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