1cff17f0a2144a8665ec778fc5781b70c4d067bb
[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
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__ */