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