comparison between 2 list of integer.
[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         out = new Int<T>(this->getDims(), this->getDimsArray());
107         type_traits::bin_neg<T, T>(this->m_iSize, this->m_pRealData, static_cast<Int<T> *>(out)->get());
108
109         return true;
110     }
111
112     virtual bool transpose(InternalType *& out)
113     {
114         return type_traits::transpose(*this, out);
115     }
116
117     bool operator==(const InternalType& it)
118     {
119         if (const_cast<InternalType &>(it).getType() != getType())
120         {
121             return false;
122         }
123
124         Int<T>* pb = const_cast<InternalType &>(it).getAs<typename types::Int<T> >();
125
126         if (pb->getDims() != GenericType::getDims())
127         {
128             return false;
129         }
130
131         for (int i = 0 ; i < GenericType::getDims() ; i++)
132         {
133             if (pb->getDimsArray()[i] != GenericType::getDimsArray()[i])
134             {
135                 return false;
136             }
137         }
138
139         if (memcmp(ArrayOf<T>::get(), pb->get(), GenericType::getSize() * sizeof(T)) != 0)
140         {
141             return false;
142         }
143         return true;
144     }
145
146     bool operator!=(const InternalType& it)
147     {
148         return !(*this == it);
149     }
150
151     /* return type as string ( double, int, cell, list, ... )*/
152     virtual std::wstring        getTypeStr();
153
154     /* return type as short string ( s, i, ce, l, ... )*/
155     virtual std::wstring        getShortTypeStr()
156     {
157         return L"i";
158     }
159
160 protected :
161     inline InternalType::ScilabType getType(void);
162     inline InternalType::ScilabId   getId(void);
163
164 private :
165     virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int /*_iDims*/)
166     {
167         int iCurrentLine = 0;
168         int iLineLen = ConfigVariable::getConsoleWidth();
169         int iMaxLines = ConfigVariable::getConsoleLines();
170
171         if (ArrayOf<T>::isScalar())
172         {
173             //scalar
174             int iWidth  = 0;
175             _piDims[0]  = 0;
176             _piDims[1]  = 0;
177             int iPos    = ArrayOf<T>::getIndex(_piDims);
178
179             if (isSigned())
180             {
181                 getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
182                 addSignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidth);
183             }
184             else
185             {
186                 getUnsignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
187                 addUnsignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidth);
188             }
189             ostr << std::endl;
190         }
191         else if (GenericType::getCols() == 1)
192         {
193             //column vector
194             int iWidthMax = 0;
195
196             //Array with the max printed size of each col
197             for (int i = 0 ; i < GenericType::getRows() ; i++)
198             {
199                 _piDims[1] = 0;
200                 _piDims[0] = i;
201                 int iWidth = 0;
202                 int iPos = ArrayOf<T>::getIndex(_piDims);
203                 if (isSigned())
204                 {
205                     getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
206                 }
207                 else
208                 {
209                     getUnsignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
210                 }
211                 iWidthMax = std::max(iWidthMax, iWidth);
212             }
213
214             for (int i = this->m_iRows1PrintState ; i < this->getRows() ; i++)
215             {
216                 iCurrentLine++;
217                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
218                 {
219                     this->m_iRows1PrintState = i;
220                     return false;
221                 }
222
223                 _piDims[1]  = 0;
224                 _piDims[0]  = i;
225                 int iPos    = ArrayOf<T>::getIndex(_piDims);
226
227                 if (isSigned())
228                 {
229                     addSignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidthMax);
230                 }
231                 else
232                 {
233                     addUnsignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidthMax);
234                 }
235                 ostr << std::endl;
236             }
237         }
238         else if (GenericType::getRows() == 1)
239         {
240             //row vector
241             std::wostringstream ostemp;
242             int iLastVal = this->m_iCols1PrintState;
243
244             for (int i = this->m_iCols1PrintState ; i < this->getCols() ; i++)
245             {
246                 int iWidth  = 0;
247                 int iLen    = 0;
248                 _piDims[0]  = 0;
249                 _piDims[1]  = i;
250                 int iPos    = ArrayOf<T>::getIndex(_piDims);
251
252                 if (isSigned())
253                 {
254                     getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
255                 }
256                 else
257                 {
258                     getUnsignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
259                 }
260
261                 iLen = iWidth + static_cast<int>(ostemp.str().size());
262                 if (iLen > iLineLen)
263                 {
264                     //Max length, new line
265                     iCurrentLine += 4; //"column x to Y" + empty line + value + empty line
266                     if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
267                     {
268                         this->m_iCols1PrintState = iLastVal;
269                         return false;
270                     }
271
272                     ostr << std::endl << L"       column " << iLastVal + 1 << L" to " << i << std::endl << std::endl;
273                     ostr << ostemp.str() << std::endl;
274                     ostemp.str(L"");
275                     iLastVal = i;
276                 }
277
278                 if (isSigned())
279                 {
280                     addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), iWidth);
281                 }
282                 else
283                 {
284                     addUnsignedIntValue(&ostemp, ArrayOf<T>::get(iPos), iWidth);
285                 }
286             }
287
288             if (iLastVal != 0)
289             {
290                 ostr << std::endl << L"       column " << iLastVal + 1 << L" to " << GenericType::getCols() << std::endl << std::endl;
291             }
292             ostemp << std::endl;
293             ostr << ostemp.str();
294         }
295         else // matrix
296         {
297             std::wostringstream ostemp;
298             int iLen = 0;
299             int iLastCol = this->m_iCols1PrintState;
300
301             //Array with the max printed size of each col
302             int *piSize = new int[GenericType::getCols()];
303             memset(piSize, 0x00, GenericType::getCols() * sizeof(int));
304
305             //compute the row size for padding for each printed bloc.
306             for (int iCols1 = this->m_iCols1PrintState ; iCols1 < this->getCols() ; iCols1++)
307             {
308                 for (int iRows1 = 0 ; iRows1 < this->getRows() ; iRows1++)
309                 {
310                     int iWidth  = 0;
311                     _piDims[0]  = iRows1;
312                     _piDims[1]  = iCols1;
313                     int iPos    = ArrayOf<T>::getIndex(_piDims);
314
315                     if (isSigned())
316                     {
317                         getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
318                     }
319                     else
320                     {
321                         getUnsignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
322                     }
323                     piSize[iCols1] = std::max(piSize[iCols1], iWidth);
324                 }
325
326                 if (iLen + piSize[iCols1] > iLineLen)
327                 {
328                     //find the limit, print this part
329                     for (int iRows2 = this->m_iRows2PrintState ; iRows2 < this->getRows() ; iRows2++)
330                     {
331                         iCurrentLine++;
332                         if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) ||
333                                 ( (iMaxLines != 0 && iCurrentLine + 3 >= iMaxLines && iRows2 == this->m_iRows2PrintState) ||
334                                   (iMaxLines != 0 && iCurrentLine + 1 >= iMaxLines && iRows2 != this->m_iRows2PrintState)))
335                         {
336                             if (this->m_iRows2PrintState == 0 && iRows2 != 0)
337                             {
338                                 //add header
339                                 ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
340                             }
341                             ostr << ostemp.str();
342                             this->m_iRows2PrintState = iRows2;
343                             this->m_iCols1PrintState = iLastCol;
344                             return false;
345                         }
346
347                         for (int iCols2 = iLastCol ; iCols2 < iCols1 ; iCols2++)
348                         {
349                             _piDims[0]  = iRows2;
350                             _piDims[1]  = iCols2;
351                             int iPos    = ArrayOf<T>::getIndex(_piDims);
352
353                             if (isSigned())
354                             {
355                                 addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
356                             }
357                             else
358                             {
359                                 addUnsignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
360                             }
361                         }
362                         ostemp << std::endl;
363                     }
364                     iLen = 0;
365
366                     iCurrentLine++;
367                     if (this->m_iRows2PrintState == 0)
368                     {
369                         iCurrentLine += 3;
370                         ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
371                     }
372
373                     ostr << ostemp.str();
374                     ostemp.str(L"");
375                     iLastCol = iCols1;
376                     this->m_iRows2PrintState = 0;
377                     this->m_iCols1PrintState = 0;
378                 }
379
380                 iLen += piSize[iCols1] + SIGN_LENGTH + SIZE_BETWEEN_TWO_VALUES;
381             }
382
383             for (int iRows2 = this->m_iRows2PrintState ; iRows2 < this->getRows() ; iRows2++)
384             {
385                 iCurrentLine++;
386                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
387                 {
388                     if (this->m_iRows2PrintState == 0 && iLastCol != 0)
389                     {
390                         //add header
391                         ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << GenericType::getCols() << std::endl << std::endl;
392                     }
393
394                     ostr << ostemp.str();
395                     this->m_iRows2PrintState = iRows2;
396                     this->m_iCols1PrintState = iLastCol;
397                     return false;
398                 }
399
400                 for (int iCols2 = iLastCol ; iCols2 < GenericType::getCols() ; iCols2++)
401                 {
402                     _piDims[0]  = iRows2;
403                     _piDims[1]  = iCols2;
404                     int iPos    = ArrayOf<T>::getIndex(_piDims);
405
406                     if (isSigned())
407                     {
408                         addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
409                     }
410                     else
411                     {
412                         addUnsignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
413                     }
414                 }
415                 ostemp << std::endl;
416             }
417
418             if (this->m_iRows2PrintState == 0 && iLastCol != 0)
419             {
420                 ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << GenericType::getCols() << std::endl << std::endl;
421             }
422             ostr << ostemp.str();
423         }
424
425         return true;
426     }
427
428     virtual T getNullValue()
429     {
430         return T(0);
431     }
432
433     virtual Int<T>* createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/)
434     {
435         return new Int<T>(_iDims, _piDims);
436     }
437
438     virtual T copyValue(T _data)
439     {
440         return _data;
441     }
442
443     virtual void deleteAll()
444     {
445         delete[] ArrayOf<T>::m_pRealData;
446         ArrayOf<T>::m_pRealData = NULL;
447         deleteImg();
448     }
449
450     virtual void deleteImg() { }
451
452     virtual T* allocData(int _iSize)
453     {
454         return new T[_iSize];
455     }
456
457     template<typename U, typename V> struct is_same_int
458     {
459         const static bool value = false;
460     };
461     template<typename U> struct is_same_int<U, U>
462     {
463         const static bool value = true;
464     };
465
466     bool isInt8()
467     {
468         return is_same_int<T, char>::value;
469     }
470     bool isInt16()
471     {
472         return is_same_int<T, short>::value;
473     }
474     bool isInt32()
475     {
476         return is_same_int<T, int>::value;
477     }
478     bool isInt64()
479     {
480         return is_same_int<T, long long>::value;
481     }
482     bool isUInt8()
483     {
484         return is_same_int<T, unsigned char>::value;
485     }
486     bool isUInt16()
487     {
488         return is_same_int<T, unsigned short>::value;
489     }
490     bool isUInt32()
491     {
492         return is_same_int<T, unsigned int>::value;
493     }
494     bool isUInt64()
495     {
496         return is_same_int<T, unsigned long long>::value;
497     }
498
499     bool isUnsigned()
500     {
501         return !isSigned();
502     }
503
504     bool isSigned()
505     {
506         return std::numeric_limits<T>::is_signed;
507     }
508 };
509
510 template<> inline InternalType::ScilabType Int<char>::getType()
511 {
512     return ScilabInt8;
513 }
514 template<> inline InternalType::ScilabType Int<unsigned char>::getType()
515 {
516     return ScilabUInt8;
517 }
518 template<> inline InternalType::ScilabType Int<short>::getType()
519 {
520     return ScilabInt16;
521 }
522 template<> inline InternalType::ScilabType Int<unsigned short>::getType()
523 {
524     return ScilabUInt16;
525 }
526 template<> inline InternalType::ScilabType Int<int>::getType()
527 {
528     return ScilabInt32;
529 }
530 template<> inline InternalType::ScilabType Int<unsigned int>::getType()
531 {
532     return ScilabUInt32;
533 }
534 template<> inline InternalType::ScilabType Int<long long>::getType()
535 {
536     return ScilabInt64;
537 }
538 template<> inline InternalType::ScilabType Int<unsigned long long>::getType()
539 {
540     return ScilabUInt64;
541 }
542
543 template<> inline InternalType::ScilabId Int<char>::getId()
544 {
545     return isScalar() ? IdScalarInt8 : IdInt8;
546 }
547 template<> inline InternalType::ScilabId Int<unsigned char>::getId()
548 {
549     return isScalar() ? IdScalarUInt8 : IdUInt8;
550 }
551 template<> inline InternalType::ScilabId Int<short>::getId()
552 {
553     return isScalar() ? IdScalarInt16 : IdInt16;
554 }
555 template<> inline InternalType::ScilabId Int<unsigned short>::getId()
556 {
557     return isScalar() ? IdScalarUInt16 : IdUInt16;
558 }
559 template<> inline InternalType::ScilabId Int<int>::getId()
560 {
561     return isScalar() ? IdScalarInt32 : IdInt32;
562 }
563 template<> inline InternalType::ScilabId Int<unsigned int>::getId()
564 {
565     return isScalar() ? IdScalarUInt32 : IdUInt32;
566 }
567 template<> inline InternalType::ScilabId Int<long long>::getId()
568 {
569     return isScalar() ? IdScalarInt64 : IdInt64;
570 }
571 template<> inline InternalType::ScilabId Int<unsigned long long>::getId()
572 {
573     return isScalar() ? IdScalarUInt64 : IdUInt64;
574 }
575
576 // Specializations
577 template<> inline std::wstring Int<char>::getTypeStr()
578 {
579     return L"int8";
580 }
581
582 template<> inline std::wstring Int<short>::getTypeStr()
583 {
584     return L"int16";
585 }
586
587 template<> inline std::wstring Int<int>::getTypeStr()
588 {
589     return L"int32";
590 }
591
592 template<> inline std::wstring Int<long long>::getTypeStr()
593 {
594     return L"int64";
595 }
596
597 template<> inline std::wstring Int<unsigned char>::getTypeStr()
598 {
599     return L"uint8";
600 }
601
602 template<> inline std::wstring Int<unsigned short>::getTypeStr()
603 {
604     return L"uint16";
605 }
606
607 template<> inline std::wstring Int<unsigned int>::getTypeStr()
608 {
609     return L"uint32";
610 }
611
612 template<> inline std::wstring Int<unsigned long long>::getTypeStr()
613 {
614     return L"uint64";
615 }
616
617 template<> inline void Int<char>::whoAmI()
618 {
619     std::cout << "types::Int8";
620 }
621
622 template<> inline void Int<short>::whoAmI()
623 {
624     std::cout << "types::Int16";
625 }
626
627 template<> inline void Int<int>::whoAmI()
628 {
629     std::cout << "types::Int32";
630 }
631
632 template<> inline void Int<long long>::whoAmI()
633 {
634     std::cout << "types::Int64";
635 }
636
637 template<> inline void Int<unsigned char>::whoAmI()
638 {
639     std::cout << "types::UInt8";
640 }
641
642 template<> inline void Int<unsigned short>::whoAmI()
643 {
644     std::cout << "types::UInt16";
645 }
646
647 template<> inline void Int<unsigned int>::whoAmI()
648 {
649     std::cout << "types::UInt32";
650 }
651
652 template<> inline void Int<unsigned long long>::whoAmI()
653 {
654     std::cout << "types::UInt64";
655 }
656
657
658 typedef Int<char> Int8;
659 typedef Int<short> Int16;
660 typedef Int<int> Int32;
661 typedef Int<long long> Int64;
662
663 typedef Int<unsigned char> UInt8;
664 typedef Int<unsigned short> UInt16;
665 typedef Int<unsigned int> UInt32;
666 typedef Int<unsigned long long> UInt64;
667
668 #ifdef _MSC_VER
669 template class Int<char>;
670 template class Int<unsigned char>;
671 template class Int<short>;
672 template class Int<unsigned short>;
673 template class Int<int>;
674 template class Int<unsigned int>;
675 template class Int<long long>;
676 template class Int<unsigned long long>;
677 #endif
678 }
679
680
681 #endif /* !__INT_HXX__ */