467283d93127eb15df360e91556db0e65b3468ae
[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 #ifdef _MSC_VER
274                 m_iSize = static_cast<int>(floor( static_cast<double>(_abs64(llEnd - llStart) / _abs64(llStep)) )) + 1;
275 #else
276                 m_iSize = static_cast<int>(floor( static_cast<double>(llabs(llEnd - llStart) / llabs(llStep)) )) + 1;
277 #endif
278             }
279             else
280             {
281                 //unsigned
282                 unsigned long long ullStart = convert_unsigned_input(m_poStart);
283                 unsigned long long ullStep      = convert_unsigned_input(m_poStep);
284                 unsigned long long ullEnd   = convert_unsigned_input(m_poEnd);
285
286 #ifdef _MSC_VER
287                 m_iSize = static_cast<int>(floor(static_cast<double>(_abs64(ullEnd - ullStart) / _abs64(ullStep)) )) + 1;
288 #else
289                 m_iSize = static_cast<int>(floor(static_cast<double>(llabs(ullEnd - ullStart) / llabs(ullStep)) )) + 1;
290 #endif
291             }
292         }
293         m_bComputed = true;
294         return true;
295     }
296     else
297     {
298         return false;
299     }
300 }
301
302 bool ImplicitList::isComputable()
303 {
304     if (m_eStartType != ScilabDouble && m_poStart->isInt() == false)
305     {
306         return false;
307     }
308
309     if (m_eStepType != ScilabDouble && m_poStep->isInt() == false)
310     {
311         return false;
312     }
313
314     if (m_eEndType != ScilabDouble && m_poEnd->isInt() == false)
315     {
316         return false;
317     }
318
319     //"compute" output type
320     m_eOutType = ScilabGeneric; //not defined type
321     if (m_poStart->isInt())
322     {
323         m_eOutType  = m_poStart->getType();
324     }
325     else if (m_poStep->isInt())
326     {
327         m_eOutType  = m_poStep->getType();
328     }
329     else if (m_poEnd->isInt())
330     {
331         m_eOutType  = m_poEnd->getType();
332     }
333     else
334     {
335         m_eOutType  = ScilabDouble;
336     }
337
338     return true;
339 }
340
341 bool ImplicitList::toString(std::wostringstream& ostr)
342 {
343     ostr << L" ";
344     if (m_eStartType == ScilabDouble)
345     {
346         Double *pD = m_poStart->getAs<Double>();
347         ostr << printDouble(pD);
348     }
349     else //Polynom
350     {
351         Polynom* pMP = m_poStart->getAs<types::Polynom>();
352         ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
353     }
354
355     ostr << L":";
356
357     if (m_eStepType == ScilabDouble)
358     {
359         Double *pD = m_poStep->getAs<Double>();
360         ostr << printDouble(pD);
361     }
362     else //Polynom
363     {
364         Polynom* pMP = m_poStep->getAs<types::Polynom>();
365         ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
366     }
367
368     ostr << L":";
369
370     if (m_eEndType == ScilabDouble)
371     {
372         Double *pD = m_poEnd->getAs<Double>();
373         ostr << printDouble(pD);
374     }
375     else //Polynom
376     {
377         Polynom* pMP = m_poEnd->getAs<types::Polynom>();
378         ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
379     }
380     ostr << std::endl;
381     return true;
382 }
383
384 InternalType::ScilabType ImplicitList::getOutputType()
385 {
386     return m_eOutType;
387 }
388
389 void ImplicitList::extractValueAsDouble(int _iOccur, Double* d)
390 {
391     double dblStart = m_pDblStart->get(0);
392     double dblStep = m_pDblStep->get(0);
393     d->get()[0] = dblStart + _iOccur * dblStep;
394 }
395
396 template<typename T>
397 void ImplicitList::extractValueAsInteger(int _iOccur, T* val)
398 {
399
400     val->get()[0] = static_cast<typename T::type>(convert_input(m_poStart)) +
401                     _iOccur * static_cast<typename T::type>(convert_input(m_poStep));
402 }
403
404 template<typename T>
405 void ImplicitList::extractValueAsUnsignedInteger(int _iOccur, T* val)
406 {
407     val->get()[0] = static_cast<typename T::type>(convert_unsigned_input(m_poStart)) +
408                     _iOccur * static_cast<typename T::type>(convert_unsigned_input(m_poStep));
409 }
410
411 InternalType* ImplicitList::getInitalType()
412 {
413     if (compute())
414     {
415         int iDims = 2;
416         int piDms[2] = {1, 1};
417         switch (m_eOutType)
418         {
419             case ScilabDouble:
420                 return new Double(iDims, piDms);
421             case ScilabInt8:
422                 return new Int8(iDims, piDms);
423             case ScilabInt16:
424                 return new Int16(iDims, piDms);
425             case ScilabInt32:
426                 return new Int32(iDims, piDms);
427             case ScilabInt64:
428                 return new Int64(iDims, piDms);
429             case ScilabUInt8:
430                 return new UInt8(iDims, piDms);
431             case ScilabUInt16:
432                 return new UInt16(iDims, piDms);
433             case ScilabUInt32:
434                 return new UInt32(iDims, piDms);
435             case ScilabUInt64:
436                 return new UInt64(iDims, piDms);
437         }
438     }
439
440     return nullptr;
441 }
442
443 //extract single value in a InternalType
444 void ImplicitList::extractValue(int _iOccur, InternalType* pIT)
445 {
446     if (pIT == nullptr)
447     {
448         return;
449     }
450
451     if (compute())
452     {
453         switch (m_eOutType)
454         {
455             case ScilabInt8:
456                 extractValueAsInteger(_iOccur, pIT->getAs<Int8>());
457                 break;
458             case ScilabInt16:
459                 extractValueAsInteger(_iOccur, pIT->getAs<Int16>());
460                 break;
461             case ScilabInt32:
462                 extractValueAsInteger(_iOccur, pIT->getAs<Int32>());
463                 break;
464             case ScilabInt64:
465                 extractValueAsInteger(_iOccur, pIT->getAs<Int64>());
466                 break;
467             case ScilabUInt8:
468                 extractValueAsUnsignedInteger(_iOccur, pIT->getAs<UInt8>());
469                 break;
470             case ScilabUInt16:
471                 extractValueAsUnsignedInteger(_iOccur, pIT->getAs<UInt16>());
472                 break;
473             case ScilabUInt32:
474                 extractValueAsUnsignedInteger(_iOccur, pIT->getAs<UInt32>());
475                 break;
476             case ScilabUInt64:
477                 extractValueAsUnsignedInteger(_iOccur, pIT->getAs<UInt64>());
478                 break;
479             case ScilabDouble:
480                 extractValueAsDouble(_iOccur, pIT->getAs<Double>());
481                 break;
482         }
483     }
484 }
485
486 //extract matrix in a Internaltype
487 InternalType* ImplicitList::extractFullMatrix()
488 {
489     InternalType* pIT = NULL;
490     if (compute())
491     {
492         if (getSize() == 0) // return []
493         {
494             pIT = Double::Empty();
495         }
496         else if (getSize() == -1) // return nan
497         {
498             unsigned long long raw = 0x7ff8000000000000;
499             double not_a_number = *( double* )&raw;
500             pIT = new Double(not_a_number);
501         }
502         else if (m_eOutType == ScilabDouble)
503         {
504             pIT = new Double(1, m_iSize);
505             extractFullMatrix(pIT->getAs<Double>());
506         }
507         else if (m_eOutType == ScilabInt8)
508         {
509             pIT = new Int8(1, m_iSize);
510             extractFullMatrix(pIT->getAs<Int8>());
511         }
512         else if (m_eOutType == ScilabUInt8)
513         {
514             pIT = new UInt8(1, m_iSize);
515             extractFullMatrix(pIT->getAs<UInt8>());
516         }
517         else if (m_eOutType == ScilabInt16)
518         {
519             pIT = new Int16(1, m_iSize);
520             extractFullMatrix(pIT->getAs<Int16>());
521         }
522         else if (m_eOutType == ScilabUInt16)
523         {
524             pIT = new UInt16(1, m_iSize);
525             extractFullMatrix(pIT->getAs<UInt16>());
526         }
527         else if (m_eOutType == ScilabInt32)
528         {
529             pIT = new Int32(1, m_iSize);
530             extractFullMatrix(pIT->getAs<Int32>());
531         }
532         else if (m_eOutType == ScilabUInt32)
533         {
534             pIT = new UInt32(1, m_iSize);
535             extractFullMatrix(pIT->getAs<UInt32>());
536         }
537         else if (m_eOutType == ScilabInt64)
538         {
539             pIT = new Int64(1, m_iSize);
540             extractFullMatrix(pIT->getAs<Int64>());
541         }
542         else if (m_eOutType == ScilabUInt64)
543         {
544             pIT = new UInt64(1, m_iSize);
545             extractFullMatrix(pIT->getAs<UInt64>());
546         }
547     }
548     return pIT;
549 }
550
551 void ImplicitList::extractFullMatrix(Double *_p)
552 {
553     double dblStart = m_poStart->getAs<Double>()->get(0);
554     double dblStep  = m_poStep->getAs<Double>()->get(0);
555
556     double* p = _p->get();
557     for (int i = 0 ; i < m_iSize ; i++)
558     {
559         p[i] = dblStart + i * dblStep;
560     }
561 }
562
563 template<typename T>
564 void ImplicitList::extractFullMatrix(T *_pT)
565 {
566     typename T::type tStart = static_cast<typename T::type>(convert_input(m_poStart));
567     typename T::type tStep = static_cast<typename T::type>(convert_input(m_poStep));
568
569     typename T::type* p = _pT->get();
570     for (int i = 0 ; i < m_iSize ; i++)
571     {
572         p[i] = tStart + i * tStep;
573     }
574 }
575
576 bool ImplicitList::transpose(InternalType *& out)
577 {
578     if (compute())
579     {
580         Double * pIT = new Double(m_iSize, 1);
581         out = pIT;
582         extractFullMatrix(pIT);
583
584         return true;
585     }
586
587     return false;
588 }
589
590 bool ImplicitList::neg(InternalType *& out)
591 {
592     if (compute() && m_poStart->isDouble() && m_poStep->isDouble() && m_poEnd->isDouble())
593     {
594         out = new Bool(1, m_iSize);
595         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());
596
597         return true;
598     }
599
600     return false;
601 }
602
603 bool ImplicitList::invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & e)
604 {
605     if (in.size() == 0)
606     {
607         out.push_back(this);
608     }
609     else
610     {
611         InternalType * _out = extract(&in);
612         if (!_out)
613         {
614             std::wostringstream os;
615             os << _W("Invalid index.\n");
616             throw ast::InternalError(os.str(), 999, e.getLocation());
617         }
618         out.push_back(_out);
619     }
620
621     return true;
622 }
623
624 InternalType* ImplicitList::extract(typed_list* _pArgs)
625 {
626     int iDims = (int)_pArgs->size();
627     typed_list pArg;
628     InternalType* pOut = NULL;
629     int index = 0;
630
631     int* piMaxDim = new int[iDims];
632     int* piCountDim = new int[iDims];
633
634     //evaluate each argument and replace by appropriate value and compute the count of combinations
635     int iSeqCount = checkIndexesArguments(this, _pArgs, &pArg, piMaxDim, piCountDim);
636     if (iSeqCount == 0)
637     {
638         //free pArg content
639         cleanIndexesArguments(_pArgs, &pArg);
640         return createEmptyDouble();
641     }
642
643     if (iDims == 1 && iSeqCount == 1)
644     {
645         if (piMaxDim[0] > 0 && piMaxDim[0] <= 3)
646         {
647             //standard case a(1)
648             Double* pDbl = pArg[0]->getAs<Double>();
649             index = (int)pDbl->get()[0] - 1;
650         }
651         else
652         {
653             index = 0;
654         }
655     }
656     else
657     {
658         int* piDims = new int[iDims];
659         int* pIndex = new int[iDims];
660         for (int i = 0 ; i < iDims ; i++)
661         {
662             piDims[i] = 1;
663         }
664
665         for (int i = 0 ; i < iSeqCount ; i++)
666         {
667             for (int j = 0 ; j < iDims ; j++)
668             {
669                 Double* pDbl = pArg[j]->getAs<Double>();
670                 pIndex[j] = (int)pDbl->get()[i] - 1;
671             }
672
673             index = getIndexWithDims(pIndex, piDims, iDims);
674         }
675         delete[] pIndex;
676         delete[] piDims;
677     }
678
679     switch (index)
680     {
681         case 0 :
682             pOut = getStart();
683             break;
684         case 1 :
685             pOut = getStep();
686             break;
687         case 2 :
688             pOut = getEnd();
689             break;
690         default :
691             pOut = NULL;
692             break;
693     }
694
695     //free pArg content
696     cleanIndexesArguments(_pArgs, &pArg);
697
698     delete[] piMaxDim;
699     delete[] piCountDim;
700     return pOut;
701 }
702
703 ast::Exp * ImplicitList::getExp(const Location & loc)
704 {
705     return new ast::DoubleExp(loc, this);
706 }
707
708 bool ImplicitList::isTrue()
709 {
710     // TODO : manage int & co
711     if (m_poStart->isDouble() && m_poStep->isDouble() && m_poEnd->isDouble())
712     {
713         return type_traits::isTrue(m_poStart->getAs<Double>()->get(0), m_poStep->getAs<Double>()->get(0), m_poEnd->getAs<Double>()->get(0));
714     }
715
716     return false;
717 }
718
719 }
720
721 std::wstring printInLinePoly(types::SinglePoly* _pPoly, std::wstring _stVar)
722 {
723     std::wostringstream ostr;
724     double* pdblIn = _pPoly->get();
725     for (int i = 0 ; i < _pPoly->getSize() ; i++)
726     {
727
728         if (pdblIn[i] != 0)
729         {
730             DoubleFormat df;
731             getDoubleFormat(pdblIn[i], &df);
732             df.bPrintPoint = ostr.str().size() != 0;
733             df.bPrintPlusSign = true;
734             df.bPrintOne = i == 0;
735             df.bPaddSign = false;
736             df.bPrintBlank = false;
737             df.bPrintPlusSign = false;
738
739             addDoubleValue(&ostr, pdblIn[i], &df);
740             if (i != 0)
741             {
742                 ostr << _stVar;
743                 if (i > 1)
744                 {
745                     ostr << "^" << i;
746                 }
747             }
748         }
749     }
750     return ostr.str();
751 }
752
753 std::wstring printDouble(types::Double* _pD)
754 {
755     std::wostringstream ostr;
756     DoubleFormat df;
757     getDoubleFormat(_pD->get(0), &df);
758     df.bPrintPoint = false;
759     df.bPaddSign = false;
760     df.bPrintBlank = false;
761     addDoubleValue(&ostr, _pD->get(0), &df);
762     return ostr.str();
763 }
764
765 long long convert_input(types::InternalType* _poIT)
766 {
767     switch (_poIT->getType())
768     {
769         case types::InternalType::ScilabDouble:
770             return static_cast<long long>(_poIT->getAs<types::Double>()->get(0));
771         case types::InternalType::ScilabInt8:
772             return static_cast<long long>(_poIT->getAs<types::Int8>()->get(0));
773         case types::InternalType::ScilabUInt8:
774             return static_cast<long long>(_poIT->getAs<types::UInt8>()->get(0));
775         case types::InternalType::ScilabInt16:
776             return static_cast<long long>(_poIT->getAs<types::Int16>()->get(0));
777         case types::InternalType::ScilabUInt16:
778             return static_cast<long long>(_poIT->getAs<types::UInt16>()->get(0));
779         case types::InternalType::ScilabInt32:
780             return static_cast<long long>(_poIT->getAs<types::Int32>()->get(0));
781         case types::InternalType::ScilabUInt32:
782             return static_cast<long long>(_poIT->getAs<types::UInt32>()->get(0));
783         case types::InternalType::ScilabInt64:
784             return static_cast<long long>(_poIT->getAs<types::Int64>()->get(0));
785         case types::InternalType::ScilabUInt64:
786             return static_cast<long long>(_poIT->getAs<types::UInt64>()->get(0));
787         default:
788             return 0;
789     }
790     return 0;
791 }
792
793 unsigned long long convert_unsigned_input(types::InternalType* _poIT)
794 {
795     switch (_poIT->getType())
796     {
797         case types::InternalType::ScilabDouble:
798             return static_cast<unsigned long long>(_poIT->getAs<types::Double>()->get(0));
799         case types::InternalType::ScilabInt8:
800             return static_cast<unsigned long long>(_poIT->getAs<types::Int8>()->get(0));
801         case types::InternalType::ScilabUInt8:
802             return static_cast<unsigned long long>(_poIT->getAs<types::UInt8>()->get(0));
803         case types::InternalType::ScilabInt16:
804             return static_cast<unsigned long long>(_poIT->getAs<types::Int16>()->get(0));
805         case types::InternalType::ScilabUInt16:
806             return static_cast<unsigned long long>(_poIT->getAs<types::UInt16>()->get(0));
807         case types::InternalType::ScilabInt32:
808             return static_cast<unsigned long long>(_poIT->getAs<types::Int32>()->get(0));
809         case types::InternalType::ScilabUInt32:
810             return static_cast<unsigned long long>(_poIT->getAs<types::UInt32>()->get(0));
811         case types::InternalType::ScilabInt64:
812             return static_cast<unsigned long long>(_poIT->getAs<types::Int64>()->get(0));
813         case types::InternalType::ScilabUInt64:
814             return static_cast<unsigned long long>(_poIT->getAs<types::UInt64>()->get(0));
815         default:
816             return 0;
817     }
818     return 0;
819 }