* Bug 15599 fixed: now degree of zero polynomial is -Inf
[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  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 *
14 */
15
16 // This code is separated in double.hxx
17 // but will be inlined in arrayof.hxx
18 //
19 // If you need additionnal headers, please add it in arrayof.hxx
20
21 //#ifndef __ARRAYOF_HXX__
22 //    #error This file must only be include by arrayof.hxx
23 //#endif
24
25 #ifndef __DOUBLE_HXX__
26 #define __DOUBLE_HXX__
27
28 #include "arrayof.hxx"
29 #include "bool.hxx"
30 #include "types_transposition.hxx"
31
32 namespace types
33 {
34 class EXTERN_AST Double : public ArrayOf<double>
35 {
36 public :
37     virtual                                             ~Double();
38
39     Double(double _dblReal);
40     Double(double _dblReal, double _dblImg);
41     Double(int _iRows, int _iCols, 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     Double(int _iDims, const int* _piDims, bool _bComplex = false, bool _bZComplex = false);
45
46     static Double*              Empty();
47     static Double*              Identity(int _iRows, int _iCols);
48     static Double*              Identity(int _iDims, const int* _piDims);
49     static Double*              Identity(int _iDims, const int* _piDims, double _dblReal);
50     static Double*              Identity(int _iDims, const int* _piDims, double _dblReal, double _dblImg);
51
52
53     /*data management*/
54     double*                     getReal() const;
55     double                      getReal(int _iRows, int _iCols);
56     bool                        setInt(int* _piReal); //to translate int to double matrix
57
58     /*zero or one set filler*/
59     bool                        setZeros();
60     bool                        setOnes();
61
62     /*Config management*/
63     void                        whoAmI();
64     bool                        isEmpty();
65
66     Double*                     clone();
67     bool                        fillFromCol(int _iCols, Double *_poSource);
68     bool                        fillFromRow(int _iRows, Double *_poSource);
69     Double*                     append(int _iRows, int _iCols, InternalType* _poSource);
70
71     //bool                        append(int _iRows, int _iCols, Double *_poSource);
72
73     bool                        operator==(const InternalType& it);
74     bool                        operator!=(const InternalType& it);
75
76     bool                        isDouble()
77     {
78         return true;
79     }
80
81     bool isComplex()
82     {
83         return (m_pImgData != NULL) || isViewAsZComplex();
84     }
85
86     inline bool isNumericallyComplex(double tolerance = 0)
87     {
88         if (isComplex())
89         {
90             int listSize = getSize();
91             double* bImg = getImg();
92             for (int i = 0; i < listSize; i++)
93             {
94                 if (abs(bImg[i]) > tolerance)
95                 {
96                     return false;
97                 }
98             }
99         }
100         return true;
101     }
102
103     bool isTrue();
104
105     bool neg(InternalType *& out)
106     {
107         if (isEmpty())
108         {
109             out = this;
110             return true;
111         }
112
113         return ArrayOf<double>::neg(out);
114     }
115
116     void                        setViewAsInteger(bool _bViewAsInteger = true)
117     {
118         m_bViewAsInteger = _bViewAsInteger;
119     }
120     bool                        isViewAsInteger()
121     {
122         return m_bViewAsInteger;
123     }
124
125     void                        convertToInteger();
126     void                        convertFromInteger();
127
128     void                        setViewAsZComplex(bool _bViewAsZComplex = true)
129     {
130         m_bViewAsZComplex = _bViewAsZComplex;
131     }
132     bool                        isViewAsZComplex()
133     {
134         return m_bViewAsZComplex;
135     }
136
137     void                        convertToZComplex();
138     void                        convertFromZComplex();
139
140     /* return type as string ( double, int, cell, list, ... )*/
141     virtual std::wstring        getTypeStr() const
142     {
143         return L"constant";
144     }
145     /* return type as short string ( s, i, ce, l, ... )*/
146     virtual std::wstring        getShortTypeStr() const
147     {
148         return L"s";
149     }
150
151     inline ScilabType           getType(void)
152     {
153         return ScilabDouble;
154     }
155     inline ScilabId             getId(void)
156     {
157         return isIdentity() ? isComplex() ? IdIdentityComplex : IdIdentity
158                : isEmpty() ? IdEmpty
159                : isComplex() ? isScalar() ? IdScalarDoubleComplex
160                : IdDoubleComplex
161                : isScalar() ? IdScalarDouble
162                : IdDouble;
163     }
164
165     inline bool conjugate(InternalType *& out)
166     {
167         if (isEmpty() || isIdentity() || !isComplex())
168         {
169             out = clone();
170             return true;
171         }
172
173         if (isScalar())
174         {
175             out = new Double(m_pRealData[0], -m_pImgData[0]);
176             return true;
177         }
178
179         if (m_iDims == 2)
180         {
181             Double * pReturn = new Double(getCols(), getRows(), true);
182             out = pReturn;
183
184             Transposition::conjugate(getSize(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
185             return true;
186         }
187
188         return false;
189
190     }
191
192     virtual bool adjoint(InternalType *& out)
193     {
194         if (isEmpty())
195         {
196             out = this;
197             return true;
198         }
199
200         if (isIdentity())
201         {
202             out = clone();
203             return true;
204         }
205
206         if (isScalar())
207         {
208             if (isComplex())
209             {
210                 out = new Double(m_pRealData[0], -m_pImgData[0]);
211             }
212             else
213             {
214                 out = clone();
215             }
216
217             return true;
218         }
219
220         if (m_iDims == 2)
221         {
222             Double * pReturn = new Double(getCols(), getRows(), isComplex());
223             out = pReturn;
224             if (isComplex())
225             {
226                 Transposition::adjoint(getRows(), getCols(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
227             }
228             else
229             {
230                 Transposition::adjoint(getRows(), getCols(), m_pRealData, pReturn->m_pRealData);
231             }
232
233             return true;
234         }
235
236         return false;
237     }
238
239     virtual bool transpose(InternalType *& out)
240     {
241         if (isEmpty())
242         {
243             out = this;
244             return true;
245         }
246
247         if (isIdentity() || isScalar())
248         {
249             out = clone();
250             return true;
251         }
252
253         if (m_iDims == 2)
254         {
255             Double * pReturn = new Double(getCols(), getRows(), isComplex());
256             out = pReturn;
257             if (isComplex())
258             {
259                 Transposition::transpose(getRows(), getCols(), m_pRealData, pReturn->m_pRealData, m_pImgData, pReturn->m_pImgData);
260             }
261             else
262             {
263                 Transposition::transpose(getRows(), getCols(), m_pRealData, pReturn->m_pRealData);
264             }
265
266             return true;
267         }
268
269         return false;
270     }
271
272     virtual ast::Exp*           getExp(const Location& loc);
273
274     virtual Double* set(int _iPos, const double _data)
275     {
276         if (_iPos >= m_iSize)
277         {
278             return NULL;
279         }
280
281         typedef Double* (Double::*set_t)(int, double);
282         Double* pIT = checkRef(this, (set_t)&Double::set, _iPos, _data);
283         if (pIT != this)
284         {
285             return pIT;
286         }
287
288         m_pRealData[_iPos] = _data;
289         return this;
290     }
291
292     virtual Double* set(int _iRows, int _iCols, const double _data)
293     {
294         return set(_iCols * getRows() + _iRows, _data);
295     }
296
297     virtual Double* set(double* _pdata)
298     {
299         if (m_pRealData == NULL)
300         {
301             return NULL;
302         }
303
304         typedef Double* (Double::*set_t)(double*);
305         Double* pIT = checkRef(this, (set_t)&Double::set, _pdata);
306         if (pIT != this)
307         {
308             return pIT;
309         }
310
311         for (int i = 0; i < m_iSize; i++)
312         {
313             m_pRealData[i] = _pdata[i];
314         }
315
316         return this;
317     }
318
319     virtual Double* set(const double* _pdata)
320     {
321         if (m_pRealData == NULL)
322         {
323             return NULL;
324         }
325
326         typedef Double* (Double::*set_t)(const double*);
327         Double* pIT = checkRef(this, (set_t)&Double::set, _pdata);
328         if (pIT != this)
329         {
330             return pIT;
331         }
332
333         for (int i = 0; i < m_iSize; i++)
334         {
335             m_pRealData[i] = _pdata[i];
336         }
337
338         return this;
339     }
340
341     virtual bool isNativeType() override
342     {
343         return true;
344     }
345
346     virtual void fillDefaultValues() override
347     {
348         int size = getSize();
349         memset(m_pRealData, 0x00, sizeof(double) * size);
350         if (isComplex())
351         {
352             memset(m_pImgData, 0x00, sizeof(double) * size);
353         }
354     }
355
356 private:
357     virtual bool                subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
358
359     virtual double              getNullValue();
360     virtual Double*             createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
361     virtual double              copyValue(double _dblData);
362     virtual void                deleteAll();
363     virtual void                deleteImg();
364     virtual double*             allocData(int _iSize);
365     virtual void                deleteData(double /*data*/) { }
366
367     bool                        m_bViewAsInteger;
368     bool                        m_bViewAsZComplex;
369
370 };
371 }
372
373 #ifdef _MSC_VER
374 template class types::ArrayOf<double>; //Double
375 #endif
376 #endif /* !__DOUBLE_HXX__ */