trunk/pygtk/type.cpp

#include <Python.h>

#include <iostream>
#include <stdexcept>
#include <string>
#include <sstream>
using namespace std;

extern "C"{
#include <utilities/ascConfig.h>
#include <utilities/ascSignal.h>
#include <general/dstring.h>
#include <compiler/instance_enum.h>
#include <compiler/fractions.h>

#include <compiler/dimen.h>
#include <compiler/symtab.h>
#include <compiler/instance_io.h>
#include <compiler/type_desc.h>
#include <compiler/bintoken.h>
#include <compiler/library.h>
#include <linear/mtx.h>
#include <system/calc.h>
#include <system/relman.h>
#include <system/slv_client.h>
#include <system/system.h>
#include <compiler/simlist.h>
}

#include "type.h"
#include "simulation.h"
#include "library.h"
#include "dimensions.h"
#include "name.h"
#include "compiler.h"

/**
    @TODO FIXME for some reason there are a lot of empty Type objects being created
*/
Type::Type(){
    //cerr << "CREATED EMPTY TYPE" << endl;
    // throw runtime_error("Type::Type: Can't create new Types via C++ interface");
}

Type::Type(const TypeDescription *t) : t(t){
    //cerr << "CREATED TYPE '" << getName() << "'" << endl;
}

const SymChar
Type::getName() const{
    if(t==NULL){
        throw runtime_error("Type::getName: t is NULL");
    }
    switch(GetBaseType(t)){
        case array_type:
            return SymChar("array");
        case relation_type:
            return SymChar("relation");
        case logrel_type:
            return SymChar("logrel");
        case when_type:
            return SymChar("when");     
        case set_type:
            return SymChar("set");
        default:
            symchar *sym = GetName(t);
            if(sym==NULL){
                throw runtime_error("Unnamed type");
            }
            return SymChar(SCP(sym));
    }
}

const int
Type::getParameterCount() const{
    return GetModelParameterCount(t);
}

const TypeDescription *
Type::getInternalType() const{
    return t;
}

const Dimensions
Type::getDimensions() const{
    if( isRefinedConstant() ){
        return Dimensions( GetConstantDimens(getInternalType()) );
    }else if( isRefinedReal() ){
        return Dimensions( GetRealDimens(getInternalType()) );
    }else{
    if( !isRefinedAtom() )throw runtime_error("Type::getDimensions: called with non-atom type");
        throw runtime_error("Type::getDimensions: unrecognised type");
    }
}

const bool
Type::isRefinedAtom() const{
    return BaseTypeIsAtomic(t);
}

const bool
Type::isRefinedReal() const{
    return BaseTypeIsReal(t);
}

const bool
Type::isRefinedConstant() const{
    return BaseTypeIsConstant(t);
}

/**
    Instantiate a type. This *can be* expensive, if you have selected to 
    compile your model into C-code and load a dynamic library with native
    machine-code versions of your equations.

    Once you have an instance of your model, you can start
    to eliminate variables and attempt to solve it, see Instanc.

    Note that there is some kind of dastardly underhand reference to the
    Compiler class implicit here: the model instantiation call refers to
    g_use_copyanon which is sort-of owned by the Compiler class.
*/
Simulation
Type::getSimulation(const SymChar &sym
        , const bool &rundefaultmethod
){
    /* notify the compiler of our bintoken options, if nec */
    Compiler::instance()->sendBinaryCompilationOptions();

    ERROR_REPORTER_HERE(ASC_PROG_NOTE,"Starting tree...\n");
    error_reporter_tree_start();
    /* ERROR_REPORTER_HERE(ASC_PROG_NOTE,"Started tree\n"); */

    Instance *i = SimsCreateInstance(getInternalType()->name, sym.getInternalType(), e_normal, NULL);
    Simulation sim(i,sym);

    bool has_error;
    if(error_reporter_tree_has_error()){
        has_error = TRUE;
    }else{
        has_error = FALSE;
    }

    error_reporter_tree_end();

    if(has_error){
        stringstream ss;
        ss << "Error(s) during instantiation of type '" << getName() << "'";
        throw runtime_error(ss.str());
    }else{
        ERROR_REPORTER_HERE(ASC_USER_NOTE,"Instantiated %s",SCP(getInternalType()->name));
    }

    if(i==NULL){
        throw runtime_error("Failed to create instance");
    }

    if(rundefaultmethod){
        CONSOLE_DEBUG("RUNNING DEFAULT METHOD");
        sim.runDefaultMethod();
    }

    return sim;
}

