ast: fix memleaks detected by ASAN during testing
[scilab.git] / scilab / modules / elementary_functions / sci_gateway / cpp / sci_linspace.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2018- St├ęphane MOTTELET
4  *
5  * This file is hereby licensed under the terms of the GNU GPL v2.0,
6  * For more information, see the COPYING file which you should have received
7  * along with this program.
8  *
9  */
10
11 #include "double.hxx"
12 #include "function.hxx"
13 #include "int.hxx"
14 #include "overload.hxx"
15
16 extern "C"
17 {
18 #include "Scierror.h"
19 #include "localization.h"
20 }
21
22 template<typename T>
23 int convertTypeToInt32(T* pVal)
24 {
25     typename T::type TVal = pVal->get(0);
26     if (TVal >= INT_MAX)
27     {
28         return INT_MAX;
29     }
30     else
31     {
32         return TVal < 0 ? 0 :  (static_cast<int> (TVal));
33     }
34 }
35
36 int convertToSize(types::InternalType *pIT);
37
38 bool fillRange(double* pdblOut, double* pdblMin, double* pdblMax, int iRows, int iCols);
39
40 /* ==================================================================== */
41 types::Function::ReturnValue sci_linspace(types::typed_list &in, int _iRetCount, types::typed_list &out)
42 {
43     int iCols = 100;
44     types::Double* pDblOut;
45
46     if (in.size() != 2 & in.size() != 3)
47     {
48         Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "linspace", 2, 3);
49         return types::Function::Error;
50     }
51
52     if (_iRetCount > 1)
53     {
54         Scierror(78, _("%s: Wrong number of output argument(s): %d expected."), "linspace", 1);
55         return types::Function::Error;
56     }
57
58     types::Double* pDbl[2];
59     for (int i = 0; i < 2; i++)
60     {
61         if (in[i]->isDouble())
62         {
63             pDbl[i] = in[i]->getAs<types::Double>();
64         }
65         else
66         {
67             // other types -> overload
68             std::wstring wstFuncName = L"%" + in[i]->getShortTypeStr() + L"_linspace";
69             return Overload::call(wstFuncName, in, _iRetCount, out);
70         }
71     }
72
73     // Check dimensions are the same
74     int  iDims0  = pDbl[0]->getDims();
75     int* piDims0 = pDbl[0]->getDimsArray();
76     int  iDims1  = pDbl[1]->getDims();
77     int* piDims1 = pDbl[1]->getDimsArray();
78     if (iDims0 != iDims1)
79     {
80         Scierror(999, _("%s: Arguments %d and %d must have same dimensions.\n"), "linspace", 1, 2);
81         return types::Function::Error;
82     }
83     for (int i = 0; i < iDims0; i++)
84     {
85         if (piDims0[i] != piDims1[i])
86         {
87             Scierror(999, _("%s: Arguments %d and %d must have same dimensions.\n"), "linspace", 1, 2);
88             return types::Function::Error;
89         }
90     }
91
92     if (in.size() == 3)
93     {
94         if (in[2]->isGenericType() && in[2]->getAs<types::GenericType>()->isScalar() &&
95             (in[2]->isInt() || (in[2]->isDouble() && in[2]->getAs<types::Double>()->isComplex() == false) ))
96         {
97             if (in[2]->isDouble())
98             {
99                 double dblCols = in[2]->getAs<types::Double>()->get(0);
100                 if (std::floor(dblCols) != dblCols)
101                 {
102                     Scierror(999, _("%s: Argument #%d: An integer value expected.\n"), "linspace",3);
103                     return types::Function::Error;
104                 }
105             }
106             iCols = convertToSize(in[2]);
107         }
108         else
109         {
110             Scierror(999, _("%s: Argument #%d: An integer value expected.\n"), "linspace", 3);
111             return types::Function::Error;
112         }
113     }
114
115     if (iCols == INT_MAX)
116     {
117          Scierror(999, _("%s: Wrong values for input argument #%d: Must be less than %d.\n"),"linspace",3,INT_MAX);
118          return types::Function::Error;
119     }
120
121     if (iCols == 0 || (pDbl[0]->getSize() == 0))
122     {
123         // empty matrix case
124         out.push_back(types::Double::Empty());
125         return types::Function::OK;
126     }
127
128     // generation is done by considering array as a column vector
129     int iRows =  pDbl[0]->getSize();
130     // pDblOut is resized later
131     pDblOut = new types::Double(iRows, iCols);
132
133     if (!fillRange(pDblOut->get(), pDbl[0]->get(), pDbl[1]->get(), iRows, iCols))
134     {
135         // if Infs or NaNs
136         pDblOut->killMe();
137         return types::Function::Error;
138     }
139
140     if (pDbl[0]->isComplex() || pDbl[1]->isComplex())
141     {
142         int iReal;
143         for (iReal = 0; iReal < 2; iReal++)
144         {
145             if (!pDbl[iReal]->isComplex())
146             {
147                 pDbl[iReal] = pDbl[iReal]->clone();
148                 pDbl[iReal]->setComplex(true);
149                 break;
150             }
151         }
152         // Complexify pDblOut
153         pDblOut->setComplex(true);
154         bool status = fillRange(pDblOut->getImg(), pDbl[0]->getImg(), pDbl[1]->getImg(), iRows, iCols);
155         if (iReal < 2)
156         {
157             pDbl[iReal]->killMe();
158         }
159         if (status != true) // if Infs or NaNs
160         {
161             pDblOut->killMe();
162             return types::Function::Error;
163         }
164     }
165
166     int *piNewDims = new int[iDims0 + 1];
167     // keep the first dimension unchanged
168     piNewDims[0] = piDims0[0];
169     int iDim = 1;
170     for (int i = 1; i < iDims0; i++)
171     {
172         // squeeze subsequent single dimensions
173         if (piDims0[i] > 1)
174         {
175             piNewDims[iDim++] = piDims0[i];
176         }
177     }
178     // add the suplementary dimension
179     piNewDims[iDim++] = iCols;
180     // reshape the matrix:
181     pDblOut->reshape(piNewDims, iDim);
182     out.push_back(pDblOut);
183
184     delete[] piNewDims;
185     return types::Function::OK;
186 }
187
188 bool fillRange(double* pdblOut, double* pdblMin, double* pdblMax, int iRows, int iCols)
189 {
190     double* step = new double[iRows];
191     for (int j = 0, k = (iCols - 1) * iRows; j < iRows; j++)
192     {
193         step[j] = (pdblMax[j] - pdblMin[j]) / (iCols - 1);
194         // checking Infs and NaNs
195         int indInfOrNan = std::isinf(pdblMin[j]) || std::isnan(pdblMin[j]) ? 1 : 0;
196         indInfOrNan = indInfOrNan == 0 ? (std::isinf(pdblMax[j]) || std::isnan(pdblMax[j]) ? 2 : 0) : indInfOrNan;
197         if (indInfOrNan > 0)
198         {
199             delete[] step;
200             Scierror(999, _("%s: Argument #%d: %%nan and %%inf values are forbidden.\n"), "linspace", indInfOrNan);
201             return false;
202         }
203         // last column is enforced (http://bugzilla.scilab.org/10966)
204         pdblOut[k++] = pdblMax[j];
205     }
206     // doing the linear range generation
207     for (int i = 0; i < iCols - 1; i++)
208     {
209         for (int j = 0; j < iRows; j++)
210         {
211             *(pdblOut++) = pdblMin[j] + i * step[j];
212         }
213     }
214     delete[] step;
215
216     return true;
217 }
218
219 int convertToSize(types::InternalType *pIT)
220 {
221     switch (pIT->getType())
222     {
223         case types::InternalType::ScilabDouble:
224         {
225             return convertTypeToInt32(pIT->getAs<types::Double>());
226         }
227         case types::InternalType::ScilabInt8:
228         {
229             return convertTypeToInt32(pIT->getAs<types::Int8>());
230         }
231         case types::InternalType::ScilabInt16:
232         {
233             return convertTypeToInt32(pIT->getAs<types::Int16>());
234         }
235         case types::InternalType::ScilabInt32:
236         {
237             return convertTypeToInt32(pIT->getAs<types::Int32>());
238         }
239         case types::InternalType::ScilabInt64:
240         {
241             return convertTypeToInt32(pIT->getAs<types::Int64>());
242         }
243         case types::InternalType::ScilabUInt8:
244         {
245             return convertTypeToInt32(pIT->getAs<types::UInt8>());
246         }
247         case types::InternalType::ScilabUInt16:
248         {
249             return convertTypeToInt32(pIT->getAs<types::UInt16>());
250         }
251         case types::InternalType::ScilabUInt32:
252         {
253             return convertTypeToInt32(pIT->getAs<types::UInt32>());
254         }
255         case types::InternalType::ScilabUInt64:
256         {
257             return convertTypeToInt32(pIT->getAs<types::UInt64>());
258         }
259     }
260 }
261