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