reduce Eigen headers visibility
[scilab.git] / scilab / modules / ast / includes / types / int.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4  *  Copyright (C) 2014 - Scilab Enterprises - Calixte DENIZET
5  *
6  *  This file must be used under the terms of the CeCILL.
7  *  This source file is licensed as described in the file COPYING, which
8  *  you should have received as part of this distribution.  The terms
9  *  are also available at
10  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14 //#ifndef __ARRAYOF_HXX__
15 //    #error This file must only be include by arrayof.hxx
16 //#endif
17
18 #ifndef __INT_HXX__
19 #define __INT_HXX__
20
21 #include "arrayof.hxx"
22 #include "bool.hxx"
23 #include "internal.hxx"
24 #include "types_transposition.hxx"
25 #include "configvariable.hxx"
26
27 #include <sstream>
28 #include <string>
29 #include <limits>       // std::numeric_limits
30 #include "tostring_common.hxx"
31
32 namespace types
33 {
34 template<typename T>
35 class EXTERN_AST Int : public ArrayOf<T>
36 {
37 public :
38
39     Int(int _iRows, int _iCols)
40     {
41         int piDims[2]   = {_iRows, _iCols};
42         T * pInt     = NULL;
43         this->create(piDims, 2, &pInt, NULL);
44 #ifndef NDEBUG
45         //Inspector::addItem(this);
46 #endif
47     }
48
49     Int(T _val)
50     {
51         int piDims[2]   = {1, 1};
52         T * pInt     = NULL;
53         this->create(piDims, 2, &pInt, NULL);
54         pInt[0] = _val;
55 #ifndef NDEBUG
56         //Inspector::addItem(this);
57 #endif
58     }
59
60     Int(int _iRows, int _iCols, T** _pData)
61     {
62         int piDims[2] = {_iRows, _iCols};
63         this->create(piDims, 2, _pData, NULL);
64 #ifndef NDEBUG
65         //Inspector::addItem(this);
66 #endif
67     }
68
69     Int(int _iDims, int* _piDims)
70     {
71         T * pInt     = NULL;
72         this->create(_piDims, _iDims, &pInt, NULL);
73 #ifndef NDEBUG
74         //Inspector::addItem(this);
75 #endif
76     }
77
78     ~Int()
79     {
80         if (InternalType::isDeletable() == true)
81         {
82             deleteAll();
83         }
84 #ifndef NDEBUG
85         //Inspector::removeItem(this);
86 #endif
87     }
88
89     InternalType* clone()
90     {
91         Int<T> *pbClone = new Int<T>(GenericType::getDims(), GenericType::getDimsArray());
92         pbClone->set(ArrayOf<T>::get());
93         return pbClone;
94     }
95
96     /*Config management*/
97     void whoAmI();
98
99     bool isInt()
100     {
101         return true;
102     }
103
104     bool neg(InternalType *& out);
105
106     virtual bool transpose(InternalType *& out);
107
108     bool operator==(const InternalType& it)
109     {
110         if (const_cast<InternalType &>(it).getType() != getType())
111         {
112             return false;
113         }
114
115         Int<T>* pb = const_cast<InternalType &>(it).getAs<typename types::Int<T> >();
116
117         if (pb->getDims() != GenericType::getDims())
118         {
119             return false;
120         }
121
122         for (int i = 0 ; i < GenericType::getDims() ; i++)
123         {
124             if (pb->getDimsArray()[i] != GenericType::getDimsArray()[i])
125             {
126                 return false;
127             }
128         }
129
130         if (memcmp(ArrayOf<T>::get(), pb->get(), GenericType::getSize() * sizeof(T)) != 0)
131         {
132             return false;
133         }
134         return true;
135     }
136
137     bool operator!=(const InternalType& it)
138     {
139         return !(*this == it);
140     }
141
142     /* return type as string ( double, int, cell, list, ... )*/
143     virtual std::wstring        getTypeStr();
144
145     /* return type as short string ( s, i, ce, l, ... )*/
146     virtual std::wstring        getShortTypeStr()
147     {
148         return L"i";
149     }
150
151 protected :
152     inline InternalType::ScilabType getType(void);
153     inline InternalType::ScilabId   getId(void);
154
155 private :
156     virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int /*_iDims*/)
157     {
158         int iCurrentLine = 0;
159         int iLineLen = ConfigVariable::getConsoleWidth();
160         int iMaxLines = ConfigVariable::getConsoleLines();
161
162         if (GenericType::isIdentity())
163         {
164             ostr << L"eye *" << std::endl << std::endl;
165             int iWidth = 0;
166             if (isSigned())
167             {
168                 getSignedIntFormat(ArrayOf<T>::get(0), &iWidth);
169                 addSignedIntValue(&ostr, ArrayOf<T>::get(0), iWidth);
170             }
171             else
172             {
173                 getUnsignedIntFormat(ArrayOf<T>::get(0), &iWidth);
174                 addUnsignedIntValue(&ostr, ArrayOf<T>::get(0), iWidth);
175             }
176             ostr << std::endl;
177         }
178         else if (GenericType::isScalar())
179         {
180             //scalar
181             int iWidth  = 0;
182             _piDims[0]  = 0;
183             _piDims[1]  = 0;
184             int iPos    = ArrayOf<T>::getIndex(_piDims);
185
186             if (isSigned())
187             {
188                 getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
189                 addSignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidth);
190             }
191             else
192             {
193                 getUnsignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
194                 addUnsignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidth);
195             }
196             ostr << std::endl;
197         }
198         else if (GenericType::getCols() == 1)
199         {
200             //column vector
201             int iWidthMax = 0;
202
203             //Array with the max printed size of each col
204             for (int i = 0 ; i < GenericType::getRows() ; i++)
205             {
206                 _piDims[1] = 0;
207                 _piDims[0] = i;
208                 int iWidth = 0;
209                 int iPos = ArrayOf<T>::getIndex(_piDims);
210                 if (isSigned())
211                 {
212                     getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
213                 }
214                 else
215                 {
216                     getUnsignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
217                 }
218                 iWidthMax = std::max(iWidthMax, iWidth);
219             }
220
221             for (int i = this->m_iRows1PrintState ; i < this->getRows() ; i++)
222             {
223                 iCurrentLine++;
224                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
225                 {
226                     this->m_iRows1PrintState = i;
227                     return false;
228                 }
229
230                 _piDims[1]  = 0;
231                 _piDims[0]  = i;
232                 int iPos    = ArrayOf<T>::getIndex(_piDims);
233
234                 if (isSigned())
235                 {
236                     addSignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidthMax);
237                 }
238                 else
239                 {
240                     addUnsignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidthMax);
241                 }
242                 ostr << std::endl;
243             }
244         }
245         else if (GenericType::getRows() == 1)
246         {
247             //row vector
248             std::wostringstream ostemp;
249             int iLastVal = this->m_iCols1PrintState;
250
251             for (int i = this->m_iCols1PrintState ; i < this->getCols() ; i++)
252             {
253                 int iWidth  = 0;
254                 int iLen    = 0;
255                 _piDims[0]  = 0;
256                 _piDims[1]  = i;
257                 int iPos    = ArrayOf<T>::getIndex(_piDims);
258
259                 if (isSigned())
260                 {
261                     getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
262                 }
263                 else
264                 {
265                     getUnsignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
266                 }
267
268                 iLen = iWidth + static_cast<int>(ostemp.str().size());
269                 if (iLen > iLineLen && iLastVal != i)
270                 {
271                     //Max length, new line
272                     iCurrentLine += 4; //"column x to Y" + empty line + value + empty line
273                     if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
274                     {
275                         this->m_iCols1PrintState = iLastVal;
276                         return false;
277                     }
278
279                     addColumnString(ostr, iLastVal + 1, i);
280                     ostr << ostemp.str() << std::endl;
281                     ostemp.str(L"");
282                     iLastVal = i;
283                 }
284
285                 if (isSigned())
286                 {
287                     addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), iWidth);
288                 }
289                 else
290                 {
291                     addUnsignedIntValue(&ostemp, ArrayOf<T>::get(iPos), iWidth);
292                 }
293             }
294
295             if (iLastVal != 0)
296             {
297                 addColumnString(ostr, iLastVal + 1, GenericType::getCols());
298             }
299
300             ostemp << std::endl;
301             ostr << ostemp.str();
302         }
303         else // matrix
304         {
305             std::wostringstream ostemp;
306             int iLen = 0;
307             int iLastCol = this->m_iCols1PrintState;
308
309             //Array with the max printed size of each col
310             int *piSize = new int[GenericType::getCols()];
311             memset(piSize, 0x00, GenericType::getCols() * sizeof(int));
312
313             //compute the row size for padding for each printed bloc.
314             for (int iCols1 = this->m_iCols1PrintState ; iCols1 < this->getCols() ; iCols1++)
315             {
316                 for (int iRows1 = 0 ; iRows1 < this->getRows() ; iRows1++)
317                 {
318                     int iWidth  = 0;
319                     _piDims[0]  = iRows1;
320                     _piDims[1]  = iCols1;
321                     int iPos    = ArrayOf<T>::getIndex(_piDims);
322
323                     if (isSigned())
324                     {
325                         getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
326                     }
327                     else
328                     {
329                         getUnsignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
330                     }
331                     piSize[iCols1] = std::max(piSize[iCols1], iWidth);
332                 }
333
334                 if (iLen + piSize[iCols1] > iLineLen && iCols1 != iLastCol)
335                 {
336                     //find the limit, print this part
337                     for (int iRows2 = this->m_iRows2PrintState ; iRows2 < this->getRows() ; iRows2++)
338                     {
339                         iCurrentLine++;
340                         if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) ||
341                                 ( (iMaxLines != 0 && iCurrentLine + 3 >= iMaxLines && iRows2 == this->m_iRows2PrintState) ||
342                                   (iMaxLines != 0 && iCurrentLine + 1 >= iMaxLines && iRows2 != this->m_iRows2PrintState)))
343                         {
344                             if (this->m_iRows2PrintState == 0 && iRows2 != 0)
345                             {
346                                 //add header
347                                 addColumnString(ostr, iLastCol + 1, iCols1);
348                             }
349
350                             ostr << ostemp.str();
351                             this->m_iRows2PrintState = iRows2;
352                             this->m_iCols1PrintState = iLastCol;
353                             return false;
354                         }
355
356                         for (int iCols2 = iLastCol ; iCols2 < iCols1 ; iCols2++)
357                         {
358                             _piDims[0]  = iRows2;
359                             _piDims[1]  = iCols2;
360                             int iPos    = ArrayOf<T>::getIndex(_piDims);
361
362                             if (isSigned())
363                             {
364                                 addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
365                             }
366                             else
367                             {
368                                 addUnsignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
369                             }
370                         }
371                         ostemp << std::endl;
372                     }
373                     iLen = 0;
374
375                     iCurrentLine++;
376                     if (this->m_iRows2PrintState == 0)
377                     {
378                         iCurrentLine += 3;
379                         addColumnString(ostr, iLastCol + 1, iCols1);
380                     }
381
382                     ostr << ostemp.str();
383                     ostemp.str(L"");
384                     iLastCol = iCols1;
385                     this->m_iRows2PrintState = 0;
386                     this->m_iCols1PrintState = 0;
387                 }
388
389                 iLen += piSize[iCols1] + SIGN_LENGTH + SIZE_BETWEEN_TWO_VALUES;
390             }
391
392             for (int iRows2 = this->m_iRows2PrintState ; iRows2 < this->getRows() ; iRows2++)
393             {
394                 iCurrentLine++;
395                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
396                 {
397                     if (this->m_iRows2PrintState == 0 && iLastCol != 0)
398                     {
399                         //add header
400                         addColumnString(ostr, iLastCol + 1, GenericType::getCols());
401                     }
402
403                     ostr << ostemp.str();
404                     this->m_iRows2PrintState = iRows2;
405                     this->m_iCols1PrintState = iLastCol;
406                     return false;
407                 }
408
409                 for (int iCols2 = iLastCol ; iCols2 < GenericType::getCols() ; iCols2++)
410                 {
411                     _piDims[0]  = iRows2;
412                     _piDims[1]  = iCols2;
413                     int iPos    = ArrayOf<T>::getIndex(_piDims);
414
415                     if (isSigned())
416                     {
417                         addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
418                     }
419                     else
420                     {
421                         addUnsignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
422                     }
423                 }
424                 ostemp << std::endl;
425             }
426
427             if (this->m_iRows2PrintState == 0 && iLastCol != 0)
428             {
429                 addColumnString(ostr, iLastCol + 1, GenericType::getCols());
430             }
431
432             ostr << ostemp.str();
433         }
434
435         return true;
436     }
437
438     virtual T getNullValue()
439     {
440         return T(0);
441     }
442
443     virtual Int<T>* createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/)
444     {
445         return new Int<T>(_iDims, _piDims);
446     }
447
448     virtual T copyValue(T _data)
449     {
450         return _data;
451     }
452
453     virtual void deleteAll()
454     {
455         delete[] ArrayOf<T>::m_pRealData;
456         ArrayOf<T>::m_pRealData = NULL;
457         deleteImg();
458     }
459
460     virtual void deleteImg() { }
461
462     virtual T* allocData(int _iSize)
463     {
464         return new T[_iSize];
465     }
466
467     template<typename U, typename V> struct is_same_int
468     {
469         const static bool value = false;
470     };
471     template<typename U> struct is_same_int<U, U>
472     {
473         const static bool value = true;
474     };
475
476     bool isInt8()
477     {
478         return is_same_int<T, char>::value;
479     }
480     bool isInt16()
481     {
482         return is_same_int<T, short>::value;
483     }
484     bool isInt32()
485     {
486         return is_same_int<T, int>::value;
487     }
488     bool isInt64()
489     {
490         return is_same_int<T, long long>::value;
491     }
492     bool isUInt8()
493     {
494         return is_same_int<T, unsigned char>::value;
495     }
496     bool isUInt16()
497     {
498         return is_same_int<T, unsigned short>::value;
499     }
500     bool isUInt32()
501     {
502         return is_same_int<T, unsigned int>::value;
503     }
504     bool isUInt64()
505     {
506         return is_same_int<T, unsigned long long>::value;
507     }
508
509     bool isUnsigned()
510     {
511         return !isSigned();
512     }
513
514     bool isSigned()
515     {
516         return std::numeric_limits<T>::is_signed;
517     }
518 };
519
520 template<> inline InternalType::ScilabType Int<char>::getType()
521 {
522     return ScilabInt8;
523 }
524 template<> inline InternalType::ScilabType Int<unsigned char>::getType()
525 {
526     return ScilabUInt8;
527 }
528 template<> inline InternalType::ScilabType Int<short>::getType()
529 {
530     return ScilabInt16;
531 }
532 template<> inline InternalType::ScilabType Int<unsigned short>::getType()
533 {
534     return ScilabUInt16;
535 }
536 template<> inline InternalType::ScilabType Int<int>::getType()
537 {
538     return ScilabInt32;
539 }
540 template<> inline InternalType::ScilabType Int<unsigned int>::getType()
541 {
542     return ScilabUInt32;
543 }
544 template<> inline InternalType::ScilabType Int<long long>::getType()
545 {
546     return ScilabInt64;
547 }
548 template<> inline InternalType::ScilabType Int<unsigned long long>::getType()
549 {
550     return ScilabUInt64;
551 }
552
553 template<> inline InternalType::ScilabId Int<char>::getId()
554 {
555     return isScalar() ? IdScalarInt8 : IdInt8;
556 }
557 template<> inline InternalType::ScilabId Int<unsigned char>::getId()
558 {
559     return isScalar() ? IdScalarUInt8 : IdUInt8;
560 }
561 template<> inline InternalType::ScilabId Int<short>::getId()
562 {
563     return isScalar() ? IdScalarInt16 : IdInt16;
564 }
565 template<> inline InternalType::ScilabId Int<unsigned short>::getId()
566 {
567     return isScalar() ? IdScalarUInt16 : IdUInt16;
568 }
569 template<> inline InternalType::ScilabId Int<int>::getId()
570 {
571     return isScalar() ? IdScalarInt32 : IdInt32;
572 }
573 template<> inline InternalType::ScilabId Int<unsigned int>::getId()
574 {
575     return isScalar() ? IdScalarUInt32 : IdUInt32;
576 }
577 template<> inline InternalType::ScilabId Int<long long>::getId()
578 {
579     return isScalar() ? IdScalarInt64 : IdInt64;
580 }
581 template<> inline InternalType::ScilabId Int<unsigned long long>::getId()
582 {
583     return isScalar() ? IdScalarUInt64 : IdUInt64;
584 }
585
586 // Specializations
587 template<> inline std::wstring Int<char>::getTypeStr()
588 {
589     return L"int8";
590 }
591
592 template<> inline std::wstring Int<short>::getTypeStr()
593 {
594     return L"int16";
595 }
596
597 template<> inline std::wstring Int<int>::getTypeStr()
598 {
599     return L"int32";
600 }
601
602 template<> inline std::wstring Int<long long>::getTypeStr()
603 {
604     return L"int64";
605 }
606
607 template<> inline std::wstring Int<unsigned char>::getTypeStr()
608 {
609     return L"uint8";
610 }
611
612 template<> inline std::wstring Int<unsigned short>::getTypeStr()
613 {
614     return L"uint16";
615 }
616
617 template<> inline std::wstring Int<unsigned int>::getTypeStr()
618 {
619     return L"uint32";
620 }
621
622 template<> inline std::wstring Int<unsigned long long>::getTypeStr()
623 {
624     return L"uint64";
625 }
626
627 template<> inline void Int<char>::whoAmI()
628 {
629     std::cout << "types::Int8";
630 }
631
632 template<> inline void Int<short>::whoAmI()
633 {
634     std::cout << "types::Int16";
635 }
636
637 template<> inline void Int<int>::whoAmI()
638 {
639     std::cout << "types::Int32";
640 }
641
642 template<> inline void Int<long long>::whoAmI()
643 {
644     std::cout << "types::Int64";
645 }
646
647 template<> inline void Int<unsigned char>::whoAmI()
648 {
649     std::cout << "types::UInt8";
650 }
651
652 template<> inline void Int<unsigned short>::whoAmI()
653 {
654     std::cout << "types::UInt16";
655 }
656
657 template<> inline void Int<unsigned int>::whoAmI()
658 {
659     std::cout << "types::UInt32";
660 }
661
662 template<> inline void Int<unsigned long long>::whoAmI()
663 {
664     std::cout << "types::UInt64";
665 }
666
667
668 typedef Int<char> Int8;
669 typedef Int<short> Int16;
670 typedef Int<int> Int32;
671 typedef Int<long long> Int64;
672
673 typedef Int<unsigned char> UInt8;
674 typedef Int<unsigned short> UInt16;
675 typedef Int<unsigned int> UInt32;
676 typedef Int<unsigned long long> UInt64;
677
678 template class Int<char>;
679 template class Int<unsigned char>;
680 template class Int<short>;
681 template class Int<unsigned short>;
682 template class Int<int>;
683 template class Int<unsigned int>;
684 template class Int<long long>;
685 template class Int<unsigned long long>;
686 }
687
688
689 #endif /* !__INT_HXX__ */