Branch data Line data Source code
1 : : /*
2 : : * equation.h - checker definitions for Qucs equations
3 : : *
4 : : * Copyright (C) 2004-2009 Stefan Jahn <stefan@lkcc.org>
5 : : *
6 : : * This is free software; you can redistribute it and/or modify
7 : : * it under the terms of the GNU General Public License as published by
8 : : * the Free Software Foundation; either version 2, or (at your option)
9 : : * any later version.
10 : : *
11 : : * This software is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with this package; see the file COPYING. If not, write to
18 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19 : : * Boston, MA 02110-1301, USA.
20 : : *
21 : : * $Id$
22 : : *
23 : : */
24 : :
25 : : #ifndef __EQUATION_H__
26 : : #define __EQUATION_H__
27 : :
28 : : #include "object.h"
29 : : #include "complex.h"
30 : : #include "vector.h"
31 : : #include "matrix.h"
32 : : #include "matvec.h"
33 : :
34 : : struct definition_t;
35 : :
36 : : namespace qucs {
37 : :
38 : : class strlist;
39 : : class dataset;
40 : : class range;
41 : :
42 : : namespace eqn {
43 : :
44 : : class solver;
45 : : class checker;
46 : : class constant;
47 : : class reference;
48 : : class assignment;
49 : : class application;
50 : :
51 : : enum NodeTag {
52 : : UNKNOWN = -1,
53 : : CONSTANT = 0, /* source code constant */
54 : : REFERENCE, /* variable reference */
55 : : APPLICATION, /* call to function */
56 : : ASSIGNMENT /* root of equation */
57 : : };
58 : :
59 : : /* The equation node base class defines and implements the basic
60 : : functionality of an equation node. Possible types of nodes are
61 : : listed in 'NodeTag'. */
62 : : class node
63 : : {
64 : : public:
65 : : node ();
66 : : node (int);
67 : : node (const node &);
68 : : virtual ~node ();
69 : 2938301 : node * getNext (void) { return next; }
70 : 257171 : void setNext (node * n) { next = n; }
71 : : int count (void);
72 : : void append (node *);
73 : : void appendNodes (node *);
74 : : void setDependencies (strlist *);
75 : : strlist * getDependencies (void);
76 : : void setDataDependencies (strlist *);
77 : 128660 : strlist * getDataDependencies (void) { return dataDependencies; }
78 : : void setDropDependencies (strlist * deps) { dropDependencies = deps; }
79 : : void addDropDependencies (char *);
80 : 127879 : strlist * getDropDependencies (void) { return dropDependencies; }
81 : 0 : void setPrepDependencies (strlist * deps) { prepDependencies = deps; }
82 : : void addPrepDependencies (char *);
83 : : void appendPrepDependencies (strlist *);
84 : 127892 : strlist * getPrepDependencies (void) { return prepDependencies; }
85 : : strlist * recurseDependencies (checker *, strlist *);
86 : : node * get (int);
87 : : constant * getResult (int);
88 : 327343 : int getType (void) { return type; }
89 : 24487 : int getTag (void) { return tag; }
90 : 133762 : void setType (int tag) { type = tag; }
91 : 1060112 : constant * getResult (void) { return res; }
92 : : nr_double_t getResultDouble (void);
93 : : nr_complex_t getResultComplex (void);
94 : : qucs::vector getResultVector (void);
95 : : void setResult (constant *);
96 : : char * getInstance (void);
97 : : void setInstance (const char *);
98 : : void applyInstance (void);
99 : : constant * calculate (void);
100 : : strlist * collectDependencies (void);
101 : : strlist * collectDataDependencies (void);
102 : :
103 : : /* These functions should be overloaded by derivative classes. */
104 : 0 : virtual void print (void) { }
105 : 129356 : virtual void addDependencies (strlist *) { }
106 : 0 : virtual int evalType (void) { return type; }
107 : 0 : virtual char * toString (void) { return txt; }
108 : 0 : virtual constant * evaluate (void) { return res; }
109 : 0 : virtual node * differentiate (char *) { return this; }
110 : 0 : virtual node * recreate (void) { return new node (*this); }
111 : 0 : virtual void replace (char *, char *) { }
112 : :
113 : : public:
114 : : int duplicate;
115 : : int cycle;
116 : : int evalPossible;
117 : : int skip;
118 : : char * txt;
119 : : int evaluated;
120 : : char * instance;
121 : : int output;
122 : : int dropdeps;
123 : : solver * solvee;
124 : : checker * checkee;
125 : :
126 : : private:
127 : : int type;
128 : : int tag;
129 : : node * next;
130 : : strlist * dependencies;
131 : : constant * res;
132 : : strlist * dataDependencies;
133 : : strlist * dropDependencies;
134 : : strlist * prepDependencies;
135 : : };
136 : :
137 : : enum ConstantTag {
138 : : TAG_UNKNOWN = 0,
139 : : TAG_DOUBLE = 1, /* double constant */
140 : : TAG_COMPLEX = 2, /* complex value */
141 : : TAG_VECTOR = 4, /* list of complex values */
142 : : TAG_MATRIX = 8, /* complex matrix */
143 : : TAG_MATVEC = 16, /* list of complex matrices */
144 : : TAG_CHAR = 32, /* single character */
145 : : TAG_STRING = 64, /* character string */
146 : : TAG_RANGE = 128, /* interval specification */
147 : : TAG_BOOLEAN = 256, /* boolean value */
148 : : };
149 : :
150 : : /* This class represents any type of constant expression. */
151 : : class constant : public node
152 : : {
153 : : public:
154 : : constant ();
155 : : constant (int);
156 : : constant (const constant &);
157 : : ~constant ();
158 : : void print (void);
159 : : int evalType (void);
160 : : char * toString (void);
161 : : constant * evaluate (void);
162 : : node * differentiate (char *);
163 : : node * recreate (void);
164 : :
165 : : public:
166 : : bool dataref;
167 : : int type;
168 : : union {
169 : : nr_double_t d;
170 : : nr_complex_t * c;
171 : : qucs::vector * v;
172 : : matrix * m;
173 : : matvec * mv;
174 : : char chr;
175 : : char * s;
176 : : range * r;
177 : : bool b;
178 : : };
179 : : };
180 : :
181 : : /* The class represents variable references. */
182 : : class reference : public node
183 : : {
184 : : public:
185 : : reference ();
186 : : reference (const reference &);
187 : : ~reference ();
188 : : void print (void);
189 : : void addDependencies (strlist *);
190 : : void findVariable (void);
191 : : int evalType (void);
192 : : char * toString (void);
193 : : constant * evaluate (void);
194 : : node * differentiate (char *);
195 : : node * recreate (void);
196 : : void replace (char *, char *);
197 : :
198 : : public:
199 : : char * n;
200 : : node * ref;
201 : : };
202 : :
203 : : /* This class represents assignments with a left hand and right hand
204 : : side. */
205 : : class assignment : public node
206 : : {
207 : : public:
208 : : assignment ();
209 : : assignment (const assignment &);
210 : : ~assignment ();
211 : : void print (void);
212 : : void addDependencies (strlist *);
213 : : int evalType (void);
214 : : char * toString (void);
215 : : constant * evaluate (void);
216 : : node * differentiate (char *);
217 : : node * recreate (void);
218 : : void replace (char *, char *);
219 : : void rename (char *);
220 : : void mul (assignment *);
221 : : void add (assignment *);
222 : : void mulref (assignment *);
223 : :
224 : : public:
225 : : char * result;
226 : : node * body;
227 : : };
228 : :
229 : : // Type of application function.
230 : : typedef constant * (* evaluator_t) (constant *);
231 : :
232 : : // Type of derivative function.
233 : : typedef node * (* differentiator_t) (application *, char *);
234 : :
235 : : /* The application class represents any kind of operation (unary,
236 : : binary and n-ary ones) containing the appropriate argument list. */
237 : : class application : public node
238 : : {
239 : : public:
240 : : application ();
241 : : application (const application &);
242 : : application (const char *, int);
243 : : ~application ();
244 : : void print (void);
245 : : void addDependencies (strlist *);
246 : : int evalType (void);
247 : : char * toString (void);
248 : : constant * evaluate (void);
249 : : node * differentiate (char *);
250 : : node * recreate (void);
251 : : void replace (char *, char *);
252 : :
253 : : public:
254 : : char * n;
255 : : int nargs;
256 : : node * args;
257 : : node * ddx;
258 : : evaluator_t eval;
259 : : differentiator_t derive;
260 : :
261 : : private:
262 : : void evalTypeArgs (void);
263 : : char * createKey (void);
264 : : int evalTypeFast (void);
265 : : int findDifferentiator (void);
266 : : };
267 : :
268 : : /* This class implements the actual functionality regarding a set of
269 : : equations stored within a netlist. */
270 : : class checker
271 : : {
272 : : public:
273 : : checker ();
274 : : ~checker ();
275 : : void collectDependencies (void);
276 : : void collectDependencies (node *);
277 : : void setEquations (node *);
278 : 56901 : node * getEquations (void) { return equations; }
279 : : void list (void);
280 : : int findUndefined (int);
281 : : static const char * tag2key (int);
282 : : static int isGenerated (char *);
283 : : strlist * getVariables (void);
284 : : int findDuplicate (void);
285 : : static node * findEquation (node *, const char * const);
286 : : int detectCycles (void);
287 : : static strlist * foldDependencies (strlist *);
288 : : node * appendEquation (node *, node *);
289 : : void dropEquation (node *);
290 : : void reorderEquations (void);
291 : : static node * lastEquation (node *);
292 : : int applyTypes (void);
293 : : int checkExport (void);
294 : : void constants (void);
295 : : int check (int noundefined = 1);
296 : : strlist * variables (void);
297 : : node * addDouble (const char *, const char *, nr_double_t);
298 : : node * createDouble (const char *, const char *, nr_double_t);
299 : : node * addComplex (const char *, const char *, nr_complex_t);
300 : : node * createComplex (const char *, const char *, nr_complex_t);
301 : : node * addReference (const char *, const char *, char *);
302 : : node * createReference (const char *, const char *, char *);
303 : : void appendEquation (node *);
304 : : void addEquation (node *);
305 : : node * findEquation (const char *
306 : : const) const;
307 : : bool containsVariable (const char * const) const;
308 : : nr_double_t getDouble (const char *const) const;
309 : : void setDouble (const char *const, nr_double_t);
310 : : qucs::vector getVector (const char * const) const;
311 : 23303 : void setDefinitions (struct definition_t * d) { defs = d; }
312 : : struct definition_t * getDefinitions (void) { return defs; }
313 : : node * findProperty (char *);
314 : :
315 : : public:
316 : : node * equations;
317 : :
318 : : private:
319 : : bool consts;
320 : : struct definition_t * defs;
321 : : };
322 : :
323 : : /* The solver class is finally used to solve the list of equations. */
324 : : class solver
325 : : {
326 : : public:
327 : : solver (checker *);
328 : : ~solver ();
329 : 23187 : void setEquations (node * eqn) { equations = eqn; }
330 : 23187 : node * getEquations (void) { return equations; }
331 : 23187 : void setData (dataset * d) { data = d; }
332 : : dataset * getDataset (void) { return data; }
333 : : void evaluate (void);
334 : : node * addEquationData (qucs::vector *, bool ref = false);
335 : : node * addEquationData (matvec *);
336 : : node * addGeneratedEquation (qucs::vector *, const char *);
337 : : qucs::vector * dataVector (node *);
338 : : void checkinDataset (void);
339 : : void checkoutDataset (void);
340 : : static int dataSize (constant *);
341 : : int getDependencySize (strlist *, int);
342 : : int getDataSize (char *);
343 : : strlist * collectDataDependencies (node *);
344 : : int dataSize (strlist *);
345 : : qucs::vector * getDataVector (char *);
346 : : void findMatrixVectors (qucs::vector *);
347 : : char * isMatrixVector (char *, int&, int&);
348 : : int findEquationResult (node *);
349 : : int solve (dataset *);
350 : :
351 : : public:
352 : : node * equations;
353 : :
354 : : private:
355 : : dataset * data;
356 : : int generated;
357 : : checker * checkee;
358 : : };
359 : :
360 : : } /* namespace eqn */
361 : :
362 : : } // namespace qucs
363 : :
364 : : #endif /* __EQUATION_H__ */
|
