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, 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 }