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