[ast] improved polynomial display with unicode superscripts
[scilab.git] / scilab / modules / ast / src / cpp / types / bool.cpp
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4 *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 *
14 */
15
16 #include <sstream>
17 #include "bool.hxx"
18 #include "boolexp.hxx"
19 #include "tostring_common.hxx"
20 #include "configvariable.hxx"
21 #include "type_traits.hxx"
22
23 extern "C"
24 {
25 #include "core_math.h"
26 }
27
28 namespace types
29 {
30 Bool::~Bool()
31 {
32     if (isDeletable() == true)
33     {
34         deleteAll();
35     }
36
37     delete m_pRealData;
38 #ifndef NDEBUG
39     Inspector::removeItem(this);
40 #endif
41 }
42
43 Bool::Bool(int _iRows, int _iCols)
44 {
45     int piDims[2]   = {_iRows, _iCols};
46     int *piBool = NULL;
47     create(piDims, 2, &piBool, NULL);
48 #ifndef NDEBUG
49     Inspector::addItem(this);
50 #endif
51 }
52
53 Bool::Bool(int _iReal)
54 {
55     int piDims[2]   = {1, 1};
56     int *piBool = NULL;
57     create(piDims, 2, &piBool, NULL);
58     piBool[0] = _iReal == 0 ? 0 : 1;
59 #ifndef NDEBUG
60     Inspector::addItem(this);
61 #endif
62 }
63
64 Bool::Bool(int _iRows, int _iCols, int **_piData)
65 {
66     int piDims[2] = {_iRows, _iCols};
67     create(piDims, 2, _piData, NULL);
68 #ifndef NDEBUG
69     Inspector::addItem(this);
70 #endif
71 }
72
73 Bool::Bool(int _iDims, const int* _piDims)
74 {
75     int* piData = NULL;
76     create(_piDims, _iDims, &piData, NULL);
77 #ifndef NDEBUG
78     Inspector::addItem(this);
79 #endif
80 }
81
82 Bool* Bool::clone()
83 {
84     Bool *pbClone =  new Bool(getDims(), getDimsArray());
85     pbClone->set(get());
86     return pbClone;
87 }
88
89 void Bool::whoAmI()
90 {
91     std::cout << "types::Bool";
92 }
93
94 Bool* Bool::setFalse()
95 {
96     Bool* pb = checkRef(this, &Bool::setFalse);
97     if (pb != this)
98     {
99         return pb;
100     }
101
102     int size = getSize();
103     for (int i = 0 ; i < size ; i++)
104     {
105         m_pRealData[i] = 0;
106     }
107
108     return this;
109 }
110
111 Bool* Bool::setTrue()
112 {
113     Bool* pb = checkRef(this, &Bool::setTrue);
114     if (pb != this)
115     {
116         return pb;
117     }
118
119     int size = getSize();
120     for (int i = 0; i < size; i++)
121     {
122         m_pRealData[i] = 1;
123     }
124
125     return this;
126 }
127
128 bool Bool::subMatrixToString(std::wostringstream& ostr, int* _piDims, int /*_iDims*/)
129 {
130     int iCurrentLine = 0;
131     int iLineLen = ConfigVariable::getConsoleWidth();
132     int iMaxLines = ConfigVariable::getConsoleLines();
133
134     if (isScalar())
135     {
136         //scalar
137         _piDims[0] = 0;
138         _piDims[1] = 0;
139         int iPos = getIndex(_piDims);
140         ostr << (get(iPos) == 1 ? L"  T" : L"  F");
141         ostr << std::endl;
142     }
143     else if (getCols() == 1)
144     {
145         //column vector
146         for (int i = m_iRows1PrintState ; i < getRows() ; i++)
147         {
148             iCurrentLine++;
149             if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
150             {
151                 m_iRows1PrintState = i;
152                 return false;
153             }
154
155             _piDims[1] = 0;
156             _piDims[0] = i;
157             int iPos = getIndex(_piDims);
158             ostr << (get(iPos) ? L"  T" : L"  F");
159             ostr << std::endl;
160         }
161     }
162     else if (getRows() == 1)
163     {
164         //row vector
165         std::wostringstream ostemp;
166         int iLastVal = m_iCols1PrintState;
167         int iLen = 0;
168
169         for (int i = m_iCols1PrintState ; i < getCols() ; i++)
170         {
171             _piDims[0] = 0;
172             _piDims[1] = i;
173             int iPos = getIndex(_piDims);
174
175             if (iLen + 2 >= iLineLen)
176             {
177                 iCurrentLine += 4; //"column x to Y" + empty line + value + empty line
178                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
179                 {
180                     m_iCols1PrintState = iLastVal;
181                     return false;
182                 }
183
184                 ostr << std::endl << L"       column " << iLastVal + 1 << L" to " << i << std::endl << std::endl;
185                 ostr << L" " << ostemp.str() << std::endl;
186                 ostemp.str(L"");
187                 iLastVal = i;
188                 iLen = 0;
189             }
190
191             ostemp << (get(iPos) ? L" T" : L" F");
192             iLen += 2;
193         }
194
195         if (iLastVal != 0)
196         {
197             ostr << std::endl << L"       column " << iLastVal + 1 << L" to " << getCols() << std::endl << std::endl;
198         }
199         ostr << L" " << ostemp.str() << std::endl;
200     }
201     else
202     {
203         std::wostringstream ostemp;
204         int iLen = 0;
205         int iLastCol = m_iCols1PrintState;
206
207         //compute the row size for padding for each printed bloc.
208         for (int iCols1 = m_iCols1PrintState ; iCols1 < getCols() ; iCols1++)
209         {
210             if (iLen + 2 > iLineLen)
211             {
212                 //find the limit, print this part
213                 for (int iRows2 = m_iRows2PrintState ; iRows2 < getRows() ; iRows2++)
214                 {
215                     iCurrentLine++;
216                     if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) ||
217                             ( (iMaxLines != 0 && iCurrentLine + 3 >= iMaxLines && iRows2 == m_iRows2PrintState) ||
218                               (iMaxLines != 0 && iCurrentLine + 1 >= iMaxLines && iRows2 != m_iRows2PrintState)))
219                     {
220                         if (m_iRows2PrintState == 0 && iRows2 != 0)
221                         {
222                             //add header
223                             ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
224                         }
225                         ostr << L" " << ostemp.str();
226                         m_iRows2PrintState = iRows2;
227                         m_iCols1PrintState = iLastCol;
228                         return false;
229                     }
230
231                     for (int iCols2 = iLastCol ; iCols2 < iCols1 ; iCols2++)
232                     {
233                         _piDims[0] = iRows2;
234                         _piDims[1] = iCols2;
235                         int iPos = getIndex(_piDims);
236                         ostemp << (get(iPos) == 0 ? L" F" : L" T");
237                     }
238                     ostemp << std::endl << L" ";
239                 }
240                 iLen = 0;
241                 iCurrentLine++;
242                 if (m_iRows2PrintState == 0)
243                 {
244                     iCurrentLine += 3;
245                     ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
246                 }
247
248                 ostr << L" " << ostemp.str();
249                 ostemp.str(L"");
250                 iLastCol = iCols1;
251                 m_iRows2PrintState = 0;
252                 m_iCols1PrintState = 0;
253             }
254             iLen += 2;
255         }
256
257         for (int iRows2 = m_iRows2PrintState ; iRows2 < getRows() ; iRows2++)
258         {
259             iCurrentLine++;
260             if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
261             {
262                 if (m_iRows2PrintState == 0 && iLastCol != 0)
263                 {
264                     //add header
265                     ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << getCols() << std::endl << std::endl;
266                 }
267
268                 ostr << ostemp.str();
269                 m_iRows2PrintState = iRows2;
270                 m_iCols1PrintState = iLastCol;
271                 return false;
272             }
273
274             for (int iCols2 = iLastCol ; iCols2 < getCols() ; iCols2++)
275             {
276                 _piDims[0] = iRows2;
277                 _piDims[1] = iCols2;
278                 int iPos = getIndex(_piDims);
279
280                 ostemp << (get(iPos) == 0 ? L" F" : L" T");
281             }
282             ostemp << std::endl << L" ";
283         }
284         if (m_iRows2PrintState == 0 && iLastCol != 0)
285         {
286             ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << getCols() << std::endl << std::endl;
287         }
288         ostr << L" " << ostemp.str();
289     }
290
291     return true;
292 }
293
294 bool Bool::operator==(const InternalType& it)
295 {
296     if (const_cast<InternalType &>(it).isBool() == false)
297     {
298         return false;
299     }
300
301     Bool* pb = const_cast<InternalType &>(it).getAs<types::Bool>();
302
303     if (pb->getDims() != getDims())
304     {
305         return false;
306     }
307
308     for (int i = 0 ; i < getDims() ; i++)
309     {
310         if (pb->getDimsArray()[i] != getDimsArray()[i])
311         {
312             return false;
313         }
314     }
315
316     if (memcmp(get(), pb->get(), getSize() * sizeof(int)) != 0)
317     {
318         return false;
319     }
320     return true;
321 }
322
323 bool Bool::operator!=(const InternalType& it)
324 {
325     return !(*this == it);
326 }
327
328 int Bool::getNullValue()
329 {
330     return 0;
331 }
332
333 Bool* Bool::createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/)
334 {
335     return new Bool(_iDims, _piDims);
336 }
337
338 int Bool::copyValue(int _iData)
339 {
340     return _iData == 0 ? 0 : 1;
341 }
342
343 void Bool::deleteAll()
344 {
345     delete[] m_pRealData;
346     m_pRealData = NULL;
347     deleteImg();
348 }
349
350 void Bool::deleteImg()
351 {
352 }
353
354 int* Bool::allocData(int _iSize)
355 {
356     return new int[_iSize];
357 }
358
359 ast::Exp* Bool::getExp(const Location& loc)
360 {
361     return new ast::BoolExp(loc, this);
362 }
363
364 bool Bool::transpose(InternalType *& out)
365 {
366     return type_traits::transpose(*this, out);
367 }
368
369 }