Overview
Comment:Octave version 2.1.x compatability and #ifdef statements for standalone rep
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | origin/master | trunk
Files: files | file ages | folders
SHA3-256: 6b01e9c0108a369a9b3871a0146a77ff47dc45c49c991f5099b171e8cb98f27b
User & Date: geraint@users.sourceforge.net on 2001-02-05 04:32:35
Other Links: branch diff | manifest | tags
Context
2001-02-05
08:32:31
typo check-in: bb0ed37feb user: geraint@users.sourceforge.net tags: origin/master, trunk
04:32:35
Octave version 2.1.x compatability and #ifdef statements for standalone rep check-in: 6b01e9c010 user: geraint@users.sourceforge.net tags: origin/master, trunk
04:23:09
Simplified. check-in: 89f987075f user: geraint@users.sourceforge.net tags: origin/master, trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified mttroot/mtt/bin/trans/make_ode2odes from [ebfab81400] to [c32cd07145]. 

1
2
3
4
5
6
7
8
9
10
11









12
13
14
15
16
17
18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27












+
+
+
+
+
+
+
+
+








#! /bin/sh

     ###################################### 
     ##### Model Transformation Tools #####
    ######################################

###############################################################
## Version control history
###############################################################
## $Id$
## $Log$
## Revision 1.46  2001/01/08 06:21:59  geraint
## #ifdef STANDALONE stuff
##
## Revision 1.45  2001/01/07 01:25:49  geraint
## Compatibility with Octave 2.1.33
##
## Revision 1.44  2000/12/05 12:11:45  peterg
## Changed function name to name()
##
## Revision 1.43  2000/12/04 10:59:40  peterg
## *** empty log message ***
##
## Revision 1.42  2000/11/10 14:19:50  peterg
## Corrected the csex and cseo functions
##
## Revision 1.41  2000/11/09 17:06:39  peterg
︙
238
239
240
241
242
243
244









245
246
247
248
249
250
251
252




253
254
255
256
















257
258
259
260
261
262
263
264



265

266

267
268
269
270
271
272
273
274
275
276



277

278

279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298



299

300

301
302
303
304
305
306
307
308
309
310
311
312
313
314
315



316

317

318
319
320
321
322
323
324
325
326
327
328
329
330







331
332
333
334
335
336
337
338
339







340
341
342
343
344
345
346










347
348
349
350
351
352
353
354

355
356
357
358
359
360
361
362
363
364
365
366
367
368







369
370
371
372
373
374
375
376
377
378
379
380
381







382
383
384
385
386
387
388
389
390
391







392
393
394
395
396
397
398
399
400
401
402
403
404
405







406
407
408
409
410
411
412
413
414


415

416
417

418
419
420
421
422
423
424

247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266




267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303

304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319

320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345

346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366

367
368
369
370
371
372
373
374
375
376
377



378
379
380
381
382
383
384
385
386
387
388
389
390



391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434



435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451



452
453
454
455
456
457
458
459
460
461
462
463
464
465



466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483



484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501

502
503

504
505
506
507
508
509
510
511








+
+
+
+
+
+
+
+
+




-
-
-
-
+
+
+
+




+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+








+
+
+

+
-
+










+
+
+

+
-
+




















+
+
+

+
-
+















+
+
+

+
-
+










-
-
-
+
+
+
+
+
+
+






-
-
-
+
+
+
+
+
+
+







+
+
+
+
+
+
+
+
+
+








+











-
-
-
+
+
+
+
+
+
+










-
-
-
+
+
+
+
+
+
+







-
-
-
+
+
+
+
+
+
+











-
-
-
+
+
+
+
+
+
+









+
+
-
+

-
+








endfunction

EOF
} # make_m

