← Back to branch summary

~ubuntu-branches/ubuntu/hoary/scilab/hoary

« back to all changes in this revision

Viewing changes to routines/scicos/evaluate_expr.c

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2005-01-09 22:58:21 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050109225821-473xr8vhgugxxx5j
Tags: 3.0-12
http://bugs.debian.org/255869
changed configure.in to build scilab's own malloc.o, closes: #255869

Show diffs side-by-side

added added

removed removed

Lines of Context:
routines/scicos/evaluate_expr.c
 
1
#include "scicos_block.h"
 
2
#include <math.h>
 
3
#if WIN32
 
4
#include <float.h>
 
5
#endif
 
6
 
 
7
#if defined(solaris)
 
8
#include <ieeefp.h>
 
9
int isinf(double x) { return !finite(x) && x==x; }
 
10
#endif
 
11
 
 
12
#if WIN32
 
13
/*
 
14
arcsinh z = log (z+sqrt(1+z2))
 
15
*/
 
16
double asinh(double x)
 
17
{
 
18
  return log(x+sqrt(x*x+1));
 
19
}
 
20
 
 
21
double acosh(double x)
 
22
{
 
23
  return log(x+sqrt(x*x-1));
 
24
}
 
25
 
 
26
/* atanh(x)
 
27
 *      For x>=0.5
 
28
 *                  1              2x                          x
 
29
 *      atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * --------)
 
30
 *                  2             1 - x                      1 - x
 
31
 *      
 
32
 *      For x<0.5
 
33
 *      atanh(x) = 0.5*log1p(2x+2x*x/(1-x))
 
34
 *
 
35
 */
 
36
 
 
37
double atanh(double x)
 
38
{
 
39
        if (x >=0.5) 
 
40
        {
 
41
                return 0.5*log((1+x)/(1-x));
 
42
        }
 
43
        else
 
44
        {
 
45
                return 0.5*log((2*x)+(2*x)*x/(1-x));
 
46
        }
 
47
  
 
48
}
 
49
#endif
 
50
 
 
51
void evaluate_expr(scicos_block *block,int flag)
 