vector<Method>
Type::getMethods() const{
    vector<Method> v;
    struct gl_list_t *l = GetInitializationList(getInternalType());
    if(l==NULL) return v;
    for(int i=1, end=gl_length(l); i<=end; ++i){
        v.push_back(Method((struct InitProcedure *)gl_fetch(l,i)));
    }
    return v;
}

Method
Type::getMethod(const SymChar &name) const{
    if(GetBaseType(t)!=model_type){
        stringstream ss;
        ss << "Type '" << getName() << "' is not a MODEL";
        throw runtime_error(ss.str());
    }

    struct InitProcedure *m;
    m = FindMethod(t,name.getInternalType());

    if(m==NULL){
        stringstream ss;
        ss << "No method named '" << name << "' in type '" << getName() << "'";
        throw runtime_error(ss.str());
        return NULL;
    }

    return Method(m);
}   

const bool
Type::isRefinedSolverVar() const{
    const TypeDescription *solver_var_type;
    Type t1 = Library().findType(SymChar("solver_var"));
    solver_var_type=t1.getInternalType();

    if(MoreRefined(t, solver_var_type)==t){
        //cerr << getName() << " IS A REFINED SOLVER_VAR" << endl;
        return true;
    }
    //cerr << getName() << "IS *NOT* A REFINED SOLVER_VAR" << endl;
    return false;
}

const bool
Type::isFundamental() const{
    return CheckFundamental(getName().getInternalType());
}

const bool
Type::isModel() const{
    return GetBaseType(t) == model_type;
}

const bool
Type::hasParameters() const{
    return GetModelParameterCount(t) > 0;
}

bool
Type::operator<(const Type &other) const{
    // modelled on the Unit_CmpAtomName function from UnitsProc.c in Tcl code...
    if(!getInternalType() || !other.getInternalType() || this->isFundamental()){
        return false;
    }
    return (this->getName() < other.getName());
}


