linear_algebra plugged.
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_common.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-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
17 #include "internal.hxx"
18 #include "double.hxx"
19 #include "polynom.hxx"
20 #include "function.hxx"
21 #include "double.hxx"
22 #include "polynom.hxx"
23
24 extern "C"
25 {
26 #include <string.h>
27 #include <stdlib.h>
28 #include "machine.h"
29 #include "core_math.h"
30 #include "call_scilab.h"
31 #include "api_scilab.h"
32 #include "api_common.h"
33 #include "api_internal_common.h"
34 #include "localization.h"
35 #include "MALLOC.h"
36 #include "api_oldstack.h"
37 }
38
39 /*Global structure for scilab 5.x*/
40 extern "C"
41 {
42     StrCtx* pvApiCtx = NULL;
43 }
44
45 using namespace types;
46 /*--------------------------------------------------------------------------*/
47 /* Defined in SCI/modules/core/src/fortran/cvname.f */
48 extern "C" {
49     extern int C2F(cvnamel)(int *id,char *str,int *jobptr,int *str_len);
50 /* *jobptr==0: Get Scilab codes from C-string */
51 /* *jobptr==1: Get C-string from Scilab codes */
52
53     extern int C2F(stackp)(int *,int *);
54 };
55 /*--------------------------------------------------------------------------*/
56 #define idstk(x,y) (C2F(vstk).idstk+(x-1)+(y-1)*nsiz)
57 #define CvNameL(id,str,jobptr,str_len) C2F(cvnamel)(id,str,jobptr,str_len);
58 /*--------------------------------------------------------------------------*/
59
60 SciErr getVarDimension(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols)
61 {
62     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
63     if(_piAddress != NULL && isVarMatrixType(_pvCtx, _piAddress))
64     {
65         *_piRows        = ((types::InternalType*)_piAddress)->getAsGenericType()->getRows();
66         *_piCols        = ((types::InternalType*)_piAddress)->getAsGenericType()->getCols();
67     }
68     else
69     {
70         *_piRows        = 0;
71         *_piCols        = 0;
72         if(_piAddress == NULL)
73         {
74             addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarDimension");
75         }
76         else
77         {
78             addErrorMessage(&sciErr, API_ERROR_NOT_MATRIX_TYPE, _("%s: matrix argument excepted"), "getVarDimension");
79         }
80     }
81     return sciErr;
82 }
83 /*--------------------------------------------------------------------------*/
84 SciErr getNamedVarDimension(void* _pvCtx, const char *_pstName, int* _piRows, int* _piCols)
85 {
86     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
87     int* piAddr                = NULL;
88     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
89     if(sciErr.iErr)
90     {
91         addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
92         return sciErr;
93     }
94
95     sciErr = getVarDimension(_pvCtx, piAddr, _piRows, _piCols);
96     if(sciErr.iErr)
97     {
98         addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
99         return sciErr;
100     }
101
102     return sciErr;
103 }
104 /*--------------------------------------------------------------------------*/
105 SciErr getVarAddressFromPosition(void* _pvCtx, int _iVar, int** _piAddress)
106 {
107     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
108
109     if(_pvCtx == NULL)
110     {
111         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarAddressFromPosition");
112         return sciErr;
113     }
114
115     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
116     types::typed_list in = *pStr->m_pIn;
117     int*    piRetCount = pStr->m_piRetCount;
118     wchar_t* pstName = pStr->m_pstName;
119
120     int iAddr            = 0;
121
122     int iValType    = 0;
123     /* we accept a call to getVarAddressFromPosition after a create... call */
124     if(_iVar > in.size())
125     {
126         //manage case where _iVar > in.size(), then look in out to get recent create variable.
127         addErrorMessage(&sciErr, API_ERROR_INVALID_POSITION, _("%s: bad call to %s! (1rst argument).\n"), pstName, "getVarAddressFromPosition");
128         return sciErr;
129     }
130
131     *_piAddress        = (int*)in[_iVar - 1];
132     return sciErr;
133 }
134 /*--------------------------------------------------------------------------*/
135 SciErr getVarNameFromPosition(void* _pvCtx, int _iVar, char* _pstName)
136 {
137     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
138     //int iNameLen                = 0;
139     //int iJob1                        = 1;
140     //CvNameL(&vstk_.idstk[(_iVar - 1) * 6], _pstName, &iJob1, &iNameLen);
141     //if(iNameLen == 0)
142     //{
143     //    addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Unable to get name of argument #%d"), "getVarNameFromPosition", _iVar);
144     //    return sciErr;
145     //}
146
147     //_pstName[iNameLen]    = '\0';
148     return sciErr;
149 }
150 /*--------------------------------------------------------------------------*/
151 int getNewVarAddressFromPosition(void* _pvCtx, int _iVar, int** _piAddress)
152 {
153     //int iAddr            = iadr(*Lstk(_iVar));
154     //*_piAddress        = istk(iAddr);
155     return 0;
156 }
157 /*--------------------------------------------------------------------------*/
158 SciErr getVarAddressFromName(void* _pvCtx, const char* _pstName, int** _piAddress)
159 {
160     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
161     //int iVarID[nsiz];
162     //int* piAddr                = NULL;
163
164     ////get variable id from name
165     //C2F(str2name)(_pstName, iVarID, (int)strlen(_pstName));
166
167     ////define scope of search
168     //Fin = -1;
169     //Err = 0;
170     ////search variable
171     //C2F(stackg)(iVarID);
172
173     ////No idea :(
174     //if ( *Infstk(Fin) == 2)
175     //    Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
176
177     //if (Err > 0 || Fin == 0)
178     //{
179     //    addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Unable to get address of variable \"%s\""), "getVarAddressFromName", _pstName);
180     //    return sciErr;
181     //}
182
183
184     ////get variable address
185     //getNewVarAddressFromPosition(_pvCtx, Fin, &piAddr);
186
187     //*_piAddress = piAddr;
188
189     return sciErr;
190 }
191
192 /*--------------------------------------------------------------------------*/
193 SciErr getVarType(void* _pvCtx, int* _piAddress, int* _piType)
194 {
195     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
196
197     if(_piAddress == NULL)
198     {
199         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarType");
200         return sciErr;
201     }
202
203     switch(((types::InternalType*)_piAddress)->getType())
204     {
205     case GenericType::RealDouble :
206         *_piType = sci_matrix;
207         break;
208     case types::GenericType::RealPoly :
209         *_piType = sci_poly;
210         break;
211     case types::GenericType::RealBool :
212         *_piType = sci_boolean;
213         break;
214         //case GenericType::RealSparse :
215         //    *_piType = sci_sparse;
216         //    break;
217         //case GenericType::RealBoolSparse :
218         //    *_piType = sci_boolean_sparse;
219         //    break;
220         //case GenericType::RealMatlabSparse :
221         //    *_piType = sci_matlab_sparse;
222         //    break;
223     case GenericType::RealInt8 :
224     case GenericType::RealUInt8 :
225     case GenericType::RealInt16 :
226     case GenericType::RealUInt16 :
227     case GenericType::RealInt32 :
228     case GenericType::RealUInt32 :
229     case GenericType::RealInt64 :
230     case GenericType::RealUInt64 :
231         *_piType = sci_ints;
232         break;
233         //case GenericType::RealHandle :
234         //    *_piType = sci_handles;
235         //    break;
236     case GenericType::RealString :
237         *_piType = sci_strings;
238         break;
239     case GenericType::RealMacroFile :
240         *_piType = sci_u_function;
241         break;
242     case GenericType::RealMacro :
243         *_piType = sci_c_function;
244         break;
245     case GenericType::RealList :
246         *_piType = sci_list;
247         break;
248     case GenericType::RealCell :
249         *_piType = sci_mlist;
250         break;
251     case GenericType::RealTList :
252         *_piType = sci_tlist;
253         break;
254     case GenericType::RealMList :
255         *_piType = sci_mlist;
256         break;
257     case GenericType::RealStruct :
258         // Scilab < 6 compatibility... Struct have type 17;
259         *_piType = sci_mlist;
260         break;
261     case GenericType::RealUserType :
262         *_piType = sci_pointer;
263         break;
264     case GenericType::RealImplicitList :
265         *_piType = sci_implicit_poly;
266         break;
267     case GenericType::RealFunction :
268         *_piType = sci_intrinsic_function;
269         break;
270     default :
271         *_piType = 0;
272     }
273
274
275     return sciErr;
276 }
277 /*--------------------------------------------------------------------------*/
278 // _pvCtx will not be used by getVarAddressFromName neither getVarType
279 // it can then be NULL.
280 SciErr getNamedVarType(void* _pvCtx, const char* _pstName, int* _piType)
281 {
282     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
283     int* piAddr                = NULL;
284
285     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
286     if(sciErr.iErr)
287     {
288         addErrorMessage(&sciErr, API_ERROR_NAMED_UNDEFINED_VAR, _("%s: Unable to get variable \"%s\""), "getNamedVarType", _pstName);
289         return sciErr;
290     }
291
292     sciErr = getVarType(_pvCtx, piAddr, _piType);
293     if(sciErr.iErr)
294     {
295         addErrorMessage(&sciErr, API_ERROR_NAMED_TYPE, _("%s: Unable to get type of variable \"%s\""), "getNamedVarType", _pstName);
296         return sciErr;
297     }
298     return sciErr;
299 }
300 /*--------------------------------------------------------------------------*/
301 int isVarComplex(void* _pvCtx, int* _piAddress)
302 {
303     SciErr sciErr;
304     int iType            = 0;
305     int iComplex    = 0;
306
307     if(_piAddress == NULL)
308     {
309         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarType");
310         return 0;
311     }
312
313     getVarType(_pvCtx, _piAddress, &iType);
314     switch(iType)
315     {
316     case sci_matrix :
317         iComplex = ((types::InternalType*)_piAddress)->getAs<Double>()->isComplex();
318         break;
319     case sci_poly :
320         iComplex = ((types::InternalType*)_piAddress)->getAs<Polynom>()->isComplex();
321     case sci_sparse :
322         //iComplex = ((InternalType*)_piAddress)->getAsSparse()->isComplex();
323         break;
324     }
325     return iComplex;
326 }
327 /*--------------------------------------------------------------------------*/
328 int isNamedVarComplex(void* _pvCtx, const char *_pstName)
329 {
330     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
331     int* piAddr                = NULL;
332
333     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
334     if(sciErr.iErr)
335     {
336         return 0;
337     }
338     return isVarComplex(_pvCtx, piAddr);
339 }
340 /*--------------------------------------------------------------------------*/
341 void createNamedVariable(int *_piVarID)
342 {
343     //int iOne                = 1;
344     //C2F(stackp)(_piVarID, &iOne);
345 }
346 /*--------------------------------------------------------------------------*/
347 int updateInterSCI(int _iVar, char _cType, int _iSCIAddress, int _iSCIDataAddress)
348 {
349     //intersci_.ntypes[_iVar - 1]    = _cType;
350     //intersci_.iwhere[_iVar - 1]    = _iSCIAddress;
351     //intersci_.lad[_iVar - 1]        = _iSCIDataAddress;
352     return 0;
353 }
354 /*--------------------------------------------------------------------------*/
355 int updateLstk(int _iNewpos, int _iSCIDataAddress, int _iVarSize)
356 {
357     //*Lstk(_iNewpos + 1) = _iSCIDataAddress + _iVarSize;
358     return 0;
359 }
360 /*--------------------------------------------------------------------------*/
361 int isVarMatrixType(void* _pvCtx, int* _piAddress)
362 {
363     if(_piAddress != NULL)
364     {
365         int iType = 0;
366         getVarType(_pvCtx, _piAddress, &iType);
367
368         switch(iType)
369         {
370         case sci_matrix :
371         case sci_poly :
372         case sci_boolean :
373         case sci_sparse :
374         case sci_boolean_sparse :
375         case sci_matlab_sparse :
376         case sci_ints :
377         case sci_handles :
378         case sci_strings :
379             return 1;
380         default :
381             return 0;
382         }
383     }
384     else
385     {
386         return 0;
387     }
388     return 1;
389 }
390 /*--------------------------------------------------------------------------*/
391 int isNamedVarMatrixType(void* _pvCtx, const char *_pstName)
392 {
393     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
394     int* piAddr                = NULL;
395
396     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
397     if(sciErr.iErr)
398     {
399         return 0;
400     }
401     return isVarMatrixType(_pvCtx, piAddr);
402 }
403 /*--------------------------------------------------------------------------*/
404 SciErr getProcessMode(void* _pvCtx, int _iPos, int* _piAddRef, int *_piMode)
405 {
406     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
407     int iRows1            = 0;
408     int iCols1            = 0;
409     int iRows2            = 0;
410     int iCols2            = 0;
411     int iType2            = 0;
412     int iMode                = 0;
413     int* piAddr2        = NULL;
414
415     sciErr = getVarDimension(_pvCtx, _piAddRef, &iRows1, &iCols1);
416     if(sciErr.iErr)
417     {
418         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
419         return sciErr;
420     }
421
422     sciErr = getVarAddressFromPosition(_pvCtx, _iPos, &piAddr2);
423     if(sciErr.iErr)
424     {
425         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get variable address"), "getProcessMode");
426         return sciErr;
427     }
428
429     sciErr = getVarType(_pvCtx, piAddr2, &iType2);
430     if(sciErr.iErr)
431     {
432         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument type"), "getProcessMode");
433         return sciErr;
434     }
435
436     if(iType2 == sci_matrix && !isVarComplex(_pvCtx, piAddr2))
437     {
438         double *pdblReal2 = NULL;
439         sciErr = getMatrixOfDouble(_pvCtx, piAddr2, &iRows2, &iCols2, &pdblReal2);
440         if(sciErr.iErr)
441         {
442             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
443             return sciErr;
444         }
445
446         if(iRows2 != 1 || iCols2 != 1)
447         {
448             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1, 1);
449             return sciErr;
450         }
451
452         iMode = (int)pdblReal2[0];
453     }
454     else if(iType2 == sci_strings)
455     {
456         int iLen                    = 0;
457         char *pstMode[1]    = {""};
458
459         sciErr = getVarDimension(_pvCtx, piAddr2, &iRows2, &iCols2);
460         if(sciErr.iErr)
461         {
462             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
463             return sciErr;
464         }
465
466         if(iRows2 != 1 || iCols2 != 1)
467         {
468             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1, 1);
469             return sciErr;
470         }
471
472         sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, NULL);
473         if(sciErr.iErr)
474         {
475             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
476             return sciErr;
477         }
478
479         pstMode[0] = (char*)MALLOC(sizeof(char) * (iLen + 1)); //+1 for null termination
480         sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, pstMode);
481         if(sciErr.iErr)
482         {
483             addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
484             return sciErr;
485         }
486
487         iMode = (int)pstMode[0][0];
488         FREE(pstMode[0]);
489     }
490     else
491     {
492         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong type for input argument #%d: A string or a scalar expected.\n"), "getProcessMode", _iPos);
493         return sciErr;
494     }
495
496     if(iMode == ROW_LETTER || iMode == BY_ROWS)
497         *_piMode = BY_ROWS;
498     else if(iMode == COL_LETTER || iMode == BY_COLS)
499         *_piMode = BY_COLS;
500     else if(iMode == STAR_LETTER || iMode == BY_ALL)
501         *_piMode = BY_ALL;
502     else if(iMode == MTLB_LETTER || iMode == BY_MTLB)
503     {
504         *_piMode = 0;
505         if(iRows1 > 1)
506             *_piMode = 1;
507         else if(iCols1 > 1)
508             *_piMode = 2;
509     }
510     else
511     {
512         addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong value for input argument #%d: ''%s'' or ''%s'' expected.\n"), "getProcessMode", _iPos, "'*', 'r', 'c', 'm', '0', '1', '2'", "-1");
513         return sciErr;
514     }
515     return sciErr;
516 }
517 /*--------------------------------------------------------------------------*/
518 SciErr getDimFromVar(void* _pvCtx, int* _piAddress, int* _piVal)
519 {
520     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
521     int iType                    = 0;
522     int iRows                    = 0;
523     int iCols                    = 0;
524     double *pdblReal    = NULL;
525
526     sciErr = getVarType(_pvCtx, _piAddress, &iType);
527     if(sciErr.iErr)
528     {
529         addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument type"), "getDimFromVar");
530         return sciErr;
531     }
532
533     if(iType == sci_matrix)
534     {
535         if(isVarComplex(_pvCtx, _piAddress))
536         {
537             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for argument %d: Real matrix expected.\n"), "getDimFromVar", getRhsFromAddress(_pvCtx, _piAddress));
538             return sciErr;
539         }
540
541         sciErr = getMatrixOfDouble(_pvCtx, _piAddress, &iRows, &iCols, &pdblReal);
542         if(sciErr.iErr)
543         {
544             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
545             return sciErr;
546         }
547
548         *_piVal = (int)Max(pdblReal[0], 0);
549     }
550     else if(iType == sci_ints)
551     {
552         int iPrec            = 0;
553
554         sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
555         if(sciErr.iErr)
556         {
557             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument dimension"), "getDimFromVar");
558             return sciErr;
559         }
560
561         if(iRows != 1 || iCols != 1)
562         {
563             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode", getRhsFromAddress(_pvCtx, _piAddress), 1, 1);
564             return sciErr;
565         }
566
567         sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddress, &iPrec);
568         if(sciErr.iErr)
569         {
570             addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument precision"), "getDimFromVar");
571             return sciErr;
572         }
573
574         switch(iPrec)
575         {
576         case SCI_INT8 :
577         {
578             char* pcData        = NULL;
579             sciErr = getMatrixOfInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pcData);
580             if(sciErr.iErr)
581             {
582                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
583                 return sciErr;
584             }
585             *_piVal = pcData[0];
586         }
587         break;
588         case SCI_UINT8 :
589         {
590             unsigned char* pucData        = NULL;
591             sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pucData);
592             if(sciErr.iErr)
593             {
594                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
595                 return sciErr;
596             }
597             *_piVal = pucData[0];
598         }
599         break;
600         case SCI_INT16 :
601         {
602             short* psData        = NULL;
603             sciErr = getMatrixOfInteger16(_pvCtx, _piAddress, &iRows, &iCols, &psData);
604             if(sciErr.iErr)
605             {
606                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
607                 return sciErr;
608             }
609             *_piVal = psData[0];
610         }
611         break;
612         case SCI_UINT16 :
613         {
614             unsigned short* pusData        = NULL;
615             sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddress, &iRows, &iCols, &pusData);
616             if(sciErr.iErr)
617             {
618                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
619                 return sciErr;
620             }
621             *_piVal = pusData[0];
622         }
623         break;
624         case SCI_INT32 :
625         {
626             int* piData        = NULL;
627             sciErr = getMatrixOfInteger32(_pvCtx, _piAddress, &iRows, &iCols, &piData);
628             if(sciErr.iErr)
629             {
630                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
631                 return sciErr;
632             }
633             *_piVal = piData[0];
634         }
635         break;
636         case SCI_UINT32 :
637         {
638             unsigned int* puiData        = NULL;
639             sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddress, &iRows, &iCols, &puiData);
640             if(sciErr.iErr)
641             {
642                 addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
643                 return sciErr;
644             }
645             *_piVal = puiData[0];
646         }
647         break;
648         }
649     }
650     else
651     {
652         addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for input argument #%d: A real scalar or a integer scalar expected.\n"), "getDimFromVar", getRhsFromAddress(_pvCtx, _piAddress));
653         return sciErr;
654     }
655     return sciErr;
656 }
657 /*--------------------------------------------------------------------------*/
658 SciErr getDimFromNamedVar(void* _pvCtx, const char* _pstName, int* _piVal)
659 {
660     SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
661     int* piAddr        = NULL;
662
663     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
664     if(sciErr.iErr)
665     {
666         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar", _pstName);
667         return sciErr;
668     }
669
670     sciErr = getDimFromVar(_pvCtx, piAddr, _piVal);
671     if(sciErr.iErr)
672     {
673         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar", _pstName);
674         return sciErr;
675     }
676
677     return sciErr;
678 }
679 /*--------------------------------------------------------------------------*/
680 int getRhsFromAddress(void* _pvCtx, int* _piAddress)
681 {
682     //int i = 0;
683     //   types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
684     //   types::typed_list in = *pStr->m_pIn;
685
686     //for(i = 0 ; i < Rhs ; i++)
687     //{
688     //    if(_piAddress == (int*)in[i])
689     //    {
690     //        return i + 1;
691     //    }
692     //}
693     return 0;
694 }
695
696 /*short cut functions*/
697
698 /*--------------------------------------------------------------------------*/
699 int isRowVector(void* _pvCtx, int* _piAddress)
700 {
701     SciErr sciErr;
702     int iRows = 0;
703     int iCols = 0;
704
705     if(_piAddress == NULL)
706     {
707         return 0;
708     }
709
710     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
711     {
712         return 0;
713     }
714
715     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
716     if(sciErr.iErr)
717     {
718         addErrorMessage(&sciErr, API_ERROR_IS_ROW_VECTOR, _("%s: Unable to get argument dimension"), "isRowVector");
719         printError(&sciErr, 0);
720         return sciErr.iErr;
721     }
722
723     if(iRows == 1 && iCols > 1)
724     {
725         return 1;
726     }
727
728     return 0;
729 }
730 /*--------------------------------------------------------------------------*/
731 int isNamedRowVector(void* _pvCtx, const char* _pstName)
732 {
733     SciErr sciErr;
734     int iRows = 0;
735     int iCols = 0;
736
737     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
738     {
739         return 0;
740     }
741
742     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
743     if(sciErr.iErr)
744     {
745         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_ROW_VECTOR, _("%s: Unable to get argument dimension"), "isNamedRowVector");
746         printError(&sciErr, 0);
747         return sciErr.iErr;
748     }
749
750     if(iRows == 1 && iCols > 1)
751     {
752         return 1;
753     }
754
755     return 0;
756 }
757 /*--------------------------------------------------------------------------*/
758 int isColumnVector(void* _pvCtx, int* _piAddress)
759 {
760     SciErr sciErr;
761     int iRows = 0;
762     int iCols = 0;
763
764     if(_piAddress == NULL)
765     {
766         return 0;
767     }
768
769     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
770     {
771         return 0;
772     }
773
774     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
775     if(sciErr.iErr)
776     {
777         addErrorMessage(&sciErr, API_ERROR_IS_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isColumnVector");
778         printError(&sciErr, 0);
779         return 0;
780     }
781
782     if(iCols == 1 && iRows > 1)
783     {
784         return 1;
785     }
786
787     return 0;
788 }
789 /*--------------------------------------------------------------------------*/
790 int isNamedColumnVector(void* _pvCtx, const char* _pstName)
791 {
792     SciErr sciErr;
793     int iRows = 0;
794     int iCols = 0;
795
796     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
797     {
798         return 0;
799     }
800
801     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
802     if(sciErr.iErr)
803     {
804         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isNamedColumnVector");
805         printError(&sciErr, 0);
806         return 0;
807     }
808
809     if(iCols == 1 && iRows > 1)
810     {
811         return 1;
812     }
813
814     return 0;
815 }
816 /*--------------------------------------------------------------------------*/
817 int isVector(void* _pvCtx, int* _piAddress)
818 {
819     return isRowVector(_pvCtx, _piAddress) || isColumnVector(_pvCtx, _piAddress);
820 }
821 /*--------------------------------------------------------------------------*/
822 int isNamedVector(void* _pvCtx, const char* _pstName)
823 {
824     return isNamedRowVector(_pvCtx, _pstName) || isNamedColumnVector(_pvCtx, _pstName);
825 }
826 /*--------------------------------------------------------------------------*/
827 int isScalar(void* _pvCtx, int* _piAddress)
828 {
829     SciErr sciErr;
830     int iRows = 0;
831     int iCols = 0;
832
833     if(_piAddress == NULL)
834     {
835         return 0;
836     }
837
838     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
839     {
840         return 0;
841     }
842
843     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
844     if(sciErr.iErr)
845     {
846         addErrorMessage(&sciErr, API_ERROR_IS_SCALAR, _("%s: Unable to get argument dimension"), "isScalar");
847         printError(&sciErr, 0);
848         return 0;
849     }
850
851     if(iCols == 1 && iRows == 1)
852     {
853         return 1;
854     }
855
856     return 0;
857 }
858 /*--------------------------------------------------------------------------*/
859 int isNamedScalar(void* _pvCtx, const char* _pstName)
860 {
861     SciErr sciErr;
862     int iRows = 0;
863     int iCols = 0;
864
865     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
866     {
867         return 0;
868     }
869
870     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
871     if(sciErr.iErr)
872     {
873         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_SCALAR, _("%s: Unable to get argument dimension"), "isNamedScalar");
874         printError(&sciErr, 0);
875         return 0;
876     }
877
878     if(iCols == 1 && iRows == 1)
879     {
880         return 1;
881     }
882
883     return 0;
884 }
885 /*--------------------------------------------------------------------------*/
886 int isSquareMatrix(void* _pvCtx, int* _piAddress)
887 {
888     SciErr sciErr;
889     int iRows = 0;
890     int iCols = 0;
891
892     if(_piAddress == NULL)
893     {
894         return 0;
895     }
896
897     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
898     {
899         return 0;
900     }
901
902     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
903     if(sciErr.iErr)
904     {
905         addErrorMessage(&sciErr, API_ERROR_IS_SQUARE, _("%s: Unable to get argument dimension"), "isSquareMatrix");
906         printError(&sciErr, 0);
907         return 0;
908     }
909
910     if(iRows > 1 && iCols == iRows)
911     {
912         return 1;
913     }
914
915     return 0;
916 }
917 /*--------------------------------------------------------------------------*/
918 int isNamedSquareMatrix(void* _pvCtx, const char* _pstName)
919 {
920     SciErr sciErr;
921     int iRows = 0;
922     int iCols = 0;
923
924     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
925     {
926         return 0;
927     }
928
929     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
930     if(sciErr.iErr)
931     {
932         addErrorMessage(&sciErr, API_ERROR_IS_NAMED_SQUARE, _("%s: Unable to get argument dimension"), "isNamedSquareMatrix");
933         printError(&sciErr, 0);
934         return 0;
935     }
936
937     if(iRows > 1 && iCols == iRows)
938     {
939         return 1;
940     }
941
942     return 0;
943 }
944 /*--------------------------------------------------------------------------*/
945 int checkVarDimension(void* _pvCtx, int* _piAddress, int _iRows, int _iCols)
946 {
947     SciErr sciErr;
948     int iRows = 0;
949     int iCols = 0;
950
951     if(_piAddress == NULL)
952     {
953         return 0;
954     }
955
956     if(isVarMatrixType(_pvCtx, _piAddress) == 0)
957     {
958         return 0;
959     }
960
961     sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
962     if(sciErr.iErr)
963     {
964         addErrorMessage(&sciErr, API_ERROR_CHECK_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkVarDimension");
965         printError(&sciErr, 0);
966         return 0;
967     }
968
969     if((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
970     {
971         return 1;
972     }
973
974     return 0;
975 }
976 /*--------------------------------------------------------------------------*/
977 int checkNamedVarDimension(void* _pvCtx, const char* _pstName, int _iRows, int _iCols)
978 {
979     SciErr sciErr;
980     int iRows = 0;
981     int iCols = 0;
982
983     if(isNamedVarMatrixType(_pvCtx, _pstName) == 0)
984     {
985         return 0;
986     }
987
988     sciErr = getNamedVarDimension(_pvCtx, _pstName, &iRows, &iCols);
989     if(sciErr.iErr)
990     {
991         addErrorMessage(&sciErr, API_ERROR_CHECK_NAMED_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkNamedVarDimension");
992         printError(&sciErr, 0);
993         return 0;
994     }
995
996     if((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
997     {
998         return 1;
999     }
1000
1001     return 0;
1002 }
1003 /*--------------------------------------------------------------------------*/
1004 int checkVarType(void* _pvCtx, int* _piAddress, int _iType)
1005 {
1006     SciErr sciErr;
1007     int iType = 0;
1008     if(_piAddress == NULL)
1009     {
1010         return 0;
1011     }
1012
1013     sciErr = getVarType(_pvCtx, _piAddress, &iType);
1014     if(sciErr.iErr)
1015     {
1016         return 0;
1017     }
1018
1019     if(iType == _iType)
1020     {
1021         return 1;
1022     }
1023
1024     return 0;
1025 }
1026 /*--------------------------------------------------------------------------*/
1027 int checkNamedVarType(void* _pvCtx, const char* _pstName, int _iType)
1028 {
1029     SciErr sciErr;
1030     int iType = 0;
1031
1032     sciErr = getNamedVarType(_pvCtx, _pstName, &iType);
1033     if(sciErr.iErr)
1034     {
1035         return 0;
1036     }
1037
1038     if(iType == _iType)
1039     {
1040         return 1;
1041     }
1042
1043     return 0;
1044 }
1045 /*--------------------------------------------------------------------------*/
1046 int isEmptyMatrix(void* _pvCtx, int* _piAddress)
1047 {
1048     if(checkVarType(_pvCtx, _piAddress, sci_matrix))
1049     {
1050         return checkVarDimension(_pvCtx, _piAddress, 0, 0);
1051     }
1052     return 0;
1053 }
1054 /*--------------------------------------------------------------------------*/
1055 int isNamedEmptyMatrix(void* _pvCtx, const char* _pstName)
1056 {
1057     if(checkNamedVarType(_pvCtx, _pstName, sci_matrix))
1058     {
1059         return checkNamedVarDimension(_pvCtx, _pstName, 0, 0);
1060     }
1061     return 0;
1062 }
1063 /*--------------------------------------------------------------------------*/
1064 int createEmptyMatrix(void* _pvCtx, int _iVar)
1065 {
1066     SciErr sciErr;
1067     double dblReal = 0;
1068
1069     sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
1070     if(sciErr.iErr)
1071     {
1072         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
1073         printError(&sciErr, 0);
1074         return sciErr.iErr;
1075     }
1076
1077     return 0;
1078 }
1079 /*--------------------------------------------------------------------------*/
1080 int createNamedEmptyMatrix(void* _pvCtx, const char *_pstName)
1081 {
1082     SciErr sciErr;
1083     double dblOne = 0;
1084
1085     sciErr = createNamedMatrixOfDouble(_pvCtx, _pstName, 0, 0, &dblOne);
1086     if(sciErr.iErr)
1087     {
1088         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createNamedEmptyMatrix");
1089         printError(&sciErr, 0);
1090         return sciErr.iErr;
1091     }
1092
1093     return 0;
1094 }
1095 /*--------------------------------------------------------------------------*/
1096 int isNamedVarExist(void* _pvCtx, const char* _pstName)
1097 {
1098     SciErr sciErr;
1099     int* piAddr = NULL;
1100
1101     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
1102     if(sciErr.iErr || piAddr == NULL)
1103     {
1104         return 0;
1105     }
1106
1107     return 1;
1108 }
1109 /*--------------------------------------------------------------------------*/