Merge remote-tracking branch 'origin/master' into windows
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_poly.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  * Please note that piece of code will be rewrited for the Scilab 6 family
15  * However, the API (profile of the functions in the header files) will be
16  * still available and supported in Scilab 6.
17  */
18
19 #include "gatewaystruct.hxx"
20 #include "polynom.hxx"
21 #include "context.hxx"
22
23 extern "C"
24 {
25 #include <string.h>
26 #include <stdlib.h>
27 #include "machine.h"
28 #include "call_scilab.h"
29 #include "api_scilab.h"
30 #include "api_internal_poly.h"
31 #include "api_internal_common.h"
32 #include "localization.h"
33 #include "sci_malloc.h"
34 #include "charEncoding.h"
35 }
36
37 static int getCommonAllocatedSinglePoly(void* _pvCtx, int* _piAddress, int _iComplex, int* _piNbCoef, double** _pdblReal, double** _pdblImg);
38 static int getCommonAllocatedNamedSinglePoly(void* _pvCtx, const char* _pstName, int _iComplex, int* _piNbCoef, double** _pdblReal, double** _pdblImg);
39 static int getCommonAllocatedMatrixOfPoly(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int** _piNbCoef, double*** _pdblReal, double*** _pdblImg);
40 static int getCommonAllocatedNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int** _piNbCoef, double*** _pdblReal, double*** _pdblImg);
41
42
43 SciErr getPolyVariableName(void* _pvCtx, int* _piAddress, char* _pstVarName, int* _piVarNameLen)
44 {
45     SciErr sciErr = sciErrInit();
46
47     if (_piAddress == NULL)
48     {
49         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getPolyVariableName");
50         return sciErr;
51     }
52
53     if (!((types::InternalType*)_piAddress)->isPoly())
54     {
55         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getPolyVariableName", _("polynomial matrix"));
56         return sciErr;
57     }
58
59     if (*_piVarNameLen == 0)
60     {
61         *_piVarNameLen = (int)((types::InternalType*)_piAddress)->getAs<types::Polynom>()->getVariableName().size();
62         //No error
63     }
64
65     if (_pstVarName == NULL)
66     {
67         return sciErr;
68     }
69
70     strcpy(_pstVarName, ((types::InternalType*)_piAddress)->getAs<types::Polynom>()->getVariableName().c_str());
71     *_piVarNameLen = static_cast<int>(strlen(_pstVarName));
72     return sciErr;
73 }
74
75 SciErr getMatrixOfPoly(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal)
76 {
77     return getCommonMatrixOfPoly(_pvCtx, _piAddress, 0, _piRows, _piCols, _piNbCoef, _pdblReal, NULL);
78 }
79
80 SciErr getComplexMatrixOfPoly(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
81 {
82     return getCommonMatrixOfPoly(_pvCtx, _piAddress, 1, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
83 }
84
85 SciErr getCommonMatrixOfPoly(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
86 {
87     SciErr sciErr = sciErrInit();
88     int iType = 0;
89     int iSize = 0;
90     int *piOffset = NULL;
91     double *pdblReal = NULL;
92     double *pdblImg = NULL;
93
94     if (_piAddress == NULL)
95     {
96         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly");
97         return sciErr;
98     }
99
100     sciErr = getVarType(_pvCtx, _piAddress, &iType);
101     if (sciErr.iErr)
102     {
103         addErrorMessage(&sciErr, API_ERROR_GET_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", getRhsFromAddress(_pvCtx, _piAddress));
104         return sciErr;
105     }
106
107     if (iType != sci_poly)
108     {
109         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", _("polynomial matrix"));
110         return sciErr;
111     }
112
113     if (isVarComplex(_pvCtx, _piAddress) != _iComplex)
114     {
115         addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly");
116         return sciErr;
117     }
118
119     sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
120     if (sciErr.iErr)
121     {
122         addErrorMessage(&sciErr, API_ERROR_GET_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", getRhsFromAddress(_pvCtx, _piAddress));
123         return sciErr;
124     }
125
126     iSize       = *_piRows **_piCols;
127
128     if (_piNbCoef == NULL)
129     {
130         return sciErr;
131     }
132
133     types::Polynom *pMP = ((types::InternalType*)_piAddress)->getAs<types::Polynom>();
134     pMP->getSizes(_piNbCoef);
135
136     if (_pdblReal == NULL)
137     {
138         return sciErr;
139     }
140
141     types::SinglePoly** pSP = pMP->get();
142     if (_iComplex == 1)
143     {
144         for (int i = 0 ; i < iSize ; i++)
145         {
146             memcpy(_pdblReal[i], pSP[i]->get(),    sizeof(double) * pSP[i]->getSize());
147             memcpy(_pdblImg[i],  pSP[i]->getImg(), sizeof(double) * _piNbCoef[i]);
148         }
149     }
150     else
151     {
152         for (int i = 0 ; i < iSize ; i++)
153         {
154             memcpy(_pdblReal[i], pSP[i]->get(), sizeof(double) * pSP[i]->getSize());
155         }
156     }
157
158     return sciErr;
159 }
160
161 SciErr createMatrixOfPoly(void* _pvCtx, int _iVar, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal)
162 {
163     return createCommonMatrixOfPoly(_pvCtx, _iVar, 0, _pstVarName, _iRows, _iCols, _piNbCoef, _pdblReal, NULL);
164 }
165
166 SciErr createComplexMatrixOfPoly(void* _pvCtx, int _iVar, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
167 {
168     return createCommonMatrixOfPoly(_pvCtx, _iVar, 1, _pstVarName, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
169 }
170
171 SciErr createCommonMatrixOfPoly(void* _pvCtx, int _iVar, int _iComplex, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
172 {
173     SciErr sciErr = sciErrInit();
174     if (_pvCtx == NULL)
175     {
176         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "createComplexMatrixOfPoly" : "createMatrixOfPoly");
177         return sciErr;
178     }
179
180     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
181     types::InternalType** out = pStr->m_pOut;
182     int rhs = _iVar - *getNbInputArgument(_pvCtx);
183
184     //return empty matrix
185     if (_iRows == 0 && _iCols == 0)
186     {
187         types::Double *pDbl = new types::Double(_iRows, _iCols);
188         if (pDbl == NULL)
189         {
190             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
191             return sciErr;
192         }
193
194         out[rhs - 1] = pDbl;
195         return sciErr;
196     }
197
198     types::Polynom* pP = new types::Polynom(_pstVarName, _iRows, _iCols, _piNbCoef);
199     if (pP == NULL)
200     {
201         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), _iComplex ? "createComplexMatrixOfPoly" : "createMatrixOfPoly");
202         return sciErr;
203     }
204
205     if (_iComplex)
206     {
207         pP->setComplex(true);
208     }
209
210     out[rhs - 1] = pP;
211
212     for (int i = 0 ; i < pP->getSize() ; i++)
213     {
214         types::Double* pD = new types::Double(_piNbCoef[i], 1, _iComplex == 1);
215         pD->set(_pdblReal[i]);
216         if (_iComplex)
217         {
218             pD->setImg(_pdblImg[i]);
219         }
220         pP->setCoef(i, pD);
221         delete pD;
222     }
223
224     return sciErr;
225 }
226
227 SciErr createNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal)
228 {
229     return createCommonNamedMatrixOfPoly(_pvCtx, _pstName, _pstVarName, 0, _iRows, _iCols, _piNbCoef, _pdblReal, NULL);
230 }
231
232 SciErr createNamedComplexMatrixOfPoly(void* _pvCtx, const char* _pstName, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
233 {
234     return createCommonNamedMatrixOfPoly(_pvCtx, _pstName, _pstVarName, 1, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
235 }
236
237 SciErr createCommonNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, char* _pstVarName, int _iComplex, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
238 {
239     SciErr sciErr = sciErrInit();
240
241     // check variable name
242     if (checkNamedVarFormat(_pvCtx, _pstName) == 0)
243     {
244         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Invalid variable name: %s."), "createCommonNamedMatrixOfPoly", _pstName);
245         return sciErr;
246     }
247
248     //return empty matrix
249     if (_iRows == 0 && _iCols == 0)
250     {
251         if (createNamedEmptyMatrix(_pvCtx, _pstName))
252         {
253             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
254             return sciErr;
255         }
256
257         return sciErr;
258     }
259
260     types::Polynom* pP = new types::Polynom(_pstVarName, _iRows, _iCols, _piNbCoef);
261     if (pP == NULL)
262     {
263         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommonNamedMatrixOfPoly", _pstName);
264         return sciErr;
265     }
266
267     if (_iComplex)
268     {
269         pP->setComplex(true);
270     }
271
272     for (int i = 0 ; i < pP->getSize() ; i++)
273     {
274         types::Double* pD = new types::Double(_piNbCoef[i], 1, _iComplex == 1);
275         pD->set(_pdblReal[i]);
276         if (_iComplex)
277         {
278             pD->setImg(_pdblImg[i]);
279         }
280         pP->setCoef(i, pD);
281         delete pD;
282     }
283
284     symbol::Context* ctx = symbol::Context::getInstance();
285     symbol::Symbol sym = symbol::Symbol(_pstName);
286     if (ctx->isprotected(sym) == false)
287     {
288         ctx->put(sym, pP);
289     }
290     else
291     {
292         delete pP;
293         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
294     }
295     return sciErr;
296 }
297
298 SciErr readNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal)
299 {
300     return readCommonNamedMatrixOfPoly(_pvCtx, _pstName, 0, _piRows, _piCols, _piNbCoef, _pdblReal, NULL);
301 }
302
303 SciErr readNamedComplexMatrixOfPoly(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
304 {
305     return readCommonNamedMatrixOfPoly(_pvCtx, _pstName, 1, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
306 }
307
308 SciErr readCommonNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
309 {
310     int* piAddr = NULL;
311
312     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
313     if (sciErr.iErr)
314     {
315         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_POLY, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfPoly" : "readNamedMatrixOfPoly", _pstName);
316         return sciErr;
317     }
318
319     if (_iComplex == 1)
320     {
321         sciErr = getComplexMatrixOfPoly(_pvCtx, piAddr, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
322     }
323     else
324     {
325         sciErr = getMatrixOfPoly(_pvCtx, piAddr, _piRows, _piCols, _piNbCoef, _pdblReal);
326     }
327
328     if (sciErr.iErr)
329     {
330         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_POLY, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfPoly" : "readNamedMatrixOfPoly", _pstName);
331         return sciErr;
332     }
333
334     return sciErr;
335 }
336
337 /*shortcut functions */
338
339 /*--------------------------------------------------------------------------*/
340 int isPolyType(void* _pvCtx, int* _piAddress)
341 {
342     return checkVarType(_pvCtx, _piAddress, sci_poly);
343 }
344 /*--------------------------------------------------------------------------*/
345 int isNamedPolyType(void* _pvCtx, const char* _pstName)
346 {
347     return checkNamedVarType(_pvCtx, _pstName, sci_poly);
348 }
349 /*--------------------------------------------------------------------------*/
350 int getAllocatedSinglePoly(void* _pvCtx, int* _piAddress, int* _piNbCoef, double** _pdblReal)
351 {
352     return getCommonAllocatedSinglePoly(_pvCtx, _piAddress, 0, _piNbCoef, _pdblReal, NULL);
353 }
354 /*--------------------------------------------------------------------------*/
355 int getAllocatedSingleComplexPoly(void* _pvCtx, int* _piAddress, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
356 {
357     return getCommonAllocatedSinglePoly(_pvCtx, _piAddress, 1, _piNbCoef, _pdblReal, _pdblImg);
358 }
359 /*--------------------------------------------------------------------------*/
360 static int getCommonAllocatedSinglePoly(void* _pvCtx, int* _piAddress, int _iComplex, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
361 {
362     SciErr sciErr = sciErrInit();
363     int iRows   = 0;
364     int iCols   = 0;
365
366     double* pdblReal = NULL;
367     double* pdblImg      = NULL;
368
369     if (isScalar(_pvCtx, _piAddress) == 0)
370     {
371         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_POLY, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), _iComplex ? "getAllocatedSingleComplexPoly" : "getAllocatedSinglePoly", getRhsFromAddress(_pvCtx, _piAddress));
372         printError(&sciErr, 0);
373         return sciErr.iErr;
374     }
375
376     sciErr = getCommonMatrixOfPoly(_pvCtx, _piAddress, _iComplex, &iRows, &iCols, _piNbCoef, NULL, NULL);
377     if (sciErr.iErr)
378     {
379         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getAllocatedSingleComplexPoly" : "getAllocatedSinglePoly", getRhsFromAddress(_pvCtx, _piAddress));
380         printError(&sciErr, 0);
381         return sciErr.iErr;
382     }
383
384     *_pdblReal = (double*)MALLOC(sizeof(double) **_piNbCoef);
385
386     if (_iComplex)
387     {
388         *_pdblImg       = (double*)MALLOC(sizeof(double) **_piNbCoef);
389     }
390
391     sciErr = getCommonMatrixOfPoly(_pvCtx, _piAddress, _iComplex, &iRows, &iCols, _piNbCoef, _pdblReal, _pdblImg);
392     if (sciErr.iErr)
393     {
394         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getAllocatedSingleComplexPoly" : "getAllocatedSinglePoly", getRhsFromAddress(_pvCtx, _piAddress));
395         printError(&sciErr, 0);
396         return sciErr.iErr;
397     }
398
399     return 0;
400 }
401 /*--------------------------------------------------------------------------*/
402 int getAllocatedNamedSinglePoly(void* _pvCtx, const char* _pstName, int* _piNbCoef, double** _pdblReal)
403 {
404     return getCommonAllocatedNamedSinglePoly(_pvCtx, _pstName, 0, _piNbCoef, _pdblReal, NULL);
405 }
406 /*--------------------------------------------------------------------------*/
407 int getAllocatedNamedSingleComplexPoly(void* _pvCtx, const char* _pstName, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
408 {
409     return getCommonAllocatedNamedSinglePoly(_pvCtx, _pstName, 1, _piNbCoef, _pdblReal, _pdblImg);
410 }
411 /*--------------------------------------------------------------------------*/
412 static int getCommonAllocatedNamedSinglePoly(void* _pvCtx, const char* _pstName, int _iComplex, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
413 {
414     SciErr sciErr = sciErrInit();
415     int iRows   = 0;
416     int iCols   = 0;
417
418     double* pdblReal = NULL;
419     double* pdblImg      = NULL;
420
421     if (isNamedScalar(_pvCtx, _pstName) == 0)
422     {
423         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_POLY, _("%s: Wrong type for input argument \"%s\": A scalar expected.\n"), _iComplex ? "getAllocatedNamedSingleComplexPoly" : "getAllocatedNamedSinglePoly", _pstName);
424         printError(&sciErr, 0);
425         return sciErr.iErr;
426     }
427
428     sciErr = readCommonNamedMatrixOfPoly(_pvCtx, _pstName, _iComplex, &iRows, &iCols, _piNbCoef, &pdblReal, &pdblImg);
429     if (sciErr.iErr)
430     {
431         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_POLY, _("%s: Unable to get argument \"%s\""), _iComplex ? "getAllocatedNamedSingleComplexPoly" : "getAllocatedNamedSinglePoly", _pstName);
432         printError(&sciErr, 0);
433         return sciErr.iErr;
434     }
435
436     *_pdblReal = (double*)MALLOC(sizeof(double) **_piNbCoef);
437     memcpy(*_pdblReal, pdblReal, sizeof(double) **_piNbCoef);
438
439     if (_iComplex)
440     {
441         *_pdblImg       = (double*)MALLOC(sizeof(double) **_piNbCoef);
442         memcpy(*_pdblImg, pdblImg, sizeof(double) **_piNbCoef);
443     }
444     return 0;
445 }
446 /*--------------------------------------------------------------------------*/
447 int getAllocatedMatrixOfPoly(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piNbCoef, double*** _pdblReal)
448 {
449     return getCommonAllocatedMatrixOfPoly(_pvCtx, _piAddress, 0, _piRows, _piCols, _piNbCoef, _pdblReal, NULL);
450 }
451 /*--------------------------------------------------------------------------*/
452 int getAllocatedMatrixOfComplexPoly(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piNbCoef, double*** _pdblReal, double*** _pdblImg)
453 {
454     return getCommonAllocatedMatrixOfPoly(_pvCtx, _piAddress, 1, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
455 }
456 /*--------------------------------------------------------------------------*/
457 static int getCommonAllocatedMatrixOfPoly(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int** _piNbCoef, double*** _pdblReal, double*** _pdblImg)
458 {
459     SciErr sciErr = sciErrInit();
460     double* pdblReal    = NULL;
461     double* pdblImg             = NULL;
462
463     sciErr = getCommonMatrixOfPoly(_pvCtx, _piAddress, _iComplex, _piRows, _piCols, NULL, NULL, NULL);
464     if (sciErr.iErr)
465     {
466         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_MATRIX_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getAllocatedMatrixOfComplexPoly" : "getAllocatedMatrixOfPoly", getRhsFromAddress(_pvCtx, _piAddress));
467         printError(&sciErr, 0);
468         return sciErr.iErr;
469     }
470
471     *_piNbCoef = (int*)MALLOC(sizeof(int) **_piRows **_piCols);
472
473     sciErr = getCommonMatrixOfPoly(_pvCtx, _piAddress, _iComplex, _piRows, _piCols, *_piNbCoef, NULL, NULL);
474     if (sciErr.iErr)
475     {
476         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_MATRIX_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getAllocatedMatrixOfComplexPoly" : "getAllocatedMatrixOfPoly", getRhsFromAddress(_pvCtx, _piAddress));
477         printError(&sciErr, 0);
478         return sciErr.iErr;
479     }
480
481     *_pdblReal = (double**)MALLOC(sizeof(double*) **_piRows **_piCols);
482     for (int i = 0 ; i < *_piRows **_piCols ; i++)
483     {
484         (*_pdblReal)[i] = (double*)MALLOC(sizeof(double) * (*_piNbCoef)[i]);
485     }
486
487     if (_iComplex)
488     {
489         *_pdblImg       = (double**)MALLOC(sizeof(double*) **_piRows **_piCols);
490         for (int i = 0 ; i < *_piRows **_piCols ; i++)
491         {
492             (*_pdblImg)[i] = (double*)MALLOC(sizeof(double) * (*_piNbCoef)[i]);
493         }
494     }
495
496     sciErr = getCommonMatrixOfPoly(_pvCtx, _piAddress, _iComplex, _piRows, _piCols, *_piNbCoef, *_pdblReal, _pdblImg == NULL ? NULL : *_pdblImg);
497     if (sciErr.iErr)
498     {
499         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_MATRIX_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getAllocatedSingleComplexPoly" : "getAllocatedSinglePoly", getRhsFromAddress(_pvCtx, _piAddress));
500         printError(&sciErr, 0);
501         return sciErr.iErr;
502     }
503
504     return 0;
505 }
506 /*--------------------------------------------------------------------------*/
507 int getAllocatedNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int** _piNbCoef, double*** _pdblReal)
508 {
509     return getCommonAllocatedNamedMatrixOfPoly(_pvCtx, _pstName, 0, _piRows, _piCols, _piNbCoef, _pdblReal, NULL);
510 }
511 /*--------------------------------------------------------------------------*/
512 int getAllocatedNamedMatrixOfComplexPoly(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int** _piNbCoef, double*** _pdblReal, double*** _pdblImg)
513 {
514     return getCommonAllocatedNamedMatrixOfPoly(_pvCtx, _pstName, 1, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
515 }
516 /*--------------------------------------------------------------------------*/
517 static int getCommonAllocatedNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int** _piNbCoef, double*** _pdblReal, double*** _pdblImg)
518 {
519     SciErr sciErr = readCommonNamedMatrixOfPoly(_pvCtx, _pstName, _iComplex, _piRows, _piCols, NULL, NULL, NULL);
520     if (sciErr.iErr)
521     {
522         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_MATRIX_POLY, _("%s: Unable to get argument \"%s\""), _iComplex ? "getAllocatedNamedMatrixOfComplexPoly" : "getAllocatedNamedMatrixOfPoly", _pstName);
523         printError(&sciErr, 0);
524         return sciErr.iErr;
525     }
526
527     *_piNbCoef = (int*)MALLOC(sizeof(int) **_piRows **_piCols);
528
529     sciErr = readCommonNamedMatrixOfPoly(_pvCtx, _pstName, _iComplex, _piRows, _piCols, *_piNbCoef, NULL, NULL);
530     if (sciErr.iErr)
531     {
532         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_MATRIX_POLY, _("%s: Unable to get argument \"%s\""), _iComplex ? "getAllocatedNamedMatrixOfComplexPoly" : "getAllocatedNamedMatrixOfPoly", _pstName);
533         printError(&sciErr, 0);
534         return sciErr.iErr;
535     }
536
537     *_pdblReal = (double**)MALLOC(sizeof(double*) **_piRows **_piCols);
538     for (int i = 0 ; i < *_piRows **_piCols ; i++)
539     {
540         (*_pdblReal)[i] = (double*)MALLOC(sizeof(double) * (*_piNbCoef)[i]);
541     }
542
543     if (_iComplex)
544     {
545         *_pdblImg       = (double**)MALLOC(sizeof(double*) **_piRows **_piCols);
546         for (int i = 0 ; i < *_piRows **_piCols ; i++)
547         {
548             (*_pdblImg)[i] = (double*)MALLOC(sizeof(double) * (*_piNbCoef)[i]);
549         }
550     }
551
552     sciErr = readCommonNamedMatrixOfPoly(_pvCtx, _pstName, _iComplex, _piRows, _piCols, *_piNbCoef, *_pdblReal, _pdblImg == NULL ? NULL : *_pdblImg);
553     if (sciErr.iErr)
554     {
555         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_MATRIX_POLY, _("%s: Unable to get argument \"%s\""), _iComplex ? "getAllocatedNamedMatrixOfComplexPoly" : "getAllocatedNamedMatrixOfPoly", _pstName);
556         printError(&sciErr, 0);
557         return sciErr.iErr;
558     }
559
560     return 0;
561 }
562 /*--------------------------------------------------------------------------*/
563 void freeAllocatedSinglePoly(double* _pdblReal)
564 {
565     FREE(_pdblReal);
566 }
567 /*--------------------------------------------------------------------------*/
568 void freeAllocatedSingleComplexPoly(double* _pdblReal, double* _pdblImg)
569 {
570     freeAllocatedSinglePoly(_pdblReal);
571     FREE(_pdblImg);
572 }
573 /*--------------------------------------------------------------------------*/
574 void freeAllocatedMatrixOfPoly(int _iRows, int _iCols, int* _piNbCoef, double** _pdblReal)
575 {
576     FREE(_piNbCoef);
577
578     for (int i = 0 ; i < _iRows * _iCols ; i++)
579     {
580         FREE(_pdblReal[i]);
581     }
582     FREE(_pdblReal);
583 }
584 /*--------------------------------------------------------------------------*/
585 void freeAllocatedMatrixOfComplexPoly(int _iRows, int _iCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
586 {
587     freeAllocatedMatrixOfPoly(_iRows, _iCols, _piNbCoef, _pdblReal);
588
589     for (int i = 0 ; i < _iRows * _iCols ; i++)
590     {
591         FREE(_pdblImg[i]);
592     }
593     FREE(_pdblImg);
594 }
595 /*--------------------------------------------------------------------------*/