License Header change: Removed the LICENSE_END before beta
[scilab.git] / scilab / modules / ast / src / cpp / types / implicitlist.cpp
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4 *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 *
14 */
15 #include <sstream>
16 #include <math.h>
17 #include "double.hxx"
18 #include "polynom.hxx"
19 #include "implicitlist.hxx"
20 #include "int.hxx"
21 #include "configvariable.hxx"
22 #include "scilabWrite.hxx"
23 #include "type_traits.hxx"
24 #include "types_tools.hxx"
25 #include "numericconstants.hxx"
26 #include "doubleexp.hxx"
27
28 #ifndef NDEBUG
29 #include "inspector.hxx"
30 #endif
31
32 #include "tostring_common.hxx"
33
34 extern "C"
35 {
36 #include "core_math.h"
37 #include "elem_common.h"
38 #include "finite.h"
39 }
40
41 std::wstring printInLinePoly(types::SinglePoly* _pPoly, std::wstring _stVar);
42 std::wstring printDouble(types::Double* _pD);
43 long long convert_input(types::InternalType* _poIT);
44 unsigned long long convert_unsigned_input(types::InternalType* _poIT);
45
46 namespace types
47 {
48 ImplicitList::~ImplicitList()
49 {
50     if (isDeletable() == true)
51     {
52         if (m_poStart)
53         {
54             m_poStart->DecreaseRef();
55             m_poStart->killMe();
56         }
57
58         if (m_poStep)
59         {
60             m_poStep->DecreaseRef();
61             m_poStep->killMe();
62         }
63
64         if (m_poEnd)
65         {
66             m_poEnd->DecreaseRef();
67             m_poEnd->killMe();
68         }
69     }
70 #ifndef NDEBUG
71     Inspector::removeItem(this);
72 #endif
73 }
74
75 ImplicitList::ImplicitList()
76 {
77     m_iSize     = -1;
78     m_eOutType  = ScilabGeneric;
79     m_bComputed = false;
80     m_poStart   = NULL;
81     m_poStep    = NULL;
82     m_poEnd     = NULL;
83     m_pDblStart = NULL;
84     m_pDblStep  = NULL;
85     m_pDblEnd   = NULL;
86
87 #ifndef NDEBUG
88     Inspector::addItem(this);
89 #endif
90 }
91
92 ImplicitList::ImplicitList(InternalType* _poStart, InternalType* _poStep, InternalType* _poEnd)
93 {
94     m_iSize     = -1;
95     m_eOutType  = ScilabGeneric;
96     m_bComputed = false;
97     m_poStart   = NULL;
98     m_poStep    = NULL;
99     m_poEnd     = NULL;
100     m_pDblStart = NULL;
101     m_pDblStep  = NULL;
102     m_pDblEnd   = NULL;
103
104     setStart(_poStart);
105     setStep(_poStep);
106     setEnd(_poEnd);
107     compute();
108 #ifndef NDEBUG
109     Inspector::addItem(this);
110 #endif
111 }
112
113 ImplicitList* ImplicitList::clone()
114 {
115     return new ImplicitList(m_poStart, m_poStep, m_poEnd);
116 }
117
118 InternalType::ScilabType ImplicitList::getStartType()
119 {
120     return m_poStart->getType();
121 }
122
123 InternalType::ScilabType ImplicitList::getStepType()
124 {
125     return m_poStep->getType();
126 }
127
128 InternalType::ScilabType ImplicitList::getEndType()
129 {
130     return m_poEnd->getType();
131 }
132
133 void ImplicitList::setStart(InternalType *_poIT)
134 {
135     if (m_poStart)
136     {
137         //clear previous value
138         m_poStart->DecreaseRef();
139         m_poStart->killMe();
140         m_poStart = NULL;
141     }
142
143     m_poStart = _poIT;
144     if (m_poStart != NULL)
145     {
146         m_poStart->IncreaseRef();
147         m_eStartType = m_poStart->getType();
148     }
149     m_bComputed = false;
150 }
151
152 void ImplicitList::setStep(InternalType *_poIT)
153 {
154     if (m_poStep)
155     {
156         //clear previous value
157         m_poStep->DecreaseRef();
158         m_poStep->killMe();
159         m_poStep = NULL;
160     }
161
162     m_poStep = _poIT;
163     if (m_poStep != NULL)
164     {
165         m_poStep->IncreaseRef();
166         m_eStepType = m_poStep->getType();
167     }
168     m_bComputed = false;
169 }
170
171 void ImplicitList::setEnd(InternalType* _poIT)
172 {
173     if (m_poEnd)
174     {
175         //clear previous value
176         m_poEnd->DecreaseRef();
177         m_poEnd->killMe();
178         m_poEnd = NULL;
179     }
180
181     m_poEnd = _poIT;
182     if (m_poEnd != NULL)
183     {
184         m_poEnd->IncreaseRef();
185         m_eEndType = m_poEnd->getType();
186     }
187     m_bComputed = false;
188 }
189
190 bool ImplicitList::compute()
191 {
192     if (m_bComputed == true)
193     {
194         return true;
195     }
196
197     m_iSize = -1;
198     if (isComputable() == true)
199     {
200         m_iSize = 0;
201         if (m_eOutType == ScilabDouble)
202         {
203             m_pDblStart = m_poStart->getAs<Double>();
204             double dblStart     = m_pDblStart->get(0);
205
206             m_pDblStep = m_poStep->getAs<Double>();
207             double dblStep      = m_pDblStep->get(0);
208
209             m_pDblEnd = m_poEnd->getAs<Double>();
210             double dblEnd       = m_pDblEnd->get(0);
211             // othe way to compute
212
213             // nan value
214             if (ISNAN(dblStart) || ISNAN(dblStep) || ISNAN(dblEnd))
215             {
216                 m_iSize = -1;
217                 m_bComputed = true;
218                 return true;
219             }
220
221             // no finite values
222             if ( finite(dblStart) == 0 || finite(dblStep) == 0 || finite(dblEnd) == 0)
223             {
224                 if ((dblStep > 0 && dblStart < dblEnd) ||
225                         (dblStep < 0 && dblStart > dblEnd))
226                 {
227                     // return nan
228                     m_iSize = -1;
229                 }
230                 // else return []
231
232                 m_bComputed = true;
233                 return true;
234             }
235
236             // step null
237             if (dblStep == 0) // return []
238             {
239                 m_bComputed = true;
240                 return true;
241             }
242
243             double dblVal = dblStart; // temp value
244             double dblEps = NumericConstants::eps;
245             double dblPrec = 2 * std::max(fabs(dblStart), fabs(dblEnd)) * dblEps;
246
247             while (dblStep * (dblVal - dblEnd) <= 0)
248             {
249                 m_iSize++;
250                 dblVal = dblStart + m_iSize * dblStep;
251             }
252
253             if (fabs(dblVal - dblEnd) < dblPrec)
254             {
255                 m_iSize++;
256             }
257         }
258         else //m_eOutType == ScilabInt
259         {
260             if (m_eOutType == ScilabInt8 ||
261                     m_eOutType == ScilabInt16 ||
262                     m_eOutType == ScilabInt32 ||
263                     m_eOutType == ScilabInt64)
264             {
265                 //signed
266                 long long llStart   = convert_input(m_poStart);
267                 long long llStep    = convert_input(m_poStep);
268                 long long llEnd     = convert_input(m_poEnd);
269
270 #ifdef _MSC_VER
271                 m_iSize = static_cast<int>(floor( static_cast<double>(_abs64(llEnd - llStart) / _abs64(llStep)) )) + 1;
272 #else
273                 m_iSize = static_cast<int>(floor( static_cast<double>(llabs(llEnd - llStart) / llabs(llStep)) )) + 1;
274 #endif
275             }
276             else
277             {
278                 //unsigned
279                 unsigned long long ullStart = convert_unsigned_input(m_poStart);
280                 unsigned long long ullStep      = convert_unsigned_input(m_poStep);
281                 unsigned long long ullEnd   = convert_unsigned_input(m_poEnd);
282
283 #ifdef _MSC_VER
284                 m_iSize = static_cast<int>(floor(static_cast<double>(_abs64(ullEnd - ullStart) / _abs64(ullStep)) )) + 1;
285 #else
286                 m_iSize = static_cast<int>(floor(static_cast<double>(llabs(ullEnd - ullStart) / llabs(ullStep)) )) + 1;
287 #endif
288             }
289         }
290         m_bComputed = true;
291         return true;
292     }
293     else
294     {
295         return false;
296     }
297 }
298
299 bool ImplicitList::isComputable()
300 {
301     if (m_eStartType != ScilabDouble && m_poStart->isInt() == false)
302     {
303         return false;
304     }
305
306     if (m_eStepType != ScilabDouble && m_poStep->isInt() == false)
307     {
308         return false;
309     }
310
311     if (m_eEndType != ScilabDouble && m_poEnd->isInt() == false)
312     {
313         return false;
314     }
315
316     //"compute" output type
317     m_eOutType = ScilabGeneric; //not defined type
318     if (m_poStart->isInt())
319     {
320         m_eOutType  = m_poStart->getType();
321     }
322     else if (m_poStep->isInt())
323     {
324         m_eOutType  = m_poStep->getType();
325     }
326     else if (m_poEnd->isInt())
327     {
328         m_eOutType  = m_poEnd->getType();
329     }
330     else
331     {
332         m_eOutType  = ScilabDouble;
333     }
334
335     return true;
336 }
337
338 bool ImplicitList::toString(std::wostringstream& ostr)
339 {
340     ostr << L" ";
341     if (m_eStartType == ScilabDouble)
342     {
343         Double *pD = m_poStart->getAs<Double>();
344         ostr << printDouble(pD);
345     }
346     else //Polynom
347     {
348         Polynom* pMP = m_poStart->getAs<types::Polynom>();
349         ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
350     }
351
352     ostr << L":";
353
354     if (m_eStepType == ScilabDouble)
355     {
356         Double *pD = m_poStep->getAs<Double>();
357         ostr << printDouble(pD);
358     }
359     else //Polynom
360     {
361         Polynom* pMP = m_poStep->getAs<types::Polynom>();
362         ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
363     }
364
365     ostr << L":";
366
367     if (m_eEndType == ScilabDouble)
368     {
369         Double *pD = m_poEnd->getAs<Double>();
370         ostr << printDouble(pD);
371     }
372     else //Polynom
373     {
374         Polynom* pMP = m_poEnd->getAs<types::Polynom>();
375         ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
376     }
377     ostr << std::endl;
378     return true;
379 }
380
381 InternalType::ScilabType ImplicitList::getOutputType()
382 {
383     return m_eOutType;
384 }
385
386 void ImplicitList::extractValueAsDouble(int _iOccur, Double* d)
387 {
388     double dblStart = m_pDblStart->get(0);
389     double dblStep = m_pDblStep->get(0);
390     d->get()[0] = dblStart + _iOccur * dblStep;
391 }
392
393 template<typename T>
394 void ImplicitList::extractValueAsInteger(int _iOccur, T* val)
395 {
396
397     val->get()[0] = static_cast<typename T::type>(convert_input(m_poStart)) +
398                     _iOccur * static_cast<typename T::type>(convert_input(m_poStep));
399 }
400
401 template<typename T>
402 void ImplicitList::extractValueAsUnsignedInteger(int _iOccur, T* val)
403 {
404     val->get()[0] = static_cast<typename T::type>(convert_unsigned_input(m_poStart)) +
405                     _iOccur * static_cast<typename T::type>(convert_unsigned_input(m_poStep));
406 }
407
408 InternalType* ImplicitList::getInitalType()
409 {
410     if (compute())
411     {
412         int iDims = 2;
413         int piDms[2] = {1, 1};
414         switch (m_eOutType)
415         {
416             case ScilabDouble:
417                 return new Double(iDims, piDms);
418             case ScilabInt8:
419                 return new Int8(iDims, piDms);
420             case ScilabInt16:
421                 return new Int16(iDims, piDms);
422             case ScilabInt32:
423                 return new Int32(iDims, piDms);
424             case ScilabInt64:
425                 return new Int64(iDims, piDms);
426             case ScilabUInt8:
427                 return new UInt8(iDims, piDms);
428             case ScilabUInt16:
429                 return new UInt16(iDims, piDms);
430             case ScilabUInt32:
431                 return new UInt32(iDims, piDms);
432             case ScilabUInt64:
433                 return new UInt64(iDims, piDms);
434         }
435     }
436
437     return nullptr;
438 }
439
440 //extract single value in a InternalType
441 void ImplicitList::extractValue(int _iOccur, InternalType* pIT)
442 {
443     if (pIT == nullptr)
444     {
445         return;
446     }
447
448     if (compute())
449     {
450         switch (m_eOutType)
451         {
452             case ScilabInt8:
453                 extractValueAsInteger(_iOccur, pIT->getAs<Int8>());
454                 break;
455             case ScilabInt16:
456                 extractValueAsInteger(_iOccur, pIT->getAs<Int16>());
457                 break;
458             case ScilabInt32:
459                 extractValueAsInteger(_iOccur, pIT->getAs<Int32>());
460                 break;
461             case ScilabInt64:
462                 extractValueAsInteger(_iOccur, pIT->getAs<Int64>());
463                 break;
464             case ScilabUInt8:
465                 extractValueAsUnsignedInteger(_iOccur, pIT->getAs<UInt8>());
466                 break;
467             case ScilabUInt16:
468                 extractValueAsUnsignedInteger(_iOccur, pIT->getAs<UInt16>());
469                 break;
470             case ScilabUInt32:
471                 extractValueAsUnsignedInteger(_iOccur, pIT->getAs<UInt32>());
472                 break;
473             case ScilabUInt64:
474                 extractValueAsUnsignedInteger(_iOccur, pIT->getAs<UInt64>());
475                 break;
476             case ScilabDouble:
477                 extractValueAsDouble(_iOccur, pIT->getAs<Double>());
478                 break;
479         }
480     }
481 }
482
483 //extract matrix in a Internaltype
484 InternalType* ImplicitList::extractFullMatrix()
485 {
486     InternalType* pIT = NULL;
487     if (compute())
488     {
489         if (getSize() == 0) // return []
490         {
491             pIT = Double::Empty();
492         }
493         else if (getSize() == -1) // return nan
494         {
495             unsigned long long raw = 0x7ff8000000000000;
496             double not_a_number = *( double* )&raw;
497             pIT = new Double(not_a_number);
498         }
499         else if (m_eOutType == ScilabDouble)
500         {
501             pIT = new Double(1, m_iSize);
502             extractFullMatrix(pIT->getAs<Double>());
503         }
504         else if (m_eOutType == ScilabInt8)
505         {
506             pIT = new Int8(1, m_iSize);
507             extractFullMatrix(pIT->getAs<Int8>());
508         }
509         else if (m_eOutType == ScilabUInt8)
510         {
511             pIT = new UInt8(1, m_iSize);
512             extractFullMatrix(pIT->getAs<UInt8>());
513         }
514         else if (m_eOutType == ScilabInt16)
515         {
516             pIT = new Int16(1, m_iSize);
517             extractFullMatrix(pIT->getAs<Int16>());
518         }
519         else if (m_eOutType == ScilabUInt16)
520         {
521             pIT = new UInt16(1, m_iSize);
522             extractFullMatrix(pIT->getAs<UInt16>());
523         }
524         else if (m_eOutType == ScilabInt32)
525         {
526             pIT = new Int32(1, m_iSize);
527             extractFullMatrix(pIT->getAs<Int32>());
528         }
529         else if (m_eOutType == ScilabUInt32)
530         {
531             pIT = new UInt32(1, m_iSize);
532             extractFullMatrix(pIT->getAs<UInt32>());
533         }
534         else if (m_eOutType == ScilabInt64)
535         {
536             pIT = new Int64(1, m_iSize);
537             extractFullMatrix(pIT->getAs<Int64>());
538         }
539         else if (m_eOutType == ScilabUInt64)
540         {
541             pIT = new UInt64(1, m_iSize);
542             extractFullMatrix(pIT->getAs<UInt64>());
543         }
544     }
545     return pIT;
546 }
547
548 void ImplicitList::extractFullMatrix(Double *_p)
549 {
550     double dblStart = m_poStart->getAs<Double>()->get(0);
551     double dblStep  = m_poStep->getAs<Double>()->get(0);
552
553     double* p = _p->get();
554     for (int i = 0 ; i < m_iSize ; i++)
555     {
556         p[i] = dblStart + i * dblStep;
557     }
558 }
559
560 template<typename T>
561 void ImplicitList::extractFullMatrix(T *_pT)
562 {
563     typename T::type tStart = static_cast<typename T::type>(convert_input(m_poStart));
564     typename T::type tStep = static_cast<typename T::type>(convert_input(m_poStep));
565
566     typename T::type* p = _pT->get();
567     for (int i = 0 ; i < m_iSize ; i++)
568     {
569         p[i] = tStart + i * tStep;
570     }
571 }
572
573 bool ImplicitList::transpose(InternalType *& out)
574 {
575     if (compute())
576     {
577         Double * pIT = new Double(m_iSize, 1);
578         out = pIT;
579         extractFullMatrix(pIT);
580
581         return true;
582     }
583
584     return false;
585 }
586
587 bool ImplicitList::neg(InternalType *& out)
588 {
589     if (compute() && m_poStart->isDouble() && m_poStep->isDouble() && m_poEnd->isDouble())
590     {
591         out = new Bool(1, m_iSize);
592         type_traits::neg(m_poStart->getAs<Double>()->get(0), m_poStep->getAs<Double>()->get(0), m_poEnd->getAs<Double>()->get(0), static_cast<Bool *>(out)->get());
593
594         return true;
595     }
596
597     return false;
598 }
599
600 bool ImplicitList::invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & e)
601 {
602     if (in.size() == 0)
603     {
604         out.push_back(this);
605     }
606     else
607     {
608         InternalType * _out = extract(&in);
609         if (!_out)
610         {
611             std::wostringstream os;
612             os << _W("Invalid index.\n");
613             throw ast::InternalError(os.str(), 999, e.getLocation());
614         }
615         out.push_back(_out);
616     }
617
618     return true;
619 }
620
621 InternalType* ImplicitList::extract(typed_list* _pArgs)
622 {
623     int iDims = (int)_pArgs->size();
624     typed_list pArg;
625     InternalType* pOut = NULL;
626     int index = 0;
627
628     int* piMaxDim = new int[iDims];
629     int* piCountDim = new int[iDims];
630
631     //evaluate each argument and replace by appropriate value and compute the count of combinations
632     int iSeqCount = checkIndexesArguments(this, _pArgs, &pArg, piMaxDim, piCountDim);
633     if (iSeqCount == 0)
634     {
635         //free pArg content
636         cleanIndexesArguments(_pArgs, &pArg);
637         return createEmptyDouble();
638     }
639
640     if (iDims == 1 && iSeqCount == 1)
641     {
642         if (piMaxDim[0] > 0 && piMaxDim[0] <= 3)
643         {
644             //standard case a(1)
645             Double* pDbl = pArg[0]->getAs<Double>();
646             index = (int)pDbl->get()[0] - 1;
647         }
648         else
649         {
650             index = 0;
651         }
652     }
653     else
654     {
655         int* piDims = new int[iDims];
656         for (int i = 0 ; i < iDims ; i++)
657         {
658             piDims[i] = 1;
659         }
660
661         for (int i = 0 ; i < iSeqCount ; i++)
662         {
663             int* pIndex = new int[iDims];
664             for (int j = 0 ; j < iDims ; j++)
665             {
666                 Double* pDbl = pArg[j]->getAs<Double>();
667                 pIndex[j] = (int)pDbl->get()[i] - 1;
668             }
669
670             index = getIndexWithDims(pIndex, piDims, iDims);
671         }
672     }
673
674     switch (index)
675     {
676         case 0 :
677             pOut = getStart();
678             break;
679         case 1 :
680             pOut = getStep();
681             break;
682         case 2 :
683             pOut = getEnd();
684             break;
685         default :
686             pOut = NULL;
687             break;
688     }
689
690     //free pArg content
691     cleanIndexesArguments(_pArgs, &pArg);
692
693     delete[] piMaxDim;
694     delete[] piCountDim;
695     return pOut;
696 }
697
698 ast::Exp * ImplicitList::getExp(const Location & loc)
699 {
700     return new ast::DoubleExp(loc, this);
701 }
702
703 bool ImplicitList::isTrue()
704 {
705     // TODO : manage int & co
706     if (m_poStart->isDouble() && m_poStep->isDouble() && m_poEnd->isDouble())
707     {
708         return type_traits::isTrue(m_poStart->getAs<Double>()->get(0), m_poStep->getAs<Double>()->get(0), m_poEnd->getAs<Double>()->get(0));
709     }
710
711     return false;
712 }
713
714 }
715
716 std::wstring printInLinePoly(types::SinglePoly* _pPoly, std::wstring _stVar)
717 {
718     std::wostringstream ostr;
719     double* pdblIn = _pPoly->get();
720     for (int i = 0 ; i < _pPoly->getSize() ; i++)
721     {
722
723         if (pdblIn[i] != 0)
724         {
725             DoubleFormat df;
726             getDoubleFormat(pdblIn[i], &df);
727             df.bPrintPoint = ostr.str().size() != 0;
728             df.bPrintPlusSign = true;
729             df.bPrintOne = i == 0;
730             df.bPaddSign = false;
731             df.bPrintBlank = false;
732             df.bPrintPlusSign = false;
733
734             addDoubleValue(&ostr, pdblIn[i], &df);
735             if (i != 0)
736             {
737                 ostr << _stVar;
738                 if (i > 1)
739                 {
740                     ostr << "^" << i;
741                 }
742             }
743         }
744     }
745     return ostr.str();
746 }
747
748 std::wstring printDouble(types::Double* _pD)
749 {
750     std::wostringstream ostr;
751     DoubleFormat df;
752     getDoubleFormat(_pD->get(0), &df);
753     df.bPrintPoint = false;
754     df.bPaddSign = true;
755     df.bPaddSign = false;
756     df.bPrintBlank = false;
757     addDoubleValue(&ostr, _pD->get(0), &df);
758     return ostr.str();
759 }
760
761 long long convert_input(types::InternalType* _poIT)
762 {
763     switch (_poIT->getType())
764     {
765         case types::InternalType::ScilabDouble:
766             return static_cast<long long>(_poIT->getAs<types::Double>()->get(0));
767         case types::InternalType::ScilabInt8:
768             return static_cast<long long>(_poIT->getAs<types::Int8>()->get(0));
769         case types::InternalType::ScilabUInt8:
770             return static_cast<long long>(_poIT->getAs<types::UInt8>()->get(0));
771         case types::InternalType::ScilabInt16:
772             return static_cast<long long>(_poIT->getAs<types::Int16>()->get(0));
773         case types::InternalType::ScilabUInt16:
774             return static_cast<long long>(_poIT->getAs<types::UInt16>()->get(0));
775         case types::InternalType::ScilabInt32:
776             return static_cast<long long>(_poIT->getAs<types::Int32>()->get(0));
777         case types::InternalType::ScilabUInt32:
778             return static_cast<long long>(_poIT->getAs<types::UInt32>()->get(0));
779         case types::InternalType::ScilabInt64:
780             return static_cast<long long>(_poIT->getAs<types::Int64>()->get(0));
781         case types::InternalType::ScilabUInt64:
782             return static_cast<long long>(_poIT->getAs<types::UInt64>()->get(0));
783         default:
784             return 0;
785     }
786     return 0;
787 }
788
789 unsigned long long convert_unsigned_input(types::InternalType* _poIT)
790 {
791     switch (_poIT->getType())
792     {
793         case types::InternalType::ScilabDouble:
794             return static_cast<unsigned long long>(_poIT->getAs<types::Double>()->get(0));
795         case types::InternalType::ScilabInt8:
796             return static_cast<unsigned long long>(_poIT->getAs<types::Int8>()->get(0));
797         case types::InternalType::ScilabUInt8:
798             return static_cast<unsigned long long>(_poIT->getAs<types::UInt8>()->get(0));
799         case types::InternalType::ScilabInt16:
800             return static_cast<unsigned long long>(_poIT->getAs<types::Int16>()->get(0));
801         case types::InternalType::ScilabUInt16:
802             return static_cast<unsigned long long>(_poIT->getAs<types::UInt16>()->get(0));
803         case types::InternalType::ScilabInt32:
804             return static_cast<unsigned long long>(_poIT->getAs<types::Int32>()->get(0));
805         case types::InternalType::ScilabUInt32:
806             return static_cast<unsigned long long>(_poIT->getAs<types::UInt32>()->get(0));
807         case types::InternalType::ScilabInt64:
808             return static_cast<unsigned long long>(_poIT->getAs<types::Int64>()->get(0));
809         case types::InternalType::ScilabUInt64:
810             return static_cast<unsigned long long>(_poIT->getAs<types::UInt64>()->get(0));
811         default:
812             return 0;
813     }
814     return 0;
815 }