the use of thread in optimisation, differential_equations and signal_processing removed
[scilab.git] / scilab / modules / differential_equations / src / cpp / differentialequationfunctions.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2011 - DIGITEO - Cedric DELAMARRE
4  *
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12 /*--------------------------------------------------------------------------*/
13 #include "execvisitor.hxx"
14 #include "string.hxx"
15 #include "double.hxx"
16 #include "differentialequationfunctions.hxx"
17
18 extern "C"
19 {
20 #include "elem_common.h"
21 #include "scifunctions.h"
22 #include "Ex-odedc.h"
23 #include "Ex-ode.h"
24 #include "Ex-daskr.h"
25 #include "localization.h"
26 }
27
28 /*
29 ** differential equation functions
30 ** \{
31 */
32
33 // need the current thread, not the last running thread.
34
35 DifferentialEquationFunctions* DifferentialEquation::m_DifferentialEquationFunctions;
36
37 void DifferentialEquation::addDifferentialEquationFunctions(DifferentialEquationFunctions* _deFunction)
38 {
39     m_DifferentialEquationFunctions = _deFunction;
40 }
41
42 void DifferentialEquation::removeDifferentialEquationFunctions()
43 {
44     m_DifferentialEquationFunctions = NULL;
45 }
46
47 DifferentialEquationFunctions* DifferentialEquation::getDifferentialEquationFunctions()
48 {
49     return m_DifferentialEquationFunctions;
50 }
51
52
53 /*
54 ** \}
55 */
56
57
58
59 /*--------------------------------------------------------------------------*/
60 DifferentialEquationFunctions::DifferentialEquationFunctions(const std::wstring& callerName)
61 {
62     m_odeYRows      = 0;
63     m_odeYCols      = 0;
64     m_odedcYDSize   = 0;
65     m_odedcFlag     = 0;
66     m_bvodeM        = 0;
67     m_bvodeN        = 0;
68     m_mu            = 0;
69     m_ml            = 0;
70     m_bandedJac     = false;
71
72     m_wstrCaller = callerName;
73
74     // callable
75     m_pCallFFunction      = NULL;
76     m_pCallJacFunction    = NULL;
77     m_pCallGFunction      = NULL;
78     m_pCallPjacFunction   = NULL;
79     m_pCallPsolFunction   = NULL;
80
81     // function extern
82     m_pStringFFunctionDyn       = NULL;
83     m_pStringJacFunctionDyn     = NULL;
84     m_pStringGFunctionDyn       = NULL;
85     m_pStringPjacFunctionDyn    = NULL;
86     m_pStringPsolFunctionDyn    = NULL;
87
88     // function static
89     m_pStringFFunctionStatic    = NULL;
90     m_pStringJacFunctionStatic  = NULL;
91     m_pStringGFunctionStatic    = NULL;
92     m_pStringPjacFunctionStatic = NULL;
93     m_pStringPsolFunctionStatic = NULL;
94
95     // bvode
96     m_pCallFsubFunction     = NULL;
97     m_pCallDfsubFunction    = NULL;
98     m_pCallGsubFunction     = NULL;
99     m_pCallDgsubFunction    = NULL;
100     m_pCallGuessFunction    = NULL;
101
102     m_pStringFsubFunctionDyn    = NULL;
103     m_pStringDfsubFunctionDyn   = NULL;
104     m_pStringGsubFunctionDyn    = NULL;
105     m_pStringDgsubFunctionDyn   = NULL;
106     m_pStringGuessFunctionDyn   = NULL;
107
108     m_pStringFsubFunctionStatic     = NULL;
109     m_pStringDfsubFunctionStatic    = NULL;
110     m_pStringGsubFunctionStatic     = NULL;
111     m_pStringDgsubFunctionStatic    = NULL;
112     m_pStringGuessFunctionStatic    = NULL;
113
114     // init static functions
115     if (callerName == L"ode")
116     {
117         m_staticFunctionMap[L"arnol"]   = (void*) C2F(arnol);
118         m_staticFunctionMap[L"fex"]     = (void*) fex;
119         m_staticFunctionMap[L"fex2"]    = (void*) fex2;
120         m_staticFunctionMap[L"fex3"]    = (void*) fex3;
121         m_staticFunctionMap[L"fexab"]   = (void*) fexab;
122         m_staticFunctionMap[L"loren"]   = (void*) C2F(loren);
123         m_staticFunctionMap[L"bcomp"]   = (void*) C2F(bcomp);
124         m_staticFunctionMap[L"lcomp"]   = (void*) C2F(lcomp);
125
126         m_staticFunctionMap[L"jex"]     = (void*) jex;
127     }
128     else if (callerName == L"odedc")
129     {
130         m_staticFunctionMap[L"fcd"]     = (void*) fcd;
131         m_staticFunctionMap[L"fcd1"]    = (void*) fcd1;
132         m_staticFunctionMap[L"fexcd"]   = (void*) fexcd;
133         m_staticFunctionMap[L"phis"]    = (void*) phis;
134         m_staticFunctionMap[L"phit"]    = (void*) phit;
135
136         m_staticFunctionMap[L"jex"]     = (void*) jex;
137     }
138     else if (callerName == L"intg")
139     {
140         m_staticFunctionMap[L"intgex"]  = (void*) C2F(intgex);
141     }
142     else if (callerName == L"int2d")
143     {
144         m_staticFunctionMap[L"int2dex"] = (void*) C2F(int2dex);
145     }
146     else if (callerName == L"int3d")
147     {
148         m_staticFunctionMap[L"int3dex"] = (void*) C2F(int3dex);
149     }
150     else if (callerName == L"feval")
151     {
152         m_staticFunctionMap[L"parab"]   = (void*) C2F(parab);
153         m_staticFunctionMap[L"parabc"]  = (void*) C2F(parabc);
154     }
155     else if (callerName == L"bvode")
156     {
157         m_staticFunctionMap[L"cndg"]    = (void*) C2F(cndg);
158         m_staticFunctionMap[L"cng"]     = (void*) C2F(cng);
159         m_staticFunctionMap[L"cnf"]     = (void*) C2F(cnf);
160         m_staticFunctionMap[L"cndf"]    = (void*) C2F(cndf);
161         m_staticFunctionMap[L"cngu"]    = (void*) C2F(cngu);
162     }
163     else if (callerName == L"impl")
164     {
165         m_staticFunctionMap[L"resid"]   = (void*) C2F(resid);  // res
166         m_staticFunctionMap[L"aplusp"]  = (void*) C2F(aplusp); // adda
167         m_staticFunctionMap[L"dgbydy"]  = (void*) C2F(dgbydy); // jac
168     }
169     else if (callerName == L"dassl" ||
170              callerName == L"dasrt" ||
171              callerName == L"daskr")
172     {
173         //res
174         m_staticFunctionMap[L"res1"]    = (void*) C2F(res1);
175         m_staticFunctionMap[L"res2"]    = (void*) C2F(res2);
176         m_staticFunctionMap[L"dres1"]   = (void*) C2F(dres1);
177         m_staticFunctionMap[L"dres2"]   = (void*) C2F(dres2);
178
179         // jac
180         m_staticFunctionMap[L"jac2"]   = (void*) C2F(jac2);
181         m_staticFunctionMap[L"djac2"]  = (void*) C2F(djac2);
182         m_staticFunctionMap[L"djac1"]  = (void*) C2F(djac1);
183
184         //g
185         if (callerName == L"dasrt" || callerName == L"daskr")
186         {
187             m_staticFunctionMap[L"gr1"]  = (void*) C2F(gr1);
188             m_staticFunctionMap[L"gr2"]  = (void*) C2F(gr2);
189         }
190
191         // pjac, psol
192         if (callerName == L"daskr")
193         {
194             m_staticFunctionMap[L"pjac1"]  = (void*) pjac1;
195             m_staticFunctionMap[L"psol1"]  = (void*) psol1;
196         }
197     }
198 }
199
200 DifferentialEquationFunctions::~DifferentialEquationFunctions()
201 {
202     m_staticFunctionMap.clear();
203 }
204
205 /*------------------------------- public -------------------------------------------*/
206 void DifferentialEquationFunctions::execDasrtG(int* ny, double* t, double* y, int* ng, double* gout, double* rpar, int* ipar)
207 {
208     char errorMsg[256];
209     if (m_pCallGFunction)
210     {
211         callDasrtMacroG(ny, t, y, ng, gout, rpar, ipar);
212     }
213     else if (m_pStringGFunctionDyn)
214     {
215         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringGFunctionDyn->get(0));
216         if (func == NULL)
217         {
218             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringGFunctionDyn->get(0));
219             throw ast::InternalError(errorMsg);
220         }
221         ((dasrt_g_t)(func->functionPtr))(ny, t, y, ng, gout, rpar, ipar);
222     }
223     else if (m_pStringGFunctionStatic)
224     {
225         ((dasrt_g_t)m_staticFunctionMap[m_pStringGFunctionStatic->get(0)])(ny, t, y, ng, gout, rpar, ipar);
226     }
227     else
228     {
229         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "g");
230         throw ast::InternalError(errorMsg);
231     }
232 }
233
234 void DifferentialEquationFunctions::execDasslF(double* t, double* y, double* ydot, double* delta, int* ires, double* rpar, int* ipar)
235 {
236     char errorMsg[256];
237     if (m_pCallFFunction)
238     {
239         callDasslMacroF(t, y, ydot, delta, ires, rpar, ipar);
240     }
241     else if (m_pStringFFunctionDyn)
242     {
243         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringFFunctionDyn->get(0));
244         if (func == NULL)
245         {
246             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringFFunctionDyn->get(0));
247             throw ast::InternalError(errorMsg);
248         }
249         ((dassl_f_t)(func->functionPtr))(t, y, ydot, delta, ires, rpar, ipar);
250     }
251     else if (m_pStringFFunctionStatic)
252     {
253         ((dassl_f_t)m_staticFunctionMap[m_pStringFFunctionStatic->get(0)])(t, y, ydot, delta, ires, rpar, ipar);
254     }
255     else
256     {
257         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "f");
258         throw ast::InternalError(errorMsg);
259     }
260 }
261
262 void DifferentialEquationFunctions::execDasslJac(double* t, double* y, double* ydot, double* pd, double* cj, double* rpar, int* ipar)
263 {
264     char errorMsg[256];
265     if (m_pCallJacFunction)
266     {
267         callDasslMacroJac(t, y, ydot, pd, cj, rpar, ipar);
268     }
269     else if (m_pStringJacFunctionDyn)
270     {
271         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringJacFunctionDyn->get(0));
272         if (func == NULL)
273         {
274             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringJacFunctionDyn->get(0));
275             throw ast::InternalError(errorMsg);
276         }
277         ((dassl_jac_t)(func->functionPtr))(t, y, ydot, pd, cj, rpar, ipar);
278     }
279     else if (m_pStringJacFunctionStatic)
280     {
281         ((dassl_jac_t)m_staticFunctionMap[m_pStringJacFunctionStatic->get(0)])(t, y, ydot, pd, cj, rpar, ipar);
282     }
283     else
284     {
285         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "jacobian");
286         throw ast::InternalError(errorMsg);
287     }
288 }
289
290 void DifferentialEquationFunctions::execDaskrPjac(double* res, int* ires, int* neq, double* t, double* y, double* ydot,
291         double* rewt, double* savr, double* wk, double* h, double* cj,
292         double* wp, int* iwp, int* ier, double* rpar, int* ipar)
293 {
294     char errorMsg[256];
295     if (m_pCallPjacFunction)
296     {
297         callDaskrMacroPjac(res, ires, neq, t, y, ydot, rewt, savr,
298                            wk, h, cj, wp, iwp, ier, rpar, ipar);
299     }
300     else if (m_pStringPjacFunctionDyn)
301     {
302         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringPjacFunctionDyn->get(0));
303         if (func == NULL)
304         {
305             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringPjacFunctionDyn->get(0));
306             throw ast::InternalError(errorMsg);
307         }
308         ((daskr_pjac_t)(func->functionPtr))(res, ires, neq, t, y, ydot, rewt, savr,
309                                             wk, h, cj, wp, iwp, ier, rpar, ipar);
310     }
311     else if (m_pStringPjacFunctionStatic)
312     {
313         ((daskr_pjac_t)m_staticFunctionMap[m_pStringPjacFunctionStatic->get(0)])(res, ires, neq, t, y, ydot, rewt, savr,
314                 wk, h, cj, wp, iwp, ier, rpar, ipar);
315     }
316     else
317     {
318         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "pjac");
319         throw ast::InternalError(errorMsg);
320     }
321 }
322
323 void DifferentialEquationFunctions::execDaskrPsol(int* neq, double* t, double* y, double* ydot, double* savr, double* wk,
324         double* cj, double* wght, double* wp, int* iwp, double* b, double* eplin,
325         int* ier, double* rpar, int* ipar)
326 {
327     char errorMsg[256];
328     if (m_pCallPsolFunction)
329     {
330         callDaskrMacroPsol(neq, t, y, ydot, savr, wk, cj, wght,
331                            wp, iwp, b, eplin, ier, rpar, ipar);
332     }
333     else if (m_pStringPsolFunctionDyn)
334     {
335         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringPsolFunctionDyn->get(0));
336         if (func == NULL)
337         {
338             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringPsolFunctionDyn->get(0));
339             throw ast::InternalError(errorMsg);
340         }
341         ((daskr_psol_t)(func->functionPtr))(neq, t, y, ydot, savr, wk, cj, wght,
342                                             wp, iwp, b, eplin, ier, rpar, ipar);
343     }
344     else if (m_pStringPsolFunctionStatic)
345     {
346         ((daskr_psol_t)m_staticFunctionMap[m_pStringPsolFunctionStatic->get(0)])(neq, t, y, ydot, savr, wk, cj, wght,
347                 wp, iwp, b, eplin, ier, rpar, ipar);
348     }
349     else
350     {
351         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "psol");
352         throw ast::InternalError(errorMsg);
353     }
354 }
355
356 void DifferentialEquationFunctions::execImplF(int* neq, double* t, double* y, double* s, double* r, int* ires)
357 {
358     char errorMsg[256];
359     if (m_pCallFFunction)
360     {
361         callImplMacroF(neq, t, y, s, r, ires);
362     }
363     else if (m_pStringFFunctionDyn)
364     {
365         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringFFunctionDyn->get(0));
366         if (func == NULL)
367         {
368             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringFFunctionDyn->get(0));
369             throw ast::InternalError(errorMsg);
370         }
371         ((impl_f_t)(func->functionPtr))(neq, t, y, s, r, ires);
372     }
373     else if (m_pStringFFunctionStatic)
374     {
375         ((impl_f_t)m_staticFunctionMap[m_pStringFFunctionStatic->get(0)])(neq, t, y, s, r, ires);
376     }
377     else
378     {
379         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "f");
380         throw ast::InternalError(errorMsg);
381     }
382 }
383
384 void DifferentialEquationFunctions::execImplG(int* neq, double* t, double* y, double* ml, double* mu, double* p, int* nrowp)
385 {
386     char errorMsg[256];
387     if (m_pCallGFunction)
388     {
389         callImplMacroG(neq, t, y, ml, mu, p, nrowp);
390     }
391     else if (m_pStringGFunctionDyn)
392     {
393         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringGFunctionDyn->get(0));
394         if (func == NULL)
395         {
396             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringGFunctionDyn->get(0));
397             throw ast::InternalError(errorMsg);
398         }
399         ((impl_g_t)(func->functionPtr))(neq, t, y, ml, mu, p, nrowp);
400     }
401     else if (m_pStringGFunctionStatic)
402     {
403         ((impl_g_t)m_staticFunctionMap[m_pStringGFunctionStatic->get(0)])(neq, t, y, ml, mu, p, nrowp);
404     }
405     else
406     {
407         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "g");
408         throw ast::InternalError(errorMsg);
409     }
410 }
411
412 void DifferentialEquationFunctions::execImplJac(int* neq, double* t, double* y, double* s, double* ml, double* mu, double* p, int* nrowp)
413 {
414     char errorMsg[256];
415     if (m_pCallJacFunction)
416     {
417         callImplMacroJac(neq, t, y, s, ml, mu, p, nrowp);
418     }
419     else if (m_pStringJacFunctionDyn)
420     {
421         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringJacFunctionDyn->get(0));
422         if (func == NULL)
423         {
424             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringJacFunctionDyn->get(0));
425             throw ast::InternalError(errorMsg);
426         }
427         ((impl_jac_t)(func->functionPtr))(neq, t, y, s, ml, mu, p, nrowp);
428     }
429     else if (m_pStringJacFunctionStatic)
430     {
431         ((impl_jac_t)m_staticFunctionMap[m_pStringJacFunctionStatic->get(0)])(neq, t, y, s, ml, mu, p, nrowp);
432     }
433     else
434     {
435         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "jacobian");
436         throw ast::InternalError(errorMsg);
437     }
438 }
439
440 void DifferentialEquationFunctions::execBvodeGuess(double *x, double *z, double *d)
441 {
442     char errorMsg[256];
443     if (m_pCallGuessFunction)
444     {
445         callBvodeMacroGuess(x, z, d);
446     }
447     else if (m_pStringGuessFunctionDyn)
448     {
449         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringGuessFunctionDyn->get(0));
450         if (func == NULL)
451         {
452             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringGuessFunctionDyn->get(0));
453             throw ast::InternalError(errorMsg);
454         }
455         ((bvode_ddd_t)(func->functionPtr))(x, z, d);
456     }
457     else if (m_pStringGuessFunctionStatic)
458     {
459         ((bvode_ddd_t)m_staticFunctionMap[m_pStringGuessFunctionStatic->get(0)])(x, z, d);
460     }
461     else
462     {
463         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "guess");
464         throw ast::InternalError(errorMsg);
465     }
466 }
467
468 void DifferentialEquationFunctions::execBvodeDfsub(double *x, double *z, double *d)
469 {
470     char errorMsg[256];
471     if (m_pCallDfsubFunction)
472     {
473         callBvodeMacroDfsub(x, z, d);
474     }
475     else if (m_pStringDfsubFunctionDyn)
476     {
477         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringDfsubFunctionDyn->get(0));
478         if (func == NULL)
479         {
480             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringDfsubFunctionDyn->get(0));
481             throw ast::InternalError(errorMsg);
482         }
483         ((bvode_ddd_t)(func->functionPtr))(x, z, d);
484     }
485     else if (m_pStringDfsubFunctionStatic)// function static
486     {
487         ((bvode_ddd_t)m_staticFunctionMap[m_pStringDfsubFunctionStatic->get(0)])(x, z, d);
488     }
489     else
490     {
491         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "fsub");
492         throw ast::InternalError(errorMsg);
493     }
494 }
495
496 void DifferentialEquationFunctions::execBvodeFsub(double *x, double *z, double *d)
497 {
498     char errorMsg[256];
499     if (m_pCallFsubFunction)
500     {
501         callBvodeMacroFsub(x, z, d);
502     }
503     else if (m_pStringFsubFunctionDyn)
504     {
505         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringFsubFunctionDyn->get(0));
506         if (func == NULL)
507         {
508             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringFsubFunctionDyn->get(0));
509             throw ast::InternalError(errorMsg);
510         }
511         ((bvode_ddd_t)(func->functionPtr))(x, z, d);
512     }
513     else if (m_pStringFsubFunctionStatic) // function static
514     {
515         ((bvode_ddd_t)m_staticFunctionMap[m_pStringFsubFunctionStatic->get(0)])(x, z, d);
516     }
517     else
518     {
519         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "fsub");
520         throw ast::InternalError(errorMsg);
521     }
522 }
523
524 void DifferentialEquationFunctions::execBvodeDgsub(int *i, double *z, double *g)
525 {
526     char errorMsg[256];
527     if (m_pCallDgsubFunction)
528     {
529         callBvodeMacroDgsub(i, z, g);
530     }
531     else if (m_pStringDgsubFunctionDyn)
532     {
533         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringDgsubFunctionDyn->get(0));
534         if (func == NULL)
535         {
536             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringDgsubFunctionDyn->get(0));
537             throw ast::InternalError(errorMsg);
538         }
539         ((bvode_idd_t)(func->functionPtr))(i, z, g);
540     }
541     else if (m_pStringDgsubFunctionStatic) // function static
542     {
543         ((bvode_idd_t)m_staticFunctionMap[m_pStringDgsubFunctionStatic->get(0)])(i, z, g);
544     }
545     else
546     {
547         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "gsub");
548         throw ast::InternalError(errorMsg);
549     }
550 }
551
552 void DifferentialEquationFunctions::execBvodeGsub(int *i, double *z, double *g)
553 {
554     char errorMsg[256];
555     if (m_pCallGsubFunction)
556     {
557         callBvodeMacroGsub(i, z, g);
558     }
559     else if (m_pStringGsubFunctionDyn)
560     {
561         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringGsubFunctionDyn->get(0));
562         if (func == NULL)
563         {
564             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringGsubFunctionDyn->get(0));
565             throw ast::InternalError(errorMsg);
566         }
567         ((bvode_idd_t)(func->functionPtr))(i, z, g);
568     }
569     else if (m_pStringGsubFunctionStatic) // function static
570     {
571         ((bvode_idd_t)m_staticFunctionMap[m_pStringGsubFunctionStatic->get(0)])(i, z, g);
572     }
573     else
574     {
575         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "gsub");
576         throw ast::InternalError(errorMsg);
577     }
578 }
579
580 void DifferentialEquationFunctions::execFevalF(int *nn, double *x1, double *x2, double *xres, int *itype)
581 {
582     char errorMsg[256];
583     if (m_pCallFFunction)
584     {
585         callFevalMacroF(nn, x1, x2, xres, itype);
586     }
587     else if (m_pStringFFunctionDyn)
588     {
589         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringFFunctionDyn->get(0));
590         if (func == NULL)
591         {
592             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringFFunctionDyn->get(0));
593             throw ast::InternalError(errorMsg);
594         }
595
596         ((feval_f_t)(func->functionPtr))(nn, x1, x2, xres, itype);
597     }
598     else if (m_pStringFFunctionStatic) // function static
599     {
600         ((feval_f_t)m_staticFunctionMap[m_pStringFFunctionStatic->get(0)])(nn, x1, x2, xres, itype);
601     }
602     else
603     {
604         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "f");
605         throw ast::InternalError(errorMsg);
606     }
607 }
608
609 void DifferentialEquationFunctions::execInt3dF(double* x, int* numfun, double* funvls)
610 {
611     char errorMsg[256];
612     if (m_pCallFFunction)
613     {
614         callInt3dMacroF(x, numfun, funvls);
615     }
616     else if (m_pStringFFunctionDyn)
617     {
618         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringFFunctionDyn->get(0));
619         if (func == NULL)
620         {
621             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringFFunctionDyn->get(0));
622             throw ast::InternalError(errorMsg);
623         }
624         ((int3d_f_t)(func->functionPtr))(x, numfun, funvls);
625     }
626     else if (m_pStringFFunctionStatic) // function static
627     {
628         ((int3d_f_t)m_staticFunctionMap[m_pStringFFunctionStatic->get(0)])(x, numfun, funvls);
629     }
630     else
631     {
632         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "f");
633         throw ast::InternalError(errorMsg);
634     }
635 }
636
637 double DifferentialEquationFunctions::execInt2dF(double* x, double* y)
638 {
639     char errorMsg[256];
640     if (m_pCallFFunction)
641     {
642         return callInt2dMacroF(x, y);
643     }
644     else if (m_pStringFFunctionDyn)
645     {
646         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringFFunctionDyn->get(0));
647         if (func == NULL)
648         {
649             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringFFunctionDyn->get(0));
650             throw ast::InternalError(errorMsg);
651         }
652         return ((int2d_f_t)(func->functionPtr))(x, y);
653     }
654     else if (m_pStringFFunctionStatic) // function static
655     {
656         return ((int2d_f_t)m_staticFunctionMap[m_pStringFFunctionStatic->get(0)])(x, y);
657     }
658     else
659     {
660         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "f");
661         throw ast::InternalError(errorMsg);
662     }
663 }
664
665 double DifferentialEquationFunctions::execIntgF(double* x)
666 {
667     char errorMsg[256];
668     if (m_pCallFFunction)
669     {
670         return callIntgMacroF(x);
671     }
672     else if (m_pStringFFunctionDyn)
673     {
674         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringFFunctionDyn->get(0));
675         if (func == NULL)
676         {
677             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringFFunctionDyn->get(0));
678             throw ast::InternalError(errorMsg);
679         }
680         return ((intg_f_t)(func->functionPtr))(x);
681     }
682     else if (m_pStringFFunctionStatic) // function static
683     {
684         return ((intg_f_t)m_staticFunctionMap[m_pStringFFunctionStatic->get(0)])(x);
685     }
686     else
687     {
688         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "f");
689         throw ast::InternalError(errorMsg);
690     }
691 }
692
693 void DifferentialEquationFunctions::execOdeF(int* n, double* t, double* y, double* yout)
694 {
695     char errorMsg[256];
696     if (m_pCallFFunction)
697     {
698         callOdeMacroF(n, t, y, yout);
699     }
700     else if (m_pStringFFunctionDyn)
701     {
702         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringFFunctionDyn->get(0));
703         if (func == NULL)
704         {
705             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringFFunctionDyn->get(0));
706             throw ast::InternalError(errorMsg);
707         }
708
709         if (m_wstrCaller == L"ode")
710         {
711             ((ode_f_t)(func->functionPtr))(n, t, y, yout);
712         }
713         else
714         {
715             ((odedc_f_t)(func->functionPtr))(&m_odedcFlag, n, &m_odedcYDSize, t, y, yout);
716         }
717     }
718     else if (m_pStringFFunctionStatic) // function static
719     {
720         if (m_wstrCaller == L"ode")
721         {
722             ((ode_f_t)m_staticFunctionMap[m_pStringFFunctionStatic->get(0)])(n, t, y, yout);
723         }
724         else // if (m_wstrCaller == L"odedc")
725         {
726             ((odedc_f_t)m_staticFunctionMap[m_pStringFFunctionStatic->get(0)])(&m_odedcFlag, n, &m_odedcYDSize, t, y, yout);
727         }
728     }
729     else
730     {
731         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "f");
732         throw ast::InternalError(errorMsg);
733     }
734 }
735
736 void DifferentialEquationFunctions::execFunctionJac(int *n, double *t, double *y, int *ml, int *mu, double *J, int *nrpd)
737 {
738     char errorMsg[256];
739     if (m_pCallJacFunction)
740     {
741         callMacroJac(n, t, y, ml, mu, J, nrpd);
742     }
743     else if (m_pStringJacFunctionDyn)
744     {
745         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringJacFunctionDyn->get(0));
746         if (func == NULL)
747         {
748             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringJacFunctionDyn->get(0));
749             throw ast::InternalError(errorMsg);
750         }
751         ((func_jac_t)(func->functionPtr))(n, t, y, ml, mu, J, nrpd);
752     }
753     else if (m_pStringJacFunctionStatic) // function static
754     {
755         ((func_jac_t)m_staticFunctionMap[m_pStringJacFunctionStatic->get(0)])(n, t, y, ml, mu, J, nrpd);
756     }
757     else
758     {
759         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "jacobian");
760         throw ast::InternalError(errorMsg);
761     }
762 }
763
764 void DifferentialEquationFunctions::execFunctionG(int* n, double* t, double* y, int* ng, double* gout)
765 {
766     char errorMsg[256];
767     if (m_pCallGFunction)
768     {
769         callMacroG(n, t, y, ng, gout);
770     }
771     else if (m_pStringGFunctionDyn)
772     {
773         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringGFunctionDyn->get(0));
774         if (func == NULL)
775         {
776             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringGFunctionDyn->get(0));
777             throw ast::InternalError(errorMsg);
778         }
779         ((func_g_t)(func->functionPtr))(n, t, y, ng, gout);
780     }
781     else if (m_pStringGFunctionStatic)// function static
782     {
783         ((func_g_t)m_staticFunctionMap[m_pStringGFunctionStatic->get(0)])(n, t, y, ng, gout);
784     }
785     else
786     {
787         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "g");
788         throw ast::InternalError(errorMsg);
789     }
790 }
791
792 //*** setter ***
793 // set rows cols
794 void DifferentialEquationFunctions::setOdeYRows(int rows)
795 {
796     m_odeYRows = rows;
797 }
798
799 void DifferentialEquationFunctions::setOdeYCols(int cols)
800 {
801     m_odeYCols = cols;
802 }
803
804 // set odedc yd size
805 void DifferentialEquationFunctions::setOdedcYDSize(int size)
806 {
807     m_odedcYDSize = size;
808 }
809
810 // set odedc flag
811 void DifferentialEquationFunctions::setOdedcFlag()
812 {
813     m_odedcFlag = 1;
814 }
815
816 // reset odedc flag
817 void DifferentialEquationFunctions::resetOdedcFlag()
818 {
819     m_odedcFlag = 0;
820 }
821
822 void DifferentialEquationFunctions::setBvodeM(int _m)
823 {
824     m_bvodeM = _m;
825 }
826
827 void DifferentialEquationFunctions::setBvodeN(int _n)
828 {
829     m_bvodeN = _n;
830 }
831
832 //set function f, jac, g, psol, pjac as types::Callable
833 void DifferentialEquationFunctions::setFFunction(types::Callable* _odeFFunc)
834 {
835     m_pCallFFunction = _odeFFunc;
836 }
837
838 void DifferentialEquationFunctions::setJacFunction(types::Callable* _odeJacFunc)
839 {
840     m_pCallJacFunction = _odeJacFunc;
841 }
842
843 void DifferentialEquationFunctions::setGFunction(types::Callable* _odeGFunc)
844 {
845     m_pCallGFunction = _odeGFunc;
846 }
847
848 void DifferentialEquationFunctions::setPsolFunction(types::Callable* _pSolFunc)
849 {
850     m_pCallPsolFunction = _pSolFunc;
851 }
852
853 void DifferentialEquationFunctions::setPjacFunction(types::Callable* _pJacFunc)
854 {
855     m_pCallPjacFunction = _pJacFunc;
856 }
857
858 //set function f, jac, g, psol, pjac as types::String
859 bool DifferentialEquationFunctions::setFFunction(types::String* _odeFFunc)
860 {
861     if (ConfigVariable::getEntryPoint(_odeFFunc->get(0)))
862     {
863         m_pStringFFunctionDyn = _odeFFunc;
864         return true;
865     }
866     else
867     {
868         if (m_staticFunctionMap.find(_odeFFunc->get(0)) != m_staticFunctionMap.end())
869         {
870             m_pStringFFunctionStatic = _odeFFunc;
871             return true;
872         }
873         return false;
874     }
875 }
876
877 bool DifferentialEquationFunctions::setJacFunction(types::String* _odeJacFunc)
878 {
879     if (ConfigVariable::getEntryPoint(_odeJacFunc->get(0)))
880     {
881         m_pStringJacFunctionDyn = _odeJacFunc;
882         return true;
883     }
884     else
885     {
886         if (m_staticFunctionMap.find(_odeJacFunc->get(0)) != m_staticFunctionMap.end())
887         {
888             m_pStringJacFunctionStatic = _odeJacFunc;
889             return true;
890         }
891         return false;
892     }
893 }
894
895 bool DifferentialEquationFunctions::setGFunction(types::String* _odeGFunc)
896 {
897     if (ConfigVariable::getEntryPoint(_odeGFunc->get(0)))
898     {
899         m_pStringGFunctionDyn = _odeGFunc;
900         return true;
901     }
902     else
903     {
904         if (m_staticFunctionMap.find(_odeGFunc->get(0)) != m_staticFunctionMap.end())
905         {
906             m_pStringGFunctionStatic = _odeGFunc;
907             return true;
908         }
909         return false;
910     }
911 }
912
913 bool DifferentialEquationFunctions::setPsolFunction(types::String* _pSolFunc)
914 {
915     if (ConfigVariable::getEntryPoint(_pSolFunc->get(0)))
916     {
917         m_pStringPsolFunctionDyn = _pSolFunc;
918         return true;
919     }
920     else
921     {
922         if (m_staticFunctionMap.find(_pSolFunc->get(0)) != m_staticFunctionMap.end())
923         {
924             m_pStringPsolFunctionStatic = _pSolFunc;
925             return true;
926         }
927         return false;
928     }
929 }
930
931 bool DifferentialEquationFunctions::setPjacFunction(types::String* _pJacFunc)
932 {
933     if (ConfigVariable::getEntryPoint(_pJacFunc->get(0)))
934     {
935         m_pStringPjacFunctionDyn = _pJacFunc;
936         return true;
937     }
938     else
939     {
940         if (m_staticFunctionMap.find(_pJacFunc->get(0)) != m_staticFunctionMap.end())
941         {
942             m_pStringPjacFunctionStatic = _pJacFunc;
943             return true;
944         }
945         return false;
946     }
947 }
948
949 // set args for f, jac, g, pjac and psol functions
950 void DifferentialEquationFunctions::setFArgs(types::InternalType* _odeFArg)
951 {
952     m_FArgs.push_back(_odeFArg);
953 }
954
955 void DifferentialEquationFunctions::setJacArgs(types::InternalType* _odeJacArg)
956 {
957     m_JacArgs.push_back(_odeJacArg);
958 }
959
960 void DifferentialEquationFunctions::setGArgs(types::InternalType* _odeGArg)
961 {
962     m_odeGArgs.push_back(_odeGArg);
963 }
964
965 void DifferentialEquationFunctions::setPsolArgs(types::InternalType* _pSolArg)
966 {
967     m_pSolArgs.push_back(_pSolArg);
968 }
969
970 void DifferentialEquationFunctions::setPjacArgs(types::InternalType* _pJacArg)
971 {
972     m_pJacArgs.push_back(_pJacArg);
973 }
974
975 // bvode set function as types::Callable gsub, dgsub, fsub, dfsub, guess
976 void DifferentialEquationFunctions::setGsubFunction(types::Callable* _func)
977 {
978     m_pCallGsubFunction = _func;
979 }
980
981 void DifferentialEquationFunctions::setDgsubFunction(types::Callable* _func)
982 {
983     m_pCallDgsubFunction = _func;
984 }
985
986 void DifferentialEquationFunctions::setFsubFunction(types::Callable* _func)
987 {
988     m_pCallFsubFunction = _func;
989 }
990
991 void DifferentialEquationFunctions::setDfsubFunction(types::Callable* _func)
992 {
993     m_pCallDfsubFunction = _func;
994 }
995
996 void DifferentialEquationFunctions::setGuessFunction(types::Callable* _func)
997 {
998     m_pCallGuessFunction = _func;
999 }
1000
1001 // bvode set function as types::String gsub, dgsub, fsub, dfsub, guess
1002 bool DifferentialEquationFunctions::setGsubFunction(types::String* _func)
1003 {
1004     if (ConfigVariable::getEntryPoint(_func->get(0)))
1005     {
1006         m_pStringGsubFunctionDyn = _func;
1007         return true;
1008     }
1009     else
1010     {
1011         if (m_staticFunctionMap.find(_func->get(0)) != m_staticFunctionMap.end())
1012         {
1013             m_pStringGsubFunctionStatic = _func;
1014             return true;
1015         }
1016         return false;
1017     }
1018 }
1019
1020 bool DifferentialEquationFunctions::setDgsubFunction(types::String* _func)
1021 {
1022     if (ConfigVariable::getEntryPoint(_func->get(0)))
1023     {
1024         m_pStringDgsubFunctionDyn = _func;
1025         return true;
1026     }
1027     else
1028     {
1029         if (m_staticFunctionMap.find(_func->get(0)) != m_staticFunctionMap.end())
1030         {
1031             m_pStringDgsubFunctionStatic = _func;
1032             return true;
1033         }
1034         return false;
1035     }
1036 }
1037
1038 bool DifferentialEquationFunctions::setFsubFunction(types::String* _func)
1039 {
1040     if (ConfigVariable::getEntryPoint(_func->get(0)))
1041     {
1042         m_pStringFsubFunctionDyn = _func;
1043         return true;
1044     }
1045     else
1046     {
1047         if (m_staticFunctionMap.find(_func->get(0)) != m_staticFunctionMap.end())
1048         {
1049             m_pStringFsubFunctionStatic = _func;
1050             return true;
1051         }
1052         return false;
1053     }
1054 }
1055
1056 bool DifferentialEquationFunctions::setDfsubFunction(types::String* _func)
1057 {
1058     if (ConfigVariable::getEntryPoint(_func->get(0)))
1059     {
1060         m_pStringDfsubFunctionDyn = _func;
1061         return true;
1062     }
1063     else
1064     {
1065         if (m_staticFunctionMap.find(_func->get(0)) != m_staticFunctionMap.end())
1066         {
1067             m_pStringDfsubFunctionStatic = _func;
1068             return true;
1069         }
1070         return false;
1071     }
1072 }
1073
1074 bool DifferentialEquationFunctions::setGuessFunction(types::String* _func)
1075 {
1076     if (ConfigVariable::getEntryPoint(_func->get(0)))
1077     {
1078         m_pStringGuessFunctionDyn = _func;
1079         return true;
1080     }
1081     else
1082     {
1083         if (m_staticFunctionMap.find(_func->get(0)) != m_staticFunctionMap.end())
1084         {
1085             m_pStringGuessFunctionStatic = _func;
1086             return true;
1087         }
1088         return false;
1089     }
1090 }
1091
1092 // bvode set set args for gsub, dgsub, fsub, dfsub, guess functions
1093 void DifferentialEquationFunctions::setGsubArgs(types::InternalType* _arg)
1094 {
1095     m_GsubArgs.push_back(_arg);
1096 }
1097
1098 void DifferentialEquationFunctions::setDgsubArgs(types::InternalType* _arg)
1099 {
1100     m_DgsubArgs.push_back(_arg);
1101 }
1102
1103 void DifferentialEquationFunctions::setFsubArgs(types::InternalType* _arg)
1104 {
1105     m_FsubArgs.push_back(_arg);
1106 }
1107
1108 void DifferentialEquationFunctions::setDfsubArgs(types::InternalType* _arg)
1109 {
1110     m_DfsubArgs.push_back(_arg);
1111 }
1112
1113 void DifferentialEquationFunctions::setGuessArgs(types::InternalType* _arg)
1114 {
1115     m_GuessArgs.push_back(_arg);
1116 }
1117
1118 // set mu and ml
1119 void DifferentialEquationFunctions::setMu(int mu)
1120 {
1121     m_bandedJac = true;
1122     m_mu = mu;
1123 }
1124
1125 void DifferentialEquationFunctions::setMl(int ml)
1126 {
1127     m_bandedJac = true;
1128     m_ml = ml;
1129 }
1130
1131 //*** getter ***
1132 // get y rows cols
1133 int DifferentialEquationFunctions::getOdeYRows()
1134 {
1135     return m_odeYRows;
1136 }
1137
1138 int DifferentialEquationFunctions::getOdeYCols()
1139 {
1140     return m_odeYCols;
1141 }
1142
1143 // get odedc yd size
1144 int DifferentialEquationFunctions::getOdedcYDSize()
1145 {
1146     return m_odedcYDSize;
1147 }
1148
1149 // get odedc flag
1150 int DifferentialEquationFunctions::getOdedcFlag()
1151 {
1152     return m_odedcFlag;
1153 }
1154
1155 /*------------------------------- private -------------------------------------------*/
1156 void DifferentialEquationFunctions::callOdeMacroF(int* n, double* t, double* y, double* ydot)
1157 {
1158     char errorMsg[256];
1159     int one         = 1;
1160     int iRetCount   = 1;
1161
1162     typed_list in;
1163     typed_list out;
1164     types::optional_list opt;
1165     ast::ExecVisitor execFunc;
1166
1167     types::Double* pDblY    = NULL;
1168     types::Double* pDblYC   = NULL;
1169     types::Double* pDblYD   = NULL;
1170     types::Double* pDblFlag = NULL;
1171
1172     // create input args
1173     types::Double* pDblT = new types::Double(*t);
1174     pDblT->IncreaseRef();
1175
1176     if (m_odedcYDSize) // odedc
1177     {
1178         pDblYC = new types::Double(*n, 1);
1179         pDblYC->set(y);
1180         pDblYC->IncreaseRef();
1181         pDblYD = new types::Double(m_odedcYDSize, 1);
1182         pDblYD->set(y + *n);
1183         pDblYD->IncreaseRef();
1184         pDblFlag = new types::Double(m_odedcFlag);
1185         pDblFlag->IncreaseRef();
1186     }
1187     else // ode
1188     {
1189         pDblY = new types::Double(m_odeYRows, m_odeYCols);
1190         pDblY->set(y);
1191         pDblY->IncreaseRef();
1192     }
1193
1194     // push_back
1195     in.push_back(pDblT);
1196     if (m_odedcYDSize) // odedc
1197     {
1198         in.push_back(pDblYC);
1199         in.push_back(pDblYD);
1200         in.push_back(pDblFlag);
1201     }
1202     else
1203     {
1204         in.push_back(pDblY);
1205     }
1206
1207     for (int i = 0; i < (int)m_FArgs.size(); i++)
1208     {
1209         m_FArgs[i]->IncreaseRef();
1210         in.push_back(m_FArgs[i]);
1211     }
1212
1213     try
1214     {
1215         // new std::wstring(L"") is delete in destructor of ast::CommentExp
1216         m_pCallFFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
1217     }
1218     catch (const ast::InternalError& ie)
1219     {
1220         for (int i = 0; i < (int)m_FArgs.size(); i++)
1221         {
1222             m_FArgs[i]->DecreaseRef();
1223         }
1224
1225         throw ie;
1226     }
1227
1228     for (int i = 0; i < (int)m_FArgs.size(); i++)
1229     {
1230         m_FArgs[i]->DecreaseRef();
1231     }
1232
1233     if (out.size() != iRetCount)
1234     {
1235         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1236         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
1237         FREE(pstrName);
1238         throw ast::InternalError(errorMsg);
1239     }
1240
1241     out[0]->IncreaseRef();
1242
1243     pDblT->DecreaseRef();
1244     if (pDblT->isDeletable())
1245     {
1246         delete pDblT;
1247     }
1248
1249     if (m_odedcYDSize) // odedc
1250     {
1251         pDblYC->DecreaseRef();
1252         if (pDblYC->isDeletable())
1253         {
1254             delete pDblYC;
1255         }
1256         pDblYD->DecreaseRef();
1257         if (pDblYD->isDeletable())
1258         {
1259             delete pDblYD;
1260         }
1261         pDblFlag->DecreaseRef();
1262         if (pDblFlag->isDeletable())
1263         {
1264             delete pDblFlag;
1265         }
1266     }
1267     else
1268     {
1269         pDblY->DecreaseRef();
1270         if (pDblY->isDeletable())
1271         {
1272             delete pDblY;
1273         }
1274     }
1275
1276     out[0]->DecreaseRef();
1277
1278     if (out[0]->isDouble() == false)
1279     {
1280         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1281         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1282         FREE(pstrName);
1283         throw ast::InternalError(errorMsg);
1284     }
1285     types::Double* pDblOut = out[0]->getAs<types::Double>();
1286     if (pDblOut->isComplex())
1287     {
1288         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1289         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1290         FREE(pstrName);
1291         throw ast::InternalError(errorMsg);
1292     }
1293
1294     if (m_odedcFlag && m_odedcYDSize)
1295     {
1296         C2F(dcopy)(&m_odedcYDSize, pDblOut->get(), &one, ydot, &one);
1297     }
1298     else
1299     {
1300         C2F(dcopy)(n, pDblOut->get(), &one, ydot, &one);
1301     }
1302
1303     if (out[0]->isDeletable())
1304     {
1305         delete out[0];
1306     }
1307 }
1308
1309 void DifferentialEquationFunctions::callMacroJac(int* n, double* t, double* y, int* ml, int* mu, double* J, int* nrpd)
1310 {
1311     char errorMsg[256];
1312     int iRetCount   = 1;
1313     int one         = 1;
1314     int iMaxSize    = (*n) * (*nrpd);
1315
1316     typed_list in;
1317     typed_list out;
1318     types::optional_list opt;
1319     ast::ExecVisitor execFunc;
1320
1321     types::Double* pDblY = new types::Double(m_odeYRows, m_odeYCols);
1322     pDblY->set(y);
1323     types::Double* pDblT = new types::Double(*t);
1324
1325     pDblT->IncreaseRef();
1326     pDblY->IncreaseRef();
1327
1328     in.push_back(pDblT);
1329     in.push_back(pDblY);
1330
1331     for (int i = 0; i < (int)m_JacArgs.size(); i++)
1332     {
1333         m_JacArgs[i]->IncreaseRef();
1334         in.push_back(m_JacArgs[i]);
1335     }
1336
1337     try
1338     {
1339         // new std::wstring(L"") is delete in destructor of ast::CommentExp
1340         m_pCallJacFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
1341     }
1342     catch (const ast::InternalError& ie)
1343     {
1344         for (int i = 0; i < (int)m_JacArgs.size(); i++)
1345         {
1346             m_JacArgs[i]->DecreaseRef();
1347         }
1348
1349         throw ie;
1350     }
1351
1352     for (int i = 0; i < (int)m_JacArgs.size(); i++)
1353     {
1354         m_JacArgs[i]->DecreaseRef();
1355     }
1356
1357     out[0]->IncreaseRef();
1358     pDblT->DecreaseRef();
1359     pDblY->DecreaseRef();
1360
1361     if (pDblT->isDeletable())
1362     {
1363         delete pDblT;
1364     }
1365
1366     if (pDblY->isDeletable())
1367     {
1368         delete pDblY;
1369     }
1370
1371     if (out.size() != iRetCount)
1372     {
1373         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
1374         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
1375         FREE(pstrName);
1376         throw ast::InternalError(errorMsg);
1377     }
1378
1379     out[0]->DecreaseRef();
1380     if (out[0]->isDouble() == false)
1381     {
1382         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
1383         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1384         FREE(pstrName);
1385         throw ast::InternalError(errorMsg);
1386     }
1387
1388
1389     types::Double* pDblOut = out[0]->getAs<types::Double>();
1390     int iSizeOut = pDblOut->getSize();
1391
1392     if (iSizeOut > iMaxSize)
1393     {
1394         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
1395         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A size less or equal than %d expected.\n"), pstrName, 1, iMaxSize);
1396         FREE(pstrName);
1397         throw ast::InternalError(errorMsg);
1398     }
1399
1400     C2F(dcopy)(&iSizeOut, pDblOut->get(), &one, J, &one);
1401 }
1402
1403 void DifferentialEquationFunctions::callMacroG(int* n, double* t, double* y, int* ng, double* gout)
1404 {
1405     char errorMsg[256];
1406     int iRetCount   = 1;
1407     int one         = 1;
1408
1409     typed_list in;
1410     typed_list out;
1411     types::optional_list opt;
1412     ast::ExecVisitor execFunc;
1413
1414     types::Double* pDblY = new types::Double(m_odeYRows, m_odeYCols);
1415     pDblY->set(y);
1416     types::Double* pDblT = new types::Double(*t);
1417
1418     pDblT->IncreaseRef();
1419     pDblY->IncreaseRef();
1420
1421     in.push_back(pDblT);
1422     in.push_back(pDblY);
1423
1424     for (int i = 0; i < (int)m_odeGArgs.size(); i++)
1425     {
1426         m_odeGArgs[i]->IncreaseRef();
1427         in.push_back(m_odeGArgs[i]);
1428     }
1429
1430     try
1431     {
1432         // new std::wstring(L"") is delete in destructor of ast::CommentExp
1433         m_pCallGFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
1434     }
1435     catch (const ast::InternalError& ie)
1436     {
1437         for (int i = 0; i < (int)m_odeGArgs.size(); i++)
1438         {
1439             m_odeGArgs[i]->DecreaseRef();
1440         }
1441
1442         throw ie;
1443     }
1444
1445     for (int i = 0; i < (int)m_odeGArgs.size(); i++)
1446     {
1447         m_odeGArgs[i]->DecreaseRef();
1448     }
1449
1450     if (out.size() != iRetCount)
1451     {
1452         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
1453         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
1454         FREE(pstrName);
1455         throw ast::InternalError(errorMsg);
1456     }
1457
1458     out[0]->IncreaseRef();
1459
1460     pDblT->DecreaseRef();
1461     pDblY->DecreaseRef();
1462
1463     if (pDblT->isDeletable())
1464     {
1465         delete pDblT;
1466     }
1467
1468     if (pDblY->isDeletable())
1469     {
1470         delete pDblY;
1471     }
1472
1473     out[0]->DecreaseRef();
1474     if (out[0]->isDouble() == false)
1475     {
1476         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
1477         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1478         FREE(pstrName);
1479         throw ast::InternalError(errorMsg);
1480     }
1481
1482     C2F(dcopy)(ng, out[0]->getAs<types::Double>()->get(), &one, gout, &one);
1483     if (out[0]->isDeletable())
1484     {
1485         delete out[0];
1486     }
1487 }
1488
1489 double DifferentialEquationFunctions::callIntgMacroF(double* t)
1490 {
1491     char errorMsg[256];
1492     int one         = 1;
1493     int iRetCount   = 1;
1494
1495     typed_list in;
1496     typed_list out;
1497     types::optional_list opt;
1498     ast::ExecVisitor execFunc;
1499
1500     // create input args
1501     types::Double* pDblT = new types::Double(*t);
1502     pDblT->IncreaseRef();
1503
1504     // push_back
1505     in.push_back(pDblT);
1506
1507     for (int i = 0; i < (int)m_FArgs.size(); i++)
1508     {
1509         m_FArgs[i]->IncreaseRef();
1510         in.push_back(m_FArgs[i]);
1511     }
1512
1513     try
1514     {
1515         // new std::wstring(L"") is delete in destructor of ast::CommentExp
1516         m_pCallFFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
1517     }
1518     catch (const ast::InternalError& ie)
1519     {
1520         for (int i = 0; i < (int)m_FArgs.size(); i++)
1521         {
1522             m_FArgs[i]->DecreaseRef();
1523         }
1524
1525         throw ie;
1526     }
1527
1528     for (int i = 0; i < (int)m_FArgs.size(); i++)
1529     {
1530         m_FArgs[i]->DecreaseRef();
1531     }
1532
1533     if (out.size() != iRetCount)
1534     {
1535         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1536         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
1537         FREE(pstrName);
1538         throw ast::InternalError(errorMsg);
1539     }
1540
1541     out[0]->IncreaseRef();
1542
1543     pDblT->DecreaseRef();
1544     if (pDblT->isDeletable())
1545     {
1546         delete pDblT;
1547     }
1548
1549     out[0]->DecreaseRef();
1550     if (out[0]->isDouble() == false)
1551     {
1552         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1553         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1554         FREE(pstrName);
1555         throw ast::InternalError(errorMsg);
1556
1557     }
1558
1559     types::Double* pDblOut = out[0]->getAs<types::Double>();
1560     if (pDblOut->getSize() != 1)
1561     {
1562         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1563         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 1);
1564         FREE(pstrName);
1565         throw ast::InternalError(errorMsg);
1566     }
1567
1568     double res = pDblOut->get(0);
1569     if (out[0]->isDeletable())
1570     {
1571         delete out[0];
1572     }
1573
1574     return res;
1575 }
1576
1577 double DifferentialEquationFunctions::callInt2dMacroF(double* x, double* y)
1578 {
1579     char errorMsg[256];
1580     int one         = 1;
1581     int iRetCount   = 1;
1582
1583     typed_list in;
1584     typed_list out;
1585     types::optional_list opt;
1586     ast::ExecVisitor execFunc;
1587
1588     // create input args
1589     types::Double* pDblX = new types::Double(*x);
1590     pDblX->IncreaseRef();
1591     types::Double* pDblY = new types::Double(*y);
1592     pDblY->IncreaseRef();
1593
1594     // push_back
1595     in.push_back(pDblX);
1596     in.push_back(pDblY);
1597
1598     for (int i = 0; i < (int)m_FArgs.size(); i++)
1599     {
1600         m_FArgs[i]->IncreaseRef();
1601         in.push_back(m_FArgs[i]);
1602     }
1603
1604     try
1605     {
1606         // new std::wstring(L"") is delete in destructor of ast::CommentExp
1607         m_pCallFFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
1608     }
1609     catch (const ast::InternalError& ie)
1610     {
1611         for (int i = 0; i < (int)m_FArgs.size(); i++)
1612         {
1613             m_FArgs[i]->DecreaseRef();
1614         }
1615
1616         throw ie;
1617     }
1618
1619     for (int i = 0; i < (int)m_FArgs.size(); i++)
1620     {
1621         m_FArgs[i]->DecreaseRef();
1622     }
1623
1624     if (out.size() != iRetCount)
1625     {
1626         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1627         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
1628         FREE(pstrName);
1629         throw ast::InternalError(errorMsg);
1630     }
1631
1632     out[0]->IncreaseRef();
1633
1634     pDblX->DecreaseRef();
1635     if (pDblX->isDeletable())
1636     {
1637         delete pDblX;
1638     }
1639
1640     pDblY->DecreaseRef();
1641     if (pDblY->isDeletable())
1642     {
1643         delete pDblY;
1644     }
1645
1646     out[0]->DecreaseRef();
1647     if (out[0]->isDouble() == false)
1648     {
1649         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1650         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1651         FREE(pstrName);
1652         throw ast::InternalError(errorMsg);
1653     }
1654
1655     types::Double* pDblOut = out[0]->getAs<types::Double>();
1656     if (pDblOut->getSize() != 1)
1657     {
1658         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1659         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 1);
1660         FREE(pstrName);
1661         throw ast::InternalError(errorMsg);
1662     }
1663
1664     double res = pDblOut->get(0);
1665     if (out[0]->isDeletable())
1666     {
1667         delete out[0];
1668     }
1669
1670     return res;
1671 }
1672
1673 void DifferentialEquationFunctions::callInt3dMacroF(double* xyz, int* numfun, double* funvls)
1674 {
1675     char errorMsg[256];
1676     int one         = 1;
1677     int iRetCount   = 1;
1678
1679     typed_list in;
1680     typed_list out;
1681     types::optional_list opt;
1682     ast::ExecVisitor execFunc;
1683
1684     // create input args
1685     types::Double* pDblXYZ = new types::Double(3, 1);
1686     pDblXYZ->set(xyz);
1687     pDblXYZ->IncreaseRef();
1688     types::Double* pDblNumfun = new types::Double(*numfun);
1689     pDblNumfun->IncreaseRef();
1690
1691     // push_back
1692     in.push_back(pDblXYZ);
1693     in.push_back(pDblNumfun);
1694
1695     for (int i = 0; i < (int)m_FArgs.size(); i++)
1696     {
1697         m_FArgs[i]->IncreaseRef();
1698         in.push_back(m_FArgs[i]);
1699     }
1700
1701     try
1702     {
1703         // new std::wstring(L"") is delete in destructor of ast::CommentExp
1704         m_pCallFFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
1705     }
1706     catch (const ast::InternalError& ie)
1707     {
1708         for (int i = 0; i < (int)m_FArgs.size(); i++)
1709         {
1710             m_FArgs[i]->DecreaseRef();
1711         }
1712
1713         throw ie;
1714     }
1715
1716     for (int i = 0; i < (int)m_FArgs.size(); i++)
1717     {
1718         m_FArgs[i]->DecreaseRef();
1719     }
1720
1721     if (out.size() != iRetCount)
1722     {
1723         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1724         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
1725         FREE(pstrName);
1726         throw ast::InternalError(errorMsg);
1727     }
1728
1729     out[0]->IncreaseRef();
1730
1731     pDblXYZ->DecreaseRef();
1732     if (pDblXYZ->isDeletable())
1733     {
1734         delete pDblXYZ;
1735     }
1736
1737     pDblNumfun->DecreaseRef();
1738     if (pDblNumfun->isDeletable())
1739     {
1740         delete pDblNumfun;
1741     }
1742
1743     out[0]->DecreaseRef();
1744     if (out[0]->isDouble() == false)
1745     {
1746         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1747         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1748         FREE(pstrName);
1749         throw ast::InternalError(errorMsg);
1750     }
1751
1752     types::Double* pDblOut = out[0]->getAs<types::Double>();
1753     if (pDblOut->getSize() != *numfun)
1754     {
1755         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1756         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: Matrix of size %d expected.\n"), pstrName, 1, *numfun);
1757         FREE(pstrName);
1758         throw ast::InternalError(errorMsg);
1759     }
1760
1761     C2F(dcopy)(numfun, pDblOut->get(), &one, funvls, &one);
1762     if (out[0]->isDeletable())
1763     {
1764         delete out[0];
1765     }
1766 }
1767
1768 void DifferentialEquationFunctions::callFevalMacroF(int* nn, double* x1, double* x2, double* xres, int* itype)
1769 {
1770     char errorMsg[256];
1771     int one         = 1;
1772     int iRetCount   = 1;
1773
1774     typed_list in;
1775     typed_list out;
1776     types::optional_list opt;
1777     ast::ExecVisitor execFunc;
1778
1779     types::Double* pDblX = NULL;
1780     types::Double* pDblY = NULL;
1781
1782     // create input args
1783
1784     pDblX = new types::Double(*x1);
1785     pDblX->IncreaseRef();
1786     in.push_back(pDblX);
1787
1788     if (*nn == 2)
1789     {
1790         pDblY = new types::Double(*x2);
1791         pDblY->IncreaseRef();
1792         in.push_back(pDblY);
1793     }
1794
1795     for (int i = 0; i < (int)m_FArgs.size(); i++)
1796     {
1797         m_FArgs[i]->IncreaseRef();
1798         in.push_back(m_FArgs[i]);
1799     }
1800     try
1801     {
1802         // new std::wstring(L"") is delete in destructor of ast::CommentExp
1803         m_pCallFFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
1804     }
1805     catch (const ast::InternalError& ie)
1806     {
1807         for (int i = 0; i < (int)m_FArgs.size(); i++)
1808         {
1809             m_FArgs[i]->DecreaseRef();
1810         }
1811
1812         throw ie;
1813     }
1814
1815     for (int i = 0; i < (int)m_FArgs.size(); i++)
1816     {
1817         m_FArgs[i]->DecreaseRef();
1818     }
1819
1820     if (out.size() != iRetCount)
1821     {
1822         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1823         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
1824         FREE(pstrName);
1825         throw ast::InternalError(errorMsg);
1826     }
1827
1828     out[0]->IncreaseRef();
1829
1830     pDblX->DecreaseRef();
1831     if (pDblX->isDeletable())
1832     {
1833         delete pDblX;
1834     }
1835
1836     if (*nn == 2)
1837     {
1838         pDblY->DecreaseRef();
1839         if (pDblY->isDeletable())
1840         {
1841             delete pDblY;
1842         }
1843     }
1844
1845     out[0]->DecreaseRef();
1846     if (out[0]->isDouble() == false)
1847     {
1848         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1849         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1850         FREE(pstrName);
1851         throw ast::InternalError(errorMsg);
1852
1853     }
1854
1855     types::Double* pDblOut = out[0]->getAs<types::Double>();
1856     if (pDblOut->getSize() != 1)
1857     {
1858         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
1859         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 1);
1860         FREE(pstrName);
1861         throw ast::InternalError(errorMsg);
1862     }
1863
1864     if (pDblOut->isComplex())
1865     {
1866         *itype = 1;
1867         xres[0] = pDblOut->get(0);
1868         xres[1] = pDblOut->getImg(0);
1869     }
1870     else
1871     {
1872         *itype = 0;
1873         xres[0] = pDblOut->get(0);
1874     }
1875
1876     if (out[0]->isDeletable())
1877     {
1878         delete out[0];
1879     }
1880 }
1881
1882 void DifferentialEquationFunctions::callBvodeMacroGsub(int* i, double* z, double* g)
1883 {
1884     char errorMsg[256];
1885     int one         = 1;
1886     int iRetCount   = 1;
1887
1888     typed_list in;
1889     typed_list out;
1890     types::optional_list opt;
1891     ast::ExecVisitor execFunc;
1892
1893     types::Double* pDblI = NULL;
1894     types::Double* pDblZ = NULL;
1895
1896     pDblI = new types::Double(*i);
1897     pDblI->IncreaseRef();
1898     in.push_back(pDblI);
1899
1900     pDblZ = new types::Double(m_bvodeM, 1);
1901     pDblZ->set(z);
1902     pDblZ->IncreaseRef();
1903     in.push_back(pDblZ);
1904
1905
1906     for (int i = 0; i < (int)m_GsubArgs.size(); i++)
1907     {
1908         m_GsubArgs[i]->IncreaseRef();
1909         in.push_back(m_GsubArgs[i]);
1910     }
1911
1912     try
1913     {
1914         // new std::wstring(L"") is delete in destructor of ast::CommentExp
1915         m_pCallGsubFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
1916     }
1917     catch (const ast::InternalError& ie)
1918     {
1919         for (int i = 0; i < (int)m_GsubArgs.size(); i++)
1920         {
1921             m_GsubArgs[i]->DecreaseRef();
1922         }
1923
1924         throw ie;
1925     }
1926
1927     for (int i = 0; i < (int)m_GsubArgs.size(); i++)
1928     {
1929         m_GsubArgs[i]->DecreaseRef();
1930     }
1931
1932     if (out.size() != iRetCount)
1933     {
1934         char* pstrName = wide_string_to_UTF8(m_pCallGsubFunction->getName().c_str());
1935         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
1936         FREE(pstrName);
1937         throw ast::InternalError(errorMsg);
1938     }
1939
1940     out[0]->IncreaseRef();
1941
1942     pDblI->DecreaseRef();
1943     if (pDblI->isDeletable())
1944     {
1945         delete pDblI;
1946     }
1947
1948     pDblZ->DecreaseRef();
1949     if (pDblZ->isDeletable())
1950     {
1951         delete pDblZ;
1952     }
1953
1954     out[0]->DecreaseRef();
1955     if (out[0]->isDouble() == false)
1956     {
1957         char* pstrName = wide_string_to_UTF8(m_pCallGsubFunction->getName().c_str());
1958         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
1959         FREE(pstrName);
1960         throw ast::InternalError(errorMsg);
1961     }
1962
1963     types::Double* pDblOut = out[0]->getAs<types::Double>();
1964     if (pDblOut->getSize() != 1)
1965     {
1966         char* pstrName = wide_string_to_UTF8(m_pCallGsubFunction->getName().c_str());
1967         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 1);
1968         FREE(pstrName);
1969         throw ast::InternalError(errorMsg);
1970     }
1971
1972     *g = pDblOut->get(0);
1973     if (out[0]->isDeletable())
1974     {
1975         delete out[0];
1976     }
1977 }
1978
1979 void DifferentialEquationFunctions::callBvodeMacroDgsub(int* i, double* z, double* g)
1980 {
1981     char errorMsg[256];
1982     int one         = 1;
1983     int iRetCount   = 1;
1984
1985     typed_list in;
1986     typed_list out;
1987     types::optional_list opt;
1988     ast::ExecVisitor execFunc;
1989
1990     types::Double* pDblI = NULL;
1991     types::Double* pDblZ = NULL;
1992
1993     pDblI = new types::Double(*i);
1994     pDblI->IncreaseRef();
1995     in.push_back(pDblI);
1996
1997     pDblZ = new types::Double(m_bvodeM, 1);
1998     pDblZ->set(z);
1999     pDblZ->IncreaseRef();
2000     in.push_back(pDblZ);
2001
2002     for (int i = 0; i < (int)m_DgsubArgs.size(); i++)
2003     {
2004         m_DgsubArgs[i]->IncreaseRef();
2005         in.push_back(m_DgsubArgs[i]);
2006     }
2007
2008     try
2009     {
2010         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2011         m_pCallDgsubFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2012     }
2013     catch (const ast::InternalError& ie)
2014     {
2015         for (int i = 0; i < (int)m_DgsubArgs.size(); i++)
2016         {
2017             m_DgsubArgs[i]->DecreaseRef();
2018         }
2019
2020         throw ie;
2021     }
2022
2023     for (int i = 0; i < (int)m_DgsubArgs.size(); i++)
2024     {
2025         m_DgsubArgs[i]->DecreaseRef();
2026     }
2027
2028     if (out.size() != iRetCount)
2029     {
2030         char* pstrName = wide_string_to_UTF8(m_pCallDgsubFunction->getName().c_str());
2031         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2032         FREE(pstrName);
2033         throw ast::InternalError(errorMsg);
2034     }
2035
2036     out[0]->IncreaseRef();
2037
2038     pDblI->DecreaseRef();
2039     if (pDblI->isDeletable())
2040     {
2041         delete pDblI;
2042     }
2043
2044     pDblZ->DecreaseRef();
2045     if (pDblZ->isDeletable())
2046     {
2047         delete pDblZ;
2048     }
2049
2050     out[0]->DecreaseRef();
2051     if (out[0]->isDouble() == false)
2052     {
2053         char* pstrName = wide_string_to_UTF8(m_pCallDgsubFunction->getName().c_str());
2054         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2055         FREE(pstrName);
2056         throw ast::InternalError(errorMsg);
2057     }
2058
2059     types::Double* pDblOut = out[0]->getAs<types::Double>();
2060     if (pDblOut->getSize() != m_bvodeM)
2061     {
2062         char* pstrName = wide_string_to_UTF8(m_pCallDgsubFunction->getName().c_str());
2063         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Matrix of size %d expected.\n"), pstrName, 1, m_bvodeM);
2064         FREE(pstrName);
2065         throw ast::InternalError(errorMsg);
2066     }
2067
2068     C2F(dcopy)(&m_bvodeM, pDblOut->get(), &one, g, &one);
2069     if (out[0]->isDeletable())
2070     {
2071         delete out[0];
2072     }
2073 }
2074
2075 void DifferentialEquationFunctions::callBvodeMacroFsub(double* x, double* z, double* d)
2076 {
2077     char errorMsg[256];
2078     int one         = 1;
2079     int iRetCount   = 1;
2080
2081     typed_list in;
2082     typed_list out;
2083     types::optional_list opt;
2084     ast::ExecVisitor execFunc;
2085
2086     types::Double* pDblX = NULL;
2087     types::Double* pDblZ = NULL;
2088
2089     pDblX = new types::Double(*x);
2090     pDblX->IncreaseRef();
2091     in.push_back(pDblX);
2092
2093     pDblZ = new types::Double(m_bvodeM, 1);
2094     pDblZ->set(z);
2095     pDblZ->IncreaseRef();
2096     in.push_back(pDblZ);
2097
2098     for (int i = 0; i < (int)m_FsubArgs.size(); i++)
2099     {
2100         m_FsubArgs[i]->IncreaseRef();
2101         in.push_back(m_FsubArgs[i]);
2102     }
2103
2104     try
2105     {
2106         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2107         m_pCallFsubFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2108     }
2109     catch (const ast::InternalError& ie)
2110     {
2111         for (int i = 0; i < (int)m_FsubArgs.size(); i++)
2112         {
2113             m_FsubArgs[i]->DecreaseRef();
2114         }
2115
2116         throw ie;
2117     }
2118
2119     for (int i = 0; i < (int)m_FsubArgs.size(); i++)
2120     {
2121         m_FsubArgs[i]->DecreaseRef();
2122     }
2123
2124     if (out.size() != iRetCount)
2125     {
2126         char* pstrName = wide_string_to_UTF8(m_pCallFsubFunction->getName().c_str());
2127         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2128         FREE(pstrName);
2129         throw ast::InternalError(errorMsg);
2130     }
2131
2132     out[0]->IncreaseRef();
2133
2134     pDblX->DecreaseRef();
2135     if (pDblX->isDeletable())
2136     {
2137         delete pDblX;
2138     }
2139
2140     pDblZ->DecreaseRef();
2141     if (pDblZ->isDeletable())
2142     {
2143         delete pDblZ;
2144     }
2145
2146     out[0]->DecreaseRef();
2147     if (out[0]->isDouble() == false)
2148     {
2149         char* pstrName = wide_string_to_UTF8(m_pCallFsubFunction->getName().c_str());
2150         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2151         FREE(pstrName);
2152         throw ast::InternalError(errorMsg);
2153     }
2154
2155     types::Double* pDblOut = out[0]->getAs<types::Double>();
2156     if (pDblOut->getSize() != m_bvodeN)
2157     {
2158         char* pstrName = wide_string_to_UTF8(m_pCallFsubFunction->getName().c_str());
2159         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, m_bvodeN);
2160         FREE(pstrName);
2161         throw ast::InternalError(errorMsg);
2162     }
2163
2164     C2F(dcopy)(&m_bvodeN, pDblOut->get(), &one, d, &one);
2165     if (out[0]->isDeletable())
2166     {
2167         delete out[0];
2168     }
2169 }
2170
2171 void DifferentialEquationFunctions::callBvodeMacroDfsub(double* x, double* z, double* d)
2172 {
2173     char errorMsg[256];
2174     int one         = 1;
2175     int iRetCount   = 1;
2176
2177     typed_list in;
2178     typed_list out;
2179     types::optional_list opt;
2180     ast::ExecVisitor execFunc;
2181
2182     types::Double* pDblX = NULL;
2183     types::Double* pDblZ = NULL;
2184
2185     pDblX = new types::Double(*x);
2186     pDblX->IncreaseRef();
2187     in.push_back(pDblX);
2188
2189     pDblZ = new types::Double(m_bvodeM, 1);
2190     pDblZ->set(z);
2191     pDblZ->IncreaseRef();
2192     in.push_back(pDblZ);
2193
2194     for (int i = 0; i < (int)m_DfsubArgs.size(); i++)
2195     {
2196         m_DfsubArgs[i]->IncreaseRef();
2197         in.push_back(m_DfsubArgs[i]);
2198     }
2199
2200     try
2201     {
2202         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2203         m_pCallDfsubFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2204     }
2205     catch (const ast::InternalError& ie)
2206     {
2207         for (int i = 0; i < (int)m_DfsubArgs.size(); i++)
2208         {
2209             m_DfsubArgs[i]->DecreaseRef();
2210         }
2211
2212         throw ie;
2213     }
2214
2215     for (int i = 0; i < (int)m_DfsubArgs.size(); i++)
2216     {
2217         m_DfsubArgs[i]->DecreaseRef();
2218     }
2219
2220     if (out.size() != iRetCount)
2221     {
2222         char* pstrName = wide_string_to_UTF8(m_pCallDfsubFunction->getName().c_str());
2223         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2224         FREE(pstrName);
2225         throw ast::InternalError(errorMsg);
2226     }
2227
2228     out[0]->IncreaseRef();
2229
2230     pDblX->DecreaseRef();
2231     if (pDblX->isDeletable())
2232     {
2233         delete pDblX;
2234     }
2235
2236     pDblZ->DecreaseRef();
2237     if (pDblZ->isDeletable())
2238     {
2239         delete pDblZ;
2240     }
2241
2242     out[0]->DecreaseRef();
2243     if (out[0]->isDouble() == false)
2244     {
2245         char* pstrName = wide_string_to_UTF8(m_pCallDfsubFunction->getName().c_str());
2246         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2247         FREE(pstrName);
2248         throw ast::InternalError(errorMsg);
2249     }
2250
2251     types::Double* pDblOut = out[0]->getAs<types::Double>();
2252     int size = m_bvodeN * m_bvodeM;
2253     if (pDblOut->getSize() != size)
2254     {
2255         char* pstrName = wide_string_to_UTF8(m_pCallDfsubFunction->getName().c_str());
2256         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, size);
2257         FREE(pstrName);
2258         throw ast::InternalError(errorMsg);
2259     }
2260
2261     C2F(dcopy)(&size, pDblOut->get(), &one, d, &one);
2262     if (out[0]->isDeletable())
2263     {
2264         delete out[0];
2265     }
2266 }
2267
2268 void DifferentialEquationFunctions::callBvodeMacroGuess(double* x, double* z, double* d)
2269 {
2270     char errorMsg[256];
2271     int one         = 1;
2272     int iRetCount   = 2;
2273
2274     typed_list in;
2275     typed_list out;
2276     types::optional_list opt;
2277     ast::ExecVisitor execFunc;
2278
2279     types::Double* pDblX = NULL;
2280
2281     pDblX = new types::Double(*x);
2282     pDblX->IncreaseRef();
2283     in.push_back(pDblX);
2284
2285     for (int i = 0; i < (int)m_GuessArgs.size(); i++)
2286     {
2287         m_GuessArgs[i]->IncreaseRef();
2288         in.push_back(m_GuessArgs[i]);
2289     }
2290
2291     try
2292     {
2293         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2294         m_pCallGuessFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2295     }
2296     catch (const ast::InternalError& ie)
2297     {
2298         for (int i = 0; i < (int)m_GuessArgs.size(); i++)
2299         {
2300             m_GuessArgs[i]->DecreaseRef();
2301         }
2302
2303         throw ie;
2304     }
2305
2306     for (int i = 0; i < (int)m_GuessArgs.size(); i++)
2307     {
2308         m_GuessArgs[i]->DecreaseRef();
2309     }
2310
2311     if (out.size() != iRetCount)
2312     {
2313         char* pstrName = wide_string_to_UTF8(m_pCallGuessFunction->getName().c_str());
2314         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2315         FREE(pstrName);
2316         throw ast::InternalError(errorMsg);
2317     }
2318
2319     out[0]->IncreaseRef();
2320     out[1]->IncreaseRef();
2321
2322     pDblX->DecreaseRef();
2323     if (pDblX->isDeletable())
2324     {
2325         delete pDblX;
2326     }
2327
2328     out[0]->DecreaseRef();
2329     if (out[0]->isDouble() == false)
2330     {
2331         char* pstrName = wide_string_to_UTF8(m_pCallGuessFunction->getName().c_str());
2332         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2333         FREE(pstrName);
2334         throw ast::InternalError(errorMsg);
2335     }
2336
2337     out[1]->DecreaseRef();
2338     if (out[1]->isDouble() == false)
2339     {
2340         char* pstrName = wide_string_to_UTF8(m_pCallGuessFunction->getName().c_str());
2341         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 2);
2342         FREE(pstrName);
2343         throw ast::InternalError(errorMsg);
2344     }
2345
2346     types::Double* pDblOutZ = out[0]->getAs<types::Double>();
2347     if (pDblOutZ->getSize() != m_bvodeM)
2348     {
2349         char* pstrName = wide_string_to_UTF8(m_pCallGuessFunction->getName().c_str());
2350         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, m_bvodeM);
2351         FREE(pstrName);
2352         throw ast::InternalError(errorMsg);
2353     }
2354
2355     types::Double* pDblOutD = out[1]->getAs<types::Double>();
2356     if (pDblOutD->getSize() != m_bvodeN)
2357     {
2358         char* pstrName = wide_string_to_UTF8(m_pCallGuessFunction->getName().c_str());
2359         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, m_bvodeN);
2360         FREE(pstrName);
2361         throw ast::InternalError(errorMsg);
2362     }
2363
2364     C2F(dcopy)(&m_bvodeM, pDblOutZ->get(), &one, z, &one);
2365     C2F(dcopy)(&m_bvodeN, pDblOutD->get(), &one, d, &one);
2366     if (out[0]->isDeletable())
2367     {
2368         delete out[0];
2369     }
2370
2371     if (out[1]->isDeletable())
2372     {
2373         delete out[1];
2374     }
2375 }
2376
2377 void DifferentialEquationFunctions::callImplMacroF(int* neq, double* t, double* y, double*s, double* r, int* ires)
2378 {
2379     char errorMsg[256];
2380     int one         = 1;
2381     int iRetCount   = 1;
2382
2383     *ires = 2;
2384
2385     typed_list in;
2386     typed_list out;
2387     types::optional_list opt;
2388     ast::ExecVisitor execFunc;
2389
2390     types::Double* pDblT = new types::Double(*t);
2391     pDblT->IncreaseRef();
2392     in.push_back(pDblT);
2393
2394     types::Double* pDblY = new types::Double(*neq, 1);
2395     pDblY->set(y);
2396     pDblY->IncreaseRef();
2397     in.push_back(pDblY);
2398
2399     types::Double* pDblS = new types::Double(*neq, 1);
2400     pDblS->set(s);
2401     pDblS->IncreaseRef();
2402     in.push_back(pDblS);
2403
2404     for (int i = 0; i < (int)m_FArgs.size(); i++)
2405     {
2406         m_FArgs[i]->IncreaseRef();
2407         in.push_back(m_FArgs[i]);
2408     }
2409
2410     try
2411     {
2412         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2413         m_pCallFFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2414     }
2415     catch (const ast::InternalError& ie)
2416     {
2417         for (int i = 0; i < (int)m_FArgs.size(); i++)
2418         {
2419             m_FArgs[i]->DecreaseRef();
2420         }
2421
2422         throw ie;
2423     }
2424
2425     if (out.size() != iRetCount)
2426     {
2427         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
2428         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2429         FREE(pstrName);
2430         throw ast::InternalError(errorMsg);
2431     }
2432
2433     out[0]->IncreaseRef();
2434
2435     pDblT->DecreaseRef();
2436     if (pDblT->isDeletable())
2437     {
2438         delete pDblT;
2439     }
2440
2441     pDblY->DecreaseRef();
2442     if (pDblY->isDeletable())
2443     {
2444         delete pDblY;
2445     }
2446
2447     pDblS->DecreaseRef();
2448     if (pDblS->isDeletable())
2449     {
2450         delete pDblS;
2451     }
2452
2453     out[0]->DecreaseRef();
2454     if (out[0]->isDouble() == false)
2455     {
2456         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
2457         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Matrix expected.\n"), pstrName, 1);
2458         FREE(pstrName);
2459         throw ast::InternalError(errorMsg);
2460     }
2461
2462     types::Double* pDblOutR = out[0]->getAs<types::Double>();
2463     if (pDblOutR->getSize() != *neq)
2464     {
2465         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
2466         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Matrix of size %d expected.\n"), pstrName, 1, *neq);
2467         FREE(pstrName);
2468         throw ast::InternalError(errorMsg);
2469     }
2470
2471     C2F(dcopy)(neq, pDblOutR->get(), &one, r, &one);
2472     *ires = 1;
2473     if (out[0]->isDeletable())
2474     {
2475         delete out[0];
2476     }
2477 }
2478
2479 void DifferentialEquationFunctions::callImplMacroG(int* neq, double* t, double* y, double* ml, double* mu, double* p, int* nrowp)
2480 {
2481     char errorMsg[256];
2482     int one         = 1;
2483     int iRetCount   = 1;
2484
2485     typed_list in;
2486     typed_list out;
2487     types::optional_list opt;
2488     ast::ExecVisitor execFunc;
2489
2490     types::Double* pDblT = new types::Double(*t);
2491     pDblT->IncreaseRef();
2492     in.push_back(pDblT);
2493
2494     types::Double* pDblY = new types::Double(*neq, 1);
2495     pDblY->set(y);
2496     pDblY->IncreaseRef();
2497     in.push_back(pDblY);
2498
2499     types::Double* pDblP = new types::Double(*nrowp, *neq);
2500     pDblP->set(p);
2501     pDblP->IncreaseRef();
2502     in.push_back(pDblP);
2503
2504     for (int i = 0; i < (int)m_odeGArgs.size(); i++)
2505     {
2506         m_odeGArgs[i]->IncreaseRef();
2507         in.push_back(m_odeGArgs[i]);
2508     }
2509
2510     try
2511     {
2512         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2513         m_pCallGFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2514     }
2515     catch (const ast::InternalError& ie)
2516     {
2517         for (int i = 0; i < (int)m_odeGArgs.size(); i++)
2518         {
2519             m_odeGArgs[i]->DecreaseRef();
2520         }
2521
2522         throw ie;
2523     }
2524
2525     for (int i = 0; i < (int)m_odeGArgs.size(); i++)
2526     {
2527         m_odeGArgs[i]->DecreaseRef();
2528     }
2529
2530     if (out.size() != iRetCount)
2531     {
2532         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
2533         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2534         FREE(pstrName);
2535         throw ast::InternalError(errorMsg);
2536     }
2537
2538     out[0]->IncreaseRef();
2539
2540     pDblT->DecreaseRef();
2541     if (pDblT->isDeletable())
2542     {
2543         delete pDblT;
2544     }
2545
2546     pDblY->DecreaseRef();
2547     if (pDblY->isDeletable())
2548     {
2549         delete pDblY;
2550     }
2551
2552     out[0]->DecreaseRef();
2553     if (out[0]->isDouble() == false)
2554     {
2555         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
2556         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2557         FREE(pstrName);
2558         throw ast::InternalError(errorMsg);
2559     }
2560
2561     types::Double* pDblOutP = out[0]->getAs<types::Double>();
2562     if (pDblOutP->getCols() != *neq || pDblOutP->getRows() != *nrowp)
2563     {
2564         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
2565         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d x %d expected.\n"), pstrName, 1, *neq, *nrowp);
2566         FREE(pstrName);
2567         throw ast::InternalError(errorMsg);
2568     }
2569
2570     int size = *neq **nrowp;
2571     C2F(dcopy)(&size, pDblOutP->get(), &one, p, &one);
2572     if (out[0]->isDeletable())
2573     {
2574         delete out[0];
2575     }
2576 }
2577
2578 void DifferentialEquationFunctions::callImplMacroJac(int* neq, double* t, double* y, double* s, double* ml, double* mu, double* p, int* nrowp)
2579 {
2580     char errorMsg[256];
2581     int one         = 1;
2582     int iRetCount   = 1;
2583
2584     typed_list in;
2585     typed_list out;
2586     types::optional_list opt;
2587     ast::ExecVisitor execFunc;
2588
2589     types::Double* pDblT = new types::Double(*t);
2590     pDblT->IncreaseRef();
2591     in.push_back(pDblT);
2592
2593     types::Double* pDblY = new types::Double(*neq, 1);
2594     pDblY->set(y);
2595     pDblY->IncreaseRef();
2596     in.push_back(pDblY);
2597
2598     types::Double* pDblS = new types::Double(*neq, 1);
2599     pDblS->set(s);
2600     pDblS->IncreaseRef();
2601     in.push_back(pDblS);
2602
2603     for (int i = 0; i < (int)m_JacArgs.size(); i++)
2604     {
2605         m_JacArgs[i]->IncreaseRef();
2606         in.push_back(m_JacArgs[i]);
2607     }
2608
2609     try
2610     {
2611         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2612         m_pCallJacFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2613     }
2614     catch (const ast::InternalError& ie)
2615     {
2616         for (int i = 0; i < (int)m_JacArgs.size(); i++)
2617         {
2618             m_JacArgs[i]->DecreaseRef();
2619         }
2620
2621         throw ie;
2622     }
2623
2624     for (int i = 0; i < (int)m_JacArgs.size(); i++)
2625     {
2626         m_JacArgs[i]->DecreaseRef();
2627     }
2628
2629     if (out.size() != iRetCount)
2630     {
2631         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2632         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2633         FREE(pstrName);
2634         throw ast::InternalError(errorMsg);
2635     }
2636
2637     out[0]->IncreaseRef();
2638
2639     pDblT->DecreaseRef();
2640     if (pDblT->isDeletable())
2641     {
2642         delete pDblT;
2643     }
2644
2645     pDblY->DecreaseRef();
2646     if (pDblY->isDeletable())
2647     {
2648         delete pDblY;
2649     }
2650
2651     pDblS->DecreaseRef();
2652     if (pDblS->isDeletable())
2653     {
2654         delete pDblS;
2655     }
2656
2657     out[0]->DecreaseRef();
2658     if (out[0]->isDouble() == false)
2659     {
2660         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2661         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2662         FREE(pstrName);
2663         throw ast::InternalError(errorMsg);
2664     }
2665
2666     types::Double* pDblOutP = out[0]->getAs<types::Double>();
2667     if (pDblOutP->getCols() != *neq || pDblOutP->getRows() != *nrowp)
2668     {
2669         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2670         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d x %d expected.\n"), pstrName, 1, *neq, *nrowp);
2671         FREE(pstrName);
2672         throw ast::InternalError(errorMsg);
2673     }
2674
2675     int size = *neq **nrowp;
2676     C2F(dcopy)(&size, pDblOutP->get(), &one, p, &one);
2677     if (out[0]->isDeletable())
2678     {
2679         delete out[0];
2680     }
2681 }
2682
2683 void DifferentialEquationFunctions::callDasslMacroF(double* t, double* y, double* ydot, double* delta, int* ires, double* rpar, int* ipar)
2684 {
2685     char errorMsg[256];
2686     int one         = 1;
2687     int iRetCount   = 2;
2688
2689     typed_list in;
2690     typed_list out;
2691     types::optional_list opt;
2692     ast::ExecVisitor execFunc;
2693
2694     types::Double* pDblT = new types::Double(*t);
2695     pDblT->IncreaseRef();
2696     in.push_back(pDblT);
2697
2698     types::Double* pDblY = new types::Double(m_odeYRows, 1);
2699     pDblY->set(y);
2700     pDblY->IncreaseRef();
2701     in.push_back(pDblY);
2702
2703     types::Double* pDblYdot = new types::Double(m_odeYRows, 1);
2704     pDblYdot->set(ydot);
2705     pDblYdot->IncreaseRef();
2706     in.push_back(pDblYdot);
2707
2708     for (int i = 0; i < (int)m_FArgs.size(); i++)
2709     {
2710         m_FArgs[i]->IncreaseRef();
2711         in.push_back(m_FArgs[i]);
2712     }
2713
2714     try
2715     {
2716         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2717         m_pCallFFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2718     }
2719     catch (const ast::InternalError& ie)
2720     {
2721         for (int i = 0; i < (int)m_FArgs.size(); i++)
2722         {
2723             m_FArgs[i]->DecreaseRef();
2724         }
2725
2726         throw ie;
2727     }
2728
2729     for (int i = 0; i < (int)m_FArgs.size(); i++)
2730     {
2731         m_FArgs[i]->DecreaseRef();
2732     }
2733
2734     if (out.size() != iRetCount)
2735     {
2736         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
2737         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2738         FREE(pstrName);
2739         throw ast::InternalError(errorMsg);
2740     }
2741
2742     out[0]->IncreaseRef();
2743     out[1]->IncreaseRef();
2744
2745     pDblT->DecreaseRef();
2746     if (pDblT->isDeletable())
2747     {
2748         delete pDblT;
2749     }
2750
2751     pDblY->DecreaseRef();
2752     if (pDblY->isDeletable())
2753     {
2754         delete pDblY;
2755     }
2756
2757     pDblYdot->DecreaseRef();
2758     if (pDblYdot->isDeletable())
2759     {
2760         delete pDblYdot;
2761     }
2762
2763     out[0]->DecreaseRef();
2764     if (out[0]->isDouble() == false)
2765     {
2766         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
2767         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2768         FREE(pstrName);
2769         throw ast::InternalError(errorMsg);
2770     }
2771
2772     out[1]->DecreaseRef();
2773     if (out[1]->isDouble() == false)
2774     {
2775         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
2776         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 2);
2777         FREE(pstrName);
2778         throw ast::InternalError(errorMsg);
2779     }
2780
2781     types::Double* pDblOutDelta = out[0]->getAs<types::Double>();
2782     if (pDblOutDelta->getSize() != m_odeYRows)
2783     {
2784         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
2785         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, m_odeYRows);
2786         FREE(pstrName);
2787         throw ast::InternalError(errorMsg);
2788     }
2789
2790     types::Double* pDblOutIres = out[1]->getAs<types::Double>();
2791     if (pDblOutIres->getSize() != 1)
2792     {
2793         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
2794         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 2);
2795         FREE(pstrName);
2796         throw ast::InternalError(errorMsg);
2797     }
2798
2799     C2F(dcopy)(&m_odeYRows, pDblOutDelta->get(), &one, delta, &one);
2800     *ires = (int)pDblOutIres->get(0);
2801
2802     if (out[0]->isDeletable())
2803     {
2804         delete out[0];
2805     }
2806
2807     if (out[1]->isDeletable())
2808     {
2809         delete out[1];
2810     }
2811 }
2812
2813 void DifferentialEquationFunctions::callDasslMacroJac(double* t, double* y, double* ydot, double* pd, double* cj, double* rpar, int* ipar)
2814 {
2815     char errorMsg[256];
2816     int one         = 1;
2817     int iRetCount   = 1;
2818
2819     typed_list in;
2820     typed_list out;
2821     types::optional_list opt;
2822     ast::ExecVisitor execFunc;
2823
2824     types::Double* pDblT = new types::Double(*t);
2825     pDblT->IncreaseRef();
2826     in.push_back(pDblT);
2827
2828     types::Double* pDblY = new types::Double(m_odeYRows, 1);
2829     pDblY->set(y);
2830     pDblY->IncreaseRef();
2831     in.push_back(pDblY);
2832
2833     types::Double* pDblYdot = new types::Double(m_odeYRows, 1);
2834     pDblYdot->set(ydot);
2835     pDblYdot->IncreaseRef();
2836     in.push_back(pDblYdot);
2837
2838     types::Double* pDblCj = new types::Double(*cj);
2839     pDblCj->IncreaseRef();
2840     in.push_back(pDblCj);
2841
2842     for (int i = 0; i < (int)m_JacArgs.size(); i++)
2843     {
2844         m_JacArgs[i]->IncreaseRef();
2845         in.push_back(m_JacArgs[i]);
2846     }
2847
2848     try
2849     {
2850         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2851         m_pCallJacFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2852     }
2853     catch (const ast::InternalError& ie)
2854     {
2855         for (int i = 0; i < (int)m_JacArgs.size(); i++)
2856         {
2857             m_JacArgs[i]->DecreaseRef();
2858         }
2859
2860         throw ie;
2861     }
2862
2863     for (int i = 0; i < (int)m_JacArgs.size(); i++)
2864     {
2865         m_JacArgs[i]->DecreaseRef();
2866     }
2867
2868     if (out.size() != iRetCount)
2869     {
2870         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2871         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2872         FREE(pstrName);
2873         throw ast::InternalError(errorMsg);
2874     }
2875
2876     out[0]->IncreaseRef();
2877
2878     pDblT->DecreaseRef();
2879     if (pDblT->isDeletable())
2880     {
2881         delete pDblT;
2882     }
2883
2884     pDblY->DecreaseRef();
2885     if (pDblY->isDeletable())
2886     {
2887         delete pDblY;
2888     }
2889
2890     pDblYdot->DecreaseRef();
2891     if (pDblYdot->isDeletable())
2892     {
2893         delete pDblYdot;
2894     }
2895
2896     pDblCj->DecreaseRef();
2897     if (pDblCj->isDeletable())
2898     {
2899         delete pDblCj;
2900     }
2901
2902     out[0]->DecreaseRef();
2903     if (out[0]->isDouble() == false)
2904     {
2905         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2906         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2907         FREE(pstrName);
2908         throw ast::InternalError(errorMsg);
2909     }
2910
2911     types::Double* pDblOutPd = out[0]->getAs<types::Double>();
2912     if ( (pDblOutPd->getCols() != m_odeYRows) ||
2913             (!m_bandedJac && pDblOutPd->getRows() != m_odeYRows) ||
2914             (m_bandedJac && pDblOutPd->getRows() != (2 * m_ml + m_mu + 1)))
2915     {
2916         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2917         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d x %d expected.\n"), pstrName, 1, m_odeYRows, (2 * m_ml + m_mu + 1));
2918         FREE(pstrName);
2919         throw ast::InternalError(errorMsg);
2920     }
2921
2922     int size = pDblOutPd->getSize();
2923     C2F(dcopy)(&size, pDblOutPd->get(), &one, pd, &one);
2924     if (out[0]->isDeletable())
2925     {
2926         delete out[0];
2927     }
2928 }
2929
2930 void DifferentialEquationFunctions::callDasrtMacroG(int* ny, double* t, double* y, int* ng, double* gout, double* rpar, int* ipar)
2931 {
2932     char errorMsg[256];
2933     int one         = 1;
2934     int iRetCount   = 1;
2935
2936     typed_list in;
2937     typed_list out;
2938     types::optional_list opt;
2939     ast::ExecVisitor execFunc;
2940
2941     types::Double* pDblT = new types::Double(*t);
2942     pDblT->IncreaseRef();
2943     in.push_back(pDblT);
2944
2945     types::Double* pDblY = new types::Double(*ny, 1);
2946     pDblY->set(y);
2947     pDblY->IncreaseRef();
2948     in.push_back(pDblY);
2949
2950     for (int i = 0; i < (int)m_odeGArgs.size(); i++)
2951     {
2952         m_odeGArgs[i]->IncreaseRef();
2953         in.push_back(m_odeGArgs[i]);
2954     }
2955
2956     try
2957     {
2958         // new std::wstring(L"") is delete in destructor of ast::CommentExp
2959         m_pCallGFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
2960     }
2961     catch (const ast::InternalError& ie)
2962     {
2963         for (int i = 0; i < (int)m_odeGArgs.size(); i++)
2964         {
2965             m_odeGArgs[i]->DecreaseRef();
2966         }
2967
2968         throw ie;
2969     }
2970
2971     for (int i = 0; i < (int)m_odeGArgs.size(); i++)
2972     {
2973         m_odeGArgs[i]->DecreaseRef();
2974     }
2975
2976     if (out.size() != iRetCount)
2977     {
2978         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
2979         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
2980         FREE(pstrName);
2981         throw ast::InternalError(errorMsg);
2982     }
2983
2984     out[0]->IncreaseRef();
2985
2986     pDblT->DecreaseRef();
2987     if (pDblT->isDeletable())
2988     {
2989         delete pDblT;
2990     }
2991
2992     pDblY->DecreaseRef();
2993     if (pDblY->isDeletable())
2994     {
2995         delete pDblY;
2996     }
2997
2998     out[0]->DecreaseRef();
2999     if (out[0]->isDouble() == false)
3000     {
3001         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
3002         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
3003         FREE(pstrName);
3004         throw ast::InternalError(errorMsg);
3005     }
3006
3007     types::Double* pDblOutGout = out[0]->getAs<types::Double>();
3008     if (pDblOutGout->getSize() != *ng)
3009     {
3010         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
3011         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, *ng);
3012         FREE(pstrName);
3013         throw ast::InternalError(errorMsg);
3014     }
3015
3016     C2F(dcopy)(ng, pDblOutGout->get(), &one, gout, &one);
3017     if (out[0]->isDeletable())
3018     {
3019         delete out[0];
3020     }
3021 }
3022
3023 void DifferentialEquationFunctions::callDaskrMacroPjac(double* res, int* ires, int* neq, double* t, double* y, double* ydot,
3024         double* rewt, double* savr, double* wk, double* h, double* cj,
3025         double* wp, int* iwp, int* ier, double* rpar, int* ipar)
3026 {
3027     // macro : [R, iR, ier] = psol(neq, t, y, ydot, h, cj, rewt, savr)
3028     char errorMsg[256];
3029     int one         = 1;
3030     int iRetCount   = 3;
3031
3032     typed_list in;
3033     typed_list out;
3034     types::optional_list opt;
3035     ast::ExecVisitor execFunc;
3036
3037     types::Double* pDblNeq = new types::Double((double)(*neq));
3038     pDblNeq->IncreaseRef();
3039     in.push_back(pDblNeq);
3040
3041     types::Double* pDblT = new types::Double(*t);
3042     pDblT->IncreaseRef();
3043     in.push_back(pDblT);
3044
3045     types::Double* pDblY = new types::Double(m_odeYRows, 1);
3046     pDblY->set(y);
3047     pDblY->IncreaseRef();
3048     in.push_back(pDblY);
3049
3050     types::Double* pDblYdot = new types::Double(m_odeYRows, 1);
3051     pDblYdot->set(ydot);
3052     pDblYdot->IncreaseRef();
3053     in.push_back(pDblYdot);
3054
3055     types::Double* pDblH = new types::Double(*h);
3056     pDblH->IncreaseRef();
3057     in.push_back(pDblH);
3058
3059     types::Double* pDblCj = new types::Double(*cj);
3060     pDblCj->IncreaseRef();
3061     in.push_back(pDblCj);
3062
3063     types::Double* pDblRewt = new types::Double(m_odeYRows, 1);
3064     pDblRewt->set(rewt);
3065     pDblRewt->IncreaseRef();
3066     in.push_back(pDblRewt);
3067
3068     types::Double* pDblSavr = new types::Double(m_odeYRows, 1);
3069     pDblSavr->set(savr);
3070     pDblSavr->IncreaseRef();
3071     in.push_back(pDblSavr);
3072
3073     for (int i = 0; i < (int)m_pJacArgs.size(); i++)
3074     {
3075         m_pJacArgs[i]->IncreaseRef();
3076         in.push_back(m_pJacArgs[i]);
3077     }
3078
3079     try
3080     {
3081         // new std::wstring(L"") is delete in destructor of ast::CommentExp
3082         m_pCallPjacFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
3083     }
3084     catch (const ast::InternalError& ie)
3085     {
3086         for (int i = 0; i < (int)m_pJacArgs.size(); i++)
3087         {
3088             m_pJacArgs[i]->DecreaseRef();
3089         }
3090
3091         throw ie;
3092     }
3093
3094     for (int i = 0; i < (int)m_pJacArgs.size(); i++)
3095     {
3096         m_pJacArgs[i]->DecreaseRef();
3097     }
3098
3099     if (out.size() != iRetCount)
3100     {
3101         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
3102         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
3103         FREE(pstrName);
3104         throw ast::InternalError(errorMsg);
3105     }
3106
3107     out[0]->IncreaseRef();
3108     out[1]->IncreaseRef();
3109     out[2]->IncreaseRef();
3110
3111     pDblNeq->DecreaseRef();
3112     if (pDblNeq->isDeletable())
3113     {
3114         delete pDblNeq;
3115     }
3116
3117     pDblT->DecreaseRef();
3118     if (pDblT->isDeletable())
3119     {
3120         delete pDblT;
3121     }
3122
3123     pDblY->DecreaseRef();
3124     if (pDblY->isDeletable())
3125     {
3126         delete pDblY;
3127     }
3128
3129     pDblYdot->DecreaseRef();
3130     if (pDblYdot->isDeletable())
3131     {
3132         delete pDblYdot;
3133     }
3134
3135     pDblH->DecreaseRef();
3136     if (pDblH->isDeletable())
3137     {
3138         delete pDblH;
3139     }
3140
3141     pDblCj->DecreaseRef();
3142     if (pDblCj->isDeletable())
3143     {
3144         delete pDblCj;
3145     }
3146
3147     pDblRewt->DecreaseRef();
3148     if (pDblRewt->isDeletable())
3149     {
3150         delete pDblRewt;
3151     }
3152
3153     pDblSavr->DecreaseRef();
3154     if (pDblSavr->isDeletable())
3155     {
3156         delete pDblSavr;
3157     }
3158
3159     // check type of output arguments
3160     if (out[0]->isDouble() == false)
3161     {
3162         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
3163         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
3164         FREE(pstrName);
3165         throw ast::InternalError(errorMsg);
3166     }
3167
3168     if (out[1]->isDouble() == false)
3169     {
3170         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
3171         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 2);
3172         FREE(pstrName);
3173         throw ast::InternalError(errorMsg);
3174     }
3175
3176     if (out[2]->isDouble() == false)
3177     {
3178         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
3179         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 3);
3180         FREE(pstrName);
3181         throw ast::InternalError(errorMsg);
3182     }
3183
3184     //  return [R, iR, ier]
3185     types::Double* pDblOutWp  = out[0]->getAs<types::Double>();
3186     types::Double* pDblOutIwp = out[1]->getAs<types::Double>();
3187     types::Double* pDblOutIer = out[2]->getAs<types::Double>();
3188
3189     // check size of output argument
3190     if (pDblOutWp->getSize() != *neq **neq)
3191     {
3192         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
3193         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, *neq **neq);
3194         FREE(pstrName);
3195         throw ast::InternalError(errorMsg);
3196     }
3197
3198     if (pDblOutIwp->getSize() != 2 * *neq **neq)
3199     {
3200         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
3201         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 2, 2 * *neq **neq);
3202         FREE(pstrName);
3203         throw ast::InternalError(errorMsg);
3204     }
3205
3206     if (pDblOutIer->isScalar() == false)
3207     {
3208         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
3209         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 3);
3210         FREE(pstrName);
3211         throw ast::InternalError(errorMsg);
3212     }
3213
3214     // copy output macro results in output variables
3215     int size = pDblOutWp->getSize();
3216     C2F(dcopy)(&size, pDblOutWp->get(), &one, wp, &one);
3217
3218     double* pdblIwp = pDblOutIwp->get();
3219     for (int i = 0; i < pDblOutIwp->getSize(); i++)
3220     {
3221         iwp[i] = (int)pdblIwp[i];
3222     }
3223
3224     *ier = (int)(pDblOutIer->get(0));
3225
3226     // delete output macro result
3227     out[0]->DecreaseRef();
3228     if (out[0]->isDeletable())
3229     {
3230         delete out[0];
3231     }
3232
3233     out[1]->DecreaseRef();
3234     if (out[1]->isDeletable())
3235     {
3236         delete out[1];
3237     }
3238
3239     out[2]->DecreaseRef();
3240     if (out[2]->isDeletable())
3241     {
3242         delete out[2];
3243     }
3244 }
3245
3246 void DifferentialEquationFunctions::callDaskrMacroPsol(int* neq, double* t, double* y, double* ydot, double* savr, double* wk,
3247         double* cj, double* wght, double* wp, int* iwp, double* b, double* eplin,
3248         int* ier, double* rpar, int* ipar)
3249 {
3250     // macro : [b, ier] = psol(R, iR, b)
3251     char errorMsg[256];
3252     int one         = 1;
3253     int iRetCount   = 2;
3254
3255     typed_list in;
3256     typed_list out;
3257     types::optional_list opt;
3258     ast::ExecVisitor execFunc;
3259
3260     // input arguments psol(R, iR, b)
3261     types::Double* pDblR = new types::Double(*neq **neq, 1);
3262     pDblR->set(wp);
3263     pDblR->IncreaseRef();
3264     in.push_back(pDblR);
3265
3266     types::Double* pDblIR = new types::Double(*neq **neq, 2);
3267     double* pdblIR = pDblIR->get();
3268     for (int i = 0; i < pDblIR->getSize(); i++)
3269     {
3270         pdblIR[i] = (double)iwp[i];
3271     }
3272     pDblIR->IncreaseRef();
3273     in.push_back(pDblIR);
3274
3275     types::Double* pDblB = new types::Double(*neq, 1);
3276     pDblB->set(b);
3277     pDblB->IncreaseRef();
3278     in.push_back(pDblB);
3279
3280     // optional arguments
3281     for (int i = 0; i < (int)m_pSolArgs.size(); i++)
3282     {
3283         m_pSolArgs[i]->IncreaseRef();
3284         in.push_back(m_pSolArgs[i]);
3285     }
3286
3287     try
3288     {
3289         // new std::wstring(L"") is delete in destructor of ast::CommentExp
3290         m_pCallPsolFunction->invoke(in, opt, iRetCount, out, execFunc, ast::CommentExp(Location(), new std::wstring(L"")));
3291     }
3292     catch (const ast::InternalError& ie)
3293     {
3294         for (int i = 0; i < (int)m_pSolArgs.size(); i++)
3295         {
3296             m_pSolArgs[i]->DecreaseRef();
3297         }
3298
3299         throw ie;
3300     }
3301
3302     for (int i = 0; i < (int)m_pSolArgs.size(); i++)
3303     {
3304         m_pSolArgs[i]->DecreaseRef();
3305     }
3306
3307     // get output
3308     if (out.size() != iRetCount)
3309     {
3310         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3311         sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
3312         FREE(pstrName);
3313         throw ast::InternalError(errorMsg);
3314     }
3315
3316     out[0]->IncreaseRef();
3317     out[1]->IncreaseRef();
3318
3319     // free input arguments
3320     pDblR->DecreaseRef();
3321     if (pDblR->isDeletable())
3322     {
3323         delete pDblR;
3324     }
3325
3326     pDblIR->DecreaseRef();
3327     if (pDblIR->isDeletable())
3328     {
3329         delete pDblIR;
3330     }
3331
3332     pDblB->DecreaseRef();
3333     if (pDblB->isDeletable())
3334     {
3335         delete pDblB;
3336     }
3337
3338     // check output result
3339     if (out[0]->isDouble() == false)
3340     {
3341         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3342         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
3343         FREE(pstrName);
3344         throw ast::InternalError(errorMsg);
3345     }
3346
3347     if (out[1]->isDouble() == false)
3348     {
3349         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3350         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 2);
3351         FREE(pstrName);
3352         throw ast::InternalError(errorMsg);
3353     }
3354
3355     // return arguments [b, ier] = psol()
3356     types::Double* pDblOutB  = out[0]->getAs<types::Double>();
3357     if (pDblOutB->getSize() != *neq) // size of b is neq
3358     {
3359         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3360         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, *neq);
3361         FREE(pstrName);
3362         throw ast::InternalError(errorMsg);
3363     }
3364
3365     // get scalar ier
3366     types::Double* pDblOutIer = out[1]->getAs<types::Double>();
3367     if (pDblOutIer->isScalar() == false)
3368     {
3369         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3370         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 2);
3371         FREE(pstrName);
3372         throw ast::InternalError(errorMsg);
3373     }
3374
3375     // copy output macro results in output variables
3376     C2F(dcopy)(neq, pDblOutB->get(), &one, b, &one);
3377     *ier = (int)(pDblOutIer->get(0));
3378
3379     // free output arguments
3380     out[0]->DecreaseRef();
3381     if (out[0]->isDeletable())
3382     {
3383         delete out[0];
3384     }
3385
3386     out[1]->DecreaseRef();
3387     if (out[1]->isDeletable())
3388     {
3389         delete out[1];
3390     }
3391 }