source: branches/dev-mj-1626/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo @ 13095

Last change on this file since 13095 was 13095, checked in by tgutzmann, 5 months ago

Merge from trunk

File size: 111.1 KB
Line 
1/*
2        Copyright (C) 2009-2013 Modelon AB
3
4        This program is free software: you can redistribute it and/or modify
5        it under the terms of the GNU General Public License as published by
6        the Free Software Foundation, version 3 of the License.
7
8        This program is distributed in the hope that it will be useful,
9        but WITHOUT ANY WARRANTY; without even the implied warranty of
10        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11        GNU General Public License for more details.
12
13        You should have received a copy of the GNU General Public License
14        along with this program.  If not, see <http://www.gnu.org/licenses/>.
15*/
16
17package EvaluationTests
18
19
20
21model VectorMul
22        parameter Integer n = 3;
23        parameter Real z[n] = 1:n;
24        parameter Real y[n] = n:-1:1;
25        parameter Real x = z * y;
26        Real q = x;
27
28    annotation(__JModelica(UnitTesting(tests={
29        EvalTestCase(
30            name="VectorMul",
31            description="Constant evaluation of vector multiplication",
32            variables="x",
33            values="10.0"
34 )})));
35end VectorMul;
36
37
38model FunctionEval1
39        function f
40                input Real i;
41                output Real o = i + 2.0;
42                algorithm
43        end f;
44       
45        parameter Real x = f(1.0);
46
47    annotation(__JModelica(UnitTesting(tests={
48        EvalTestCase(
49            name="FunctionEval1",
50            description="Constant evaluation of functions: basic test",
51            variables="x",
52            values="3.0"
53 )})));
54end FunctionEval1;
55
56
57model FunctionEval2
58        function fib
59                input Real n;
60                output Real a;
61        protected
62                Real b;
63                Real c;
64                Real i;
65        algorithm
66                a := 1;
67                b := 1;
68                if n < 3 then
69                        return;
70                end if;
71                i := 2;
72                while i < n loop
73                        c := b;
74                        b := a;
75                        a := b + c;
76                        i := i + 1;
77                end while;
78        end fib;
79
80        parameter Real x[6] = { fib(1), fib(2), fib(3), fib(4), fib(5), fib(6) };
81
82    annotation(__JModelica(UnitTesting(tests={
83        EvalTestCase(
84            name="FunctionEval2",
85            description="Constant evaluation of functions: while and if",
86            variables="
87x[1]
88x[2]
89x[3]
90x[4]
91x[5]
92x[6]
93",
94            values="
951.0
961.0
972.0
983.0
995.0
1008.0
101")})));
102end FunctionEval2;
103
104
105model FunctionEval3
106        function f
107                input Real[3] i;
108                output Real o = 1;
109        protected
110                Real[size(i,1)] x;
111        algorithm
112                x := i + (1:size(i,1));
113                for j in 1:size(i,1) loop
114                        o := o * x[j];
115                end for;
116        end f;
117       
118        parameter Real x = f({1,2,3});
119
120    annotation(__JModelica(UnitTesting(tests={
121        EvalTestCase(
122            name="FunctionEval3",
123            description="Constant evaluation of functions: array inputs and for loops",
124            variables="x",
125            values="48.0"
126 )})));
127end FunctionEval3;
128
129
130model FunctionEval4
131        function f
132                input Real[:] i;
133                output Real o = 1;
134        protected
135                Real[size(i,1)] x;
136        algorithm
137                x := i + (1:size(i,1));
138                for j in 1:size(i,1) loop
139                        o := o * x[j];
140                end for;
141        end f;
142       
143        parameter Real x = f({1,2,3});
144
145    annotation(__JModelica(UnitTesting(tests={
146        EvalTestCase(
147            name="FunctionEval4",
148            description="Constant evaluation of functions: unknown array sizes",
149            variables="x",
150            values="48.0"
151 )})));
152end FunctionEval4;
153
154
155model FunctionEval5
156        function f
157                input Real[3] i;
158                output Real o;
159        algorithm
160                o := 0;
161                for x in i loop
162                        o := o + x;
163                end for;
164        end f;
165       
166        parameter Real x = f({1,2,3});
167
168    annotation(__JModelica(UnitTesting(tests={
169        EvalTestCase(
170            name="FunctionEval5",
171            description="Constant evaluation of functions: using input as for index expression",
172            variables="x",
173            values="6.0"
174 )})));
175end FunctionEval5;
176
177
178model FunctionEval6
179        parameter Real y[2] = {1, 2};
180        parameter Real x[2] = f(y);
181       
182        function f
183                input Real i[2];
184                output Real o[2];
185        algorithm
186                o := i;
187        end f;
188
189    annotation(__JModelica(UnitTesting(tests={
190        EvalTestCase(
191            name="FunctionEval6",
192            description="Constant evaluation of functions: array output",
193            variables="
194x[1]
195x[2]
196",
197            values="
1981.0
1992.0
200")})));
201end FunctionEval6;
202
203
204model FunctionEval7
205        parameter Real y[2] = {1, 2};
206        parameter Real x[2] = f(y);
207       
208        function f
209                input Real i[:];
210                output Real o[size(i, 1)];
211        algorithm
212                o := i;
213        end f;
214
215    annotation(__JModelica(UnitTesting(tests={
216        EvalTestCase(
217            name="FunctionEval7",
218            description="Constant evaluation of functions: array output, unknown size",
219            variables="
220x[1]
221x[2]
222",
223            values="
2241.0
2252.0
226")})));
227end FunctionEval7;
228
229
230model FunctionEval8
231        function f
232                input Real i;
233                output Real o = 2 * i;
234        algorithm
235        end f;
236       
237        parameter Real x[2] = { f(i) for i in 1:2 };
238
239    annotation(__JModelica(UnitTesting(tests={
240        EvalTestCase(
241            name="FunctionEval8",
242            description="Constant evaluation and variability of iter exp containing function call",
243            variables="
244x[1]
245x[2]
246",
247            values="
2482.0
2494.0
250")})));
251end FunctionEval8;
252
253
254model FunctionEval9
255        function f
256                input Real i;
257                output Real o;
258        protected
259                Real x;
260        algorithm
261                x := 2;
262                o := 1;
263                while x <= i loop
264                        o := o * x;
265                        x := x + 1;
266                end while;
267        end f;
268
269        parameter Real x = f(5);
270
271    annotation(__JModelica(UnitTesting(tests={
272        EvalTestCase(
273            name="FunctionEval9",
274            description="Constant evaluation of functions: while loops (flat tree, independent param)",
275            variables="x",
276            values="120.0"
277 )})));
278end FunctionEval9;
279
280
281model FunctionEval10
282        function f
283                input Real i;
284                output Real o;
285        protected
286                Real x;
287        algorithm
288                x := 2;
289                o := 1;
290                while x <= i loop
291                        o := o * x;
292                        x := x + 1;
293                end while;
294        end f;
295
296        constant Real x = f(5);
297        Real y = x;
298
299    annotation(__JModelica(UnitTesting(tests={
300        FlatteningTestCase(
301            name="FunctionEval10",
302            description="Constant evaluation of functions: while loops (instance tree)",
303            flatModel="
304fclass EvaluationTests.FunctionEval10
305 constant Real x = 120.0;
306 Real y = 120.0;
307
308public
309 function EvaluationTests.FunctionEval10.f
310  input Real i;
311  output Real o;
312  Real x;
313 algorithm
314  x := 2;
315  o := 1;
316  while x <= i loop
317   o := o * x;
318   x := x + 1;
319  end while;
320  return;
321 end EvaluationTests.FunctionEval10.f;
322
323end EvaluationTests.FunctionEval10;
324")})));
325end FunctionEval10;
326
327
328model FunctionEval11
329        function f
330                input Real i;
331                output Real o;
332        protected
333                Real x;
334        algorithm
335                x := 2;
336                o := 1;
337                while x <= i loop
338                        o := o * x;
339                        x := x + 1;
340                end while;
341        end f;
342
343        parameter Real x = f(y);
344        parameter Real y = 5;
345
346    annotation(__JModelica(UnitTesting(tests={
347        EvalTestCase(
348            name="FunctionEval11",
349            description="Constant evaluation of functions: while loops (flat tree, dependent param)",
350            variables="x",
351            values="120.0"
352 )})));
353end FunctionEval11;
354
355
356model FunctionEval12
357        record R
358                Real a;
359                Real b;
360        end R;
361       
362        function f1
363                input Real a;
364                output R x;
365        algorithm
366                x := R(a, 2*a);
367        end f1;
368       
369        function f2
370                input R a;
371                output Real x;
372        algorithm
373                x := a.a + a.b;
374        end f2;
375       
376        constant Real x = f2(f1(2));
377        Real y = x;
378
379    annotation(__JModelica(UnitTesting(tests={
380        FlatteningTestCase(
381            name="FunctionEval12",
382            description="Constant evaluation of functions: records",
383            flatModel="
384fclass EvaluationTests.FunctionEval12
385 constant Real x = 6.0;
386 Real y = 6.0;
387
388public
389 function EvaluationTests.FunctionEval12.f2
390  input EvaluationTests.FunctionEval12.R a;
391  output Real x;
392 algorithm
393  x := a.a + a.b;
394  return;
395 end EvaluationTests.FunctionEval12.f2;
396
397 function EvaluationTests.FunctionEval12.f1
398  input Real a;
399  output EvaluationTests.FunctionEval12.R x;
400 algorithm
401  x := EvaluationTests.FunctionEval12.R(a, 2 * a);
402  return;
403 end EvaluationTests.FunctionEval12.f1;
404
405 record EvaluationTests.FunctionEval12.R
406  Real a;
407  Real b;
408 end EvaluationTests.FunctionEval12.R;
409
410end EvaluationTests.FunctionEval12;
411")})));
412end FunctionEval12;
413
414
415model FunctionEval13
416        record R
417                Real a;
418                Real b;
419        end R;
420       
421        function f
422                input Real a;
423                output R x;
424        algorithm
425                x := R(a, 2*a);
426        end f;
427       
428        constant R x = f(2);
429        R y = x;
430
431    annotation(__JModelica(UnitTesting(tests={
432        FlatteningTestCase(
433            name="FunctionEval13",
434            description="Constant evaluation of functions: records",
435            flatModel="
436fclass EvaluationTests.FunctionEval13
437 constant EvaluationTests.FunctionEval13.R x = EvaluationTests.FunctionEval13.R(2, 4.0);
438 EvaluationTests.FunctionEval13.R y = EvaluationTests.FunctionEval13.R(2, 4.0);
439
440public
441 function EvaluationTests.FunctionEval13.f
442  input Real a;
443  output EvaluationTests.FunctionEval13.R x;
444 algorithm
445  x := EvaluationTests.FunctionEval13.R(a, 2 * a);
446  return;
447 end EvaluationTests.FunctionEval13.f;
448
449 record EvaluationTests.FunctionEval13.R
450  Real a;
451  Real b;
452 end EvaluationTests.FunctionEval13.R;
453
454end EvaluationTests.FunctionEval13;
455")})));
456end FunctionEval13;
457
458
459model FunctionEval14
460        record R
461                Real a;
462                Real b;
463        end R;
464       
465        function f
466                input R a;
467                output Real x;
468        algorithm
469                x := a.a + a.b;
470        end f;
471       
472        constant Real x = f(R(1, 2));
473        Real y = x;
474
475    annotation(__JModelica(UnitTesting(tests={
476        FlatteningTestCase(
477            name="FunctionEval14",
478            description="Constant evaluation of functions: records",
479            flatModel="
480fclass EvaluationTests.FunctionEval14
481 constant Real x = 3.0;
482 Real y = 3.0;
483
484public
485 function EvaluationTests.FunctionEval14.f
486  input EvaluationTests.FunctionEval14.R a;
487  output Real x;
488 algorithm
489  x := a.a + a.b;
490  return;
491 end EvaluationTests.FunctionEval14.f;
492
493 record EvaluationTests.FunctionEval14.R
494  Real a;
495  Real b;
496 end EvaluationTests.FunctionEval14.R;
497
498end EvaluationTests.FunctionEval14;
499")})));
500end FunctionEval14;
501
502
503model FunctionEval15
504        record R1
505                Real a[2];
506                Real b[3];
507        end R1;
508       
509        record R2
510                R1 a[2];
511                R1 b[3];
512        end R2;
513       
514        function f1
515                input R2 a[2];
516                output Real x;
517        algorithm
518                x := sum(a.a.a) + sum(a.a.b) + sum(a.b.a) + sum(a.b.b);
519        end f1;
520       
521        function f2
522                output R2 x[2];
523        algorithm
524                x.a.a := ones(2,2,2);
525                for i in 1:2, j in 1:2 loop
526                        x[i].a[j].b := {1, 1, 1};
527                        x[i].b.a[j] := x[i].a[j].b;
528                end for;
529                x.b.b[1] := ones(2,3);
530                x.b[1].b := ones(2,3);
531                x.b[2:3].b[2:3] := ones(2,2,2);
532        end f2;
533       
534        constant Real x = f1(f2());
535        Real y = x;
536
537    annotation(__JModelica(UnitTesting(tests={
538        FlatteningTestCase(
539            name="FunctionEval15",
540            description="",
541            flatModel="
542fclass EvaluationTests.FunctionEval15
543 constant Real x = 50.0;
544 Real y = 50.0;
545
546public
547 function EvaluationTests.FunctionEval15.f1
548  input EvaluationTests.FunctionEval15.R2[:] a;
549  output Real x;
550 algorithm
551  assert(2 == size(a, 1), \"Mismatching sizes in function 'EvaluationTests.FunctionEval15.f1', component 'a', dimension '1'\");
552  for i1 in 1:size(a, 1) loop
553   assert(2 == size(a[i1].a, 1), \"Mismatching sizes in function 'EvaluationTests.FunctionEval15.f1', component 'a[i1].a', dimension '1'\");
554   for i2 in 1:size(a[i1].a, 1) loop
555    assert(2 == size(a[i1].a[i2].a, 1), \"Mismatching sizes in function 'EvaluationTests.FunctionEval15.f1', component 'a[i1].a[i2].a', dimension '1'\");
556    assert(3 == size(a[i1].a[i2].b, 1), \"Mismatching sizes in function 'EvaluationTests.FunctionEval15.f1', component 'a[i1].a[i2].b', dimension '1'\");
557   end for;
558   assert(3 == size(a[i1].b, 1), \"Mismatching sizes in function 'EvaluationTests.FunctionEval15.f1', component 'a[i1].b', dimension '1'\");
559   for i2 in 1:size(a[i1].b, 1) loop
560    assert(2 == size(a[i1].b[i2].a, 1), \"Mismatching sizes in function 'EvaluationTests.FunctionEval15.f1', component 'a[i1].b[i2].a', dimension '1'\");
561    assert(3 == size(a[i1].b[i2].b, 1), \"Mismatching sizes in function 'EvaluationTests.FunctionEval15.f1', component 'a[i1].b[i2].b', dimension '1'\");
562   end for;
563  end for;
564  x := sum(a[1:2].a[1:2].a[1:2]) + sum(a[1:2].a[1:2].b[1:3]) + sum(a[1:2].b[1:3].a[1:2]) + sum(a[1:2].b[1:3].b[1:3]);
565  return;
566 end EvaluationTests.FunctionEval15.f1;
567
568 function EvaluationTests.FunctionEval15.f2
569  output EvaluationTests.FunctionEval15.R2[:] x;
570 algorithm
571  init x as EvaluationTests.FunctionEval15.R2[2];
572  x[1:2].a[1:2].a[1:2] := ones(2, 2, 2);
573  for i in 1:2 loop
574   for j in 1:2 loop
575    x[i].a[j].b[1:3] := {1, 1, 1};
576    x[i].b[1:3].a[j] := x[i].a[j].b[1:3];
577   end for;
578  end for;
579  x[1:2].b[1:3].b[1] := ones(2, 3);
580  x[1:2].b[1].b[1:3] := ones(2, 3);
581  x[1:2].b[2:3].b[2:3] := ones(2, 2, 2);
582  return;
583 end EvaluationTests.FunctionEval15.f2;
584
585 record EvaluationTests.FunctionEval15.R1
586  Real a[2];
587  Real b[3];
588 end EvaluationTests.FunctionEval15.R1;
589
590 record EvaluationTests.FunctionEval15.R2
591  EvaluationTests.FunctionEval15.R1 a[2];
592  EvaluationTests.FunctionEval15.R1 b[3];
593 end EvaluationTests.FunctionEval15.R2;
594
595end EvaluationTests.FunctionEval15;
596")})));
597end FunctionEval15;
598
599
600model FunctionEval16
601        record R
602                Real a;
603                Real b;
604        end R;
605       
606        function f1
607                input Real a;
608                output R x;
609        algorithm
610                x := R(a, 2*a);
611        end f1;
612       
613        function f2
614                input R a;
615                output Real x;
616        algorithm
617                x := a.a + a.b;
618        end f2;
619       
620        parameter Real x = f2(f1(2));
621
622    annotation(__JModelica(UnitTesting(tests={
623        EvalTestCase(
624            name="FunctionEval16",
625            description="Constant evaluation of functions: records",
626            variables="x",
627            values="6.0"
628 )})));
629end FunctionEval16;
630
631
632model FunctionEval17
633        record R
634                Real a;
635                Real b;
636        end R;
637       
638        function f
639                input Real a;
640                output R x;
641        algorithm
642                x := R(a, 2*a);
643        end f;
644       
645        parameter R x = f(2);
646
647    annotation(__JModelica(UnitTesting(tests={
648        EvalTestCase(
649            name="FunctionEval17",
650            description="Constant evaluation of functions: records",
651            variables="
652x.a
653x.b
654",
655            values="
6562.0
6574.0
658")})));
659end FunctionEval17;
660
661
662model FunctionEval18
663        record R
664                Real a;
665                Real b;
666        end R;
667       
668        function f
669                input R a;
670                output Real x;
671        algorithm
672                x := a.a + a.b;
673        end f;
674       
675        parameter Real x = f(R(1, 2));
676
677    annotation(__JModelica(UnitTesting(tests={
678        EvalTestCase(
679            name="FunctionEval18",
680            description="Constant evaluation of functions: records",
681            variables="x",
682            values="3.0"
683 )})));
684end FunctionEval18;
685
686
687model FunctionEval19
688        record R1
689                Real a[2];
690                Real b[3];
691        end R1;
692       
693        record R2
694                R1 a[2];
695                R1 b[3];
696        end R2;
697       
698        function f1
699                input R2 a[2];
700                output Real x;
701        algorithm
702                x := sum(a.a.a) + sum(a.a.b) + sum(a.b.a) + sum(a.b.b);
703        end f1;
704       
705        function f2
706                output R2 x[2];
707        algorithm
708                x.a.a := ones(2,2,2);
709                for i in 1:2, j in 1:2 loop
710                        x[i].a[j].b := {1, 1, 1};
711                        x[i].b.a[j] := x[i].a[j].b;
712                end for;
713                x.b.b[1] := ones(2,3);
714                x.b[1].b := ones(2,3);
715                x.b[2:3].b[2:3] := ones(2,2,2);
716        end f2;
717       
718        parameter Real x = f1(f2());
719
720    annotation(__JModelica(UnitTesting(tests={
721        EvalTestCase(
722            name="FunctionEval19",
723            description="Constant evaluation of functions: arrays of records",
724            variables="x",
725            values="50.0"
726 )})));
727end FunctionEval19;
728
729
730model FunctionEval20
731        function f
732                input Real x[:];
733                output Real y;
734        algorithm
735                y := x * x;
736        end f;
737       
738        parameter Real a = f({1, 2});
739        parameter Real b = f({1, 2, 3});
740
741    annotation(__JModelica(UnitTesting(tests={
742        EvalTestCase(
743            name="FunctionEval20",
744            description="",
745            variables="
746a
747b
748",
749            values="
7505.0
75114.0
752")})));
753end FunctionEval20;
754
755
756model FunctionEval21
757        function f
758                input Real a;
759                output Real b;
760        algorithm
761                assert(true, "Test");
762                b := a;
763        end f;
764       
765        parameter Real x = f(1);
766
767    annotation(__JModelica(UnitTesting(tests={
768        EvalTestCase(
769            name="FunctionEval21",
770            description="Evaluation of function containing assert()",
771            variables="x",
772            values="1.0"
773 )})));
774end FunctionEval21;
775
776   
777model FunctionEval22
778        function f1
779                input Real x1;
780                input Real x2;
781                output Real y;
782        protected
783                Real z1;
784                Real z2;
785        algorithm
786                (z1, z2) := f2(x1, x2);
787                y := z1 + z2;
788    end f1;
789       
790    function f2
791        input Real x1;
792                input Real x2;
793                output Real y1;
794                output Real y2;
795        algorithm
796                y1 := x1 * x2;
797                y2 := x1 + x2;
798    end f2;
799       
800    parameter Real x = f1(1,2);
801
802    annotation(__JModelica(UnitTesting(tests={
803        EvalTestCase(
804            name="FunctionEval22",
805            description="Test evaluation of function containing function call statement using more than one output",
806            variables="x",
807            values="5.0"
808 )})));
809end FunctionEval22;
810
811model FunctionEval23
812    function f
813        input Real x;
814        output Real y;
815    algorithm
816        z := 5;
817        y := x + z;
818    end f;
819       
820    constant Real p = f(3);
821
822    annotation(__JModelica(UnitTesting(tests={
823        ErrorTestCase(
824            name="FunctionEval23",
825            description="",
826            errorMessage="
8273 errors found:
828
829Error at line 6, column 9, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
830  Cannot find class or component declaration for z
831
832Error at line 7, column 18, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
833  Cannot find class or component declaration for z
834
835Error at line 10, column 23, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
836  Could not evaluate binding expression for constant 'p': 'f(3)'
837")})));
838end FunctionEval23;
839
840model FunctionEval24
841        function f
842                input Real x;
843                output Real y;
844        algorithm
845                y := x;
846        end f;
847       
848        constant Real z = f();
849
850    annotation(__JModelica(UnitTesting(tests={
851        ErrorTestCase(
852            name="FunctionEval24",
853            description="",
854            errorMessage="
8552 errors found:
856
857Error at line 9, column 20, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
858  Calling function f(): missing argument for required input x
859
860Error at line 9, column 20, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
861  Could not evaluate binding expression for constant 'z': 'f()'
862    Unspecified constant evaluation failure
863")})));
864end FunctionEval24;
865
866
867model FunctionEval25
868        function f
869                input Real[:] x;
870                output Integer y;
871        algorithm
872                y := 0;
873                for i in 1:(size(x,1) - 1) loop
874                        y := y + i;
875                end for;
876        end f;
877       
878        Real x = f(ones(3));
879    parameter Integer n = f(ones(4));
880        Real z[n];
881
882    annotation(__JModelica(UnitTesting(tests={
883        FlatteningTestCase(
884            name="FunctionEval25",
885            description="Check that functions containing scalar expressions depending on unknown sizes can be evaluated after being error checked",
886            flatModel="
887fclass EvaluationTests.FunctionEval25
888 Real x = EvaluationTests.FunctionEval25.f(ones(3));
889 structural parameter Integer n = 6 /* 6 */;
890 Real z[6];
891
892public
893 function EvaluationTests.FunctionEval25.f
894  input Real[:] x;
895  output Integer y;
896 algorithm
897  y := 0;
898  for i in 1:size(x, 1) - 1 loop
899   y := y + i;
900  end for;
901  return;
902 end EvaluationTests.FunctionEval25.f;
903
904end EvaluationTests.FunctionEval25;
905")})));
906end FunctionEval25;
907
908
909model FunctionEval26a
910    record A
911        Real x;
912        Real y;
913    end A;
914   
915    function f
916        input Real x;
917        output A a(x=x, y=x*x);
918    algorithm
919    end f;
920   
921    constant A a1 = f(2);
922    constant A a2 = a1;
923
924    annotation(__JModelica(UnitTesting(tests={
925        EvalTestCase(
926            name="FunctionEval26a",
927            description="Evaluation in instance tree of function with modifications on record variable",
928            variables="
929a1.x
930a1.y
931a2.x
932a2.y
933",
934            values="
9352.0
9364.0
9372.0
9384.0
939")})));
940end FunctionEval26a;
941
942model FunctionEval26b
943    record A
944        Real x;
945        Real y;
946    end A;
947   
948    function f
949        input Real x;
950        output A a(x=x, y=x*x);
951    algorithm
952    end f;
953   
954    A a1 = f(2);
955    A a2 = a1;
956
957    annotation(__JModelica(UnitTesting(tests={
958        EvalTestCase(
959            name="FunctionEval26b",
960            description="Evaluation in flat tree of function with modifications on record variable",
961            eliminate_alias_variables=false,
962            variables="
963a1.x
964a1.y
965a2.x
966a2.y
967",
968            values="
9692.0
9704.0
9712.0
9724.0
973")})));
974end FunctionEval26b;
975
976
977model FunctionEval27
978    function f
979        input Real x;
980        output Real y;
981    algorithm
982        y := x + 2;
983        y := x * y;
984    end f;
985   
986    function f2 = f;
987   
988    constant Real a1 = f2(2);
989
990    annotation(__JModelica(UnitTesting(tests={
991        FlatteningTestCase(
992            name="FunctionEval27",
993            description="Evaluation of function defined in short class decl",
994            flatModel="
995fclass EvaluationTests.FunctionEval27
996 constant Real a1 = 8.0;
997
998public
999 function EvaluationTests.FunctionEval27.f
1000  input Real x;
1001  output Real y;
1002 algorithm
1003  y := x + 2;
1004  y := x * y;
1005  return;
1006 end EvaluationTests.FunctionEval27.f;
1007
1008end EvaluationTests.FunctionEval27;
1009")})));
1010end FunctionEval27;
1011
1012
1013model FunctionEval28
1014    function f
1015        input Real x;
1016        output Real y;
1017    algorithm
1018        y := x + 2;
1019        y := x * y;
1020    end f;
1021   
1022    function f2 = f(x(min=1));
1023   
1024    constant Real a1 = f2(2);
1025
1026    annotation(__JModelica(UnitTesting(tests={
1027        FlatteningTestCase(
1028            name="FunctionEval28",
1029            description="Evaluation of function defined in short class decl",
1030            flatModel="
1031fclass EvaluationTests.FunctionEval28
1032 constant Real a1 = 8.0;
1033
1034public
1035 function EvaluationTests.FunctionEval28.f2
1036  input Real x;
1037  output Real y;
1038 algorithm
1039  y := x + 2;
1040  y := x * y;
1041  return;
1042 end EvaluationTests.FunctionEval28.f2;
1043
1044end EvaluationTests.FunctionEval28;
1045")})));
1046end FunctionEval28;
1047
1048
1049model FunctionEval29
1050    function f
1051        input Real x;
1052        output Real y;
1053    algorithm
1054        y := x + 2;
1055        y := x * y;
1056    end f;
1057   
1058    function f2
1059        input Real x;
1060        output Real y;
1061    end f2;
1062
1063    model A
1064        replaceable function f3 = f2;
1065    end A;
1066
1067    model B
1068        extends A(redeclare function f3 = f(x = 2));
1069    end B;
1070   
1071    model C
1072        outer B b;
1073        constant Real x = b.f3(1);
1074    end B;
1075   
1076    inner B b;
1077    C c;
1078
1079    annotation(__JModelica(UnitTesting(tests={
1080        FlatteningTestCase(
1081            name="FunctionEval29",
1082            description="",
1083            flatModel="
1084fclass EvaluationTests.FunctionEval29
1085 constant Real c.x = 3.0;
1086
1087public
1088 function EvaluationTests.FunctionEval29.b.f3
1089  input Real x;
1090  output Real y;
1091 algorithm
1092  y := x + 2;
1093  y := x * y;
1094  return;
1095 end EvaluationTests.FunctionEval29.b.f3;
1096
1097end EvaluationTests.FunctionEval29;
1098")})));
1099end FunctionEval29;
1100
1101model FunctionEval30
1102    record R
1103        Real x;
1104    end R;
1105    function f2
1106        input Real  x;
1107        output Real y;
1108      algorithm
1109        y := x;
1110    end f2;
1111    function f1
1112        input Real x;
1113        output Real z;
1114      protected
1115        R y;
1116      algorithm
1117        (y.x) := f2(x);
1118        z := y.x;
1119    end f1;
1120    constant Real x = f1(3);
1121
1122    annotation(__JModelica(UnitTesting(tests={
1123        EvalTestCase(
1124            name="FunctionEval30",
1125            description="Constant evaluation of vector multiplication",
1126            variables="x",
1127            values="3.0"
1128 )})));
1129end FunctionEval30;
1130
1131model FunctionEval31
1132    record R1
1133        Real x;
1134    end R2;
1135    record R2
1136        extends R1;
1137    end R2;
1138    function f
1139        input R2 r2;
1140        output Real y;
1141      algorithm
1142        y := r2.x;
1143    end f;
1144   
1145    constant Real y1 = f(R2(3));
1146    Real y2 = f(R2(3));
1147
1148    annotation(__JModelica(UnitTesting(tests={
1149        EvalTestCase(
1150            name="FunctionEval31",
1151            description="Constant evaluation record component in input",
1152            variables="
1153y1
1154y2
1155",
1156            values="
11573.0
11583.0
1159")})));
1160end FunctionEval31;
1161
1162model FunctionEval32
1163    function f
1164        input Real[:] x;
1165        output Real[size(x,1)] y = zeros(n);
1166      protected
1167        Integer n = size(x,1);
1168        algorithm
1169    end f;
1170   
1171    constant Real[1] r = f({1}); 
1172
1173    annotation(__JModelica(UnitTesting(tests={
1174        EvalTestCase(
1175            name="FunctionEval32",
1176            description="Constant evaluation record component in input",
1177            variables="r[1]",
1178            values="0.0"
1179 )})));
1180end FunctionEval32;
1181
1182model FunctionEval33
1183    function f
1184        input Integer x[:];
1185        output Integer y = sum(x);
1186    algorithm
1187    end f;
1188   
1189    parameter Integer n1 = f({1,2});
1190    Real x1[n1] = 1:n1;
1191    parameter Integer n2 = f({1,2,3});
1192    Real x2[n2] = 1:n2;
1193
1194    annotation(__JModelica(UnitTesting(tests={
1195        FlatteningTestCase(
1196            name="FunctionEval33",
1197            description="Evaluation of function with non-input with binding expression depending on unknown size",
1198            flatModel="
1199fclass EvaluationTests.FunctionEval33
1200 structural parameter Integer n1 = 3 /* 3 */;
1201 Real x1[3] = 1:3;
1202 structural parameter Integer n2 = 6 /* 6 */;
1203 Real x2[6] = 1:6;
1204
1205public
1206 function EvaluationTests.FunctionEval33.f
1207  input Integer[:] x;
1208  output Integer y;
1209 algorithm
1210  y := sum(x[:]);
1211  return;
1212 end EvaluationTests.FunctionEval33.f;
1213
1214end EvaluationTests.FunctionEval33;
1215")})));
1216end FunctionEval33;
1217
1218model FunctionEval34
1219    function f
1220        input Real[n] x;
1221        input Integer n;
1222        output Real y;
1223      algorithm
1224        y := 0;
1225        for i in 1:n loop
1226            if x[i] > 1 then
1227                y := y + x[i];
1228            end if;
1229        end for;
1230    end f;
1231   
1232    constant Real y1 = f({1,2,4},3);
1233    Real y2 = f({1,2,4},3);
1234
1235    annotation(__JModelica(UnitTesting(tests={
1236        TransformCanonicalTestCase(
1237            name="FunctionEval34",
1238            description="If statement in for statement",
1239            inline_functions="none",
1240            eliminate_alias_variables=false,
1241            flatModel="
1242fclass EvaluationTests.FunctionEval34
1243 constant Real y1 = 6.0;
1244 constant Real y2 = 6.0;
1245end EvaluationTests.FunctionEval34;
1246")})));
1247end FunctionEval34;
1248
1249model FunctionEval35
1250    function f
1251        input Real[:,:] x;
1252        output Real[size(x,1),size(x,2)] y = x;
1253        output Real t = sum(x);
1254        algorithm
1255    end f;
1256   
1257    function fw
1258        input Real[:,:] x;
1259        output Real[size(x,1),size(x,2)] y;
1260        Real t;
1261      algorithm
1262        y := x;
1263        (y,t) := f(x);
1264    end fw;
1265   
1266    Real[1,1] y = fw({{1}});
1267
1268    annotation(__JModelica(UnitTesting(tests={
1269        TransformCanonicalTestCase(
1270            name="FunctionEval35",
1271            description="Function call stmt assigning array with value",
1272            inline_functions="none",
1273            flatModel="
1274fclass EvaluationTests.FunctionEval35
1275 constant Real y[1,1] = 1;
1276end EvaluationTests.FunctionEval35;
1277")})));
1278end FunctionEval35;
1279
1280model FunctionEval36
1281    record R
1282        Real a;
1283    end R;
1284   
1285    function f1
1286        input Real x;
1287        output Real y;
1288    protected
1289        R r;
1290    algorithm
1291        (r.a) := f2(x);
1292        y := r.a + 1;
1293        annotation(Inline=true);
1294    end f1;
1295   
1296    function f2
1297        input Real x;
1298        output Real y;
1299    protected
1300        R r;
1301    algorithm
1302        y := x - 1;
1303        annotation(Inline=true);
1304    end f2;
1305   
1306    function f3
1307        input Real x;
1308        output Real y;
1309        output Real z;
1310    protected
1311        R r;
1312    algorithm
1313        y := f1(x);
1314        z := 1;
1315        annotation(Inline=true);
1316    end f3;
1317   
1318    Real x;
1319    Real y;
1320equation
1321    (x, y) = f3(1);
1322
1323    annotation(__JModelica(UnitTesting(tests={
1324        TransformCanonicalTestCase(
1325            name="FunctionEval36",
1326            description="Function call statement assigning record component",
1327            inline_functions="none",
1328            flatModel="
1329fclass EvaluationTests.FunctionEval36
1330 constant Real x = 1.0;
1331 constant Real y = 1;
1332end EvaluationTests.FunctionEval36;
1333")})));
1334end FunctionEval36;
1335
1336
1337model FunctionEval37
1338    function f
1339        input Real x[2];
1340        input Integer i;
1341        output Real y;
1342    protected
1343        Real z = x[i];
1344    algorithm
1345        y := z;
1346    end f;
1347
1348    constant Real x = f({1, 2}, 1);
1349    constant Real y = f({3, 4}, 2);
1350
1351    annotation(__JModelica(UnitTesting(tests={
1352        TransformCanonicalTestCase(
1353            name="FunctionEval37",
1354            description="Evaluation of array index in binding expression of protected variable in function",
1355            flatModel="
1356fclass EvaluationTests.FunctionEval37
1357 constant Real x = 1;
1358 constant Real y = 4;
1359end EvaluationTests.FunctionEval37;
1360")})));
1361end FunctionEval37;
1362
1363model FunctionEval38
1364    record R
1365        Real[:] x;
1366    end R;
1367    function f
1368        input R r;
1369        output Real x = r.x[end];
1370    algorithm
1371    end f;
1372    constant Real x1 = f(R({1,2}));
1373    Real x2 = f(R({1,2}));
1374
1375    annotation(__JModelica(UnitTesting(tests={
1376        TransformCanonicalTestCase(
1377            name="FunctionEval38",
1378            description="Evaluation of end exp",
1379            flatModel="
1380fclass EvaluationTests.FunctionEval38
1381 constant Real x1 = 2;
1382end EvaluationTests.FunctionEval38;
1383")})));
1384end FunctionEval38;
1385
1386model FunctionEval39
1387    record R
1388        parameter Integer n;
1389        Real[n] x;
1390    end R;
1391    function f
1392        input R r;
1393        output Real x = r.x[end];
1394    algorithm
1395    end f;
1396    constant Real x1 = f(R(2,{1,2}));
1397    Real x2 = f(R(2,{1,2}));
1398
1399    annotation(__JModelica(UnitTesting(tests={
1400        TransformCanonicalTestCase(
1401            name="FunctionEval39",
1402            description="Evaluation of end exp",
1403            flatModel="
1404fclass EvaluationTests.FunctionEval39
1405 constant Real x1 = 2;
1406end EvaluationTests.FunctionEval39;
1407")})));
1408end FunctionEval39;
1409
1410model FunctionEval40
1411    record R
1412        parameter Integer n;
1413    end R;
1414   
1415    function f
1416        input R r;
1417        output Real y;
1418    protected
1419        Real[r.n+1] N;
1420    algorithm
1421        N := 1:r.n+1;
1422        y := sum(N);
1423    end f;
1424   
1425    constant Real y = f(R(2));
1426   
1427    annotation(__JModelica(UnitTesting(tests={
1428        TransformCanonicalTestCase(
1429            name="FunctionEval40",
1430            description="Evaluation of unknown array size in record",
1431            flatModel="
1432fclass EvaluationTests.FunctionEval40
1433 constant Real y = 6.0;
1434end EvaluationTests.FunctionEval40;
1435")})));
1436end FunctionEval40;
1437
1438model FunctionEval41
1439    function F
1440        input Real[:] i;
1441        output Real o;
1442    algorithm
1443        o:= sqrt(i * i);
1444    end F;
1445   
1446    parameter Real a = F({1,2});
1447    parameter Real b = F({2,1});
1448
1449    annotation(__JModelica(UnitTesting(tests={
1450        FlatteningTestCase(
1451            name="FunctionEval41",
1452            description="Evaluation of non-slice use",
1453            flatModel="
1454fclass EvaluationTests.FunctionEval41
1455 parameter Real a = EvaluationTests.FunctionEval41.F({1, 2}) /* evaluation error */;
1456 parameter Real b = EvaluationTests.FunctionEval41.F({2, 1}) /* evaluation error */;
1457
1458public
1459 function EvaluationTests.FunctionEval41.F
1460  input Real[:] i;
1461  output Real o;
1462 algorithm
1463  o := sqrt(i[:] * i[:]);
1464  return;
1465 end EvaluationTests.FunctionEval41.F;
1466
1467end EvaluationTests.FunctionEval41;
1468")})));
1469end FunctionEval41;
1470
1471model FunctionEval42
1472    function f1
1473        input Real x;
1474        output Real y;
1475    end f1;
1476   
1477    function f2
1478        extends f1;
1479        input Real x;
1480        output Real y;
1481    algorithm
1482        y := x + 1;
1483    end f2;
1484   
1485    constant Real a = f2(1);
1486
1487    annotation(__JModelica(UnitTesting(tests={
1488        FlatteningTestCase(
1489            name="FunctionEval42",
1490            description="Evaluation in instance tree of function that declares inherited inputs again",
1491            flatModel="
1492fclass EvaluationTests.FunctionEval42
1493 constant Real a = 2.0;
1494
1495public
1496 function EvaluationTests.FunctionEval42.f2
1497  input Real x;
1498  output Real y;
1499 algorithm
1500  y := x + 1;
1501  return;
1502 end EvaluationTests.FunctionEval42.f2;
1503
1504end EvaluationTests.FunctionEval42;
1505")})));
1506end FunctionEval42;
1507
1508model FunctionEval43
1509    function F
1510        input Integer[:] x;
1511        output Real[sum(x)] y;
1512    algorithm
1513        for i in 1:sum(x) loop
1514            y[i] := i + sum(x);
1515        end for;
1516    end F;
1517   
1518    parameter Integer[:] p1 = {1,1};
1519    parameter Integer[:] p2 = {2};
1520    parameter Real[2] a1 = F(p1) + F(p2);
1521
1522    annotation(__JModelica(UnitTesting(tests={
1523        FlatteningTestCase(
1524            name="FunctionEval43",
1525            description="Test array caching bug #5118",
1526            flatModel="
1527fclass EvaluationTests.FunctionEval43
1528 structural parameter Integer p1[2] = {1, 1} /* { 1, 1 } */;
1529 structural parameter Integer p2[1] = {2} /* { 2 } */;
1530 structural parameter Real a1[2] = {6, 8} /* { 6, 8 } */;
1531
1532public
1533 function EvaluationTests.FunctionEval43.F
1534  input Integer[:] x;
1535  output Real[:] y;
1536 algorithm
1537  init y as Real[sum(x[:])];
1538  for i in 1:sum(x[:]) loop
1539   y[i] := i + sum(x[:]);
1540  end for;
1541  return;
1542 end EvaluationTests.FunctionEval43.F;
1543
1544end EvaluationTests.FunctionEval43;
1545")})));
1546end FunctionEval43;
1547
1548model FunctionEval44
1549    constant Real[:] x = {sum(j for j in i:3) for i in 1:3};
1550
1551    annotation(__JModelica(UnitTesting(tests={
1552        EvalTestCase(
1553            name="FunctionEval44",
1554            description="Constant evaluation of iter exp containing function call",
1555            variables="
1556x[1]
1557x[2]
1558x[3]
1559",
1560            values="
15616.0
15625.0
15633.0
1564")})));
1565end FunctionEval44;
1566
1567model FunctionEval45
1568    function f
1569        input Real[:] x;
1570        output Real y = 0;
1571        Integer i = 1;
1572    algorithm
1573        while i <= size(x,1) loop
1574            y := y + sum(x[i:size(x,1)]);
1575            i := i + 1;
1576        end while;
1577    end f;
1578    constant Real y = f({1,2,3});
1579
1580    annotation(__JModelica(UnitTesting(tests={
1581        FlatteningTestCase(
1582            name="FunctionEval45",
1583            description="Constant evaluation of functions: records",
1584            flatModel="
1585fclass EvaluationTests.FunctionEval45
1586 constant Real y = 14.0;
1587
1588public
1589 function EvaluationTests.FunctionEval45.f
1590  input Real[:] x;
1591  output Real y;
1592  Integer i;
1593 algorithm
1594  y := 0;
1595  i := 1;
1596  while i <= size(x, 1) loop
1597   y := y + sum(x[i:size(x, 1)]);
1598   i := i + 1;
1599  end while;
1600  return;
1601 end EvaluationTests.FunctionEval45.f;
1602
1603end EvaluationTests.FunctionEval45;
1604")})));
1605end FunctionEval45;
1606
1607model FunctionEval46
1608    function f
1609        input Real[:] xs1;
1610        input Real[:] xs2;
1611        output Real y;
1612    algorithm
1613        y := 0;
1614        for x1 in xs1, x2 in xs2 loop
1615            y := x1 + x2;
1616        end for;
1617    end f;
1618   
1619    constant Real y = f({0.5},{0.5});
1620
1621    annotation(__JModelica(UnitTesting(tests={
1622        FlatteningTestCase(
1623            name="FunctionEval46",
1624            description="Constant evaluation of functions: real for index",
1625            flatModel="
1626fclass EvaluationTests.FunctionEval46
1627 constant Real y = 1.0;
1628
1629public
1630 function EvaluationTests.FunctionEval46.f
1631  input Real[:] xs1;
1632  input Real[:] xs2;
1633  output Real y;
1634 algorithm
1635  y := 0;
1636  for x1 in xs1 loop
1637   for x2 in xs2 loop
1638    y := x1 + x2;
1639   end for;
1640  end for;
1641  return;
1642 end EvaluationTests.FunctionEval46.f;
1643
1644end EvaluationTests.FunctionEval46;
1645")})));
1646end FunctionEval46;
1647
1648model VectorFuncEval1
1649    function f
1650        input Real x;
1651        output Real y = x + x;
1652        algorithm
1653    end f;
1654    constant Real[2] y1 = f({1,2});
1655    Real[2] y2 = f({1,2});
1656   
1657    annotation(__JModelica(UnitTesting(tests={
1658        EvalTestCase(
1659            name="VectorFuncEval1",
1660            description="Constant evaluation of vectorized function call",
1661            variables="
1662y1[1]
1663y1[2]
1664y2[1]
1665y2[2]
1666",
1667            values="
16682.0
16694.0
16702.0
16714.0
1672")})));
1673end VectorFuncEval1;
1674
1675model VectorFuncEval2
1676    function f
1677        input Real x1;
1678        input Real[:] x2;
1679        output Real y = x1 + sum(x2);
1680        algorithm
1681    end f;
1682    constant Real[3] y1 = f({1,2,3},{{1,2},{3,4},{5,6}});
1683    Real[3] y2 = f({1,2,3},{{1,2},{3,4},{5,6}});
1684   
1685    annotation(__JModelica(UnitTesting(tests={
1686        EvalTestCase(
1687            name="VectorFuncEval2",
1688            description="Constant evaluation of vectorized function call",
1689            variables="
1690y1[1]
1691y1[2]
1692y1[3]
1693y2[1]
1694y2[2]
1695y2[3]
1696",
1697            values="
16984.0
16999.0
170014.0
17014.0
17029.0
170314.0
1704")})));
1705end VectorFuncEval2;
1706
1707model VectorFuncEval3
1708    function f
1709        input Real x1;
1710        input Real[:] x2;
1711        input Real[:,:] x3;
1712        output Real y = x1 + sum(x2) + sum(x3);
1713        algorithm
1714    end f;
1715    constant Real[3] y1 = f({1,2,3},{{1,2},{3,4},{5,6}}, {{1},{2},{3}});
1716   
1717    annotation(__JModelica(UnitTesting(tests={
1718        EvalTestCase(
1719            name="VectorFuncEval3",
1720            description="Constant evaluation of vectorized function call",
1721            variables="
1722y1[1]
1723y1[2]
1724y1[3]
1725",
1726            values="
172710.0
172815.0
172920.0
1730")})));
1731end VectorFuncEval3;
1732
1733model VectorFuncEval4
1734    function f
1735        input Real x1;
1736        input Real[:] x2;
1737        input Real[:,:] x3;
1738        output Real y = x1 + sum(x2) + sum(x3);
1739        algorithm
1740    end f;
1741    constant Real[3] y1 = f(3,{{1,2},{3,4},{5,6}}, {{{1},{1}},{{2},{2}},{{3},{3}}});
1742   
1743    annotation(__JModelica(UnitTesting(tests={
1744        EvalTestCase(
1745            name="VectorFuncEval4",
1746            description="Constant evaluation of vectorized function call",
1747            variables="
1748y1[1]
1749y1[2]
1750y1[3]
1751",
1752            values="
17538.0
175414.0
175520.0
1756")})));
1757end VectorFuncEval4;
1758
1759model VectorFuncEval5
1760    function f
1761            input Real x1;
1762            input Real[:] x2;
1763            output Real y = x1;
1764        algorithm
1765    end f;
1766    Real[:,:] y = f({{time,time}}, {{{time},{time}}});
1767    Real[1,2] y1 = f({{1,2}}, {{{3},{4}}});
1768
1769    annotation(__JModelica(UnitTesting(tests={
1770        EvalTestCase(
1771            name="VectorFuncEval5",
1772            description="Constant evaluation of vectorized function call",
1773            variables="
1774y1[1,1]
1775y1[1,2]
1776",
1777            values="
17781.0
17792.0
1780")})));
1781end VectorFuncEval5;
1782
1783model StringConcat
1784 Real a = 1;
1785 parameter String b = "1" + "2";
1786 parameter String[2] c = { "1", "2" } .+ "3";
1787 parameter String[2] d = { "1", "2" } + { "3", "4" };
1788
1789    annotation(__JModelica(UnitTesting(tests={
1790        EvalTestCase(
1791            name="StringConcat",
1792            description="",
1793            variables="
1794b
1795c[1]
1796c[2]
1797d[1]
1798d[2]
1799",
1800            values="
1801\"12\"
1802\"13\"
1803\"23\"
1804\"13\"
1805\"24\"
1806")})));
1807end StringConcat;
1808
1809model ParameterEval1
1810        parameter Real[:,:] a = b;
1811        parameter Real[:,:] b = c;
1812        parameter Real[:,:] c = d;
1813        parameter Real[:,:] d = e;
1814        parameter Real[:,:] e = f;
1815        parameter Real[:,:] f = g;
1816        parameter Real[:,:] g = h;
1817        parameter Real[:,:] h = {{0,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,28,29},{30,31,32,33,34,35,36,37,38,39},{40,41,42,43,44,45,46,47,48,49},{50,51,52,53,54,55,56,57,58,59},{60,61,62,63,64,65,66,67,68,69},{70,71,72,73,74,75,76,77,78,79},{80,81,82,83,84,85,86,87,88,89},{90,91,92,93,94,95,96,97,98,99}};
1818        Boolean x;
1819equation
1820x = if a[1,1] > a[1,2] then true else false;
1821
1822    annotation(__JModelica(UnitTesting(tests={
1823        TimeTestCase(
1824            name="ParameterEval1",
1825            description="Make sure time complexity of evaluation of array parameters is of an acceptable order",
1826            maxTime=2.0
1827 )})));
1828end ParameterEval1;
1829
1830model EvalInheritedAnnotation
1831    model BaseEvalFalse
1832        parameter Real x(start=1);
1833        parameter Real y(start=3);
1834        replaceable parameter Real z = x + y annotation(Evaluate=false);
1835    end BaseEvalFalse;
1836   
1837    model EvalTrue
1838        extends BaseEvalFalse(redeclare replaceable parameter Real z = 2*x + y annotation(Evaluate=true)); 
1839    end EvalTrue;
1840   
1841    model EvalStillTrue
1842        extends EvalTrue(redeclare replaceable parameter Real z = 3*x + y); 
1843        annotation(__JModelica(UnitTesting(tests={
1844            FlatteningTestCase(
1845                name="C",
1846                description="Evaluate primitives without binding exp",
1847                flatModel="
1848        fclass EvaluationTests.EvalInheritedAnnotation.EvalStillTrue
1849         structural parameter Real x = 1 /* 1 */;
1850         structural parameter Real y = 3 /* 3 */;
1851         eval parameter Real z = 6.0 /* 6.0 */;
1852        end EvaluationTests.EvalInheritedAnnotation.EvalStillTrue;
1853    ")})));
1854    end EvalStillTrue;
1855   
1856    model EvalStillTrue2
1857        extends EvalStillTrue;
1858        annotation(__JModelica(UnitTesting(tests={
1859            FlatteningTestCase(
1860                name="D",
1861                description="Evaluate primitives without binding exp",
1862                flatModel="
1863        fclass EvaluationTests.EvalInheritedAnnotation.EvalStillTrue2
1864         structural parameter Real x = 1 /* 1 */;
1865         structural parameter Real y = 3 /* 3 */;
1866         eval parameter Real z = 6.0 /* 6.0 */;
1867        end EvaluationTests.EvalInheritedAnnotation.EvalStillTrue2;
1868    ")})));
1869    end EvalStillTrue2;
1870   
1871    model EvalDefaultFalse
1872        extends EvalStillTrue2(redeclare replaceable parameter Real z = y annotation());
1873        annotation(__JModelica(UnitTesting(tests={
1874            FlatteningTestCase(
1875                name="E",
1876                description="Evaluate primitives without binding exp",
1877                flatModel="
1878        fclass EvaluationTests.EvalInheritedAnnotation.EvalDefaultFalse
1879         parameter Real x(start = 1);
1880         parameter Real y(start = 3);
1881         parameter Real z = y;
1882        end EvaluationTests.EvalInheritedAnnotation.EvalDefaultFalse;
1883    ")})));
1884    end EvalDefaultFalse;
1885end EvalInheritedAnnotation;
1886
1887
1888
1889model EvalNoBinding1
1890    parameter Real x(start=1);
1891    parameter Real y(start=3);
1892    parameter Real z = x + y annotation(Evaluate=true);
1893   
1894    annotation(__JModelica(UnitTesting(tests={
1895        FlatteningTestCase(
1896            name="EvalNoBinding1",
1897            description="Evaluate primitives without binding exp",
1898            flatModel="
1899fclass EvaluationTests.EvalNoBinding1
1900 structural parameter Real x = 1 /* 1 */;
1901 structural parameter Real y = 3 /* 3 */;
1902 eval parameter Real z = 4.0 /* 4.0 */;
1903end EvaluationTests.EvalNoBinding1;
1904")})));
1905end EvalNoBinding1;
1906
1907model EvalNoBinding2
1908    parameter Real x[2,2](start={{1,2},{3,4}});
1909    parameter Real y[2,2](each start=5);
1910    parameter Real z1[2,2] = x + y annotation(Evaluate=true);
1911    parameter Real z2 = sum({{x[i,j] + y[i,j] for i in 1:2} for j in 1:2});
1912   
1913    annotation(__JModelica(UnitTesting(tests={
1914        FlatteningTestCase(
1915            name="EvalNoBinding2",
1916            description="Evaluate array primitives without binding exp",
1917            flatModel="
1918fclass EvaluationTests.EvalNoBinding2
1919 structural parameter Real x[2,2] = {{1, 2}, {3, 4}} /* { { 1, 2 }, { 3, 4 } } */;
1920 structural parameter Real y[2,2] = {{5, 5}, {5, 5}} /* { { 5, 5 }, { 5, 5 } } */;
1921 eval parameter Real z1[2,2] = {{6.0, 7.0}, {8.0, 9.0}} /* { { 6.0, 7.0 }, { 8.0, 9.0 } } */;
1922 structural parameter Real z2 = 30.0 /* 30.0 */;
1923end EvaluationTests.EvalNoBinding2;
1924")})));
1925end EvalNoBinding2;
1926
1927model EvalNoBinding3
1928    record R
1929        parameter Real x(start=2);
1930        Real[2,2] c(start={{3,4},{5,6}});
1931        Real[2,2] d(each start=7);
1932    end R;
1933   
1934    parameter R r1 annotation(Evaluate=true);
1935    parameter R r2 = r1 annotation(Evaluate=true);
1936   
1937    annotation(__JModelica(UnitTesting(tests={
1938        FlatteningTestCase(
1939            name="EvalNoBinding3",
1940            description="Evaluate primitives in record without binding exp",
1941            flatModel="
1942fclass EvaluationTests.EvalNoBinding3
1943 eval parameter EvaluationTests.EvalNoBinding3.R r1 = EvaluationTests.EvalNoBinding3.R(2, {{3, 4}, {5, 6}}, {{7, 7}, {7, 7}}) /* EvaluationTests.EvalNoBinding3.R(2, { { 3, 4 }, { 5, 6 } }, { { 7, 7 }, { 7, 7 } }) */;
1944 eval parameter EvaluationTests.EvalNoBinding3.R r2 = EvaluationTests.EvalNoBinding3.R(2, {{3, 4}, {5, 6}}, {{7, 7}, {7, 7}}) /* EvaluationTests.EvalNoBinding3.R(2, { { 3, 4 }, { 5, 6 } }, { { 7, 7 }, { 7, 7 } }) */;
1945
1946public
1947 record EvaluationTests.EvalNoBinding3.R
1948  parameter Real x;
1949  Real c[2,2];
1950  Real d[2,2];
1951 end EvaluationTests.EvalNoBinding3.R;
1952
1953end EvaluationTests.EvalNoBinding3;
1954")})));
1955end EvalNoBinding3;
1956
1957model EvalNoBinding4
1958    record R
1959        parameter Real x(start=2);
1960        Real[2,2] c(start={{3,4},{5,6}});
1961        Real[2,2] d(each start=7);
1962    end R;
1963   
1964    parameter R r[2,2] annotation(Evaluate=true);
1965    parameter Real[2,2] x = {{r[i,j].c[i,j] + r[i,j].d[i,j] for j in 1:2} for i in 1:2} annotation(Evaluate=true);
1966    parameter Real y = sum({{r[i,j].x for j in 1:2} for i in 1:2}) annotation(Evaluate=true);
1967       
1968    annotation(__JModelica(UnitTesting(tests={
1969        FlatteningTestCase(
1970            name="EvalNoBinding4",
1971            description="Evaluate primitives in record array without binding exp",
1972            flatModel="
1973fclass EvaluationTests.EvalNoBinding4
1974 eval parameter EvaluationTests.EvalNoBinding4.R r[2,2] = {{EvaluationTests.EvalNoBinding4.R(2, {{3, 4}, {5, 6}}, {{7, 7}, {7, 7}}), EvaluationTests.EvalNoBinding4.R(2, {{3, 4}, {5, 6}}, {{7, 7}, {7, 7}})}, {EvaluationTests.EvalNoBinding4.R(2, {{3, 4}, {5, 6}}, {{7, 7}, {7, 7}}), EvaluationTests.EvalNoBinding4.R(2, {{3, 4}, {5, 6}}, {{7, 7}, {7, 7}})}} /* { { EvaluationTests.EvalNoBinding4.R(2, { { 3, 4 }, { 5, 6 } }, { { 7, 7 }, { 7, 7 } }), EvaluationTests.EvalNoBinding4.R(2, { { 3, 4 }, { 5, 6 } }, { { 7, 7 }, { 7, 7 } }) }, { EvaluationTests.EvalNoBinding4.R(2, { { 3, 4 }, { 5, 6 } }, { { 7, 7 }, { 7, 7 } }), EvaluationTests.EvalNoBinding4.R(2, { { 3, 4 }, { 5, 6 } }, { { 7, 7 }, { 7, 7 } }) } } */;
1975 eval parameter Real x[2,2] = {{10.0, 11.0}, {12.0, 13.0}} /* { { 10.0, 11.0 }, { 12.0, 13.0 } } */;
1976 eval parameter Real y = 8.0 /* 8.0 */;
1977
1978public
1979 record EvaluationTests.EvalNoBinding4.R
1980  parameter Real x;
1981  Real c[2,2];
1982  Real d[2,2];
1983 end EvaluationTests.EvalNoBinding4.R;
1984
1985end EvaluationTests.EvalNoBinding4;
1986")})));
1987end EvalNoBinding4;
1988
1989model EvalNoBinding5
1990    class A
1991        extends ExternalObject;
1992       
1993        function constructor
1994            input Real b;
1995            output A a;
1996            external;
1997        end constructor;
1998       
1999        function destructor
2000            input A a;
2001            external;
2002        end destructor;
2003    end A;
2004   
2005    function f
2006        input A a;
2007        output Integer b;
2008        external;
2009    end f;
2010   
2011    parameter A a;
2012    parameter Integer n = f(a);
2013    Real x[n] = (1:n) * time;
2014
2015    annotation(__JModelica(UnitTesting(tests={
2016        ErrorTestCase(
2017            name="EvalNoBinding5",
2018            description="Constant eval of external object lacking binding exp",
2019            errorMessage="
20203 errors found:
2021
2022Error at line 23, column 5, in file '...', EXTERNAL_OBJECT_MISSING_BINDING_EXPRESSION:
2023  The external object 'a' does not have a binding expression
2024
2025Error at line 24, column 27, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
2026  Could not evaluate binding expression for structural parameter 'n': 'f(a)'
2027    in function 'EvaluationTests.EvalNoBinding5.f'
2028    Could not evaluate external function, unknown values in arguments
2029
2030Error at line 25, column 12, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
2031  Could not evaluate array size expression: n
2032")})));
2033end EvalNoBinding5;
2034
2035
2036
2037model EvalColonSizeCell
2038    function f
2039        input Real[:] x;
2040        output Real[size(x, 1) + 1] y;
2041    algorithm
2042                for i in 1:size(x,1) loop
2043            y[i] := x[i] / 2;
2044                        y[i + 1] := y[i] + 1;
2045                end for;
2046    end f;
2047   
2048    parameter Real a[1] = {1};
2049    parameter Real b[2] = f(a);
2050    parameter Real c[1] = if b[1] > 0.1 then {1} else {0} annotation (Evaluate=true);
2051
2052    annotation(__JModelica(UnitTesting(tests={
2053        FlatteningTestCase(
2054            name="EvalColonSizeCell",
2055            description="Evaluation of function returning array dependent on colon size",
2056            flatModel="
2057fclass EvaluationTests.EvalColonSizeCell
2058 structural parameter Real a[1] = {1} /* { 1 } */;
2059 structural parameter Real b[2] = {0.5, 1.5} /* { 0.5, 1.5 } */;
2060 eval parameter Real c[1] = {1} /* { 1 } */;
2061
2062public
2063 function EvaluationTests.EvalColonSizeCell.f
2064  input Real[:] x;
2065  output Real[:] y;
2066 algorithm
2067  init y as Real[size(x, 1) + 1];
2068  for i in 1:size(x, 1) loop
2069   y[i] := x[i] / 2;
2070   y[i + 1] := y[i] + 1;
2071  end for;
2072  return;
2073 end EvaluationTests.EvalColonSizeCell.f;
2074
2075end EvaluationTests.EvalColonSizeCell;
2076")})));
2077end EvalColonSizeCell;
2078
2079
2080model SignEval1
2081        constant Integer a1 = sign(-1.0);
2082    constant Integer a2 = a1;
2083    constant Integer b1 = sign(-0.5);
2084    constant Integer b2 = b1;
2085    constant Integer c1 = sign(0.0);
2086    constant Integer c2 = c1;
2087    constant Integer d1 = sign(0.5);
2088    constant Integer d2 = d1;
2089    constant Integer e1 = sign(1.0);
2090    constant Integer e2 = e1;
2091
2092    annotation(__JModelica(UnitTesting(tests={
2093        FlatteningTestCase(
2094            name="SignEval1",
2095            description="Test constant evaluation of sign()",
2096            flatModel="
2097fclass EvaluationTests.SignEval1
2098 constant Integer a1 = -1;
2099 constant Integer a2 = -1;
2100 constant Integer b1 = -1;
2101 constant Integer b2 = -1;
2102 constant Integer c1 = 0;
2103 constant Integer c2 = 0;
2104 constant Integer d1 = 1;
2105 constant Integer d2 = 1;
2106 constant Integer e1 = 1;
2107 constant Integer e2 = 1;
2108end EvaluationTests.SignEval1;
2109")})));
2110end SignEval1;
2111
2112model ParameterEvalAnnotation1
2113        parameter Real[3] p1 = {1,2,3} annotation (Evaluate=true);
2114        Real[3] r;
2115equation
2116        r = {1,2,3} .* p1;
2117
2118    annotation(__JModelica(UnitTesting(tests={
2119        TransformCanonicalTestCase(
2120            name="ParameterEvalAnnotation1",
2121            description="Test constant evaluation Evaluate parameter",
2122            flatModel="
2123fclass EvaluationTests.ParameterEvalAnnotation1
2124 eval parameter Real p1[1] = 1 /* 1 */;
2125 eval parameter Real p1[2] = 2 /* 2 */;
2126 eval parameter Real p1[3] = 3 /* 3 */;
2127 constant Real r[1] = 1.0;
2128 constant Real r[2] = 4.0;
2129 constant Real r[3] = 9.0;
2130end EvaluationTests.ParameterEvalAnnotation1;
2131")})));
2132end ParameterEvalAnnotation1;
2133
2134model ParameterEvalAnnotation2
2135       
2136        parameter Real p;
2137        parameter Real dp = p;
2138        parameter Real p1 = 1 annotation (Evaluate=true);
2139        parameter Real p2 = p1 + c;
2140        parameter Real p3 = 3*p2 + 3;
2141        parameter Real p4 = p1 + p;
2142        parameter Real p5 = p3 + dp;
2143       
2144        constant Real c = 1;
2145
2146    annotation(__JModelica(UnitTesting(tests={
2147        TransformCanonicalTestCase(
2148            name="ParameterEvalAnnotation2",
2149            description="Test constant evaluation Evaluate parameter",
2150            eliminate_alias_variables=false,
2151            flatModel="
2152fclass EvaluationTests.ParameterEvalAnnotation2
2153 parameter Real p;
2154 parameter Real dp;
2155 eval parameter Real p1 = 1 /* 1 */;
2156 structural parameter Real p2 = 2.0 /* 2.0 */;
2157 structural parameter Real p3 = 9.0 /* 9.0 */;
2158 parameter Real p4;
2159 parameter Real p5;
2160 constant Real c = 1;
2161parameter equation
2162 dp = p;
2163 p4 = 1.0 + p;
2164 p5 = 9.0 + dp;
2165end EvaluationTests.ParameterEvalAnnotation2;
2166")})));
2167end ParameterEvalAnnotation2;
2168
2169model ParameterEvalAnnotation3
2170       
2171function f
2172        input Real[2] i;
2173        output Real[2] o = i;
2174algorithm
2175end f;
2176
2177function fs
2178        input Real a;
2179        output Real b = a;
2180algorithm
2181end fs;
2182
2183        constant Real[2] c = {1,2};
2184        parameter Real[2] x = {1,2} + 2*f(c) annotation(Evaluate=true);
2185        parameter Real[2] y = {1,2} + 2*fs(x);
2186        parameter Real[2] z = 2*f(y);
2187equation
2188
2189    annotation(__JModelica(UnitTesting(tests={
2190        TransformCanonicalTestCase(
2191            name="ParameterEvalAnnotation3",
2192            description="Test constant evaluation Evaluate parameter",
2193            eliminate_alias_variables=false,
2194            flatModel="
2195fclass EvaluationTests.ParameterEvalAnnotation3
2196 constant Real c[1] = 1;
2197 constant Real c[2] = 2;
2198 eval parameter Real x[1] = 3 /* 3 */;
2199 eval parameter Real x[2] = 6 /* 6 */;
2200 structural parameter Real y[1] = 7 /* 7 */;
2201 structural parameter Real y[2] = 14 /* 14 */;
2202 structural parameter Real z[1] = 14 /* 14 */;
2203 structural parameter Real z[2] = 28 /* 28 */;
2204end EvaluationTests.ParameterEvalAnnotation3;
2205")})));
2206end ParameterEvalAnnotation3;
2207
2208
2209model ConstantInRecord1
2210    record A
2211        constant Real a = 1;
2212        constant Real b = a + 1;
2213    end A;
2214   
2215    constant Real c = A.a;
2216    constant Real d = A.b;
2217
2218    annotation(__JModelica(UnitTesting(tests={
2219        FlatteningTestCase(
2220            name="ConstantInRecord1",
2221            description="Evaluation of constants in records",
2222            flatModel="
2223fclass EvaluationTests.ConstantInRecord1
2224 constant Real c = 1;
2225 constant Real d = 2.0;
2226end EvaluationTests.ConstantInRecord1;
2227")})));
2228end ConstantInRecord1;
2229
2230
2231model ShortClassWithInstanceNameHelper
2232    model A
2233        constant String b = getInstanceName();
2234    end A;
2235   
2236    A a;
2237    parameter Real c = 1;
2238
2239    annotation(__JModelica(UnitTesting(tests={
2240        FlatteningTestCase(
2241            name="ShortClassWithInstanceNameHelper",
2242            description="",
2243            flatModel="
2244fclass EvaluationTests.ShortClassWithInstanceNameHelper
2245 constant String a.b = \"ShortClassWithInstanceNameHelper.a\";
2246 parameter Real c = 1 /* 1 */;
2247end EvaluationTests.ShortClassWithInstanceNameHelper;
2248")})));
2249end ShortClassWithInstanceNameHelper;
2250
2251
2252// TODO: this test gives the wrong value (may not be able to fix that in a reasonable way, since simple short class decl is only a pointer)
2253model ShortClassWithInstanceName1 = ShortClassWithInstanceNameHelper
2254
2255    annotation(__JModelica(UnitTesting(tests={
2256        FlatteningTestCase(
2257            name="ShortClassWithInstanceName1",
2258            description="Check that getInstaneName() works correctly for short class declarations",
2259            flatModel="
2260fclass EvaluationTests.ShortClassWithInstanceName1
2261 constant String a.b = \"ShortClassWithInstanceNameHelper.a\";
2262 parameter Real c = 1 /* 1 */;
2263end EvaluationTests.ShortClassWithInstanceName1;
2264")})));
2265
2266
2267model ShortClassWithInstanceName2 = ShortClassWithInstanceNameHelper(c = 2)
2268    annotation(__JModelica(UnitTesting(tests={
2269        FlatteningTestCase(
2270            name="ShortClassWithInstanceName2",
2271            description="Check that getInstaneName() works correctly for short class declarations",
2272            flatModel="
2273fclass EvaluationTests.ShortClassWithInstanceName2
2274 constant String a.b = \"ShortClassWithInstanceName2.a\";
2275 parameter Real c = 2 /* 2 */;
2276end EvaluationTests.ShortClassWithInstanceName2;
2277")})));
2278
2279
2280model FuncInArrayExpEval1
2281    function f
2282        input Real x;
2283        output Real[2] y;
2284    algorithm
2285        y := {x, x - 1};
2286    end f;
2287   
2288    parameter Real[2] a = {1, 2};
2289    parameter Real[2] b = a + f(m);
2290    parameter Integer n = integer(b[1]);
2291        parameter Integer m = 2;
2292    Real x[n] = (1:n) * time;
2293
2294    annotation(__JModelica(UnitTesting(tests={
2295        TransformCanonicalTestCase(
2296            name="FuncInArrayExpEval1",
2297            description="Constant evaluation of array binary expression containing function call returning array",
2298            variability_propagation=false,
2299            eliminate_alias_variables=false,
2300            eliminate_linear_equations=false,
2301            flatModel="
2302fclass EvaluationTests.FuncInArrayExpEval1
2303 structural parameter Real a[1] = 1 /* 1 */;
2304 structural parameter Real a[2] = 2 /* 2 */;
2305 structural parameter Real b[1] = 3.0 /* 3.0 */;
2306 structural parameter Real b[2] = 3.0 /* 3.0 */;
2307 structural parameter Integer n = 3 /* 3 */;
2308 structural parameter Integer m = 2 /* 2 */;
2309 Real x[1];
2310 Real x[2];
2311 Real x[3];
2312equation
2313 x[1] = time;
2314 x[2] = 2 * time;
2315 x[3] = 3 * time;
2316end EvaluationTests.FuncInArrayExpEval1;
2317")})));
2318end FuncInArrayExpEval1;
2319
2320model PreExp1
2321    Integer x = 1;
2322    Integer y = pre(x);
2323    annotation(__JModelica(UnitTesting(tests={
2324        TransformCanonicalTestCase(
2325            name="PreExp1",
2326            description="Constant evaluation of pre exp.",
2327            eliminate_alias_variables=false,
2328            flatModel="
2329fclass EvaluationTests.PreExp1
2330 constant Integer x = 1;
2331 constant Integer y = 1;
2332end EvaluationTests.PreExp1;
2333")})));
2334end PreExp1;
2335
2336model Delay1
2337    constant Real x1 = delay(1,1);
2338    Real x2 = delay(2,1);
2339    annotation(__JModelica(UnitTesting(tests={
2340        TransformCanonicalTestCase(
2341            name="Delay1",
2342            description="Constant evaluation of delay operator.",
2343            flatModel="
2344fclass EvaluationTests.Delay1
2345 constant Real x1 = 1;
2346 constant Real x2 = 2;
2347end EvaluationTests.Delay1;
2348")})));
2349end Delay1;
2350
2351model SpatialDistribution1
2352    constant Real x1 = spatialDistribution(1,1,1,false);
2353    Real x2,x3;
2354  equation
2355    (x2,x3) = spatialDistribution(2,1,1,true, {0,1}, {3,4});
2356    annotation(__JModelica(UnitTesting(tests={
2357        TransformCanonicalTestCase(
2358            name="SpatialDistribution1",
2359            description="Constant evaluation of spatialDistribution operator",
2360            flatModel="
2361fclass EvaluationTests.SpatialDistribution1
2362 constant Real x1 = 0.0;
2363 constant Real x2 = 3;
2364 constant Real x3 = 4;
2365end EvaluationTests.SpatialDistribution1;
2366")})));
2367end SpatialDistribution1;
2368
2369model SpatialDistribution2
2370    constant Real[3] x1 = spatialDistribution({1,2,3},{1,2,3},1,false);
2371    constant Real[3] x2 = spatialDistribution({2,3,4},{2,3,4},1,true,{0,0.5,1},{{0,1,2},{3,4,5},{6,7,8}});
2372    annotation(__JModelica(UnitTesting(tests={
2373        TransformCanonicalTestCase(
2374            name="SpatialDistribution2",
2375            description="Constant evaluation of vectorized spatialDistribution operator",
2376            eliminate_alias_variables=false,
2377            flatModel="
2378fclass EvaluationTests.SpatialDistribution2
2379 constant Real x1[1] = 0.0;
2380 constant Real x1[2] = 0.0;
2381 constant Real x1[3] = 0.0;
2382 constant Real x2[1] = 0;
2383 constant Real x2[2] = 3;
2384 constant Real x2[3] = 6;
2385end EvaluationTests.SpatialDistribution2;
2386")})));
2387end SpatialDistribution2;
2388
2389model Functional1
2390    partial function partFunc
2391        output Real y;
2392    end partFunc;
2393   
2394    function fullFunc
2395        extends partFunc;
2396      algorithm
2397        y := 3;
2398    end fullFunc;
2399   
2400    function usePartFunc
2401        input partFunc pf;
2402        output Real y;
2403      algorithm
2404        y := pf();
2405    end usePartFunc;
2406   
2407    constant Real c1 = usePartFunc(function fullFunc());
2408    Real y1 = usePartFunc(function fullFunc());
2409   
2410    annotation(__JModelica(UnitTesting(tests={
2411        TransformCanonicalTestCase(
2412            name="Functional1",
2413            description="Constant evaluation of functional input arguments, zero inputs",
2414            eliminate_alias_variables=false,
2415            flatModel="
2416fclass EvaluationTests.Functional1
2417 constant Real c1 = 3;
2418 constant Real y1 = 3;
2419end EvaluationTests.Functional1;
2420")})));
2421end Functional1;
2422
2423model Functional2
2424    partial function partFunc
2425        input Real x;
2426        output Real y;
2427    end partFunc;
2428   
2429    function fullFunc
2430        extends partFunc;
2431      algorithm
2432        y := x*x;
2433    end fullFunc;
2434   
2435    function usePartFunc
2436        input partFunc pf;
2437        input Real x;
2438        output Real y;
2439      algorithm
2440        y := pf(x);
2441    end usePartFunc;
2442   
2443    constant Real c1 = usePartFunc(function fullFunc(), 3);
2444    Real y1 = usePartFunc(function fullFunc(), 3);
2445   
2446    annotation(__JModelica(UnitTesting(tests={
2447        TransformCanonicalTestCase(
2448            name="Functional2",
2449            description="Constant evaluation of functional input arguments, zero inputs, one partial input",
2450            eliminate_alias_variables=false,
2451            flatModel="
2452fclass EvaluationTests.Functional2
2453 constant Real c1 = 9.0;
2454 constant Real y1 = 9.0;
2455end EvaluationTests.Functional2;
2456")})));
2457end Functional2;
2458
2459model Functional3
2460    partial function partFunc
2461        input Real x1;
2462        input Integer x2;
2463        output Real y1;
2464    end partFunc;
2465   
2466    function fullFunc
2467        extends partFunc;
2468        input Real x3;
2469        input Integer x4;
2470        output Real y2;
2471      algorithm
2472        y1 := x1*x2 + x3*x4;
2473        y2 := y1 + 1;
2474    end fullFunc;
2475   
2476    function usePartFunc
2477        input partFunc pf;
2478        input Integer x;
2479        output Real y;
2480      algorithm
2481        y := pf(x,x+1);
2482    end usePartFunc;
2483   
2484    constant Real c1 = usePartFunc(function fullFunc(x3=1,x4=2), 3);
2485    Real y1 = usePartFunc(function fullFunc(x3=1,x4=2), 3);
2486   
2487    annotation(__JModelica(UnitTesting(tests={
2488        TransformCanonicalTestCase(
2489            name="Functional3",
2490            description="Constant evaluation of functional input arguments, many inputs",
2491            eliminate_alias_variables=false,
2492            flatModel="
2493fclass EvaluationTests.Functional3
2494 constant Real c1 = 14.0;
2495 constant Real y1 = 14.0;
2496end EvaluationTests.Functional3;
2497")})));
2498end Functional3;
2499
2500model Functional4
2501    partial function partFunc
2502        input Real x1 = 1;
2503        input Integer x2 = 2;
2504        output Real y1 = x1 * x2;
2505    end partFunc;
2506   
2507    function fullFunc
2508        extends partFunc;
2509        input Real x3 = 10;
2510        input Integer x4 = 11;
2511      algorithm
2512        y1 := y1 + x3*x4;
2513    end fullFunc;
2514   
2515    function usePartFunc
2516        input partFunc pf;
2517        input Integer x;
2518        output Real y;
2519      algorithm
2520        y := pf(x) + pf(x1=x) + pf(x2=x);
2521    end usePartFunc;
2522   
2523    constant Real c1 = usePartFunc(function fullFunc(x3=100), 3);
2524    constant Real c2 = usePartFunc(function fullFunc(x4=100), 3);
2525    Real y1 = usePartFunc(function fullFunc(x3=100), 3);
2526    Real y2 = usePartFunc(function fullFunc(x4=100), 3);
2527   
2528    annotation(__JModelica(UnitTesting(tests={
2529        TransformCanonicalTestCase(
2530            name="Functional4",
2531            description="Constant evaluation of functional input arguments, binding expressions",
2532            eliminate_alias_variables=false,
2533            flatModel="
2534fclass EvaluationTests.Functional4
2535 constant Real c1 = 3315.0;
2536 constant Real c2 = 3015.0;
2537 constant Real y1 = 3315.0;
2538 constant Real y2 = 3015.0;
2539end EvaluationTests.Functional4;
2540")})));
2541end Functional4;
2542
2543model Functional5
2544    partial function partFunc1
2545        input Real x1;
2546        output Real y1;
2547    end partFunc1;
2548   
2549    partial function partFunc2
2550        extends partFunc1;
2551        input Real x2;
2552    end partFunc2;
2553   
2554    function fullFunc
2555        extends partFunc2;
2556        input Real x3;
2557      algorithm
2558        y1 := x1*x2*x3;
2559    end fullFunc;
2560   
2561    function usePartFunc
2562        input partFunc1 pf1;
2563        input partFunc2 pf2;
2564        input Integer x;
2565        output Real y;
2566        Real t1,t2;
2567      algorithm
2568        y := pf1(x) + pf2(x,2);
2569    end usePartFunc;
2570   
2571    constant Real c1 = usePartFunc(function fullFunc(x2=2,x3=1), function fullFunc(x3=2), 3);
2572    Real y1 = usePartFunc(function fullFunc(x2=2,x3=1), function fullFunc(x3=2), 3);
2573   
2574    annotation(__JModelica(UnitTesting(tests={
2575        TransformCanonicalTestCase(
2576            name="Functional5",
2577            description="Constant evaluation of functional input arguments, multiple extend levels",
2578            eliminate_alias_variables=false,
2579            flatModel="
2580fclass EvaluationTests.Functional5
2581 constant Real c1 = 18.0;
2582 constant Real y1 = 18.0;
2583end EvaluationTests.Functional5;
2584")})));
2585end Functional5;
2586
2587model Functional6
2588    partial function partFunc1
2589        input Real x1;
2590        output Real y1;
2591    end partFunc1;
2592   
2593    partial function partFunc2
2594        extends partFunc1;
2595        input Real x2;
2596        output Real y2;
2597    end partFunc2;
2598   
2599    function fullFunc
2600        extends partFunc2;
2601        input Real x3;
2602      algorithm
2603        y1 := x1*x2*x3;
2604        y2 := 1;
2605    end fullFunc;
2606   
2607    function usePartFunc
2608        input partFunc1 pf1;
2609        input partFunc2 pf2;
2610        input Integer x;
2611        output Real y;
2612      protected
2613        Real t1,t2;
2614      algorithm
2615        (t1,t2) := pf2(x,2);
2616        y := pf1(x) + t1 + t2;
2617    end usePartFunc;
2618   
2619    constant Real c1 = usePartFunc(function fullFunc(x2=2,x3=1), function fullFunc(x3=2), 3);
2620    Real y1 = usePartFunc(function fullFunc(x2=2,x3=1), function fullFunc(x3=2), 3);
2621   
2622    annotation(__JModelica(UnitTesting(tests={
2623        TransformCanonicalTestCase(
2624            name="Functional6",
2625            description="Constant evaluation of functional input arguments, multiple outputs",
2626            eliminate_alias_variables=false,
2627            flatModel="
2628fclass EvaluationTests.Functional6
2629 constant Real c1 = 19.0;
2630 constant Real y1 = 19.0;
2631end EvaluationTests.Functional6;
2632")})));
2633end Functional6;
2634
2635model Functional7
2636    partial function partFunc
2637        input Real x1;
2638        output Real y;
2639    end partFunc;
2640   
2641    partial function middleFunc
2642        extends partFunc;
2643        input Real x2;
2644    end middleFunc;
2645   
2646    function fullFunc
2647        extends middleFunc;
2648        input Real x3;
2649      algorithm
2650        y := x1 + x2 + x3;
2651    end fullFunc;
2652   
2653    function useMiddleFunc
2654        input middleFunc mf;
2655        input Real b;
2656        input Real c;
2657        output Real y = usePartFunc(function mf(x2=b), c);
2658        algorithm
2659    end useMiddleFunc;
2660   
2661    function usePartFunc
2662        input partFunc pf;
2663        input Real c;
2664        output Real y;
2665      algorithm
2666        y := pf(c);
2667    end usePartFunc;
2668   
2669    constant Real c1 = useMiddleFunc(function fullFunc(x3=1), 2, 3);
2670    Real y1 = useMiddleFunc(function fullFunc(x3=1), 2, 3);
2671   
2672    annotation(__JModelica(UnitTesting(tests={
2673        TransformCanonicalTestCase(
2674            name="Functional7",
2675            description="Constant evaluation of functional input arguments, chained",
2676            eliminate_alias_variables=false,
2677            flatModel="
2678fclass EvaluationTests.Functional7
2679 constant Real c1 = 6.0;
2680 constant Real y1 = 6.0;
2681end EvaluationTests.Functional7;
2682")})));
2683end Functional7;
2684
2685model Functional8
2686    partial function partFunc
2687        input Real x1;
2688        output Real y;
2689    end partFunc;
2690   
2691    function partAlias = partFunc;
2692   
2693    partial function middleFunc
2694        extends partAlias;
2695        input Real x2;
2696    end middleFunc;
2697   
2698    function middleAlias = middleFunc;
2699   
2700    function fullFunc
2701        extends middleAlias;
2702        input Real x3;
2703      algorithm
2704        y := x1 + x2 + x3;
2705    end fullFunc;
2706   
2707    function fullAlias = fullFunc;
2708   
2709    function useMiddleFunc
2710        input middleAlias mf;
2711        input Real b;
2712        input Real c;
2713        output Real y = usePartAlias(function mf(x2=b), c);
2714        algorithm
2715    end useMiddleFunc;
2716   
2717    function useMiddleAlias = useMiddleFunc;
2718   
2719    function usePartFunc
2720        input partAlias pf;
2721        input Real c;
2722        output Real y;
2723      algorithm
2724        y := pf(c);
2725    end usePartFunc;
2726   
2727    function usePartAlias = usePartFunc;
2728   
2729    constant Real c1 = useMiddleAlias(function fullAlias(x3=1), 2, 3);
2730    Real y1 = useMiddleAlias(function fullAlias(x3=1), 2, 3);
2731   
2732    annotation(__JModelica(UnitTesting(tests={
2733        TransformCanonicalTestCase(
2734            name="Functional8",
2735            description="Constant evaluation of functional input arguments, chained with shortclassdecls",
2736            eliminate_alias_variables=false,
2737            flatModel="
2738fclass EvaluationTests.Functional8
2739 constant Real c1 = 6.0;
2740 constant Real y1 = 6.0;
2741end EvaluationTests.Functional8;
2742")})));
2743end Functional8;
2744
2745
2746model Functional9
2747    partial function partFunc
2748        input Real x1;
2749        input Real x3;
2750        input Real x5;
2751        output Real y;
2752    end partFunc;
2753   
2754    function fullFunc
2755        input Real x1;
2756        input Real x2;
2757        input Real x3;
2758        input Real x4;
2759        input Real x5;
2760        output Real y;
2761      algorithm
2762        y := x1 + x2 + x3 + x4 + x5;
2763    end fullFunc;
2764   
2765    function usePartFunc
2766        input partFunc pf;
2767        output Real y;
2768      algorithm
2769        y := pf(1,3,5);
2770    end usePartFunc;
2771   
2772    function usePartAlias = usePartFunc;
2773   
2774    constant Real c1 = usePartFunc(function fullFunc(x2=2, x4=4));
2775    Real y1 = usePartFunc(function fullFunc(x2=2, x4=4));
2776   
2777    annotation(__JModelica(UnitTesting(tests={
2778        TransformCanonicalTestCase(
2779            name="Functional9",
2780            description="Constant evaluation of functional input arguments. Interleaving binds.",
2781            eliminate_alias_variables=false,
2782            flatModel="
2783fclass EvaluationTests.Functional9
2784 constant Real c1 = 15.0;
2785 constant Real y1 = 15.0;
2786end EvaluationTests.Functional9;
2787")})));
2788end Functional9;
2789
2790// Checks evaluation of partially unknown expressions
2791package Partial
2792    model Mul1
2793        function f
2794            input Real x1;
2795            input Real x2;
2796            output Real y = x1 * x2 + x2 * x1;
2797            output Real dummy;
2798            algorithm
2799        end f;
2800        Real y;
2801      equation
2802       (y, ) = f(0,time);
2803    annotation(__JModelica(UnitTesting(tests={
2804        TransformCanonicalTestCase(
2805            name="Mul1",
2806            description="Evaluation of multiplication with zero and unknown",
2807            inline_functions="none",
2808            flatModel="
2809fclass EvaluationTests.Partial.Mul1
2810 constant Real y = 0.0;
2811end EvaluationTests.Partial.Mul1;
2812")})));
2813    end Mul1;
2814   
2815    model Mul2
2816        function f
2817            input Real[:] x1;
2818            input Real[:] x2;
2819            output Real y = x1 * x2 + x2 * x1;
2820            output Real dummy;
2821            algorithm
2822        end f;
2823        Real y;
2824      equation
2825        (y, ) = f({0,0},{time,time});
2826    annotation(__JModelica(UnitTesting(tests={
2827        TransformCanonicalTestCase(
2828            name="Mul2",
2829            description="Evaluation of multiplication with zero and unknown",
2830            inline_functions="none",
2831            flatModel="
2832fclass EvaluationTests.Partial.Mul2
2833 constant Real y = 0.0;
2834end EvaluationTests.Partial.Mul2;
2835")})));
2836    end Mul2;
2837   
2838    model Mul3
2839        function f
2840            input Real[:] x1;
2841            input Real[:] x2;
2842            output Real[size(x1,1)] y = x1 .* x2 + x2 .* x1;
2843            algorithm
2844        end f;
2845        Real[2] y = f({0,0},{time,time});
2846    annotation(__JModelica(UnitTesting(tests={
2847        TransformCanonicalTestCase(
2848            name="Mul3",
2849            description="Evaluation of multiplication with zero and unknown",
2850            inline_functions="none",
2851            eliminate_alias_variables=false,
2852            flatModel="
2853fclass EvaluationTests.Partial.Mul3
2854 constant Real y[1] = 0.0;
2855 constant Real y[2] = 0.0;
2856end EvaluationTests.Partial.Mul3;
2857")})));
2858    end Mul3;
2859   
2860    model Mul4
2861        function f
2862            input Real[:,:] x1;
2863            input Real[:,:] x2;
2864            output Real[size(x1,1),size(x2,2)] y = x1 * x2 + x2 * x1;
2865            algorithm
2866        end f;
2867        Real[2,2] y = f({{0,0},{0,0}},{{time,time}, {time,time}});
2868    annotation(__JModelica(UnitTesting(tests={
2869        TransformCanonicalTestCase(
2870            name="Mul4",
2871            description="Evaluation of multiplication with zero and unknown",
2872            inline_functions="none",
2873            eliminate_alias_variables=false,
2874            flatModel="
2875fclass EvaluationTests.Partial.Mul4
2876 constant Real y[1,1] = 0.0;
2877 constant Real y[1,2] = 0.0;
2878 constant Real y[2,1] = 0.0;
2879 constant Real y[2,2] = 0.0;
2880end EvaluationTests.Partial.Mul4;
2881")})));
2882    end Mul4;
2883   
2884    model AssignStmt1
2885        function f
2886            input Real[:] x1;
2887            input Real[:] x2;
2888            output Real[size(x1,1)] y;
2889          algorithm
2890            y := x1;
2891            y := x2;
2892            y := x1 .* x2;
2893            y := x1;
2894        end f;
2895        Real[2] y2 = f({1,2},{time,time});
2896    annotation(__JModelica(UnitTesting(tests={
2897        TransformCanonicalTestCase(
2898            name="AssignStmt1",
2899            description="Evaluation of failing assign stmt",
2900            inline_functions="none",
2901            flatModel="
2902fclass EvaluationTests.Partial.AssignStmt1
2903 constant Real y2[1] = 1;
2904 constant Real y2[2] = 2;
2905end EvaluationTests.Partial.AssignStmt1;
2906")})));
2907    end AssignStmt1;
2908   
2909    model FunctionCallStmt1
2910        function f2
2911            input Real[:] x1;
2912            output Real[size(x1,1)] y = x1;
2913            algorithm
2914        end f2;
2915        function f
2916            input Real[:] x1;
2917            input Real[:] x2;
2918            output Real[size(x1,1)] y;
2919          algorithm
2920            (y) := f2(x1);
2921            (y) := f2(x2);
2922            (y) := f2(x1);
2923        end f;
2924        Real[2] y2 = f({1,2},{time,time});
2925    annotation(__JModelica(UnitTesting(tests={
2926        TransformCanonicalTestCase(
2927            name="FunctionCallStmt1",
2928            description="Evaluation of function call stmt with unknown value",
2929            inline_functions="none",
2930            flatModel="
2931fclass EvaluationTests.Partial.FunctionCallStmt1
2932 constant Real y2[1] = 1;
2933 constant Real y2[2] = 2;
2934end EvaluationTests.Partial.FunctionCallStmt1;
2935")})));
2936    end FunctionCallStmt1;
2937   
2938    model FunctionCallStmt2
2939        function f2
2940            input Real[:] x1;
2941            input Real[:] x2;
2942            output Real[size(x1,1)] y1 = x1;
2943            output Real[size(x2,1)] y2 = x2;
2944            algorithm
2945        end f2;
2946        function f
2947            input Real[:] x1;
2948            input Real[:] x2;
2949            output Real[size(x1,1)] y;
2950            Real[size(x1,1)] t;
2951          algorithm
2952            (y,t) := f2(x1,x2);
2953        end f;
2954        Real[2] y2 = f({1,2},{time,time});
2955    annotation(__JModelica(UnitTesting(tests={
2956        TransformCanonicalTestCase(
2957            name="FunctionCallStmt2",
2958            description="Evaluation of function call stmt with known and unknown values",
2959            inline_functions="none",
2960            flatModel="
2961fclass EvaluationTests.Partial.FunctionCallStmt2
2962 constant Real y2[1] = 1;
2963 constant Real y2[2] = 2;
2964end EvaluationTests.Partial.FunctionCallStmt2;
2965")})));
2966    end FunctionCallStmt2;
2967
2968    model IfStmt1
2969        function f
2970            input Real[:] x;
2971            input Real n;
2972            output Real[size(x,1)] y;
2973          algorithm
2974            y := x;
2975            if x[1] < x[2] then
2976                y := x .* n;
2977            end if;
2978        end f;
2979       
2980        Real[2] y = f({time,time}, 0);
2981    annotation(__JModelica(UnitTesting(tests={
2982        TransformCanonicalTestCase(
2983            name="IfStmt1",
2984            description="Partial evaluation of if stmt. All branches known.",
2985            inline_functions="none",
2986            flatModel="
2987fclass EvaluationTests.Partial.IfStmt1
2988 Real y[1];
2989 Real y[2];
2990equation
2991 ({y[1], y[2]}) = EvaluationTests.Partial.IfStmt1.f({time, time}, 0);
2992
2993public
2994 function EvaluationTests.Partial.IfStmt1.f
2995  input Real[:] x;
2996  input Real n;
2997  output Real[:] y;
2998 algorithm
2999  init y as Real[size(x, 1)];
3000  for i1 in 1:size(x, 1) loop
3001   y[i1] := x[i1];
3002  end for;
3003  if x[1] < x[2] then
3004   for i1 in 1:size(x, 1) loop
3005    y[i1] := x[i1] .* n;
3006   end for;
3007  end if;
3008  return;
3009 end EvaluationTests.Partial.IfStmt1.f;
3010
3011end EvaluationTests.Partial.IfStmt1;
3012")})));
3013    end IfStmt1;
3014   
3015    model IfStmt2
3016        function f
3017            input Real[:] x;
3018            input Real n;
3019            output Real[size(x,1)] y;
3020          algorithm
3021            y := x;
3022            if x[1] < x[2] then
3023                y := x .* n;
3024            else
3025                y := zeros(size(x,1));
3026            end if;
3027        end f;
3028       
3029        Real[2] y = f({time,time}, 0);
3030    annotation(__JModelica(UnitTesting(tests={
3031        TransformCanonicalTestCase(
3032            name="IfStmt2",
3033            description="Partial evaluation of if stmt. All branches known.",
3034            inline_functions="none",
3035            eliminate_alias_variables=false,
3036            flatModel="
3037fclass EvaluationTests.Partial.IfStmt2
3038 constant Real y[1] = 0.0;
3039 constant Real y[2] = 0.0;
3040end EvaluationTests.Partial.IfStmt2;
3041")})));
3042    end IfStmt2;
3043   
3044    model IfStmt3
3045        function f
3046            input Real[:] x;
3047            input Real n;
3048            output Real[size(x,1)] y;
3049          algorithm
3050            y := x;
3051            if x[1] < x[2] then
3052                y := x .* n;
3053            elseif x[1] > x[2] then
3054                y := (x .+ 1) .* n;
3055            else
3056                y := zeros(size(x,1));
3057            end if;
3058        end f;
3059       
3060        Real[2] y = f({time,time}, 0);
3061    annotation(__JModelica(UnitTesting(tests={
3062        TransformCanonicalTestCase(
3063            name="IfStmt3",
3064            description="Partial evaluation of if stmt. All branches known.",
3065            inline_functions="none",
3066            eliminate_alias_variables=false,
3067            flatModel="
3068fclass EvaluationTests.Partial.IfStmt3
3069 constant Real y[1] = 0.0;
3070 constant Real y[2] = 0.0;
3071end EvaluationTests.Partial.IfStmt3;
3072")})));
3073    end IfStmt3;
3074   
3075    model IfStmt4
3076        function f
3077            input Real[:] x;
3078            input Real n;
3079            output Real[size(x,1)] y;
3080          algorithm
3081            if x[1] < x[2] then
3082                y := x .* n;
3083            else
3084                y := x;
3085            end if;
3086        end f;
3087       
3088        Real[2] y = f({time,time}, 0);
3089    annotation(__JModelica(UnitTesting(tests={
3090        TransformCanonicalTestCase(
3091            name="IfStmt4",
3092            description="Partial evaluation of if stmt. Unknown branch.",
3093            inline_functions="none",
3094            flatModel="
3095fclass EvaluationTests.Partial.IfStmt4
3096 Real y[1];
3097 Real y[2];
3098equation
3099 ({y[1], y[2]}) = EvaluationTests.Partial.IfStmt4.f({time, time}, 0);
3100
3101public
3102 function EvaluationTests.Partial.IfStmt4.f
3103  input Real[:] x;
3104  input Real n;
3105  output Real[:] y;
3106 algorithm
3107  init y as Real[size(x, 1)];
3108  if x[1] < x[2] then
3109   for i1 in 1:size(x, 1) loop
3110    y[i1] := x[i1] .* n;
3111   end for;
3112  else
3113   for i1 in 1:size(x, 1) loop
3114    y[i1] := x[i1];
3115   end for;
3116  end if;
3117  return;
3118 end EvaluationTests.Partial.IfStmt4.f;
3119
3120end EvaluationTests.Partial.IfStmt4;
3121")})));
3122    end IfStmt4;
3123   
3124    model IfStmt5
3125        function f
3126            input Real[:] x;
3127            input Real n;
3128            output Real[size(x,1)] y;
3129          algorithm
3130            y := x;
3131            if x[1] < x[2] then
3132                y := x;
3133            else
3134                y := x .* n;
3135            end if;
3136        end f;
3137       
3138        Real[2] y = f({time,time}, 0);
3139    annotation(__JModelica(UnitTesting(tests={
3140        TransformCanonicalTestCase(
3141            name="IfStmt5",
3142            description="Partial evaluation of if stmt. Unknown branch.",
3143            inline_functions="none",
3144            flatModel="
3145fclass EvaluationTests.Partial.IfStmt5
3146 Real y[1];
3147 Real y[2];
3148equation
3149 ({y[1], y[2]}) = EvaluationTests.Partial.IfStmt5.f({time, time}, 0);
3150
3151public
3152 function EvaluationTests.Partial.IfStmt5.f
3153  input Real[:] x;
3154  input Real n;
3155  output Real[:] y;
3156 algorithm
3157  init y as Real[size(x, 1)];
3158  for i1 in 1:size(x, 1) loop
3159   y[i1] := x[i1];
3160  end for;
3161  if x[1] < x[2] then
3162   for i1 in 1:size(x, 1) loop
3163    y[i1] := x[i1];
3164   end for;
3165  else
3166   for i1 in 1:size(x, 1) loop
3167    y[i1] := x[i1] .* n;
3168   end for;
3169  end if;
3170  return;
3171 end EvaluationTests.Partial.IfStmt5.f;
3172
3173end EvaluationTests.Partial.IfStmt5;
3174")})));
3175    end IfStmt5;
3176   
3177    model IfStmt6
3178        function f
3179            input Real[:] x;
3180            input Real n;
3181            output Real[size(x,1)] y;
3182          algorithm
3183            y := x;
3184            if n > 0 then
3185                y := x;
3186            elseif x[1] > x[2] then
3187                y := (x .+ 1) .* n;
3188            elseif n == 0 then
3189                y := zeros(size(x,1));
3190            elseif x[1] > x[2] then
3191                y := x;
3192            else
3193                y := x;
3194            end if;
3195        end f;
3196       
3197        Real[2] y = f({time,time}, 0);
3198    annotation(__JModelica(UnitTesting(tests={
3199        TransformCanonicalTestCase(
3200            name="IfStmt6",
3201            description="Partial evaluation of if stmt. Chained false, unknown, and true if tests.",
3202            inline_functions="none",
3203            eliminate_alias_variables=false,
3204            flatModel="
3205fclass EvaluationTests.Partial.IfStmt6
3206 constant Real y[1] = 0.0;
3207 constant Real y[2] = 0.0;
3208end EvaluationTests.Partial.IfStmt6;
3209")})));
3210    end IfStmt6;
3211   
3212    model IfStmt7
3213        function f
3214            input Real[:] x;
3215            input Real n;
3216            output Real[size(x,1)] y;
3217          algorithm
3218            y := x;
3219            if x[1] < x[2] then
3220                y := x .* n;
3221                y[1] := x[1];
3222            else
3223                y := x;
3224                y[2] := 0;
3225            end if;
3226        end f;
3227       
3228        Real[2] y = f({time,time}, 0);
3229    annotation(__JModelica(UnitTesting(tests={
3230        TransformCanonicalTestCase(
3231            name="IfStmt7",
3232            description="Partial evaluation of if stmt. Partially known array.",
3233            inline_functions="none",
3234            flatModel="
3235fclass EvaluationTests.Partial.IfStmt7
3236 Real y[1];
3237 constant Real y[2] = 0.0;
3238equation
3239 ({y[1], }) = EvaluationTests.Partial.IfStmt7.f({time, time}, 0);
3240
3241public
3242 function EvaluationTests.Partial.IfStmt7.f
3243  input Real[:] x;
3244  input Real n;
3245  output Real[:] y;
3246 algorithm
3247  init y as Real[size(x, 1)];
3248  for i1 in 1:size(x, 1) loop
3249   y[i1] := x[i1];
3250  end for;
3251  if x[1] < x[2] then
3252   for i1 in 1:size(x, 1) loop
3253    y[i1] := x[i1] .* n;
3254   end for;
3255   y[1] := x[1];
3256  else
3257   for i1 in 1:size(x, 1) loop
3258    y[i1] := x[i1];
3259   end for;
3260   y[2] := 0;
3261  end if;
3262  return;
3263 end EvaluationTests.Partial.IfStmt7.f;
3264
3265end EvaluationTests.Partial.IfStmt7;
3266")})));
3267    end IfStmt7;
3268   
3269    model IfStmt8
3270        record R
3271            Real a;
3272            Real b;
3273        end R;
3274        function f
3275            input R x;
3276            input Real n;
3277            output R y;
3278          algorithm
3279            y := x;
3280            if x.a < x.b then
3281                y.a := x.a;
3282                y.b := x.b * n;
3283            else
3284                y.a := x.a;
3285                y.b := 0;
3286            end if;
3287        end f;
3288       
3289        R y = f(R(time,time), 0);
3290    annotation(__JModelica(UnitTesting(tests={
3291        TransformCanonicalTestCase(
3292            name="IfStmt8",
3293            description="Partial evaluation of if stmt. Partially known record.",
3294            inline_functions="none",
3295            flatModel="
3296fclass EvaluationTests.Partial.IfStmt8
3297 Real y.a;
3298 constant Real y.b = 0.0;
3299equation
3300 (EvaluationTests.Partial.IfStmt8.R(y.a, )) = EvaluationTests.Partial.IfStmt8.f(EvaluationTests.Partial.IfStmt8.R(time, time), 0);
3301
3302public
3303 function EvaluationTests.Partial.IfStmt8.f
3304  input EvaluationTests.Partial.IfStmt8.R x;
3305  input Real n;
3306  output EvaluationTests.Partial.IfStmt8.R y;
3307 algorithm
3308  y.a := x.a;
3309  y.b := x.b;
3310  if x.a < x.b then
3311   y.a := x.a;
3312   y.b := x.b * n;
3313  else
3314   y.a := x.a;
3315   y.b := 0;
3316  end if;
3317  return;
3318 end EvaluationTests.Partial.IfStmt8.f;
3319
3320 record EvaluationTests.Partial.IfStmt8.R
3321  Real a;
3322  Real b;
3323 end EvaluationTests.Partial.IfStmt8.R;
3324
3325end EvaluationTests.Partial.IfStmt8;
3326")})));
3327    end IfStmt8;
3328   
3329    model IfStmt9
3330        function f
3331            input Real[:] x;
3332            input Real n;
3333            output Real[size(x,1)] y;
3334          algorithm
3335            y := x;
3336            if x[1] < x[2] then
3337                y := x;
3338                if n > 0 then
3339                    y := x;
3340                elseif x[1] > x[2] then
3341                    if n > 0 then
3342                        y := x;
3343                    else
3344                        y := (x .+ 1) .* n;
3345                    end if;
3346                elseif n == 0 then
3347                    y := zeros(size(x,1));
3348                elseif x[1] > x[2] then
3349                    y := x;
3350                else
3351                    y := x;
3352                end if;
3353            else
3354                y := zeros(size(x,1));
3355            end if;
3356        end f;
3357       
3358        Real[2] y = f({time,time}, 0);
3359    annotation(__JModelica(UnitTesting(tests={
3360        TransformCanonicalTestCase(
3361            name="IfStmt9",
3362            description="Partial evaluation of if stmt. Nested.",
3363            inline_functions="none",
3364            eliminate_alias_variables=false,
3365            flatModel="
3366fclass EvaluationTests.Partial.IfStmt9
3367 constant Real y[1] = 0.0;
3368 constant Real y[2] = 0.0;
3369end EvaluationTests.Partial.IfStmt9;
3370")})));
3371    end IfStmt9;
3372   
3373    model IfStmt10
3374        function f
3375            input Real[:] x;
3376            input Real n;
3377            output Real[size(x,1)] y;
3378          algorithm
3379            y := x;
3380            for i in 1:size(x,1) loop
3381                if x[i] > 1 then
3382                    y[i] := n;
3383                    break;
3384                else
3385                    y[i] := 0;
3386                end if;
3387            end for;
3388        end f;
3389       
3390        Real[4] y = f({time,1,2,3}, 0);
3391    annotation(__JModelica(UnitTesting(tests={
3392        TransformCanonicalTestCase(
3393            name="IfStmt10",
3394            description="Partial evaluation of if stmt. Break.",
3395            inline_functions="none",
3396            flatModel="
3397fclass EvaluationTests.Partial.IfStmt10
3398 Real y[1];
3399 Real y[2];
3400 Real y[3];
3401 Real y[4];
3402equation
3403 ({y[1], y[2], y[3], y[4]}) = EvaluationTests.Partial.IfStmt10.f({time, 1, 2, 3}, 0);
3404
3405public
3406 function EvaluationTests.Partial.IfStmt10.f
3407  input Real[:] x;
3408  input Real n;
3409  output Real[:] y;
3410 algorithm
3411  init y as Real[size(x, 1)];
3412  for i1 in 1:size(x, 1) loop
3413   y[i1] := x[i1];
3414  end for;
3415  for i in 1:size(x, 1) loop
3416   if x[i] > 1 then
3417    y[i] := n;
3418    break;
3419   else
3420    y[i] := 0;
3421   end if;
3422  end for;
3423  return;
3424 end EvaluationTests.Partial.IfStmt10.f;
3425
3426end EvaluationTests.Partial.IfStmt10;
3427")})));
3428    end IfStmt10;
3429   
3430    model IfStmt11
3431        function f
3432            input Real[:] x;
3433            input Real n;
3434            output Real[size(x,1)] y;
3435          algorithm
3436            y := x;
3437            for i in 1:size(x,1) loop
3438                if x[i] > 1 then
3439                    y[i] := n;
3440                    break;
3441                else
3442                    y[i] := 0;
3443                    break;
3444                end if;
3445            end for;
3446        end f;
3447       
3448        Real[4] y = f({time,1,2,3}, 0);
3449    annotation(__JModelica(UnitTesting(tests={
3450        TransformCanonicalTestCase(
3451            name="IfStmt11",
3452            description="Partial evaluation of if stmt. Break.",
3453            inline_functions="none",
3454            flatModel="
3455fclass EvaluationTests.Partial.IfStmt11
3456 constant Real y[1] = 0;
3457 constant Real y[2] = 1;
3458 constant Real y[3] = 2;
3459 constant Real y[4] = 3;
3460end EvaluationTests.Partial.IfStmt11;
3461")})));
3462    end IfStmt11;
3463   
3464    model IfStmt12
3465        function f
3466            input Real[:] x;
3467            input Real n;
3468            output Real[size(x,1)] y1;
3469            output Real y2;
3470            output Real y3;
3471          algorithm
3472            y1 := x;
3473            if x[1] < x[2] then
3474                y1 := x .* n;
3475                y2 := 3;
3476            else
3477                y1 := x;
3478                y1[2] := 0;
3479                y3 := 3;
3480            end if;
3481        end f;
3482       
3483        Real[4] y1;
3484        Real y2,y3;
3485      equation
3486        (y1,y2,y3) = f({time,1,2,3}, 0);
3487    annotation(__JModelica(UnitTesting(tests={
3488        TransformCanonicalTestCase(
3489            name="IfStmt12",
3490            description="Partial evaluation of if stmt. Assigned in only one branch.",
3491            inline_functions="none",
3492            flatModel="
3493fclass EvaluationTests.Partial.IfStmt12
3494 Real y1[1];
3495 constant Real y1[2] = 0.0;
3496 Real y1[3];
3497 Real y1[4];
3498 Real y2;
3499 Real y3;
3500equation
3501 ({y1[1], , y1[3], y1[4]}, y2, y3) = EvaluationTests.Partial.IfStmt12.f({time, 1, 2, 3}, 0);
3502
3503public
3504 function EvaluationTests.Partial.IfStmt12.f
3505  input Real[:] x;
3506  input Real n;
3507  output Real[:] y1;
3508  output Real y2;
3509  output Real y3;
3510 algorithm
3511  init y1 as Real[size(x, 1)];
3512  for i1 in 1:size(x, 1) loop
3513   y1[i1] := x[i1];
3514  end for;
3515  if x[1] < x[2] then
3516   for i1 in 1:size(x, 1) loop
3517    y1[i1] := x[i1] .* n;
3518   end for;
3519   y2 := 3;
3520  else
3521   for i1 in 1:size(x, 1) loop
3522    y1[i1] := x[i1];
3523   end for;
3524   y1[2] := 0;
3525   y3 := 3;
3526  end if;
3527  return;
3528 end EvaluationTests.Partial.IfStmt12.f;
3529
3530end EvaluationTests.Partial.IfStmt12;
3531")})));
3532    end IfStmt12;
3533   
3534    model IfStmt13
3535        record R
3536            Real a,b;
3537        end R;
3538       
3539        function f
3540            input Real x1;
3541            input Real x2;
3542            output R r;
3543          algorithm
3544            r := R(x2,x2);
3545            if x1 < 2 then
3546                r.a := x1;
3547            end if;
3548            r.b := x1;
3549        end f;
3550       
3551        R y = f(1, time);
3552       
3553    annotation(__JModelica(UnitTesting(tests={
3554        TransformCanonicalTestCase(
3555            name="IfStmt13",
3556            description="Partial evaluation of if stmt. Assigned in only one branch.",
3557            eliminate_alias_variables=false,
3558            inline_functions="none",
3559            flatModel="
3560fclass EvaluationTests.Partial.IfStmt13
3561 constant Real y.a = 1;
3562 constant Real y.b = 1;
3563end EvaluationTests.Partial.IfStmt13;
3564")})));
3565    end IfStmt13;
3566   
3567    model IfStmt14
3568        record R
3569            Real a,b;
3570        end R;
3571       
3572        function f
3573            input Real x1;
3574            input Real x2;
3575            output R r;
3576          algorithm
3577            if x1 < x2 then
3578                r.a := x1;
3579                r.b := x1;
3580            else
3581                r.a := x1;
3582                r.b := x2;
3583            end if;
3584        end f;
3585       
3586        R y = f(1, time);
3587       
3588    annotation(__JModelica(UnitTesting(tests={
3589        TransformCanonicalTestCase(
3590            name="IfStmt14",
3591            description="Partial evaluation of if stmt. Part of record assigned different values per branch, other part assigned same",
3592            inline_functions="none",
3593            flatModel="
3594fclass EvaluationTests.Partial.IfStmt14
3595 constant Real y.a = 1;
3596 Real y.b;
3597equation
3598 (EvaluationTests.Partial.IfStmt14.R(, y.b)) = EvaluationTests.Partial.IfStmt14.f(1, time);
3599
3600public
3601 function EvaluationTests.Partial.IfStmt14.f
3602  input Real x1;
3603  input Real x2;
3604  output EvaluationTests.Partial.IfStmt14.R r;
3605 algorithm
3606  if x1 < x2 then
3607   r.a := x1;
3608   r.b := x1;
3609  else
3610   r.a := x1;
3611   r.b := x2;
3612  end if;
3613  return;
3614 end EvaluationTests.Partial.IfStmt14.f;
3615
3616 record EvaluationTests.Partial.IfStmt14.R
3617  Real a;
3618  Real b;
3619 end EvaluationTests.Partial.IfStmt14.R;
3620
3621end EvaluationTests.Partial.IfStmt14;
3622")})));
3623    end IfStmt14;
3624   
3625    model IfStmt15
3626        function f
3627            input Real x1;
3628            input Real x2;
3629            output Real[2] r;
3630          algorithm
3631            if x1 < x2 then
3632                r[1] := x1;
3633                r[2] := x1;
3634            else
3635                r[1] := x1;
3636                r[2] := x2;
3637            end if;
3638        end f;
3639       
3640        Real[2] y = f(1, time);
3641       
3642    annotation(__JModelica(UnitTesting(tests={
3643        TransformCanonicalTestCase(
3644            name="IfStmt15",
3645            description="Partial evaluation of if stmt. Part of array assigned different values per branch, other part assigned same",
3646            inline_functions="none",
3647            flatModel="
3648fclass EvaluationTests.Partial.IfStmt15
3649 constant Real y[1] = 1;
3650 Real y[2];
3651equation
3652 ({, y[2]}) = EvaluationTests.Partial.IfStmt15.f(1, time);
3653
3654public
3655 function EvaluationTests.Partial.IfStmt15.f
3656  input Real x1;
3657  input Real x2;
3658  output Real[:] r;
3659 algorithm
3660  init r as Real[2];
3661  if x1 < x2 then
3662   r[1] := x1;
3663   r[2] := x1;
3664  else
3665   r[1] := x1;
3666   r[2] := x2;
3667  end if;
3668  return;
3669 end EvaluationTests.Partial.IfStmt15.f;
3670
3671end EvaluationTests.Partial.IfStmt15;
3672")})));
3673    end IfStmt15;
3674   
3675end Partial;
3676
3677
3678
3679model AssigningCached1
3680    record R
3681        Real a;
3682    end R;
3683   
3684    function f
3685        input R x;
3686        output R y = x;
3687      algorithm
3688        y.a := 2;
3689    end f;
3690   
3691    constant R y1 = R(1);
3692    constant R y2 = f(y1);
3693   
3694    annotation(__JModelica(UnitTesting(tests={
3695        FlatteningTestCase(
3696            name="AssigningCached1",
3697            description="",
3698            flatModel="
3699fclass EvaluationTests.AssigningCached1
3700 constant EvaluationTests.AssigningCached1.R y1 = EvaluationTests.AssigningCached1.R(1);
3701 constant EvaluationTests.AssigningCached1.R y2 = EvaluationTests.AssigningCached1.R(2);
3702
3703public
3704 function EvaluationTests.AssigningCached1.f
3705  input EvaluationTests.AssigningCached1.R x;
3706  output EvaluationTests.AssigningCached1.R y;
3707 algorithm
3708  y := x;
3709  y.a := 2;
3710  return;
3711 end EvaluationTests.AssigningCached1.f;
3712
3713 record EvaluationTests.AssigningCached1.R
3714  Real a;
3715 end EvaluationTests.AssigningCached1.R;
3716
3717end EvaluationTests.AssigningCached1;
3718")})));
3719end AssigningCached1;
3720
3721
3722model AssigningCached2
3723    function f
3724        input Real[:] x;
3725        output Real[:] y = x;
3726      algorithm
3727        y[2] := 3;
3728    end f;
3729    constant Real[2] y1 = {1,2};
3730    constant Real[2] y2 = f(y1);
3731   
3732    annotation(__JModelica(UnitTesting(tests={
3733        FlatteningTestCase(
3734            name="AssigningCached2",
3735            description="",
3736            flatModel="
3737fclass EvaluationTests.AssigningCached2
3738 constant Real y1[2] = {1, 2};
3739 constant Real y2[2] = {1, 3};
3740
3741public
3742 function EvaluationTests.AssigningCached2.f
3743  input Real[:] x;
3744  output Real[:] y;
3745 algorithm
3746  init y as Real[size(x, 1)];
3747  y := x[:];
3748  y[2] := 3;
3749  return;
3750 end EvaluationTests.AssigningCached2.f;
3751
3752end EvaluationTests.AssigningCached2;
3753")})));
3754end AssigningCached2;
3755
3756
3757model AssigningCached3
3758    record R
3759        Real[2] a;
3760    end R;
3761    function f
3762        input Real[2] x;
3763        output R y = R(x);
3764      algorithm
3765        y.a[2] := 3;
3766    end f;
3767    constant Real[2] y1 = {1,2};
3768    constant R y2 = f(y1);
3769   
3770    annotation(__JModelica(UnitTesting(tests={
3771        FlatteningTestCase(
3772            name="AssigningCached3",
3773            description="",
3774            flatModel="
3775fclass EvaluationTests.AssigningCached3
3776 constant Real y1[2] = {1, 2};
3777 constant EvaluationTests.AssigningCached3.R y2 = EvaluationTests.AssigningCached3.R({1, 3});
3778
3779public
3780 function EvaluationTests.AssigningCached3.f
3781  input Real[:] x;
3782  output EvaluationTests.AssigningCached3.R y;
3783 algorithm
3784  assert(2 == size(x, 1), \"Mismatching sizes in function 'EvaluationTests.AssigningCached3.f', component 'x', dimension '1'\");
3785  y := EvaluationTests.AssigningCached3.R(x);
3786  y.a[2] := 3;
3787  return;
3788 end EvaluationTests.AssigningCached3.f;
3789
3790 record EvaluationTests.AssigningCached3.R
3791  Real a[2];
3792 end EvaluationTests.AssigningCached3.R;
3793
3794end EvaluationTests.AssigningCached3;
3795")})));
3796end AssigningCached3;
3797
3798
3799model AssigningCached4
3800    record R
3801        Real[3] a;
3802    end R;
3803    function f
3804        input Real[3] x;
3805        Real[size(x,1)] t;
3806        output R y1;
3807      algorithm
3808        t := x;
3809        y1 := R(t);
3810        t[1] := 0;
3811    end f;
3812    constant Real[3] y1 = {1,2,3};
3813    constant R y2 = f(y1);
3814   
3815    annotation(__JModelica(UnitTesting(tests={
3816        FlatteningTestCase(
3817            name="AssigningCached4",
3818            description="",
3819            flatModel="
3820fclass EvaluationTests.AssigningCached4
3821 constant Real y1[3] = {1, 2, 3};
3822 constant EvaluationTests.AssigningCached4.R y2 = EvaluationTests.AssigningCached4.R({1, 2, 3});
3823
3824public
3825 function EvaluationTests.AssigningCached4.f
3826  input Real[:] x;
3827  Real[:] t;
3828  output EvaluationTests.AssigningCached4.R y1;
3829 algorithm
3830  assert(3 == size(x, 1), \"Mismatching sizes in function 'EvaluationTests.AssigningCached4.f', component 'x', dimension '1'\");
3831  init t as Real[3];
3832  t[1:3] := x[1:3];
3833  y1 := EvaluationTests.AssigningCached4.R(t);
3834  t[1] := 0;
3835  return;
3836 end EvaluationTests.AssigningCached4.f;
3837
3838 record EvaluationTests.AssigningCached4.R
3839  Real a[3];
3840 end EvaluationTests.AssigningCached4.R;
3841
3842end EvaluationTests.AssigningCached4;
3843")})));
3844end AssigningCached4;
3845
3846model AssigningCached5
3847    function f
3848        input Integer n;
3849        Real[n2] k = 1:n2;
3850        Integer n2 = n;
3851        output Real u = sum(k);
3852    algorithm
3853        annotation(Inline=false);
3854    end f;
3855
3856    Real y = f(1);
3857   
3858    annotation(__JModelica(UnitTesting(tests={
3859        TransformCanonicalTestCase(
3860            name="AssigningCached5",
3861            description="",
3862            flatModel="
3863fclass EvaluationTests.AssigningCached5
3864 constant Real y = 1.0;
3865end EvaluationTests.AssigningCached5;
3866")})));
3867end AssigningCached5;
3868
3869
3870model ParameterMinMax1
3871    parameter Integer n(min=1);
3872    Real[n] x = if n < 2 then {2} else 1:n;
3873
3874    annotation(__JModelica(UnitTesting(tests={
3875        FlatteningTestCase(
3876            name="ParameterMinMax1",
3877            description="Constricting evaluation of parameters without binding expression to min-max range",
3878            flatModel="
3879fclass EvaluationTests.ParameterMinMax1
3880 structural parameter Integer n = 1 /* 1 */;
3881 Real x[1] = {2};
3882end EvaluationTests.ParameterMinMax1;
3883")})));
3884end ParameterMinMax1;
3885
3886
3887model ParameterMinMax2
3888    parameter Integer n(min=1, start=2);
3889    Real[n] x = if n < 2 then {2} else 1:n;
3890
3891    annotation(__JModelica(UnitTesting(tests={
3892        FlatteningTestCase(
3893            name="ParameterMinMax2",
3894            description="Constricting evaluation of parameters without binding expression to min-max range",
3895            flatModel="
3896fclass EvaluationTests.ParameterMinMax2
3897 structural parameter Integer n = 2 /* 2 */;
3898 Real x[2] = 1:2;
3899end EvaluationTests.ParameterMinMax2;
3900")})));
3901end ParameterMinMax2;
3902
3903
3904model ParameterMinMax3
3905    parameter Integer n(max=-1);
3906    Real[-n] x = if n > -2 then {2} else 1:(-n);
3907
3908    annotation(__JModelica(UnitTesting(tests={
3909        FlatteningTestCase(
3910            name="ParameterMinMax3",
3911            description="Constricting evaluation of parameters without binding expression to min-max range",
3912            flatModel="
3913fclass EvaluationTests.ParameterMinMax3
3914 structural parameter Integer n = -1 /* -1 */;
3915 Real x[1] = {2};
3916end EvaluationTests.ParameterMinMax3;
3917")})));
3918end ParameterMinMax3;
3919
3920
3921model ParameterMinMax4
3922    parameter Integer n(max=-1, start=-2);
3923    Real[-n] x = if n > -2 then {2} else 1:(-n);
3924
3925    annotation(__JModelica(UnitTesting(tests={
3926        FlatteningTestCase(
3927            name="ParameterMinMax4",
3928            description="Constricting evaluation of parameters without binding expression to min-max range",
3929            flatModel="
3930fclass EvaluationTests.ParameterMinMax4
3931 structural parameter Integer n = -2 /* -2 */;
3932 Real x[2] = 1:2;
3933end EvaluationTests.ParameterMinMax4;
3934")})));
3935end ParameterMinMax4;
3936
3937
3938model ParameterMinMax5
3939    parameter Real n(min=1.2);
3940    Real[integer(n)] x = 1:size(x,1);
3941
3942    annotation(__JModelica(UnitTesting(tests={
3943        FlatteningTestCase(
3944            name="ParameterMinMax5",
3945            description="Constricting evaluation of parameters without binding expression to min-max range",
3946            flatModel="
3947fclass EvaluationTests.ParameterMinMax5
3948 structural parameter Real n = 1.2 /* 1.2 */;
3949 Real x[1] = 1:size(x[1:1], 1);
3950end EvaluationTests.ParameterMinMax5;
3951")})));
3952end ParameterMinMax5;
3953
3954
3955model ParameterMinMax6
3956    parameter Real n(max=-1.2);
3957    Real[integer(-n)] x = 1:size(x,1);
3958
3959    annotation(__JModelica(UnitTesting(tests={
3960        FlatteningTestCase(
3961            name="ParameterMinMax6",
3962            description="Constricting evaluation of parameters without binding expression to min-max range",
3963            flatModel="
3964fclass EvaluationTests.ParameterMinMax6
3965 structural parameter Real n = -1.2 /* -1.2 */;
3966 Real x[1] = 1:size(x[1:1], 1);
3967end EvaluationTests.ParameterMinMax6;
3968")})));
3969end ParameterMinMax6;
3970
3971
3972model ParameterMinMax7
3973    type A = enumeration(a, b, c, d, e);
3974    type B = A(start = B.c);
3975    parameter B n(min=B.d);
3976    Real[Integer(n)] x = 1:size(x,1);
3977
3978    annotation(__JModelica(UnitTesting(tests={
3979        FlatteningTestCase(
3980            name="ParameterMinMax7",
3981            description="Constricting evaluation of parameters without binding expression to min-max range",
3982            flatModel="
3983fclass EvaluationTests.ParameterMinMax7
3984 structural parameter EvaluationTests.ParameterMinMax7.B n = EvaluationTests.ParameterMinMax7.A.d /* EvaluationTests.ParameterMinMax7.A.d */;
3985 Real x[4] = 1:size(x[1:4], 1);
3986
3987public
3988 type EvaluationTests.ParameterMinMax7.B = enumeration(a, b, c, d, e)(start = EvaluationTests.ParameterMinMax7.A.c);
3989
3990 type EvaluationTests.ParameterMinMax7.A = enumeration(a, b, c, d, e);
3991
3992end EvaluationTests.ParameterMinMax7;
3993")})));
3994end ParameterMinMax7;
3995
3996
3997model ParameterMinMax8
3998    type A = enumeration(a, b, c, d, e);
3999    type B = A(start = B.c);
4000    parameter B n(max=B.b);
4001    Real[Integer(n)] x = 1:size(x,1);
4002
4003    annotation(__JModelica(UnitTesting(tests={
4004        FlatteningTestCase(
4005            name="ParameterMinMax8",
4006            description="Constricting evaluation of parameters without binding expression to min-max range",
4007            flatModel="
4008fclass EvaluationTests.ParameterMinMax8
4009 structural parameter EvaluationTests.ParameterMinMax8.B n = EvaluationTests.ParameterMinMax8.A.b /* EvaluationTests.ParameterMinMax8.A.b */;
4010 Real x[2] = 1:size(x[1:2], 1);
4011
4012public
4013 type EvaluationTests.ParameterMinMax8.B = enumeration(a, b, c, d, e)(start = EvaluationTests.ParameterMinMax8.A.c);
4014
4015 type EvaluationTests.ParameterMinMax8.A = enumeration(a, b, c, d, e);
4016
4017end EvaluationTests.ParameterMinMax8;
4018")})));
4019end ParameterMinMax8;
4020
4021
4022model ForLoopSizeVary1
4023    function f
4024        input Real x;
4025        output Real y = 0;
4026      algorithm
4027        for i in 1:3 loop
4028            for j in 1:i-1 loop
4029                y := y + j;
4030            end for;
4031        end for;
4032    end f;
4033   
4034    constant Real y1 = f(1);
4035    Real y2 = f(1);
4036   
4037    annotation(__JModelica(UnitTesting(tests={
4038        TransformCanonicalTestCase(
4039            name="ForLoopSizeVary1",
4040            description="Varying sizes in for loops",
4041            eliminate_alias_variables=false,
4042            inline_functions="none",
4043            flatModel="
4044fclass EvaluationTests.ForLoopSizeVary1
4045 constant Real y1 = 4.0;
4046 constant Real y2 = 4.0;
4047end EvaluationTests.ForLoopSizeVary1;
4048")})));
4049end ForLoopSizeVary1;
4050
4051model ForLoopSizeVary2
4052    function f
4053        input Real x;
4054        output Real y = 0;
4055      algorithm
4056        for i in 1:3 loop
4057            for j in 1:3-i loop
4058                y := y + j;
4059            end for;
4060        end for;
4061    end f;
4062   
4063    constant Real y1 = f(1);
4064    Real y2 = f(1);
4065   
4066    annotation(__JModelica(UnitTesting(tests={
4067        TransformCanonicalTestCase(
4068            name="ForLoopSizeVary2",
4069            description="Varying sizes in for loops",
4070            inline_functions="none",
4071            eliminate_alias_variables=false,
4072            flatModel="
4073fclass EvaluationTests.ForLoopSizeVary2
4074 constant Real y1 = 4.0;
4075 constant Real y2 = 4.0;
4076end EvaluationTests.ForLoopSizeVary2;
4077")})));
4078end ForLoopSizeVary2;
4079
4080model RelExpAlmost1
4081    constant Real eps = 1e-16;
4082    constant Boolean b1 = 1 >= 1 - eps;
4083    constant Boolean b2 = 1 <= 1 - eps;
4084    constant Boolean b3 = 1 > 1 - eps;
4085    constant Boolean b4 = 1 < 1 - eps;
4086    constant Boolean b5 = 0 < 1e-15;
4087   
4088    annotation(__JModelica(UnitTesting(tests={
4089        TransformCanonicalTestCase(
4090            name="RelExpAlmost1",
4091            description="Very close real comparisons",
4092            eliminate_alias_variables=false,
4093            flatModel="
4094fclass EvaluationTests.RelExpAlmost1
4095 constant Real eps = 1.0E-16;
4096 constant Boolean b1 = true;
4097 constant Boolean b2 = true;
4098 constant Boolean b3 = true;
4099 constant Boolean b4 = false;
4100 constant Boolean b5 = true;
4101end EvaluationTests.RelExpAlmost1;
4102")})));
4103end RelExpAlmost1;
4104
4105
4106model RelExpAlmost2
4107    constant Real eps = 1e-20;
4108    constant Boolean b1 = 0 > -eps;
4109    constant Boolean b2 = 0 < -eps;
4110    constant Boolean b3 = 0 > eps;
4111    constant Boolean b4 = 0 < eps;
4112    constant Boolean b5 = 1 > 1;
4113    constant Boolean b6 = 1 < 1;
4114
4115    annotation(__JModelica(UnitTesting(tests={
4116        TransformCanonicalTestCase(
4117            name="RelExpAlmost2",
4118            description="Very close real comparisons",
4119            eliminate_alias_variables=false,
4120            flatModel="
4121fclass EvaluationTests.RelExpAlmost2
4122 constant Real eps = 1.0E-20;
4123 constant Boolean b1 = true;
4124 constant Boolean b2 = false;
4125 constant Boolean b3 = false;
4126 constant Boolean b4 = true;
4127 constant Boolean b5 = false;
4128 constant Boolean b6 = false;
4129end EvaluationTests.RelExpAlmost2;
4130")})));
4131end RelExpAlmost2;
4132
4133
4134model FScalarExpEval
4135    constant Real x = scalar({1});
4136    Integer y = 1.0; // Generate error so we can use error test
4137
4138    annotation(__JModelica(UnitTesting(tests={
4139        ComplianceErrorTestCase(
4140            name="FScalarExpEval",
4141            description="Check that scalar() can be constant evaluated (before scalarization)",
4142            errorMessage="
41431 errors found:
4144
4145Error at line 3, column 17, in file 'Compiler/ModelicaFlatTree/src/test/EvaluationTests.mo', BINDING_EXPRESSION_TYPE_MISMATCH:
4146  The binding expression of the variable y does not match the declared type of the variable
4147")})));
4148end FScalarExpEval;
4149
4150model Atan2
4151    constant Real x1 = atan2(1,5);
4152    Real x2 = atan2(1,5);
4153   
4154    constant Real x3 = atan2(0,5);
4155    constant Real x4 = atan2(1,0);
4156
4157    constant Real x5 = atan2(0,0);
4158
4159    annotation(__JModelica(UnitTesting(tests={
4160        TransformCanonicalTestCase(
4161            name="Atan2",
4162            description="Basic test of atan2().",
4163            eliminate_alias_variables=false,
4164            flatModel="
4165fclass EvaluationTests.Atan2
4166 constant Real x1 = 0.19739555984988078;
4167 constant Real x2 = 0.19739555984988078;
4168 constant Real x3 = 0.0;
4169 constant Real x4 = 1.5707963267948966;
4170 constant Real x5 = 0.0;
4171end EvaluationTests.Atan2;
4172")})));
4173end Atan2;
4174
4175
4176model RangeSubscript1
4177    function f
4178        input Real[2] x;
4179        output Real[2,2] y;
4180    algorithm
4181        y[1,:] := x[1:2];
4182        y[2,:] := {1,2};
4183    end f;
4184   
4185    model A
4186        parameter Real b[2];
4187    end A;
4188   
4189    A a[2](b = f(c));
4190    final parameter Real c[2] = {1,2};
4191
4192    annotation(__JModelica(UnitTesting(tests={
4193        TransformCanonicalTestCase(
4194            name="RangeSubscript1",
4195            description="Constant eval of non-slice array access with subscripts in flat tree",
4196            flatModel="
4197fclass EvaluationTests.RangeSubscript1
4198 final parameter Real c[1] = 1 /* 1 */;
4199 final parameter Real c[2] = 2 /* 2 */;
4200end EvaluationTests.RangeSubscript1;
4201")})));
4202end RangeSubscript1;
4203
4204model RangeSubscript2
4205    function f
4206        input Real[:] x;
4207        output Integer[size(x,1)] i;
4208        output Real[size(x,1)] y;
4209    algorithm
4210        i := 1:size(x,1);
4211        y := x[i];
4212    end f;
4213   
4214    constant Real[:] y1 = f({1,2});
4215    Real[:] y2 = f({1,2,3});
4216
4217    annotation(__JModelica(UnitTesting(tests={
4218        TransformCanonicalTestCase(
4219            name="RangeSubscript2",
4220            description="Test proper flush for sizes after evaluation",
4221            variability_propagation=false,
4222            inline_functions="none",
4223            flatModel="
4224fclass EvaluationTests.RangeSubscript2
4225 constant Real y1[1] = 1;
4226 constant Real y1[2] = 2;
4227 Real y2[1];
4228 Real y2[2];
4229 Real y2[3];
4230equation
4231 ({y2[1], y2[2], y2[3]}) = EvaluationTests.RangeSubscript2.f({1, 2, 3});
4232
4233public
4234 function EvaluationTests.RangeSubscript2.f
4235  input Real[:] x;
4236  output Integer[:] i;
4237  output Real[:] y;
4238 algorithm
4239  init i as Integer[size(x, 1)];
4240  init y as Real[size(x, 1)];
4241  for i1 in 1:size(x, 1) loop
4242   i[i1] := i1;
4243  end for;
4244  for i1 in 1:size(x, 1) loop
4245   y[i1] := x[i[i1]];
4246  end for;
4247  return;
4248 end EvaluationTests.RangeSubscript2.f;
4249
4250end EvaluationTests.RangeSubscript2;
4251")})));
4252end RangeSubscript2;
4253
4254model ConstantInFunction1
4255    record R
4256        Real x;
4257    end R;
4258   
4259    constant R[:] r = {R(1),R(2)};
4260   
4261    function f
4262        input Integer i;
4263        output Real y = r[i].x;
4264    algorithm
4265        y := y + r[i].x;
4266    end f;
4267   
4268    constant Real y = f(1) + f(2);
4269
4270    annotation(__JModelica(UnitTesting(tests={
4271        TransformCanonicalTestCase(
4272            name="ConstantInFunction1",
4273            description="Constant eval of composite array package constant in function",
4274            flatModel="
4275fclass EvaluationTests.ConstantInFunction1
4276 constant Real r[1].x = 1;
4277 constant Real r[2].x = 2;
4278 constant Real y = 6.0;
4279end EvaluationTests.ConstantInFunction1;
4280")})));
4281end ConstantInFunction1;
4282
4283model ConstantInFunction2
4284    record R
4285        Real x;
4286    end R;
4287   
4288    constant R[:] r = {R(1),R(2)};
4289   
4290    function f
4291        input Integer i;
4292        output Real y = r[i].x;
4293    algorithm
4294        y := y + r[i].x;
4295    end f;
4296   
4297    constant Real y1 = f(2);
4298    constant Real y2 = f(1);
4299
4300    annotation(__JModelica(UnitTesting(tests={
4301        TransformCanonicalTestCase(
4302            name="ConstantInFunction2",
4303            description="Constant eval of composite array package constant in function",
4304            flatModel="
4305fclass EvaluationTests.ConstantInFunction2
4306 constant Real r[1].x = 1;
4307 constant Real r[2].x = 2;
4308 constant Real y1 = 4.0;
4309 constant Real y2 = 2.0;
4310end EvaluationTests.ConstantInFunction2;
4311")})));
4312end ConstantInFunction2;
4313
4314model ZeroSizeRecordArray1
4315    record R
4316        Real x = 1;
4317    end R;
4318   
4319    constant R[0] r;
4320
4321    annotation(__JModelica(UnitTesting(tests={
4322        TransformCanonicalTestCase(
4323            name="ZeroSizeRecordArray1",
4324            description="",
4325            flatModel="
4326fclass EvaluationTests.ZeroSizeRecordArray1
4327end EvaluationTests.ZeroSizeRecordArray1;
4328")})));
4329end ZeroSizeRecordArray1;
4330
4331model EvaluatePartialFunction1
4332    function g
4333        input Integer[:] x;
4334        output Integer y;
4335    algorithm
4336        y := sum(x);
4337    end g;
4338
4339    function f
4340        input Integer x;
4341        output Integer y;
4342    end f;
4343   
4344    constant Integer[:] n = g(f({{2}}));
4345
4346    annotation(__JModelica(UnitTesting(tests={
4347        ErrorTestCase(
4348            name="EvaluatePartialFunction1",
4349            description="Check for no NullPointerException when evaluating partial vectorized function",
4350            errorMessage="
4351Error at line 14, column 29, in file '...':
4352  Could not evaluate binding expression for constant 'n': 'g(f({{2}}))'
4353
4354Error at line 14, column 31, in file '...':
4355  Calling function f(): can only call functions that have one algorithm section or external function specification
4356")})));
4357end EvaluatePartialFunction1;
4358
4359end EvaluationTests;
Note: See TracBrowser for help on using the repository browser.