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