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