libqalculate-ruby 0.0.1

data/ext/libqalculate/Unit.h

@@ -0,0 +1,300 @@
+/*
+    Qalculate    
+
+    Copyright (C) 2003-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 UNIT_H
+#define UNIT_H
+
+/** @file */
+
+/// Type of unit
+typedef enum {
+	/// class Unit
+	SUBTYPE_BASE_UNIT,
+	/// class AliasUnit
+	SUBTYPE_ALIAS_UNIT,
+	/// class CompositeUnit
+	SUBTYPE_COMPOSITE_UNIT
+} UnitSubtype;
+
+#include <libqalculate/ExpressionItem.h>
+#include <libqalculate/includes.h>
+
+/// A unit for measurement.
+/**
+* The Unit class both represents a base unit and is the base class for other unit types.
+* Base units are units defined as basis for other units. Meters and seconds are typical base units.
+*
+* For base units, a name is all that is needed.
+* Base units do however normally have three different names defined for use in expressions - abbreviation (ex. "m"), singular ("meter") and plural ("meters").
+*/
+class Unit : public ExpressionItem {
+
+  protected:
+
+	string ssystem;
+	bool b_si;
+
+  public:
+
+	Unit(string cat_, string name_, string plural_ = "", string singular_ = "", string title_ = "", bool is_local = true, bool is_builtin = false, bool is_active = true);
+	Unit();	
+	Unit(const Unit *unit);	
+	virtual ~Unit();
+
+	virtual ExpressionItem *copy() const;
+	virtual void set(const ExpressionItem *item);
+
+	/** Returns if the unit is part of the SI standard.
+	*
+	* @returns true if the unit is part of the SI standard.
+	*/
+	bool isSIUnit() const;
+	/** State that the unit is part of the SI standard.
+	* Sets system to "SI".
+	*/
+	void setAsSIUnit();
+	/** Sets which system/standard ("SI", "SGC", etc.) the unit is part of.
+	* Setting system to "SI" (case-insensitive), is equivalent to setAsSIUnit().
+	*/
+	void setSystem(string s_system);
+	/** Returns the system/standard that the unit is part of.
+	*
+	* @returns System string.
+	*/
+	const string &system() const;
+	/** Returns if the unit is a currency (Euro is base unit).
+	*
+	* @returns true if the unit is a currency.
+	*/
+	bool isCurrency() const;
+	/** Returns a display string representing the unit in an expression.
+	*
+	* Equivalent to preferredName() for Unit and AliasUnit, but closer to MathStructure::print() for CompositeUnit (prints out base expression).
+	*/
+	virtual string print(bool plural_, bool short_, bool use_unicode = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	virtual const string &plural(bool return_singular_if_no_plural = true, bool use_unicode = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	virtual const string &singular(bool return_abbreviation_if_no_singular = true, bool use_unicode = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	virtual const string &abbreviation(bool return_singular_if_no_abbreviation = true, bool use_unicode = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	virtual bool isUsedByOtherUnits() const;
+	virtual Unit* baseUnit() const;
+	virtual MathStructure &convertToBaseUnit(MathStructure &mvalue, MathStructure &mexp) const;
+	virtual MathStructure &convertFromBaseUnit(MathStructure &mvalue, MathStructure &mexp) const;
+	virtual MathStructure &convertToBaseUnit(MathStructure &mvalue) const;
+	virtual MathStructure &convertFromBaseUnit(MathStructure &mvalue) const;
+	virtual MathStructure convertToBaseUnit() const;
+	virtual MathStructure convertFromBaseUnit() const;
+	virtual int baseExponent(int exp = 1) const;
+	virtual int type() const;
+	/** Returns the subtype of the unit, corresponding to which subsubclass the object belongs to.
+	*
+	* @returns ::UnitSubtype.
+	*/
+	virtual int subtype() const;
+	/** If specified unit is a base unit for this unit, directly or with other units in between.
+	* Equivalent to u->isParentOf(this).
+	*/
+	virtual bool isChildOf(Unit *u) const;
+	/** If this unit is a base unit for specified unit, directly or with other units in between.
+	* Equivalent to u->isChildOf(this).
+	*/
+	virtual bool isParentOf(Unit *u) const;
+	virtual bool hasComplexRelationTo(Unit *u) const;
+	/** Converts a value from specified unit and exponent to this unit.
+	* value * (unit^exponent) = new value * (this^new exponent)
+	* This function cannot convert to or from CompositeUnit.
+	*
+	* @param u Unit to convert from.
+	* @param[in,out] mvalue Quantity value.
+	* @param[in,out] exp Exponent.
+	* @returns true if the value was successfully converted.
+	*/
+	bool convert(Unit *u, MathStructure &mvalue, MathStructure &exp) const;
+	/** Converts a value from specified unit and exponent to this unit.
+	* value * unit = new value * this
+	* This function cannot convert to or from CompositeUnit.
+	*
+	* @param u Unit to convert from.
+	* @param[in,out] mvalue Quantity value.
+	* @returns true if the value was successfully converted.
+	*/
+	bool convert(Unit *u, MathStructure &mvalue) const;
+	MathStructure convert(Unit *u, bool *converted = NULL) const;
+
+};
+
+
+/// An unit with relation to another unit
+/**
+* Alias units is defined in relation to another unit.
+* For example, hour are defined as an alias unit that equals 60 minutes which in turn is defined in relation to seconds.
+*
+* Alias units have an associated base unit, exponent and relation expression.
+* For more complex relations an inverse relation can also be specified for conversion back from the base unit.
+* The base unit must not necessarily be of the base unit class and it is recommended that an alias unit is defined in relation to the closest unit
+* (ex. 1ft = 3 hands, 1 hand = 4 in, and 1 in = 0.0254 m).
+*
+* The relation is usually just a number that tells how large quantity of the base unit is needed to get the alias unit (alias unit = base unit * relation).
+* More complex units can specify the relation as a full-blown expression where '\x' is replaced by the quantity of the base unit and
+* '\y' is the exponent.
+* For example, Degrees Celsius has the relation "\x + 273.15" and the inverse relation "\x - 273.15" to the base unit Kelvin.
+* For simple relations, the reversion is automatic and ought not be defined separately.
+*
+* The precision property inherited from ExpressionItem defines the precision of the relation.
+*
+* The exponent defines the exponential relation to the base unit, so that the alias unit equals the base unit raised to the exponent.
+* For simple unit relations this gives: alias unit = relation * base unit^exponent.
+*
+* Alias units normally have three different names defined for use in expressions - abbreviation (ex. "m"), singular ("meter") and plural ("meters").
+*/
+class AliasUnit : public Unit {
+
+  protected:
+
+	string svalue, sinverse;
+	int i_exp;
+	Unit *o_unit;
+
+  public:
+
+	AliasUnit(string cat_, string name_, string plural_, string singular_, string title_, Unit *alias, string relation = "1", int exp = 1, string inverse = "", bool is_local = true, bool is_builtin = false, bool is_active = true);
+	AliasUnit(const AliasUnit *unit);		
+	AliasUnit();			
+	virtual ~AliasUnit();
+
+	virtual ExpressionItem *copy() const;
+	virtual void set(const ExpressionItem *item);
+	
+	virtual Unit* baseUnit() const;
+	virtual Unit* firstBaseUnit() const;
+	virtual void setBaseUnit(Unit *alias);
+	virtual string expression() const;
+	virtual string inverseExpression() const;
+	/**
+	* Sets the relation expression.
+	*/
+	virtual void setExpression(string relation);
+	/**
+	* Sets the inverse relation expression.
+	*/
+	virtual void setInverseExpression(string inverse);
+	virtual MathStructure &convertToFirstBaseUnit(MathStructure &mvalue, MathStructure &mexp) const;
+	virtual MathStructure &convertFromFirstBaseUnit(MathStructure &mvalue, MathStructure &mexp) const;
+	virtual MathStructure &convertToBaseUnit(MathStructure &mvalue, MathStructure &mexp) const;
+	virtual MathStructure &convertFromBaseUnit(MathStructure &mvalue, MathStructure &mexp) const;
+	virtual MathStructure &convertToBaseUnit(MathStructure &mvalue) const;
+	virtual MathStructure &convertFromBaseUnit(MathStructure &mvalue) const;
+	virtual MathStructure convertToBaseUnit() const;
+	virtual MathStructure convertFromBaseUnit() const;
+	virtual int baseExponent(int exp = 1) const;
+	virtual void setExponent(int exp);
+	virtual int firstBaseExponent() const;
+	virtual int subtype() const;
+	virtual bool isChildOf(Unit *u) const;
+	virtual bool isParentOf(Unit *u) const;
+	virtual bool hasComplexExpression() const;
+	virtual bool hasComplexRelationTo(Unit *u) const;
+
+};
+
+/// A subunit in a CompositeUnit
+/**
+* Should normally not be used directly.
+*/
+class AliasUnit_Composite : public AliasUnit {
+
+  protected:
+
+	Prefix *prefixv;
+
+  public:
+
+	AliasUnit_Composite(Unit *alias, int exp = 1, Prefix *prefix_ = NULL);
+	AliasUnit_Composite(const AliasUnit_Composite *unit);			
+	virtual ~AliasUnit_Composite();
+
+	virtual ExpressionItem *copy() const;
+	virtual void set(const ExpressionItem *item);
+	
+	virtual string print(bool plural_, bool short_, bool use_unicode = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	virtual Prefix *prefix() const;
+	virtual int prefixExponent() const;	
+	virtual void set(Unit *u, int exp = 1, Prefix *prefix_ = NULL);
+	virtual MathStructure &convertToFirstBaseUnit(MathStructure &mvalue, MathStructure &mexp) const;
+	virtual MathStructure &convertFromFirstBaseUnit(MathStructure &mvalue, MathStructure &mexp) const;
+
+};
+
+/// A unit consisting of a number of other units
+/**
+* Composite units are defined by a unit expression with multiple units.
+* Composite units often have an alias unit associated with them, as they do not have a reference name on their own.
+* For example, a joule is defined as an alias defined in relation to a composite unit defined as "Newton * meter".
+*
+* The names of composite units is only used to reference the unit in definitions of other units.
+* They can not be used in expressions.
+*
+* Composite units is definited as a composition of units.
+* The units, with prefixes and exponents, can either be added one by one with add() or
+* parsed from an expression (ex. "cm^3/g) with setBaseExpression().
+*/
+class CompositeUnit : public Unit {
+	
+	protected:
+	
+		string sshort;
+		vector<AliasUnit_Composite*> units;
+
+	public:
+
+		CompositeUnit(string cat_, string name_, string title_ = "", string base_expression_ = "", bool is_local = true, bool is_builtin = false, bool is_active = true);
+		CompositeUnit(const CompositeUnit *unit);
+		virtual ~CompositeUnit();
+		virtual ExpressionItem *copy() const;
+		virtual void set(const ExpressionItem *item);
+		/** Adds a sub/base unit with specified exponent and an optional prefix.
+		*
+		* @param u Unit.
+		* @param exp Exponent.
+		* @param prefix Prefix.
+		*/
+		virtual void add(Unit *u, int exp = 1, Prefix *prefix = NULL);
+		/** Retrieves information about a sub/base unit 
+		*
+		* @param index Index starting at 1.
+		* @param[out] exp Exponent.
+		* @param[out] prefix Prefix.
+		* @returns Sub/base unit (AliasUnit_Composite::firstBaseUnit()).
+		*/
+		virtual Unit *get(size_t index, int *exp = NULL, Prefix **prefix = NULL) const;
+		virtual void setExponent(size_t index, int exp);
+		virtual void setPrefix(size_t index, Prefix *prefix);
+		/** Returns the number of sub/base units */
+		virtual size_t countUnits() const;
+		virtual size_t find(Unit *u) const;
+		virtual void del(size_t index);
+		/** Prints out the sub/base units with prefixes and exponents.
+		* This is the representation of the unit in expressions.
+		*/
+		virtual string print(bool plural_, bool short_, bool use_unicode = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+		virtual int subtype() const;
+		/** If this unit contains a sub/base unit with a relation to the specified unit.
+		 */
+		virtual bool containsRelativeTo(Unit *u) const;
+		/** Creates a MathStructure with the sub/base units of the unit.
+		*/
+		virtual MathStructure generateMathStructure(bool make_division = false) const;
+		virtual void setBaseExpression(string base_expression_);		
+		/** Removes all sub/base units. */
+		virtual void clear();
+};
+
+
+#endif

data/ext/libqalculate/Variable.h

@@ -0,0 +1,380 @@
+/*
+    Qalculate    
+
+    Copyright (C) 2003-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 VARIABLE_H
+#define VARIABLE_H
+
+#include <libqalculate/ExpressionItem.h>
+#include <libqalculate/includes.h>
+
+/** @file */
+
+#define DECLARE_BUILTIN_VARIABLE(x)	class x : public DynamicVariable { \
+					  private: \
+						void calculate() const;	\
+ 					  public: \
+						x(); \
+						x(const x *variable) {set(variable);} \
+						ExpressionItem *copy() const {return new x(this);} \
+					};
+
+/// Type assumption.
+/**
+* Each type is a subset of the type above.
+*/
+typedef enum {
+	ASSUMPTION_TYPE_NONE = 0,
+	/// Multiplication is NOT commutative
+	ASSUMPTION_TYPE_NONMATRIX = 1,
+	ASSUMPTION_TYPE_NUMBER = 2,
+	/// im(x) != 0
+	ASSUMPTION_TYPE_COMPLEX = 3,
+	ASSUMPTION_TYPE_REAL = 4,
+	ASSUMPTION_TYPE_RATIONAL = 5,
+	ASSUMPTION_TYPE_INTEGER = 6
+} AssumptionType;
+
+/// Signedness assumption.
+typedef enum {
+	/// x = ?
+	ASSUMPTION_SIGN_UNKNOWN,
+	/// x > 0
+	ASSUMPTION_SIGN_POSITIVE,
+	/// x >= 0
+	ASSUMPTION_SIGN_NONNEGATIVE,
+	/// x < 0
+	ASSUMPTION_SIGN_NEGATIVE,
+	/// x <= 0
+	ASSUMPTION_SIGN_NONPOSITIVE,
+	/// x != 0
+	ASSUMPTION_SIGN_NONZERO
+} AssumptionSign;
+
+/// Type of variable
+typedef enum {
+	/// class Variable
+	SUBTYPE_VARIABLE,
+	/// class UnknownVariable
+	SUBTYPE_UNKNOWN_VARIABLE,
+	/// class KnownVariable
+	SUBTYPE_KNOWN_VARIABLE
+} VariableSubtype;
+
+/// An assumption about an unknown mathematical value.
+/** Assumptions have a type and a sign. The type describes the type of the value -- if it represents a number or something else, and what type of number is represented.
+* The sign restricts the signedness of a number. The sign generally only applies the assumptions representing a number.
+* The assumption class also includes max and min values, which however are not used anywhere yet.
+*/
+class Assumptions {
+
+  protected:
+  
+	AssumptionType i_type;
+	AssumptionSign i_sign;
+	Number *fmin, *fmax;
+	bool b_incl_min, b_incl_max;
+
+  public:
+
+	Assumptions();
+	~Assumptions();
+
+	bool isPositive();
+	bool isNegative();
+	bool isNonNegative();
+	bool isNonPositive();
+	bool isInteger();
+	bool isNumber();
+	bool isRational();
+	bool isReal();
+	bool isComplex();
+	bool isNonZero();
+	bool isNonMatrix();
+	
+	AssumptionType type();
+	AssumptionSign sign();
+	void setType(AssumptionType ant);
+	void setSign(AssumptionSign as);
+	
+	void setMin(const Number *nmin);	
+	void setIncludeEqualsMin(bool include_equals);
+	bool includeEqualsMin() const;	
+	const Number *min() const;
+	void setMax(const Number *nmax);	
+	void setIncludeEqualsMax(bool include_equals);
+	bool includeEqualsMax() const;	
+	const Number *max() const;
+	
+};
+
+/// Abstract base class for variables.
+/** A variable is an alpha-numerical representation of a known or unknown value.
+*/
+class Variable : public ExpressionItem {
+
+  public:
+
+	Variable(string cat_, string name_, string title_ = "", bool is_local = true, bool is_builtin = false, bool is_active = true);
+	Variable();
+	Variable(const Variable *variable);
+	virtual ~Variable();
+	virtual ExpressionItem *copy() const = 0;
+	virtual void set(const ExpressionItem *item);
+	virtual int type() const {return TYPE_VARIABLE;}
+	/** Returns the subtype of the variable, corresponding to which subsubclass the object belongs to.
+	*
+	* @returns ::VariableSubtype.
+	*/
+	virtual int subtype() const {return SUBTYPE_VARIABLE;}
+	/** Returns if the variable has a known value (as oppossed to assumptions).
+	*
+	* @returns true if the variable is of class KnownVariable, false if UnknownVariable.
+	*/
+	virtual bool isKnown() const = 0;
+
+	/** Returns if the variable represents a positive value.
+	*/
+	virtual bool representsPositive(bool = false) {return false;}
+	virtual bool representsNegative(bool = false) {return false;}
+	virtual bool representsNonNegative(bool = false) {return false;}
+	virtual bool representsNonPositive(bool = false) {return false;}
+	virtual bool representsInteger(bool = false) {return false;}
+	virtual bool representsNumber(bool = false) {return false;}
+	virtual bool representsRational(bool = false) {return false;}
+	virtual bool representsReal(bool = false) {return false;}
+	virtual bool representsComplex(bool = false) {return false;}
+	virtual bool representsNonZero(bool = false) {return false;}
+	virtual bool representsEven(bool = false) {return false;}
+	virtual bool representsOdd(bool = false) {return false;}
+	virtual bool representsUndefined(bool = false, bool = false, bool = false) {return false;}
+	virtual bool representsBoolean() {return false;}
+	virtual bool representsNonMatrix() {return false;}
+	
+};
+
+/// A variable with unknown value.
+/** Unknown variables have an associated assumption object.
+*/
+class UnknownVariable : public Variable {
+
+  protected:
+  
+  	Assumptions *o_assumption;
+  
+  public:
+
+	/** Create an unknown.
+	*
+	* @param cat_ Category that the variable belongs to.
+	* @param name_ Initial name of the variable.
+	* @param title_ Descriptive name.
+	* @param is_local If the variable is local/user-defined or global.
+	* @param is_builtin If the variable is builtin and not modifiable.
+	* @param is_active If the variable is active and can be used in expressions.
+	*/
+	UnknownVariable(string cat_, string name_, string title_ = "", bool is_local = true, bool is_builtin = false, bool is_active = true);
+	/** Create an empty unknown variable.
+	*/
+	UnknownVariable();
+	/** Create a copy of an unknown variable.
+	*
+	* @param variable Unknown variable to copy.
+	*/
+	UnknownVariable(const UnknownVariable *variable);
+	virtual ~UnknownVariable();
+	virtual ExpressionItem *copy() const;
+	virtual void set(const ExpressionItem *item);
+	bool isKnown() const {return false;}
+	
+	/** Sets the assumptions of the unknown variable.
+	*
+	* @param ass Assumptions.
+	*/
+	void setAssumptions(Assumptions *ass);
+	/** Returns the assumptions of the unknown variable.
+	*
+	* @returns Assumptions of the unknown variable.
+	*/
+	Assumptions *assumptions();
+	int subtype() const {return SUBTYPE_UNKNOWN_VARIABLE;}
+
+	virtual bool representsPositive(bool = false);
+	virtual bool representsNegative(bool = false);
+	virtual bool representsNonNegative(bool = false);
+	virtual bool representsNonPositive(bool = false);
+	virtual bool representsInteger(bool = false);
+	virtual bool representsNumber(bool = false);
+	virtual bool representsRational(bool = false);
+	virtual bool representsReal(bool = false);
+	virtual bool representsComplex(bool = false);
+	virtual bool representsNonZero(bool = false);
+	virtual bool representsNonMatrix();
+	
+};
+
+/// A variable with a known value.
+/** Known variables have an associated value. The value can be a simple number or a full mathematical expression. The known variable class is used both for variable values and constants.
+*
+* The value can be provided as an expression in the form of a text string or as a mathematical value in the form of an object of the MathStructure class.
+* The text string is parsed when needed, which saves time when loading many variable definitions which might not be used, at least not immediately.
+*/
+class KnownVariable : public Variable {
+
+  protected:
+
+	MathStructure *mstruct;
+	bool b_expression;
+ 	int calculated_precision;
+	string sexpression;
+
+  public:
+  
+	/** Create a known variable with a value. 
+	*
+	* @param cat_ Category that the variable belongs to.
+	* @param name_ Initial name of the variable.
+	* @param o Value.
+	* @param title_ Descriptive name.
+	* @param is_local If the variable is local/user-defined or global.
+	* @param is_builtin If the variable is builtin and not modifiable.
+	* @param is_active If the variable is active and can be used in expressions.
+	*/
+	KnownVariable(string cat_, string name_, const MathStructure &o, string title_ = "", bool is_local = true, bool is_builtin = false, bool is_active = true);
+	/** Create a known variable with an text string expression.
+	*
+	* @param cat_ Category that the variable belongs to.
+	* @param name_ Initial name of the variable.
+	* @param expression_ Expression.
+	* @param title_ Descriptive name.
+	* @param is_local If the variable is local/user-defined or global.
+	* @param is_builtin If the variable is builtin and not modifiable.
+	* @param is_active If the variable is active and can be used in expressions.
+	*/
+	KnownVariable(string cat_, string name_, string expression_, string title_ = "", bool is_local = true, bool is_builtin = false, bool is_active = true);	
+	/** Create an empty known variable. Primarily for internal use.
+	*/
+	KnownVariable();
+	/** Create a copy of a known variable.
+	*
+	* @param variable Known variable to copy.
+	*/
+	KnownVariable(const KnownVariable *variable);
+	virtual ~KnownVariable();
+
+	virtual ExpressionItem *copy() const;
+	virtual void set(const ExpressionItem *item);
+	bool isKnown() const {return true;}
+	/** Returns if the variable has an text string expression instead of a value.
+	*
+	* @returns True if the variable has an expression instead of a value.
+	*/
+	virtual bool isExpression() const;
+	/** Returns the variable's string expression or an empty string if it has not got an expression.
+	*
+	* @returns The variable's expression.
+	*/
+	virtual string expression() const;
+	int subtype() const {return SUBTYPE_KNOWN_VARIABLE;}
+
+	/** Sets the value of the variable. If expression is set, it is cleared.
+	*
+	* @param o Value.
+	*/
+	virtual void set(const MathStructure &o);
+	/** Sets the text string expression of the variable. The value is cleared.
+	*
+	* @param expression_ Expression.
+	*/
+	virtual void set(string expression_);	
+
+	/** Returns the value of the variable. If no value is set or parsed and an expression is set, the expression is parsed and resulting value returned.
+	*
+	* @returns The value of the variable..
+	*/
+	virtual const MathStructure &get();
+	
+	virtual bool representsPositive(bool = false);
+	virtual bool representsNegative(bool = false);
+	virtual bool representsNonNegative(bool = false);
+	virtual bool representsNonPositive(bool = false);
+	virtual bool representsInteger(bool = false);
+	virtual bool representsNumber(bool = false);
+	virtual bool representsRational(bool = false);
+	virtual bool representsReal(bool = false);
+	virtual bool representsComplex(bool = false);
+	virtual bool representsNonZero(bool = false);
+	virtual bool representsEven(bool = false);
+	virtual bool representsOdd(bool = false);
+	virtual bool representsUndefined(bool = false, bool = false, bool = false);
+	virtual bool representsBoolean();
+	virtual bool representsNonMatrix();
+
+};
+
+/// Abstract base class for variables with a value which is recalculated when the precision has changed.
+/**
+*/
+class DynamicVariable : public KnownVariable {
+
+  protected:
+  
+  	virtual void calculate() const = 0;
+  	
+  public:
+
+	DynamicVariable(string cat_, string name_, string title_ = "", bool is_local = false, bool is_builtin = true, bool is_active = true);
+	DynamicVariable(const DynamicVariable *variable);
+	DynamicVariable();
+	virtual ~DynamicVariable();
+
+	ExpressionItem *copy() const = 0;
+	void set(const ExpressionItem *item);
+
+	const MathStructure &get();
+	
+	void set(const MathStructure &o);
+	void set(string expression_);
+	
+	/** Returns the precision of the calculated value.
+	*
+	* @returns Precision of the calculated value or zero if the value has not yet been calculated.
+	*/
+	int calculatedPrecision() const;
+	
+	virtual bool representsPositive(bool = false) {return true;}
+	virtual bool representsNegative(bool = false) {return false;}
+	virtual bool representsNonNegative(bool = false) {return true;}
+	virtual bool representsNonPositive(bool = false) {return false;}
+	virtual bool representsInteger(bool = false) {return false;}
+	virtual bool representsNumber(bool = false) {return true;}
+	virtual bool representsRational(bool = false) {return false;}
+	virtual bool representsReal(bool = false) {return true;}
+	virtual bool representsComplex(bool = false) {return false;}
+	virtual bool representsNonZero(bool = false) {return true;}
+	virtual bool representsEven(bool = false) {return false;}
+	virtual bool representsOdd(bool = false) {return false;}
+	virtual bool representsUndefined(bool = false, bool = false, bool = false) {return false;}
+	virtual bool representsBoolean() {return false;}
+	virtual bool representsNonMatrix() {return true;}
+
+};
+
+/// Dynamic variable for Pi
+DECLARE_BUILTIN_VARIABLE(PiVariable)
+/// Dynamic variable for e, the base of natural logarithms
+DECLARE_BUILTIN_VARIABLE(EVariable)
+/// Dynamic variable for Euler's constant
+DECLARE_BUILTIN_VARIABLE(EulerVariable)
+/// Dynamic variable for Catalan's constant
+DECLARE_BUILTIN_VARIABLE(CatalanVariable)
+
+
+#endif