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