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