trunk/pygtk/ascpy.i

/* : set syntax=cpp : */
/*
	SWIG interface routines to read a file into the library
*/

%module(directors=1) ascpy

%include <python/std_string.i>
%include <python/std_except.i>
%include <python/std_vector.i>
%include <python/std_map.i>

%{
#include "library.h"
#include "compiler.h"
#include "type.h"
#include "instance.h"
#include "variable.h"
#include "relation.h"
#include "name.h"
#include "reporter.h"
#include "simulation.h"
#include "solver.h"
#include "symchar.h"
#include "set.h"
#include "dimensions.h"
#include "units.h"
#include "extmethod.h"
#include "plot.h"
#include "curve.h"
#include "solverparameters.h"
#include "solverstatus.h"
#include "solverreporter.h"
#include "incidencematrix.h"
#include "registry.h"
%}

// All STL runtime_errors caught to Python

%exception {
	try {
		$action
	}
	catch (std::range_error &e) {
		SWIG_exception(SWIG_IndexError,e.what());
	}
	catch (std::runtime_error &e) {
		SWIG_exception(SWIG_RuntimeError,e.what());
	}
}

// Import the preferences module
%pythoncode {
	import preferences;
}

// Set-valued instance variable
%pythoncode {
	class SetIter:
		def __init__(self,set):
			self.set=set
			self.index=0
		def next(self):
			if self.index==self.set.length():
				raise StopIteration
			self.index = self.index + 1
			return self.set[self.index]
}

template<class T>
class ASCXX_Set{
private:
	ASCXX_Set();
public:
	const T at(const unsigned long&) const;
	const unsigned long	length() const;
};
%extend ASCXX_Set<long>{
	%pythoncode {
		def __getitem__(self, index):
			return self.at(index)
		def __iter__(self):
			return SetIter(self)
	}
}
%extend ASCXX_Set<SymChar>{
	%pythoncode {
		def __getitem__(self, index):
			return self.at(index)
		def __iter__(self):
			return SetIter(self)
	}
}


%template(ModuleVector) std::vector<Module>;
%template(TypeVector) std::vector<Type>;
%template(MethodVector) std::vector<Method>;
%template(InstancVector) std::vector<Instanc>;
%template(ExtMethodVector) std::vector<ExtMethod>;
%template(SetInt) ASCXX_Set<long>;
%template(SetString) ASCXX_Set<SymChar>;
%template(DoubleVector) std::vector<double>;
%template(IntVector) std::vector<int>;
%template(CurveVector) std::vector<Curve>;
%template(StringVector) std::vector<std::string>;
%template(IntStringMap) std::map<int,std::string>;

%rename(Instance) Instanc;
%rename(Name) Nam;#include "incidencematrix.h"
%rename(getSetIntValue) Instanc::getSetValue<long>;
%rename(getSetStringValue) Instanc::getSetValue<SymChar>;
%rename(Units) UnitsM;
%rename(set) Registry::setPyObject;


// Grab a Python function object as a Python object.
%typemap(in) PyObject *pyfunc {
  if (!PyCallable_Check($input)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
  }
  $1 = $input;
}

//----------------------------
// REPORTER: callbacks to python
class Reporter{
private:
	~Reporter();
	Reporter();
public:
	// use 'getReporter' instead of 'Reporter::Instance()' in python
	void setErrorCallback(error_reporter_callback_t callback, void *client_data);
	void setPythonErrorCallback(PyObject *pyfunc);
	void clearPythonErrorCallback();
};

%extend Reporter {
	void reportError(const char *msg){
		ERROR_REPORTER_NOLINE(ASC_USER_ERROR,"%s", msg);
	}
	void reportNote(const char *msg){
		ERROR_REPORTER_NOLINE(ASC_USER_NOTE,"%s",msg);
	}
	void reportWarning(const char *msg){
		ERROR_REPORTER_NOLINE(ASC_USER_WARNING,"%s",msg);
	}
	void reportSuccess(const char *msg){
		ERROR_REPORTER_NOLINE(ASC_USER_SUCCESS,"%s",msg);
	}
}

// There are problems with Instance(), so use this instead:
Reporter *getReporter();

//----------------------------------------
// UNITS AND DIMENSIONS


class UnitsM;

class Dimensions{
public:
	static const unsigned MAX_DIMS;
	static const std::string getBaseUnit(const unsigned &);

