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