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     if (out[0]->isDeletable())
2639     {
2640         delete out[0];
2641     }
2642 }
2643
2644 void DifferentialEquationFunctions::callDasslMacroJac(double* t, double* y, double* ydot, double* pd, double* cj, double* rpar, int* ipar)
2645 {
2646     char errorMsg[256];
2647     int one         = 1;
2648     int iRetCount   = 1;
2649
2650     typed_list in;
2651     typed_list out;
2652     types::optional_list opt;
2653     ast::ExecVisitor execFunc;
2654
2655     types::Double* pDblT = new types::Double(*t);
2656     pDblT->IncreaseRef();
2657     in.push_back(pDblT);
2658
2659     types::Double* pDblY = new types::Double(m_odeYRows, 1);
2660     pDblY->set(y);
2661     pDblY->IncreaseRef();
2662     in.push_back(pDblY);
2663
2664     types::Double* pDblYdot = new types::Double(m_odeYRows, 1);
2665     pDblYdot->set(ydot);
2666     pDblYdot->IncreaseRef();
2667     in.push_back(pDblYdot);
2668
2669     types::Double* pDblCj = new types::Double(*cj);
2670     pDblCj->IncreaseRef();
2671     in.push_back(pDblCj);
2672
2673     for (int i = 0; i < (int)m_JacArgs.size(); i++)
2674     {
2675         m_JacArgs[i]->IncreaseRef();
2676         in.push_back(m_JacArgs[i]);
2677     }
2678
2679     bool bOk = m_pCallJacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
2680
2681     for (int i = 0; i < (int)m_FArgs.size(); i++)
2682     {
2683         m_FArgs[i]->DecreaseRef();
2684     }
2685
2686     if (bOk == false)
2687     {
2688         sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallJacFunction->getName().c_str());
2689         throw ast::ScilabError(errorMsg);
2690     }
2691
2692     if (out.size() != iRetCount)
2693     {
2694         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2695         sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
2696         FREE(pstrName);
2697         throw ast::ScilabError(errorMsg);
2698     }
2699
2700     out[0]->IncreaseRef();
2701
2702     pDblT->DecreaseRef();
2703     if (pDblT->isDeletable())
2704     {
2705         delete pDblT;
2706     }
2707
2708     pDblY->DecreaseRef();
2709     if (pDblY->isDeletable())
2710     {
2711         delete pDblY;
2712     }
2713
2714     pDblYdot->DecreaseRef();
2715     if (pDblYdot->isDeletable())
2716     {
2717         delete pDblYdot;
2718     }
2719
2720     pDblCj->DecreaseRef();
2721     if (pDblCj->isDeletable())
2722     {
2723         delete pDblCj;
2724     }
2725
2726     out[0]->DecreaseRef();
2727     if (out[0]->isDouble() == false)
2728     {
2729         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2730         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2731         FREE(pstrName);
2732         throw ast::ScilabError(errorMsg);
2733     }
2734
2735     types::Double* pDblOutPd = out[0]->getAs<types::Double>();
2736     if ( (pDblOutPd->getCols() != m_odeYRows) ||
2737             (!m_bandedJac && pDblOutPd->getRows() != m_odeYRows) ||
2738             (m_bandedJac && pDblOutPd->getRows() != (2 * m_ml + m_mu + 1)))
2739     {
2740         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
2741         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));
2742         FREE(pstrName);
2743         throw ast::ScilabError(errorMsg);
2744     }
2745
2746     int size = pDblOutPd->getSize();
2747     C2F(dcopy)(&size, pDblOutPd->get(), &one, pd, &one);
2748     if (out[0]->isDeletable())
2749     {
2750         delete out[0];
2751     }
2752 }
2753
2754 void DifferentialEquationFunctions::callDasrtMacroG(int* ny, double* t, double* y, int* ng, double* gout, double* rpar, int* ipar)
2755 {
2756     char errorMsg[256];
2757     int one         = 1;
2758     int iRetCount   = 1;
2759
2760     typed_list in;
2761     typed_list out;
2762     types::optional_list opt;
2763     ast::ExecVisitor execFunc;
2764
2765     types::Double* pDblT = new types::Double(*t);
2766     pDblT->IncreaseRef();
2767     in.push_back(pDblT);
2768
2769     types::Double* pDblY = new types::Double(*ny, 1);
2770     pDblY->set(y);
2771     pDblY->IncreaseRef();
2772     in.push_back(pDblY);
2773
2774     for (int i = 0; i < (int)m_odeGArgs.size(); i++)
2775     {
2776         m_odeGArgs[i]->IncreaseRef();
2777         in.push_back(m_odeGArgs[i]);
2778     }
2779
2780     bool bOk = m_pCallGFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
2781
2782     for (int i = 0; i < (int)m_FArgs.size(); i++)
2783     {
2784         m_FArgs[i]->DecreaseRef();
2785     }
2786
2787     if (bOk == false)
2788     {
2789         sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallGFunction->getName().c_str());
2790         throw ast::ScilabError(errorMsg);
2791     }
2792
2793     if (out.size() != iRetCount)
2794     {
2795         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
2796         sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
2797         FREE(pstrName);
2798         throw ast::ScilabError(errorMsg);
2799     }
2800
2801     out[0]->IncreaseRef();
2802
2803     pDblT->DecreaseRef();
2804     if (pDblT->isDeletable())
2805     {
2806         delete pDblT;
2807     }
2808
2809     pDblY->DecreaseRef();
2810     if (pDblY->isDeletable())
2811     {
2812         delete pDblY;
2813     }
2814
2815     out[0]->DecreaseRef();
2816     if (out[0]->isDouble() == false)
2817     {
2818         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
2819         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2820         FREE(pstrName);
2821         throw ast::ScilabError(errorMsg);
2822     }
2823
2824     types::Double* pDblOutGout = out[0]->getAs<types::Double>();
2825     if (pDblOutGout->getSize() != *ng)
2826     {
2827         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
2828         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, *ng);
2829         FREE(pstrName);
2830         throw ast::ScilabError(errorMsg);
2831     }
2832
2833     C2F(dcopy)(ng, pDblOutGout->get(), &one, gout, &one);
2834     if (out[0]->isDeletable())
2835     {
2836         delete out[0];
2837     }
2838 }
2839
2840 void DifferentialEquationFunctions::callDaskrMacroPjac(double* res, int* ires, int* neq, double* t, double* y, double* ydot,
2841         double* rewt, double* savr, double* wk, double* h, double* cj,
2842         double* wp, int* iwp, int* ier, double* rpar, int* ipar)
2843 {
2844     // macro : [R, iR, ier] = psol(neq, t, y, ydot, h, cj, rewt, savr)
2845     char errorMsg[256];
2846     int one         = 1;
2847     int iRetCount   = 3;
2848
2849     typed_list in;
2850     typed_list out;
2851     types::optional_list opt;
2852     ast::ExecVisitor execFunc;
2853
2854     types::Double* pDblNeq = new types::Double((double)(*neq));
2855     pDblNeq->IncreaseRef();
2856     in.push_back(pDblNeq);
2857
2858     types::Double* pDblT = new types::Double(*t);
2859     pDblT->IncreaseRef();
2860     in.push_back(pDblT);
2861
2862     types::Double* pDblY = new types::Double(m_odeYRows, 1);
2863     pDblY->set(y);
2864     pDblY->IncreaseRef();
2865     in.push_back(pDblY);
2866
2867     types::Double* pDblYdot = new types::Double(m_odeYRows, 1);
2868     pDblYdot->set(ydot);
2869     pDblYdot->IncreaseRef();
2870     in.push_back(pDblYdot);
2871
2872     types::Double* pDblH = new types::Double(*h);
2873     pDblH->IncreaseRef();
2874     in.push_back(pDblH);
2875
2876     types::Double* pDblCj = new types::Double(*cj);
2877     pDblCj->IncreaseRef();
2878     in.push_back(pDblCj);
2879
2880     types::Double* pDblRewt = new types::Double(m_odeYRows, 1);
2881     pDblRewt->set(rewt);
2882     pDblRewt->IncreaseRef();
2883     in.push_back(pDblRewt);
2884
2885     types::Double* pDblSavr = new types::Double(m_odeYRows, 1);
2886     pDblSavr->set(savr);
2887     pDblSavr->IncreaseRef();
2888     in.push_back(pDblSavr);
2889
2890     for (int i = 0; i < (int)m_pJacArgs.size(); i++)
2891     {
2892         in.push_back(m_pJacArgs[i]);
2893     }
2894
2895     bool bOk = m_pCallPjacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
2896
2897     if (bOk == false)
2898     {
2899         sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallPjacFunction->getName().c_str());
2900         throw ast::ScilabError(errorMsg);
2901     }
2902
2903     if (out.size() != iRetCount)
2904     {
2905         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
2906         sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
2907         FREE(pstrName);
2908         throw ast::ScilabError(errorMsg);
2909     }
2910
2911     out[0]->IncreaseRef();
2912
2913     pDblNeq->DecreaseRef();
2914     if (pDblNeq->isDeletable())
2915     {
2916         delete pDblNeq;
2917     }
2918
2919     pDblT->DecreaseRef();
2920     if (pDblT->isDeletable())
2921     {
2922         delete pDblT;
2923     }
2924
2925     pDblY->DecreaseRef();
2926     if (pDblY->isDeletable())
2927     {
2928         delete pDblY;
2929     }
2930
2931     pDblYdot->DecreaseRef();
2932     if (pDblYdot->isDeletable())
2933     {
2934         delete pDblYdot;
2935     }
2936
2937     pDblH->DecreaseRef();
2938     if (pDblH->isDeletable())
2939     {
2940         delete pDblH;
2941     }
2942
2943     pDblCj->DecreaseRef();
2944     if (pDblCj->isDeletable())
2945     {
2946         delete pDblCj;
2947     }
2948
2949     pDblRewt->DecreaseRef();
2950     if (pDblRewt->isDeletable())
2951     {
2952         delete pDblRewt;
2953     }
2954
2955     pDblSavr->DecreaseRef();
2956     if (pDblSavr->isDeletable())
2957     {
2958         delete pDblSavr;
2959     }
2960
2961     // check type of output arguments
2962     if (out[0]->isDouble() == false)
2963     {
2964         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
2965         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
2966         FREE(pstrName);
2967         throw ast::ScilabError(errorMsg);
2968     }
2969
2970     if (out[1]->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, 2);
2974         FREE(pstrName);
2975         throw ast::ScilabError(errorMsg);
2976     }
2977
2978     if (out[2]->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, 3);
2982         FREE(pstrName);
2983         throw ast::ScilabError(errorMsg);
2984     }
2985
2986     //  return [R, iR, ier]
2987     types::Double* pDblOutWp  = out[0]->getAs<types::Double>();
2988     types::Double* pDblOutIwp = out[1]->getAs<types::Double>();
2989     types::Double* pDblOutIer = out[2]->getAs<types::Double>();
2990
2991     // check size of output argument
2992     if (pDblOutWp->getSize() != *neq **neq)
2993     {
2994         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
2995         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, *neq **neq);
2996         FREE(pstrName);
2997         throw ast::ScilabError(errorMsg);
2998     }
2999
3000     if (pDblOutIwp->getSize() != 2 * *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, 2, 2 * *neq **neq);
3004         FREE(pstrName);
3005         throw ast::ScilabError(errorMsg);
3006     }
3007
3008     if (pDblOutIer->isScalar() == false)
3009     {
3010         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
3011         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 3);
3012         FREE(pstrName);
3013         throw ast::ScilabError(errorMsg);
3014     }
3015
3016     // copy output macro results in output variables
3017     int size = pDblOutWp->getSize();
3018     C2F(dcopy)(&size, pDblOutWp->get(), &one, wp, &one);
3019
3020     double* pdblIwp = pDblOutIwp->get();
3021     for (int i = 0; i < pDblOutIwp->getSize(); i++)
3022     {
3023         iwp[i] = (int)pdblIwp[i];
3024     }
3025
3026     *ier = (int)(pDblOutIer->get(0));
3027
3028     // delete output macro result
3029     out[0]->DecreaseRef();
3030     if (out[0]->isDeletable())
3031     {
3032         delete out[0];
3033     }
3034
3035     out[1]->DecreaseRef();
3036     if (out[1]->isDeletable())
3037     {
3038         delete out[1];
3039     }
3040
3041     out[2]->DecreaseRef();
3042     if (out[2]->isDeletable())
3043     {
3044         delete out[2];
3045     }
3046 }
3047
3048 void DifferentialEquationFunctions::callDaskrMacroPsol(int* neq, double* t, double* y, double* ydot, double* savr, double* wk,
3049         double* cj, double* wght, double* wp, int* iwp, double* b, double* eplin,
3050         int* ier, double* rpar, int* ipar)
3051 {
3052     // macro : [b, ier] = psol(R, iR, b)
3053     char errorMsg[256];
3054     int one         = 1;
3055     int iRetCount   = 2;
3056
3057     typed_list in;
3058     typed_list out;
3059     types::optional_list opt;
3060     ast::ExecVisitor execFunc;
3061
3062     // input arguments psol(R, iR, b)
3063     types::Double* pDblR = new types::Double(1, *neq **neq);
3064     pDblR->set(wp);
3065     pDblR->IncreaseRef();
3066     in.push_back(pDblR);
3067
3068     types::Double* pDblIR = new types::Double(1, 2 * *neq **neq);
3069     double* pdblIR = pDblIR->get();
3070     for (int i = 0; i < pDblIR->getSize(); i++)
3071     {
3072         pdblIR[i] = (double)iwp[i];
3073     }
3074     pDblIR->IncreaseRef();
3075     in.push_back(pDblIR);
3076
3077     types::Double* pDblB = new types::Double(1, *neq);
3078     pDblB->set(b);
3079     pDblB->IncreaseRef();
3080     in.push_back(pDblB);
3081
3082     // optional arguments
3083     for (int i = 0; i < (int)m_pSolArgs.size(); i++)
3084     {
3085         in.push_back(m_pSolArgs[i]);
3086     }
3087
3088     // call macro
3089     bool bOk = m_pCallPsolFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
3090
3091     if (bOk == false)
3092     {
3093         sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallPsolFunction->getName().c_str());
3094         throw ast::ScilabError(errorMsg);
3095     }
3096
3097     // get output
3098     if (out.size() != iRetCount)
3099     {
3100         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3101         sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
3102         FREE(pstrName);
3103         throw ast::ScilabError(errorMsg);
3104     }
3105
3106     out[0]->IncreaseRef();
3107
3108     // free input arguments
3109     pDblR->DecreaseRef();
3110     if (pDblR->isDeletable())
3111     {
3112         delete pDblR;
3113     }
3114
3115     pDblIR->DecreaseRef();
3116     if (pDblIR->isDeletable())
3117     {
3118         delete pDblIR;
3119     }
3120
3121     pDblB->DecreaseRef();
3122     if (pDblB->isDeletable())
3123     {
3124         delete pDblB;
3125     }
3126
3127     // check output result
3128     if (out[0]->isDouble() == false)
3129     {
3130         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3131         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
3132         FREE(pstrName);
3133         throw ast::ScilabError(errorMsg);
3134     }
3135
3136     if (out[1]->isDouble() == false)
3137     {
3138         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3139         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 2);
3140         FREE(pstrName);
3141         throw ast::ScilabError(errorMsg);
3142     }
3143
3144     // return arguments [b, ier] = psol()
3145     types::Double* pDblOutB  = out[0]->getAs<types::Double>();
3146     if (pDblOutB->getSize() != *neq) // size of b is neq
3147     {
3148         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3149         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), pstrName, 1, *neq);
3150         FREE(pstrName);
3151         throw ast::ScilabError(errorMsg);
3152     }
3153
3154     // get scalar ier
3155     types::Double* pDblOutIer = out[1]->getAs<types::Double>();
3156     if (pDblOutIer->isScalar() == false)
3157     {
3158         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
3159         sprintf(errorMsg, _("%s: Wrong size for output argument #%d: A Scalar expected.\n"), pstrName, 2);
3160         FREE(pstrName);
3161         throw ast::ScilabError(errorMsg);
3162     }
3163
3164     // copy output macro results in output variables
3165     C2F(dcopy)(neq, pDblOutB->get(), &one, b, &one);
3166     *ier = (int)(pDblOutIer->get(0));
3167
3168     // free output arguments
3169     out[0]->DecreaseRef();
3170     if (out[0]->isDeletable())
3171     {
3172         delete out[0];
3173     }
3174
3175     out[1]->DecreaseRef();
3176     if (out[1]->isDeletable())
3177     {
3178         delete out[1];
3179     }
3180 }