utf: api_scilab 2
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_double.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 <string.h>
17 #include <stdlib.h>
18
19 #include "gatewaystruct.hxx"
20 #include "double.hxx"
21 #include "context.hxx"
22
23 extern "C"
24 {
25 #include "doublecomplex.h"
26 #include "api_scilab.h"
27 #include "api_internal_common.h"
28 #include "api_internal_double.h"
29 #include "localization.h"
30 #include "elem_common.h"
31 #include "sci_tools.h"
32     extern int C2F(entier)(int *n, double *d__, int *s);
33     extern int C2F(icopy)(int *, int *, int *, int *, int *);
34 }
35
36 /*******************************/
37 /*   double matrix functions   */
38 /*******************************/
39
40 static int getCommonScalarDouble(void* _pvCtx, int* _piAddress, int _iComplex, double* _pdblReal, double* _pdblImg);
41 static int createCommonScalarDouble(void* _pvCtx, int _iVar, int _iComplex, double _dblReal, double _dblImg);
42 static int createCommonNamedScalarDouble(void* _pvCtx, const char* _pstName, int _iComplex, double _dblReal, double _dblImg);
43 static int getCommonNamedScalarDouble(void* _pvCtx, const char* _pstName, int _iComplex, double* _pdblReal, double* _pdblImg);
44 static int createCommonMatrixDoubleFromInteger(void* _pvCtx, int _iVar, int _iComplex, int _iRows, int _iCols, int* _piReal, int* _piImg);
45 static int createCommonScalarDoubleFromInteger(void* _pvCtx, int _iVar, int _iComplex, int _iReal, int _iImg);
46
47 SciErr getMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, double** _pdblReal)
48 {
49     return getCommonMatrixOfDouble(_pvCtx, _piAddress, '$', 0, _piRows, _piCols, _pdblReal, NULL);
50 }
51
52 SciErr getComplexMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
53 {
54     return getCommonMatrixOfDouble(_pvCtx, _piAddress, '$', 1, _piRows, _piCols, _pdblReal, _pdblImg);
55 }
56
57 SciErr getComplexZMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, doublecomplex** _pdblZ)
58 {
59     int iSize = 0;
60     double *pdblReal = NULL;
61
62     SciErr sciErr = getCommonMatrixOfDouble(_pvCtx, _piAddress, 'z', 0, _piRows, _piCols, &pdblReal, NULL);
63     if (sciErr.iErr)
64     {
65         addErrorMessage(&sciErr, API_ERROR_GET_ZDOUBLE, _("%s: Unable to get argument #%d"), "getComplexZMatrixOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
66         return sciErr;
67     }
68
69     types::Double* pDbl = (types::Double*)_piAddress;
70     pDbl->convertToZComplex();
71     *_pdblZ     = (doublecomplex*)(pDbl->get());
72     return sciErr;
73 }
74
75 SciErr getMatrixOfDoubleAsInteger(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piReal)
76 {
77     double* pdblReal = NULL;
78     int iSize = 0;
79     SciErr sciErr = getCommonMatrixOfDouble(_pvCtx, _piAddress, 'i', 0, _piRows, _piCols, &pdblReal, NULL);
80     if (sciErr.iErr)
81     {
82         return sciErr;
83     }
84
85     iSize = *_piRows **_piCols;
86     *_piReal = (int*)pdblReal;
87
88     //Warning we overwrite double by int !!!!
89     C2F(entier)(&iSize, pdblReal, *_piReal);
90
91     types::Double* pD = (types::Double*)_piAddress;
92     pD->setViewAsInteger();
93
94     return sciErr;
95 }
96
97 SciErr getComplexMatrixOfDoubleAsInteger(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piReal, int** _piImg)
98 {
99     double* pdblReal = NULL;
100     double* pdblImg  = NULL;
101
102     SciErr sciErr = getCommonMatrixOfDouble(_pvCtx, _piAddress, 'i', 1, _piRows, _piCols, &pdblReal, &pdblImg);
103     if (sciErr.iErr)
104     {
105         return sciErr;
106     }
107
108     types::Double* pD = (types::Double*)_piAddress;
109     //convert values and view of data to int and int*
110     pD->convertToInteger();
111
112     *_piReal = (int*)pD->get();
113     *_piImg = (int*)pD->getImg();
114
115     return sciErr;
116 }
117
118 SciErr getCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, char _cType, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
119 {
120     SciErr sciErr = sciErrInit();
121     int iType = 0;
122     if (_piAddress == NULL)
123     {
124         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble");
125         return sciErr;
126     }
127
128     sciErr = getVarType(_pvCtx, _piAddress, &iType);
129     if (sciErr.iErr || iType != sci_matrix)
130     {
131         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble", _("double matrix"));
132         return sciErr;
133     }
134
135     sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
136     if (sciErr.iErr)
137     {
138         addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
139         return sciErr;
140     }
141
142     if (_pdblReal != NULL)
143     {
144         *_pdblReal = ((types::InternalType*)_piAddress)->getAs<types::Double>()->getReal();
145     }
146
147     if (_iComplex && _pdblImg != NULL)
148     {
149         *_pdblImg = ((types::InternalType*)_piAddress)->getAs<types::Double>()->getImg();
150     }
151
152     return sciErr;
153 }
154
155 SciErr allocMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal)
156 {
157     double *pdblReal    = NULL;
158
159     SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, '$', 0, _iRows, _iCols, &pdblReal, NULL);
160     if (sciErr.iErr)
161     {
162         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfDouble");
163         return sciErr;
164     }
165
166     *_pdblReal = pdblReal;
167
168     return sciErr;
169 }
170
171 SciErr allocComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
172 {
173     double *pdblReal    = NULL;
174     double *pdblImg             = NULL;
175
176     SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, '$', 1, _iRows, _iCols, &pdblReal, &pdblImg);
177     if (sciErr.iErr)
178     {
179         addErrorMessage(&sciErr, API_ERROR_ALLOC_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
180         return sciErr;
181     }
182
183     *_pdblReal = pdblReal;
184     *_pdblImg  = pdblImg;
185     return sciErr;
186 }
187
188 SciErr allocMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piReal)
189 {
190     double *pdblReal    = NULL;
191
192     SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 0, _iRows, _iCols, &pdblReal, NULL);
193     if (sciErr.iErr)
194     {
195         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfDouble");
196         return sciErr;
197     }
198
199     *_piReal = (int*)pdblReal;
200     return sciErr;
201 }
202
203 SciErr allocComplexMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piReal, int** _piImg)
204 {
205     double *pdblReal    = NULL;
206     double *pdblImg             = NULL;
207
208     SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 1, _iRows, _iCols, &pdblReal, &pdblImg);
209     if (sciErr.iErr)
210     {
211         addErrorMessage(&sciErr, API_ERROR_ALLOC_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
212         return sciErr;
213     }
214
215     *_piReal = (int*)pdblReal;
216     *_piImg  = (int*)pdblImg;
217     return sciErr;
218 }
219
220 SciErr allocCommonMatrixOfDouble(void* _pvCtx, int _iVar, char _cType, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
221 {
222     SciErr sciErr = sciErrInit();
223
224     if (_pvCtx == NULL)
225     {
226         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "allocComplexMatrixOfDouble" : "allocMatrixOfDouble");
227         return sciErr;
228     }
229
230     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
231     types::InternalType** out = pStr->m_pOut;
232
233     types::Double* pDbl = NULL;
234     try
235     {
236         if (_cType == 'z')
237         {
238             pDbl = new types::Double(_iRows, _iCols, _iComplex == 1, true);
239         }
240         else
241         {
242             pDbl = new types::Double(_iRows, _iCols, _iComplex == 1);
243             if (_cType == 'i')
244             {
245                 pDbl->setViewAsInteger();
246             }
247         }
248     }
249     catch (const ast::InternalError& ie)
250     {
251         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %s"), _iComplex ? "allocComplexMatrixOfDouble" : "allocMatrixOfDouble", ie.GetErrorMessage().c_str());
252         return sciErr;
253     }
254
255     if (pDbl == NULL)
256     {
257         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), _iComplex ? "allocComplexMatrixOfDouble" : "allocMatrixOfDouble");
258         return sciErr;
259     }
260
261     int rhs = _iVar - *getNbInputArgument(_pvCtx);
262     out[rhs - 1] = pDbl;
263     *_pdblReal = pDbl->getReal();
264     if (*_pdblReal == NULL)
265     {
266         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), _iComplex ? "allocComplexMatrixOfDouble" : "allocexMatrixOfDouble");
267         return sciErr;
268     }
269
270     if (_iComplex && _pdblImg != NULL)
271     {
272         *_pdblImg       = pDbl->getImg();
273         if (*_pdblImg == NULL)
274         {
275             addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), _iComplex ? "allocComplexMatrixOfDouble" : "allocMatrixOfDouble");
276             return sciErr;
277         }
278     }
279
280     return sciErr;
281 }
282
283 SciErr allocComplexZMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const doublecomplex** _pdblData)
284 {
285     SciErr sciErr = sciErrInit();
286     double *pdblReal    = NULL;
287     double *pdblImg             = NULL;
288
289     sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'z', 1, _iRows, _iCols, &pdblReal, NULL);
290     if (sciErr.iErr)
291     {
292         addErrorMessage(&sciErr, API_ERROR_ALLOC_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
293         return sciErr;
294     }
295
296     *_pdblData = (doublecomplex*)pdblReal;
297     return sciErr;
298 }
299
300 SciErr createMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const double* _pdblReal)
301 {
302     double *pdblReal = NULL;
303
304     int iOne = 1;
305     int iSize = _iRows * _iCols;
306
307     SciErr sciErr = allocMatrixOfDouble(_pvCtx, _iVar, _iRows, _iCols, &pdblReal);
308     if (sciErr.iErr)
309     {
310         addErrorMessage(&sciErr, API_ERROR_CREATE_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
311         return sciErr;
312     }
313
314     C2F(dcopy)(&iSize, const_cast<double*>(_pdblReal), &iOne, pdblReal, &iOne);
315     return sciErr;
316 }
317
318 SciErr createComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
319 {
320     double *pdblReal    = NULL;
321     double *pdblImg             = NULL;
322
323     int iOne = 1;
324     int iSize = _iRows * _iCols;
325
326     SciErr sciErr = allocComplexMatrixOfDouble(_pvCtx, _iVar, _iRows, _iCols, &pdblReal, &pdblImg);
327     if (sciErr.iErr)
328     {
329         addErrorMessage(&sciErr, API_ERROR_CREATE_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
330         return sciErr;
331     }
332
333     C2F(dcopy)(&iSize, const_cast<double*>(_pdblReal), &iOne, pdblReal, &iOne);
334     C2F(dcopy)(&iSize, const_cast<double*>(_pdblImg), &iOne, pdblImg, &iOne);
335     return sciErr;
336 }
337
338 SciErr createMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piReal)
339 {
340     double *pdblReal    = NULL;
341
342     int iOne = 1;
343     int iSize = _iRows * _iCols;
344
345     SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 0, _iRows, _iCols, &pdblReal, NULL);
346     if (sciErr.iErr)
347     {
348         addErrorMessage(&sciErr, API_ERROR_CREATE_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
349         return sciErr;
350     }
351
352     C2F(icopy)(&iSize, (int*)_piReal, &iOne, (int*)pdblReal, &iOne);
353     return sciErr;
354 }
355
356 SciErr createComplexMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piReal, const int* _piImg)
357 {
358     double *pdblReal    = NULL;
359     double *pdblImg             = NULL;
360
361     int iOne = 1;
362     int iSize = _iRows * _iCols;
363
364     SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 1, _iRows, _iCols, &pdblReal, &pdblImg);
365     if (sciErr.iErr)
366     {
367         addErrorMessage(&sciErr, API_ERROR_CREATE_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
368         return sciErr;
369     }
370
371     C2F(icopy)(&iSize, (int*)_piReal, &iOne, (int*)pdblReal, &iOne);
372     C2F(icopy)(&iSize, (int*)_piImg, &iOne, (int*)pdblImg, &iOne);
373     return sciErr;
374 }
375
376 SciErr createComplexZMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const doublecomplex* _pdblData)
377 {
378     SciErr sciErr = sciErrInit();
379     const doublecomplex *pdblZ = NULL;
380
381     sciErr = allocComplexZMatrixOfDouble(_pvCtx, _iVar, _iRows, _iCols, &pdblZ);
382     if (sciErr.iErr)
383     {
384         addErrorMessage(&sciErr, API_ERROR_CREATE_ZDOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
385         return sciErr;
386     }
387
388     memcpy((void*)pdblZ, _pdblData, _iRows * _iCols * sizeof(doublecomplex));
389     return sciErr;
390 }
391
392 SciErr createNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const double* _pdblReal)
393 {
394     return createCommonNamedMatrixOfDouble(_pvCtx, _pstName, 0, _iRows, _iCols, _pdblReal, NULL);
395 }
396
397 SciErr createNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
398 {
399     return createCommonNamedMatrixOfDouble(_pvCtx, _pstName, 1, _iRows, _iCols, _pdblReal, _pdblImg);
400 }
401
402 SciErr createNamedComplexZMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const doublecomplex* _pdblData)
403 {
404     SciErr sciErr = sciErrInit();
405
406     int iOne                                    = 1;
407     int iTwo                                    = 2;
408     int iSize                                   = _iRows * _iCols;
409
410     if (!checkNamedVarFormat(_pvCtx, _pstName))
411     {
412         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createNamedComplexZMatrixOfDouble", _pstName);
413         return sciErr;
414     }
415
416     types::Double* pDbl = new types::Double(_iRows, _iCols, true);
417
418     double* pdblReal = pDbl->get();
419     double* pdblImg = pDbl->getImg();
420     C2F(dcopy)(&iSize, const_cast<double*>(&_pdblData->r), &iTwo, pdblReal, &iOne);
421     C2F(dcopy)(&iSize, const_cast<double*>(&_pdblData->i), &iOne, pdblImg, &iOne);
422
423     symbol::Context* ctx = symbol::Context::getInstance();
424     symbol::Symbol sym = symbol::Symbol(_pstName);
425     if (ctx->isprotected(sym) == false)
426     {
427         ctx->put(sym, pDbl);
428     }
429     else
430     {
431         delete pDbl;
432         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
433     }
434
435     return sciErr;
436 }
437
438 SciErr createCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
439 {
440     SciErr sciErr = sciErrInit();
441     if (!checkNamedVarFormat(_pvCtx, _pstName))
442     {
443         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommonNamedMatrixOfDouble", _pstName);
444         return sciErr;
445     }
446
447     int iOne                                    = 1;
448     int iSize                                   = _iRows * _iCols;
449
450     types::Double* pDbl = new types::Double(_iRows, _iCols, _iComplex == 1);
451
452     double* pdblReal = pDbl->get();
453     C2F(dcopy)(&iSize, const_cast<double*>(_pdblReal), &iOne, pdblReal, &iOne);
454
455     if (_iComplex)
456     {
457         double* pdblImg = pDbl->getImg();
458         C2F(dcopy)(&iSize, const_cast<double*>(_pdblImg), &iOne, pdblImg, &iOne);
459     }
460
461     symbol::Context* ctx = symbol::Context::getInstance();
462     symbol::Symbol sym = symbol::Symbol(_pstName);
463     if (ctx->isprotected(sym) == false)
464     {
465         ctx->put(sym, pDbl);
466     }
467     else
468     {
469         delete pDbl;
470         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
471     }
472     return sciErr;
473 }
474
475 SciErr readNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, double* _pdblReal)
476 {
477     return readCommonNamedMatrixOfDouble(_pvCtx, _pstName, 0, _piRows, _piCols, _pdblReal, NULL);
478 }
479
480 SciErr readNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg)
481 {
482     return readCommonNamedMatrixOfDouble(_pvCtx, _pstName, 1, _piRows, _piCols, _pdblReal, _pdblImg);
483 }
484
485 SciErr readCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg)
486 {
487     int* piAddr = NULL;
488     double* pdblReal = NULL;
489     double* pdblImg = NULL;
490     int iSize = 0;
491     int iOne = 1;
492
493     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
494     if (sciErr.iErr)
495     {
496         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_DOUBLE, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfDouble" : "readNamedMatrixOfDouble", _pstName);
497         return sciErr;
498     }
499
500     sciErr = getCommonMatrixOfDouble(_pvCtx, piAddr, '$', _iComplex, _piRows, _piCols, &pdblReal, &pdblImg);
501     if (sciErr.iErr)
502     {
503         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_DOUBLE, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfDouble" : "readNamedMatrixOfDouble", _pstName);
504         return sciErr;
505     }
506
507     if (_pdblReal == NULL || (_iComplex && _pdblImg == NULL))
508     {
509         return sciErr;
510     }
511
512     iSize = (*_piRows) * (*_piCols);
513     /* dcopy source to dest */
514     C2F(dcopy)(&iSize, pdblReal, &iOne, _pdblReal, &iOne);
515     if (_iComplex)
516     {
517         C2F(dcopy)(&iSize, pdblImg, &iOne, _pdblImg, &iOne);
518     }
519
520     return sciErr;
521 }
522
523 /*shortcut functions*/
524
525 int isDoubleType(void* _pvCtx, int* _piAddress)
526 {
527     return checkVarType(_pvCtx, _piAddress, sci_matrix);
528 }
529 /*--------------------------------------------------------------------------*/
530 int isNamedDoubleType(void* _pvCtx, const char* _pstName)
531 {
532     return checkNamedVarType(_pvCtx, _pstName, sci_matrix);
533 }
534 /*--------------------------------------------------------------------------*/
535 int getScalarDouble(void* _pvCtx, int* _piAddress, double* _pdblReal)
536 {
537     return getCommonScalarDouble(_pvCtx, _piAddress, 0, _pdblReal, NULL);
538 }
539 /*--------------------------------------------------------------------------*/
540 int getScalarComplexDouble(void* _pvCtx, int* _piAddress, double* _pdblReal, double* _pdblImg)
541 {
542     return getCommonScalarDouble(_pvCtx, _piAddress, 1, _pdblReal, _pdblImg);
543 }
544 /*--------------------------------------------------------------------------*/
545 static int getCommonScalarDouble(void* _pvCtx, int* _piAddress, int _iComplex, double* _pdblReal, double* _pdblImg)
546 {
547     int iRows = 0;
548     int iCols = 0;
549
550     double* pdblReal = NULL;
551     double* pdblImg = NULL;
552
553     SciErr sciErr = getCommonMatrixOfDouble(_pvCtx, _piAddress, '$', _iComplex, &iRows, &iCols, &pdblReal, &pdblImg);
554     if (sciErr.iErr)
555     {
556         addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_DOUBLE, _("%s: Unable to get argument #%d"), _iComplex ? "getScalarComplexDouble" : "getScalarDouble", getRhsFromAddress(_pvCtx, _piAddress));
557         printError(&sciErr, 0);
558         return sciErr.iErr;
559     }
560
561     if (isScalar(_pvCtx, _piAddress) == 0)
562     {
563         addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_DOUBLE, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), _iComplex ? "getScalarComplexDouble" : "getScalarDouble", getRhsFromAddress(_pvCtx, _piAddress));
564         printError(&sciErr, 0);
565         return sciErr.iErr;
566     }
567
568     if (_pdblReal != NULL)
569     {
570         *_pdblReal      = pdblReal[0];
571     }
572
573     if (_iComplex == 1 && _pdblImg != NULL && pdblImg != NULL)
574     {
575         *_pdblImg               = pdblImg[0];
576     }
577     else if (_pdblImg != NULL)
578     {
579         *_pdblImg = 0;
580     }
581
582     return 0;
583 }
584 /*--------------------------------------------------------------------------*/
585 int getNamedScalarDouble(void* _pvCtx, const char* _pstName, double* _pdblReal)
586 {
587     return getCommonNamedScalarDouble(_pvCtx, _pstName, 0, _pdblReal, 0);
588 }
589 /*--------------------------------------------------------------------------*/
590 int getNamedScalarComplexDouble(void* _pvCtx, const char* _pstName, double* _pdblReal, double* _pdblImg)
591 {
592     return getCommonNamedScalarDouble(_pvCtx, _pstName, 1, _pdblReal, _pdblImg);
593 }
594 /*--------------------------------------------------------------------------*/
595 static int getCommonNamedScalarDouble(void* _pvCtx, const char* _pstName, int _iComplex, double* _pdblReal, double* _pdblImg)
596 {
597     SciErr sciErr = sciErrInit();
598     int iRows   = 0;
599     int iCols   = 0;
600
601     double dblReal = 0;
602     double dblImg        = 0;
603
604     if (isNamedScalar(_pvCtx, _pstName) == 0)
605     {
606         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_DOUBLE, _("%s: Wrong type for input argument \"%s\": A scalar expected.\n"), _iComplex ? "getNamedScalarComplexDouble" : "getNamedScalarDouble", _pstName);
607         printError(&sciErr, 0);
608         return sciErr.iErr;
609     }
610
611     sciErr = readCommonNamedMatrixOfDouble(_pvCtx, _pstName, _iComplex, &iRows, &iCols, &dblReal, &dblImg);
612     if (sciErr.iErr)
613     {
614         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_DOUBLE, _("%s: Unable to get argument \"%s\""), _iComplex ? "getNamedScalarComplexDouble" : "getNamedScalarDouble", _pstName);
615         printError(&sciErr, 0);
616         return sciErr.iErr;
617     }
618
619     if (_pdblReal != NULL)
620     {
621         _pdblReal[0]    = dblReal;
622     }
623
624     if (_pdblImg != NULL)
625     {
626         _pdblImg[0]             = dblImg;
627     }
628
629     return 0;
630 }
631 /*--------------------------------------------------------------------------*/
632 int createScalarDouble(void* _pvCtx, int _iVar, double _dblReal)
633 {
634     return createCommonScalarDouble(_pvCtx, _iVar, 0, _dblReal, 0);
635 }
636 /*--------------------------------------------------------------------------*/
637 int createScalarComplexDouble(void* _pvCtx, int _iVar, double _dblReal, double _dblImg)
638 {
639     return createCommonScalarDouble(_pvCtx, _iVar, 1, _dblReal, _dblImg);
640 }
641 /*--------------------------------------------------------------------------*/
642 static int createCommonScalarDouble(void* _pvCtx, int _iVar, int _iComplex, double _dblReal, double _dblImg)
643 {
644     double *pdblReal    = NULL;
645     double *pdblImg             = NULL;
646
647     SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, '$', _iComplex, 1, 1, &pdblReal, &pdblImg);
648     if (sciErr.iErr)
649     {
650         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_DOUBLE, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createScalarComplexDouble" : "createScalarDouble");
651         printError(&sciErr, 0);
652         return sciErr.iErr;
653     }
654
655     pdblReal[0] = _dblReal;
656     if (_iComplex)
657     {
658         pdblImg[0]      = _dblImg;
659     }
660     return 0;
661 }
662 /*--------------------------------------------------------------------------*/
663 int createNamedScalarDouble(void* _pvCtx, const char* _pstName, double _dblReal)
664 {
665     return createCommonNamedScalarDouble(_pvCtx, _pstName, 0, _dblReal, 0);
666 }
667 /*--------------------------------------------------------------------------*/
668 int createNamedScalarComplexDouble(void* _pvCtx, const char* _pstName, double _dblReal, double _dblImg)
669 {
670     return createCommonNamedScalarDouble(_pvCtx, _pstName, 1, _dblReal, _dblImg);
671 }
672 /*--------------------------------------------------------------------------*/
673 static int createCommonNamedScalarDouble(void* _pvCtx, const char* _pstName, int _iComplex, double _dblReal, double _dblImg)
674 {
675     SciErr sciErr = createCommonNamedMatrixOfDouble(_pvCtx, _pstName, _iComplex, 1, 1, &_dblReal, &_dblImg);
676     if (sciErr.iErr)
677     {
678         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createNamedScalarComplexDouble" : "createNamedScalarDouble");
679         printError(&sciErr, 0);
680         return sciErr.iErr;
681     }
682
683     return 0;
684 }
685 /*--------------------------------------------------------------------------*/
686 int createScalarDoubleFromInteger(void* _pvCtx, int _iVar, int _iReal)
687 {
688     return createCommonScalarDoubleFromInteger(_pvCtx, _iVar, 0, _iReal, 0);
689 }
690 /*--------------------------------------------------------------------------*/
691 int createScalarComplexDoubleFromInteger(void* _pvCtx, int _iVar, int _iReal, int _iImg)
692 {
693     return createCommonScalarDoubleFromInteger(_pvCtx, _iVar, 1, _iReal, _iImg);
694 }
695 /*--------------------------------------------------------------------------*/
696 static int createCommonScalarDoubleFromInteger(void* _pvCtx, int _iVar, int _iComplex, int _iReal, int _iImg)
697 {
698     SciErr sciErr;
699     double* pdblReal = NULL;
700     double* pdblImg     = NULL;
701
702
703     sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', _iComplex, 1, 1, &pdblReal, &pdblImg);
704     if (sciErr.iErr)
705     {
706         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_FROM_INTEGER, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createScalarComplexDoubleFromInteger" : "createScalarDoubleFromInteger");
707         printError(&sciErr, 0);
708         return sciErr.iErr;
709     }
710
711     pdblReal[0] = (double)_iReal;
712
713     if (_iComplex)
714     {
715         pdblImg[0] = (double)_iImg;
716     }
717     return 0;
718 }
719 /*--------------------------------------------------------------------------*/
720 int createMatrixOfDoubleFromInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int* _piReal)
721 {
722     return createCommonMatrixDoubleFromInteger(_pvCtx, _iVar, 0, _iRows, _iCols, _piReal, NULL);
723 }
724 /*--------------------------------------------------------------------------*/
725 int createMatrixOfComplexDoubleFromInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int* _piReal, int* _piImg)
726 {
727     return createCommonMatrixDoubleFromInteger(_pvCtx, _iVar, 1, _iRows, _iCols, _piReal, _piImg);
728 }
729 /*--------------------------------------------------------------------------*/
730 static int createCommonMatrixDoubleFromInteger(void* _pvCtx, int _iVar, int _iComplex, int _iRows, int _iCols, int* _piReal, int* _piImg)
731 {
732     SciErr sciErr;
733     double* pdblReal = NULL;
734     double* pdblImg     = NULL;
735
736
737     sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', _iComplex, _iRows, _iCols, &pdblReal, &pdblImg);
738     if (sciErr.iErr)
739     {
740         addErrorMessage(&sciErr, API_ERROR_CREATE_MATRIX_FROM_INTEGER, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createMatrixOfComplexDoubleFromInteger" : "createMatrixOfDoubleFromInteger");
741         printError(&sciErr, 0);
742         return sciErr.iErr;
743     }
744
745     memcpy(pdblReal, _piReal, _iRows * _iCols * sizeof(int));
746
747     if (_iComplex)
748     {
749         memcpy(pdblImg, _piImg, _iRows * _iCols * sizeof(int));
750     }
751     return 0;
752 }
753 /*--------------------------------------------------------------------------*/