	const bool operator==(const Dimensions &) const;
	const bool operator!=(const Dimensions &) const;
	const bool operator<(const Dimensions &) const;
	Dimensions(const Dimensions &);
	const bool isWild() const;
	const bool isDimensionless() const;
	const short getFractionNumerator(const unsigned &) const;
	const short getFractionDenominator(const unsigned &) const;
};

class UnitsM{
public:
	UnitsM(const char *);
	const SymChar getName() const; // the units description string eg 'bar' or 'kJ/kg/K'
	const Dimensions getDimensions() const;
	const double getConversion() const; // multiplication factor to convert eg feet to SI (metres)
};

%extend UnitsM{
	%pythoncode{
		def getConvertedValue(self,si_value):
			_u_value = si_value / self.getConversion()
			return str(_u_value) + " " + self.getName().toString();
	}
}

/*
	This function creates default (SI) units for any dimension given. Most
	of the time you will want to use custom units in place of these, eg
	'N' instead of 'kg*m/s^2'.
*/
%extend Dimensions{
	%pythoncode {

		def getDefaultUnits(self):
			if self.isDimensionless():
				return Units("");

			if self.isWild():
				return Units("?");

			# create a string representation of the current dimensions
			numparts=[]
			denparts=[]
			for i in range(0, self.MAX_DIMS):
				baseunit = self.getBaseUnit(i);
				num = self.getFractionNumerator(i)
				den = self.getFractionDenominator(i)
				if num > 0:
					if den == 1:
						if num == 1:
							numparts.append(baseunit)
						else:
							numparts.append("%s^%d" % (baseunit, num) )
					else:
						numparts.append("%s^(%d/%d)" % (baseunit, num, den) )
				elif num < 0:
					if den == 1:
						if num == -1:
							denparts.append(baseunit)
						else:
							denparts.append("%s^%d" % (baseunit, -num) )
					else:
						denparts.append("%s^(%d/%d)" % (baseunit, -num, den) )

			if len(numparts):
				str = "*".join(numparts)
			else:
				str = "1"

			if len(denparts):
				str = str + "/" + "/".join(denparts)

			return Units(str)

	}
}

/*
some python code for nice unicode unit strings, need to extend the units.c code as well though.

elif num == 2:
	numparts.append(baseunit + ur'\u00b2')
elif num == 3:
	numparts.append(baseunit + ur'\u00b3')

str = ur'\u00b7'.join(numparts)
*/
//----------------------------

class Library{
public:
	Library(const char *defaultpath=NULL);
	~Library();

	void load(char *filename);
	void listModules(const int &module_type=0);
	Type &findType(const char *name);
	std::vector<Module> getModules();
	std::vector<Type> getModuleTypes(const Module &);
	std::vector<ExtMethod> getExtMethods();
	void clear();
};

class SymChar{
public:
	SymChar(const std::string &);
	const char *toString() const;
};
%extend SymChar{
	const char *__repr__(){
		return self->toString();
	}
}

class Module{
public:
	const char *getName() const;
	const char *getFilename() const;
	const struct tm *getMtime() const;
};

class Method{
public:
	const char *getName() const;
};

// Renamed in python as 'Name'
class Nam{
public:
	Nam(const SymChar &);
	const std::string getName() const;
};

%include "compiler.h"
/* we can always disown Compiler * as it's a singleton */
%apply SWIGTYPE *DISOWN { Compiler * };

class Type{
public:
	const SymChar getName();
	const int getParameterCount();
	Simulation getSimulation(const char *name);
	std::vector<Method> getMethods();
	const bool isRefinedSolverVar() const;
	const bool isRefinedReal() const;
	const Dimensions getDimensions() const;
	const bool hasParameters() const;
};
%extend Type{
	const char *__repr__(){
		return self->getName().toString();
	}

	%pythoncode{
		def getPreferredUnits(self):
			if not self.isRefinedReal():
				return None

			_pref = preferences.Preferences()
			#print "Checking for preferred units for %s" % self.getName()
			_u = _pref.getPreferredUnits(self.getName().toString())
			if _u == None:
				# no preferred units set
				return None
			_units = Units(_u);

			if _units.getDimensions() != self.getDimensions():
				getReporter().reportWarning("Preferred units '%s' for type '%s' are not dimensionally correct: ignoring." % (_u, self.getName()) );
				return None

			return _units;
	}
}

