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