Replace Min, Max and Abs by std::min, std::max and std::abs
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_sparse.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 #include "sparse.hxx"
16
17 extern "C"
18 {
19 #include <string.h>
20 #include "elem_common.h"
21 #include "api_scilab.h"
22 #include "api_internal_common.h"
23 #include "api_internal_sparse.h"
24 #include "localization.h"
25 #include "sci_malloc.h"
26 #include "call_scilab.h"
27 }
28
29 using namespace types;
30
31 static int getCommonAllocatedSparseMatrix(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg);
32 static int getCommonNamedAllocatedSparseMatrix(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg);
33
34
35 //internal sparse functions
36 SciErr getSparseMatrix(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
37 {
38     return getCommonSparseMatrix(_pvCtx, _piAddress, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
39 }
40
41 SciErr getComplexSparseMatrix(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
42 {
43     return getCommonSparseMatrix(_pvCtx, _piAddress, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
44 }
45
46 SciErr getCommonSparseMatrix(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
47 {
48     SciErr sciErr = sciErrInit();
49     int iPos    = 0;
50     int iType   = 0;
51
52     if (_piAddress == NULL)
53     {
54         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix");
55         return sciErr;
56     }
57
58     sciErr = getVarType(_pvCtx, _piAddress, &iType);
59     if (sciErr.iErr)
60     {
61         addErrorMessage(&sciErr, API_ERROR_GET_SPARSE, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix", getRhsFromAddress(_pvCtx, _piAddress));
62         return sciErr;
63     }
64
65     if (iType != sci_sparse)
66     {
67         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix", _("sparse matrix"));
68         return sciErr;
69     }
70
71     if (isVarComplex(_pvCtx, _piAddress) != _iComplex)
72     {
73         addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix");
74         return sciErr;
75     }
76
77
78     sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
79     if (sciErr.iErr)
80     {
81         addErrorMessage(&sciErr, API_ERROR_GET_SPARSE, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix", getRhsFromAddress(_pvCtx, _piAddress));
82         return sciErr;
83     }
84
85     Sparse* pS = ((InternalType*)_piAddress)->getAs<Sparse>();
86
87     *_piNbItem = (int)pS->nonZeros();
88
89     if (_piNbItemRow == NULL)
90     {
91         return sciErr;
92     }
93
94     //WARNING: leak memory, caller must free pointer
95     int* piNbItemRows = (int*)MALLOC(sizeof(int) **_piRows);
96     *_piNbItemRow = pS->getNbItemByRow(piNbItemRows);
97
98     if (_piColPos == NULL)
99     {
100         return sciErr;
101     }
102
103     //WARNING: leak memory, caller must free pointer
104     int* piColPos = (int*)MALLOC(sizeof(int) **_piNbItem);
105     *_piColPos = pS->getColPos(piColPos);
106
107     if (_pdblReal == NULL)
108     {
109         return sciErr;
110     }
111
112     //WARNING: leak memory, caller must free pointers
113     double* pR = (double*)MALLOC(sizeof(double) **_piNbItem);
114     double* pI = (double*)MALLOC(sizeof(double) **_piNbItem);
115     pS->outputValues(pR, pI);
116
117     *_pdblReal = pR;
118
119     if (_iComplex == 1 && _pdblImg != NULL)
120     {
121         *_pdblImg = pI;
122     }
123     return sciErr;
124 }
125
126 SciErr allocSparseMatrix(void* _pvCtx, int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
127 {
128     return allocCommonSparseMatrix(_pvCtx, _iVar, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
129 }
130
131 SciErr allocComplexSparseMatrix(void* _pvCtx, int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
132 {
133     return allocCommonSparseMatrix(_pvCtx, _iVar, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
134 }
135
136 SciErr allocCommonSparseMatrix(void* _pvCtx, int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
137 {
138     SciErr sciErr = sciErrInit();
139
140 #if 0
141     int iNewPos     = Top - Rhs + _iVar;
142     int iAddr       = *Lstk(iNewPos);
143     int iTotalSize  = 0;
144     int iOffset     = 0;
145     int* piAddr     = NULL;
146
147     //return empty matrix
148     if (_iRows == 0 && _iCols == 0)
149     {
150         double dblReal = 0;
151         sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
152         if (sciErr.iErr)
153         {
154             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
155         }
156         return sciErr;
157     }
158
159     //header + offset
160     int iMemSize = (5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2)) / 2;
161     //+ items size
162     iMemSize += _iNbItem * (_iComplex + 1);
163     int iFreeSpace = iadr(*Lstk(Bot)) - (iadr(iAddr));
164     if (iMemSize > iFreeSpace)
165     {
166         addStackSizeError(&sciErr, ((StrCtx*)_pvCtx)->pstName, iMemSize);
167         return sciErr;
168     }
169
170     getNewVarAddressFromPosition(_pvCtx, iNewPos, &piAddr);
171
172     sciErr = fillCommonSparseMatrix(_pvCtx, piAddr, _iComplex, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg, &iTotalSize);
173     if (sciErr.iErr)
174     {
175         addErrorMessage(&sciErr, API_ERROR_ALLOC_SPARSE, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "allocComplexSparseMatrix" : "allocSparseMatrix");
176         return sciErr;
177     }
178
179     iOffset     = 5;//4 for header + 1 for NbItem
180     iOffset             += _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
181
182     updateInterSCI(_iVar, '$', iAddr, sadr(iadr(iAddr) + iOffset));
183     updateLstk(iNewPos, sadr(iadr(iAddr) + iOffset), iTotalSize);
184 #endif
185     return sciErr;
186 }
187
188 SciErr fillCommonSparseMatrix(void* _pvCtx, int *_piAddress, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int* _piTotalSize)
189 {
190     SciErr sciErr = sciErrInit();
191     if (_piAddress == NULL)
192     {
193         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "fillCommonSparseMatrix");
194         return sciErr;
195     }
196
197     _piAddress[0] = sci_sparse;
198     _piAddress[1] = std::min(_iRows, _iRows * _iCols);
199     _piAddress[2] = std::min(_iCols, _iRows * _iCols);
200     _piAddress[3] = _iComplex;
201
202     _piAddress[4] = _iNbItem;
203
204     *_piNbItemRow = _piAddress + 5;//4 for header + 1 for NbItem
205     *_piColPos = *_piNbItemRow + _iRows;
206     *_pdblReal = (double*)(*_piColPos + _iNbItem + !((_iRows + _iNbItem) % 2));
207
208     if (_iComplex == 1)
209     {
210         *_pdblImg = *_pdblReal + _iNbItem;
211     }
212
213     *_piTotalSize = _iNbItem * (_iComplex + 1);
214     return sciErr;
215 }
216
217 SciErr createSparseMatrix(void* _pvCtx, int _iVar, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal)
218 {
219     return createCommonSparseMatrix(_pvCtx, _iVar, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
220 }
221
222 SciErr createComplexSparseMatrix(void* _pvCtx, int _iVar, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg)
223 {
224     return createCommonSparseMatrix(_pvCtx, _iVar, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
225 }
226
227 SciErr createCommonSparseMatrix(void* _pvCtx, int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg)
228 {
229     int* piNbItemRow    = NULL;
230     int* piColPos       = NULL;
231     int iOne            = 1;
232     double* pdblReal    = NULL;
233     double* pdblImg     = NULL;
234
235     if (_iRows == 0 && _iCols == 0)
236     {
237         double dblReal = 0;
238         SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
239         if (sciErr.iErr)
240         {
241             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
242         }
243         return sciErr;
244     }
245
246     SciErr sciErr = allocCommonSparseMatrix(_pvCtx, _iVar, _iComplex, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
247     if (sciErr.iErr)
248     {
249         addErrorMessage(&sciErr, API_ERROR_CREATE_SPARSE, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createComplexSparseMatrix" : "createSparseMatrix");
250         return sciErr;
251     }
252
253     memcpy(piNbItemRow, _piNbItemRow, _iRows * sizeof(int));
254     memcpy(piColPos, _piColPos, _iNbItem * sizeof(int));
255     C2F(dcopy)(&_iNbItem, const_cast<double*>(_pdblReal), &iOne, pdblReal, &iOne);
256     if (_iComplex)
257     {
258         C2F(dcopy)(&_iNbItem, const_cast<double*>(_pdblImg), &iOne, pdblImg, &iOne);
259     }
260     return sciErr;
261 }
262
263 SciErr createNamedSparseMatrix(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal)
264 {
265     return createCommonNamedSparseMatrix(_pvCtx, _pstName, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
266 }
267
268 SciErr createNamedComplexSparseMatrix(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg)
269 {
270     return createCommonNamedSparseMatrix(_pvCtx, _pstName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
271 }
272
273 SciErr createCommonNamedSparseMatrix(void* _pvCtx, const char* _pstName, int _iComplex, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg)
274 {
275     SciErr sciErr = sciErrInit();
276
277 #if 0
278     int iVarID[nsiz];
279     int iSaveRhs        = Rhs;
280     int iSaveTop        = Top;
281     int iTotalSize      = 0;
282     int iPos            = 0;
283
284     int* piAddr         = NULL;
285     int* piNbItemRow    = NULL;
286     int* piColPos       = NULL;
287     int iOne            = 1;
288     double* pdblReal    = NULL;
289     double* pdblImg     = NULL;
290
291     //return named empty matrix
292     if (_iRows == 0 && _iCols == 0)
293     {
294         double dblReal = 0;
295         sciErr = createNamedMatrixOfDouble(_pvCtx, _pstName, 0, 0, &dblReal);
296         if (sciErr.iErr)
297         {
298             addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
299         }
300         return sciErr;
301     }
302
303     if (!checkNamedVarFormat(_pvCtx, _pstName))
304     {
305         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommonNamedSparseMatrix", _pstName);
306         return sciErr;
307     }
308
309     C2F(str2name)(_pstName, iVarID, (int)strlen(_pstName));
310     Top = Top + Nbvars + 1;
311
312     //header + offset
313     int iMemSize = (5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2)) / 2;
314     //+ items size
315     iMemSize += _iNbItem * (_iComplex + 1);
316     int iFreeSpace = iadr(*Lstk(Bot)) - (iadr(*Lstk(Top)));
317     if (iMemSize > iFreeSpace)
318     {
319         addStackSizeError(&sciErr, ((StrCtx*)_pvCtx)->pstName, iMemSize);
320         return sciErr;
321     }
322
323     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
324
325     sciErr = fillCommonSparseMatrix(_pvCtx, piAddr, _iComplex, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg, &iTotalSize);
326     if (sciErr.iErr)
327     {
328         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SPARSE, _("%s: Unable to create %s named \"%s\""), _iComplex ? "createNamedComplexSparseMatrix" : "createNamedSparseMatrix", _("sparse matrix"), _pstName);
329         return sciErr;
330     }
331
332     memcpy(piNbItemRow, _piNbItemRow, _iRows * sizeof(int));
333     memcpy(piColPos, _piColPos, _iNbItem * sizeof(int));
334     C2F(dcopy)(&_iNbItem, const_cast<double*>(_pdblReal), &iOne, pdblReal, &iOne);
335     if (_iComplex)
336     {
337         C2F(dcopy)(&_iNbItem, const_cast<double*>(_pdblImg), &iOne, pdblImg, &iOne);
338     }
339
340     iPos        = 5;//4 for header + 1 for NbItem
341     iPos += _iRows + _iNbItem;
342
343     //update "variable index"
344     updateLstk(Top, *Lstk(Top) + iPos, iTotalSize);
345
346     Rhs = 0;
347     //Add name in stack reference list
348     createNamedVariable(iVarID);
349
350     Top = iSaveTop;
351     Rhs = iSaveRhs;
352 #endif
353
354     return sciErr;
355 }
356
357 SciErr readNamedSparseMatrix(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal)
358 {
359     return readCommonNamedSparseMatrix(_pvCtx, _pstName, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
360 }
361
362 SciErr readNamedComplexSparseMatrix(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
363 {
364     return readCommonNamedSparseMatrix(_pvCtx, _pstName, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
365 }
366
367 SciErr readCommonNamedSparseMatrix(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
368 {
369     int* piAddr = NULL;
370     int* piNbItemRow = 0;
371     int* piColPos = 0;
372     int iOne = 1;
373
374     double* pdblReal    = NULL;
375     double* pdblImg             = NULL;
376
377     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
378     if (sciErr.iErr)
379     {
380         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_SPARSE, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexSparseMatrix" : "readNamedSparseMatrix", _pstName);
381         return sciErr;
382     }
383
384     if (_iComplex == 1)
385     {
386         sciErr = getComplexSparseMatrix(_pvCtx, piAddr, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
387     }
388     else
389     {
390         sciErr = getSparseMatrix(_pvCtx, piAddr, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos, &pdblReal);
391     }
392
393     if (sciErr.iErr)
394     {
395         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_SPARSE, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexSparseMatrix" : "readNamedSparseMatrix", _pstName);
396         return sciErr;
397     }
398
399     if (_piNbItemRow == NULL)
400     {
401         return sciErr;
402     }
403
404     memcpy(_piNbItemRow, piNbItemRow, *_piRows * sizeof(int));
405
406     if (_piColPos == NULL)
407     {
408         return sciErr;
409     }
410
411     memcpy(_piColPos, piColPos, *_piNbItem * sizeof(int));
412
413
414     if (_pdblReal == NULL)
415     {
416         return sciErr;
417     }
418
419     C2F(dcopy)(_piNbItem, pdblReal, &iOne, _pdblReal, &iOne);
420
421     if (_iComplex && _pdblImg)
422     {
423         C2F(dcopy)(_piNbItem, pdblImg, &iOne, _pdblImg, &iOne);
424     }
425
426     return sciErr;
427 }
428
429 /* shortcut functions */
430
431 /*--------------------------------------------------------------------------*/
432 int isSparseType(void* _pvCtx, int* _piAddress)
433 {
434     return checkVarType(_pvCtx, _piAddress, sci_sparse);
435 }
436 /*--------------------------------------------------------------------------*/
437 int isNamedSparseType(void* _pvCtx, const char* _pstName)
438 {
439     return checkNamedVarType(_pvCtx, _pstName, sci_sparse);
440 }
441 /*--------------------------------------------------------------------------*/
442 int getAllocatedSparseMatrix(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
443 {
444     return getCommonAllocatedSparseMatrix(_pvCtx, _piAddress, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
445 }
446 /*--------------------------------------------------------------------------*/
447 int getAllocatedComplexSparseMatrix(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
448 {
449     return getCommonAllocatedSparseMatrix(_pvCtx, _piAddress, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
450 }
451 /*--------------------------------------------------------------------------*/
452 static int getCommonAllocatedSparseMatrix(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
453 {
454     int* piNbItemRow = NULL;
455     int* piColPos = NULL;
456     int iOne = 1;
457     double* pdblReal = NULL;
458     double* pdblImg = NULL;
459
460     SciErr sciErr = getCommonSparseMatrix(_pvCtx, _piAddress, _iComplex, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
461     if (sciErr.iErr)
462     {
463         addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SPARSE, _("%s: Unable to get argument #%d"), _iComplex ? "getAllocatedComplexSparseMatrix" : "getAllocatedSparseMatrix", getRhsFromAddress(_pvCtx, _piAddress));
464         printError(&sciErr, 0);
465         return sciErr.iErr;
466     }
467
468     *_piNbItemRow = (int*)MALLOC(sizeof(int) **_piRows);
469     memcpy(*_piNbItemRow, piNbItemRow, sizeof(int) **_piRows);
470
471     *_piColPos = (int*)MALLOC(sizeof(int) **_piNbItem);
472     memcpy(*_piColPos, piColPos, sizeof(int) **_piNbItem);
473
474     *_pdblReal = (double*)MALLOC(sizeof(double) **_piNbItem);
475     C2F(dcopy)(_piNbItem, pdblReal, &iOne, *_pdblReal, &iOne);
476
477     if (_iComplex)
478     {
479         *_pdblImg = (double*)MALLOC(sizeof(double) **_piNbItem);
480         C2F(dcopy)(_piNbItem, pdblImg, &iOne, *_pdblImg, &iOne);
481     }
482
483     return 0;
484 }
485 /*--------------------------------------------------------------------------*/
486 int getNamedAllocatedSparseMatrix(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
487 {
488     return getCommonNamedAllocatedSparseMatrix(_pvCtx, _pstName, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
489 }
490 /*--------------------------------------------------------------------------*/
491 int getNamedAllocatedComplexSparseMatrix(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
492 {
493     return getCommonNamedAllocatedSparseMatrix(_pvCtx, _pstName, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
494 }
495 /*--------------------------------------------------------------------------*/
496 static int getCommonNamedAllocatedSparseMatrix(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
497 {
498     SciErr sciErr = readCommonNamedSparseMatrix(_pvCtx, _pstName, _iComplex, _piRows, _piCols, _piNbItem, NULL, NULL, NULL, NULL);
499     if (sciErr.iErr)
500     {
501         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_ALLOC_SPARSE, _("%s: Unable to get argument \"%s\""), _iComplex ? "getNamedAllocatedComplexSparseMatrix" : "getNamedAllocatedSparseMatrix", _pstName);
502         printError(&sciErr, 0);
503         return sciErr.iErr;
504     }
505
506     *_piNbItemRow = (int*)MALLOC(sizeof(int) **_piRows);
507     *_piColPos = (int*)MALLOC(sizeof(int) **_piNbItem);
508
509     *_pdblReal = (double*)MALLOC(sizeof(double) **_piNbItem);
510     if (_iComplex)
511     {
512         *_pdblImg = (double*)MALLOC(sizeof(double) **_piNbItem);
513     }
514
515     sciErr = readCommonNamedSparseMatrix(_pvCtx, _pstName, _iComplex, _piRows, _piCols, _piNbItem, *_piNbItemRow, *_piColPos, *_pdblReal, *_pdblImg);
516     if (sciErr.iErr)
517     {
518         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_ALLOC_SPARSE, _("%s: Unable to get argument \"%s\""), _iComplex ? "getNamedAllocatedComplexSparseMatrix" : "getNamedAllocatedSparseMatrix", _pstName);
519         printError(&sciErr, 0);
520         return sciErr.iErr;
521     }
522
523     return 0;
524 }
525 /*--------------------------------------------------------------------------*/
526 void freeAllocatedSparseMatrix(int* _piNbItemRows, int* _piColPos, double* _pdblReal)
527 {
528     FREE(_piNbItemRows);
529     FREE(_piColPos);
530     FREE(_pdblReal);
531 }
532 /*--------------------------------------------------------------------------*/
533 void freeAllocatedComplexSparseMatrix(int* _piNbItemRows, int* _piColPos, double* _pdblReal, double* _pdblImg)
534 {
535     freeAllocatedSparseMatrix(_piNbItemRows, _piColPos, _pdblReal);
536     FREE(_pdblImg);
537 }
538 /*--------------------------------------------------------------------------*/