Replace Min, Max and Abs by std::min, std::max and std::abs
[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 "tostring_common.hxx"
30
31 namespace types
32 {
33 template<typename T>
34 class EXTERN_AST Int : public ArrayOf<T>
35 {
36 public :
37
38     Int(int _iRows, int _iCols)
39     {
40         int piDims[2]   = {_iRows, _iCols};
41         T * pInt     = NULL;
42         this->create(piDims, 2, &pInt, NULL);
43 #ifndef NDEBUG
44         //Inspector::addItem(this);
45 #endif
46     }
47
48     Int(T _val)
49     {
50         int piDims[2]   = {1, 1};
51         T * pInt     = NULL;
52         this->create(piDims, 2, &pInt, NULL);
53         pInt[0] = _val;
54 #ifndef NDEBUG
55         //Inspector::addItem(this);
56 #endif
57     }
58
59     Int(int _iRows, int _iCols, T** _pData)
60     {
61         int piDims[2] = {_iRows, _iCols};
62         this->create(piDims, 2, _pData, NULL);
63 #ifndef NDEBUG
64         //Inspector::addItem(this);
65 #endif
66     }
67
68     Int(int _iDims, int* _piDims)
69     {
70         T * pInt     = NULL;
71         this->create(_piDims, _iDims, &pInt, NULL);
72 #ifndef NDEBUG
73         //Inspector::addItem(this);
74 #endif
75     }
76
77     ~Int()
78     {
79         if (InternalType::isDeletable() == true)
80         {
81             deleteAll();
82         }
83 #ifndef NDEBUG
84         //Inspector::removeItem(this);
85 #endif
86     }
87
88     InternalType* clone()
89     {
90         Int<T> *pbClone = new Int<T>(GenericType::getDims(), GenericType::getDimsArray());
91         pbClone->set(ArrayOf<T>::get());
92         return pbClone;
93     }
94
95     /*Config management*/
96     void whoAmI();
97
98     bool isInt()
99     {
100         return true;
101     }
102
103     bool neg(InternalType *& out)
104     {
105         out = new Int<T>(this->getDims(), this->getDimsArray());
106         type_traits::bin_neg<T, T>(this->m_iSize, this->m_pRealData, static_cast<Int<T> *>(out)->get());
107
108         return true;
109     }
110
111     virtual bool transpose(InternalType *& out)
112     {
113         return type_traits::transpose(*this, out);
114     }
115
116     bool operator==(const InternalType& it)
117     {
118         if (const_cast<InternalType &>(it).getType() != getType())
119         {
120             return false;
121         }
122
123         Int<T>* pb = const_cast<InternalType &>(it).getAs<typename types::Int<T> >();
124
125         if (pb->getDims() != GenericType::getDims())
126         {
127             return false;
128         }
129
130         for (int i = 0 ; i < GenericType::getDims() ; i++)
131         {
132             if (pb->getDimsArray()[i] != GenericType::getDimsArray()[i])
133             {
134                 return false;
135             }
136         }
137
138         if (memcmp(ArrayOf<T>::get(), pb->get(), GenericType::getSize() * sizeof(int)) != 0)
139         {
140             return false;
141         }
142         return true;
143     }
144
145     bool operator!=(const InternalType& it)
146     {
147         return !(*this == it);
148     }
149
150     /* return type as string ( double, int, cell, list, ... )*/
151     virtual std::wstring        getTypeStr();
152
153     /* return type as short string ( s, i, ce, l, ... )*/
154     virtual std::wstring        getShortTypeStr()
155     {
156         return L"i";
157     }
158
159 protected :
160     inline InternalType::ScilabType getType(void);
161     inline InternalType::ScilabId   getId(void);
162
163 private :
164     virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims)
165     {
166         int iCurrentLine = 0;
167         int iLineLen = ConfigVariable::getConsoleWidth();
168         int iMaxLines = ConfigVariable::getConsoleLines();
169
170         if (ArrayOf<T>::isScalar())
171         {
172             //scalar
173             int iWidth  = 0;
174             _piDims[0]  = 0;
175             _piDims[1]  = 0;
176             int iPos    = ArrayOf<T>::getIndex(_piDims);
177
178             getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
179             addSignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidth);
180             ostr << std::endl;
181         }
182         else if (GenericType::getCols() == 1)
183         {
184             //column vector
185             int iWidthMax = 0;
186
187             //Array with the max printed size of each col
188             for (int i = 0 ; i < GenericType::getRows() ; i++)
189             {
190                 _piDims[1] = 0;
191                 _piDims[0] = i;
192                 int iWidth = 0;
193                 int iPos = ArrayOf<T>::getIndex(_piDims);
194                 getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
195                 iWidthMax = std::max(iWidthMax, iWidth);
196             }
197
198             for (int i = this->m_iRows1PrintState ; i < this->getRows() ; i++)
199             {
200                 iCurrentLine++;
201                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
202                 {
203                     this->m_iRows1PrintState = i;
204                     return false;
205                 }
206
207                 _piDims[1]  = 0;
208                 _piDims[0]  = i;
209                 int iPos    = ArrayOf<T>::getIndex(_piDims);
210
211                 addSignedIntValue(&ostr, ArrayOf<T>::get(iPos), iWidthMax);
212                 ostr << std::endl;
213             }
214         }
215         else if (GenericType::getRows() == 1)
216         {
217             //row vector
218             std::wostringstream ostemp;
219             int iLastVal = this->m_iCols1PrintState;
220
221             for (int i = this->m_iCols1PrintState ; i < this->getCols() ; i++)
222             {
223                 int iWidth  = 0;
224                 int iLen    = 0;
225                 _piDims[0]  = 0;
226                 _piDims[1]  = i;
227                 int iPos    = ArrayOf<T>::getIndex(_piDims);
228
229                 getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
230                 iLen = iWidth + static_cast<int>(ostemp.str().size());
231                 if (iLen > iLineLen)
232                 {
233                     //Max length, new line
234                     iCurrentLine += 4; //"column x to Y" + empty line + value + empty line
235                     if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
236                     {
237                         this->m_iCols1PrintState = iLastVal;
238                         return false;
239                     }
240
241                     ostr << std::endl << L"       column " << iLastVal + 1 << L" to " << i << std::endl << std::endl;
242                     ostr << ostemp.str() << std::endl;
243                     ostemp.str(L"");
244                     iLastVal = i;
245                 }
246
247                 addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), iWidth);
248             }
249
250             if (iLastVal != 0)
251             {
252                 ostr << std::endl << L"       column " << iLastVal + 1 << L" to " << GenericType::getCols() << std::endl << std::endl;
253             }
254             ostemp << std::endl;
255             ostr << ostemp.str();
256         }
257         else // matrix
258         {
259             std::wostringstream ostemp;
260             int iLen = 0;
261             int iLastCol = this->m_iCols1PrintState;
262
263             //Array with the max printed size of each col
264             int *piSize = new int[GenericType::getCols()];
265             memset(piSize, 0x00, GenericType::getCols() * sizeof(int));
266
267             //compute the row size for padding for each printed bloc.
268             for (int iCols1 = this->m_iCols1PrintState ; iCols1 < this->getCols() ; iCols1++)
269             {
270                 for (int iRows1 = 0 ; iRows1 < this->getRows() ; iRows1++)
271                 {
272                     int iWidth  = 0;
273                     _piDims[0]  = iRows1;
274                     _piDims[1]  = iCols1;
275                     int iPos    = ArrayOf<T>::getIndex(_piDims);
276
277                     getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
278                     piSize[iCols1] = std::max(piSize[iCols1], iWidth);
279                 }
280
281                 if (iLen + piSize[iCols1] > iLineLen)
282                 {
283                     //find the limit, print this part
284                     for (int iRows2 = this->m_iRows2PrintState ; iRows2 < this->getRows() ; iRows2++)
285                     {
286                         iCurrentLine++;
287                         if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) ||
288                                 ( (iMaxLines != 0 && iCurrentLine + 3 >= iMaxLines && iRows2 == this->m_iRows2PrintState) ||
289                                   (iMaxLines != 0 && iCurrentLine + 1 >= iMaxLines && iRows2 != this->m_iRows2PrintState)))
290                         {
291                             if (this->m_iRows2PrintState == 0 && iRows2 != 0)
292                             {
293                                 //add header
294                                 ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
295                             }
296                             ostr << ostemp.str();
297                             this->m_iRows2PrintState = iRows2;
298                             this->m_iCols1PrintState = iLastCol;
299                             return false;
300                         }
301
302                         for (int iCols2 = iLastCol ; iCols2 < iCols1 ; iCols2++)
303                         {
304                             int iWidth  = 0;
305                             _piDims[0]  = iRows2;
306                             _piDims[1]  = iCols2;
307                             int iPos    = ArrayOf<T>::getIndex(_piDims);
308
309                             addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
310                         }
311                         ostemp << std::endl;
312                     }
313                     iLen = 0;
314
315                     iCurrentLine++;
316                     if (this->m_iRows2PrintState == 0)
317                     {
318                         iCurrentLine += 3;
319                         ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
320                     }
321
322                     ostr << ostemp.str();
323                     ostemp.str(L"");
324                     iLastCol = iCols1;
325                     this->m_iRows2PrintState = 0;
326                     this->m_iCols1PrintState = 0;
327                 }
328
329                 iLen += piSize[iCols1] + SIGN_LENGTH + SIZE_BETWEEN_TWO_VALUES;
330             }
331
332             for (int iRows2 = this->m_iRows2PrintState ; iRows2 < this->getRows() ; iRows2++)
333             {
334                 iCurrentLine++;
335                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
336                 {
337                     if (this->m_iRows2PrintState == 0 && iLastCol != 0)
338                     {
339                         //add header
340                         ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << GenericType::getCols() << std::endl << std::endl;
341                     }
342
343                     ostr << ostemp.str();
344                     this->m_iRows2PrintState = iRows2;
345                     this->m_iCols1PrintState = iLastCol;
346                     return false;
347                 }
348
349                 for (int iCols2 = iLastCol ; iCols2 < GenericType::getCols() ; iCols2++)
350                 {
351                     int iWidth  = 0;
352                     _piDims[0]  = iRows2;
353                     _piDims[1]  = iCols2;
354                     int iPos    = ArrayOf<T>::getIndex(_piDims);
355
356                     addSignedIntValue(&ostemp, ArrayOf<T>::get(iPos), piSize[iCols2]);
357                 }
358                 ostemp << std::endl;
359             }
360
361             if (this->m_iRows2PrintState == 0 && iLastCol != 0)
362             {
363                 ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << GenericType::getCols() << std::endl << std::endl;
364             }
365             ostr << ostemp.str();
366         }
367
368         return true;
369     }
370
371     virtual T getNullValue()
372     {
373         return T(0);
374     }
375
376     virtual Int<T>* createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/)
377     {
378         return new Int<T>(_iDims, _piDims);
379     }
380
381     virtual T copyValue(T _data)
382     {
383         return _data;
384     }
385
386     virtual void deleteAll()
387     {
388         delete[] ArrayOf<T>::m_pRealData;
389         ArrayOf<T>::m_pRealData = NULL;
390         deleteImg();
391     }
392
393     virtual void deleteImg() { }
394
395     virtual T* allocData(int _iSize)
396     {
397         return new T[_iSize];
398     }
399
400     template<typename U, typename V> struct is_same_int
401     {
402         const static bool value = false;
403     };
404     template<typename U> struct is_same_int<U, U>
405     {
406         const static bool value = true;
407     };
408
409     bool isInt8()
410     {
411         return is_same_int<T, char>::value;
412     }
413     bool isInt16()
414     {
415         return is_same_int<T, short>::value;
416     }
417     bool isInt32()
418     {
419         return is_same_int<T, int>::value;
420     }
421     bool isInt64()
422     {
423         return is_same_int<T, long long>::value;
424     }
425     bool isUInt8()
426     {
427         return is_same_int<T, unsigned char>::value;
428     }
429     bool isUInt16()
430     {
431         return is_same_int<T, unsigned short>::value;
432     }
433     bool isUInt32()
434     {
435         return is_same_int<T, unsigned int>::value;
436     }
437     bool isUInt64()
438     {
439         return is_same_int<T, unsigned long long>::value;
440     }
441 };
442
443 template<> inline InternalType::ScilabType Int<char>::getType()
444 {
445     return ScilabInt8;
446 }
447 template<> inline InternalType::ScilabType Int<unsigned char>::getType()
448 {
449     return ScilabUInt8;
450 }
451 template<> inline InternalType::ScilabType Int<short>::getType()
452 {
453     return ScilabInt16;
454 }
455 template<> inline InternalType::ScilabType Int<unsigned short>::getType()
456 {
457     return ScilabUInt16;
458 }
459 template<> inline InternalType::ScilabType Int<int>::getType()
460 {
461     return ScilabInt32;
462 }
463 template<> inline InternalType::ScilabType Int<unsigned int>::getType()
464 {
465     return ScilabUInt32;
466 }
467 template<> inline InternalType::ScilabType Int<long long>::getType()
468 {
469     return ScilabInt64;
470 }
471 template<> inline InternalType::ScilabType Int<unsigned long long>::getType()
472 {
473     return ScilabUInt64;
474 }
475
476 template<> inline InternalType::ScilabId Int<char>::getId()
477 {
478     return isScalar() ? IdScalarInt8 : IdInt8;
479 }
480 template<> inline InternalType::ScilabId Int<unsigned char>::getId()
481 {
482     return isScalar() ? IdScalarUInt8 : IdUInt8;
483 }
484 template<> inline InternalType::ScilabId Int<short>::getId()
485 {
486     return isScalar() ? IdScalarInt16 : IdInt16;
487 }
488 template<> inline InternalType::ScilabId Int<unsigned short>::getId()
489 {
490     return isScalar() ? IdScalarUInt16 : IdUInt16;
491 }
492 template<> inline InternalType::ScilabId Int<int>::getId()
493 {
494     return isScalar() ? IdScalarInt32 : IdInt32;
495 }
496 template<> inline InternalType::ScilabId Int<unsigned int>::getId()
497 {
498     return isScalar() ? IdScalarUInt32 : IdUInt32;
499 }
500 template<> inline InternalType::ScilabId Int<long long>::getId()
501 {
502     return isScalar() ? IdScalarInt64 : IdInt64;
503 }
504 template<> inline InternalType::ScilabId Int<unsigned long long>::getId()
505 {
506     return isScalar() ? IdScalarUInt64 : IdUInt64;
507 }
508
509 typedef Int<char> Int8;
510 typedef Int<short> Int16;
511 typedef Int<int> Int32;
512 typedef Int<long long> Int64;
513
514 typedef Int<unsigned char> UInt8;
515 typedef Int<unsigned short> UInt16;
516 typedef Int<unsigned int> UInt32;
517 typedef Int<unsigned long long> UInt64;
518
519 #ifdef _MSC_VER
520 template class Int<char>;
521 template class Int<unsigned char>;
522 template class Int<short>;
523 template class Int<unsigned short>;
524 template class Int<int>;
525 template class Int<unsigned int>;
526 template class Int<long long>;
527 template class Int<unsigned long long>;
528 #endif
529 }
530
531
532 #endif /* !__INT_HXX__ */