Improve performance for loop and insertion
[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
21 #ifndef NDEBUG
22 #include "inspector.hxx"
23 #endif
24
25 #include "tostring_common.hxx"
26
27 extern "C"
28 {
29 #include "core_math.h"
30 #include "elem_common.h"
31 #include "finite.h"
32 }
33
34 std::wstring printInLinePoly(types::SinglePoly* _pPoly, std::wstring _stVar);
35 std::wstring printDouble(types::Double* _pD);
36 long long convert_input(types::InternalType* _poIT);
37 unsigned long long convert_unsigned_input(types::InternalType* _poIT);
38
39 namespace types
40 {
41 ImplicitList::~ImplicitList()
42 {
43     if (isDeletable() == true)
44     {
45         if (m_poStart)
46         {
47             m_poStart->DecreaseRef();
48             m_poStart->killMe();
49         }
50
51         if (m_poStep)
52         {
53             m_poStep->DecreaseRef();
54             m_poStep->killMe();
55         }
56
57         if (m_poEnd)
58         {
59             m_poEnd->DecreaseRef();
60             m_poEnd->killMe();
61         }
62     }
63 #ifndef NDEBUG
64     Inspector::removeItem(this);
65 #endif
66 }
67
68 ImplicitList::ImplicitList()
69 {
70     m_iSize     = -1;
71     m_eOutType  = ScilabGeneric;
72     m_bComputed = false;
73     m_poStart   = NULL;
74     m_poStep    = NULL;
75     m_poEnd     = NULL;
76     m_pDblStart = NULL;
77     m_pDblStep  = NULL;
78     m_pDblEnd   = NULL;
79
80 #ifndef NDEBUG
81     Inspector::addItem(this);
82 #endif
83 }
84
85 ImplicitList::ImplicitList(InternalType* _poStart, InternalType* _poStep, InternalType* _poEnd)
86 {
87     m_iSize     = -1;
88     m_eOutType  = ScilabGeneric;
89     m_bComputed = false;
90     m_poStart   = NULL;
91     m_poStep    = NULL;
92     m_poEnd     = NULL;
93     m_pDblStart = NULL;
94     m_pDblStep  = NULL;
95     m_pDblEnd   = NULL;
96
97     setStart(_poStart);
98     setStep(_poStep);
99     setEnd(_poEnd);
100     compute();
101 #ifndef NDEBUG
102     Inspector::addItem(this);
103 #endif
104 }
105
106 InternalType* ImplicitList::clone()
107 {
108     return new ImplicitList(m_poStart, m_poStep, m_poEnd);
109 }
110
111 InternalType::ScilabType ImplicitList::getStartType()
112 {
113     return m_poStart->getType();
114 }
115
116 InternalType::ScilabType ImplicitList::getStepType()
117 {
118     return m_poStep->getType();
119 }
120
121 InternalType::ScilabType ImplicitList::getEndType()
122 {
123     return m_poEnd->getType();
124 }
125
126 void ImplicitList::setStart(InternalType *_poIT)
127 {
128     if (m_poStart)
129     {
130         //clear previous value
131         m_poStart->DecreaseRef();
132         m_poStart->killMe();
133         m_poStart = NULL;
134     }
135
136     m_poStart = _poIT;
137     if (m_poStart != NULL)
138     {
139         m_poStart->IncreaseRef();
140         m_eStartType = m_poStart->getType();
141     }
142     m_bComputed = false;
143 }
144
145 void ImplicitList::setStep(InternalType *_poIT)
146 {
147     if (m_poStep)
148     {
149         //clear previous value
150         m_poStep->DecreaseRef();
151         m_poStep->killMe();
152         m_poStep = NULL;
153     }
154
155     m_poStep = _poIT;
156     if (m_poStep != NULL)
157     {
158         m_poStep->IncreaseRef();
159         m_eStepType = m_poStep->getType();
160     }
161     m_bComputed = false;
162 }
163
164 void ImplicitList::setEnd(InternalType* _poIT)
165 {
166     if (m_poEnd)
167     {
168         //clear previous value
169         m_poEnd->DecreaseRef();
170         m_poEnd->killMe();
171         m_poEnd = NULL;
172     }
173
174     m_poEnd = _poIT;
175     if (m_poEnd != NULL)
176     {
177         m_poEnd->IncreaseRef();
178         m_eEndType = m_poEnd->getType();
179     }
180     m_bComputed = false;
181 }
182
183 bool ImplicitList::compute()
184 {
185     if (m_bComputed == true)
186     {
187         return true;
188     }
189
190     m_iSize = -1;
191     if (isComputable() == true)
192     {
193         m_iSize = 0;
194         if (m_eOutType == ScilabDouble)
195         {
196             m_pDblStart = m_poStart->getAs<Double>();
197             double dblStart     = m_pDblStart->get(0);
198
199             m_pDblStep = m_poStep->getAs<Double>();
200             double dblStep      = m_pDblStep->get(0);
201
202             m_pDblEnd = m_poEnd->getAs<Double>();
203             double dblEnd       = m_pDblEnd->get(0);
204             // othe way to compute
205
206             // nan value
207             if (ISNAN(dblStart) || ISNAN(dblStep) || ISNAN(dblEnd))
208             {
209                 m_iSize = -1;
210                 m_bComputed = true;
211                 return true;
212             }
213
214             // no finite values
215             if ( finite(dblStart) == 0 || finite(dblStep) == 0 || finite(dblEnd) == 0)
216             {
217                 if ((dblStep > 0 && dblStart < dblEnd) ||
218                         (dblStep < 0 && dblStart > dblEnd))
219                 {
220                     // return nan
221                     m_iSize = -1;
222                 }
223                 // else return []
224
225                 m_bComputed = true;
226                 return true;
227             }
228
229             // step null
230             if (dblStep == 0) // return []
231             {
232                 m_bComputed = true;
233                 return true;
234             }
235
236             double dblVal = dblStart; // temp value
237             double dblEps = getRelativeMachinePrecision();
238             double dblPrec = 2 * std::max(fabs(dblStart), fabs(dblEnd)) * dblEps;
239
240             while (dblStep * (dblVal - dblEnd) <= 0)
241             {
242                 m_iSize++;
243                 dblVal = dblStart + m_iSize * dblStep;
244             }
245
246             if (fabs(dblVal - dblEnd) < dblPrec)
247             {
248                 m_iSize++;
249             }
250         }
251         else //m_eOutType == ScilabInt
252         {
253             if (m_eOutType == ScilabInt8 ||
254                     m_eOutType == ScilabInt16 ||
255                     m_eOutType == ScilabInt32 ||
256                     m_eOutType == ScilabInt64)
257             {
258                 //signed
259                 long long llStart   = convert_input(m_poStart);
260                 long long llStep    = convert_input(m_poStep);
261                 long long llEnd     = convert_input(m_poEnd);
262
263 #ifdef _MSC_VER
264                 m_iSize = static_cast<int>(floor( static_cast<double>(_abs64(llEnd - llStart) / _abs64(llStep)) )) + 1;
265 #else
266                 m_iSize = static_cast<int>(floor( static_cast<double>(llabs(llEnd - llStart) / llabs(llStep)) )) + 1;
267 #endif
268             }
269             else
270             {
271                 //unsigned
272                 unsigned long long ullStart = convert_unsigned_input(m_poStart);
273                 unsigned long long ullStep      = convert_unsigned_input(m_poStep);
274                 unsigned long long ullEnd   = convert_unsigned_input(m_poEnd);
275
276 #ifdef _MSC_VER
277                 m_iSize = static_cast<int>(floor(static_cast<double>(_abs64(ullEnd - ullStart) / _abs64(ullStep)) )) + 1;
278 #else
279                 m_iSize = static_cast<int>(floor(static_cast<double>(llabs(ullEnd - ullStart) / llabs(ullStep)) )) + 1;
280 #endif
281             }
282         }
283         m_bComputed = true;
284         return true;
285     }
286     else
287     {
288         return false;
289     }
290 }
291
292 bool ImplicitList::isComputable()
293 {
294     if (m_eStartType != ScilabDouble && m_poStart->isInt() == false)
295     {
296         return false;
297     }
298
299     if (m_eStepType != ScilabDouble && m_poStep->isInt() == false)
300     {
301         return false;
302     }
303
304     if (m_eEndType != ScilabDouble && m_poEnd->isInt() == false)
305     {
306         return false;
307     }
308
309     //"compute" output type
310     m_eOutType = ScilabGeneric; //not defined type
311     if (m_poStart->isInt())
312     {
313         m_eOutType  = m_poStart->getType();
314     }
315     else if (m_poStep->isInt())
316     {
317         m_eOutType  = m_poStep->getType();
318     }
319     else if (m_poEnd->isInt())
320     {
321         m_eOutType  = m_poEnd->getType();
322     }
323     else
324     {
325         m_eOutType  = ScilabDouble;
326     }
327
328     return true;
329 }
330
331 bool ImplicitList::toString(std::wostringstream& ostr)
332 {
333     if (isComputable())
334     {
335         types::InternalType* pIT = extractFullMatrix();
336         bool ret = pIT->toString(ostr);
337         delete pIT;
338         return ret;
339     }
340     else
341     {
342         ostr << L" ";
343         if (m_eStartType == ScilabDouble)
344         {
345             Double *pD = m_poStart->getAs<Double>();
346             ostr << printDouble(pD);
347         }
348         else //Polynom
349         {
350             Polynom* pMP = m_poStart->getAs<types::Polynom>();
351             ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
352         }
353
354         ostr << L":";
355
356         if (m_eStepType == ScilabDouble)
357         {
358             Double *pD = m_poStep->getAs<Double>();
359             ostr << printDouble(pD);
360         }
361         else //Polynom
362         {
363             Polynom* pMP = m_poStep->getAs<types::Polynom>();
364             ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
365         }
366
367         ostr << L":";
368
369         if (m_eEndType == ScilabDouble)
370         {
371             Double *pD = m_poEnd->getAs<Double>();
372             ostr << printDouble(pD);
373         }
374         else //Polynom
375         {
376             Polynom* pMP = m_poEnd->getAs<types::Polynom>();
377             ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
378         }
379         ostr << std::endl;
380         return true;
381     }
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, ast::ConstVisitor & /*execFunc*/, 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::ScilabError(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         for (int i = 0 ; i < iDims ; i++)
660         {
661             piDims[i] = 1;
662         }
663
664         for (int i = 0 ; i < iSeqCount ; i++)
665         {
666             int* pIndex = new int[iDims];
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     }
676
677     switch (index)
678     {
679         case 0 :
680             pOut = getStart();
681             break;
682         case 1 :
683             pOut = getStep();
684             break;
685         case 2 :
686             pOut = getEnd();
687             break;
688         default :
689             pOut = NULL;
690             break;
691     }
692
693     //free pArg content
694     cleanIndexesArguments(_pArgs, &pArg);
695
696     delete[] piMaxDim;
697     delete[] piCountDim;
698     return pOut;
699 }
700 }
701
702 std::wstring printInLinePoly(types::SinglePoly* _pPoly, std::wstring _stVar)
703 {
704     std::wostringstream ostr;
705     double* pdblIn = _pPoly->get();
706     for (int i = 0 ; i < _pPoly->getSize() ; i++)
707     {
708
709         if (pdblIn[i] != 0)
710         {
711             DoubleFormat df;
712             getDoubleFormat(pdblIn[i], &df);
713             df.bPrintPoint = ostr.str().size() != 0;
714             df.bPrintPlusSign = true;
715             df.bPrintOne = i == 0;
716             df.bPaddSign = false;
717             df.bPrintBlank = false;
718             df.bPrintPlusSign = false;
719
720             addDoubleValue(&ostr, pdblIn[i], &df);
721             if (i != 0)
722             {
723                 ostr << _stVar;
724                 if (i > 1)
725                 {
726                     ostr << "^" << i;
727                 }
728             }
729         }
730     }
731     return ostr.str();
732 }
733
734 std::wstring printDouble(types::Double* _pD)
735 {
736     std::wostringstream ostr;
737     DoubleFormat df;
738     getDoubleFormat(_pD->get(0), &df);
739     df.bPrintPoint = false;
740     df.bPaddSign = true;
741     df.bPaddSign = false;
742     df.bPrintBlank = false;
743     addDoubleValue(&ostr, _pD->get(0), &df);
744     return ostr.str();
745 }
746
747 long long convert_input(types::InternalType* _poIT)
748 {
749     switch (_poIT->getType())
750     {
751         case types::InternalType::ScilabDouble:
752             return static_cast<long long>(_poIT->getAs<types::Double>()->get(0));
753         case types::InternalType::ScilabInt8:
754             return static_cast<long long>(_poIT->getAs<types::Int8>()->get(0));
755         case types::InternalType::ScilabUInt8:
756             return static_cast<long long>(_poIT->getAs<types::UInt8>()->get(0));
757         case types::InternalType::ScilabInt16:
758             return static_cast<long long>(_poIT->getAs<types::Int16>()->get(0));
759         case types::InternalType::ScilabUInt16:
760             return static_cast<long long>(_poIT->getAs<types::UInt16>()->get(0));
761         case types::InternalType::ScilabInt32:
762             return static_cast<long long>(_poIT->getAs<types::Int32>()->get(0));
763         case types::InternalType::ScilabUInt32:
764             return static_cast<long long>(_poIT->getAs<types::UInt32>()->get(0));
765         case types::InternalType::ScilabInt64:
766             return static_cast<long long>(_poIT->getAs<types::Int64>()->get(0));
767         case types::InternalType::ScilabUInt64:
768             return static_cast<long long>(_poIT->getAs<types::UInt64>()->get(0));
769         default:
770             return 0;
771     }
772     return 0;
773 }
774
775 unsigned long long convert_unsigned_input(types::InternalType* _poIT)
776 {
777     switch (_poIT->getType())
778     {
779         case types::InternalType::ScilabDouble:
780             return static_cast<unsigned long long>(_poIT->getAs<types::Double>()->get(0));
781         case types::InternalType::ScilabInt8:
782             return static_cast<unsigned long long>(_poIT->getAs<types::Int8>()->get(0));
783         case types::InternalType::ScilabUInt8:
784             return static_cast<unsigned long long>(_poIT->getAs<types::UInt8>()->get(0));
785         case types::InternalType::ScilabInt16:
786             return static_cast<unsigned long long>(_poIT->getAs<types::Int16>()->get(0));
787         case types::InternalType::ScilabUInt16:
788             return static_cast<unsigned long long>(_poIT->getAs<types::UInt16>()->get(0));
789         case types::InternalType::ScilabInt32:
790             return static_cast<unsigned long long>(_poIT->getAs<types::Int32>()->get(0));
791         case types::InternalType::ScilabUInt32:
792             return static_cast<unsigned long long>(_poIT->getAs<types::UInt32>()->get(0));
793         case types::InternalType::ScilabInt64:
794             return static_cast<unsigned long long>(_poIT->getAs<types::Int64>()->get(0));
795         case types::InternalType::ScilabUInt64:
796             return static_cast<unsigned long long>(_poIT->getAs<types::UInt64>()->get(0));
797         default:
798             return 0;
799     }
800     return 0;
801 }