make_cc() 
{
# get octave version
octave_development=`octave --version | awk '{print $4}' | awk -F\. '{print $2}'`
if [ octave_development ]; then
    vector_value=column_vector_value
    feval_header=parse.h
else
    vector_value=vector_value
    feval_header=toplev.h
fi

cat <<EOF  > $filename
#include <octave/oct.h>

#include <octave/toplev.h>
#include <octave/LSODE.h>
#include <octave/ov-struct.h>
#include <octave/oct-map.h>
#include <octave/${feval_header}>
#include <octave/ov-struct.h>
#include <octave/oct-map.h>
#include <octave/lo-mappers.h>

#include "${sys}_def.h"
#include "${sys}_sympar.h"

#ifdef STANDALONE
#define DECLARE(name) extern octave_value_list F##name (const octave_value_list &, int);
DECLARE(mtt_euler)
DECLARE(mtt_implicit)
DECLARE(mtt_write)
DECLARE(${sys}_${ode})
DECLARE(${sys}_${odeo})
DECLARE(${sys}_input)
DECLARE(${sys}_numpar)
DECLARE(${sys}_simpar)
DECLARE(${sys}_smxa)
DECLARE(${sys}_smxax)
DECLARE(${sys}_state)
DECLARE(${sys}_logic)
#endif // STANDALONE

ColumnVector
mtt_${ode} (ColumnVector x, ColumnVector u, double t, ColumnVector par)
{
  octave_value_list args, f;
  args (0) = octave_value (x);
  args (1) = octave_value (u);
  args (2) = octave_value (t);
  args (3) = octave_value (par);
#ifdef STANDALONE
  f = F${sys}_${ode} (args, 1);
#else
  f = feval ("${sys}_${ode}", args, 1);
#endif
  return f(0).vector_value ();
  return f(0).${vector_value} ();
}

ColumnVector
mtt_${odeo} (ColumnVector x, ColumnVector u, double t, ColumnVector par)
{
  octave_value_list args, f;
  args (0) = octave_value (x);
  args (1) = octave_value (u);
  args (2) = octave_value (t);
  args (3) = octave_value (par);
#ifdef STANDALONE
  f = F${sys}_${odeo} (args, 1);
#else
  f = feval ("${sys}_${odeo}", args, 1);
#endif
  return f(0).vector_value ();
  return f(0).${vector_value} ();
}

// #define mtt_implicit(x,dx,AA,AAx,ddt,nx,open) call_mtt_implicit((x),(dx),(AA),(AAx),(ddt),(nx),(open))
ColumnVector
mtt_implicit (ColumnVector x,
		   ColumnVector dx,
		   Matrix AA,
		   ColumnVector AAx,
		   double ddt,
		   int nx,
		   ColumnVector open_switches)
{
  octave_value_list args, f;
  args (0) = octave_value (x);
  args (1) = octave_value (dx);
  args (2) = octave_value (AA);
  args (3) = octave_value (AAx);
  args (4) = octave_value (ddt);
  args (5) = octave_value ((double)nx);
  args (6) = octave_value (open_switches);
#ifdef STANDALONE
  f = Fmtt_implicit (args, 1);
#else
  f = feval ("mtt_implicit", args, 1);
#endif
  return f(0).vector_value ();
  return f(0).${vector_value} ();
}

ColumnVector
mtt_euler (ColumnVector x,
		   ColumnVector dx,
		   double ddt,
		   int nx,
		   ColumnVector open_switches)
{
  octave_value_list args, f;
  args (0) = octave_value (x);
  args (1) = octave_value (dx);
  args (2) = octave_value (ddt);
  args (3) = octave_value ((double)nx);
  args (4) = octave_value (open_switches);
#ifdef STANDALONE
  f = Fmtt_euler (args, 1);
#else
  f = feval ("mtt_euler", args, 1);
#endif
  return f(0).vector_value ();
  return f(0).${vector_value} ();
}

ColumnVector
mtt_input (ColumnVector x, ColumnVector y, const double t, ColumnVector par)
{
  octave_value_list args;
  args (0) = octave_value (x);
  args (1) = octave_value (y);
  args (2) = octave_value (t);
  args (3) = octave_value (par);
  ColumnVector f;
  f = feval ("${sys}_input", args, 1)(0).vector_value ();
  return (f);
  octave_value_list f;
#ifdef STANDALONE
  f = F${sys}_input (args, 1);
#else
  f = feval ("${sys}_input", args, 1);
#endif
  return f(0).${vector_value} ();
}

ColumnVector
mtt_numpar (void)
{
  octave_value_list args;
  ColumnVector f;
  f = feval ("${sys}_numpar", args, 1)(0).vector_value ();
  return (f);
  octave_value_list f;
#ifdef STANDALONE
  f = F${sys}_numpar (args, 1);
#else
  f = feval ("${sys}_numpar", args, 1);
#endif
  return f(0).${vector_value} ();
}

Octave_map
mtt_simpar (void)
{
  octave_value_list args;
  Octave_map f;
#ifdef STANDALONE
  f["first"]		= F${sys}_simpar (args, 1)(0).map_value ()["first"];
  f["dt"]		= F${sys}_simpar (args, 1)(0).map_value ()["dt"];
  f["last"]		= F${sys}_simpar (args, 1)(0).map_value ()["last"];
  f["stepfactor"]     	= F${sys}_simpar (args, 1)(0).map_value ()["stepfactor"];
  f["wmin"]		= F${sys}_simpar (args, 1)(0).map_value ()["wmin"];
  f["wmax"]		= F${sys}_simpar (args, 1)(0).map_value ()["wmax"];
  f["wsteps"]		= F${sys}_simpar (args, 1)(0).map_value ()["wsteps"];
  f["input"]		= F${sys}_simpar (args, 1)(0).map_value ()["input"];
#else
  f["first"]		= feval ("${sys}_simpar", args, 1)(0).map_value ()["first"];
  f["dt"]		= feval ("${sys}_simpar", args, 1)(0).map_value ()["dt"];
  f["last"]		= feval ("${sys}_simpar", args, 1)(0).map_value ()["last"];
  f["stepfactor"]     	= feval ("${sys}_simpar", args, 1)(0).map_value ()["stepfactor"];
  f["wmin"]		= feval ("${sys}_simpar", args, 1)(0).map_value ()["wmin"];
  f["wmax"]		= feval ("${sys}_simpar", args, 1)(0).map_value ()["wmax"];
  f["wsteps"]		= feval ("${sys}_simpar", args, 1)(0).map_value ()["wsteps"];
  f["input"]		= feval ("${sys}_simpar", args, 1)(0).map_value ()["input"];
#endif
  return (f);
}

Matrix
mtt_smxa (ColumnVector x, ColumnVector u, double t, ColumnVector par)
{
  octave_value_list args;
  args (0) = octave_value (x);
  args (1) = octave_value (u);
  args (2) = octave_value (t);
  args (3) = octave_value (par);
  Matrix f;
  f = feval ("${sys}_smxa", args, 1)(0).matrix_value ();
  return (f);
  octave_value_list f;
#ifdef STANDALONE
  f = F${sys}_smxa (args, 1);
#else
  f = feval ("${sys}_smxa", args, 1);
#endif
  return f(0).matrix_value ();
}

ColumnVector
mtt_smxax (ColumnVector x, ColumnVector u, double t, ColumnVector par)
{
  octave_value_list args;
  args (0) = octave_value (x);
  args (1) = octave_value (u);
  args (2) = octave_value (t);
  args (3) = octave_value (par);
  ColumnVector f;
  f = feval ("${sys}_smxax", args, 1)(0).vector_value ();
  return (f);
  octave_value_list f;
#ifdef STANDALONE
  f = F${sys}_smxax (args, 1);
#else
  f = feval ("${sys}_smxax", args, 1);
#endif
  return f(0).${vector_value} ();
}

ColumnVector
mtt_state (ColumnVector x)
{
  octave_value_list args;
  args (0) = octave_value (x);
  ColumnVector f;
  f = feval ("${sys}_state", args, 1)(0).vector_value ();
  return (f);
  octave_value_list f;
#ifdef STANDALONE
  f = F${sys}_state (args, 1);
#else
  f = feval ("${sys}_state", args, 1);
#endif
  return f(0).${vector_value} ();
}

ColumnVector
mtt_logic (ColumnVector x, ColumnVector u, double t, ColumnVector par)
{
  octave_value_list args;
  args (0) = octave_value (x);
  args (1) = octave_value (u);
  args (2) = octave_value (t);
  args (3) = octave_value (par);

  ColumnVector f;
  f = feval ("${sys}_logic", args, 1)(0).vector_value ();
  return (f);
  octave_value_list f;
#ifdef STANDALONE
  f = F${sys}_logic (args, 1);
#else
  f = feval ("${sys}_logic", args, 1);
#endif
  return f(0).${vector_value} ();
}


void
mtt_write (double t, ColumnVector x, ColumnVector y){
  octave_value_list args;
  args (0) = octave_value (t);
  args (1) = octave_value (x);
  args (2) = octave_value (y);
#ifdef STANDALONE
  Fmtt_write (args, 1);
  ColumnVector f;
#else
  feval ("mtt_write", args, 1);

#endif
}

//void
//mtt_write (double t, ColumnVector x, ColumnVector y, int nx, int ny)
//{
//  register int i;
//  cout.precision (5);		// this should be passed in as an argument
︙
449
450
451
452
453
454
455
456

457
458
459
460
461
462
463

536
537
538
539
540
541
542

543
544
545
546
547
548
549
550








-
+








	{
	  v (j) = v0 (i);
	  j++;
	}
    }
  return (j)
    ? v.extract (0, --j)
    : 0x0;
    : ColumnVector ();
}