typedef enum{
	ASCXX_VAR_STATUS_UNKNOWN=0, ASCXX_VAR_FIXED, ASCXX_VAR_UNSOLVED, ASCXX_VAR_ACTIVE, ASCXX_VAR_SOLVED
} VarStatus;

class Instanc{
private:
	Instanc();
public:
	Instanc(Instance *);
	Instanc(Instance *, SymChar &name);
	~Instanc();
	std::vector<Instanc> getChildren();
	const std::string getKindStr() const;
	const SymChar &getName();
	const Type getType() const;
	const bool isAtom() const;
	const bool isFixed() const;
	const bool isActive() const;
	const bool isFund() const;
	const bool isConst() const;
	const bool isAssigned() const;
	const bool isCompound() const;
	const bool isRelation() const;
	const bool isLogicalRelation() const;
	const bool isWhen() const;
	const bool isSet() const; // a set (group) of things
	const bool isSetInt() const;
	const bool isSetString() const;
	const bool isSetEmpty() const;
	const bool isDefined() const;
	const bool isBool() const;
	const bool isInt() const;
	const bool isSymbol() const;
	const bool isReal() const;
	const bool isModel() const;

	const double getRealValue() const;
	const bool isDimensionless() const;
	const Dimensions getDimensions() const;
	const bool getBoolValue() const;
	const long getIntValue() const;
	const SymChar getSymbolValue() const;
	const std::string getValueAsString() const; ///< Use carefully: rounding will occur for doubles!

	const std::string getRelationAsString(const Instanc &relative_to) const;
	const double getResidual() const;

	Plot getPlot() const;

	const bool isPlottable() const;
	const ASCXX_Set<long> getSetValue<long>() const;
	const ASCXX_Set<SymChar> getSetValue<SymChar>() const;
	const bool isChildless() const;
	void setFixed(const bool &val=true);
	void setRealValue(const double &val);
	void setRealValueWithUnits(const double &, const char *);
	void setBoolValue(const bool &val);
	void setSymbolValue(const SymChar &sym);
	void write();

	const VarStatus getVarStatus() const;

	void setLowerBound(const double &);
	void setUpperBound(const double &);
	void setNominal(const double &);
	const double getLowerBound() const;
	const double  getUpperBound() const;
	const double  getNominal() const;

	const std::vector<Instanc> getClique() const;
};

%extend Instanc{
	const char *__repr__(){
		return self->getName().toString();
	}
	%pythoncode {
		def getSetValue(self):
			if self.isSetInt():
				return self.getSetIntValue()
			elif self.isSetString():
				return self.getSetStringValue()
			elif self.isSetEmpty():
				return set()
			else:
				raise RuntimeError("getSetValue: unknown set type");

		def getValue(self):
			# print "GETTING VALUE OF %s" % self.getName()
			if self.isCompound():
				return ""
			elif self.isRelation():
				return self.getResidual()
			elif self.isWhen():
				return "WHEN"
			elif self.isSet():
				_s = set(self.getSetValue());
				#for _v in self.getSetValue():
				#	_s.add( _v )
				return _s

			elif ( self.isAtom() or self.isFund() ) and not self.isDefined():
				return "undefined"
			elif self.isReal():
				return self.getRealValueAndUnits()
			elif self.isBool():
				return self.getBoolValue()
			elif self.isInt():
				return self.getIntValue()
			elif self.isSymbol():
				return self.getSymbolValue()
			else:
				return "UNKNOWN TYPE" #raise RuntimeError("Unknown value model type="+self.getType().getName().toString()+", instance kind=".getKindStr())

		def getRealValueAndUnits(self):
			if not self.isReal():
				raise TypeError
			if self.isDimensionless():
				return self.getRealValue();
			_u = self.getType().getPreferredUnits();
			if _u == None:
				return str(self.getRealValue()) + ' ' + self.getDimensions().getDefaultUnits().getName().toString()
			return _u.getConvertedValue(self.getRealValue())

		def setFixedValue(self,val):
			if not self.isFixed():
				self.setFixed();
			# getReporter().reportError("Setting value of %s to %s" % (self.getName().toString(),val))
			self.setRealValue(val);
	}
}

%include "config.h"
%include "registry.h"

%include "solver.i"

