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