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