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