source: trunk/Python/src/tests_jmodelica/files/Modelica/ExtFunctionTests.mo @ 13719

Last change on this file since 13719 was 13719, checked in by Christian Andersson, 8 weeks ago

Recommitted changeset:13700 to trunk with two bug fixes. Related to ticket:5837

File size: 38.4 KB
Line 
1package ExtFunctionTests
2
3model Evaluator_Double
4    function d_i
5     input Integer a;
6     output Real b;
7
8     external "C" b=f_d_i(a) annotation(Library="evaluatorTestsShared",
9                             Include="#include \"evaluatorTests.h\"");
10    end d_i;
11   
12    function d_idd
13     input Integer a;
14     input Real b;
15     input Real c;
16     output Real d;
17
18     external "C" d=f_d_idd(a,b,c) annotation(Library="evaluatorTestsShared",
19                             Include="#include \"evaluatorTests.h\"");
20    end d_idd;
21   
22   
23    Real c = d_i(1);
24    Real d = d_idd(1, 2.0, 3.0);
25end Evaluator_Double;
26
27model Evaluator_Integer
28    function i_ii
29     input Integer a;
30     input Integer b;
31     output Integer c;
32
33     external "C" c=f_i_ii(a,b) annotation(Library="evaluatorTestsShared",
34                             Include="#include \"evaluatorTests.h\"");
35    end i_ii;
36   
37    constant Integer c = i_ii(1,2);
38end Evaluator_Integer;
39
40model Evaluator_Record
41    record R
42        Real x0;
43        Real x1;
44        Real x2;
45        Real x3;
46        Real x4;
47        Real x5;
48        Real x6;
49        Real x7;
50        Real x8;
51        Real x9;
52        Real x10;
53    end R;
54    function iddpR_ddddddddddd_
55     input Integer a;
56     input Real b;
57     input Real c;
58     output R d;
59
60     external "C" f___iddpR_ddddddddddd_(a,b,c,d) annotation(Library="evaluatorTestsShared",
61                             Include="#include \"evaluatorTests.h\"");
62    end iddpR_ddddddddddd_;
63   
64    constant R c = iddpR_ddddddddddd_(1,2.0,3.0);
65end Evaluator_Record;
66
67
68model Evaluator_Substring
69    constant String full="Yy00";
70    constant String sub=Modelica.Utilities.Strings.substring(full,1,1);
71    constant String string1 = "This is line 111";
72    constant String string2 = Modelica.Utilities.Strings.substring(string1,9,12); // string2 = \"line\"
73    constant Integer len = Modelica.Utilities.Strings.length(string1);
74    constant Integer start = Modelica.Utilities.Strings.Advanced.skipWhiteSpace("   Hello", 1);
75    constant Boolean not_equal = Modelica.Utilities.Strings.isEqual("Temp", "test", true);
76    constant Boolean equal = Modelica.Utilities.Strings.isEqual("Temp", "Temp", true);
77end Evaluator_Substring;
78
79model Evaluator_Add
80 function add1
81     input Real a;
82     input Real b;
83     output Real c;
84
85     external "C" c=add(a,b) annotation(Library="addNumbersShared",
86                             Include="#include \"addNumbers.h\"");
87 end add1;
88 
89 function add2
90     input Real a;
91     input Real b;
92     output Real c;
93
94     external "C" add_output(a,b,c) annotation(Library="addNumbersShared",
95                             Include="#include \"addNumbers.h\"");
96 end add2;
97
98 constant Real a = 1;
99 constant Real b = 2;
100 Real c = add1(a,b);
101 Real d = add2(a,b);
102end Evaluator_Add;
103
104model Evaluator_Multiple_Add
105 function add
106     input Real a;
107     input Real b;
108     input Real c;
109     input Real d;
110     input Real e;
111     input Real f;
112     input Real g;
113     input Real h;
114     input Real i;
115     output Real o;
116
117     external "C" o=multiple_add(a,b,c,d,e,f,g,h,i) annotation(Library="addNumbersShared",
118                             Include="#include \"addNumbers.h\"");
119 end add;
120 
121 constant Real a = 1;
122 constant Real b = 2;
123 Real c = add(a,b,a,b,a,b,a,b,a);
124end Evaluator_Multiple_Add;
125
126model Evaluator_Unknown_Shared
127    function unknown_function
128        input Real a;
129        output Real b;
130        external "C" b = unknown(a) annotation(Library="unknown");
131    end unknown_function;
132   
133    constant Real a = unknown_function(1.0);
134end Evaluator_Unknown_Shared;
135
136model ExtFunctionTest1
137 Real a(start=1) = 1;
138 Real b(start=2) = 2;
139 Real c(start=2);
140
141equation
142  c = add(a,b);
143
144end ExtFunctionTest1;
145
146function add
147 input Real a;
148 input Real b;
149 output Real c;
150
151 external "C" annotation(Library="addNumbers",
152                         Include="#include \"addNumbers.h\"");
153end add;
154
155model ExtFunctionTest2
156   
157function extFunc1
158    input Real m;
159    input Real[:,:,:] a;
160    input Integer[size(a,1),size(a,2),size(a,3)] b;
161    input Boolean[size(a,1),size(a,2)] c;
162    output Real sum;
163    output Real[size(a,1),size(a,2),size(a,3)] o;
164    output Real[size(a,1)*size(a,2)*size(a,3)] step;
165    external "C" annotation(
166        Library="arrayFunctions",
167        Include="#include \"arrayFunctions.h\"");
168end extFunc1;
169
170Real[3,3,3] x;
171Real s;
172Real[27] step;
173
174constant Real arg1 = 3.14;
175constant Real[3,3,3] arg2 = {{{1e1,1e2,1e3},{1e4,1e5,1e6},{1e7,1e8,1e9}},{{1,1,1},{1,1,1},{1,1,1}},{{1e-1,1e-2,1e-3},{1e-4,1e-5,1e-6},{1e-7,1e-8,1e-9}}};
176constant Integer[3,3,3] arg3 = {{{1,2,3},{4,5,6},{7,8,9}},{{11,12,13},{14,15,16},{17,18,19}},{{21,22,23},{24,25,26},{27,28,29}}};
177constant Boolean[3,3] arg4 = {{true,true,true},{true, false, true},{false,true,false}};
178equation
179    (s,x,step) = extFunc1(arg1, arg2, arg3, arg4);
180
181end ExtFunctionTest2;
182
183model ExtFunctionBool
184   
185function copyBoolArray
186    input Boolean[:] a;
187    output Boolean[size(a,1)] b;
188    external "C" annotation(
189        Library="arrayFunctions",
190        Include="#include \"arrayFunctions.h\"");
191end copyBoolArray;
192
193constant Boolean[8] arg = {true,true,true,false,true,false,false,true};
194Boolean[8] res;
195equation
196    res = copyBoolArray(arg);
197end ExtFunctionBool;
198
199model ExtFunctionRecord
200    record R
201        Real x;
202    end R;
203    function fRecord
204        input R r;
205        output R y;
206      external "C" fRecord(r,y) annotation(
207        Library="externalFunctionsC",
208        Include="#include \"externalFunctionsC.h\"");
209    end fRecord;
210    R y = fRecord(R(time));
211end ExtFunctionRecord;
212
213model ExtFunctionRecordCeval
214    record R
215        Real x;
216    end R;
217    function fRecord
218        input R r;
219        output R y;
220      external "C" fRecord(r,y) annotation(
221        Library="externalFunctionsC",
222        Include="#include \"externalFunctionsC.h\"");
223    end fRecord;
224    constant R y1 = fRecord(R(3));
225    R y2 = fRecord(R(3));
226end ExtFunctionRecordCeval;
227
228model ExtFunctionRecordObj
229    record R1
230        R2 r2;
231    end R1;
232    record R2
233        Real x;
234    end R2;
235   
236    model EO
237        extends ExternalObject;
238        function constructor
239            input R1 r1;
240            output EO eo;
241            external "C" eo=eo_constructor_record(r1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
242        end constructor;
243        function destructor
244            input EO eo;
245            external "C" eo_destructor_record(eo) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
246        end destructor;
247    end EO;
248   
249    function f
250        input EO eo;
251        output Real y;
252        external "C" y=eo_use_record(eo) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
253    end f;
254   
255    parameter EO eo = EO(R1(R2(3)));
256    parameter Real y = f(eo);
257end ExtFunctionRecordObj;
258
259model ExtFunctionRecordObjCeval
260    extends ExtFunctionRecordObj;
261    parameter Integer n = integer(y);
262    Real[:] x = 1:n;
263end ExtFunctionRecordObjCeval;
264
265model ExtFunctionTest3
266 Real a(start=10);
267 Real b;
268   
269 equation
270   b = testModelicaMessages(5);
271   testModelicaErrorMessages();
272   testModelicaAllocateStrings();
273   der(a) = a;
274 
275end ExtFunctionTest3;
276
277function testModelicaMessages
278input Real a;
279output Real b;
280    external "C" annotation(Include="#include \"testModelicaUtilities.c\"");
281end testModelicaMessages;
282
283function testModelicaErrorMessages
284    external "C" annotation(Include="#include \"testModelicaUtilities.c\"");
285end testModelicaErrorMessages;
286
287function testModelicaAllocateStrings
288    external "C" annotation(Include="#include \"testModelicaUtilities.c\"");
289end testModelicaAllocateStrings;
290
291model ExtFunctionTest4
292    Integer[3] myArray = {1,2,3};
293    Integer[3] myResult = doubleArray(myArray);
294   
295end ExtFunctionTest4;
296
297function doubleArray
298    input Integer[3] arr;
299    output Integer[3] res;
300
301    external "C" multiplyAnArray(arr, res, 3, 2) annotation(Include="#include \"addNumbers.h\"", Library="addNumbers");
302end doubleArray;
303
304class FileOnDelete
305    extends ExternalObject;
306   
307    function constructor
308        input String name;
309        output FileOnDelete out;
310        external "C" out = constructor_string(name) 
311            annotation(Library="extObjects", Include="#include \"extObjects.h\"");
312    end constructor;
313   
314    function destructor
315        input FileOnDelete obj;
316        external "C" destructor_string_create_file(obj) 
317            annotation(Library="extObjects", Include="#include \"extObjects.h\"");
318    end destructor; 
319end FileOnDelete;
320
321function use_FOD
322    input FileOnDelete obj;
323    output Real x;
324    external "C" x = constant_extobj_func(obj) 
325        annotation(Library="extObjects", Include="#include \"extObjects.h\"");
326end use_FOD;
327
328model ExternalObjectTests1
329    FileOnDelete obj = FileOnDelete("test_ext_object.marker");
330    Real x = use_FOD(obj);
331end ExternalObjectTests1;
332
333model ExternalObjectTests2
334    FileOnDelete myEOs[2] = { FileOnDelete("test_ext_object_array1.marker"), FileOnDelete("test_ext_object_array2.marker")};
335    Real z;
336
337 function get_y
338    input FileOnDelete eos[:];
339    output Real y;
340 algorithm
341    y := use_FOD(eos[1]);
342 end get_y;
343 
344equation
345    z = get_y(myEOs); 
346end ExternalObjectTests2;
347
348class ConstructorSingleCall
349    extends ExternalObject;
350   
351    function constructor
352        input String name;
353        output ConstructorSingleCall out;
354        external "C" out = constructor_error_multiple_calls(name) 
355            annotation(Library="extObjects", Include="#include \"extObjects.h\"");
356    end constructor;
357   
358    function destructor
359        input ConstructorSingleCall obj;
360        external "C" destructor(obj) 
361            annotation(Library="extObjects", Include="#include \"extObjects.h\"");
362    end destructor; 
363end ConstructorSingleCall;
364
365model ConstructorSingleCallTest
366    ConstructorSingleCall obj = ConstructorSingleCall("test_ext_object.marker");
367end ConstructorSingleCallTest;
368
369model ConstructorSingleCallDepTest
370    parameter String s = "test_ext_object.marker";
371    ConstructorSingleCall obj = ConstructorSingleCall(s);
372end ConstructorSingleCallDepTest;
373
374model ExternalInfinityTest
375function whileTrue
376    input Real a;
377    output Real b;
378    external "C" annotation(
379        Library="arrayFunctions",
380        Include="#include \"arrayFunctions.h\"");
381end whileTrue;
382    Real x;
383equation
384    x = whileTrue(1);
385end ExternalInfinityTest;
386
387model ExternalInfinityTestCeval
388function whileTrue
389    input Real a;
390    output Real b;
391    external "C" annotation(
392        Library="arrayFunctions",
393        Include="#include \"arrayFunctions.h\"");
394end whileTrue;
395    constant Real x = whileTrue(1);
396end ExternalInfinityTestCeval;
397
398package CEval
399  package C
400    model RealTest
401      function fRealScalar
402        input  Real x_in;
403        output Real x_out;
404      external "C" annotation(
405        Library="externalFunctionsC",
406        Include="#include \"externalFunctionsC.h\"");
407      end fRealScalar;
408     
409      function fRealArray
410        input  Real[2] x_in;
411        output Real[size(x_in,1)] x_out;
412      external "C" annotation(
413        Library="externalFunctionsC",
414        Include="#include \"externalFunctionsC.h\"");
415      end fRealArray;
416     
417      function fRealArrayUnknown
418        input  Real[:] x_in;
419        output Real[size(x_in,1)] x_out;
420      external "C" fRealArray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
421        Library="externalFunctionsC",
422        Include="#include \"externalFunctionsC.h\"");
423      end fRealArrayUnknown;
424
425      constant Real    xScalar        = fRealScalar(3);
426      constant Real[2] xArray         = fRealArray({4,5});
427      constant Real[2] xArrayUnknown  = fRealArrayUnknown({6,7});
428    end RealTest;
429   
430    model IntegerTest
431      function fIntegerScalar
432        input  Integer x_in;
433        output Integer x_out;
434      external "C" annotation(
435        Library="externalFunctionsC",
436        Include="#include \"externalFunctionsC.h\"");
437      end fIntegerScalar;
438     
439      function fIntegerArray
440        input  Integer[2] x_in;
441        output Integer[size(x_in,1)] x_out;
442      external "C" annotation(
443        Library="externalFunctionsC",
444        Include="#include \"externalFunctionsC.h\"");
445      end fIntegerArray;
446     
447      function fIntegerArrayUnknown
448        input  Integer[:] x_in;
449        output Integer[size(x_in,1)] x_out;
450      external "C" fIntegerArray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
451        Library="externalFunctionsC",
452        Include="#include \"externalFunctionsC.h\"");
453      end fIntegerArrayUnknown;
454
455      constant Integer    xScalar        = fIntegerScalar(3);
456      constant Integer[2] xArray         = fIntegerArray({4,5});
457      constant Integer[2] xArrayUnknown  = fIntegerArrayUnknown({6,7});
458    end IntegerTest;
459   
460    model BooleanTest
461      function fBooleanScalar
462        input  Boolean x_in;
463        output Boolean x_out;
464      external "C" annotation(
465        Library="externalFunctionsC",
466        Include="#include \"externalFunctionsC.h\"");
467      end fBooleanScalar;
468     
469      function fBooleanArray
470        input  Boolean[2] x_in;
471        output Boolean[size(x_in,1)] x_out;
472      external "C" annotation(
473        Library="externalFunctionsC",
474        Include="#include \"externalFunctionsC.h\"");
475      end fBooleanArray;
476     
477      function fBooleanArrayUnknown
478        input  Boolean[:] x_in;
479        output Boolean[size(x_in,1)] x_out;
480      external "C" fBooleanArray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
481        Library="externalFunctionsC",
482        Include="#include \"externalFunctionsC.h\"");
483      end fBooleanArrayUnknown;
484
485      constant Boolean    xScalar        = fBooleanScalar(true);
486      constant Boolean[2] xArray         = fBooleanArray({false,false});
487      constant Boolean[2] xArrayUnknown  = fBooleanArrayUnknown({false,true});
488    end BooleanTest;
489   
490    model StringTest
491      function fStringScalar
492        input  String x_in;
493        output String x_out;
494      external "C" annotation(
495        Library="externalFunctionsC",
496        Include="#include \"externalFunctionsC.h\"");
497      end fStringScalar;
498     
499      function fStringScalarLit
500        input  String x_in;
501        output String x_out;
502      external "C" annotation(
503        Library="externalFunctionsC",
504        Include="#include \"externalFunctionsC.h\"");
505      end fStringScalarLit;
506     
507      function fStringArray
508        input  String[2] x_in;
509        output String[size(x_in,1)] x_out;
510      external "C" annotation(
511        Library="externalFunctionsC",
512        Include="#include \"externalFunctionsC.h\"");
513      end fStringArray;
514     
515      function fStringArrayUnknown
516        input  String[:] x_in;
517        output String[size(x_in,1)] x_out;
518      external "C" fStringArray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
519        Library="externalFunctionsC",
520        Include="#include \"externalFunctionsC.h\"");
521      end fStringArrayUnknown;
522     
523      function fStrlen
524        input String s;
525        output Integer n;
526      external "C" n = fStrlen(s) annotation(
527        Library="externalFunctionsC",
528        Include="#include \"externalFunctionsC.h\"");
529      end fStrlen;
530
531      constant Integer   len            = fStrlen("abcde");
532      constant String    xScalar        = fStringScalar("abcde");
533      constant String    xScalarLit     = fStringScalarLit("abcde");
534      constant String[2] xArray         = fStringArray({"abc","def"});
535      constant String[2] xArrayUnknown  = fStringArrayUnknown({"abc","def"});
536    end StringTest;
537   
538    model EnumTest
539      type E = enumeration(E1,E2);
540      function fEnumScalar
541        input  E x_in;
542        output E x_out;
543      external "C" annotation(
544        Library="externalFunctionsC",
545        Include="#include \"externalFunctionsC.h\"");
546      end fEnumScalar;
547     
548      function fEnumArray
549        input  E[2] x_in;
550        output E[size(x_in,1)] x_out;
551      external "C" annotation(
552        Library="externalFunctionsC",
553        Include="#include \"externalFunctionsC.h\"");
554      end fEnumArray;
555   
556      function fEnumArrayUnknown
557        input  E[:] x_in;
558        output E[size(x_in,1)] x_out;
559      external "C" fEnumArray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
560        Library="externalFunctionsC",
561        Include="#include \"externalFunctionsC.h\"");
562      end fEnumArrayUnknown;
563     
564      constant E    xScalar        = fEnumScalar(E.E1);
565      constant E[2] xArray         = fEnumArray({E.E2,E.E1});
566      constant E[2] xArrayUnknown  = fEnumArrayUnknown({E.E1,E.E2});
567    end EnumTest;
568   
569    model ShortClass
570        function f1
571            input Real x;
572            output Real y;
573          external y = fRealScalar(x) annotation(
574            Library="externalFunctionsC",
575            Include="#include \"externalFunctionsC.h\"");
576        end f1;
577        function f2 = f1(x(min=1));
578        function f3 = f2;
579        function f4 = f3(x(max=2));
580        constant Real a1 = f1(1) + f2(2) + f3(3) + f4(4);
581    end ShortClass;
582   
583    model PackageConstantTest
584      constant Real[2] c = {4,5};
585     
586      function f
587        output Real[2] x_out;
588      external "C" fRealArray(c, size(c,1), x_out, size(x_out,1)) annotation(
589        Library="externalFunctionsC",
590        Include="#include \"externalFunctionsC.h\"");
591      end f;
592   
593      constant Real[2] x  = f();
594    end PackageConstantTest;
595   
596  end C;
597 
598  package Fortran
599    model RealTest
600      function frealscalar
601        input  Real x_in;
602        output Real x_out;
603      external "FORTRAN 77" annotation(
604        Library="externalFunctionsFortran");
605      end frealscalar;
606     
607      function frealarray
608        input  Real[2] x_in;
609        output Real[size(x_in,1)] x_out;
610      external "FORTRAN 77" annotation(
611        Library="externalFunctionsFortran");
612      end frealarray;
613   
614      function frealarrayunknown
615        input  Real[:] x_in;
616        output Real[size(x_in,1)] x_out;
617      external "FORTRAN 77" frealarray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
618        Library="externalFunctionsFortran");
619      end frealarrayunknown;
620     
621      constant Real    xScalar        = frealscalar(3);
622      constant Real[2] xArray         = frealarray({4,5});
623      constant Real[2] xArrayUnknown  = frealarrayunknown({6,7});
624    end RealTest;
625   
626    model RealTestMatrix
627      function frealmatrix
628        input  Real[:,:] x_in;
629        output Real[size(x_in,1), size(x_in,2)] x_out;
630      external "FORTRAN 77" frealmatrix(size(x_in,1), size(x_in,2), x_in, x_out) annotation(
631        Library="externalFunctionsFortran");
632      end frealmatrix;
633     
634      constant Real[1,1] y1  = frealmatrix({{1}});
635      constant Real[2,2] y2  = frealmatrix({{6,7},{8,9}});
636    end RealTestMatrix;
637   
638    model IntegerTest
639      function fintegerscalar
640        input  Integer x_in;
641        output Integer x_out;
642      external "FORTRAN 77" annotation(
643        Library="externalFunctionsFortran");
644      end fintegerscalar;
645     
646      function fintegerarray
647        input  Integer[2] x_in;
648        output Integer[size(x_in,1)] x_out;
649      external "FORTRAN 77" annotation(
650        Library="externalFunctionsFortran");
651      end fintegerarray;
652   
653      function fintegerarrayunknown
654        input  Integer[:] x_in;
655        output Integer[size(x_in,1)] x_out;
656      external "FORTRAN 77" fintegerarray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
657        Library="externalFunctionsFortran");
658      end fintegerarrayunknown;
659     
660      constant Integer    xScalar        = fintegerscalar(3);
661      constant Integer[2] xArray         = fintegerarray({4,5});
662      constant Integer[2] xArrayUnknown  = fintegerarrayunknown({6,7});
663    end IntegerTest;
664   
665    model BooleanTest
666      function fbooleanscalar
667        input  Boolean x_in;
668        output Boolean x_out;
669      external "FORTRAN 77" annotation(
670        Library="externalFunctionsFortran");
671      end fbooleanscalar;
672     
673      function fbooleanarray
674        input  Boolean[2] x_in;
675        output Boolean[size(x_in,1)] x_out;
676      external "FORTRAN 77" annotation(
677        Library="externalFunctionsFortran");
678      end fbooleanarray;
679   
680      function fbooleanarrayunknown
681        input  Boolean[:] x_in;
682        output Boolean[size(x_in,1)] x_out;
683      external "FORTRAN 77" fbooleanarray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
684        Library="externalFunctionsFortran");
685      end fbooleanarrayunknown;
686     
687      constant Boolean    xScalar        = fbooleanscalar(true);
688      constant Boolean[2] xArray         = fbooleanarray({false,false});
689      constant Boolean[2] xArrayUnknown  = fbooleanarrayunknown({false,true});
690    end BooleanTest;
691
692    model EnumTest
693      type E = enumeration(E1,E2);
694      function fenumscalar
695        input  E x_in;
696        output E x_out;
697      external "FORTRAN 77" annotation(
698        Library="externalFunctionsFortran");
699      end fenumscalar;
700     
701      function fenumarray
702        input  E[2] x_in;
703        output E[size(x_in,1)] x_out;
704      external "FORTRAN 77" annotation(
705        Library="externalFunctionsFortran");
706      end fenumarray;
707   
708      function fenumarrayunknown
709        input  E[:] x_in;
710        output E[size(x_in,1)] x_out;
711      external "FORTRAN 77" fenumarray(x_in, size(x_in,1), x_out, size(x_in,1)) annotation(
712        Library="externalFunctionsFortran");
713      end fenumarrayunknown;
714     
715      constant E    xScalar        = fenumscalar(E.E1);
716      constant E[2] xArray         = fenumarray({E.E2,E.E1});
717      constant E[2] xArrayUnknown  = fenumarrayunknown({E.E1,E.E2});
718    end EnumTest;
719  end Fortran;
720 
721  package Utility
722    model LogTest
723      function func_with_ModelicaError
724        input  Real x_in;
725        output Real x_out;
726      external "C" annotation(Library="useModelicaError",
727                         Include="#include \"useModelicaError.h\"");
728      end func_with_ModelicaError;
729
730      Real xLog   = func_with_ModelicaError(1.1);
731      Real xError = func_with_ModelicaError(2.1);
732    end LogTest;
733  end Utility;
734 
735  package Advanced
736    model DgelsxTest
737      function dgelsx
738        "Computes the minimum-norm solution to a real linear least squares problem with rank deficient A"
739        input Real A[3, 2];
740        input Real B[size(A, 1), 3];
741        input Real rcond=0.0 "Reciprocal condition number to estimate rank";
742        output Real X[max(size(A, 1), size(A, 2)), size(B, 2)]=cat(
743                1,
744                B,
745                zeros(max(nrow, ncol) - nrow, nrhs))
746        "Solution is in first size(A,2) rows";
747        output Integer info;
748        output Integer rank "Effective rank of A";
749      protected
750        Integer nrow=size(A, 1);
751        Integer ncol=size(A, 2);
752        Integer nx=max(nrow, ncol);
753        Integer nrhs=size(B, 2);
754        Real work[max(min(size(A, 1), size(A, 2)) + 3*size(A, 2), 2*min(size(A, 1),
755          size(A, 2)) + size(B, 2))];
756        Real Awork[size(A, 1), size(A, 2)]=A;
757        Integer jpvt[size(A, 2)]=zeros(ncol);
758      external"FORTRAN 77" dgelsx(
759                nrow,
760                ncol,
761                nrhs,
762                Awork,
763                nrow,
764                X,
765                nx,
766                jpvt,
767                rcond,
768                rank,
769                work,
770                info);
771      end dgelsx;
772     
773      Real[3,3] out;
774      Real a;
775      Real b;
776    equation
777      (out,a,b) = dgelsx({{1,2},{3,4}, {5,6}},{{7,8,9},{10,11,12}, {13,14,15}});
778     
779    end DgelsxTest;
780    package Os
781    model Obj1
782        extends ExternalObject;
783        function constructor
784            input Real x;
785            input Integer y;
786            input Boolean b;
787            input String s;
788            output Obj1 o1;
789            external "C" o1 = my_constructor1(x,y,b,s)
790                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
791        end constructor;
792        function destructor
793            input Obj1 o1;
794            external "C"
795                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
796        end destructor;
797    end Obj1;
798    end Os;
799    model Obj2
800        extends ExternalObject;
801        function constructor
802            input Real[:] x;
803            input Integer[2] y;
804            input Boolean[:] b;
805            input String[:] s;
806            output Obj2 o2;
807            external "C" my_constructor2(x,y,o2,b,s)
808                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
809        end constructor;
810        function destructor
811            input Obj2 o2;
812            external "C"
813                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
814        end destructor;
815    end Obj2;
816    model Obj3
817        extends ExternalObject;
818        function constructor
819            input Os.Obj1 o1;
820            input Obj2[:] o2;
821            output Obj3 o3;
822            external "C" my_constructor3(o1,o2,o3)
823                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
824        end constructor;
825        function destructor
826            input Obj3 o3;
827            external "C"
828                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
829        end destructor;
830    end Obj3;
831    model ExtObjTest1
832        function use1
833            input  Os.Obj1 o1;
834            output Real x;
835            external annotation(Library="extObjects", Include="#include \"extObjects.h\"");
836        end use1;
837        Os.Obj1 o1 = Os.Obj1(3.13, 3, true, "A message");
838        Real x = use1(o1); 
839    end ExtObjTest1;
840    model ExtObjTest2
841        function use2
842            input  Obj2 o2;
843            output Real x;
844            external annotation(Library="extObjects", Include="#include \"extObjects.h\"");
845        end use2;
846        Obj2 o2 = Obj2({3.13,3.14}, {3,4}, {false, true}, {"A message 1", "A message 2"});
847        constant Real x = use2(o2); 
848    end ExtObjTest2;
849    model ExtObjTest3
850        function use3
851            input  Obj3 o3;
852            output Real x;
853            external annotation(Library="extObjects", Include="#include \"extObjects.h\"");
854        end use3;
855        Os.Obj1 o1 = Os.Obj1(3.13, 3, true, "A message");
856        Obj2 o2 = Obj2({3.13,3.14}, {3,4}, {false, true}, {"A message 1", "A message 2"});
857        Obj3 o3 = Obj3(o1,{o2,o2});
858        constant Real x = use3(o3); 
859    end ExtObjTest3;
860   
861    model UnknownInput
862      // Should fail
863      function f
864        input  Real x;
865        input  Real t;
866        output Real y = t;
867        output Real dummy=1;
868      external "C" y=fRealScalar(x) annotation(
869        Library="externalFunctionsC",
870        Include="#include \"externalFunctionsC.h\"");
871      end f;
872     
873      Real y;
874    equation
875      (y, ) = f(3, time);
876    end UnknownInput;
877  end Advanced;
878 
879  package Caching
880    model CacheExtObj
881        model EO
882            extends ExternalObject;
883            function constructor
884                input Integer x;
885                output EO o1;
886                external "C" o1 = inc_int_con(x) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
887            end constructor;
888            function destructor
889                input EO o1;
890                external "C" inc_int_decon(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
891            end destructor;
892        end EO;
893        function use
894            input  EO o1;
895            output Integer x;
896            external x = inc_int_use(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
897        end use;
898        parameter EO o1 = EO(1);
899        parameter Integer n1 = use(o1);
900        parameter Integer n2 = use(o1);
901        parameter Integer n3 = n1 + n2;
902        Real[n3] x = (1:n3)*time;
903        Integer nn1,nn2,nn3;
904      equation
905        nn1 = use(o1);
906        nn2 = use(o1);
907        nn3 = nn1 + nn2;
908    end CacheExtObj;
909   
910    model CacheExtObjLimit
911        model EO
912            extends ExternalObject;
913            function constructor
914                input Integer x;
915                output EO o1;
916                external "C" o1 = inc_int_con(x) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
917            end constructor;
918            function destructor
919                input EO o1;
920                external "C" inc_int_decon(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
921            end destructor;
922        end EO;
923        function use1
924            input  EO o1;
925            output Integer x;
926            external x = inc_int_use(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
927        end use1;
928        function use2
929            input  EO o1;
930            output Integer x;
931            external x = inc_int_use2(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
932        end use2;
933        parameter EO o1 = EO(1);
934        parameter EO o2 = EO(1);
935        parameter Integer n1 = use1(o1) + use2(o1) + use1(o2) + use2(o1);
936        parameter Integer n2 = use2(o2) + use2(o1) + use2(o2) + use1(o1);
937        parameter Integer n3 = n1 + n2;
938        Real[n3] x = (1:n3)*time;
939    end CacheExtObjLimit;
940   
941    model ConError
942        model EO
943            extends ExternalObject;
944            function constructor
945                input Integer x;
946                output EO o1;
947                external "C" o1 = error_con(x) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
948            end constructor;
949            function destructor
950                input EO o1;
951                external "C" inc_int_decon(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
952            end destructor;
953        end EO;
954        function use
955            input  EO o1;
956            output Integer x;
957            external x = inc_int_use(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
958        end use;
959        parameter EO o1 = EO(1) annotation(Evaluate=true);
960        parameter Integer n1 = use(o1);
961        parameter Integer n2 = use(o1);
962        parameter Integer n3 = n1 + n2;
963    end ConError;
964   
965    model DeconError
966        model EO
967            extends ExternalObject;
968            function constructor
969                input Integer x;
970                output EO o1;
971                external "C" o1 = inc_int_con(x) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
972            end constructor;
973            function destructor
974                input EO o1;
975                external "C" error_decon(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
976            end destructor;
977        end EO;
978        function use
979            input  EO o1;
980            output Integer x;
981            external x = inc_int_use(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
982        end use;
983        parameter EO o1 = EO(1) annotation(Evaluate=true);
984        parameter Integer n1 = use(o1);
985        parameter Integer n2 = use(o1);
986        parameter Integer n3 = n1 + n2;
987    end DeconError;
988   
989    model UseError
990        model EO
991            extends ExternalObject;
992            function constructor
993                input Integer x;
994                output EO o1;
995                external "C" o1 = inc_int_con(x) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
996            end constructor;
997            function destructor
998                input EO o1;
999                external "C" inc_int_decon(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1000            end destructor;
1001        end EO;
1002        function use
1003            input  EO o1;
1004            output Integer x;
1005            external x = error_use(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1006        end use;
1007        parameter EO o1 = EO(1) annotation(Evaluate=true);
1008        parameter Integer n1 = use(o1);
1009        parameter Integer n2 = use(o1);
1010        parameter Integer n3 = n1 + n2;
1011    end UseError;
1012   
1013    model ConCrash
1014        model EO
1015            extends ExternalObject;
1016            function constructor
1017                input Integer x;
1018                output EO o1;
1019                external "C" o1 = crash_con(x) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1020            end constructor;
1021            function destructor
1022                input EO o1;
1023                external "C" inc_int_decon(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1024            end destructor;
1025        end EO;
1026        function use
1027            input  EO o1;
1028            output Integer x;
1029            external x = inc_int_use(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1030        end use;
1031        parameter EO o1 = EO(1) annotation(Evaluate=true);
1032        parameter Integer n1 = use(o1);
1033        parameter Integer n2 = use(o1);
1034        parameter Integer n3 = n1 + n2;
1035    end ConCrash;
1036   
1037    model DeconCrash
1038        model EO
1039            extends ExternalObject;
1040            function constructor
1041                input Integer x;
1042                output EO o1;
1043                external "C" o1 = inc_int_con(x) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1044            end constructor;
1045            function destructor
1046                input EO o1;
1047                external "C" crash_decon(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1048            end destructor;
1049        end EO;
1050        function use
1051            input  EO o1;
1052            output Integer x;
1053            external x = inc_int_use(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1054        end use;
1055        parameter EO o1 = EO(1) annotation(Evaluate=true);
1056        parameter Integer n1 = use(o1);
1057        parameter Integer n2 = use(o1);
1058        parameter Integer n3 = n1 + n2;
1059    end DeconCrash;
1060   
1061    model UseCrash
1062        model EO
1063            extends ExternalObject;
1064            function constructor
1065                input Integer x;
1066                output EO o1;
1067                external "C" o1 = inc_int_con(x) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1068            end constructor;
1069            function destructor
1070                input EO o1;
1071                external "C" inc_int_decon(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1072            end destructor;
1073        end EO;
1074        function use
1075            input  EO o1;
1076            output Integer x;
1077            external x = crash_use(o1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1078        end use;
1079        parameter EO o1 = EO(1) annotation(Evaluate=true);
1080        parameter Integer n1 = use(o1);
1081        parameter Integer n2 = use(o1);
1082        parameter Integer n3 = n1 + n2;
1083    end UseCrash;
1084  end Caching;
1085end CEval;
1086
1087model PrintsControlCharacters
1088    "This model prints some control characters using ModelicaMessage during compilation"
1089    function f
1090        input Real i;
1091        output Real o;
1092        external "C" o = f(i) annotation(Include="double f(double i) {ModelicaMessage(\"\\1\\2\\3\\4\");return i;}");
1093    end f;
1094    constant Real c = f(2);
1095end PrintsControlCharacters;
1096
1097model StructuralAsserts
1098    function f
1099        output Integer n;
1100        external "C" n = get_time() annotation(Library="externalFunctionsC", Include="#include \"externalFunctionsC.h\"");
1101    end f;
1102   
1103    parameter Integer n = f() annotation(Evaluate=true);
1104end StructuralAsserts;
1105
1106
1107model TestString
1108    import Modelica.Utilities.Strings.*;
1109    function Str1
1110        input  Real x;
1111        output Real y;
1112    protected
1113        String str;
1114    algorithm
1115        str := Str2(x);
1116        y := length(str);
1117        assert(str == "Hej", "Failed to provide the correct string, was: "+str);
1118        annotation(Inline=false);
1119    end Str1;
1120    function Str2
1121        input  Real x;
1122        output String str;
1123    algorithm
1124        str := fStringScalarLit("jeH");
1125        assert(str == "Hej", "Failed to provide the correct string, was: "+str);
1126        annotation(Inline=false);
1127    end Str2;
1128    function fStringScalarLit
1129        input  String x_in;
1130        output String x_out;
1131      external "C" annotation(
1132        Library="externalFunctionsC",
1133        Include="#include \"externalFunctionsC.h\"");
1134      end fStringScalarLit;
1135    parameter Real x(fixed=false);
1136initial equation
1137    x = Str1(1.0);
1138end TestString;
1139
1140
1141model ExternalObjectTests3
1142    class ModelicaMsgOnDelete
1143        extends ExternalObject;
1144       
1145        function constructor
1146            input String name;
1147            output ModelicaMsgOnDelete out;
1148            external "C" out = constructor_modelica_msg(name) 
1149                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1150        end constructor;
1151       
1152        function destructor
1153            input ModelicaMsgOnDelete obj;
1154            external "C" destructor_modelica_msg(obj) 
1155                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1156        end destructor; 
1157    end ModelicaMsgOnDelete;
1158
1159    function use_MMOD
1160        input ModelicaMsgOnDelete obj;
1161        output Real x;
1162        external "C" x = constant_extobj_func(obj) 
1163            annotation(Library="extObjects", Include="#include \"extObjects.h\"");
1164    end use_MMOD;
1165   
1166    ModelicaMsgOnDelete obj = ModelicaMsgOnDelete("test_ext_object.marker");
1167    Real x = use_MMOD(obj);
1168end ExternalObjectTests3;
1169
1170model MultiUse1
1171    function f1
1172        input Real x;
1173        output Real y;
1174        external "C" y = add(x,1) annotation(Library="addNumbers",
1175                                           Include="#include \"addNumbers.h\"");
1176    end f1;
1177    function f2
1178        input Real x;
1179        output Real y;
1180        external "C" y = add(x,2) annotation(Library="addNumbers",
1181                                           Include="#include \"addNumbers.h\"");
1182    end f2;
1183   
1184    Real y = f1(1) + f2(1);
1185end MultiUse1;
1186
1187end ExtFunctionTests;
Note: See TracBrowser for help on using the repository browser.