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