class ExtMethod{
public:
	ExtMethod(const ExtMethod &);
	const char *getName() const;
	const char *getHelp() const;
	const unsigned long getNumInputs() const;
	const unsigned long getNumOutputs() const;
};

%include "plot.i"

class Curve : public Instanc{

public:
	std::vector<double> x;
	std::vector<double> y;
	const std::string getLegend() const;

};

1	johnpye	225	/* : set syntax=cpp : */
2	johnpye	132	/*
3			SWIG interface routines to read a file into the library
4			*/
5
6	johnpye	463	%module(directors=1) ascpy
7	johnpye	132
8	johnpye	340	%include <python/std_string.i>
9			%include <python/std_except.i>
10			%include <python/std_vector.i>
11	johnpye	669	%include <python/std_map.i>
12	johnpye	132
13			%{
14			#include "library.h"
15	johnpye	770	#include "compiler.h"
16	johnpye	132	#include "type.h"
17			#include "instance.h"
18			#include "variable.h"
19	johnpye	238	#include "relation.h"
20	johnpye	132	#include "name.h"
21			#include "reporter.h"
22			#include "simulation.h"
23			#include "solver.h"
24			#include "symchar.h"
25			#include "set.h"
26			#include "dimensions.h"
27			#include "units.h"
28	johnpye	212	#include "extmethod.h"
29	johnpye	175	#include "plot.h"
30			#include "curve.h"
31	johnpye	208	#include "solverparameters.h"
32	johnpye	307	#include "solverstatus.h"
33	johnpye	310	#include "solverreporter.h"
34	johnpye	233	#include "incidencematrix.h"
35	johnpye	869	#include "registry.h"
36	johnpye	132	%}
37
38			// All STL runtime_errors caught to Python
39
40			%exception {
41			try {
42			$action
43			}
44	johnpye	319	catch (std::range_error &e) {
45			SWIG_exception(SWIG_IndexError,e.what());
46			}
47	johnpye	132	catch (std::runtime_error &e) {
48			SWIG_exception(SWIG_RuntimeError,e.what());
49			}
50			}
51
52			// Import the preferences module
53			%pythoncode {
54			import preferences;
55			}
56
57			// Set-valued instance variable
58			%pythoncode {
59			class SetIter:
60			def __init__(self,set):
61			self.set=set
62			self.index=0
63			def next(self):
64			if self.index==self.set.length():
65			raise StopIteration
66			self.index = self.index + 1
67			return self.set[self.index]
68			}
69
70			template<class T>
71			class ASCXX_Set{
72			private:
73			ASCXX_Set();
74			public:
75			const T at(const unsigned long&) const;
76			const unsigned long length() const;
77			};
78			%extend ASCXX_Set<long>{
79			%pythoncode {
80			def __getitem__(self, index):
81			return self.at(index)
82			def __iter__(self):
83			return SetIter(self)
84			}
85			}
86			%extend ASCXX_Set<SymChar>{
87			%pythoncode {
88			def __getitem__(self, index):
89			return self.at(index)
90			def __iter__(self):
91			return SetIter(self)
92			}
93			}
94
95
96			%template(ModuleVector) std::vector<Module>;
97			%template(TypeVector) std::vector<Type>;
98			%template(MethodVector) std::vector<Method>;
99			%template(InstancVector) std::vector<Instanc>;
100	johnpye	212	%template(ExtMethodVector) std::vector<ExtMethod>;
101	johnpye	132	%template(SetInt) ASCXX_Set<long>;
102			%template(SetString) ASCXX_Set<SymChar>;
103	johnpye	175	%template(DoubleVector) std::vector<double>;
104	johnpye	283	%template(IntVector) std::vector<int>;
105	johnpye	175	%template(CurveVector) std::vector<Curve>;
106	johnpye	223	%template(StringVector) std::vector<std::string>;
107	johnpye	669	%template(IntStringMap) std::map<int,std::string>;
108	johnpye	132
109			%rename(Instance) Instanc;
110	johnpye	233	%rename(Name) Nam;#include "incidencematrix.h"
111	johnpye	132	%rename(getSetIntValue) Instanc::getSetValue<long>;
112			%rename(getSetStringValue) Instanc::getSetValue<SymChar>;
113			%rename(Units) UnitsM;
114	johnpye	869	%rename(set) Registry::setPyObject;
115	johnpye	132
116
117			// Grab a Python function object as a Python object.
118	johnpye	341	%typemap(in) PyObject *pyfunc {
119	johnpye	278	if (!PyCallable_Check($input)) {
120	johnpye	132	PyErr_SetString(PyExc_TypeError, "Need a callable object!");
121			return NULL;
122			}
123	johnpye	278	$1 = $input;
124	johnpye	132	}
125
126			//----------------------------
127			// REPORTER: callbacks to python
128			class Reporter{
129			private:
130			~Reporter();
131			Reporter();
132			public:
133			// use 'getReporter' instead of 'Reporter::Instance()' in python
134			void setErrorCallback(error_reporter_callback_t callback, void *client_data);
135			void setPythonErrorCallback(PyObject *pyfunc);
136			void clearPythonErrorCallback();
137			};
138
139			%extend Reporter {
140			void reportError(const char *msg){
141	johnpye	529	ERROR_REPORTER_NOLINE(ASC_USER_ERROR,"%s", msg);
142	johnpye	132	}
143			void reportNote(const char *msg){
144	johnpye	529	ERROR_REPORTER_NOLINE(ASC_USER_NOTE,"%s",msg);
145	johnpye	132	}
146			void reportWarning(const char *msg){
147	johnpye	529	ERROR_REPORTER_NOLINE(ASC_USER_WARNING,"%s",msg);
148	johnpye	132	}
149			void reportSuccess(const char *msg){
150	johnpye	529	ERROR_REPORTER_NOLINE(ASC_USER_SUCCESS,"%s",msg);
151	johnpye	132	}
152			}
153
154			// There are problems with Instance(), so use this instead:
155			Reporter *getReporter();
156
157			//----------------------------------------
158			// UNITS AND DIMENSIONS
159
160
161			class UnitsM;
162
163			class Dimensions{
164			public:
165			static const unsigned MAX_DIMS;
166			static const std::string getBaseUnit(const unsigned &);
167
168			const bool operator==(const Dimensions &) const;
169			const bool operator!=(const Dimensions &) const;
170			const bool operator<(const Dimensions &) const;
171			Dimensions(const Dimensions &);
172			const bool isWild() const;
173			const bool isDimensionless() const;
174			const short getFractionNumerator(const unsigned &) const;
175			const short getFractionDenominator(const unsigned &) const;
176			};
177
178			class UnitsM{
179			public:
180			UnitsM(const char *);
181			const SymChar getName() const; // the units description string eg 'bar' or 'kJ/kg/K'
182			const Dimensions getDimensions() const;
183			const double getConversion() const; // multiplication factor to convert eg feet to SI (metres)
184			};
185
186			%extend UnitsM{
187			%pythoncode{
188			def getConvertedValue(self,si_value):
189			_u_value = si_value / self.getConversion()
190			return str(_u_value) + " " + self.getName().toString();
191			}
192			}
193
194			/*
195			This function creates default (SI) units for any dimension given. Most
196			of the time you will want to use custom units in place of these, eg
197			'N' instead of 'kg*m/s^2'.
198			*/
199			%extend Dimensions{
200			%pythoncode {
201
202			def getDefaultUnits(self):
203			if self.isDimensionless():
204			return Units("");
205
206			if self.isWild():
207			return Units("?");
208
209			# create a string representation of the current dimensions
210			numparts=[]
211			denparts=[]
212			for i in range(0, self.MAX_DIMS):
213			baseunit = self.getBaseUnit(i);
214			num = self.getFractionNumerator(i)
215			den = self.getFractionDenominator(i)
216			if num > 0:
217			if den == 1:
218			if num == 1:
219			numparts.append(baseunit)
220			else:
221			numparts.append("%s^%d" % (baseunit, num) )
222			else:
223			numparts.append("%s^(%d/%d)" % (baseunit, num, den) )
224			elif num < 0:
225			if den == 1:
226			if num == -1:
227			denparts.append(baseunit)
228			else:
229			denparts.append("%s^%d" % (baseunit, -num) )
230			else:
231			denparts.append("%s^(%d/%d)" % (baseunit, -num, den) )
232	johnpye	481
233	johnpye	132	if len(numparts):
234			str = "*".join(numparts)
235			else:
236			str = "1"
237	johnpye	481
238	johnpye	132	if len(denparts):
239			str = str + "/" + "/".join(denparts)
240
241			return Units(str)
242
243			}
244			}
245
246			/*
247			some python code for nice unicode unit strings, need to extend the units.c code as well though.
248
249			elif num == 2:
250			numparts.append(baseunit + ur'\u00b2')
251			elif num == 3:
252			numparts.append(baseunit + ur'\u00b3')
253
254			str = ur'\u00b7'.join(numparts)
255			*/
256			//----------------------------
257
258			class Library{
259			public:
260	johnpye	481	Library(const char *defaultpath=NULL);
261	johnpye	132	~Library();
262
263			void load(char *filename);
264			void listModules(const int &module_type=0);
265			Type &findType(const char *name);
266			std::vector<Module> getModules();
267			std::vector<Type> getModuleTypes(const Module &);
268	johnpye	212	std::vector<ExtMethod> getExtMethods();
269	johnpye	132	void clear();
270			};
271
272			class SymChar{
273			public:
274			SymChar(const std::string &);
275			const char *toString() const;
276			};
277			%extend SymChar{
278			const char *__repr__(){
279			return self->toString();
280			}
281			}
282
283			class Module{
284			public:
285			const char *getName() const;
286			const char *getFilename() const;
287			const struct tm *getMtime() const;
288			};
289
290			class Method{
291			public:
292			const char *getName() const;
293			};
294
295			// Renamed in python as 'Name'
296			class Nam{
297			public:
298			Nam(const SymChar &);
299			const std::string getName() const;
300			};
301
302	johnpye	770	%include "compiler.h"
303			/* we can always disown Compiler * as it's a singleton */
304			%apply SWIGTYPE DISOWN { Compiler };
305
306	johnpye	132	class Type{
307			public:
308			const SymChar getName();
309			const int getParameterCount();
310			Simulation getSimulation(const char *name);
311			std::vector<Method> getMethods();
312			const bool isRefinedSolverVar() const;
313			const bool isRefinedReal() const;
314			const Dimensions getDimensions() const;
315	johnpye	355	const bool hasParameters() const;
316	johnpye	132	};
317			%extend Type{
318			const char *__repr__(){
319			return self->getName().toString();
320			}
321
322			%pythoncode{
323			def getPreferredUnits(self):
324			if not self.isRefinedReal():
325			return None
326
327			_pref = preferences.Preferences()
328			#print "Checking for preferred units for %s" % self.getName()
329			_u = _pref.getPreferredUnits(self.getName().toString())
330			if _u == None:
331			# no preferred units set
332			return None
333			_units = Units(_u);
334	johnpye	481
335	johnpye	132	if _units.getDimensions() != self.getDimensions():
336			getReporter().reportWarning("Preferred units '%s' for type '%s' are not dimensionally correct: ignoring." % (_u, self.getName()) );
337			return None
338	johnpye	481
339	johnpye	132	return _units;
340			}
341			}
342
343	johnpye	255	typedef enum{
344	johnpye	258	ASCXX_VAR_STATUS_UNKNOWN=0, ASCXX_VAR_FIXED, ASCXX_VAR_UNSOLVED, ASCXX_VAR_ACTIVE, ASCXX_VAR_SOLVED
345	johnpye	255	} VarStatus;
346
347	johnpye	132	class Instanc{
348			private:
349			Instanc();
350			public:
351			Instanc(Instance *);
352			Instanc(Instance *, SymChar &name);
353	johnpye	732	~Instanc();
354	johnpye	132	std::vector<Instanc> getChildren();
355			const std::string getKindStr() const;
356			const SymChar &getName();
357			const Type getType() const;
358			const bool isAtom() const;
359			const bool isFixed() const;
360	johnpye	808	const bool isActive() const;
361	johnpye	132	const bool isFund() const;
362			const bool isConst() const;
363			const bool isAssigned() const;
364			const bool isCompound() const;
365			const bool isRelation() const;
366	johnpye	799	const bool isLogicalRelation() const;
367	johnpye	132	const bool isWhen() const;
368			const bool isSet() const; // a set (group) of things
369			const bool isSetInt() const;
370			const bool isSetString() const;
371			const bool isSetEmpty() const;
372			const bool isDefined() const;
373			const bool isBool() const;
374			const bool isInt() const;
375			const bool isSymbol() const;
376			const bool isReal() const;
377	johnpye	774	const bool isModel() const;
378
379	johnpye	132	const double getRealValue() const;
380			const bool isDimensionless() const;
381			const Dimensions getDimensions() const;
382			const bool getBoolValue() const;
383			const long getIntValue() const;
384			const SymChar getSymbolValue() const;
385	johnpye	207	const std::string getValueAsString() const; ///< Use carefully: rounding will occur for doubles!
386	johnpye	273
387	johnpye	215	const std::string getRelationAsString(const Instanc &relative_to) const;
388	johnpye	273	const double getResidual() const;
389
390	johnpye	176	Plot getPlot() const;
391
392	johnpye	172	const bool isPlottable() const;
393	johnpye	132	const ASCXX_Set<long> getSetValue<long>() const;
394			const ASCXX_Set<SymChar> getSetValue<SymChar>() const;
395			const bool isChildless() const;
396			void setFixed(const bool &val=true);
397			void setRealValue(const double &val);
398			void setRealValueWithUnits(const double &, const char *);
399			void setBoolValue(const bool &val);
400	johnpye	844	void setSymbolValue(const SymChar &sym);
401	johnpye	132	void write();
402	johnpye	255
403			const VarStatus getVarStatus() const;
404	johnpye	268
405			void setLowerBound(const double &);
406			void setUpperBound(const double &);
407			void setNominal(const double &);
408			const double getLowerBound() const;
409			const double getUpperBound() const;
410			const double getNominal() const;
411	johnpye	271
412	johnpye	732	const std::vector<Instanc> getClique() const;
413	johnpye	132	};
414
415			%extend Instanc{
416			const char *__repr__(){
417			return self->getName().toString();
418			}
419			%pythoncode {
420			def getSetValue(self):
421			if self.isSetInt():
422			return self.getSetIntValue()
423			elif self.isSetString():
424			return self.getSetStringValue()
425			elif self.isSetEmpty():
426			return set()
427			else:
428			raise RuntimeError("getSetValue: unknown set type");
429
430			def getValue(self):
431			# print "GETTING VALUE OF %s" % self.getName()
432			if self.isCompound():
433			return ""
434	johnpye	273	elif self.isRelation():
435			return self.getResidual()
436			elif self.isWhen():
437			return "WHEN"
438	johnpye	132	elif self.isSet():
439			_s = set(self.getSetValue());
440			#for _v in self.getSetValue():
441			# _s.add( _v )
442			return _s
443	johnpye	481
444	johnpye	132	elif ( self.isAtom() or self.isFund() ) and not self.isDefined():
445			return "undefined"
446			elif self.isReal():
447			return self.getRealValueAndUnits()
448			elif self.isBool():
449			return self.getBoolValue()
450			elif self.isInt():
451			return self.getIntValue()
452			elif self.isSymbol():
453			return self.getSymbolValue()
454			else:
455			return "UNKNOWN TYPE" #raise RuntimeError("Unknown value model type="+self.getType().getName().toString()+", instance kind=".getKindStr())
456
457			def getRealValueAndUnits(self):
458			if not self.isReal():
459			raise TypeError
460			if self.isDimensionless():
461			return self.getRealValue();
462			_u = self.getType().getPreferredUnits();
463			if _u == None:
464			return str(self.getRealValue()) + ' ' + self.getDimensions().getDefaultUnits().getName().toString()
465			return _u.getConvertedValue(self.getRealValue())
466
467			def setFixedValue(self,val):
468			if not self.isFixed():
469	johnpye	481	self.setFixed();
470	johnpye	132	# getReporter().reportError("Setting value of %s to %s" % (self.getName().toString(),val))
471			self.setRealValue(val);
472	johnpye	481	}
473	johnpye	132	}
474
475	johnpye	869	%include "config.h"
476			%include "registry.h"
477
478	johnpye	221	%include "solver.i"
479	johnpye	132
480	johnpye	212	class ExtMethod{
481	johnpye	132	public:
482	johnpye	212	ExtMethod(const ExtMethod &);
483	johnpye	132	const char *getName() const;
484			const char *getHelp() const;
485			const unsigned long getNumInputs() const;
486			const unsigned long getNumOutputs() const;
487			};
488
489	johnpye	176	%include "plot.i"
490	johnpye	175
491			class Curve : public Instanc{
492
493			public:
494			std::vector<double> x;
495			std::vector<double> y;
496			const std::string getLegend() const;
497
498			};
499