DEFUN_DLD (${sys}_ode2odes, args, ,
"Octave ode2odes representation of system 
Usage: ${sys}_ode2odes (x, par, simpar)
")
︙
476
477
478
479
480
481
482
483
484


485
486
487
488
489
490
491
492
493
494
495
496


497
498
499
500
501
502
503
504
505
506
507
508

509
510
511
512
513
514
515

563
564
565
566
567
568
569


570
571
572
573
574
575
576
577
578
579
580
581


582
583
584
585
586
587
588
589
590
591
592
593
594

595
596
597
598
599
600
601
602








-
-
+
+










-
-
+
+











-
+








      simpar["dt"]		= args (2).map_value ()["dt"];
      simpar["last"]		= args (2).map_value ()["last"];
      simpar["stepfactor"]     	= args (2).map_value ()["stepfactor"];
      simpar["wmin"]		= args (2).map_value ()["wmin"];
      simpar["wmax"]		= args (2).map_value ()["wmax"];
      simpar["wsteps"]		= args (2).map_value ()["wsteps"];
      simpar["input"]		= args (2).map_value ()["input"];
      par    = args (1).vector_value ();
      x      = args (0).vector_value ();
      par    = args (1).${vector_value} ();
      x      = args (0).${vector_value} ();
      break;
    case 2:
      simpar["first"]		= mtt_simpar ()["first"];
      simpar["dt"]		= mtt_simpar ()["dt"];
      simpar["last"]		= mtt_simpar ()["last"];
      simpar["stepfactor"]     	= mtt_simpar ()["stepfactor"];
      simpar["wmin"]		= mtt_simpar ()["wmin"];
      simpar["wmax"]		= mtt_simpar ()["wmax"];
      simpar["wsteps"]		= mtt_simpar ()["wsteps"];
      simpar["input"]		= mtt_simpar ()["input"];
      par    = args (1).vector_value ();
      x      = args (0).vector_value ();
      par    = args (1).${vector_value} ();
      x      = args (0).${vector_value} ();
      break;
    case 1:
      simpar["first"]		= mtt_simpar ()["first"];
      simpar["dt"]		= mtt_simpar ()["dt"];
      simpar["last"]		= mtt_simpar ()["last"];
      simpar["stepfactor"]     	= mtt_simpar ()["stepfactor"];
      simpar["wmin"]		= mtt_simpar ()["wmin"];
      simpar["wmax"]		= mtt_simpar ()["wmax"];
      simpar["wsteps"]		= mtt_simpar ()["wsteps"];
      simpar["input"]		= mtt_simpar ()["input"];
      par    = mtt_numpar ();
      x      = args (0).vector_value ();
      x      = args (0).${vector_value} ();
      break;
    case 0:
      simpar["first"]		= mtt_simpar ()["first"];
      simpar["dt"]		= mtt_simpar ()["dt"];
      simpar["last"]		= mtt_simpar ()["last"];
      simpar["stepfactor"]     	= mtt_simpar ()["stepfactor"];
      simpar["wmin"]		= mtt_simpar ()["wmin"];
︙
532
533
534
535
536
537
538
539

540
541
542
543
544
545
546

619
620
621
622
623
624
625

626
627
628
629
630
631
632
633








-
+








  ColumnVector	AAx (MTTNX);

  ColumnVector	open_switches (MTTNX);

  register double t	= 0.0;

  const double	ddt	= simpar ["dt"].double_value () / simpar ["stepfactor"].double_value ();
  const int	ilast	= (int)round (simpar ["last"].double_value () / ddt) + 1;
  const int	ilast	= static_cast<int> (round (simpar ["last"].double_value () / ddt)) + 1;

  // cse translation
  // LSODE will need ODEFUNC

  for (register int j = 0, i = 1; i <= ilast; i++)
    {
      y	= mtt_${odeo} (x, u, t, par);
︙
563
564
565
566
567
568
569
570

571
572
573
574
575
576
577
578








579
580
581
582
583
584
585
586
587
588
589
590
591

650
651
652
653
654
655
656

657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686








-
+








+
+
+
+
+
+
+
+















## Common stuff
cat <<EOF >> $filename
      open_switches = mtt_logic (x, u, t, par);
      x =  $algorithm; 
      t += ddt;
      j++;
      j = (j == (int)simpar ["stepfactor"].double_value ()) ? 0 : j;
      j = (j == static_cast<int> (simpar ["stepfactor"].double_value ())) ? 0 : j;
    }

  retval (0) = octave_value (y);
  retval (1) = octave_value (x);
  retval (2) = octave_value (t);
  return (retval);
}

#ifdef STANDALONE
int main (void)
{
  octave_value_list args;
  F${sys}_ode2odes (args, 3);
  return 0;
}
#endif
EOF
}

case ${lang} in
    m)
        make_m	
	;;
    cc)
	make_cc
	;;
    *)
	echo Language ${lang} is not supported
esac

MTT: Model Transformation Tools
[ GitHub | SourceHut | Sourceforge | Fossil RSS ]