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"
#include <compiler/importhandler.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;

// 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();
	}
	Instanc __getattr__(const char *name){
		return self->getChild(SymChar(name));
	}
	double __float__(){
		if(self->isReal()){
			return self->getRealValue();
		}else{
			throw std::runtime_error("Can't cast this instance to float");
		}
	}
		
	%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);

		def __coerce__(self,other):
			return (self.getValue(),other.getValue())
	}
}

/*
	This 'registry' thing is a bit of a hack that allows interface pointers to 
	be registered with libascend so that they can be accessed from external
	script methods
*/
%include "registry.h"
%extend Registry{
	void set(const char *key, PyObject *obj){
		self->setPyObject(key,obj);
	}
}

%include "solver.i"

%include "extmethod.h"

%include "plot.i"

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