52
{
 
53
  static double stack [1000];
 
54
  static int count,bottom,nzcr,i,phase; 
 
55
  int j;  
 
56
  if (flag==1||flag==9){
 
57
    phase=get_phase_simulation();
 
58
    bottom=-1;
 
59
    count=-1;
 
60
    nzcr=-1;
 
61
    while (count<block->nipar-1){
 
62
      count=count+1;
 
63
      switch (block->ipar[count]) {
 
64
      case 2:
 
65
        count=count+1;
 
66
        bottom=bottom+1;
 
67
        if(bottom>999){
 
68
          set_block_error(-16);
 
69
          return;
 
70
        }
 
71
        if (block->nin>1){
 
72
          stack[bottom]=block->inptr[block->ipar[count]-1][0];
 
73
        }else{
 
74
          j=block->ipar[count]-1;
 
75
          if (j<block->insz[0]){
 
76
            stack[bottom]=block->inptr[0][block->ipar[count]-1];
 
77
          }else{
 
78
            stack[bottom]=0.;
 
79
          }
 
80
        }
 
81
        break;
 
82
      case 6:
 
83
        count=count+1;
 
84
        bottom=bottom+1;
 
85
        if(bottom>999){
 
86
          set_block_error(-16);
 
87
          return;
 
88
        }
 
89
        stack[bottom]=block->rpar[block->ipar[count]-1];
 
90
        break;
 
91
      case 5:
 
92
        count=count+1;
 
93
        switch (block->ipar[count]) {
 
94
        case 1:
 
95
          stack[bottom-1]=stack[bottom-1]+stack[bottom];
 
96
          bottom=bottom-1;
 
97
          break;
 
98
        case 2:
 
99
          stack[bottom-1]=stack[bottom-1]-stack[bottom];
 
100
          bottom=bottom-1;
 
101
          break;
 
102
        case 3:
 
103
          stack[bottom-1]=stack[bottom-1]*stack[bottom];
 
104
          bottom=bottom-1;
 
105
          break;
 
106
        case 7:
 
107
          stack[bottom-1]=stack[bottom-1]/stack[bottom];
 
108
          bottom=bottom-1;
 
109
          break;
 
110
        case 15:
 
111
          stack[bottom-1]=pow(stack[bottom-1],stack[bottom]);
 
112
          bottom=bottom-1;
 
113
          break;
 
114
        case 16: /* case == */
 
115
          if(block->ng>0) nzcr=nzcr+1;
 
116
          if (flag==9) {
 
117
            block->g[nzcr]=stack[bottom-1]-stack[bottom];
 
118
            if(phase==1) {
 
119
              block->mode[nzcr]=(stack[bottom-1]==stack[bottom]);
 
120
            }
 
121
          }
 
122
          if(phase==1||block->ng==0){
 
123
            i=(stack[bottom-1]==stack[bottom]);
 
124
          } else{
 
125
            i=block->mode[nzcr];
 
126
          }
 
127
          stack[bottom-1]=(double)i;
 
128
          bottom=bottom-1;
 
129
          break;
 
130
 
 
131
        case 17:
 
132
          if(block->ng>0) nzcr=nzcr+1;
 
133
          if (flag==9) {
 
134
            block->g[nzcr]=stack[bottom-1]-stack[bottom];
 
135
            if(phase==1) {
 
136
              block->mode[nzcr]=(stack[bottom-1]<stack[bottom]);
 
137
            }
 
138
          }
 
139
          if(phase==1||block->ng==0){
 
140
            i=(stack[bottom-1]<stack[bottom]);
 
141
          } else{
 
142
            i=block->mode[nzcr];
 
143
          }
 
144
          stack[bottom-1]=(double)i;
 
145
          bottom=bottom-1;
 
146
          break;
 
147
        case 18:
 
148
          if(block->ng>0) nzcr=nzcr+1;
 
149
          if (flag==9) {
 
150
            block->g[nzcr]=stack[bottom-1]-stack[bottom];
 
151
            if(phase==1) {
 
152
              block->mode[nzcr]=(stack[bottom-1]>stack[bottom]);
 
153
            }
 
154
          }
 
155
          if(phase==1||block->ng==0){
 
156
            i=(stack[bottom-1]>stack[bottom]);
 
157
          } else{
 
158
            i=block->mode[nzcr];
 
159
          }
 
160
          stack[bottom-1]=(double)i;
 
161
          bottom=bottom-1;
 
162
          break;
 
163
        case 19:
 
164
          if(block->ng>0) nzcr=nzcr+1;
 
165
          if (flag==9) {
 
166
            block->g[nzcr]=stack[bottom-1]-stack[bottom];
 
167
            if(phase==1) {
 
168
              block->mode[nzcr]=(stack[bottom-1]<=stack[bottom]);
 
169
            }
 
170
          }
 
171
          if(phase==1||block->ng==0){
 
172
            i=(stack[bottom-1]<=stack[bottom]);
 
173
          } else{
 
174
            i=block->mode[nzcr];
 
175
          }
 
176
          stack[bottom-1]=(double)i;
 
177
          bottom=bottom-1;
 
178
          break;
 
179
        case 20:
 
180
          if(block->ng>0) nzcr=nzcr+1;
 
181
          if (flag==9) {
 
182
            block->g[nzcr]=stack[bottom-1]-stack[bottom];
 
183
            if(phase==1) {
 
184
              block->mode[nzcr]=(stack[bottom-1]>=stack[bottom]);
 
185
            }
 
186
          }
 
187
          if(phase==1||block->ng==0){
 
188
            i=(stack[bottom-1]>=stack[bottom]);
 
189
          } else{
 
190
            i=block->mode[nzcr];
 
191
          }
 
192
          stack[bottom-1]=(double)i;
 
193
          bottom=bottom-1;
 
194
          break;
 
195
        case 21:
 
196
          if(block->ng>0) nzcr=nzcr+1;
 
197
          if (flag==9) {
 
198
            block->g[nzcr]=stack[bottom-1]-stack[bottom];
 
199
            if(phase==1) {
 
200
              block->mode[nzcr]=(stack[bottom-1]!=stack[bottom]);
 
201
            }
 
202
          }
 
203
          if(phase==1||block->ng==0){
 
204
            i=(stack[bottom-1]!=stack[bottom]);
 
205
          } else{
 
206
            i=block->mode[nzcr];
 
207
          }
 
208
          stack[bottom-1]=(double)i;
 
209
          bottom=bottom-1;
 
210
          break;
 
211
        case 28:
 
212
          if(block->ng>0) nzcr=nzcr+1;
 
213
          if (flag==9) {
 
214
            block->g[nzcr]=stack[bottom-1]-stack[bottom];
 
215
            if(phase==1) {
 
216
              block->mode[nzcr]=((int)stack[bottom-1]||(int)stack[bottom]);
 
217
            }
 
218
          }
 
219
          if(phase==1||block->ng==0){
 
220
            i=((int)stack[bottom-1]||(int)stack[bottom]);
 
221
          } else{
 
222
            i=block->mode[nzcr];
 
223
          }
 
224
          stack[bottom-1]=(double)i;
 
225
          bottom=bottom-1;
 
226
          break;
 
227
        case 29:
 
228
          if(block->ng>0) nzcr=nzcr+1;
 
229
          if (flag==9) {
 
230
            block->g[nzcr]=stack[bottom-1]-stack[bottom];
 
231
            if(phase==1) {
 
232
              block->mode[nzcr]=((int)stack[bottom-1]&&(int)stack[bottom]);
 
233
            }
 
234
          }
 
235
          if(phase==1||block->ng==0){
 
236
            i=((int)stack[bottom-1]&&(int)stack[bottom]);
 
237
          } else{
 
238
            i=block->mode[nzcr];
 
239
          }
 
240
          stack[bottom-1]=(double)i;
 
241
          bottom=bottom-1;
 
242
          break;
 
243
 
 
244
        case 30:
 
245
          if (flag==9) {
 
246
            block->g[nzcr]=stack[bottom];
 
247
            if(phase==1) {
 
248
              block->mode[nzcr]=(0.0==stack[bottom]);
 
249
            }
 
250
          }
 
251
          if(block->ng>0) nzcr=nzcr+1;
 
252
          if(phase==1||block->ng==0){
 
253
            i=(stack[bottom]==0.0);
 
254
          }else{
 
255
            i=block->mode[nzcr];
 
256
          }
 
257
          if (i){
 
258
            stack[bottom]=1.0;
 
259
          }else{
 
260
            stack[bottom]=0.0;   
 
261
          }
 
262
          break;
 
263
        case 99:
 
264
          stack[bottom]=-stack[bottom];
 
265
          break;
 
266
        case 101:
 
267
          stack[bottom]=sin(stack[bottom]);
 
268
          break;
 
269
        case 102:
 
270
          stack[bottom]=cos(stack[bottom]);
 
271
          break;
 
272
        case 103:
 
273
          stack[bottom]=tan(stack[bottom]);
 
274
          break;
 
275
        case 104:
 
276
          stack[bottom]=exp(stack[bottom]);
 
277
          break;
 
278
        case 105:
 
279
          stack[bottom]=log(stack[bottom]);
 
280
          break;
 
281
        case 106:
 
282
          stack[bottom]=sinh(stack[bottom]);
 
283
          break;
 
284
        case 107:
 
285
          stack[bottom]=cosh(stack[bottom]);
 
286
          break;
 
287
        case 108:
 
288
          stack[bottom]=tanh(stack[bottom]);
 
289
          break;
 
290
 
 
291
        case 109:
 
292
          if(block->ng>0) nzcr=nzcr+1;
 
293
          if (flag==9) {
 
294
            if (stack[bottom]>0) {
 
295
              i=(int)floor(stack[bottom]);
 
296
            }else{
 
297
              i=(int)ceil(stack[bottom]);
 
298
            }
 
299
            if(i==0)  {
 
300
              block->g[nzcr]=(stack[bottom]-1)*(stack[bottom]+1);
 
301
            }else if(i>0){
 
302
              block->g[nzcr]=(stack[bottom]-i-1.)*(stack[bottom]-i);
 
303
            }else{
 
304
              block->g[nzcr]=(stack[bottom]-i)*(stack[bottom]-i+1);
 
305
            }
 
306
            if(i%2)  block->g[nzcr]=-block->g[nzcr];
 
307
            if(phase==1) block->mode[nzcr]=i;
 
308
          }
 
309
          if(phase==1||block->ng==0){
 
310
            if (stack[bottom]>0) {
 
311
              stack[bottom]=floor(stack[bottom]);
 
312
            }else{
 
313
              stack[bottom]=ceil(stack[bottom]);
 
314
            }
 
315
          }else{
 
316
            stack[bottom]=(double) block->mode[nzcr];
 
317
          }
 
318
          break;
 
319
          /*
 
320
          if (stack[bottom]>0) {
 
321
            stack[bottom]=floor(stack[bottom]);
 
322
          }else{
 
323
            stack[bottom]=ceil(stack[bottom]);
 
324
            }*/
 
325
          break;
 
326
        case 110:
 
327
          if(block->ng>0) nzcr=nzcr+1;
 
328
          if (flag==9) {
 
329
            if (stack[bottom]>0) {
 
330
              i=(int)floor(stack[bottom]+.5);
 
331
            }else{
 
332
              i=(int)ceil(stack[bottom]-.5);
 
333
            }
 
334
            block->g[nzcr]=(stack[bottom]-i-.5)*(stack[bottom]-i+.5);
 
335
            if(i%2)  block->g[nzcr]=-block->g[nzcr];
 
336
            if(phase==1) block->mode[nzcr]=i;
 
337
          }
 
338
          if(phase==1||block->ng==0){
 
339
            if (stack[bottom]>0) {
 
340
              stack[bottom]=floor(stack[bottom]+.5);
 
341
            }else{
 
342
              stack[bottom]=ceil(stack[bottom]-.5);
 
343
            }
 
344
          }else{
 
345
            stack[bottom]=(double) block->mode[nzcr];
 
346
          }
 
347
          break;
 
348
          /*  if (stack[bottom]>0) {
 
349
            stack[bottom]=floor(stack[bottom]+.5);
 
350
          }else{
 
351
            stack[bottom]=ceil(stack[bottom]-.5);
 
352
          }*/
 
353
        case 111:
 
354
          if(block->ng>0) nzcr=nzcr+1;
 
355
          if (flag==9) {
 
356
            i=(int)ceil(stack[bottom]);
 
357
            block->g[nzcr]=(stack[bottom]-i)*(stack[bottom]-i+1);
 
358
            if(i%2)  block->g[nzcr]=-block->g[nzcr];
 
359
            if(phase==1) block->mode[nzcr]=i;
 
360
          }
 
361
          if(phase==1||block->ng==0){
 
362
            stack[bottom]=ceil(stack[bottom]);
 
363
          }else{
 
364
            stack[bottom]=(double) block->mode[nzcr];
 
365
          }
 
366
          break;
 
367
        case 112:
 
368
          if(block->ng>0) nzcr=nzcr+1;
 
369
          if (flag==9) {
 
370
            i=(int)floor(stack[bottom]);
 
371
            block->g[nzcr]=(stack[bottom]-i-1)*(stack[bottom]-i);
 
372
            if(i%2)  block->g[nzcr]=-block->g[nzcr];
 
373
            if(phase==1) block->mode[nzcr]=i;
 
374
          }
 
375
          if(phase==1||block->ng==0){
 
376
            stack[bottom]=floor(stack[bottom]);
 
377
          }else{
 
378
            stack[bottom]=(double) block->mode[nzcr];
 
379
          }
 
380
          break;
 
381
        case 113:
 
382
          if(block->ng>0) nzcr=nzcr+1;
 
383
          if (flag==9) {
 
384
            if (stack[bottom]>0) {
 
385
              i=1;
 
386
            }else if (stack[bottom]<0){
 
387
              i=-1;
 
388
            }else{
 
389
              i=0;
 
390
            }
 
391
            block->g[nzcr]=stack[bottom];
 
392
            if(phase==1) block->mode[nzcr]=i;
 
393
          }
 
394
          if(phase==1||block->ng==0){
 
395
            if (stack[bottom]>0) {
 
396
              stack[bottom]=1.0;
 
397
            }else if(stack[bottom]<0){
 
398
              stack[bottom]=-1.0;
 
399
            }else{
 
400
              stack[bottom]=0.0;
 
401
            }
 
402
          }else{
 
403
            stack[bottom]=(double) block->mode[nzcr];
 
404
          }
 
405
          break;
 
406
          /* if (stack[bottom]>0) {
 
407
            stack[bottom]=1.0;
 
408
          }else if(stack[bottom]<0){
 
409
            stack[bottom]=-1.0;
 
410
          }else{
 
411
            stack[bottom]=0.0;
 
412
            }*/
 
413
        case 114:  /* abs */
 
414
          if(block->ng>0) nzcr=nzcr+1;
 
415
          if (flag==9) {
 
416
            if (stack[bottom]>0) {
 
417
              i=1;
 
418
            }else if (stack[bottom]<0){
 
419
              i=-1;
 
420
            }else{
 
421
              i=0;
 
422
            }
 
423
            block->g[nzcr]=stack[bottom];
 
424
            if(phase==1) block->mode[nzcr]=i;
 
425
          }
 
426
          if(phase==1||block->ng==0){
 
427
            if (stack[bottom]>0) {
 
428
              stack[bottom]=stack[bottom];
 
429
            }else {
 
430
              stack[bottom]=-stack[bottom];
 
431
            }
 
432
          }else{
 
433
            stack[bottom]=stack[bottom]*(block->mode[nzcr]);
 
434
          }
 
435
          break;
 
436
          /* if (stack[bottom]>0) {
 
437
            stack[bottom]=stack[bottom];
 
438
          }else {
 
439
            stack[bottom]=-stack[bottom];
 
440
            }*/
 
441
        case 115:
 
442
          if(block->ng>0) nzcr=nzcr+1;
 
443
          if (flag==9) {
 
444
            if (stack[bottom]>stack[bottom-1]) {
 
445
              i=0;
 
446
            }else {
 
447
              i=1;
 
448
            }
 
449
            block->g[nzcr]=stack[bottom]-stack[bottom-1];
 
450
            if(phase==1) block->mode[nzcr]=i;
 
451
          }
 
452
          if(phase==1||block->ng==0){
 
453
            stack[bottom-1]=max(stack[bottom-1],stack[bottom]);
 
454
          }else{
 
455
            stack[bottom-1]=stack[bottom-block->mode[nzcr]];
 
456
          }
 
457
          bottom=bottom-1;
 
458
          break;
 
459
        case 116:
 
460
          if(block->ng>0) nzcr=nzcr+1;
 
461
          if (flag==9) {
 
462
            if (stack[bottom]<stack[bottom-1]) {
 
463
              i=0;
 
464
            }else {
 
465
              i=1;
 
466
            }
 
467
            block->g[nzcr]=stack[bottom]-stack[bottom-1];
 
468
            if(phase==1) block->mode[nzcr]=i;
 
469
          }
 
470
          if(phase==1||block->ng==0){
 
471
            stack[bottom-1]=min(stack[bottom-1],stack[bottom]);
 
472
          }else{
 
473
            stack[bottom-1]=stack[bottom-block->mode[nzcr]];
 
474
          }
 
475
          bottom=bottom-1;
 
476
          break;
 
477
        case 117:
 
478
          stack[bottom]=asin(stack[bottom]);
 
479
          break;
 
480
        case 118:
 
481
          stack[bottom]=acos(stack[bottom]);
 
482
          break;
 
483
        case 119:
 
484
          stack[bottom]=atan(stack[bottom]);
 
485
          break;
 
486
        case 120:
 
487
          stack[bottom]=asinh(stack[bottom]);
 
488
          break;
 
489
        case 121:
 
490
          stack[bottom]=acosh(stack[bottom]);
 
491
          break;
 
492
        case 122:
 
493
          stack[bottom]=atanh(stack[bottom]);
 
494
          break;
 
495
        case 123:
 
496
          stack[bottom-1]=atan2(stack[bottom-1],stack[bottom]);
 
497
          bottom=bottom-1;
 
498
          break;
 
499
 
 
500
        case 124:
 
501
          stack[bottom]=log10(stack[bottom]);
 
502
          break;
 
503
        }
 
504
      }
 
505
    }
 
506
    #if WIN32
 
507
    if(!_finite(stack[bottom])||_isnan(stack[bottom])){
 
508
    #else
 
509
     if(isinf(stack[bottom])||isnan(stack[bottom])){
 
510
    #endif
 
511
      set_block_error(-2);
 
512
      return;
 
513
    }else{
 
514
      block->outptr[0][0]=stack[bottom];
 
515
    }
 
516
  }
 
517
}