scilab/modules/ast/includes/types/double.hxx

   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 // This code is separated in double.hxx
  17 // but will be inlined in arrayof.hxx
  18 //
  19 // If you need additionnal headers, please add it in arrayof.hxx
  20
  21 //#ifndef __ARRAYOF_HXX__
  22 //    #error This file must only be include by arrayof.hxx
  23 //#endif
  24
  25 #ifndef __DOUBLE_HXX__
  26 #define __DOUBLE_HXX__
  27
  28 #include "arrayof.hxx"
  29 #include "bool.hxx"
  30 #include "types_transposition.hxx"
  31
  32 namespace types
  33 {
  34 class EXTERN_AST Double : public ArrayOf<double>
  35 {
  36 public :
  37     virtual                                             ~Double();
  38
  39     Double(double _dblReal);
  40     Double(double _dblReal, double _dblImg);
  41     Double(int _iRows, int _iCols, bool _bComplex = false, bool _bZComplex = false);
  42     Double(int _iRows, int _iCols, double **_pdblReal);
  43     Double(int _iRows, int _iCols, double **_pdblReal, double **_pdblImg);
  44     Double(int _iDims, const int* _piDims, bool _bComplex = false, bool _bZComplex = false);
  45
  46     static Double*              Empty();
  47     static Double*              Identity(int _iRows, int _iCols);
  48     static Double*              Identity(int _iDims, const int* _piDims);
  49     static Double*              Identity(int _iDims, const int* _piDims, double _dblReal);
  50     static Double*              Identity(int _iDims, const int* _piDims, double _dblReal, double _dblImg);
  51
  52
  53     /*data management*/
  54     double*                     getReal() const;
  55     double                      getReal(int _iRows, int _iCols);
  56     bool                        setInt(int* _piReal); //to translate int to double matrix
  57
  58     /*zero or one set filler*/
  59     bool                        setZeros();
  60     bool                        setOnes();
  61
  62     /*Config management*/
  63     void                        whoAmI();
  64     bool                        isEmpty();
  65
  66     Double*                     clone();
  67     bool                        fillFromCol(int _iCols, Double *_poSource);
  68     bool                        fillFromRow(int _iRows, Double *_poSource);
  69     Double*                     append(int _iRows, int _iCols, InternalType* _poSource);
  70
  71     //bool                        append(int _iRows, int _iCols, Double *_poSource);
  72
  73     bool                        operator==(const InternalType& it);
  74     bool                        operator!=(const InternalType& it);
  75
  76     bool                        isDouble()
  77     {
  78         return true;
  79     }
  80
  81     bool isComplex()
  82     {
  83         return (m_pImgData != NULL) || isViewAsZComplex();
  84     }
  85
  86     inline bool isNumericallyComplex(double tolerance = 0)
  87     {
  88         if (isComplex())
  89         {
  90             int listSize = getSize();
  91             double* bImg = getImg();
  92             for (int i = 0; i < listSize; i++)
  93             {
  94                 if (abs(bImg[i]) > tolerance)
  95                 {
  96                     return false;
  97                 }
  98             }
  99         }
 100         return true;
 101     }
 102
 103     bool isTrue();
 104
 105     bool neg(InternalType *& out)
 106     {
 107         if (isEmpty())
 108         {
 109             out = this;
 110             return true;
 111         }
 112
 113         return ArrayOf<double>::neg(out);
 114     }
 115
 116     void                        setViewAsInteger(bool _bViewAsInteger = true)
 117     {
 118         m_bViewAsInteger = _bViewAsInteger;
 119     }
 120     bool                        isViewAsInteger()
 121     {
 122         return m_bViewAsInteger;
 123     }
 124
 125     void                        convertToInteger();
 126     void                        convertFromInteger();
 127
 128     void                        setViewAsZComplex(bool _bViewAsZComplex = true)
 129     {
 130         m_bViewAsZComplex = _bViewAsZComplex;
 131     }
 132     bool                        isViewAsZComplex()
 133     {
 134         return m_bViewAsZComplex;
 135     }
 136
 137     void                        convertToZComplex();
 138     void                        convertFromZComplex();
 139
 140     /* return type as string ( double, int, cell, list, ... )*/
 141     virtual std::wstring        getTypeStr() const
 142     {
 143         return L"constant";
 144     }
 145     /* return type as short string ( s, i, ce, l, ... )*/
 146     virtual std::wstring        getShortTypeStr() const
 147     {
 148         return L"s";
 149     }
 150
 151     inline ScilabType           getType(void)
 152     {
 153         return ScilabDouble;
 154     }
 155     inline ScilabId             getId(void)
 156     {
 157         return isIdentity() ? isComplex() ? IdIdentityComplex : IdIdentity
 158                : isEmpty() ? IdEmpty
 159                : isComplex() ? isScalar() ? IdScalarDoubleComplex
 160                : IdDoubleComplex
 161                : isScalar() ? IdScalarDouble
 162                : IdDouble;
 163     }
 164
 165     inline bool conjugate(InternalType *& out)
 166     {
 167         if (isEmpty() || isIdentity() || !isComplex())
 168         {
 169             out = clone();
 170             return true;
 171         }
 172
 173         if (isScalar())
 174         {
 175             out = new Double(m_pRealData[0], -m_pImgData[0]);
 176             return true;
 177         }
 178
 179         if (m_iDims == 2)
 180         {
 181             Double * pReturn = new Double(getCols(), getRows(), true);
 182             out = pReturn;
 183
 184             Transposition::conjugate(getSize(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
 185             return true;
 186         }
 187
 188         return false;
 189
 190     }
 191
 192     virtual bool adjoint(InternalType *& out)
 193     {
 194         if (isEmpty())
 195         {
 196             out = this;
 197             return true;
 198         }
 199
 200         if (isIdentity())
 201         {
 202             out = clone();
 203             return true;
 204         }
 205
 206         if (isScalar())
 207         {
 208             if (isComplex())
 209             {
 210                 out = new Double(m_pRealData[0], -m_pImgData[0]);
 211             }
 212             else
 213             {
 214                 out = clone();
 215             }
 216
 217             return true;
 218         }
 219
 220         if (m_iDims == 2)
 221         {
 222             Double * pReturn = new Double(getCols(), getRows(), isComplex());
 223             out = pReturn;
 224             if (isComplex())
 225             {
 226                 Transposition::adjoint(getRows(), getCols(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
 227             }
 228             else
 229             {
 230                 Transposition::adjoint(getRows(), getCols(), m_pRealData, pReturn->m_pRealData);
 231             }
 232
 233             return true;
 234         }
 235
 236         return false;
 237     }
 238
 239     virtual bool transpose(InternalType *& out)
 240     {
 241         if (isEmpty())
 242         {
 243             out = this;
 244             return true;
 245         }
 246
 247         if (isIdentity() || isScalar())
 248         {
 249             out = clone();
 250             return true;
 251         }
 252
 253         if (m_iDims == 2)
 254         {
 255             Double * pReturn = new Double(getCols(), getRows(), isComplex());
 256             out = pReturn;
 257             if (isComplex())
 258             {
 259                 Transposition::transpose(getRows(), getCols(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
 260             }
 261             else
 262             {
 263                 Transposition::transpose(getRows(), getCols(), m_pRealData, pReturn->m_pRealData);
 264             }
 265
 266             return true;
 267         }
 268
 269         return false;
 270     }
 271
 272     virtual ast::Exp*           getExp(const Location& loc);
 273
 274     virtual Double* set(int _iPos, const double _data)
 275     {
 276         if (_iPos >= m_iSize)
 277         {
 278             return NULL;
 279         }
 280
 281         typedef Double* (Double::*set_t)(int, double);
 282         Double* pIT = checkRef(this, (set_t)&Double::set, _iPos, _data);
 283         if (pIT != this)
 284         {
 285             return pIT;
 286         }
 287
 288         m_pRealData[_iPos] = _data;
 289         return this;
 290     }
 291
 292     virtual Double* set(int _iRows, int _iCols, const double _data)
 293     {
 294         return set(_iCols * getRows() + _iRows, _data);
 295     }
 296
 297     virtual Double* set(double* _pdata)
 298     {
 299         if (m_pRealData == NULL)
 300         {
 301             return NULL;
 302         }
 303
 304         typedef Double* (Double::*set_t)(double*);
 305         Double* pIT = checkRef(this, (set_t)&Double::set, _pdata);
 306         if (pIT != this)
 307         {
 308             return pIT;
 309         }
 310
 311         for (int i = 0; i < m_iSize; i++)
 312         {
 313             m_pRealData[i] = _pdata[i];
 314         }
 315
 316         return this;
 317     }
 318
 319     virtual Double* set(const double* _pdata)
 320     {
 321         if (m_pRealData == NULL)
 322         {
 323             return NULL;
 324         }
 325
 326         typedef Double* (Double::*set_t)(const double*);
 327         Double* pIT = checkRef(this, (set_t)&Double::set, _pdata);
 328         if (pIT != this)
 329         {
 330             return pIT;
 331         }
 332
 333         for (int i = 0; i < m_iSize; i++)
 334         {
 335             m_pRealData[i] = _pdata[i];
 336         }
 337
 338         return this;
 339     }
 340
 341     virtual bool isNativeType() override
 342     {
 343         return true;
 344     }
 345
 346     virtual void fillDefaultValues() override
 347     {
 348         int size = getSize();
 349         memset(m_pRealData, 0x00, sizeof(double) * size);
 350         if (isComplex())
 351         {
 352             memset(m_pImgData, 0x00, sizeof(double) * size);
 353         }
 354     }
 355
 356 private:
 357     virtual bool                subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
 358
 359     virtual double              getNullValue();
 360     virtual Double*             createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
 361     virtual double              copyValue(double _dblData);
 362     virtual void                deleteAll();
 363     virtual void                deleteImg();
 364     virtual double*             allocData(int _iSize);
 365     virtual void                deleteData(double /*data*/) { }
 366
 367     bool                        m_bViewAsInteger;
 368     bool                        m_bViewAsZComplex;
 369
 370 };
 371 }
 372
 373 #ifdef _MSC_VER
 374 template class types::ArrayOf<double>; //Double
 375 #endif
 376 #endif /* !__DOUBLE_HXX__ */