comparison equal and no equal
[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     virtual bool invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_list & out, ast::ConstVisitor & execFunc, const ast::CallExp & e)
155     {
156         if (isEmpty())
157         {
158             out.push_back(this);
159
160             return true;
161         }
162
163         return ArrayOf<double>::invoke(in, opt, _iRetCount, out, execFunc, e);
164     }
165
166     inline bool conjugate(InternalType *& out)
167     {
168         if (isEmpty() || isIdentity() || !isComplex())
169         {
170             out = clone();
171             return true;
172         }
173
174         if (isScalar())
175         {
176             out = new Double(m_pRealData[0], -m_pImgData[0]);
177             return true;
178         }
179
180         if (m_iDims == 2)
181         {
182             Double * pReturn = new Double(getCols(), getRows(), true);
183             out = pReturn;
184
185             Transposition::conjugate(getSize(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
186             return true;
187         }
188
189         return false;
190
191     }
192
193     virtual bool adjoint(InternalType *& out)
194     {
195         if (isEmpty())
196         {
197             out = this;
198             return true;
199         }
200
201         if (isIdentity())
202         {
203             out = clone();
204             return true;
205         }
206
207         if (isScalar())
208         {
209             if (isComplex())
210             {
211                 out = new Double(m_pRealData[0], -m_pImgData[0]);
212             }
213             else
214             {
215                 out = clone();
216             }
217
218             return true;
219         }
220
221         if (m_iDims == 2)
222         {
223             Double * pReturn = new Double(getCols(), getRows(), isComplex());
224             out = pReturn;
225             if (isComplex())
226             {
227                 Transposition::adjoint(getRows(), getCols(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
228             }
229             else
230             {
231                 Transposition::adjoint(getRows(), getCols(), m_pRealData, pReturn->m_pRealData);
232             }
233
234             return true;
235         }
236
237         return false;
238     }
239
240     virtual bool transpose(InternalType *& out)
241     {
242         if (isEmpty())
243         {
244             out = this;
245             return true;
246         }
247
248         if (isIdentity() || isScalar())
249         {
250             out = clone();
251             return true;
252         }
253
254         if (m_iDims == 2)
255         {
256             Double * pReturn = new Double(getCols(), getRows(), isComplex());
257             out = pReturn;
258             if (isComplex())
259             {
260                 Transposition::transpose(getRows(), getCols(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
261             }
262             else
263             {
264                 Transposition::transpose(getRows(), getCols(), m_pRealData, pReturn->m_pRealData);
265             }
266
267             return true;
268         }
269
270         return false;
271     }
272
273     virtual ast::Exp*           getExp(const Location& loc);
274
275 private :
276     virtual bool                subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims);
277
278     virtual double              getNullValue();
279     virtual Double*             createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
280     virtual double              copyValue(double _dblData);
281     virtual void                deleteAll();
282     virtual void                deleteImg();
283     virtual double*             allocData(int _iSize);
284
285     bool                        m_bViewAsInteger;
286     bool                        m_bViewAsZComplex;
287
288 };
289 }
290
291 #ifdef _MSC_VER
292 template class types::ArrayOf<double>; //Double
293 #endif
294 #endif /* !__DOUBLE_HXX__ */