c1861caf55e861464192b79cb95575b5760580c1
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_hypermat.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
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 <stdio.h>
20 #include "double.hxx"
21 #include "bool.hxx"
22 #include "string.hxx"
23 #include "int.hxx"
24 #include "polynom.hxx"
25 #include "gatewaystruct.hxx"
26
27 extern "C"
28 {
29 #include "api_scilab.h"
30 #include "api_internal_common.h"
31 #include "api_internal_double.h"
32 #include "localization.h"
33
34 #include "call_scilab.h"
35 }
36
37 int isHypermatType(void* _pvCtx, int* _piAddress)
38 {
39     types::InternalType* it = (types::InternalType*)_piAddress;
40     if (it->isGenericType() == false)
41     {
42         return 0;
43     }
44
45     types::GenericType* gt = it->getAs<types::GenericType>();
46     if (gt->getDims() < 3)
47     {
48         return 0;
49     }
50
51     return 1;
52 }
53
54 int isHypermatComplex(void* _pvCtx, int* _piAddress)
55 {
56     types::InternalType* it = (types::InternalType*)_piAddress;
57     if (it->isGenericType() == false)
58     {
59         return 0;
60     }
61
62     types::GenericType* gt = it->getAs<types::GenericType>();
63     if (gt->isComplex())
64     {
65         return 1;
66     }
67
68     return 0;
69 }
70
71 SciErr getHypermatType(void *_pvCtx, int *_piAddress, int *_piType)
72 {
73     return getVarType(_pvCtx, _piAddress, _piType);
74 }
75
76 SciErr getHypermatOfIntegerPrecision(void *_pvCtx, int *_piAddress, int *_piPrecision)
77 {
78     return getMatrixOfIntegerPrecision(_pvCtx, _piAddress, _piPrecision);
79 }
80
81 SciErr getHypermatDimensions(void *_pvCtx, int *_piAddress, int **_dims, int *_ndims)
82 {
83     SciErr sciErr = sciErrInit();
84     types::InternalType* it = (types::InternalType*)_piAddress;
85     if (it->isGenericType() == false)
86     {
87         addErrorMessage(&sciErr, API_ERROR_NOT_MATRIX_TYPE, _("%s: matrix argument expected"), "getHypermatDimensions");
88         return sciErr;
89     }
90
91     types::GenericType* gt = it->getAs<types::GenericType>();
92     *_ndims = gt->getDims();
93     *_dims = gt->getDimsArray();
94     return sciErr;
95 }
96
97 static int getHypermatEntries(void* _pvCtx, int* _piAddress, void** _piEntriesAddress)
98 {
99     types::InternalType* it = (types::InternalType*)_piAddress;
100     if (it->isGenericType() == false)
101     {
102         return 1;
103     }
104
105     switch (it->getType())
106     {
107         case types::InternalType::ScilabDouble:
108         {
109             *_piEntriesAddress = it->getAs<types::Double>();
110             break;
111         }
112         case types::InternalType::ScilabBool:
113         {
114             *_piEntriesAddress = it->getAs<types::Bool>();
115             break;
116         }
117         case types::InternalType::ScilabString:
118         {
119             *_piEntriesAddress = it->getAs<types::String>();
120             break;
121         }
122         case types::InternalType::ScilabPolynom:
123         {
124             *_piEntriesAddress = it->getAs<types::Polynom>();
125             break;
126         }
127         case types::InternalType::ScilabInt8:
128         {
129             *_piEntriesAddress = it->getAs<types::Int8>();
130             break;
131         }
132         case types::InternalType::ScilabInt16:
133         {
134             *_piEntriesAddress = it->getAs<types::Int16>();
135             break;
136         }
137         case types::InternalType::ScilabInt32:
138         {
139             *_piEntriesAddress = it->getAs<types::Int32>();
140             break;
141         }
142         case types::InternalType::ScilabInt64:
143         {
144             *_piEntriesAddress = it->getAs<types::Int64>();
145             break;
146         }
147         case types::InternalType::ScilabUInt8:
148         {
149             *_piEntriesAddress = it->getAs<types::UInt8>();
150             break;
151         }
152         case types::InternalType::ScilabUInt16:
153         {
154             *_piEntriesAddress = it->getAs<types::UInt16>();
155             break;
156         }
157         case types::InternalType::ScilabUInt32:
158         {
159             *_piEntriesAddress = it->getAs<types::UInt32>();
160             break;
161         }
162         case types::InternalType::ScilabUInt64:
163         {
164             *_piEntriesAddress = it->getAs<types::UInt64>();
165             break;
166         }
167         default:
168         {
169             *_piEntriesAddress = NULL;
170             break;
171         }
172     }
173
174     return 0;
175 }
176
177 SciErr getHypermatOfDouble(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, double** _pdblReal)
178 {
179     SciErr sciErr = sciErrInit();
180     void* entries = NULL;
181
182     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
183     if (ret || entries == NULL || ((types::InternalType*)entries)->isDouble() == false)
184     {
185         addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE, _("%s: Unable to get argument #%d"), "getHypermatOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
186     }
187
188     types::Double* d = (types::Double*)entries;
189     *_dims = d->getDimsArray();
190     *_ndims = d->getDims();
191     *_pdblReal = d->get();
192     return sciErr;
193 }
194
195 SciErr getComplexHypermatOfDouble(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, double** _pdblReal, double** _pdblImg)
196 {
197     SciErr sciErr = sciErrInit();
198     void* entries = NULL;
199
200     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
201     if (ret || entries == NULL || ((types::InternalType*)entries)->isDouble() == false)
202     {
203         addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE, _("%s: Unable to get argument #%d"), "getHypermatOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
204     }
205
206     types::Double* d = (types::Double*)entries;
207     *_dims = d->getDimsArray();
208     *_ndims = d->getDims();
209     *_pdblReal = d->get();
210     *_pdblImg = d->getImg();
211     return sciErr;
212 }
213
214 SciErr getHypermatPolyVariableName(void* _pvCtx, int* _piAddress, char* _pstVarName, int* _piVarNameLen)
215 {
216     SciErr sciErr = sciErrInit();
217     void * entries = NULL;
218
219     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
220
221     if (ret || entries == NULL || ((types::InternalType*)entries)->isPoly() == false)
222     {
223         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatPolyVariableName");
224         return sciErr;
225     }
226
227     types::Polynom* p = (types::Polynom*)entries;
228     std::wstring var = p->getVariableName();
229
230     char* varname = wide_string_to_UTF8(var.data());
231     *_piVarNameLen = static_cast<int>(strlen(varname));
232
233     if (_pstVarName)
234     {
235         strcpy(_pstVarName, varname);
236     }
237
238     FREE(varname);
239     return sciErr;
240 }
241
242 SciErr getHypermatOfPoly(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int* _piNbCoef, double** _pdblReal)
243 {
244     SciErr sciErr = sciErrInit();
245     void * entries = NULL;
246
247     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
248
249     if (ret || entries == NULL || ((types::InternalType*)entries)->isPoly() == false)
250     {
251         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfPoly");
252         return sciErr;
253     }
254
255     types::Polynom* p = (types::Polynom*)entries;
256     *_dims = p->getDimsArray();
257     *_ndims = p->getDims();
258
259     if (_piNbCoef == NULL)
260     {
261         return sciErr;
262     }
263
264     p->getSizes(_piNbCoef);
265
266     if (_pdblReal == NULL)
267     {
268         return sciErr;
269     }
270
271     int size = p->getSize();
272     types::SinglePoly** s = p->get();
273
274     for (int i = 0; i < size; i++)
275     {
276         memcpy(_pdblReal[i], s[i]->get(), sizeof(double) * s[i]->getSize());
277     }
278
279     return sciErr;
280 }
281
282 SciErr getComplexHypermatOfPoly(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
283 {
284     SciErr sciErr = sciErrInit();
285     void * entries = NULL;
286
287     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
288
289     if (ret || entries == NULL || ((types::InternalType*)entries)->isPoly() == false)
290     {
291         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getComplexHypermatOfPoly");
292         return sciErr;
293     }
294
295     types::Polynom* p = (types::Polynom*)entries;
296
297     if (p->isComplex() == false)
298     {
299         addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), "getComplexHypermatOfPoly");
300         return sciErr;
301     }
302
303     *_dims = p->getDimsArray();
304     *_ndims = p->getDims();
305
306     if (_piNbCoef == NULL)
307     {
308         return sciErr;
309     }
310
311     p->getSizes(_piNbCoef);
312
313     if (_pdblReal == NULL)
314     {
315         return sciErr;
316     }
317
318     int size = p->getSize();
319     types::SinglePoly** s = p->get();
320
321     for (int i = 0; i < size; i++)
322     {
323         memcpy(_pdblReal[i], s[i]->get(), sizeof(double) * s[i]->getSize());
324         memcpy(_pdblImg[i], s[i]->getImg(), sizeof(double) * s[i]->getSize());
325     }
326
327     return sciErr;
328 }
329
330 SciErr getHypermatOfString(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int* _piLength, char** _pstStrings)
331 {
332     SciErr sciErr = sciErrInit();
333     void * entries = NULL;
334
335     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
336
337     if (ret || entries == NULL || ((types::InternalType*)entries)->isString() == false)
338     {
339         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfString");
340         return sciErr;
341     }
342
343     types::String* p = (types::String*)entries;
344     *_dims = p->getDimsArray();
345     *_ndims = p->getDims();
346     int size = p->getSize();
347
348     if (_piLength == NULL)
349     {
350         return sciErr;
351     }
352
353
354     if (_pstStrings == NULL || *_pstStrings == NULL)
355     {
356         wchar_t** s = p->get();
357         for (int i = 0; i < size; i++)
358         {
359             char* c = wide_string_to_UTF8(s[i]);
360             _piLength[i] = (int)strlen(c);
361             FREE(c);
362         }
363     }
364     else
365     {
366         wchar_t** s = p->get();
367         for (int i = 0; i < size; i++)
368         {
369             if (_pstStrings[i] == NULL)
370             {
371                 addErrorMessage(&sciErr, API_ERROR_INVALID_SUBSTRING_POINTER, _("%s: Invalid argument address"), "getHypermatOfString");
372                 return sciErr;
373             }
374
375             char* c = wide_string_to_UTF8(s[i]);
376             strcpy(_pstStrings[i], c);
377             FREE(c);
378         }
379     }
380
381     return sciErr;
382 }
383
384 SciErr getHypermatOfWideString(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int* _piLength, wchar_t** _pwstStrings)
385 {
386     SciErr sciErr = sciErrInit();
387     void * entries = NULL;
388
389     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
390
391     if (ret || entries == NULL || ((types::InternalType*)entries)->isString() == false)
392     {
393         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfWideString");
394         return sciErr;
395     }
396
397     types::String* p = (types::String*)entries;
398     *_dims = p->getDimsArray();
399     *_ndims = p->getDims();
400     int size = p->getSize();
401
402     if (_piLength == NULL)
403     {
404         return sciErr;
405     }
406
407
408     if (_pwstStrings == NULL || *_pwstStrings == NULL)
409     {
410         wchar_t** s = p->get();
411         for (int i = 0; i < size; i++)
412         {
413             _piLength[i] = (int)wcslen(s[i]);
414         }
415     }
416     else
417     {
418         wchar_t** s = p->get();
419         for (int i = 0; i < size; i++)
420         {
421             if (_pwstStrings[i] == NULL)
422             {
423                 addErrorMessage(&sciErr, API_ERROR_INVALID_SUBSTRING_POINTER, _("%s: Invalid argument address"), "getHypermatOfWideString");
424                 return sciErr;
425             }
426
427             wcscpy(_pwstStrings[i], s[i]);
428         }
429     }
430
431     return sciErr;
432 }
433
434 SciErr getHypermatOfInteger8(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, char** _pcData8)
435 {
436     SciErr sciErr = sciErrInit();
437     void * entries = NULL;
438
439     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
440
441     if (ret || entries == NULL || ((types::InternalType*)entries)->isInt8() == false)
442     {
443         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfInteger8");
444         return sciErr;
445     }
446
447     types::Int8* p = (types::Int8*)entries;
448     *_dims = p->getDimsArray();
449     *_ndims = p->getDims();
450     *_pcData8 = p->get();
451     return sciErr;
452 }
453
454 SciErr getHypermatOfUnsignedInteger8(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, unsigned char** _pucData8)
455 {
456     SciErr sciErr = sciErrInit();
457     void * entries = NULL;
458
459     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
460
461     if (ret || entries == NULL || ((types::InternalType*)entries)->isUInt8() == false)
462     {
463         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfUnsignedInteger8");
464         return sciErr;
465     }
466
467     types::UInt8* p = (types::UInt8*)entries;
468     *_dims = p->getDimsArray();
469     *_ndims = p->getDims();
470     *_pucData8 = p->get();
471     return sciErr;
472 }
473
474 SciErr getHypermatOfInteger16(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, short** _psData16)
475 {
476     SciErr sciErr = sciErrInit();
477     void * entries = NULL;
478
479     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
480
481     if (ret || entries == NULL || ((types::InternalType*)entries)->isInt16() == false)
482     {
483         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfInteger16");
484         return sciErr;
485     }
486
487     types::Int16* p = (types::Int16*)entries;
488     *_dims = p->getDimsArray();
489     *_ndims = p->getDims();
490     *_psData16 = p->get();
491     return sciErr;
492 }
493
494 SciErr getHypermatOfUnsignedInteger16(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, unsigned short** _pusData16)
495 {
496     SciErr sciErr = sciErrInit();
497     void * entries = NULL;
498
499     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
500
501     if (ret || entries == NULL || ((types::InternalType*)entries)->isUInt16() == false)
502     {
503         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfUnsignedInteger16");
504         return sciErr;
505     }
506
507     types::UInt16* p = (types::UInt16*)entries;
508     *_dims = p->getDimsArray();
509     *_ndims = p->getDims();
510     *_pusData16 = p->get();
511     return sciErr;
512 }
513
514 SciErr getHypermatOfInteger32(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int** _piData32)
515 {
516     SciErr sciErr = sciErrInit();
517     void * entries = NULL;
518
519     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
520
521     if (ret || entries == NULL || ((types::InternalType*)entries)->isInt32() == false)
522     {
523         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfInteger32");
524         return sciErr;
525     }
526
527     types::Int32* p = (types::Int32*)entries;
528     *_dims = p->getDimsArray();
529     *_ndims = p->getDims();
530     *_piData32 = p->get();
531     return sciErr;
532 }
533
534 SciErr getHypermatOfUnsignedInteger32(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, unsigned int** _puiData32)
535 {
536     SciErr sciErr = sciErrInit();
537     void * entries = NULL;
538
539     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
540
541     if (ret || entries == NULL || ((types::InternalType*)entries)->isUInt32() == false)
542     {
543         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfUnsignedInteger32");
544         return sciErr;
545     }
546
547     types::UInt32* p = (types::UInt32*)entries;
548     *_dims = p->getDimsArray();
549     *_ndims = p->getDims();
550     *_puiData32 = p->get();
551     return sciErr;
552 }
553
554 SciErr getHypermatOfInteger64(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, long long** _pllData64)
555 {
556     SciErr sciErr = sciErrInit();
557     void * entries = NULL;
558
559     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
560
561     if (ret || entries == NULL || ((types::InternalType*)entries)->isInt64() == false)
562     {
563         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfInteger64");
564         return sciErr;
565     }
566
567     types::Int64* p = (types::Int64*)entries;
568     *_dims = p->getDimsArray();
569     *_ndims = p->getDims();
570     *_pllData64 = p->get();
571     return sciErr;
572 }
573
574 SciErr getHypermatOfUnsignedInteger64(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, unsigned long long** _pullData64)
575 {
576     SciErr sciErr = sciErrInit();
577     void * entries = NULL;
578
579     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
580
581     if (ret || entries == NULL || ((types::InternalType*)entries)->isUInt64() == false)
582     {
583         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfUnsignedInteger64");
584         return sciErr;
585     }
586
587     types::UInt64* p = (types::UInt64*)entries;
588     *_dims = p->getDimsArray();
589     *_ndims = p->getDims();
590     *_pullData64 = p->get();
591     return sciErr;
592 }
593
594 SciErr getHypermatOfBoolean(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int** _piBool)
595 {
596     SciErr sciErr = sciErrInit();
597     void * entries = NULL;
598
599     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
600
601     if (ret || entries == NULL || ((types::InternalType*)entries)->isBool() == false)
602     {
603         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfBoolean");
604         return sciErr;
605     }
606
607     types::Bool* p = (types::Bool*)entries;
608     *_dims = p->getDimsArray();
609     *_ndims = p->getDims();
610     *_piBool = p->get();
611     return sciErr;
612 }
613
614 SciErr createHypermatOfString(void *_pvCtx, int _iVar, int * _dims, int _ndims, const char* const* _pstStrings)
615 {
616     SciErr sciErr = sciErrInit();
617     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
618     types::typed_list in = *pStr->m_pIn;
619     types::InternalType** out = pStr->m_pOut;
620     int rhs = _iVar - *getNbInputArgument(_pvCtx);
621
622     types::String* p = new types::String(_ndims, _dims);
623     int size = p->getSize();
624
625     if (size == 0)
626     {
627         delete p;
628         out[rhs - 1] = types::Double::Empty();
629         return sciErr;
630     }
631
632     for (int i = 0; i < size; ++i)
633     {
634         wchar_t* w = to_wide_string(_pstStrings[i]);
635         p->set(i, w);
636         FREE(w);
637     }
638
639     out[rhs - 1] = p;
640     return sciErr;
641 }
642
643 SciErr createHypermatOfPoly(void *_pvCtx, int _iVar, char* _pstVarName, int * _dims, int _ndims, const int* _piNbCoef, const double* const* _pdblReal)
644 {
645     SciErr sciErr = sciErrInit();
646     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
647     types::typed_list in = *pStr->m_pIn;
648     types::InternalType** out = pStr->m_pOut;
649     int rhs = _iVar - *getNbInputArgument(_pvCtx);
650
651     wchar_t* w = to_wide_string(_pstVarName);
652     types::Polynom* p = new types::Polynom(w, _ndims, _dims, _piNbCoef);
653
654     int size = p->getSize();
655     if (size == 0)
656     {
657         delete p;
658         out[rhs - 1] = types::Double::Empty();
659         FREE(w);
660         return sciErr;
661     }
662
663     types::SinglePoly** s = p->get();
664
665     for (int i = 0; i < size; ++i)
666     {
667         s[i]->setCoef(_pdblReal[i], NULL);
668     }
669
670     out[rhs - 1] = p;
671     FREE(w);
672     return sciErr;
673 }
674
675 SciErr createComplexHypermatOfPoly(void *_pvCtx, int _iVar, char* _pstVarName, int * _dims, int _ndims, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
676 {
677     SciErr sciErr = sciErrInit();
678     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
679     types::typed_list in = *pStr->m_pIn;
680     types::InternalType** out = pStr->m_pOut;
681     int rhs = _iVar - *getNbInputArgument(_pvCtx);
682
683     wchar_t* w = to_wide_string(_pstVarName);
684     types::Polynom* p = new types::Polynom(w, _ndims, _dims, _piNbCoef);
685     p->setComplex(true);
686
687     int size = p->getSize();
688     if (size == 0)
689     {
690         delete p;
691         out[rhs - 1] = types::Double::Empty();
692         FREE(w);
693         return sciErr;
694     }
695
696     types::SinglePoly** s = p->get();
697
698     for (int i = 0; i < size; ++i)
699     {
700         s[i]->setCoef(_pdblReal[i], _pdblImg[i]);
701     }
702
703     out[rhs - 1] = p;
704     FREE(w);
705     return sciErr;
706 }
707
708 SciErr allocHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, double** _pdblReal)
709 {
710     SciErr sciErr = sciErrInit();
711     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
712     types::typed_list in = *pStr->m_pIn;
713     types::InternalType** out = pStr->m_pOut;
714     int rhs = _iVar - *getNbInputArgument(_pvCtx);
715
716     types::Double* p = new types::Double(_ndims, _dims);
717
718     int size = p->getSize();
719     if (size == 0)
720     {
721         delete p;
722         out[rhs - 1] = types::Double::Empty();
723         return sciErr;
724     }
725
726     *_pdblReal = p->get();
727     out[rhs - 1] = p;
728     return sciErr;
729 }
730
731 SciErr createHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, const double * _pdblReal)
732 {
733     SciErr sciErr = sciErrInit();
734     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
735     types::typed_list in = *pStr->m_pIn;
736     types::InternalType** out = pStr->m_pOut;
737     int rhs = _iVar - *getNbInputArgument(_pvCtx);
738
739     types::Double* p = new types::Double(_ndims, _dims);
740
741     int size = p->getSize();
742     if (size == 0)
743     {
744         delete p;
745         out[rhs - 1] = types::Double::Empty();
746         return sciErr;
747     }
748
749     p->set(_pdblReal);
750     out[rhs - 1] = p;
751     return sciErr;
752 }
753
754 SciErr createComplexHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, const double * _pdblReal, const double * _pdblImg)
755 {
756     SciErr sciErr = sciErrInit();
757     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
758     types::typed_list in = *pStr->m_pIn;
759     types::InternalType** out = pStr->m_pOut;
760     int rhs = _iVar - *getNbInputArgument(_pvCtx);
761
762     types::Double* p = new types::Double(_ndims, _dims, true);
763
764     int size = p->getSize();
765     if (size == 0)
766     {
767         delete p;
768         out[rhs - 1] = types::Double::Empty();
769         return sciErr;
770     }
771
772     p->set(_pdblReal);
773     p->setImg(_pdblImg);
774     out[rhs - 1] = p;
775     return sciErr;
776 }
777
778 SciErr createHypermatOfBoolean(void *_pvCtx, int _iVar, int * _dims, int _ndims, const int * _piBool)
779 {
780     SciErr sciErr = sciErrInit();
781     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
782     types::typed_list in = *pStr->m_pIn;
783     types::InternalType** out = pStr->m_pOut;
784     int rhs = _iVar - *getNbInputArgument(_pvCtx);
785
786     types::Bool* p = new types::Bool(_ndims, _dims);
787
788     int size = p->getSize();
789     if (size == 0)
790     {
791         delete p;
792         out[rhs - 1] = types::Double::Empty();
793         return sciErr;
794     }
795
796     p->set(_piBool);
797     out[rhs - 1] = p;
798     return sciErr;
799 }
800
801 SciErr createHypermatOfInteger8(void *_pvCtx, int _iVar, int * _dims, int _ndims, const char * _pcData8)
802 {
803     SciErr sciErr = sciErrInit();
804     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
805     types::typed_list in = *pStr->m_pIn;
806     types::InternalType** out = pStr->m_pOut;
807     int rhs = _iVar - *getNbInputArgument(_pvCtx);
808
809     types::Int8* p = new types::Int8(_ndims, _dims);
810
811     int size = p->getSize();
812     if (size == 0)
813     {
814         delete p;
815         out[rhs - 1] = types::Double::Empty();
816         return sciErr;
817     }
818
819     p->set(_pcData8);
820     out[rhs - 1] = p;
821     return sciErr;
822 }
823
824 SciErr createHypermatOfUnsignedInteger8(void *_pvCtx, int _iVar, int * _dims, int _ndims, const unsigned char * _pucData8)
825 {
826     SciErr sciErr = sciErrInit();
827     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
828     types::typed_list in = *pStr->m_pIn;
829     types::InternalType** out = pStr->m_pOut;
830     int rhs = _iVar - *getNbInputArgument(_pvCtx);
831
832     types::UInt8* p = new types::UInt8(_ndims, _dims);
833
834     int size = p->getSize();
835     if (size == 0)
836     {
837         delete p;
838         out[rhs - 1] = types::Double::Empty();
839         return sciErr;
840     }
841
842     p->set(_pucData8);
843     out[rhs - 1] = p;
844     return sciErr;
845 }
846
847 SciErr createHypermatOfInteger16(void *_pvCtx, int _iVar, int * _dims, int _ndims, const short * _psData16)
848 {
849     SciErr sciErr = sciErrInit();
850     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
851     types::typed_list in = *pStr->m_pIn;
852     types::InternalType** out = pStr->m_pOut;
853     int rhs = _iVar - *getNbInputArgument(_pvCtx);
854
855     types::Int16* p = new types::Int16(_ndims, _dims);
856
857     int size = p->getSize();
858     if (size == 0)
859     {
860         delete p;
861         out[rhs - 1] = types::Double::Empty();
862         return sciErr;
863     }
864
865     p->set(_psData16);
866     out[rhs - 1] = p;
867     return sciErr;
868 }
869
870 SciErr createHypermatOfUnsignedInteger16(void *_pvCtx, int _iVar, int * _dims, int _ndims, const unsigned short * _pusData16)
871 {
872     SciErr sciErr = sciErrInit();
873     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
874     types::typed_list in = *pStr->m_pIn;
875     types::InternalType** out = pStr->m_pOut;
876     int rhs = _iVar - *getNbInputArgument(_pvCtx);
877
878     types::UInt16* p = new types::UInt16(_ndims, _dims);
879
880     int size = p->getSize();
881     if (size == 0)
882     {
883         delete p;
884         out[rhs - 1] = types::Double::Empty();
885         return sciErr;
886     }
887
888     p->set(_pusData16);
889     out[rhs - 1] = p;
890     return sciErr;
891 }
892
893 SciErr createHypermatOfInteger32(void *_pvCtx, int _iVar, int * _dims, int _ndims, const int * _piData32)
894 {
895     SciErr sciErr = sciErrInit();
896     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
897     types::typed_list in = *pStr->m_pIn;
898     types::InternalType** out = pStr->m_pOut;
899     int rhs = _iVar - *getNbInputArgument(_pvCtx);
900
901     types::Int32* p = new types::Int32(_ndims, _dims);
902
903     int size = p->getSize();
904     if (size == 0)
905     {
906         delete p;
907         out[rhs - 1] = types::Double::Empty();
908         return sciErr;
909     }
910
911     p->set(_piData32);
912     out[rhs - 1] = p;
913     return sciErr;
914 }
915
916 SciErr createHypermatOfUnsignedInteger32(void *_pvCtx, int _iVar, int * _dims, int _ndims, const unsigned int * _puiData32)
917 {
918     SciErr sciErr = sciErrInit();
919     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
920     types::typed_list in = *pStr->m_pIn;
921     types::InternalType** out = pStr->m_pOut;
922     int rhs = _iVar - *getNbInputArgument(_pvCtx);
923
924     types::UInt32* p = new types::UInt32(_ndims, _dims);
925
926     int size = p->getSize();
927     if (size == 0)
928     {
929         delete p;
930         out[rhs - 1] = types::Double::Empty();
931         return sciErr;
932     }
933
934     p->set(_puiData32);
935     out[rhs - 1] = p;
936     return sciErr;
937 }
938
939 SciErr createHypermatOfInteger64(void *_pvCtx, int _iVar, int * _dims, int _ndims, const long long* _pllData64)
940 {
941     SciErr sciErr = sciErrInit();
942     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
943     types::typed_list in = *pStr->m_pIn;
944     types::InternalType** out = pStr->m_pOut;
945     int rhs = _iVar - *getNbInputArgument(_pvCtx);
946
947     types::Int64* p = new types::Int64(_ndims, _dims);
948
949     int size = p->getSize();
950     if (size == 0)
951     {
952         delete p;
953         out[rhs - 1] = types::Double::Empty();
954         return sciErr;
955     }
956
957     p->set(_pllData64);
958     out[rhs - 1] = p;
959     return sciErr;
960 }
961
962 SciErr createHypermatOfUnsignedInteger64(void *_pvCtx, int _iVar, int * _dims, int _ndims, const unsigned long long* _pullData64)
963 {
964     SciErr sciErr = sciErrInit();
965     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
966     types::typed_list in = *pStr->m_pIn;
967     types::InternalType** out = pStr->m_pOut;
968     int rhs = _iVar - *getNbInputArgument(_pvCtx);
969
970     types::UInt64* p = new types::UInt64(_ndims, _dims);
971
972     int size = p->getSize();
973     if (size == 0)
974     {
975         delete p;
976         out[rhs - 1] = types::Double::Empty();
977         return sciErr;
978     }
979
980     p->set(_pullData64);
981     out[rhs - 1] = p;
982     return sciErr;
983 }