150bd1fc3ef492877cba1e5f143d578b82a38f8e
[scilab.git] / scilab / modules / scicos_blocks / includes / scicos_block4.h
1 /*  Scicos
2 *
3 *  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 *
19 * See the file ./license.txt
20 */
21
22 #ifndef __SCICOS_BLOCK4_H__
23 #define __SCICOS_BLOCK4_H__
24
25 #ifndef NULL
26 #define NULL 0
27 #endif
28
29 #include <math.h>
30 #include <assert.h>
31 #include <stdlib.h>
32
33 #ifdef _MSC_VER
34 typedef void (*voidg) ();
35 #else
36 typedef void (*voidg) (void);
37 #endif
38
39 /* scicos_block structure definition
40 * WARNING: take care that this sructure is
41 * not the same as the one in scicos_block.h
42 * i.e same name but inptr and outptr are void **
43 */
44 typedef struct
45 {
46     int nevprt;
47     voidg funpt;
48     int type;
49     void* scsptr;
50     int nz;
51     double *z;
52     int noz;
53     int *ozsz;
54     int *oztyp;
55     void **ozptr;
56     int nx;
57     double *x;
58     double *xd;
59     double *res;
60     int *xprop;
61     int nin;
62     int *insz;
63     void **inptr;
64     int nout;
65     int *outsz;
66     void **outptr;
67     int nevout;
68     double *evout;
69     int nrpar;
70     double *rpar;
71     int nipar;
72     int *ipar;
73     int nopar;
74     int *oparsz;
75     int *opartyp;
76     void **oparptr;
77     int ng;
78     double *g;
79     int ztyp;
80     int *jroot;
81     char *label;
82     void **work;
83     int nmode;
84     int *mode;
85     char *uid;
86 } scicos_block;
87
88 /** define scicos flag number */
89 typedef enum
90 {
91     /* Should not be used directly, set through the API. */
92     CosError = -5,
93
94     /* Valid simulation states */
95     DerivativeState = 0,
96     OutputUpdate = 1,
97     StateUpdate = 2,
98     OutputEventTiming = 3,
99     Initialization = 4,
100     Ending = 5,
101     ReInitialization = 6,
102     ContinuousPropertiesUpdate = 7,
103     ZeroCrossing = 9,
104     Jacobian = 10
105 } scicos_flag;
106
107 /* utility function for block declaration */
108 int get_block_error(void);
109 int *get_pointer_xproperty(void);
110 int get_npointer_xproperty(void);
111 double Get_Jacobian_cj(void);
112 double Get_Jacobian_ci(void);
113 double Get_Scicos_SQUR(void);
114 void Set_Jacobian_flag(int flag);
115
116 int Convert_number(char *, double *);
117 void homotopy(double *);
118 int hfjac_(double *, double *, int *);
119 int rhojac_(double *, double *, double *, double *, int *, double *, int *);
120 int rho_(double *, double *, double *, double *, double *, int *);
121 int fx_(double *, double *);
122 int read_xml_initial_states(int nvar, const char *xmlfile, char **ids, double *svars);
123 int write_xml_states(int, const char *, char **, double *);
124
125 /** Define scicos simulator data type number (_N) */
126 typedef enum
127 {
128     SCSREAL_N = 10,
129     SCSCOMPLEX_N = 11,
130     SCSINT_N = 80,
131     SCSINT8_N = 81,
132     SCSINT16_N = 82,
133     SCSINT32_N = 84,
134     SCSUINT_N = 800,
135     SCSUINT8_N = 811,
136     SCSUINT16_N = 812,
137     SCSUINT32_N = 814,
138     SCSUNKNOW_N = -1
139 } scicos_datatype_number;
140
141 /* Define scicos simulator data type C operators (_COP) */
142 #define SCSREAL_COP double
143 #define SCSCOMPLEX_COP double
144 #define SCSINT_COP int
145 #define SCSINT8_COP char
146 #define SCSINT16_COP short
147 #define SCSINT32_COP int
148 #define SCSUINT_COP unsigned int
149 #define SCSUINT8_COP unsigned char
150 #define SCSUINT16_COP unsigned short
151 #define SCSUINT32_COP unsigned int
152 #define SCSUNKNOW_COP double
153
154 /** \name Getters
155  *  These macros should be used to ease programming and debugging of new blocks.
156  */
157 ///@{
158
159 /**
160 \brief Get number of regular input port.
161 */
162 #define GetNin(blk) (blk->nin)
163
164 /**
165 \brief Get regular input port pointer of port number x.
166 */
167 #define GetInPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->inptr[(x)-1])
168
169 /**
170 \brief Get number of regular output port.
171 */
172 #define GetNout(blk) (blk->nout)
173
174 /**
175 \brief Get regular output port pointer of port number x.
176 */
177 #define GetOutPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outptr[x-1])
178
179 /**
180 \brief Get number of rows (first dimension) of regular input port number x.
181 */
182 #define GetInPortRows(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->insz[x-1])
183
184 /**
185 \brief Get number of columns (second dimension) of regular input port number x.
186 */
187 #define GetInPortCols(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->insz[blk->nin+(x-1)])
188
189 /**
190 \brief Get regular input port size number x.
191 *   GetInPortSize(blk,x,1) : get first dimension of input port number x
192 *   GetInPortSize(blk,x,2) : get second dimension of input port number x
193 */
194 #define GetInPortSize(blk,x,y) (assert((x)>0), assert((x)<=(blk->nin)), \
195         assert((y)>0), assert((y)<=2), blk->insz[(y-1)*blk->nin+(x-1)])
196
197 /**
198 \brief Get type of regular input port number x.
199 */
200 #define GetInType(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), \
201         blk->insz[2*(blk->nin)+(x-1)])
202
203 /**
204 \brief Get number of rows (first dimension) of regular output port number x.
205 */
206 #define GetOutPortRows(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outsz[x-1])
207
208 /**
209 \brief Get number of columns (second dimension) of regular output port number x.
210 */
211 #define GetOutPortCols(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outsz[blk->nout+(x-1)])
212
213 /**
214 \brief Get regular output port size number x.
215 *   GetOutPortSize(blk,x,1) : get first dimension of output port number x
216 *   GetOutPortSize(blk,x,2) : get second dimension of output port number x
217 */
218 #define GetOutPortSize(blk,x,y) (assert((x)>0), assert((x)<=(blk->nout)), \
219     assert((y)>0), assert((y)<=2), blk->outsz[(y-1)*blk->nout+(x-1)])
220
221 /**
222 \brief Get type of regular output port number x.
223 */
224 #define GetOutType(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), \
225         blk->outsz[2*(blk->nout)+(x-1)])
226
227 /**
228 \brief Get pointer of real part of regular input port number x.
229 */
230 #define GetRealInPortPtrs(blk,x) (SCSREAL_COP *) GetInPortPtrs(blk,x)
231
232 /**
233 \brief Get pointer of imaginary part of regular input port number x.
234 */
235 #define GetImagInPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), \
236         (SCSREAL_COP *) ((SCSREAL_COP *)blk->inptr[x-1]+ \
237         ((blk->insz[(x-1)])*(blk->insz[blk->nin+(x-1)]))))
238
239 /**
240 \brief Get pointer of real part of regular output port number x.
241 */
242 #define GetRealOutPortPtrs(blk,x) (SCSREAL_COP *) GetOutPortPtrs(blk,x)
243
244 /**
245 \brief Get pointer of imaginary part of regular output port number x.
246 */
247 #define GetImagOutPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), \
248         (SCSREAL_COP *) ((SCSREAL_COP *)blk->outptr[x-1]+ \
249         ((blk->outsz[(x-1)])*(blk->outsz[blk->nout+(x-1)]))))
250
251 /**
252 \brief Get pointer of int8 typed regular input port number x.
253 */
254 #define Getint8InPortPtrs(blk,x) (SCSINT8_COP *) GetInPortPtrs(blk,x)
255
256 /**
257 \brief Get pointer of int16 typed regular input port number x.
258 */
259 #define Getint16InPortPtrs(blk,x) (SCSINT16_COP *) GetInPortPtrs(blk,x)
260
261 /**
262 \brief Get pointer of int32 typed regular input port number x.
263 */
264 #define Getint32InPortPtrs(blk,x) (SCSINT32_COP *) GetInPortPtrs(blk,x)
265
266 /**
267 \brief Get pointer of uint8 typed regular input port number x.
268 */
269 #define Getuint8InPortPtrs(blk,x) (SCSUINT8_COP *) GetInPortPtrs(blk,x)
270
271 /**
272 \brief Get pointer of uint16 typed regular input port number x.
273 */
274 #define Getuint16InPortPtrs(blk,x) (SCSUINT16_COP *) GetInPortPtrs(blk,x)
275
276 /**
277 \brief Get pointer of uint32 typed regular input port number x.
278 */
279 #define Getuint32InPortPtrs(blk,x) (SCSUINT32_COP *) GetInPortPtrs(blk,x)
280
281 /**
282 \brief Get pointer of int8 typed regular output port number x.
283 */
284 #define Getint8OutPortPtrs(blk,x) (SCSINT8_COP *) GetOutPortPtrs(blk,x)
285
286 /**
287 \brief Get pointer of int16 typed regular output port number x.
288 */
289 #define Getint16OutPortPtrs(blk,x) (SCSINT16_COP *) GetOutPortPtrs(blk,x)
290
291 /**
292 \brief Get pointer of int32 typed regular output port number x.
293 */
294 #define Getint32OutPortPtrs(blk,x) (SCSINT32_COP *) GetOutPortPtrs(blk,x)
295
296 /**
297 \brief Get pointer of uint8 typed regular output port number x.
298 */
299 #define Getuint8OutPortPtrs(blk,x) (SCSUINT8_COP *) GetOutPortPtrs(blk,x)
300
301 /**
302 \brief Get pointer of uint16 typed regular output port number x.
303 */
304 #define Getuint16OutPortPtrs(blk,x) (SCSUINT16_COP *) GetOutPortPtrs(blk,x)
305
306 /**
307 \brief Get pointer of uint32 typed regular output port number x.
308 */
309 #define Getuint32OutPortPtrs(blk,x) (SCSUINT32_COP *) GetOutPortPtrs(blk,x)
310
311 /**
312 \brief Get number of integer parameters.
313 */
314 #define GetNipar(blk) (blk->nipar)
315
316 /**
317 \brief Get pointer of the integer parameters register
318 */
319 #define GetIparPtrs(blk) (blk->ipar)
320
321 /**
322 \brief Get number of real parameters.
323 */
324 #define GetNrpar(blk) (blk->nrpar)
325
326 /**
327 \brief Get pointer of the real parameters register.
328 */
329 #define GetRparPtrs(blk) (blk->rpar)
330
331 /**
332 \brief Get the pointer of the Work array.
333 */
334 #define GetWorkPtrs(blk) (*(blk->work))
335
336 /**
337 \brief Get number of continuous state.
338 */
339 #define GetNstate(blk) (blk->nx)
340
341 /**
342 \brief Get pointer of the continuous state register.
343 */
344 #define GetState(blk) (blk->x)
345
346 /**
347 \brief Get pointer of the derivative continuous state register.
348 */
349 #define GetDerState(blk) (blk->xd)
350
351 /**
352 \brief Get pointer of the residual continuous state register.
353 */
354 #define GetResState(blk) (blk->res)
355
356 /**
357 \brief Get pointer of continuous state properties register.
358 */
359 #define GetXpropPtrs(blk) (blk->xprop)
360
361 /**
362 \brief Get number of discrete state.
363 */
364 #define GetNdstate(blk) (blk->nz)
365
366 /**
367 \brief Get pointer of the discrete state register.
368 */
369 #define GetDstate(blk) (blk->z)
370
371 /**
372 \brief Get the input event number.
373 */
374 #define GetNevIn(blk) (blk->nevprt)
375
376 /**
377 \brief Get number of event output port.
378 */
379 #define GetNevOut(blk) (blk->nevout)
380
381 /**
382 \brief Get pointer of event output register.
383 */
384 #define GetNevOutPtrs(blk) (blk->evout)
385
386 /**
387 \brief Get number of object parameters.
388 */
389 #define GetNopar(blk) (blk->nopar)
390
391 /**
392 \brief Get type of object parameters number x.
393 */
394 #define GetOparType(blk,x) (assert(x>0), assert(x<=blk->nopar), blk->opartyp[x-1])
395
396 /**
397 \brief Get size of object parameters number x.
398 *   GetOparSize(blk,x,1) : get first dimension of opar
399 *   GetOparSize(blk,x,2) : get second dimension of opar
400 */
401 #define GetOparSize(blk,x,y) (assert((x)>0), assert(x<=blk->nopar), \
402     assert((y)>0), assert((y)<=2), blk->oparsz[(y-1)*blk->nopar+(x-1)])
403
404 /**
405 \brief Get pointer of object parameters number x.
406 */
407 #define GetOparPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->nopar), (blk)->oparptr[(x)-1])
408
409 /**
410 \brief Get pointer of real object parameters number x.
411 */
412 #define GetRealOparPtrs(blk,x) (SCSREAL_COP *) GetOparPtrs(blk,x)
413
414 /**
415 \brief Get pointer of imaginary part of object parameters number x.
416 */
417 #define GetImagOparPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nopar)), \
418         (SCSREAL_COP *) ((SCSREAL_COP *)blk->oparptr[x-1]+ \
419         ((blk->oparsz[x-1])*(blk->oparsz[blk->nopar+(x-1)])))
420
421 /**
422 \brief Get pointer of int8 typed object parameters number x.
423 */
424 #define Getint8OparPtrs(blk,x) (SCSINT8_COP *) GetOparPtrs(blk,x)
425
426 /**
427 \brief Get pointer of int16 typed object parameters number x.
428 */
429 #define Getint16OparPtrs(blk,x) (SCSINT16_COP *) GetOparPtrs(blk,x)
430
431 /**
432 \brief Get pointer of int32 typed object parameters number x.
433 */
434 #define Getint32OparPtrs(blk,x) (SCSINT32_COP *) GetOparPtrs(blk,x)
435
436 /**
437 \brief Get pointer of uint8 typed object parameters number x.
438 */
439 #define Getuint8OparPtrs(blk,x) (SCSUINT8_COP *) GetOparPtrs(blk,x)
440
441 /**
442 \brief Get pointer of uint16 typed object parameters number x.
443 */
444 #define Getuint16OparPtrs(blk,x) (SCSUINT16_COP *) GetOparPtrs(blk,x)
445
446 /**
447 \brief Get pointer of uint32 typed object parameters number x.
448 */
449 #define Getuint32OparPtrs(blk,x) (SCSUINT32_COP *) GetOparPtrs(blk,x)
450
451 /**
452 \brief Get number of object state.
453 */
454 #define GetNoz(blk) (blk->noz)
455
456 /**
457 \brief Get type of object state number x.
458 */
459 #define GetOzType(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), (blk)->oztyp[(x)-1])
460
461 /**
462 \brief Get size of object state number x.
463 *   GetOzSize(blk,x,1) : get first dimension of oz
464 *   GetOzSize(blk,x,2) : get second dimension of oz
465 */
466 #define GetOzSize(blk,x,y) (assert((x)>0), assert((x)<=(blk)->noz), \
467         assert((y)>0), assert((y)<=2), (blk)->ozsz[((y)-1)*(blk)->noz+((x)-1)])
468
469 /**
470 \brief Get pointer of object state number x.
471 */
472 #define GetOzPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), (blk)->ozptr[(x)-1])
473
474 /**
475 \brief Get pointer of real object state number x.
476 */
477 #define GetRealOzPtrs(blk,x) (SCSREAL_COP *) GetOzPtrs(blk,x)
478
479 /**
480 \brief Get pointer of imaginary part of object state number x.
481 */
482 #define GetImagOzPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), \
483         (SCSREAL_COP *) ((SCSREAL_COP *)blk->ozptr[x-1]+ \
484         ((blk->ozsz[x-1])*(blk->ozsz[blk->noz+(x-1)])))
485
486 /**
487 \brief Get pointer of int8 typed object state number x.
488 */
489 #define Getint8OzPtrs(blk,x) (SCSINT8_COP *) GetOzPtrs(blk,x)
490
491 /**
492 \brief Get pointer of int16 typed object state number x.
493 */
494 #define Getint16OzPtrs(blk,x) (SCSINT16_COP *) GetOzPtrs(blk,x)
495
496 /**
497 \brief Get pointer of int32 typed object state number x.
498 */
499 #define Getint32OzPtrs(blk,x) (SCSINT32_COP *) GetOzPtrs(blk,x)
500
501 /**
502 \brief Get pointer of uint8 typed object state number x.
503 */
504 #define Getuint8OzPtrs(blk,x) (SCSUINT8_COP *) GetOzPtrs(blk,x)
505
506 /**
507 \brief Get pointer of uint16 typed object state number x.
508 */
509 #define Getuint16OzPtrs(blk,x) (SCSUINT16_COP *) GetOzPtrs(blk,x)
510
511 /**
512 \brief Get pointer of uint32 typed object state number x.
513 */
514 #define Getuint32OzPtrs(blk,x) (SCSUINT32_COP *) GetOzPtrs(blk,x)
515
516 /**
517 \brief Get the sizeof of the object state number x.
518 */
519 #define GetSizeOfOz(blk,x)    ((GetOzType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
520         (GetOzType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
521         ((GetOzType(blk,x)==SCSINT8_N)|(GetOzType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
522         ((GetOzType(blk,x)==SCSINT16_N)|(GetOzType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
523         ((GetOzType(blk,x)==SCSINT32_N)|(GetOzType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
524
525 /**
526 \brief Get the sizeof of the object parameters number x.
527 */
528 #define GetSizeOfOpar(blk,x)  ((GetOparType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
529         (GetOparType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
530         ((GetOparType(blk,x)==SCSINT8_N)|(GetOparType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
531         ((GetOparType(blk,x)==SCSINT16_N)|(GetOparType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
532         ((GetOparType(blk,x)==SCSINT32_N)|(GetOparType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
533
534 /**
535 \brief Get the sizeof of the regular output port number x.
536 */
537 #define GetSizeOfOut(blk,x)  ((GetOutType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
538         (GetOutType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
539         ((GetOutType(blk,x)==SCSINT8_N)|(GetOutType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
540         ((GetOutType(blk,x)==SCSINT16_N)|(GetOutType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
541         ((GetOutType(blk,x)==SCSINT32_N)|(GetOutType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
542 /**
543 \brief Get the sizeof of the regular input port number x.
544 */
545 #define GetSizeOfIn(blk,x)  ((GetInType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
546         (GetInType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
547         ((GetInType(blk,x)==SCSINT8_N)|(GetInType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
548         ((GetInType(blk,x)==SCSINT16_N)|(GetInType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
549         ((GetInType(blk,x)==SCSINT32_N)|(GetInType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
550
551 /**
552 \brief Get number of zero crossing surface.
553 */
554 #define GetNg(blk) (blk->ng)
555
556 /**
557 \brief Get pointer of the zero crossing register.
558 */
559 #define GetGPtrs(blk) (blk->g)
560
561 /**
562 \brief Get pointer of the direction of the zero crossing register.
563 */
564 #define GetJrootPtrs(blk) (blk->jroot)
565
566 /**
567 \brief Get number of modes.
568 */
569 #define GetNmode(blk) (blk->nmode)
570
571 /**
572 \brief Get pointer of the mode register.
573 */
574 #define GetModePtrs(blk) (blk->mode)
575
576 /**
577 \brief Get pointer of the block label
578 */
579 #define GetLabelPtrs(blk) (blk->label)
580
581 ///@}
582
583 #endif /* __SCICOS_BLOCK_H__ */
584