// =======================================================================================
// F2_parameter.h
// Time-stamp: <2004-02-24 19:14:28 aknoblau>
// Definition of parameter types and of a parser system to read parameters from file
// programmed in May 2001 by Andreas Knoblauch
// Department of Neural Information Processing, TComponent* owner_arg
// University of Ulm, Germany
// Version 1.0 alpha
// last documented change: May 6, 2001
// =======================================================================================
// types/classes/interfaces:
// TParamOwner, TParameter, TMRange, TMNumParameter,
// TMMarrayParameter, TMNumMarrayParameter,
// TMScalarParameter, TMVectorParameter, TMMatrixParameter,
// TMParameter0D, TMParameter1D, TMParameter2D
// ---------------------------------------------------------------------------------------
// global objects:
// ---------------------------------------------------------------------------------------
// related modules:
// ---------------------------------------------------------------------------------------
// notes:
// ---------------------------------------------------------------------------------------
// history:
// Version 1.0 alpha programmed on May 6, 2001 by Andreas Knoblauch
// ---------------------------------------------------------------------------------------
// bugs:
// ---------------------------------------------------------------------------------------
// 2 do:
// =======================================================================================
#ifndef F2_parameter_H
#define F2_parameter_H
#include
#include
#include
#include "F2_types.h"
#include "F2_layout.h"
#include "F2_parser.h"
#ifdef FELIX_GUI
extern "C" {
typedef int SliderValue;
extern void SetSlider(SliderValue*,SliderValue);
}
#endif
class TParameter;
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TParamOwner
* Abstract base type for parameter owner
* A parameter owner is usually a simulation component such as a neuron population, see @ref TNeuron
*
* @short Abstract base type for parameter owner
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: May 6, 2001
*/
class TParamOwner {
// **************************************************************************************************************************
public:
// object fields
string& ownerName; // id of TParamOwner
TParamOwner* parent; // the TParamOwner used by this one as a pattern (may be NULL for roots)
vector childs; // all the TParamOwners that used this one as a pattern
vector parameters; // all the parameters of this TParamOwner
int updatedParametersFlag; // set if one of the parameters was updated (by slider or reparsing)
// constructors/destructors
TParamOwner(string& ownerName_arg); // constructor for a root TParamOwner
TParamOwner(string& ownerName_arg, TParamOwner* parent_arg); // constructor for a possibly non-root TParamOwner
~TParamOwner(); // destructor
// methods for parameter database
void setParent(TParamOwner* parent_arg); // set parent (e.g. with 0 to make a TParamOwner root)
void addParameter(TParameter* par); // insert par in parameters
void removeParameter(TParameter* par); // remove par from parameters
TParameter* getParameter(int id); // returns the parameter in parameters with a given id
// methods for updating parameters and its dependecies
void updateChildParameters(TParameter* par); // for all childs update parameter name with par
void setReparsedParameters(const vector& repPars); // update parameters with reparsed parameters
void setUpdatedParametersFlags(int newFlags); // resets updatedParametersFlag and the updatedFlags of all parameters
virtual void handleUpdatedParameters(); // handles the updated parameters (by slider or reparsing)
void setParameters(); // set all updated flags and call handleUpdatedParameters()
// input/output
void outputState(ostream & os) const; // output all fields of this object
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TParameter
* Base type for parameters of TComponents
*
* @short Base type for parameters of TComponents
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: May 6, 2001
*/
class TParameter {
// **************************************************************************************************************************
public:
// static data
#if GNU==1
static int id_static; // global counter for assigning copy id's to parameters
#endif
#if SUN==1
extern static int id_static; // global counter for assigning copy id's to parameters
#endif
// object fields
const int id; // id from id_static; id is equal for parameters constructed using copy constructors
const string name; // name of TParameter as it will be parsed
TParamOwner* owner; // TParamOwner which the parameter refers to
vector dependentParameters; // ids of parameters (of the same owner!) which should also be updated if this parameter was updated
int updatedFlag; // if set then parameter value was updated (by slider or reparsing)
int updateChildsFlag; // if set then notify updates and notifies also the childs of the owner (per default unset)
int reparseFlag; // if set then the parameter can be reparsed (per default unset)
int sliderFlag; // if set then the parameter is connected to a slider of the GUI (e.g. Felix)
int protectSliderFlag; // if set then slider value prevails reparsing (per default unset)
// constuctors/destructors
TParameter(TParamOwner* owner_arg, const char* name_arg); // constructors (assigns a new id)
TParameter(TParamOwner* owner_arg, const TParameter& copy); // copy constructor (assigns same id as copy)
TParameter(const TParameter& copy); // copy constructor (assigns same id as copy)
~TParameter(); // destructor
// static methods
static TParameter* getParameter(int id, const vector& p); // returns the parameter in p with a given id
static bool existsParameter(int id, const vector& p); // returns the parameter in p with a given id
// dependent parameters
void addDependentParameter(TParameter* par); // add id of par (should be of the same owner!) to dependentParameters
void removeDependentParameter(TParameter* par); // remove id of par from dependentParameters
// virtual access to parameter data
virtual char* getData() const; // returns pointer to parameter data as a char*
virtual void setData(size_t len, char* data_arg); // sets parameter data
virtual size_t getLen() const; // returns length of parameter data (in char units)
virtual bool sameParameterDataAs(TParameter* par) const; // compares parameter data to data of par via getData() and getLen()
// interface between parameter and corresponding slider
virtual int flushSliderValue(); // write slider value to parameter data, calls notifyOwner() (and returns 1) if changed
virtual int flushParameterData(); // write parameter data to slider value, calls notifySlider() (and returns 1) if changed
inline void notifyOwner(); // informs TParamOwner owner with parameter value (e.g. if changed)
virtual void notifySlider(); // informs slider (if sliderFlag set) that parameter value has changed
// update parameter with another parameter
void updateWith(TParameter* par); // updates parameter with parameter data of par (calls setData(),flushParameterData(),notifyOwner())
// setting of object flags
void setUpdatedFlag(); // set updatedFlag (and the updatedFlag of dependent parameters???)
void setUpdateChildsFlag(int newFlag); // set/unset updateChildsFlag
void setReparseFlag(int newFlag); // set/unset reparseFlag
void setSliderFlag(int newFlag); // set/unset sliderFlag
void setProtectSliderFlag(int newFlag); // set/unset protectSliderFlag
bool dependentOnSlider(); // returns true iff slider or if parent.dependentOnSlider()
// input/output
void outputState(ostream & os) const; // output all fields of this object
friend ostream & operator <<(ostream & os, const TParameter & par); // output operator
friend istream & operator >>(istream & is, TParameter & par); // input operator
};
#if SUN==1
#ifdef F2_PARAMETER_CPP
int TParameter::id_static=0;
#endif
#endif
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TSliderRange
* Interface to control a TMNumParameter via an integer valued Slider as in Felix
*
* @short Interface to control a TMNumParameter via an integer valued Slider as in Felix
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: November 3, 2001
*/
class TSliderRange {
// **************************************************************************************************************************
public:
int slider_val; // integer slider value for use in Felix
int slider_old; // old slider_val during last call to setSliderValue
int slider_min, slider_max; // minimal and maximal values for the slider variable;
TSliderRange(); // constructor;
~TSliderRange(); // destructor;
void setSliderRange(int min_arg, int max_arg); // set slider_min and slider_max
void outputState(ostream& os) const; // output all fields of the object
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMRange
* Class for specifying valid parameter range and the interface to (discrete valued) sliders
*
* @short Class for specifying valid parameter range and the interface to (discrete valued) sliders
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: May 6, 2001
*/
template
class TMRange : public TSliderRange {
// **************************************************************************************************************************
public:
TNum min,max; // minimal and maximal of interval allowed for data; if min>max, then irrelevant
TNum scale; // slider_min*scale = min, slider_max*scale=max, for trafo between real and slider domain
TMRange(); // constructor for all values
TMRange(TNum max_arg); // constructor for values in [0;max_arg], scale=1;
TMRange(TNum min_arg, TNum max_arg); // constructor for values in [min_arg;max_arg], scale=1;
TMRange(TNum min_arg, TNum max_arg, TNum scale_arg); // constructor for values in [min_arg;max_arg] by scale
~TMRange(); // destructor
void setRange(TNum min_arg, TNum max_arg, TNum scale_arg); // set range
void getSliderLabels(string& s, int &min1,int&max1); // deliver slider labels
void outputState(ostream & os) const; // output all fields of this object
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMNumParameter
* Base template for numerical parameters of @ref TParamOwners using a numerical type TNum
*
* @short Base template for numerical parameters of @ref TParamOwners
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: May 6, 2001
*/
template
class TMNumParameter : public TParameter, public TMRange {
// **************************************************************************************************************************
public:
TMNumParameter(TParamOwner* owner_arg, const char* name_arg); // constructor
TMNumParameter(TParamOwner* owner_arg, const char* name_arg, const TMRange& range_arg); // constructor
TMNumParameter(TParamOwner* owner_arg, const TMNumParameter& copy); // copy constructor
TMNumParameter(const TMNumParameter& copy); // copy constructor
~TMNumParameter(); // destructor
virtual int getNumPar() const; // returns parameter value in the slider-domain (normally only for singular parameters)
virtual int setNumPar(int val); // sets parameter value in the slider-domain and informs owner/returns 1 if changed
virtual void initSliderValue(); // initializes slider_val according to data (implemented by descendants)
virtual int flushSliderValue(); // informs owner/returns 1 if slider_val (TSliderRange) has changed
virtual int flushParameterData(); // write parameter data to slider value, calls notifySlider() (and returns 1) if changed
virtual void notifySlider(); // informs slider (if sliderFlag set) that parameter value has changed
void outputState(ostream & os) const; // output all fields of this object
friend ostream & operator<< (ostream & os, const TMNumParameter & par); // output operator
friend istream & operator>> (istream & is, TMNumParameter & par); // input operator
};
template
ostream & operator<<(ostream & os, const TMNumParameter & par); // output operator
template
istream & operator>>(istream & is, TMNumParameter & par); // input operator
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMMarrayParameter
* Template for multi-array parameters of TParamOwners
* template may be instantiated with any type T
* inherits @ref TMMarray
*
* @short Template for multidim-array parameters
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: April 6, 2001
*/
template
class TMMarrayParameter : public TParameter, public TMMarray {
// **************************************************************************************************************************
public:
TMMarrayParameter(TParamOwner* owner_arg, const char* name_arg); // GENERIC constructors
TMMarrayParameter(TParamOwner* owner_arg, const char* name_arg, const TCuboidLT& layout_arg); // further constructors
TMMarrayParameter(TParamOwner* owner_arg, const char* name_arg, const TCuboidLT& layout_arg, T* data_arg);
TMMarrayParameter(TParamOwner* owner_arg, const TMMarrayParameter& copy);
TMMarrayParameter(TParamOwner* owner_arg, const TMMarrayParameter& copy, T* data_arg);
TMMarrayParameter(const TMMarrayParameter& copy);
TMMarrayParameter(const TMMarrayParameter& copy, T* data_arg);
~TMMarrayParameter(); // destructor
virtual char* getData() const; // returns pointer to parameter data as a char*
virtual void setData(size_t len, char* data); // sets parameter data
virtual size_t getLen() const; // returns length of parameter data (in char units)
virtual bool sameParameterDataAs(TParameter* par) const; // compares parameter data to data of par
void outputState(ostream & os) const; // output all fields of this object
friend ostream & operator<< (ostream & os, const TMMarrayParameter & par); // output operator
friend istream & operator>> (istream & os, TMMarrayParameter & par); // input operator
};
template
ostream & operator <<(ostream & os, const TMMarrayParameter & par); // output operator
template
istream & operator >>(istream & is, TMMarrayParameter & par); // input operator
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMNumMarrayParameter
* Template for multi-array parameters of TParamOwners
* Template is instantiated with a numerical type TNum.
*
* @short Template for numerical multi-dim-array parameters
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: April 6, 2001
*/
template
class TMNumMarrayParameter : public TMNumParameter, public TMNumMarray {
// **************************************************************************************************************************
public:
TMNumMarrayParameter(TParamOwner* owner_arg, const char* name_arg); // GENERIC constructor
TMNumMarrayParameter(TParamOwner* owner_arg, const char* name_arg,const TCuboidLT& layout_arg); // further constructors
TMNumMarrayParameter(TParamOwner* owner_arg, const char* name_arg,const TCuboidLT& layout_arg,TNum* data_arg);
TMNumMarrayParameter(TParamOwner* owner_arg, const char* name_arg,const TCuboidLT& layout_arg,const TMRange& range_arg);
TMNumMarrayParameter(
TParamOwner* owner_arg,const char* name_arg,const TCuboidLT& layout_arg,const TMRange& range_arg,TNum* data_arg
);
TMNumMarrayParameter(TParamOwner* owner_arg,const TMNumMarrayParameter& copy);
TMNumMarrayParameter(TParamOwner* owner_arg,const TMNumMarrayParameter& copy,TNum* data_arg);
TMNumMarrayParameter(const TMNumMarrayParameter& copy);
TMNumMarrayParameter(const TMNumMarrayParameter& copy,TNum* data_arg);
~TMNumMarrayParameter(); // destructor
virtual char* getData() const; // returns pointer to parameter data as a char*
virtual void setData(size_t len, char* data_arg); // sets parameter data
virtual size_t getLen() const; // returns length of parameter data (in char units)
virtual int getNumPar() const; // delivers *data scaled to the slider-domain
virtual int setNumPar(int val); // sets *data corresponding to scaled val; informs owner/returns 1 if changed
virtual void initSliderValue(); // initializes slider_val according to data (implemented by descendants)
virtual int flushSliderValue(); // write slider value to parameter data, calls notifyOwner() (and returns 1) if changed
virtual int flushParameterData(); // write parameter data to slider value, calls notifySlider() (and returns 1) if changed
virtual void notifySlider(); // informs slider (if sliderFlag set) that parameter value has changed
inline int getNumPar_il() const; // inline version of getNumPar()
inline int setNumPar_il(int val); // inline version of setNumPar()
inline int flushSliderValue_il(); // inline version of setSliderValue()
inline int flushParameterData_il(); // inline version of setSliderValue()
void outputState(ostream & os) const; // output all fields of this object
friend ostream & operator<< (ostream & os, const TMNumMarrayParameter & par); // output operator
friend istream & operator>> (istream & os, TMNumMarrayParameter & par); // input operator
};
template
ostream & operator<<(ostream & os, const TMNumMarrayParameter & par); // output operator
template
istream & operator>>(istream & is, TMNumMarrayParameter & par); // input operator
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMScalarParameter
* Template for scalar numerical parameters
* Template is instantiated with a numerical type TNum.
*
* @short Template for scalar numerical parameters
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: April 6, 2001
*/
template
class TMScalarParameter : public TMNumMarrayParameter {
// **************************************************************************************************************************
public:
TMScalarParameter(const char* name_arg); // constructors
TMScalarParameter(const char* name_arg, TNum data_arg);
TMScalarParameter(const char* name_arg, TNum* data_arg);
TMScalarParameter(const char* name_arg, const TMRange& range_arg);
TMScalarParameter(const char* name_arg, const TMRange& range_arg, TNum data_arg);
TMScalarParameter(const char* name_arg, const TMRange& range_arg, TNum* data_arg);
TMScalarParameter(TParamOwner* owner_arg, const char* name_arg);
TMScalarParameter(TParamOwner* owner_arg, const char* name_arg, TNum data_arg);
TMScalarParameter(TParamOwner* owner_arg, const char* name_arg, TNum* data_arg);
TMScalarParameter(TParamOwner* owner_arg, const char* name_arg, const TMRange& range_arg);
TMScalarParameter(TParamOwner* owner_arg, const char* name_arg, const TMRange& range_arg, TNum data_arg);
TMScalarParameter(TParamOwner* owner_arg, const char* name_arg, const TMRange& range_arg, TNum* data_arg);
TMScalarParameter(TParamOwner* owner_arg, const TMScalarParameter& copy);
TMScalarParameter(TParamOwner* owner_arg, const TMScalarParameter& copy, TNum* data_arg);
TMScalarParameter(const TMScalarParameter& copy);
TMScalarParameter(const TMScalarParameter& copy, TNum* data_arg);
~TMScalarParameter(); // destructor
inline void set(TNum data_arg); // sets parameter data
inline void set(TNum* data_arg); // sets parameter data
inline void set(TNum data_arg, int notify); // sets parameter data and notifys owner if flag set
inline void set(TNum* data_arg, int notify); // sets parameter data and notifys owner if flag set
inline TNum get() const; // gets parameter data
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMVectorParameter
* Template for one-dimensional numerical parameters, i.e. a 1-dim array of parameters
* Template is instantiated with a numerical type TNum.
*
* @short Template for one-dimensional numerical parameter
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: April 6, 2001
*/
template
class TMVectorParameter : public TMNumMarrayParameter {
// **************************************************************************************************************************
public:
TMVectorParameter(const char* name_arg); // constructor with GENERIC size
TMVectorParameter(const char* name_arg, int len); // constructors with FIXED size
TMVectorParameter(const char* name_arg, int len, TNum *data_arg);
TMVectorParameter(const char* name_arg, int len, const TMRange& range_arg);
TMVectorParameter(const char* name_arg, int len, const TMRange& range_arg, TNum *data_arg);
TMVectorParameter(TParamOwner* owner_arg, const char* name_arg); // constructor with GENERIC size
TMVectorParameter(TParamOwner* owner_arg, const char* name_arg, int len); // constructors with FIXED size
TMVectorParameter(TParamOwner* owner_arg, const char* name_arg, int len, TNum *data_arg);
TMVectorParameter(TParamOwner* owner_arg, const char* name_arg, int len, const TMRange& range_arg);
TMVectorParameter(TParamOwner* owner_arg, const char* name_arg, int len, const TMRange& range_arg, TNum *data_arg);
TMVectorParameter(TParamOwner* owner_arg, const TMVectorParameter& copy); // copy constructor
TMVectorParameter(TParamOwner* owner_arg, const TMVectorParameter& copy, TNum *data_arg); // copy constructor
TMVectorParameter(const TMVectorParameter& copy); // copy constructor
TMVectorParameter(const TMVectorParameter& copy, TNum *data_arg); // copy constructor
~TMVectorParameter(); // destructor
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMMatrixParameter
* Template for two-dimensional numerical parameters
* Template is instantiated with a numerical type TNum.
*
* @short Template for two-dimensional array of numerical parameters
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: April 6, 2001
*/
template
class TMMatrixParameter : public TMNumMarrayParameter {
// **************************************************************************************************************************
public:
TMMatrixParameter(const char* name_arg); // constructor with GENERIC size
TMMatrixParameter(const char* name_arg, int M, int N); // constructors with FIXED size
TMMatrixParameter(const char* name_arg, int M, int N, TNum *data_arg);
TMMatrixParameter(const char* name_arg, int M, int N, const TMRange& range_arg);
TMMatrixParameter(const char* name_arg, int M, int N, const TMRange& range_arg, TNum *data_arg);
TMMatrixParameter(TParamOwner* owner_arg, const char* name_arg); // constructor with GENERIC size
TMMatrixParameter(TParamOwner* owner_arg, const char* name_arg, int M, int N); // constructor with FIXED size
TMMatrixParameter(TParamOwner* owner_arg, const char* name_arg, int M, int N, TNum *data_arg);
TMMatrixParameter(TParamOwner* owner_arg, const char* name_arg, int M, int N, const TMRange& range_arg);
TMMatrixParameter(TParamOwner* owner_arg, const char* name_arg, int M, int N, const TMRange& range_arg, TNum *data_arg);
TMMatrixParameter(TParamOwner* owner_arg, const TMMatrixParameter& copy); // copy constructor
TMMatrixParameter(TParamOwner* owner_arg, const TMMatrixParameter& copy, TNum *data_arg); // copy constructor
TMMatrixParameter(const TMMatrixParameter& copy); // copy constructor
TMMatrixParameter(const TMMatrixParameter& copy, TNum *data_arg); // copy constructor
~TMMatrixParameter(); // destructor
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMCubeParameter
* Template for 3d numerical parameters
* Template is instantiated with a numerical type TNum.
*
* @short Template for 3d array of numerical parameters
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: August 23, 2002
*/
template
class TMCubeParameter : public TMNumMarrayParameter {
// **************************************************************************************************************************
public:
TMCubeParameter(const char* name_arg); // constructor with GENERIC size
TMCubeParameter(const char* name_arg, int X, int Y, int Z); // constructors with FIXED size
TMCubeParameter(const char* name_arg, int X, int Y, int Z, TNum *data_arg);
TMCubeParameter(const char* name_arg, int X, int Y, int Z, const TMRange& range_arg);
TMCubeParameter(const char* name_arg, int X, int Y, int Z, const TMRange& range_arg, TNum *data_arg);
TMCubeParameter(TParamOwner* owner_arg, const char* name_arg); // constructor with GENERIC size
TMCubeParameter(TParamOwner* owner_arg, const char* name_arg, int X, int Y, int Z); // constructor with FIXED size
TMCubeParameter(TParamOwner* owner_arg, const char* name_arg, int X, int Y, int Z, TNum *data_arg);
TMCubeParameter(TParamOwner* owner_arg, const char* name_arg, int X, int Y, int Z, const TMRange& range_arg);
TMCubeParameter(TParamOwner* owner_arg, const char* name_arg, int X, int Y, int Z, const TMRange& range_arg, TNum *data_arg);
TMCubeParameter(TParamOwner* owner_arg, const TMCubeParameter& copy); // copy constructor
TMCubeParameter(TParamOwner* owner_arg, const TMCubeParameter& copy, TNum *data_arg); // copy constructor
TMCubeParameter(const TMCubeParameter& copy); // copy constructor
TMCubeParameter(const TMCubeParameter& copy, TNum *data_arg); // copy constructor
~TMCubeParameter(); // destructor
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMParameter0D
* Template for singular parameters
* Template may be instantiated with any type T.
*
* @short Template for a single (0-dim.) parameter
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: April 6, 2001
*/
template
class TMParameter0D : public TMMarrayParameter {
// **************************************************************************************************************************
public:
TMParameter0D(const char* name_arg); // constructors
TMParameter0D(const char* name_arg, T* data_arg);
TMParameter0D(const char* name_arg, T data_arg);
TMParameter0D(TParamOwner* owner_arg, const char* name_arg);
TMParameter0D(TParamOwner* owner_arg, const char* name_arg, T* data_arg);
TMParameter0D(TParamOwner* owner_arg, const char* name_arg, T data_arg);
TMParameter0D(TParamOwner* owner_arg, const TMParameter0D& copy);
TMParameter0D(TParamOwner* owner_arg, const TMParameter0D& copy, T* data_arg);
TMParameter0D(const TMParameter0D& copy);
TMParameter0D(const TMParameter0D& copy, T* data_arg);
~TMParameter0D(); // destructor
inline void set(T& data_arg); // sets parameter data
inline void set(T* data_arg); // sets parameter data
inline void set(T& data_arg, int notify); // sets parameter data and notifys owner if flag set
inline void set(T* data_arg, int notify); // sets parameter data and notifys owner if flag set
inline T& get() const; // gets parameter data
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMParameter1D
* Template for one-dimensional parameters
* Template is instantiated with a numerical type T.
*
* @short Template for one-dimensional parameters
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: April 6, 2001
*/
template
class TMParameter1D : public TMMarrayParameter {
// **************************************************************************************************************************
public:
TMParameter1D(const char* name_arg); // constructor with GENERIC size
TMParameter1D(const char* name_arg, int len); // constructors with FIXED size
TMParameter1D(const char* name_arg, int len, T *data_arg);
TMParameter1D(TParamOwner* owner_arg, const char* name_arg); // constructor with GENERIC size
TMParameter1D(TParamOwner* owner_arg, const char* name_arg, int len); // constructors with FIXED size
TMParameter1D(TParamOwner* owner_arg, const char* name_arg, int len, T *data_arg);
TMParameter1D(TParamOwner* owner_arg, const TMParameter1D& copy); // copy constructor
TMParameter1D(TParamOwner* owner_arg, const TMParameter1D& copy, T *data_arg); // copy constructor
TMParameter1D(const TMParameter1D& copy); // copy constructor
TMParameter1D(const TMParameter1D& copy, T *data_arg); // copy constructor
~TMParameter1D(); // destructor
};
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMParameter2D
* Template for two-dimensional parameters
* Template can be instantiated with any type T.
*
* @short Template for two-dimensional numerical parameters
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: April 6, 2001
*/
template
class TMParameter2D : public TMMarrayParameter {
// **************************************************************************************************************************
public:
TMParameter2D(const char* name_arg); // constructor with GENERIC size
TMParameter2D(const char* name_arg, int M, int N); // constructors with FIXED size
TMParameter2D(const char* name_arg, int M, int N, T *data_arg);
TMParameter2D(TParamOwner* owner_arg, const char* name_arg); // constructor with GENERIC size
TMParameter2D(TParamOwner* owner_arg, const char* name_arg, int M, int N); // constructors with FIXED size
TMParameter2D(TParamOwner* owner_arg, const char* name_arg, int M, int N, T *data_arg);
TMParameter2D(TParamOwner* owner_arg, const TMParameter2D& copy); // copy constructor
TMParameter2D(TParamOwner* owner_arg, const TMParameter2D& copy, T *data_arg); // copy constructor
TMParameter2D(const TMParameter2D& copy); // copy constructor
TMParameter2D(const TMParameter2D& copy, T *data_arg); // copy constructor
~TMParameter2D(); // destructor
};
typedef TMScalarParameter TPar; // standard parameter types
typedef TMVectorParameter TVecPar;
typedef TMMatrixParameter TMatPar;
typedef TMCubeParameter TCubPar;
typedef TMScalarParameter TiPar;
typedef TMVectorParameter TiVecPar;
typedef TMMatrixParameter TiMatPar;
typedef TMCubeParameter TiCubPar;
typedef TMParameter0D TsPar;
typedef TMParameter1D TsVecPar;
typedef TMParameter2D TsMatPar;
#endif /* F2_parameter_H */
| Generated by: aknoblau on synfire on Sat May 1 14:32:16 2004, using kdoc 2.0a54. |