1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4 *  Copyright (C) 2011-2011 - DIGITEO - Bruno JOFRET
5 *  Copyright (C) 2018 - Stéphane MOTTELET
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14 *
15 */
16 //for Visual Leak Detector in debug compilation mode
17 //#define DEBUG_VLD
18 #if defined(DEBUG_VLD) && defined(_DEBUG)
19 #include <vld.h>
20 #endif
21 
22 #include "elem_func_gw.hxx"
23 #include "function.hxx"
24 #include "context.hxx"
25 #include "overload.hxx"
26 #include "Scierror.h"
27 #include "localization.h"
28 #include "charEncoding.h"
29 #include "sparse.hxx"
30 #include "int.hxx"
31 #include "double.hxx"
32 #include "bool.hxx"
33 #include "string.hxx"
34 
35 #define MODULE_NAME L"elementary_functions"
36 extern "C"
37 {
38 #include "gw_elementary_functions.h"
39 }
40 
Load()41 int ElemFuncModule::Load()
42 {
43     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"abs", &sci_abs, MODULE_NAME));
44     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"acos", &sci_acos, MODULE_NAME));
45     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"asin", &sci_asin, MODULE_NAME));
46     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"atan", &sci_atan, MODULE_NAME));
47     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"bitstring", &sci_bitstring, MODULE_NAME));
48     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"ceil", &sci_ceil, MODULE_NAME));
49     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"clean", &sci_clean, MODULE_NAME));
50     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"conj", &sci_conj, MODULE_NAME));
51     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"cos", &sci_cos, MODULE_NAME));
52     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"cumprod", &sci_cumprod, MODULE_NAME));
53     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"cumsum", &sci_cumsum, MODULE_NAME));
54     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"diag", &sci_diag, MODULE_NAME));
55     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"dsearch", &sci_dsearch, MODULE_NAME));
56     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"exp", &sci_exp, MODULE_NAME));
57     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"expm", &sci_expm, MODULE_NAME));
58     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"eye", &sci_eye, MODULE_NAME));
59     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"floor", &sci_floor, MODULE_NAME));
60     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"frexp", &sci_frexp, MODULE_NAME));
61     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"gsort", &sci_gsort, MODULE_NAME));
62     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"imag", &sci_imag, MODULE_NAME));
63     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"imult", &sci_imult, MODULE_NAME));
64     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"int", &sci_int, MODULE_NAME));
65     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"isreal", &sci_isreal, MODULE_NAME));
66     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"isequal", &sci_isequal, MODULE_NAME));
67     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"isvector", &sci_isvector, MODULE_NAME));
68     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"kron", &sci_kron, MODULE_NAME));
69     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"linspace", &sci_linspace, MODULE_NAME));
70     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"log", &sci_log, MODULE_NAME));
71     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"log1p", &sci_log1p, MODULE_NAME));
72     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"matrix", &sci_matrix, MODULE_NAME));
73     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"max", &sci_max, MODULE_NAME));
74     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"min", &sci_min, MODULE_NAME));
75     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"nearfloat", &sci_nearfloat, MODULE_NAME));
76     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"number_properties", &sci_number_properties, MODULE_NAME));
77     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"ones", &sci_ones, MODULE_NAME));
78     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"prod", &sci_prod, MODULE_NAME));
79     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"permute", &sci_permute, MODULE_NAME));
80     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"rand", &sci_rand, MODULE_NAME));
81     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"real", &sci_real, MODULE_NAME));
82     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"round", &sci_round, MODULE_NAME));
83     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sign", &sci_sign, MODULE_NAME));
84     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sin", &sci_sin, MODULE_NAME));
85     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"size", &sci_size, MODULE_NAME));
86     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sqrt", &sci_sqrt, MODULE_NAME));
87     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sum", &sci_sum, MODULE_NAME));
88     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"tan", &sci_tan, MODULE_NAME));
89     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"testmatrix", &sci_testmatrix, MODULE_NAME));
90     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"tril", &sci_tril, MODULE_NAME));
91     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"triu", &sci_triu, MODULE_NAME));
92     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"zeros", &sci_zeros, MODULE_NAME));
93     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"rat", &sci_rat, MODULE_NAME));
94     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"base2dec", &sci_base2dec, MODULE_NAME));
95     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"dec2base", &sci_dec2base, MODULE_NAME));
96     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"log10", &sci_log10, MODULE_NAME));
97     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"cosh", &sci_cosh, MODULE_NAME));
98     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sinh", &sci_sinh, MODULE_NAME));
99     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"tanh", &sci_tanh, MODULE_NAME));
100     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"acosh", &sci_acosh, MODULE_NAME));
101     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"asinh", &sci_asinh, MODULE_NAME));
102     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"atanh", &sci_atanh, MODULE_NAME));
103     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"isvector", &sci_isvector, MODULE_NAME));
104     symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"issquare", &sci_issquare, MODULE_NAME));
105     return 1;
106 }
107 
108 
getDimsFromArguments(types::typed_list & in,const std::string & _pstName,int * _iDims,int ** _piDims,bool * _alloc)109 bool getDimsFromArguments(types::typed_list& in, const std::string& _pstName, int* _iDims, int** _piDims, bool* _alloc)
110 {
111     types::Double* pOut = 0;
112 
113     *_alloc = false;
114     *_iDims = 0;
115     *_piDims = NULL;
116 
117     if (in.size() == 0)
118     {
119         *_iDims = 2;
120         *_piDims = new int[*_iDims];
121         (*_piDims)[0] = 1;
122         (*_piDims)[1] = 1;
123         *_alloc = true;
124         return true;
125     }
126     else if (in.size() == 1)
127     {
128         *_iDims = 1;
129         // :
130         if (in[0]->isColon())
131         {
132             *_iDims = -1;
133             return false;
134         }
135 
136         if (in[0]->isArrayOf() == false)
137         {
138             if (in[0]->isSparse())
139             {
140                 types::Sparse* sp = in[0]->getAs<types::Sparse>();
141                 *_iDims = sp->getDims();
142                 *_piDims = sp->getDimsArray();
143                 return true;
144             }
145             else if (in[0]->isSparseBool())
146             {
147                 types::SparseBool* sp = in[0]->getAs<types::SparseBool>();
148                 *_iDims = sp->getDims();
149                 *_piDims = sp->getDimsArray();
150                 return true;
151             }
152             return false;
153         }
154 
155         types::GenericType* pIn = in[0]->getAs<types::GenericType>();
156         *_iDims = pIn->getDims();
157         *_piDims = pIn->getDimsArray();
158 
159         return true;
160     }
161     else
162     {
163         *_iDims = static_cast<int>(in.size());
164         *_piDims = new int[*_iDims];
165         *_alloc = true;
166         for (int i = 0; i < *_iDims; i++)
167         {
168             if (in[i]->isArrayOf() == false)
169             {
170                 Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), _pstName.c_str(), i + 1);
171                 delete[] * _piDims;
172                 return false;
173             }
174 
175             types::GenericType* pGTIn = in[i]->getAs<types::GenericType>();
176             if (pGTIn->isScalar() == false || pGTIn->isComplex())
177             {
178                 Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), _pstName.c_str(), i + 1);
179                 delete[] * _piDims;
180                 return false;
181             }
182 
183             switch (in[i]->getType())
184             {
185                 case types::InternalType::ScilabDouble:
186                 {
187                     double dValue = in[i]->getAs<types::Double>()->get(0);
188                     if (dValue >= INT_MAX)
189                     {
190                         Scierror(999, _("%s: variable size exceeded : less than %d expected.\n"), _pstName.c_str(), INT_MAX);
191                         delete[] * _piDims;
192                         return false;
193                     }
194                     (*_piDims)[i] = static_cast<int>(dValue);
195                 }
196                 break;
197                 case types::InternalType::ScilabInt8:
198                     (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::Int8>()->get()[0]);
199                     break;
200                 case types::InternalType::ScilabUInt8:
201                     (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::UInt8>()->get()[0]);
202                     break;
203                 case types::InternalType::ScilabInt16:
204                     (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::Int16>()->get()[0]);
205                     break;
206                 case types::InternalType::ScilabUInt16:
207                     (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::UInt16>()->get()[0]);
208                     break;
209                 case types::InternalType::ScilabInt32:
210                     (*_piDims)[i] = in[i]->getAs<types::Int32>()->get()[0];
211                     break;
212                 case types::InternalType::ScilabUInt32:
213                     (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::UInt32>()->get()[0]);
214                     break;
215                 case types::InternalType::ScilabInt64:
216                 {
217                     long long llValue = in[i]->getAs<types::Int64>()->get(0);
218                     if (llValue >= INT_MAX)
219                     {
220                         Scierror(999, _("%s: variable size exceeded : less than %d expected.\n"), _pstName.c_str(), INT_MAX);
221                         delete[] * _piDims;
222                         return false;
223                     }
224                     (*_piDims)[i] = static_cast<int>(llValue);
225                     break;
226                 }
227                 case types::InternalType::ScilabUInt64:
228                 {
229                     unsigned long long ullValue = in[i]->getAs<types::UInt64>()->get(0);
230                     if (ullValue >= INT_MAX)
231                     {
232                         Scierror(999, _("%s: variable size exceeded : less than %d expected.\n"), _pstName.c_str(), INT_MAX);
233                         delete[] * _piDims;
234                         return false;
235                     }
236                     (*_piDims)[i] = static_cast<int>(ullValue);
237                     break;
238                 }
239                 default:
240                     Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), _pstName.c_str(), i + 1);
241                     delete[] * _piDims;
242                     return false;
243             }
244         }
245 
246         return true;
247     }
248 
249     return false;
250 }
251 
trigo(types::Double * in,func_real func_r,func_complex func_c,bool forceComplex)252 types::Double* trigo(types::Double* in, func_real func_r, func_complex func_c, bool forceComplex)
253 {
254     bool isComplex = in->isComplex() || forceComplex;
255     types::Double* out = new types::Double(in->getDims(), in->getDimsArray(), isComplex);
256 
257     int size = in->getSize();
258     double* pInR = in->get();
259     double* pOutR = out->get();
260 
261     if (isComplex)
262     {
263         double* pInI = in->getImg();
264         double* pOutI = out->getImg();
265         std::complex<double> d;
266         for (int i = 0; i < size; ++i)
267         {
268             d.real(pInR[i]);
269             d.imag(pInI[i]);
270             std::complex<double> res = func_c(d);
271             pOutR[i] = res.real();
272             pOutI[i] = res.imag();
273         }
274     }
275     else
276     {
277         for (int i = 0; i < size; ++i)
278         {
279             pOutR[i] = func_r(pInR[i]);
280         }
281     }
282 
283     return out;
284 }
285 
zerosOrOnesFromValue(types::typed_list & in,int _iRetCount,types::typed_list & out,bool value)286 types::Function::ReturnValue zerosOrOnesFromValue(types::typed_list& in, int _iRetCount, types::typed_list& out, bool value)
287 {
288     int iDims = 0;
289     int* piDims = NULL;
290 
291     static std::map<std::wstring, types::InternalType::ScilabType> mapOfTypes = {
292         {L"double", types::InternalType::ScilabDouble},
293         {L"constant", types::InternalType::ScilabDouble},
294         {L"boolean", types::InternalType::ScilabBool},
295         {L"uint8", types::InternalType::ScilabUInt8},
296         {L"int8", types::InternalType::ScilabInt8},
297         {L"uint16", types::InternalType::ScilabUInt16},
298         {L"int16", types::InternalType::ScilabInt16},
299         {L"uint32", types::InternalType::ScilabUInt32},
300         {L"int32", types::InternalType::ScilabInt32},
301         {L"uint64", types::InternalType::ScilabUInt64},
302         {L"int64", types::InternalType::ScilabInt64}
303     };
304 
305     types::InternalType::ScilabType reftype = types::InternalType::ScilabDouble;
306     bool alloc = false;
307 
308     int size = (int)in.size();
309     if (size > 1 && in[size - 1]->isString())
310     {
311         types::InternalType* it = in[size - 1];
312 
313         // get optional type string
314         wchar_t* pType = it->getAs<types::String>()->get()[0];
315         auto f = mapOfTypes.find(pType);
316         if (f == mapOfTypes.end())
317         {
318             Scierror(999, _("%s: Wrong value for input argument #%d: Must be in the set {%s}"),
319                 value ? "ones" : "zeros", in.size(), "double, boolean, (u)int(8|16|32|64) ");
320             return types::Function::Error;
321         }
322 
323         reftype = f->second;
324         in.pop_back();
325     }
326 
327     bool ret = getDimsFromArguments(in, value ? "ones" : "zeros", &iDims, &piDims, &alloc);
328     if (ret == false)
329     {
330         switch (iDims)
331         {
332             case -1:
333                 Scierror(21, _("Invalid index.\n"));
334                 break;
335             case 1:
336             {
337                 //call overload
338                 return Overload::generateNameAndCall(value ? L"ones" : L"zeros", in, _iRetCount, out);
339             }
340         }
341 
342         return types::Function::Error;
343     }
344 
345     if (std::find(piDims, piDims+iDims, 0) != piDims+iDims)
346     {
347       // in Scilab, empty matrix is always a Double
348       reftype = types::InternalType::ScilabDouble;
349     }
350 
351     switch (reftype)
352     {
353         case types::InternalType::ScilabInt8:
354         {
355             types::Int8* pOut = new types::Int8(iDims, piDims);
356             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
357             out.push_back(pOut);
358             break;
359         }
360         case types::InternalType::ScilabInt16:
361         {
362             types::Int16* pOut = new types::Int16(iDims, piDims);
363             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
364             out.push_back(pOut);
365             break;
366         }
367         case types::InternalType::ScilabInt32:
368         {
369             types::Int32* pOut = new types::Int32(iDims, piDims);
370             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
371             out.push_back(pOut);
372             break;
373         }
374         case types::InternalType::ScilabInt64:
375         {
376             types::Int64* pOut = new types::Int64(iDims, piDims);
377             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
378             out.push_back(pOut);
379             break;
380         }
381         case types::InternalType::ScilabUInt8:
382         {
383             types::UInt8* pOut = new types::UInt8(iDims, piDims);
384             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
385             out.push_back(pOut);
386             break;
387         }
388         case types::InternalType::ScilabUInt16:
389         {
390             types::UInt16* pOut = new types::UInt16(iDims, piDims);
391             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
392             out.push_back(pOut);
393             break;
394         }
395         case types::InternalType::ScilabUInt32:
396         {
397             types::UInt32* pOut = new types::UInt32(iDims, piDims);
398             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
399             out.push_back(pOut);
400             break;
401         }
402         case types::InternalType::ScilabUInt64:
403         {
404             types::UInt64* pOut = new types::UInt64(iDims, piDims);
405             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
406             out.push_back(pOut);
407             break;
408         }
409         case types::InternalType::ScilabBool:
410         {
411             types::Bool* pOut = new types::Bool(iDims, piDims);
412             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
413             out.push_back(pOut);
414             break;
415         }
416         default: // other cases: create double with inherited dimensions only (not type)
417         case types::InternalType::ScilabDouble:
418         {
419             types::Double* pOut = new types::Double(iDims, piDims);
420             std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
421             out.push_back(pOut);
422             break;
423         }
424     }
425 
426     if (alloc)
427     {
428         delete[] piDims;
429     }
430 
431     return types::Function::OK;
432 }
433