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