10f0093fc60a3485a98a7b14d01d21ebb7ab279f
[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, 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, int* _piDims);
46
47
48     /*data management*/
49     double*                     getReal() const;
50     double                      getReal(int _iRows, int _iCols);
51     bool                        setInt(int* _piReal); //to translate int to double matrix
52
53     /*zero or one set filler*/
54     bool                        setZeros();
55     bool                        setOnes();
56
57     /*Config management*/
58     void                        whoAmI();
59     bool                        isEmpty();
60
61     InternalType*               clone();
62     bool                        fillFromCol(int _iCols, Double *_poSource);
63     bool                        fillFromRow(int _iRows, Double *_poSource);
64     bool                        append(int _iRows, int _iCols, InternalType* _poSource);
65
66     //bool                        append(int _iRows, int _iCols, Double *_poSource);
67
68     bool                        operator==(const InternalType& it);
69     bool                        operator!=(const InternalType& it);
70
71     bool                        isDouble()
72     {
73         return true;
74     }
75
76
77     bool isTrue()
78     {
79         if (isEmpty() || isComplex())
80         {
81             return false;
82         }
83
84         return type_traits::isTrue<double>(m_iSize, m_pRealData);
85     }
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     virtual bool invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_list & out, ast::ConstVisitor & execFunc, const ast::CallExp & e)
148     {
149         if (isEmpty())
150         {
151             out.push_back(this);
152
153             return true;
154         }
155
156         return ArrayOf<double>::invoke(in, opt, _iRetCount, out, execFunc, e);
157     }
158
159     inline bool conjugate(InternalType *& out)
160     {
161         if (isEmpty() || isIdentity() || !isComplex())
162         {
163             out = clone();
164             return true;
165         }
166
167         if (isScalar())
168         {
169             out = new Double(m_pRealData[0], -m_pImgData[0]);
170             return true;
171         }
172
173         if (m_iDims == 2)
174         {
175             Double * pReturn = new Double(getCols(), getRows(), true);
176             out = pReturn;
177
178             Transposition::conjugate(getSize(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
179             return true;
180         }
181
182         return false;
183
184     }
185
186     virtual bool adjoint(InternalType *& out)
187     {
188         if (isEmpty())
189         {
190             out = this;
191             return true;
192         }
193
194         if (isIdentity())
195         {
196             out = clone();
197             return true;
198         }
199
200         if (isScalar())
201         {
202             if (m_bComplex)
203             {
204                 out = new Double(m_pRealData[0], -m_pImgData[0]);
205             }
206             else
207             {
208                 out = clone();
209             }
210
211             return true;
212         }
213
214         if (m_iDims == 2)
215         {
216             Double * pReturn = new Double(getCols(), getRows(), m_bComplex);
217             out = pReturn;
218             if (m_bComplex)
219             {
220                 Transposition::adjoint(getRows(), getCols(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
221             }
222             else
223             {
224                 Transposition::adjoint(getRows(), getCols(), m_pRealData, pReturn->m_pRealData);
225             }
226
227             return true;
228         }
229
230         return false;
231     }
232
233     virtual bool transpose(InternalType *& out)
234     {
235         if (isEmpty())
236         {
237             out = this;
238             return true;
239         }
240
241         if (isIdentity() || isScalar())
242         {
243             out = clone();
244             return true;
245         }
246
247         if (m_iDims == 2)
248         {
249             Double * pReturn = new Double(getCols(), getRows(), m_bComplex);
250             out = pReturn;
251             if (m_bComplex)
252             {
253                 Transposition::transpose(getRows(), getCols(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
254             }
255             else
256             {
257                 Transposition::transpose(getRows(), getCols(), m_pRealData, pReturn->m_pRealData);
258             }
259
260             return true;
261         }
262
263         return false;
264     }
265
266 private :
267     virtual bool                subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims);
268
269     virtual double              getNullValue();
270     virtual Double*             createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
271     virtual double              copyValue(double _dblData);
272     virtual void                deleteAll();
273     virtual void                deleteImg();
274     virtual double*             allocData(int _iSize);
275
276     bool                        m_bViewAsInteger;
277     bool                        m_bViewAsZComplex;
278
279 };
280 }
281
282 #ifdef _MSC_VER
283 template class types::ArrayOf<double>; //Double
284 #endif
285 #endif /* !__DOUBLE_HXX__ */