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