1	#include <Python.h>
2
3	#include <iostream>
4	#include <stdexcept>
5	#include <string>
6	#include <sstream>
7	using namespace std;
8
9	extern "C"{
10	#include <utilities/ascConfig.h>
11	#include <utilities/ascSignal.h>
12	#include <general/dstring.h>
13	#include <compiler/instance_enum.h>
14	#include <compiler/fractions.h>
15
16	#include <compiler/dimen.h>
17	#include <compiler/symtab.h>
18	#include <compiler/instance_io.h>
19	#include <compiler/type_desc.h>
20	#include <compiler/bintoken.h>
21	#include <compiler/library.h>
22	#include <linear/mtx.h>
23	#include <system/calc.h>
24	#include <system/relman.h>
25	#include <system/slv_client.h>
26	#include <system/system.h>
27	#include <compiler/simlist.h>
28	}
29
30	#include "type.h"
31	#include "simulation.h"
32	#include "library.h"
33	#include "dimensions.h"
34	#include "name.h"
35	#include "compiler.h"
36
37	/**
38	@TODO FIXME for some reason there are a lot of empty Type objects being created
39	*/
40	Type::Type(){
41	//cerr << "CREATED EMPTY TYPE" << endl;
42	// throw runtime_error("Type::Type: Can't create new Types via C++ interface");
43	}
44
45	Type::Type(const TypeDescription *t) : t(t){
46	//cerr << "CREATED TYPE '" << getName() << "'" << endl;
47	}
48
49	const SymChar
50	Type::getName() const{
51	if(t==NULL){
52	throw runtime_error("Type::getName: t is NULL");
53	}
54	switch(GetBaseType(t)){
55	case array_type:
56	return SymChar("array");
57	case relation_type:
58	return SymChar("relation");
59	case logrel_type:
60	return SymChar("logrel");
61	case when_type:
62	return SymChar("when");
63	case set_type:
64	return SymChar("set");
65	default:
66	symchar *sym = GetName(t);
67	if(sym==NULL){
68	throw runtime_error("Unnamed type");
69	}
70	return SymChar(SCP(sym));
71	}
72	}
73
74	const int
75	Type::getParameterCount() const{
76	return GetModelParameterCount(t);
77	}
78
79	const TypeDescription *
80	Type::getInternalType() const{
81	return t;
82	}
83
84	const Dimensions
85	Type::getDimensions() const{
86	if( isRefinedConstant() ){
87	return Dimensions( GetConstantDimens(getInternalType()) );
88	}else if( isRefinedReal() ){
89	return Dimensions( GetRealDimens(getInternalType()) );
90	}else{
91	if( !isRefinedAtom() )throw runtime_error("Type::getDimensions: called with non-atom type");
92	throw runtime_error("Type::getDimensions: unrecognised type");
93	}
94	}
95
96	const bool
97	Type::isRefinedAtom() const{
98	return BaseTypeIsAtomic(t);
99	}
100
101	const bool
102	Type::isRefinedReal() const{
103	return BaseTypeIsReal(t);
104	}
105
106	const bool
107	Type::isRefinedConstant() const{
108	return BaseTypeIsConstant(t);
109	}
110
111	/**
112	Instantiate a type. This can be expensive, if you have selected to
113	compile your model into C-code and load a dynamic library with native
114	machine-code versions of your equations.
115
116	Once you have an instance of your model, you can start
117	to eliminate variables and attempt to solve it, see Instanc.
118
119	Note that there is some kind of dastardly underhand reference to the
120	Compiler class implicit here: the model instantiation call refers to
121	g_use_copyanon which is sort-of owned by the Compiler class.
122	*/
123	Simulation
124	Type::getSimulation(const SymChar &sym
125	, const bool &rundefaultmethod
126	){
127	/* notify the compiler of our bintoken options, if nec */
128	Compiler::instance()->sendBinaryCompilationOptions();
129
130	ERROR_REPORTER_HERE(ASC_PROG_NOTE,"Starting tree...\n");
131	error_reporter_tree_start();
132	/* ERROR_REPORTER_HERE(ASC_PROG_NOTE,"Started tree\n"); */
133
134	Instance *i = SimsCreateInstance(getInternalType()->name, sym.getInternalType(), e_normal, NULL);
135	Simulation sim(i,sym);
136
137	bool has_error;
138	if(error_reporter_tree_has_error()){
139	has_error = TRUE;
140	}else{
141	has_error = FALSE;
142	}
143
144	error_reporter_tree_end();
145
146	if(has_error){
147	stringstream ss;
148	ss << "Error(s) during instantiation of type '" << getName() << "'";
149	throw runtime_error(ss.str());
150	}else{
151	ERROR_REPORTER_HERE(ASC_USER_NOTE,"Instantiated %s",SCP(getInternalType()->name));
152	}
153
154	if(i==NULL){
155	throw runtime_error("Failed to create instance");
156	}
157
158	if(rundefaultmethod){
159	CONSOLE_DEBUG("RUNNING DEFAULT METHOD");
160	sim.runDefaultMethod();
161	}
162
163	return sim;
164	}
165
166	vector<Method>
167	Type::getMethods() const{
168	vector<Method> v;
169	struct gl_list_t *l = GetInitializationList(getInternalType());
170	if(l==NULL) return v;
171	for(int i=1, end=gl_length(l); i<=end; ++i){
172	v.push_back(Method((struct InitProcedure *)gl_fetch(l,i)));
173	}
174	return v;
175	}
176
177	Method
178	Type::getMethod(const SymChar &name) const{
179	if(GetBaseType(t)!=model_type){
180	stringstream ss;
181	ss << "Type '" << getName() << "' is not a MODEL";
182	throw runtime_error(ss.str());
183	}
184
185	struct InitProcedure *m;
186	m = FindMethod(t,name.getInternalType());
187
188	if(m==NULL){
189	stringstream ss;
190	ss << "No method named '" << name << "' in type '" << getName() << "'";
191	throw runtime_error(ss.str());
192	return NULL;
193	}
194
195	return Method(m);
196	}
197
198	const bool
199	Type::isRefinedSolverVar() const{
200	const TypeDescription *solver_var_type;
201	Type t1 = Library().findType(SymChar("solver_var"));
202	solver_var_type=t1.getInternalType();
203
204	if(MoreRefined(t, solver_var_type)==t){
205	//cerr << getName() << " IS A REFINED SOLVER_VAR" << endl;
206	return true;
207	}
208	//cerr << getName() << "IS NOT A REFINED SOLVER_VAR" << endl;
209	return false;
210	}
211
212	const bool
213	Type::isFundamental() const{
214	return CheckFundamental(getName().getInternalType());
215	}
216
217	const bool
218	Type::isModel() const{
219	return GetBaseType(t) == model_type;
220	}
221
222	const bool
223	Type::hasParameters() const{
224	return GetModelParameterCount(t) > 0;
225	}
226
227	bool
228	Type::operator<(const Type &other) const{
229	// modelled on the Unit_CmpAtomName function from UnitsProc.c in Tcl code...
230	if(!getInternalType() \|\| !other.getInternalType() \|\| this->isFundamental()){
231	return false;
232	}
233	return (this->getName() < other.getName());
234	}
235
236