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