the use of thread in optimisation, differential_equations and signal_processing removed
[scilab.git] / scilab / modules / signal_processing / src / cpp / signalprocessingfunctions.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2014 - Scilab Enterprises - Anais AUBERT
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
14 #include "execvisitor.hxx"
15 #include "double.hxx"
16 #include "signalprocessingfunctions.hxx"
17
18 extern "C"
19 {
20 #include "elem_common.h"
21 #include "Ex-corr.h"
22 #include "localization.h"
23 }
24
25 /*--------------------------------------------------------------------------*/
26
27 Signalprocessingfunctions* Signalprocessing::m_Signalprocessingfunctions;
28
29 void Signalprocessing::addSignalprocessingfunctions(Signalprocessingfunctions* _spFunction)
30 {
31     m_Signalprocessingfunctions = _spFunction;
32 }
33
34 void Signalprocessing::removeSignalprocessingfunctions()
35 {
36     m_Signalprocessingfunctions = NULL;
37 }
38
39 Signalprocessingfunctions* Signalprocessing::getSignalprocessingfunctions()
40 {
41     return m_Signalprocessingfunctions;
42 }
43
44 Signalprocessingfunctions::Signalprocessingfunctions(std::wstring callerName)
45 {
46
47     m_wstrCaller = callerName;
48
49     m_pCallDgetx = NULL;
50     m_pCallDgety = NULL;
51
52     m_pStringDgetxDyn = NULL;
53     m_pStringDgetyDyn = NULL;
54
55     m_pStringDgetxStatic = NULL;
56     m_pStringDgetyStatic = NULL;
57
58     // init static functions
59     if (callerName == L"corr")
60     {
61         m_staticFunctionMap[L"corexx"]   = (void*) C2F(corexx);
62         m_staticFunctionMap[L"corexy"]     = (void*) C2F(corexy);
63
64     }
65 }
66
67 void Signalprocessingfunctions::execFunctionDgetx(double* x, int* siz, int* iss)
68 {
69     char errorMsg[256];
70     if (m_pCallDgetx)
71     {
72         callDgetx(x, siz, iss);
73     }
74     else if (m_pStringDgetxDyn)
75     {
76         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringDgetxDyn->get(0));
77         if (func == NULL)
78         {
79             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringDgetxDyn->get(0));
80             throw ast::InternalError(errorMsg);
81         }
82         ((dgetx_f_t)(func->functionPtr))(x, siz, iss);
83     }
84     else if (m_pStringDgetxStatic)// function static
85     {
86         ((dgetx_f_t)m_staticFunctionMap[m_pStringDgetxStatic->get(0)])(x, siz, iss);
87     }
88     else
89     {
90         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "g");
91         throw ast::InternalError(errorMsg);
92     }
93 }
94
95 void Signalprocessingfunctions::setDgetx(types::Callable* _dgetx)
96 {
97     m_pCallDgetx = _dgetx;
98 }
99
100 void Signalprocessingfunctions::setDgetx(types::String* _dgetx)
101 {
102     m_pStringDgetxStatic = _dgetx;
103 }
104 void Signalprocessingfunctions::setDgety(types::Callable* _dgety)
105 {
106     m_pCallDgety = _dgety;
107 }
108 void Signalprocessingfunctions::setDgety(types::String* _dgety)
109 {
110     m_pStringDgetyStatic = _dgety;
111 }
112
113 //param for fortran call
114 void dgetx_f(double* x, int* siz, int* iss)
115 {
116     Signalprocessingfunctions* spFunction = NULL;
117     spFunction = Signalprocessing::getSignalprocessingfunctions();
118
119     if (spFunction == NULL)
120     {
121         throw ast::InternalError(_("An error occurred while getting Signalprocessingfunctions object.\n"));
122     }
123
124     spFunction->execFunctionDgetx(x, siz, iss);
125 }
126
127 void Signalprocessingfunctions::execFunctionDgety(double* y, int* siz, int* iss)
128 {
129     char errorMsg[256];
130     if (m_pCallDgety)
131     {
132         callDgety(y, siz, iss);
133
134     }
135     else if (m_pStringDgetxDyn)
136     {
137         ConfigVariable::EntryPointStr* func = ConfigVariable::getEntryPoint(m_pStringDgetyDyn->get(0));
138         if (func == NULL)
139         {
140             sprintf(errorMsg, _("Undefined fonction '%ls'.\n"), m_pStringDgetyDyn->get(0));
141             throw ast::InternalError(errorMsg);
142         }
143         ((dgety_f_t)(func->functionPtr))(y, siz, iss);
144     }
145     else if (m_pStringDgetyStatic)// function static
146     {
147         ((dgety_f_t)m_staticFunctionMap[m_pStringDgetyStatic->get(0)])(y, siz, iss);
148     }
149     else
150     {
151         sprintf(errorMsg, _("User function '%s' have not been setted.\n"), "g");
152         throw ast::InternalError(errorMsg);
153     }
154 }
155
156 //param for fortran call
157 void dgety_f(double* y, int* siz, int* iss)
158 {
159     Signalprocessingfunctions* spFunction = NULL;
160     spFunction = Signalprocessing::getSignalprocessingfunctions();
161
162     if (spFunction == NULL)
163     {
164         throw ast::InternalError(_("An error occurred while getting Signalprocessingfunctions object.\n"));
165     }
166
167     spFunction->execFunctionDgety(y, siz, iss);
168 }
169
170 void Signalprocessingfunctions::callDgety(double* y, int* siz, int* iss)
171 {
172     char errorMsg[256];
173     int one         = 1;
174     int iRetCount   = 1;
175
176     typed_list in;
177     typed_list out;
178     types::optional_list opt;
179     ast::ExecVisitor execFunc;
180
181     types::Double* pDblY    = new types::Double(*siz);
182
183     // create input args
184     types::Double* pDblT = new types::Double(*iss);
185     pDblT->IncreaseRef();
186     pDblY->IncreaseRef();
187
188     // push_back
189     in.push_back(pDblY);
190     in.push_back(pDblT);
191
192
193
194     for (int i = 0; i < (int)m_FArgs.size(); i++)
195     {
196         m_FArgs[i]->IncreaseRef();
197         in.push_back(m_FArgs[i]);
198     }
199
200     bool bOk = m_pCallDgety->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
201
202     for (int i = 0; i < (int)m_FArgs.size(); i++)
203     {
204         m_FArgs[i]->DecreaseRef();
205     }
206
207     if (bOk == false)
208     {
209         sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallDgety->getName().c_str());
210         throw ast::InternalError(errorMsg);
211     }
212
213     if (out.size() != iRetCount)
214     {
215         char* pstrName = wide_string_to_UTF8(m_pCallDgety->getName().c_str());
216         sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
217         FREE(pstrName);
218         throw ast::InternalError(errorMsg);
219     }
220
221     out[0]->IncreaseRef();
222
223     pDblT->DecreaseRef();
224     if (pDblT->isDeletable())
225     {
226         delete pDblT;
227     }
228
229
230     pDblY->DecreaseRef();
231     if (pDblY->isDeletable())
232     {
233         delete pDblY;
234     }
235
236
237     out[0]->DecreaseRef();
238
239     if (out[0]->isDouble() == false)
240     {
241         char* pstrName = wide_string_to_UTF8(m_pCallDgety->getName().c_str());
242         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
243         FREE(pstrName);
244         throw ast::InternalError(errorMsg);
245     }
246     types::Double* pDblOut = out[0]->getAs<types::Double>();
247     if (pDblOut->isComplex())
248     {
249         char* pstrName = wide_string_to_UTF8(m_pCallDgety->getName().c_str());
250         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
251         FREE(pstrName);
252         throw ast::InternalError(errorMsg);
253     }
254
255     C2F(dcopy)(siz, pDblOut->get(), &one, y, &one);
256
257
258     if (out[0]->isDeletable())
259     {
260         delete out[0];
261     }
262 }
263 //call external
264 void Signalprocessingfunctions::callDgetx(double* x, int* siz, int* iss)
265 {
266     char errorMsg[256];
267     int one         = 1;
268     int iRetCount   = 1;
269
270     typed_list in;
271     typed_list out;
272     types::optional_list opt;
273     ast::ExecVisitor execFunc;
274
275     types::Double* pDblX    = new types::Double(*siz);
276
277     // create input args
278     types::Double* pDblT = new types::Double(*iss);
279     pDblT->IncreaseRef();
280     pDblX->IncreaseRef();
281
282     // push_back
283     in.push_back(pDblX);
284     in.push_back(pDblT);
285
286
287
288     for (int i = 0; i < (int)m_FArgs.size(); i++)
289     {
290         m_FArgs[i]->IncreaseRef();
291         in.push_back(m_FArgs[i]);
292     }
293
294     bool bOk = m_pCallDgetx->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
295
296     for (int i = 0; i < (int)m_FArgs.size(); i++)
297     {
298         m_FArgs[i]->DecreaseRef();
299     }
300
301     if (bOk == false)
302     {
303         sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallDgetx->getName().c_str());
304         throw ast::InternalError(errorMsg);
305     }
306
307     if (out.size() != iRetCount)
308     {
309         char* pstrName = wide_string_to_UTF8(m_pCallDgetx->getName().c_str());
310         sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
311         FREE(pstrName);
312         throw ast::InternalError(errorMsg);
313     }
314
315     out[0]->IncreaseRef();
316
317     pDblT->DecreaseRef();
318     if (pDblT->isDeletable())
319     {
320         delete pDblT;
321     }
322
323
324     pDblX->DecreaseRef();
325     if (pDblX->isDeletable())
326     {
327         delete pDblX;
328     }
329
330
331     out[0]->DecreaseRef();
332
333     if (out[0]->isDouble() == false)
334     {
335         char* pstrName = wide_string_to_UTF8(m_pCallDgetx->getName().c_str());
336         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
337         FREE(pstrName);
338         throw ast::InternalError(errorMsg);
339     }
340     types::Double* pDblOut = out[0]->getAs<types::Double>();
341     if (pDblOut->isComplex())
342     {
343         char* pstrName = wide_string_to_UTF8(m_pCallDgetx->getName().c_str());
344         sprintf(errorMsg, _("%s: Wrong type for output argument #%d: Real matrix expected.\n"), pstrName, 1);
345         FREE(pstrName);
346         throw ast::InternalError(errorMsg);
347     }
348
349     C2F(dcopy)(siz, pDblOut->get(), &one, x, &one);
350
351
352     if (out[0]->isDeletable())
353     {
354         delete out[0];
355     }
356 }