libqalculate-ruby 0.0.1

data/ext/libqalculate/MathStructure.h

@@ -0,0 +1,827 @@
+/*
+    Qalculate    
+
+    Copyright (C) 2004-2007  Niklas Knutsson (nq@altern.org)
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+*/
+
+#ifndef MATH_STRUCTURE_H
+#define MATH_STRUCTURE_H
+
+#include <libqalculate/includes.h>
+#include <libqalculate/Number.h>
+
+/** @file */
+
+/// Types for MathStructure
+typedef enum {
+	STRUCT_MULTIPLICATION,
+	STRUCT_INVERSE,
+	STRUCT_DIVISION,
+	STRUCT_ADDITION,
+	STRUCT_NEGATE,
+	STRUCT_POWER,
+	STRUCT_NUMBER,
+	STRUCT_UNIT,
+	STRUCT_SYMBOLIC,
+	STRUCT_FUNCTION,
+	STRUCT_VARIABLE,
+	STRUCT_VECTOR,
+	STRUCT_BITWISE_AND,
+	STRUCT_BITWISE_OR,
+	STRUCT_BITWISE_XOR,
+	STRUCT_BITWISE_NOT,
+	STRUCT_LOGICAL_AND,
+	STRUCT_LOGICAL_OR,
+	STRUCT_LOGICAL_XOR,
+	STRUCT_LOGICAL_NOT,
+	STRUCT_COMPARISON,
+	STRUCT_UNDEFINED
+} StructureType;
+
+enum {
+	MULTIPLICATION_SIGN_NONE,
+	MULTIPLICATION_SIGN_SPACE,
+	MULTIPLICATION_SIGN_OPERATOR,
+	MULTIPLICATION_SIGN_OPERATOR_SHORT
+};
+
+/// A structure representing a mathematical value/expression/result
+/**
+* A MathStructure can both be container representing an operation with an ordered list of children or simple value representing
+* a number, , variable etc. The children of a container might be of any type, allowing a tree-like nested structure.
+*
+* These are the most common conatiner/operation types:
+*	- \b Addition: contains two or more children, representing terms (x+y+...)
+*	- \b Multiplication: contains two or more children, representing factors (x*y*...)
+*	- \b Power: contains exactly two children, representing base and exponent (x^y)
+*	- \b Function: contains a two or more children, representing arguments, and a reference to a MathFunction object ( f(x,y,...) )
+*	- \b Comparison: an equality or inequality containing exactly two children, represening the expressions right and left of the sign, specified with a ComparisonType (x=y, x!=y, x&gt;y, ...)
+*	- \b Vector: contains zero or more children, representing elements in a vector ( [x, y, z, ...] )
+*
+* Also available are containers representing logical and bitwise operations.
+* Subtraction is represented by an addition structure with negated children and division by a multiplication structure with inverted children.
+* Matrices is represented by a vector with vectors as children.
+*
+* For formatted structures, the following types is also available:
+*	- \b Negation: contains exactly one child (-x)
+*	- \b Invertion: contains exactly one child (1/x)
+*	- \b Division: contains exactly two children representing numerator and denominator (x/y)
+*
+* The following value types are available:
+*	- \b Number: has a Number object, representing a rational, floating point, complex or infinite numeric value
+*	- \b Variable: has a reference to a Variable object, with a known or unknown value
+*	- \b Symbolic: has an associated text string, with assumptions about the represented value controlled by the default assumptions
+*	- \b Unit: has a reference to a Unit object, and might in a formatted structure also have a reference to a Prefix object
+*	- \b Undefined: represents an undefined value
+*
+* To create a MathStructure, you can either create a simple structure using the constructors and then expanding it with structural operations,
+* or use the parse or calculation functions of the global Calculator object to convert an expression string.
+*
+* The expression "(5x + 2) * 3" can be turned into a MathStructure either using
+* \code
+* MathStructure mstruct = CALCULATOR->parse("(5x + 2) * 3");
+* \endcode
+* or
+* \code
+* MathStructure mstruct(5);
+* mstruct *= CALCULATOR->v_x;
+* mstruct += 2;
+* mstruct *= 3:
+* \endcode
+* The first variant is obviously simpler, but slower and allows less control.
+*
+* Then, to evaluate/calculate/simplify (whatever) a structure, eval() should normally be used. The EvaluationOptions passed to eval() allows much control over the process
+* and the outcome.
+* \code
+* EvaluationOptions eo;
+* mstruct.eval(eo);
+* \endcode
+*
+* After that, to display the result, you should first format the structure using format() and then display it using print(), passing the PrintOptions to both.
+* \code
+* PrintOptions po;
+* mstruct.format(po);
+* std::cout << mstruct.print(po) << std::endl;
+* \endcode
+*
+* Most low-level functions expect the structure to be unformatted och require that unformat() is called after an expression string has been parsed or format() has been called.
+*
+* To access a child structure either the [] operator or the safer getChild() can be used.
+* Note however that the index passed to the operator start at zero and the index argument for getChild() starts at one.
+* \code
+* MathStructure mstruct(5);
+* mstruct += 2;
+* std::cout << mstruct.print() << std::endl; // output: "5 + 2"
+* std::cout << mstruct.getChild(1)->print() << std::endl; // output: "5"
+* std::cout << mstruct[1].print() << std::endl; // output: "2"
+* \endcode
+*
+* MathStructure uses reference count for management of objects allocated with new.
+* Call ref() when starting to use the object and unref() when done.
+* Note that the reference count is initialized to 1 in the constructors, so ref() should not be called after the object creation.
+* This system is used for all child objects, so the following is perfectly legal:
+* \code
+* MathStructure *mchild_p = mstruct->getChild(1);
+* mchild_p->ref(); // mchild_p reference count = 2
+* mstruct->unref(); //mstruct reference count = 0, mstruct deleted, mchild_p reference count = 1
+* (...)
+* mchild_p->unref(); // mchild_p reference count = 0, mchild_p deleted
+* \endcode
+*/
+
+class MathStructure {
+
+	protected:
+	
+		size_t i_ref;
+	
+		StructureType m_type;
+		bool b_approx;
+		int i_precision;
+	
+		vector<MathStructure*> v_subs;
+		vector<size_t> v_order;
+		string s_sym;
+		Number o_number;
+		Variable *o_variable;
+
+		Unit *o_unit;
+		Prefix *o_prefix;
+		bool b_plural;
+		
+		MathFunction *o_function;
+		MathStructure *function_value;
+		
+		ComparisonType ct_comp;
+		bool b_protected;
+		
+		bool isolate_x_sub(const EvaluationOptions &eo, EvaluationOptions &eo2, const MathStructure &x_var, MathStructure *morig = NULL);
+		void init();
+	
+	public:
+
+		/** @name Constructors */
+		//@{
+		/** Create a new structure, initialized to zero. */
+		MathStructure();
+		/** Create a copy of a structure. Child structures are copied.
+		*
+		* @param o The structure to copy.
+		*/
+//		MathStructure(const MathStructure &o);
+		/** Create a new numeric structure (value=num/den*10^exp10). Equivalent to MathStructure(Number(num, den, exp10)). 
+		*
+		* @param num The numerator of the numeric value.
+		* @param den The denominator of the numeric value.
+		* @param exp10 The base 10 exponent of the numeric value.
+		*/
+		MathStructure(int num, int den = 1, int exp10 = 0);
+		/** Create a new symbolic/text structure.
+		*
+		* @param sym Symbolic/text value.
+		*/
+		MathStructure(string sym);
+		/** Create a new numeric structure with floating point value. Uses Number::setFloat().
+		*
+		* @param o Numeric value.
+		*/
+		MathStructure(double float_value);
+		/** Create a new vector.
+		*
+		* @param o The first element (copied) in the vector.
+		* @param ... Elements (copied) in the vector. End with NULL.
+		*/
+		MathStructure(const MathStructure *o, ...);
+		/** Create a new function structure.
+		*
+		* @param o Function value.
+		* @param ... Arguments (copied) to the function. End with NULL.
+		*/
+		MathStructure(MathFunction *o, ...);
+		/** Create a new unit structure.
+		*
+		* @param u The unit value.
+		* @param p Prefix of the unit.
+		*/
+		MathStructure(Unit *u, Prefix *p = NULL);
+		/** Create a new variable structure.
+		*
+		* @param o Variable value.
+		*/
+		MathStructure(Variable *o);
+		/** Create a new numeric structure.
+		*
+		* @param o Numeric value.
+		*/
+		MathStructure(const Number &o);
+		~MathStructure();
+		//@}
+		
+		/** @name Functions/operators for setting type and content */
+		//@{
+		/** Set the structure to a copy of another structure. Child structures are copied.
+		*
+		* @param o The structure to copy.
+		* @param merge_precision Preserve the current precision (unless the new value has a lower precision).
+		*/
+		void set(const MathStructure &o, bool merge_precision = false);
+		/** Set the structure to a copy of another structure. Pointers to child structures are copied.
+		*
+		* @param o The structure to copy.
+		* @param merge_precision Preserve the current precision (unless the new value has a lower precision).
+		*/
+		void set_nocopy(MathStructure &o, bool merge_precision = false);
+		/** Set the structure to a number (num/den*10^exp10). Equivalent to set(Number(num, den, exp10), precerve_precision). 
+		*
+		* @param num The numerator of the new numeric value.
+		* @param den The denominator of the new numeric value.
+		* @param exp10 The base 10 exponent of the new numeric value.
+		* @param preserve_precision Preserve the current precision (unless the new value has a lower precision).
+		*/
+		void set(int num, int den = 1, int exp10 = 0, bool preserve_precision = false);
+		/** Set the structure to a symbolic/text value.
+		*
+		* @param o The new symolic/text value.
+		* @param preserve_precision Preserve the current precision.
+		*/
+		void set(string sym, bool preserve_precision = false);
+		/** Set the structure to a number with a floating point value. Uses Number::setFloat().
+		*
+		* @param o The new numeric value.
+		* @param preserve_precision Preserve the current precision (unless the new value has a lower precision).
+		*/
+		void set(double float_value, bool preserve_precision = false);
+		/** Set the structure to a vector.
+		*
+		* @param o The first element (copied) in the new vector.
+		* @param ... Elements (copied) in the new vector. End with NULL.
+		*/
+		void setVector(const MathStructure *o, ...);
+		/** Set the structure to a mathematical function.
+		*
+		* @param o The new function value.
+		* @param ... Arguments (copied) to the function. End with NULL.
+		*/
+//		void set(MathFunction *o, ...);
+		/** Set the structure to a unit.
+		*
+		* @param u The new unit value.
+		* @param p Prefix of the unit.
+		* @param preserve_precision Preserve the current precision (unless the new value has a lower precision).
+		*/
+		void set(Unit *u, Prefix *p = NULL, bool preserve_precision = false);
+		/** Set the structure to a variable.
+		*
+		* @param o The new variable value.
+		* @param preserve_precision Preserve the current precision.
+		*/
+		void set(Variable *o, bool preserve_precision = false);
+		/** Set the structure to a number.
+		*
+		* @param o The new numeric value.
+		* @param preserve_precision Preserve the current precision (unless the new value has a lower precision).
+		*/
+		void set(const Number &o, bool preserve_precision = false);
+		void setInfinity(bool preserve_precision = false);
+		/** Set the value of the structure to undefined.
+		*
+		* @param preserve_precision Preserve the current precision.
+		*/
+		void setUndefined(bool preserve_precision = false);
+		/** Reset the value (to zero) and parameters of the structure.
+		*
+		* @param preserve_precision Preserve the current precision.
+		*/
+		void clear(bool preserve_precision = false);
+		/** Set the structure to an empty vector.
+		*
+		* @param preserve_precision Preserve the current precision.
+		*/
+		void clearVector(bool preserve_precision = false);
+		/** Set the structure to an empty matrix.
+		*
+		* @param preserve_precision Preserve the current precision.
+		*/
+		void clearMatrix(bool preserve_precision = false);
+
+		/** Explicitely sets the type of the structure.
+		* setType() is dangerous and might crash the program if used unwisely.
+		*
+		* @param mtype The new structure type
+		*/
+		void setType(StructureType mtype);
+
+		void operator = (const MathStructure &o);
+		void operator = (const Number &o);
+		void operator = (int i);
+		void operator = (Unit *u);
+		void operator = (Variable *v);
+		void operator = (string sym);
+		//@}
+
+		/** @name Functions to keep track of referrers */
+		//@{
+		void ref();
+		void unref();
+		size_t refcount() const;
+		//@}
+
+		/** @name Functions for numbers */
+		//@{
+		const Number &number() const;
+		Number &number();
+		void numberUpdated();
+		//@}
+
+		/** @name Functions for symbols */
+		//@{
+		const string &symbol() const;
+		//@}
+
+		/** @name Functions for units */
+		//@{
+		Unit *unit() const;
+		Prefix *prefix() const;
+		void setPrefix(Prefix *p);
+		bool isPlural() const;
+		void setPlural(bool is_plural);
+		void setUnit(Unit *u);
+		//@}
+		
+		/** @name Functions for mathematical functions */
+		//@{
+		void setFunction(MathFunction *f);
+		MathFunction *function() const;
+		const MathStructure *functionValue() const;
+		//@}
+
+		/** @name Functions for variables */
+		//@{
+		void setVariable(Variable *v);
+		Variable *variable() const;
+		//@}
+
+		/** @name Functions for nested structures (power, muliplication, addition, vector, etc) */
+		//@{
+		/** Call this function when you have updated a child. Updates the precision.
+		*
+		* @param index Index (starting at 1) of the updated child.
+		* @recursive If true, do the same for each child of the child.
+		*/
+		void childUpdated(size_t index, bool recursive = false);
+		/** Call this function when you have updated children. Updates the precision.
+		*
+		* @recursive If true, do the same for each child of the children.
+		*/
+		void childrenUpdated(bool recursive = false);
+		/** Returns a child. Does not check if a child exists at the index.
+		*
+		* @param index Index (starting at zero).
+		*/
+		MathStructure &operator [] (size_t index);
+		/** Returns a child. Does not check if a child exists at the index.
+		*
+		* @param index Index (starting at zero).
+		*/
+		const MathStructure &operator [] (size_t index) const;
+		void setToChild(size_t index, bool merge_precision = false, MathStructure *mparent = NULL, size_t index_this = 1);
+		void swapChildren(size_t index1, size_t index2);
+		void childToFront(size_t index);
+		void addChild(const MathStructure &o);
+		void addChild_nocopy(MathStructure *o);
+		void delChild(size_t index);
+		void insertChild(const MathStructure &o, size_t index);
+		void insertChild_nocopy(MathStructure *o, size_t index);
+		void setChild(const MathStructure &o, size_t index = 1);
+		void setChild_nocopy(MathStructure *o, size_t index = 1);
+		const MathStructure *getChild(size_t index) const;
+		MathStructure *getChild(size_t index);
+		size_t countChildren() const;
+		size_t countTotalChildren(bool count_function_as_one = true) const;
+		size_t size() const;
+		//@}
+
+		/** @name Functions for power */
+		//@{
+		const MathStructure *base() const;
+		const MathStructure *exponent() const;
+		MathStructure *base();
+		MathStructure *exponent();
+		//@}
+
+		/** @name Functions for comparisons */
+		//@{
+		ComparisonType comparisonType() const;
+		void setComparisonType(ComparisonType comparison_type);
+		//@}		
+		
+		/** @name Functions checking type and value */
+		//@{
+		StructureType type() const;
+
+		bool isAddition() const;
+		bool isMultiplication() const;
+		bool isPower() const;
+		bool isSymbolic() const;
+		bool isEmptySymbol() const;
+		bool isVector() const;
+		bool isMatrix() const;
+		bool isFunction() const;
+		bool isUnit() const;
+		bool isUnit_exp() const;
+		bool isNumber_exp() const;
+		bool isVariable() const;
+		bool isComparison() const;
+		bool isBitwiseAnd() const;
+		bool isBitwiseOr() const;
+		bool isBitwiseXor() const;
+		bool isBitwiseNot() const;
+		bool isLogicalAnd() const;
+		bool isLogicalOr() const;
+		bool isLogicalXor() const;
+		bool isLogicalNot() const;
+		bool isInverse() const;
+		bool isDivision() const;
+		bool isNegate() const;
+		bool isInfinity() const;
+		bool isUndefined() const;
+		bool isInteger() const;
+		bool isNumber() const;
+		bool isZero() const;
+		bool isOne() const;
+		bool isMinusOne() const;
+		
+		bool hasNegativeSign() const;
+		
+		bool representsBoolean() const;
+		bool representsPositive(bool allow_units = false) const;
+		bool representsNegative(bool allow_units = false) const;
+		bool representsNonNegative(bool allow_units = false) const;
+		bool representsNonPositive(bool allow_units = false) const;
+		bool representsInteger(bool allow_units = false) const;
+		bool representsNumber(bool allow_units = false) const;
+		bool representsRational(bool allow_units = false) const;
+		bool representsReal(bool allow_units = false) const;
+		bool representsComplex(bool allow_units = false) const;
+		bool representsNonZero(bool allow_units = false) const;
+		bool representsZero(bool allow_units = false) const;
+		bool representsEven(bool allow_units = false) const;
+		bool representsOdd(bool allow_units = false) const;
+		bool representsUndefined(bool include_childs = false, bool include_infinite = false, bool be_strict = false) const;
+		bool representsNonMatrix() const;
+		//@}
+	
+		/** @name Functions for precision */
+		//@{
+		void setApproximate(bool is_approx = true);	
+		bool isApproximate() const;		
+		void setPrecision(int prec);
+		int precision() const;
+		void mergePrecision(const MathStructure &o);
+		//@}
+
+		/** @name Operators for structural transformations and additions 
+		* These operators transforms or adds to the structure without doing any calculations
+		*/
+		//@{
+
+		MathStructure operator - () const;
+		MathStructure operator * (const MathStructure &o) const;
+		MathStructure operator / (const MathStructure &o) const;
+		MathStructure operator + (const MathStructure &o) const;
+		MathStructure operator - (const MathStructure &o) const;
+		MathStructure operator ^ (const MathStructure &o) const;
+		MathStructure operator && (const MathStructure &o) const;
+		MathStructure operator || (const MathStructure &o) const;
+		MathStructure operator ! () const;
+		
+		void operator *= (const MathStructure &o);
+		void operator /= (const MathStructure &o);
+		void operator += (const MathStructure &o);
+		void operator -= (const MathStructure &o);
+		void operator ^= (const MathStructure &o);
+		
+		void operator *= (const Number &o);
+		void operator /= (const Number &o);
+		void operator += (const Number &o);
+		void operator -= (const Number &o);
+		void operator ^= (const Number &o);
+		
+		void operator *= (int i);
+		void operator /= (int i);
+		void operator += (int i);
+		void operator -= (int i);
+		void operator ^= (int i);
+		
+		void operator *= (Unit *u);
+		void operator /= (Unit *u);
+		void operator += (Unit *u);
+		void operator -= (Unit *u);
+		void operator ^= (Unit *u);
+		
+		void operator *= (Variable *v);
+		void operator /= (Variable *v);
+		void operator += (Variable *v);
+		void operator -= (Variable *v);
+		void operator ^= (Variable *v);
+		
+		void operator *= (string sym);
+		void operator /= (string sym);
+		void operator += (string sym);
+		void operator -= (string sym);
+		void operator ^= (string sym);
+
+		//@}
+
+		/** @name Functions for structural transformations and additions 
+		* These functions transforms or adds to the structure without doing any calculations
+		*/
+		//@{
+		void add(const MathStructure &o, MathOperation op, bool append = false);
+		void add(const MathStructure &o, bool append = false);
+		void subtract(const MathStructure &o, bool append = false);
+		void multiply(const MathStructure &o, bool append = false);
+		void divide(const MathStructure &o, bool append = false);
+		void raise(const MathStructure &o);
+		void add(const Number &o, bool append = false);
+		void subtract(const Number &o, bool append = false);
+		void multiply(const Number &o, bool append = false);
+		void divide(const Number &o, bool append = false);
+		void raise(const Number &o);
+		void add(int i, bool append = false);
+		void subtract(int i, bool append = false);
+		void multiply(int i, bool append = false);
+		void divide(int i, bool append = false);
+		void raise(int i);
+		void add(Variable *v, bool append = false);
+		void subtract(Variable *v, bool append = false);
+		void multiply(Variable *v, bool append = false);
+		void divide(Variable *v, bool append = false);
+		void raise(Variable *v);
+		void add(Unit *u, bool append = false);
+		void subtract(Unit *u, bool append = false);
+		void multiply(Unit *u, bool append = false);
+		void divide(Unit *u, bool append = false);
+		void raise(Unit *u);
+		void add(string sym, bool append = false);
+		void subtract(string sym, bool append = false);
+		void multiply(string sym, bool append = false);
+		void divide(string sym, bool append = false);
+		void raise(string sym);
+		void add_nocopy(MathStructure *o, MathOperation op, bool append = false);
+		void add_nocopy(MathStructure *o, bool append = false);
+		void subtract_nocopy(MathStructure *o, bool append = false);
+		void multiply_nocopy(MathStructure *o, bool append = false);
+		void divide_nocopy(MathStructure *o, bool append = false);
+		void raise_nocopy(MathStructure *o);		
+		void inverse();
+		void negate();
+		void setLogicalNot();
+		void setBitwiseNot();
+
+		void transform(StructureType mtype, const MathStructure &o);
+		void transform(StructureType mtype, const Number &o);
+		void transform(StructureType mtype, int i);
+		void transform(StructureType mtype, Unit *u);
+		void transform(StructureType mtype, Variable *v);
+		void transform(StructureType mtype, string sym);
+		void transform_nocopy(StructureType mtype, MathStructure *o);
+		void transform(StructureType mtype);
+		//@}
+		
+		/** @name Functions/operators for comparisons */
+		//@{
+
+		bool equals(const MathStructure &o) const;
+		bool equals(const Number &o) const;
+		bool equals(int i) const;
+		bool equals(Unit *u) const;
+		bool equals(Variable *v) const;
+		bool equals(string sym) const;
+		
+		ComparisonResult compare(const MathStructure &o) const;
+		ComparisonResult compareApproximately(const MathStructure &o) const;
+
+		bool operator == (const MathStructure &o) const;
+		bool operator == (const Number &o) const;
+		bool operator == (int i) const;
+		bool operator == (Unit *u) const;
+		bool operator == (Variable *v) const;
+		bool operator == (string sym) const;
+		
+		bool operator != (const MathStructure &o) const;
+
+		//@}
+		
+		/** @name Functions for calculation/evaluation */
+		//@{
+		MathStructure &eval(const EvaluationOptions &eo = default_evaluation_options);
+		bool calculateMergeIndex(size_t index, const EvaluationOptions &eo, const EvaluationOptions &feo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalOrLast(const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalOrIndex(size_t index, const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalOr(const MathStructure &mor, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalXorLast(const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalXor(const MathStructure &mxor, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalAndLast(const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalAndIndex(size_t index, const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalAnd(const MathStructure &mand, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateLogicalNot(const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseNot(const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateInverse(const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateNegate(const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateRaiseExponent(const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateRaise(const MathStructure &mexp, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseOrLast(const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseOrIndex(size_t index, const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseOr(const MathStructure &mor, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseXorLast(const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseXorIndex(size_t index, const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseXor(const MathStructure &mxor, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseAndLast(const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseAndIndex(size_t index, const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateBitwiseAnd(const MathStructure &mand, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateMultiplyLast(const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateMultiplyIndex(size_t index, const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateMultiply(const MathStructure &mmul, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateDivide(const MathStructure &mdiv, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateAddLast(const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateAddIndex(size_t index, const EvaluationOptions &eo, bool check_size = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateAdd(const MathStructure &madd, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateSubtract(const MathStructure &msub, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1);
+		bool calculateFunctions(const EvaluationOptions &eo, bool recursive = true);
+		int merge_addition(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false);
+		int merge_multiplication(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false, bool do_append = true);
+		int merge_power(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false);
+		int merge_logical_and(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false);
+		int merge_logical_or(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false);
+		int merge_logical_xor(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false);
+		int merge_bitwise_and(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false);
+		int merge_bitwise_or(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false);
+		int merge_bitwise_xor(MathStructure &mstruct, const EvaluationOptions &eo, MathStructure *mparent = NULL, size_t index_this = 1, size_t index_that = 2, bool reversed = false);
+		bool calculatesub(const EvaluationOptions &eo, const EvaluationOptions &feo, bool recursive = true, MathStructure *mparent = NULL, size_t index_this = 1);
+		void evalSort(bool recursive = false);
+		bool integerFactorize();
+		//@}
+
+		/** @name Functions for protection from changes when evaluating */
+		//@{
+		void setProtected(bool do_protect = true);
+		bool isProtected() const;
+		//@}
+		
+		/** @name Functions for format and display */
+		//@{
+		void sort(const PrintOptions &po = default_print_options, bool recursive = true);
+		bool improve_division_multipliers(const PrintOptions &po = default_print_options);
+		void setPrefixes(const PrintOptions &po = default_print_options, MathStructure *parent = NULL, size_t pindex = 0);
+		void prefixCurrencies();
+		void format(const PrintOptions &po = default_print_options);
+		void formatsub(const PrintOptions &po = default_print_options, MathStructure *parent = NULL, size_t pindex = 0, bool recursive = true);
+		void postFormatUnits(const PrintOptions &po = default_print_options, MathStructure *parent = NULL, size_t pindex = 0);
+		bool factorizeUnits();
+		void unformat(const EvaluationOptions &eo = default_evaluation_options);
+		bool needsParenthesis(const PrintOptions &po, const InternalPrintStruct &ips, const MathStructure &parent, size_t index, bool flat_division = true, bool flat_power = true) const;
+
+		int neededMultiplicationSign(const PrintOptions &po, const InternalPrintStruct &ips, const MathStructure &parent, size_t index, bool par, bool par_prev, bool flat_division = true, bool flat_power = true) const;
+		
+		string print(const PrintOptions &po = default_print_options, const InternalPrintStruct &ips = top_ips) const;
+		//@}
+		
+
+		/** @name Functions for vectors */
+		//@{
+
+		MathStructure &flattenVector(MathStructure &mstruct) const;
+		
+		bool rankVector(bool ascending = true);
+		bool sortVector(bool ascending = true);
+		
+		MathStructure &getRange(int start, int end, MathStructure &mstruct) const;
+		
+		void resizeVector(size_t i, const MathStructure &mfill);
+
+		//@}
+		
+
+		/** @name Functions for matrices */
+		//@{
+
+		size_t rows() const;
+		size_t columns() const;
+		const MathStructure *getElement(size_t row, size_t column) const;
+		MathStructure *getElement(size_t row, size_t column);
+		MathStructure &getArea(size_t r1, size_t c1, size_t r2, size_t c2, MathStructure &mstruct) const;
+		MathStructure &rowToVector(size_t r, MathStructure &mstruct) const;
+		MathStructure &columnToVector(size_t c, MathStructure &mstruct) const;
+		MathStructure &matrixToVector(MathStructure &mstruct) const;
+		void setElement(const MathStructure &mstruct, size_t row, size_t column);
+		void addRows(size_t r, const MathStructure &mfill);
+		void addColumns(size_t c, const MathStructure &mfill);
+		void addRow(const MathStructure &mfill);
+		void addColumn(const MathStructure &mfill);
+		void resizeMatrix(size_t r, size_t c, const MathStructure &mfill);
+		bool matrixIsSquare() const;
+		bool isNumericMatrix() const;
+		int pivot(size_t ro, size_t co, bool symbolic = true);
+		int gaussianElimination(const EvaluationOptions &eo = default_evaluation_options, bool det = false);
+		MathStructure &determinant(MathStructure &mstruct, const EvaluationOptions &eo) const;
+		MathStructure &permanent(MathStructure &mstruct, const EvaluationOptions &eo) const;
+		void setToIdentityMatrix(size_t n);
+		MathStructure &getIdentityMatrix(MathStructure &mstruct) const;
+		bool invertMatrix(const EvaluationOptions &eo);
+		bool adjointMatrix(const EvaluationOptions &eo);
+		bool transposeMatrix();
+		MathStructure &cofactor(size_t r, size_t c, MathStructure &mstruct, const EvaluationOptions &eo) const;	
+		//@}
+
+		/** @name Functions for unit conversion */
+		//@{
+		int isUnitCompatible(const MathStructure &mstruct);
+		bool syncUnits(bool sync_complex_relations = false, bool *found_complex_relations = NULL, bool calculate_new_functions = false, const EvaluationOptions &feo = default_evaluation_options);
+		bool testDissolveCompositeUnit(Unit *u);
+		bool testCompositeUnit(Unit *u);	
+		bool dissolveAllCompositeUnits();			
+		bool convert(Unit *u, bool convert_complex_relations = false, bool *found_complex_relations = NULL, bool calculate_new_functions = false, const EvaluationOptions &feo = default_evaluation_options);
+		bool convert(const MathStructure unit_mstruct, bool convert_complex_relations = false, bool *found_complex_relations = NULL, bool calculate_new_functions = false, const EvaluationOptions &feo = default_evaluation_options);
+		//@}
+		
+		/** @name Functions for recursive search and replace */
+		//@{
+		int contains(const MathStructure &mstruct, bool structural_only = true, bool check_variables = false, bool check_functions = false) const;
+		int containsRepresentativeOf(const MathStructure &mstruct, bool check_variables = false, bool check_functions = false) const;
+		int containsType(StructureType mtype, bool structural_only = true, bool check_variables = false, bool check_functions = false) const;
+		int containsRepresentativeOfType(StructureType mtype, bool check_variables = false, bool check_functions = false) const;
+		bool containsOpaqueContents() const;
+		bool containsAdditionPower() const;
+		bool containsUnknowns() const;
+		bool containsDivision() const;
+		size_t countFunctions(bool count_subfunctions = true) const;
+		void findAllUnknowns(MathStructure &unknowns_vector);
+		bool replace(const MathStructure &mfrom, const MathStructure &mto);
+		bool calculateReplace(const MathStructure &mfrom, const MathStructure &mto, const EvaluationOptions &eo);
+		bool replace(const MathStructure &mfrom1, const MathStructure &mto1, const MathStructure &mfrom2, const MathStructure &mto2);
+		bool removeType(StructureType mtype);
+		//@}
+		
+		/** @name Functions to generate vectors for plotting */
+		//@{
+		MathStructure generateVector(MathStructure x_mstruct, const MathStructure &min, const MathStructure &max, int steps, MathStructure *x_vector = NULL, const EvaluationOptions &eo = default_evaluation_options) const;
+		MathStructure generateVector(MathStructure x_mstruct, const MathStructure &min, const MathStructure &max, const MathStructure &step, MathStructure *x_vector = NULL, const EvaluationOptions &eo = default_evaluation_options) const;
+		MathStructure generateVector(MathStructure x_mstruct, const MathStructure &x_vector, const EvaluationOptions &eo = default_evaluation_options) const;
+		//@}
+		
+		/** @name Differentiation and integration */
+		//@{
+		bool differentiate(const MathStructure &x_var, const EvaluationOptions &eo);
+		bool integrate(const MathStructure &x_var, const EvaluationOptions &eo);
+		//@}
+
+		/** @name Functions for polynomials */
+		//@{
+		bool simplify(const EvaluationOptions &eo = default_evaluation_options, bool unfactorize = true);
+		bool factorize(const EvaluationOptions &eo = default_evaluation_options);
+		/** If the structure represents a rational polynomial.
+		* This is true for
+		*	- rational numbers;
+		*	- functions, units, variables and symbols that do not represent a matrix or undefined;
+		*	- a power with a positive integer exponent and any of the previous as base;
+		*	- a multiplication with the previous as factors; or
+		*	- an addition with the previous as terms.
+		*
+		* @returns true if structure represents a rational polynomial.
+		*/
+		bool isRationalPolynomial() const;
+		const Number &overallCoefficient() const;
+		const Number &degree(const MathStructure &xvar) const;
+		const Number &ldegree(const MathStructure &xvar) const;
+		void lcoefficient(const MathStructure &xvar, MathStructure &mcoeff) const;
+		void tcoefficient(const MathStructure &xvar, MathStructure &mcoeff) const;
+		void coefficient(const MathStructure &xvar, const Number &pownr, MathStructure &mcoeff) const;
+		Number maxCoefficient();
+		int polynomialUnit(const MathStructure &xvar) const;
+		void polynomialContent(const MathStructure &xvar, MathStructure &mcontent, const EvaluationOptions &eo) const;
+		void polynomialPrimpart(const MathStructure &xvar, MathStructure &mprim, const EvaluationOptions &eo) const;
+		void polynomialPrimpart(const MathStructure &xvar, const MathStructure &c, MathStructure &mprim, const EvaluationOptions &eo) const;
+		void polynomialUnitContentPrimpart(const MathStructure &xvar, int &munit, MathStructure &mcontent, MathStructure &mprim, const EvaluationOptions &eo) const;
+		//@}
+
+		static bool polynomialDivide(const MathStructure &mnum, const MathStructure &mden, MathStructure &mquotient, const EvaluationOptions &eo, bool check_args = true);
+		static bool polynomialQuotient(const MathStructure &mnum, const MathStructure &mden, const MathStructure &xvar, MathStructure &mquotient, const EvaluationOptions &eo, bool check_args = true);
+		static bool lcm(const MathStructure &m1, const MathStructure &m2, MathStructure &mlcm, const EvaluationOptions &eo, bool check_args = true);
+		static bool gcd(const MathStructure &m1, const MathStructure &m2, MathStructure &mresult, const EvaluationOptions &eo, MathStructure *ca = NULL, MathStructure *cb = NULL, bool check_args = true);
+
+		/** @name Functions for equations */
+		//@{
+		const MathStructure &find_x_var() const;
+		bool isolate_x(const EvaluationOptions &eo, const MathStructure &x_var = m_undefined, bool check_result = false);
+		bool isolate_x(const EvaluationOptions &eo, const EvaluationOptions &feo, const MathStructure &x_var = m_undefined, bool check_result = false);
+		//@}
+		
+};
+
+#endif