69bd760883c191ba19baf3fe72cc08ce601d333d
[scilab.git] / scilab / modules / ast / src / cpp / types / double.cpp
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 #include <sstream>
14 #include <math.h>
15 #include "double.hxx"
16 #include "tostring_common.hxx"
17 #include "scilabexception.hxx"
18 #include "configvariable.hxx"
19
20 extern "C"
21 {
22 #include <stdio.h>
23 #include "elem_common.h"
24 #include "localization.h"
25 #include "charEncoding.h"
26 #include "os_swprintf.h"
27 }
28
29 using namespace std;
30
31 namespace types
32 {
33 Double* Double::Empty()
34 {
35     return new Double(0, 0);
36 }
37
38 Double* Double::Identity(int _iRows, int _iCols)
39 {
40     double* pdbl = NULL;
41     Double* pI = new Double(_iRows, _iCols, &pdbl);
42     pI->setZeros();
43     for (int i = 0 ; i < Min(_iRows, _iCols) ; i++)
44     {
45         pI->set(i, i, 1);
46     }
47
48     if (_iRows == -1 && _iCols == -1)
49     {
50         pdbl[0] = 1;
51     }
52     return pI;
53 }
54
55 Double* Double::Identity(int _iDims, int* _piDims)
56 {
57     Double* pI = new Double(_iDims, _piDims);
58     pI->setZeros();
59     int iMinDim = _piDims[0];
60     for (int i = 1 ; i < _iDims ; i++)
61     {
62         if (_piDims[i] < iMinDim)
63         {
64             iMinDim = _piDims[i];
65         }
66     }
67
68     for (int i = 0 ; i < iMinDim ; i++)
69     {
70         int* piIndex = new int[_iDims];
71         for (int j = 0 ; j < _iDims ; j++)
72         {
73             piIndex[j] = i;
74         }
75
76         int index = getIndexWithDims(piIndex, _piDims, _iDims);
77         pI->set(index, 1);
78     }
79     return pI;
80 }
81
82 bool Double::isEmpty()
83 {
84     if (getDims() == 2 && getRows() == 0 && getCols() == 0)
85     {
86         return true;
87     }
88     return false;
89 }
90
91 Double::~Double()
92 {
93     if (isDeletable() == true)
94     {
95         deleteAll();
96     }
97 #ifndef NDEBUG
98     //Inspector::removeItem(this);
99 #endif
100 }
101
102 Double::Double(int _iRows, int _iCols, bool _bComplex, bool _bZComplex)
103 {
104     int piDims[2]   = {_iRows, _iCols};
105     double *pReal   = NULL;
106     double *pImg    = NULL;
107     setViewAsZComplex(_bZComplex);
108     if (_bComplex == false || _bZComplex)
109     {
110         create(piDims, 2, &pReal, NULL);
111     }
112     else
113     {
114         create(piDims, 2, &pReal, &pImg);
115     }
116
117     m_bComplex = _bComplex || _bZComplex;
118
119     setViewAsInteger(false);
120 #ifndef NDEBUG
121     //Inspector::addItem(this);
122 #endif
123 }
124
125 Double::Double(double _dblReal)
126 {
127     m_piDims[0] = 1;
128     m_piDims[1] = 1;
129     m_iDims = 2;
130     m_iRows = 1;
131     m_iCols = 1;
132     m_iSize = 1;
133     m_iSizeMax = m_iSize;
134     m_pRealData = new double[1];
135     setViewAsInteger(false);
136     setViewAsZComplex(false);
137
138     m_pRealData[0] = _dblReal;
139
140     //      int piDims[2] = {1, 1};
141     //double *pdblVal;
142     //create(piDims, 2, &pdblVal, NULL);
143     //pdblVal[0] = _dblReal;
144 #ifndef NDEBUG
145     //Inspector::addItem(this);
146 #endif
147 }
148
149 Double::Double(double _dblReal, double _dblImg)
150 {
151     int piDims[2] = {1, 1};
152     double *pdblR;
153     double *pdblI;
154     setViewAsInteger(false);
155     setViewAsZComplex(false);
156     create(piDims, 2, &pdblR, &pdblI);
157
158     pdblR[0] = _dblReal;
159     pdblI[0] = _dblImg;
160 #ifndef NDEBUG
161     //Inspector::addItem(this);
162 #endif
163 }
164
165 Double::Double(int _iRows, int _iCols, double **_pdblReal)
166 {
167     int piDims[2] = {_iRows, _iCols};
168     setViewAsInteger(false);
169     setViewAsZComplex(false);
170     create(piDims, 2, _pdblReal, NULL);
171
172 #ifndef NDEBUG
173     //Inspector::addItem(this);
174 #endif
175 }
176
177 Double::Double(int _iRows, int _iCols, double **_pdblReal, double **_pdblImg)
178 {
179     int piDims[2] = {_iRows, _iCols};
180     setViewAsInteger(false);
181     setViewAsZComplex(false);
182     create(piDims, 2, _pdblReal, _pdblImg);
183
184 #ifndef NDEBUG
185     //Inspector::addItem(this);
186 #endif
187 }
188
189 Double::Double(int _iDims, int* _piDims, bool _bComplex, bool _bZComplex)
190 {
191     double *pReal   = NULL;
192     double *pImg        = NULL;
193     setViewAsZComplex(_bZComplex);
194     setViewAsInteger(false);
195
196     if (_bComplex == false || _bZComplex)
197     {
198         create(_piDims, _iDims, &pReal, NULL);
199     }
200     else
201     {
202         create(_piDims, _iDims, &pReal, &pImg);
203     }
204
205     m_bComplex = _bComplex || _bZComplex;
206
207 #ifndef NDEBUG
208     //Inspector::addItem(this);
209 #endif
210 }
211
212 double* Double::getReal() const
213 {
214     return get();
215 }
216
217 double Double::getReal(int _iRows, int _iCols)
218 {
219     return get(_iRows, _iCols);
220 }
221
222 bool Double::setInt(int* _piReal)
223 {
224     bool ret = true;
225     for (int i = 0 ; i < m_iSize ; i++)
226     {
227         ret = set(i, static_cast<double>(_piReal[i]));
228         if (ret == false)
229         {
230             return false;
231         }
232     }
233     return true;
234 }
235
236 void Double::whoAmI()
237 {
238     std::cout << "types::Double";
239 }
240
241 bool Double::setZeros()
242 {
243     if (m_pRealData != NULL)
244     {
245         memset(m_pRealData, 0x00, m_iSize * sizeof(double));
246     }
247     else
248     {
249         return false;
250     }
251
252     if (m_bComplex == true)
253     {
254         if (m_pImgData != NULL)
255         {
256             memset(m_pImgData, 0x00, m_iSize * sizeof(double));
257         }
258         else
259         {
260             return false;
261         }
262     }
263     return true;
264 }
265
266 bool Double::setOnes()
267 {
268     if (m_pRealData != NULL)
269     {
270         std::fill(m_pRealData, m_pRealData + m_iSize, 1);
271         //for(int iIndex = 0 ; iIndex < m_iSize ; iIndex++)
272         //{
273         //      m_pRealData[iIndex] = 1;
274         //}
275     }
276     else
277     {
278         return false;
279     }
280
281     if (m_bComplex == true)
282     {
283         if (m_pImgData != NULL)
284         {
285             std::fill(m_pImgData, m_pImgData + m_iSize, 1);
286         }
287         else
288         {
289             return false;
290         }
291     }
292     return true;
293 }
294
295 bool Double::subMatrixToString(wostringstream& ostr, int* _piDims, int _iDims)
296 {
297     int iCurrentLine = 0;
298     int iLineLen = ConfigVariable::getConsoleWidth();
299     int iMaxLines = ConfigVariable::getConsoleLines();
300
301     if (isIdentity())
302     {
303         ostr << L"eye *" << endl << endl;
304         if (isComplex() == false)
305         {
306             DoubleFormat df;
307             getDoubleFormat((m_pRealData[0]), &df);
308             addDoubleValue(&ostr, (m_pRealData[0]), &df);
309             ostr << endl;
310         }
311         else
312         {
313             //complex value
314             DoubleFormat dfR, dfI;
315             getDoubleFormat(ZeroIsZero(m_pRealData[0]), &dfR);
316             getDoubleFormat(ZeroIsZero(m_pImgData[0]), &dfI);
317             addDoubleComplexValue(&ostr, ZeroIsZero(m_pRealData[0]), ZeroIsZero(m_pImgData[0]), dfR.iWidth + dfI.iWidth, &dfR, &dfI);
318             ostr << endl;
319         }
320         ostr << endl;
321     }
322     else if (isEmpty())
323     {
324         ostr << L"    []";
325         ostr << endl;
326     }
327     else if (isScalar())
328     {
329         //scalar
330         _piDims[0] = 0;
331         _piDims[1] = 0;
332         int iPos = getIndex(_piDims);
333
334         if (isComplex() == false)
335         {
336             DoubleFormat df;
337             getDoubleFormat((m_pRealData[iPos]), &df);
338             ostr << SPACE_BETWEEN_TWO_VALUES;
339             addDoubleValue(&ostr, (m_pRealData[iPos]), &df);
340             ostr << endl;
341         }
342         else
343         {
344             //complex value
345             DoubleFormat dfR, dfI;
346             getDoubleFormat(ZeroIsZero(m_pRealData[iPos]), &dfR);
347             getDoubleFormat(ZeroIsZero(m_pImgData[iPos]), &dfI);
348             ostr << SPACE_BETWEEN_TWO_VALUES;
349             addDoubleComplexValue(&ostr, ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), dfR.iWidth + dfI.iWidth, &dfR, &dfI);
350             ostr << endl;
351         }
352     }
353     else if (getCols() == 1)
354     {
355         //column vector
356
357         if (isComplex() == false)
358         {
359             for (int i = m_iRows1PrintState ; i < getRows() ; i++)
360             {
361                 iCurrentLine++;
362                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
363                 {
364                     m_iRows1PrintState = i;
365                     return false;
366                 }
367
368                 _piDims[1] = 0;
369                 _piDims[0] = i;
370                 int iPos = getIndex(_piDims);
371
372                 DoubleFormat df;
373                 getDoubleFormat(ZeroIsZero(m_pRealData[iPos]), &df);
374                 ostr << SPACE_BETWEEN_TWO_VALUES;
375                 addDoubleValue(&ostr, ZeroIsZero(m_pRealData[iPos]), &df);
376                 ostr << endl;
377             }
378         }
379         else
380         {
381             for (int i = m_iRows1PrintState ; i < getRows() ; i++)
382             {
383                 //complex value
384                 iCurrentLine++;
385                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
386                 {
387                     m_iRows1PrintState = i;
388                     return false;
389                 }
390
391                 _piDims[1] = 0;
392                 _piDims[0] = i;
393                 int iPos = getIndex(_piDims);
394
395                 DoubleFormat dfR, dfI;
396                 getDoubleFormat(ZeroIsZero(m_pRealData[iPos]), &dfR);
397                 getDoubleFormat(ZeroIsZero(m_pImgData[iPos]), &dfI);
398
399                 ostr << SPACE_BETWEEN_TWO_VALUES;
400                 addDoubleComplexValue(&ostr, ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), dfR.iWidth + dfI.iWidth, &dfR, &dfI);
401                 ostr << endl;
402             }
403         }
404     }
405     else if (getRows() == 1)
406     {
407         //row vector
408         wostringstream ostemp;
409         int iLastVal = m_iCols1PrintState;
410
411         if (isComplex() == false)
412         {
413             for (int i = m_iCols1PrintState ; i < getCols() ; i++)
414             {
415                 int iLen = 0;
416                 _piDims[0] = 0;
417                 _piDims[1] = i;
418                 int iPos = getIndex(_piDims);
419
420                 DoubleFormat df;
421                 getDoubleFormat(ZeroIsZero(m_pRealData[iPos]), &df);
422                 iLen = df.iWidth + static_cast<int>(ostemp.str().size());
423                 if (iLen > iLineLen)
424                 {
425                     //Max length, new line
426                     iCurrentLine += 4; //"column x to Y" + empty line + value + empty line
427                     if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
428                     {
429                         m_iCols1PrintState = iLastVal;
430                         ostr << endl << endl;
431                         return false;
432                     }
433
434                     ostr << endl << L"       column " << iLastVal + 1 << L" to " << i << endl << endl;
435                     ostr << ostemp.str() << endl;
436                     ostemp.str(L"");
437                     iLastVal = i;
438                 }
439
440                 ostemp << SPACE_BETWEEN_TWO_VALUES;
441                 addDoubleValue(&ostemp, ZeroIsZero(m_pRealData[iPos]), &df);
442             }
443
444             if (iLastVal != 0)
445             {
446                 ostr << endl << L"       column " << iLastVal + 1 << L" to " << getCols() << endl << endl;
447             }
448             ostemp << endl;
449             ostr << ostemp.str();
450         }
451         else //complex case
452         {
453             for (int i = m_iCols1PrintState ; i < getCols() ; i++)
454             {
455                 int iLen = 0;
456                 _piDims[0] = 0;
457                 _piDims[1] = i;
458                 int iTotalLen = 0;
459                 int iPos = getIndex(_piDims);
460
461                 DoubleFormat dfR, dfI;
462                 getComplexFormat(ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), &iTotalLen, &dfR, &dfI);
463
464                 iLen = static_cast<int>(ostemp.str().size());
465                 if (isRealZero(m_pImgData[iPos]))
466                 {
467                     if (isRealZero(m_pRealData[iPos]))
468                     {
469                         iLen += 1; //"0"
470                     }
471                     else
472                     {
473                         iLen            += dfR.iWidth;
474                         dfI.iWidth      = 0;
475                     }
476                 }
477                 else
478                 {
479                     if (isRealZero(m_pRealData[iPos]))
480                     {
481                         iLen            += dfI.iWidth;
482                         dfR.iWidth      = 0;
483                     }
484                     else
485                     {
486                         iLen += dfR.iWidth;
487                         iLen += SIZE_BETWEEN_REAL_COMPLEX;
488                         iLen += dfI.iWidth;
489                     }
490                 }
491
492                 if (iLen > iLineLen)
493                 {
494                     //Max length, new line
495                     iCurrentLine += 4; //"column x to Y" + empty line + value + empty line
496                     if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
497                     {
498                         m_iCols1PrintState = iLastVal;
499                         ostr << endl << endl;
500                         return false;
501                     }
502
503                     ostr << endl << L"       column " << iLastVal + 1 << L" to " << i << endl << endl;
504                     ostr << ostemp.str() << endl;
505                     ostemp.str(L"");
506                     iLastVal = i;
507                 }
508
509                 ostemp << SPACE_BETWEEN_TWO_VALUES;
510                 addDoubleComplexValue(&ostemp, ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), iLen, &dfR, &dfI);
511             }
512
513             if (iLastVal != 0)
514             {
515                 ostr << endl << L"       column " << iLastVal + 1 << L" to " << getCols() << endl << endl;
516             }
517             ostemp << endl;
518             ostr << ostemp.str();
519         }
520     }
521     else // matrix
522     {
523         wostringstream ostemp;
524         int iLen = 0;
525         int iLastCol = m_iCols1PrintState;
526
527         //Array with the max printed size of each col
528         int *piSize = new int[getCols()];
529         memset(piSize, 0x00, getCols() * sizeof(int));
530
531         if (isComplex() == false)
532         {
533             //compute the row size for padding for each printed bloc.
534             for (int iCols1 = m_iCols1PrintState ; iCols1 < getCols() ; iCols1++)
535             {
536                 for (int iRows1 = 0 ; iRows1 < getRows() ; iRows1++)
537                 {
538                     int iCurrentLen = 0;
539                     _piDims[0] = iRows1;
540                     _piDims[1] = iCols1;
541                     int iPos = getIndex(_piDims);
542
543                     DoubleFormat df;
544                     getDoubleFormat(ZeroIsZero(m_pRealData[iPos]), &df);
545                     iCurrentLen = df.iWidth;
546
547                     if (iCurrentLen > piSize[iCols1])
548                     {
549                         piSize[iCols1] = iCurrentLen;
550                     }
551                 }
552
553                 if (iLen + piSize[iCols1] > iLineLen)
554                 {
555                     //find the limit, print this part
556                     for (int iRows2 = m_iRows2PrintState ; iRows2 < getRows() ; iRows2++)
557                     {
558                         iCurrentLine++;
559                         if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) ||
560                                 ( (iMaxLines != 0 && iCurrentLine + 3 >= iMaxLines && iRows2 == m_iRows2PrintState) ||
561                                   (iMaxLines != 0 && iCurrentLine + 1 >= iMaxLines && iRows2 != m_iRows2PrintState)))
562                         {
563                             if (m_iRows2PrintState == 0 && iRows2 != 0)
564                             {
565                                 //add header
566                                 ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
567                             }
568                             ostr << ostemp.str();
569                             m_iRows2PrintState = iRows2;
570                             m_iCols1PrintState = iLastCol;
571                             return false;
572                         }
573
574                         for (int iCols2 = iLastCol ; iCols2 < iCols1 ; iCols2++)
575                         {
576                             _piDims[0] = iRows2;
577                             _piDims[1] = iCols2;
578                             int iPos = getIndex(_piDims);
579
580                             DoubleFormat df;
581                             getDoubleFormat(ZeroIsZero(m_pRealData[iPos]), &df);
582
583                             ostemp << SPACE_BETWEEN_TWO_VALUES;
584
585                             df.iWidth = piSize[iCols2];
586                             addDoubleValue(&ostemp, ZeroIsZero(m_pRealData[iPos]), &df);
587                         }
588                         ostemp << endl;
589                     }
590
591                     iLen = 0;
592
593                     iCurrentLine++;
594                     if (m_iRows2PrintState == 0)
595                     {
596                         iCurrentLine += 3;
597                         ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
598                     }
599                     ostr << ostemp.str();
600                     ostemp.str(L"");
601                     iLastCol = iCols1;
602                     m_iRows2PrintState = 0;
603                     m_iCols1PrintState = 0;
604                 }
605
606                 iLen += piSize[iCols1] + SIGN_LENGTH + SIZE_BETWEEN_TWO_VALUES;
607             }
608
609             for (int iRows2 = m_iRows2PrintState ; iRows2 < getRows() ; iRows2++)
610             {
611                 iCurrentLine++;
612                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
613                 {
614                     if (m_iRows2PrintState == 0 && iLastCol != 0)
615                     {
616                         //add header
617                         ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << getCols() << std::endl << std::endl;
618                     }
619
620                     ostr << ostemp.str();
621                     m_iRows2PrintState = iRows2;
622                     m_iCols1PrintState = iLastCol;
623                     return false;
624                 }
625
626                 for (int iCols2 = iLastCol ; iCols2 < getCols() ; iCols2++)
627                 {
628                     _piDims[0] = iRows2;
629                     _piDims[1] = iCols2;
630                     int iPos = getIndex(_piDims);
631
632                     DoubleFormat df;
633                     getDoubleFormat(ZeroIsZero(m_pRealData[iPos]), &df);
634
635                     ostemp << SPACE_BETWEEN_TWO_VALUES;
636                     df.iWidth = piSize[iCols2];
637                     addDoubleValue(&ostemp, ZeroIsZero(m_pRealData[iPos]), &df);
638                 }
639                 ostemp << endl;
640             }
641
642             if (m_iRows2PrintState == 0 && iLastCol != 0)
643             {
644                 ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << getCols() << std::endl << std::endl;
645             }
646             ostr << ostemp.str();
647         }
648         else //Complex case
649         {
650             //compute the row size for padding for each printed bloc.
651             for (int iCols1 = m_iCols1PrintState ; iCols1 < getCols() ; iCols1++)
652             {
653                 for (int iRows1 = 0 ; iRows1 < getRows() ; iRows1++)
654                 {
655                     int iTotalWidth = 0;
656                     _piDims[0] = iRows1;
657                     _piDims[1] = iCols1;
658                     int iPos = getIndex(_piDims);
659
660                     DoubleFormat dfR, dfI;
661                     getComplexFormat(ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), &iTotalWidth, &dfR, &dfI);
662
663                     iTotalWidth += (dfR.iWidth == 0 ? 0 : SIGN_LENGTH) + (dfI.iWidth == 0 ? 0 : SIGN_LENGTH + 1);
664                     if (iTotalWidth > piSize[iCols1])
665                     {
666                         piSize[iCols1] = iTotalWidth;
667                     }
668                 }
669
670                 if (iLen + piSize[iCols1] > iLineLen)
671                 {
672                     //find the limit, print this part
673                     for (int iRows2 = m_iRows2PrintState ; iRows2 < getRows() ; iRows2++)
674                     {
675                         iCurrentLine++;
676                         if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) ||
677                                 ( (iMaxLines != 0 && iCurrentLine + 3 >= iMaxLines && iRows2 == m_iRows2PrintState) ||
678                                   (iMaxLines != 0 && iCurrentLine + 1 >= iMaxLines && iRows2 != m_iRows2PrintState)))
679                         {
680                             if (m_iRows2PrintState == 0 && iRows2 != 0)
681                             {
682                                 //add header
683                                 ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
684                             }
685                             ostr << ostemp.str();
686                             m_iRows2PrintState = iRows2;
687                             m_iCols1PrintState = iLastCol;
688                             return false;
689                         }
690
691                         for (int iCols2 = iLastCol ; iCols2 < iCols1 ; iCols2++)
692                         {
693                             int iTotalWidth = 0;
694                             _piDims[0] = iRows2;
695                             _piDims[1] = iCols2;
696                             int iPos = getIndex(_piDims);
697
698                             DoubleFormat dfR, dfI;
699                             getComplexFormat(ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), &iTotalWidth, &dfR, &dfI);
700
701                             ostemp << SPACE_BETWEEN_TWO_VALUES;
702                             addDoubleComplexValue(&ostemp, ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), piSize[iCols2], &dfR, &dfI);
703                         }
704                         ostemp << endl;
705                     }
706
707                     iLen = 0;
708
709                     iCurrentLine++;
710                     if (m_iRows2PrintState == 0)
711                     {
712                         iCurrentLine += 3;
713                         ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << iCols1 << std::endl << std::endl;
714                     }
715                     ostr << ostemp.str();
716                     ostemp.str(L"");
717                     iLastCol = iCols1;
718                     m_iRows2PrintState = 0;
719                     m_iCols1PrintState = 0;
720                 }
721
722                 iLen += piSize[iCols1] + SIZE_BETWEEN_TWO_VALUES;
723             }
724
725             for (int iRows2 = m_iRows2PrintState ; iRows2 < getRows() ; iRows2++)
726             {
727                 iCurrentLine++;
728                 if ((iMaxLines == 0 && iCurrentLine >= MAX_LINES) || (iMaxLines != 0 && iCurrentLine >= iMaxLines))
729                 {
730                     if (m_iRows2PrintState == 0 && iLastCol != 0)
731                     {
732                         //add header
733                         ostr << std::endl << L"       column " << iLastCol + 1 << L" to " << getCols() << std::endl << std::endl;
734                     }
735
736                     ostr << ostemp.str();
737                     m_iRows2PrintState = iRows2;
738                     m_iCols1PrintState = iLastCol;
739                     return false;
740                 }
741
742                 for (int iCols2 = iLastCol ; iCols2 < getCols() ; iCols2++)
743                 {
744                     int iTotalWidth = 0;
745                     _piDims[0] = iRows2;
746                     _piDims[1] = iCols2;
747                     int iPos = getIndex(_piDims);
748
749                     DoubleFormat dfR, dfI;
750                     getComplexFormat(ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), &iTotalWidth, &dfR, &dfI);
751
752                     ostemp << SPACE_BETWEEN_TWO_VALUES;
753                     addDoubleComplexValue(&ostemp, ZeroIsZero(m_pRealData[iPos]), ZeroIsZero(m_pImgData[iPos]), piSize[iCols2], &dfR, &dfI);
754                 }
755                 ostemp << endl;
756             }
757
758             if (m_iRows2PrintState == 0 && iLastCol != 0)
759             {
760                 ostr << endl << L"       column " << iLastCol + 1 << L" to " << getCols() << endl << endl;
761             }
762             ostr << ostemp.str();
763         }
764     }
765
766     return true;
767 }
768
769 InternalType* Double::clone()
770 {
771     int iOne = 1;
772     Double *pReturn = new Double(m_iDims, m_piDims, m_bComplex);
773     //memcpy(pReturn->getReal(), m_pRealData, m_iSize * sizeof(double));
774     dcopy_(&m_iSize, m_pRealData, &iOne, pReturn->getReal(), &iOne);
775
776     if (m_bComplex)
777     {
778         pReturn->setComplex(true);
779         //memcpy(pReturn->getImg(), m_pImgData, m_iSize * sizeof(double));
780         dcopy_(&m_iSize, m_pImgData, &iOne, pReturn->getImg(), &iOne);
781     }
782     return pReturn;
783 }
784
785 bool Double::fillFromCol(int _iCols, Double *_poSource)
786 {
787     //blas
788     int iDestOffset     = _iCols * m_iRows;
789     int iSize           = _poSource->getSize();
790     double* pdblDest    = m_pRealData + iDestOffset;
791     int iOne            = 1;
792     dcopy_(&iSize, _poSource->getReal(), &iOne, pdblDest, &iOne);
793
794     if (m_bComplex)
795     {
796         pdblDest    = m_pImgData + iDestOffset;
797         dcopy_(&iSize, _poSource->getImg(), &iOne, pdblDest, &iOne);
798     }
799     return true;
800 }
801
802 bool Double::fillFromRow(int _iRows, Double *_poSource)
803 {
804     int iCols = _poSource->getCols();
805
806     if (m_bComplex)
807     {
808     }
809     else
810     {
811         for (int i = 0 ; i < iCols ; i++)
812         {
813             int iDestOffset     = i * m_iRows + _iRows;
814             int iOrigOffset     = i * _poSource->getRows();
815             int iSize           = _poSource->getRows();
816             double* pdblDest    = m_pRealData + iDestOffset;
817             double* pdblSource  = _poSource->getReal() + iOrigOffset;
818             int iOne            = 1;
819
820             dcopy_(&iSize, pdblSource, &iOne, pdblDest, &iOne);
821         }
822     }
823     return true;
824 }
825
826 bool Double::operator==(const InternalType& it)
827 {
828     if (const_cast<InternalType &>(it).isDouble() == false)
829     {
830         return false;
831     }
832
833     Double* pdbl = const_cast<InternalType &>(it).getAs<Double>();
834
835     if (pdbl->getDims() != getDims())
836     {
837         return false;
838     }
839
840     for (int i = 0 ; i < getDims() ; i++)
841     {
842         if (pdbl->getDimsArray()[i] != getDimsArray()[i])
843         {
844             return false;
845         }
846     }
847
848     double *pdblReal = pdbl->getReal();
849     for (int i = 0 ; i < getSize() ; i++)
850     {
851         if (m_pRealData[i] != pdblReal[i])
852         {
853             return false;
854         }
855     }
856
857     //both complex
858     if (isComplex() && pdbl->isComplex())
859     {
860         double *pdblImg = pdbl->getImg();
861         for (int i = 0 ; i < m_iSize ; i++)
862         {
863             if (m_pImgData[i] != pdblImg[i])
864             {
865                 return false;
866             }
867         }
868     }
869     //pdbl complex check all img values == 0
870     else if (pdbl->isComplex())
871     {
872         double *pdblImg = pdbl->getImg();
873         for (int i = 0 ; i < m_iSize ; i++)
874         {
875             if (pdblImg[i])
876             {
877                 return false;
878             }
879         }
880     }
881     //complex check all img values == 0
882     else if (isComplex())
883     {
884         for (int i = 0 ; i < m_iSize ; i++)
885         {
886             if (m_pImgData[i])
887             {
888                 return false;
889             }
890         }
891     }
892
893     return true;
894 }
895
896 bool Double::operator!=(const InternalType& it)
897 {
898     return !(*this == it);
899 }
900
901 double Double::getNullValue()
902 {
903     return 0;
904 }
905
906 Double* Double::createEmpty(int _iDims, int* _piDims, bool _bComplex)
907 {
908     return new Double(_iDims, _piDims, _bComplex);
909 }
910
911 double Double::copyValue(double _dblData)
912 {
913     return _dblData;
914 }
915
916 void Double::deleteAll()
917 {
918     delete[] m_pRealData;
919     m_pRealData = NULL;
920     deleteImg();
921 }
922
923 void Double::deleteImg()
924 {
925     if (isComplex() && m_pImgData)
926     {
927         delete[] m_pImgData;
928         m_pImgData = NULL;
929     }
930 }
931
932 double* Double::allocData(int _iSize)
933 {
934     double* pDbl = NULL;
935     try
936     {
937         if (_iSize < 0)
938         {
939             m_pRealData = NULL;
940             m_pImgData = NULL;
941             char message[bsiz];
942             sprintf(message, _("Can not allocate negative size (%d).\n"),  _iSize);
943             ast::ScilabError se(message);
944             se.SetErrorNumber(999);
945             throw(se);
946         }
947         else
948         {
949             if (isViewAsZComplex())
950             {
951                 pDbl = (double*)new doublecomplex[_iSize];
952             }
953             else
954             {
955                 pDbl = new double[_iSize];
956             }
957         }
958     }
959     catch (std::bad_alloc &e)
960     {
961         char message[bsiz];
962         sprintf(message, _("Can not allocate %.2f MB memory.\n"),  (double) (_iSize * sizeof(double)) / 1.e6);
963         ast::ScilabError se(message);
964         se.SetErrorNumber(999);
965         throw(se);
966     }
967     return pDbl;
968 }
969
970 bool Double::append(int _iRows, int _iCols, InternalType* _poSource)
971 {
972     Double* pD = _poSource->getAs<Double>();
973     int iRows = pD->getRows();
974     int iCols = pD->getCols();
975     int iSize = iRows * iCols;
976
977     //insert without resize
978     if (iRows + _iRows > m_iRows || iCols + _iCols > m_iCols)
979     {
980         return false;
981     }
982
983     //Update complexity if necessary
984     setComplex(isComplex() || pD->isComplex());
985
986     int iInc = 1;
987     int iOne = 1;
988
989     //two cases :
990     //  - append to 0,0
991     //  - real append in x,y
992
993     if (_iRows == 0 && _iCols == 0)
994     {
995         //append to 0,0
996         //std::cout << "append 0,0" << std::endl;
997         if (iRows == 1 || iRows == getRows())
998         {
999             //std::cout << "full Rows or one row" << std::endl;
1000             if (iRows == 1)
1001             {
1002                 iInc = getRows();
1003                 //std::cout << "iInc : " << iInc << std::endl;
1004             }
1005
1006             if (isComplex())
1007             {
1008                 C2F(dcopy)(&iSize, pD->get(), &iOne, get(), &iInc);
1009                 if (pD->isComplex())
1010                 {
1011                     C2F(dcopy)(&iSize, pD->getImg(), &iOne, getImg(), &iInc);
1012                 }
1013                 else
1014                 {
1015                     memset(getImg(), 0x00, iSize * sizeof(double));
1016                 }
1017             }
1018             else
1019             {
1020                 C2F(dcopy)(&iSize, pD->get(), &iOne, get(), &iInc);
1021             }
1022         }
1023         else
1024         {
1025             //std::cout << "part of row" << std::endl;
1026             if (isComplex())
1027             {
1028                 for (int i = 0 ; i < iCols ; i++)
1029                 {
1030                     int iOffset = i * getRows();
1031                     C2F(dcopy)(&iRows, pD->get() + i * iRows, &iOne, get() + iOffset, &iOne);
1032                     if (pD->isComplex())
1033                     {
1034                         C2F(dcopy)(&iRows, pD->getImg() + i * iRows, &iOne, getImg() + iOffset, &iOne);
1035                     }
1036                     else
1037                     {
1038                         memset(getImg() + iOffset, 0x00, iRows * sizeof(double));
1039                     }
1040                 }
1041             }
1042             else
1043             {
1044                 for (int i = 0 ; i < iCols ; i++)
1045                 {
1046                     C2F(dcopy)(&iRows, pD->get() + i * iRows, &iOne, get() + i * getRows(), &iOne);
1047                 }
1048             }
1049         }
1050     }
1051     else if (_iRows == 0 || (_iCols == 0 && (iCols == 1 || iRows == 1)))
1052     {
1053         //real append in x,y
1054         //std::cout << "real append in x,y" << std::endl;
1055         if (iRows == 1)
1056         {
1057             iInc = getRows();
1058             //std::cout << "iInc : " << iInc << std::endl;
1059         }
1060
1061         int iOffset =  _iCols * getRows() + _iRows;
1062         C2F(dcopy)(&iSize, pD->get(), &iOne, get() + iOffset, &iInc);
1063
1064         if (isComplex())
1065         {
1066             int iOffset =  _iCols * getRows() + _iRows;
1067             C2F(dcopy)(&iSize, pD->get(), &iOne, get() + iOffset, &iInc);
1068             if (pD->isComplex())
1069             {
1070                 C2F(dcopy)(&iSize, pD->getImg(), &iOne, getImg() + iOffset, &iInc);
1071             }
1072             else
1073             {
1074                 int iZero = 0;
1075                 double dblZero = 0;
1076                 C2F(dcopy)(&iSize, &dblZero, &iZero, getImg() + iOffset, &iInc);
1077             }
1078         }
1079     }
1080     else
1081     {
1082         //std::cout << "no optimisation" << std::endl;
1083         if (isComplex())
1084         {
1085             for (int i = 0 ; i < iCols ; i++)
1086             {
1087                 int iOffset = (_iCols + i) * getRows() + _iRows;
1088                 C2F(dcopy)(&iRows, pD->get() + i * iRows, &iOne, get() + iOffset, &iOne);
1089                 if (pD->isComplex())
1090                 {
1091                     C2F(dcopy)(&iRows, pD->getImg() + i * iRows, &iOne, getImg() + iOffset, &iOne);
1092                 }
1093                 else
1094                 {
1095                     memset(getImg() + iOffset, 0x00, iRows * sizeof(double));
1096                 }
1097             }
1098         }
1099         else
1100         {
1101             for (int i = 0 ; i < iCols ; i++)
1102             {
1103                 C2F(dcopy)(&iRows, pD->get() + i * iRows, &iOne, get() + (_iCols + i) * getRows() + _iRows, &iOne);
1104             }
1105         }
1106     }
1107     return true;
1108 }
1109
1110 void Double::convertToInteger()
1111 {
1112     if (isViewAsInteger())
1113     {
1114         //already done
1115         return;
1116     }
1117     //convert in place double to integer
1118     int* piR = (int*)get();
1119     double *pdblR = get();
1120
1121     if (isComplex())
1122     {
1123         int* piI = (int*)getImg();
1124         double *pdblI = getImg();
1125
1126         //normal way to prevent overlap
1127         for (int i = 0 ; i < getSize() ; i++)
1128         {
1129             piR[i] = (int)pdblR[i];
1130             piI[i] = (int)pdblI[i];
1131         }
1132     }
1133     else
1134     {
1135         //normal way to prevent overlap
1136         for (int i = 0 ; i < getSize() ; i++)
1137         {
1138             piR[i] = (int)pdblR[i];
1139         }
1140     }
1141
1142     setViewAsInteger(true);
1143 }
1144
1145 void Double::convertFromInteger()
1146 {
1147     if (isViewAsInteger() == false)
1148     {
1149         //no need change
1150         return;
1151     }
1152
1153     int* piR = (int*)get();
1154     double *pdblR = get();
1155     //convert in place integer to double
1156
1157     if (isComplex())
1158     {
1159         int* piI = (int*)getImg();
1160         double *pdblI = getImg();
1161
1162         //reverse way to prevent overlap
1163         for (int i = getSize() - 1 ; i >= 0 ; i--)
1164         {
1165             pdblR[i] = (double)piR[i];
1166             pdblI[i] = (double)piI[i];
1167         }
1168     }
1169     else
1170     {
1171         //reverse way to prevent overlap
1172         for (int i = getSize() - 1 ; i >= 0 ; i--)
1173         {
1174             pdblR[i] = (double)piR[i];
1175         }
1176     }
1177
1178     setViewAsInteger(false);
1179 }
1180
1181 void Double::convertFromZComplex()
1182 {
1183     if (isViewAsZComplex() == false)
1184     {
1185         //no need change
1186         return;
1187     }
1188
1189     doublecomplex* pdblZ = (doublecomplex*)get();
1190     m_pRealData = new double[getSize()];
1191
1192     if (m_pImgData)
1193     {
1194         delete[] m_pImgData;
1195     }
1196
1197     m_pImgData = new double[getSize()];
1198
1199     vGetPointerFromDoubleComplex(pdblZ, getSize(), m_pRealData, m_pImgData);
1200     vFreeDoubleComplexFromPointer(pdblZ);
1201     setViewAsZComplex(false);
1202 }
1203
1204 void Double::convertToZComplex()
1205 {
1206     if (isViewAsZComplex())
1207     {
1208         //already done
1209         return;
1210     }
1211
1212     doublecomplex* pdblZ = NULL;
1213
1214     if (isComplex())
1215     {
1216         pdblZ = oGetDoubleComplexFromPointer(getReal(), getImg() , getSize());
1217         delete[] m_pImgData;
1218         m_pImgData = NULL;
1219     }
1220     else
1221     {
1222         pdblZ = oGetDoubleComplexFromPointer(getReal(), NULL, getSize());
1223         m_bComplex = true;
1224     }
1225
1226     delete[] m_pRealData;
1227     m_pRealData = (double*)pdblZ;
1228     setViewAsZComplex(true);
1229 }
1230 }