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