|
|
The basic element. Map can be anything (by inheriting it), but it's nearly nothing by default.
A Map object just has a pointer to another Map object, and when you make it do anything, it passes the command to the next Map object.
QString |
[ protected: ]
bool |
[ protected: ]
QStringList |
[ protected: ]
Splits a string in several strings, separated by sep. The difference with QStringList::split, is that this method takes care of (basic) syntaxis, not to break things like : f(x,y,g(a,b)) in (x , y , g(a , b)) instead of (x, y, g(a,b) )
QString |
[ protected: ]
QString |
[ protected: ]
unsigned int |
[ protected: ]
QStringList * |
[ protected: ]
class Parameter ** |
[ protected: ]
Map * |
[ protected: ]
static QDict |
int |
[ protected: const]
Check each parameter to see if they have correct data types. Returns true if everything is ok, false if it's not.
|
[ protected: ]
|
|
|
[virtual]
void |
inline void |
inline int |
[const]
void |
[virtual]
Map * |
[const virtual]
void |
[virtual]
void |
[virtual]
void |
[virtual]
void |
Parses the parameters and call setParameterExpression automatically The parameter should be in the form "14,x+2" for a call in the form f(14,x+2)
QDict <Map> * |
Evaluates the parameters and stores them in a new QDict object. For example, if the function is f(x,z) and is used as this : 2*f(3*x,y+1), and vars contains { x=5, y=6 }, then the QDict object this function returns contains { x=15, y=6, z=7 }.
Note that you must delete the pointer that this function returns after using it !
Map * |
[virtual]
Map * |
[virtual]
Derivates (symbolically) the current map with respect to the variable var.
Map * |
[static]
Searches in the pool of maps for one with name "name", constructs a new map object of the same type and returns it
Map * |
[static]
Parses a string and creates a map object.
void |
[const]
void |
[const]
QString |
[const virtual]
QString |
[const virtual]
QString |
[static]
QString |
[const virtual]
QString |
[static]
inline QString |
[const]
QString |
[const]
bool |
[const]
bool |
[const virtual]
Returns true if this map doesn't depend on any variable. The difference with isA("Constant") is that this also check (when implemented) for constant matrices.
inline bool |
[const virtual]
bool |
[static]
Map * |
[virtual]
Returns a simplified form of this Map if possible. If there's no simplified form, it returns 0L .
void |
Simplifies the tree calling simplify and substituting it with the simplified form. Note that it's "not desirable" to call this method on non-Map classes.
Map * |
[static]
Binary operations for maps. The nice thing about these methods is that they are quite optimized to do always the best thing with the pointers. For example, when you sum two temporary maps (and tell Map::add to "manage" them), they're not copied, but used directly.
With managem1 and managem2, you specify that you aren't going to need that pointer anymore, so instead of deleting it yourself in the next line, you tell Map::add to do whatever it wants with it, so if it isn't going to be used, it will be deleted. If you use true as value for managem1 or managem2, be sure to not reference that variable anymore, as it may be deleted ! (in this case, it will be set to 0L).
Map * |
[static]
Map * |
[static]
Map * |
[static]
Map * |
[static]
Map * |
[static]
These functions are provided for convience and should be used with extreme care
Map * |
[static]
Map * |
[static]
Map * |
[static]
Map * |
[static]
unsigned int |
[const]
Returns the number of arguments
Map * |
[const]
Returns the map used as i-th argument.
inline Parameter * |
[const]
Returns the parameter at the i-th position.
inline T * |
[const virtual]
Returns a T object if this is a Constant Map. else, it returns 0L It's not neccesary to check if this->isA("Constant") since it's a virtual method.
inline TMatrix * |
[const virtual]
Returns a TMatrix object if this is a Matrix Map. else, it returns 0L It's not neccesary to check if this->isA("Matrix") since it's a virtual method.