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