fix ast tests memory leaks
[scilab.git] / scilab / modules / ast / src / cpp / types / polynom.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 "core_math.h"
15 #include "tostring_common.hxx"
16 #include "singlepoly.hxx"
17 #include "polynom.hxx"
18 #include "configvariable.hxx"
19
20 using namespace std;
21
22 namespace types
23 {
24 Polynom::Polynom()
25 {
26 #ifndef NDEBUG
27     Inspector::addItem(this);
28 #endif
29 }
30
31 Polynom::Polynom(wstring& _szVarName, int _iRows, int _iCols)
32 {
33     int piDims[2]   = {_iRows, _iCols};
34     createPoly(_szVarName, 2, piDims, NULL);
35 }
36
37 Polynom::Polynom(wstring& _szVarName, int _iRows, int _iCols, const int *_piRank)
38 {
39     int piDims[2]   = {_iRows, _iCols};
40     createPoly(_szVarName, 2, piDims, _piRank);
41 }
42
43 Polynom::Polynom(wstring& _szVarName, int _iDims, int* _piDims)
44 {
45     createPoly(_szVarName, _iDims, _piDims, NULL);
46 }
47
48 Polynom::Polynom(wstring& _szVarName, int _iDims, int* _piDims, const int *_piRank)
49 {
50     createPoly(_szVarName, _iDims, _piDims, _piRank);
51 }
52
53 Polynom::~Polynom()
54 {
55     if (isDeletable() == true)
56     {
57         deleteAll();
58     }
59 #ifndef NDEBUG
60     Inspector::removeItem(this);
61 #endif
62 }
63
64 void Polynom::createPoly(wstring& _szVarName, int _iDims, int* _piDims, const int *_piRank)
65 {
66     m_szVarName = _szVarName;
67     SinglePoly** pPoly = NULL;
68     create(_piDims, _iDims, &pPoly, NULL);
69
70     if (_piRank)
71     {
72         for (int i = 0 ; i < getSize() ; i++)
73         {
74             double* pReal = NULL;
75             m_pRealData[i] = new SinglePoly(&pReal, _piRank[i]);
76         }
77     }
78 #ifndef NDEBUG
79     Inspector::addItem(this);
80 #endif
81 }
82
83 bool Polynom::set(int _iPos, SinglePoly* _pS)
84 {
85     bool bComplex = isComplex();
86     if (m_pRealData == NULL || _iPos >= m_iSize)
87     {
88         return false;
89     }
90
91     if (m_pRealData[_iPos])
92     {
93         delete m_pRealData[_iPos];
94     }
95
96     m_pRealData[_iPos] = copyValue(_pS);
97
98     if (_pS->isComplex() && bComplex == false)
99     {
100         setComplex(true);
101     }
102     else if (_pS->isComplex() == false && bComplex)
103     {
104         m_pRealData[_iPos]->setComplex(true);
105     }
106
107     return true;
108 }
109
110 bool Polynom::set(int _iRows, int _iCols, SinglePoly* _pS)
111 {
112     return set(_iCols * getRows() + _iRows, _pS);
113 }
114
115 bool Polynom::set(SinglePoly** _pS)
116 {
117     for (int i = 0 ; i < m_iSize ; i++)
118     {
119         set(i, _pS[i]);
120     }
121     return true;
122 }
123
124 bool Polynom::setCoef(int _iRows, int _iCols, Double *_pdblCoef)
125 {
126     int piDims[] = {_iRows, _iCols};
127     int iPos = getIndex(piDims);
128     return setCoef(iPos, _pdblCoef);
129 }
130
131 bool Polynom::setCoef(int _iIdx, Double *_pdblCoef)
132 {
133     if (_iIdx < getSize())
134     {
135         /*Get old SinglePoly*/
136         m_pRealData[_iIdx]->setRank(_pdblCoef->getSize() - 1);
137         m_pRealData[_iIdx]->setCoef(_pdblCoef);
138     }
139     else
140     {
141         return false;
142     }
143
144     return true;
145 }
146
147 void Polynom::setZeros()
148 {
149     for (int i = 0; i < m_iSize; i++)
150     {
151         m_pRealData[i]->setZeros();
152     }
153 }
154
155 bool Polynom::getSizes(int *_piSizes)
156 {
157     if (_piSizes == NULL || m_pRealData == NULL)
158     {
159         return false;
160     }
161
162     for (int i = 0 ; i < getSize() ; i++)
163     {
164         _piSizes[i] = m_pRealData[i]->getSize();
165     }
166
167     return true;
168 }
169
170 bool Polynom::getRank(int *_piRank)
171 {
172     if (_piRank == NULL || m_pRealData == NULL)
173     {
174         return false;
175     }
176
177     for (int i = 0 ; i < getSize() ; i++)
178     {
179         _piRank[i] = m_pRealData[i]->getRank();
180     }
181
182     return true;
183 }
184
185 void Polynom::whoAmI(void)
186 {
187     std::cout << "types::SinglePoly";
188 }
189
190 wstring& Polynom::getVariableName()
191 {
192     return m_szVarName;
193 }
194
195 void Polynom::setVariableName(wstring _szVarName)
196 {
197     m_szVarName = _szVarName;
198 }
199
200 bool Polynom::isComplex()
201 {
202     if (m_iSize && m_pRealData[0])
203     {
204         return m_pRealData[0]->isComplex();
205     }
206
207     return false;
208 }
209
210 void Polynom::setComplex(bool _bComplex)
211 {
212     if (_bComplex != isComplex())
213     {
214         for (int i = 0 ; i < getSize() ; i++)
215         {
216             get(i)->setComplex(_bComplex);
217         }
218     }
219 }
220
221 InternalType* Polynom::clone()
222 {
223     Polynom* pMP = new Polynom(getVariableName(), getDims(), getDimsArray());
224     for (int i = 0 ; i < getSize() ; i++)
225     {
226         pMP->set(i, m_pRealData[i]);
227     }
228
229     return pMP;
230 }
231
232 bool Polynom::transpose(InternalType *& out)
233 {
234     if (isScalar())
235     {
236         out = clone();
237         return true;
238     }
239
240     if (m_iDims == 2)
241     {
242         int piNewDims[2] = {m_piDims[1], m_piDims[0]};
243         Polynom* pPoly = new Polynom(m_szVarName, m_iDims, piNewDims);
244         Transposition::transpose_clone(getRows(), getCols(), m_pRealData, pPoly->get());
245         out = pPoly;
246         return true;
247     }
248
249     return false;
250
251 }
252
253 bool Polynom::adjoint(InternalType *& out)
254 {
255     if (isComplex())
256     {
257         if (m_iDims == 2)
258         {
259             int piNewDims[2] = {m_piDims[1], m_piDims[0]};
260             Polynom* pPoly = new Polynom(m_szVarName, m_iDims, piNewDims);
261             Transposition::adjoint_clone(getRows(), getCols(), m_pRealData, pPoly->get());
262             out = pPoly;
263             return true;
264         }
265         else
266         {
267             return false;
268         }
269     }
270     else
271     {
272         return transpose(out);
273     }
274 }
275
276 Double* Polynom::evaluate(Double* _pdblValue)
277 {
278     double *pR = _pdblValue->getReal();
279     double *pI = _pdblValue->getImg();
280     int iRows  = _pdblValue->getRows();
281     int iCols  = _pdblValue->getCols();
282
283     double *pReturnR = NULL;
284     double *pReturnI = NULL;
285     Double *pReturn  = new Double(getRows() * iRows, getCols() * iCols, &pReturnR, &pReturnI);
286     pReturn->setComplex(_pdblValue->isComplex());
287
288     int i = 0;
289     //all lines of the matrix remplacement
290     for (int iCol = 0 ; iCol < iCols ; iCol++)
291     {
292         for (int iPolyCol = 0 ; iPolyCol < getCols() ; iPolyCol++)
293         {
294             for (int iRow = 0 ; iRow < iRows ; iRow++)
295             {
296                 for (int iPolyRow = 0 ; iPolyRow < getRows() ; iPolyRow++)
297                 {
298                     double OutR = 0;
299                     double OutI = 0;
300
301                     SinglePoly *pPoly = get(iPolyRow, iPolyCol);
302                     if (pReturn->isComplex())
303                     {
304                         pPoly->evaluate(pR[iCol * iRows + iRow], pI[iCol * iRows + iRow], &OutR, &OutI);
305                         pReturnR[i] = OutR;
306                         pReturnI[i] = OutI;
307                     }
308                     else
309                     {
310                         pPoly->evaluate(pR[iCol * iRows + iRow], 0, &OutR, &OutI);
311                         pReturnR[i] = OutR;
312                     }
313                     i++;
314                 }
315             }
316         }
317     }
318     return pReturn;
319 }
320
321 void Polynom::updateRank(void)
322 {
323     for (int i = 0 ; i < getSize() ; i++)
324     {
325         m_pRealData[i]->updateRank();
326     }
327 }
328
329 int Polynom::getMaxRank(void)
330 {
331     int *piRank = new int[getSize()];
332     getRank(piRank);
333     int iMaxRank = 0;
334     for (int i = 0 ; i < getSize() ; i++)
335     {
336         iMaxRank = std::max(iMaxRank, piRank[i]);
337     }
338     delete[] piRank;
339     return iMaxRank;
340 }
341
342 Double* Polynom::getCoef(void)
343 {
344     int iMaxRank = getMaxRank();
345     int iColsOut = getCols() * (iMaxRank + 1);
346
347     Double *pCoef = new Double(getRows(), iColsOut, isComplex());
348     pCoef->setZeros();
349     double *pCoefR = pCoef->getReal();
350
351     if (isComplex())
352     {
353         double *pCoefI = pCoef->getImg();
354         for (int i = 0 ; i < m_iSize ; i++)
355         {
356             SinglePoly *pPoly = m_pRealData[i];
357             int iSize = pPoly->getSize();
358             double *pR = pPoly->get();
359             double *pI = pPoly->getImg();
360
361             for (int iRank = 0 ; iRank < iSize ; iRank++)
362             {
363                 pCoefR[iRank * m_iSize + i] = pR[iRank];
364                 pCoefI[iRank * m_iSize + i] = pI[iRank];
365             }
366         }
367     }
368     else
369     {
370         for (int i = 0 ; i < m_iSize ; i++)
371         {
372             SinglePoly *pPoly = m_pRealData[i];
373             int iSize = pPoly->getSize();
374             double *pR = pPoly->get();
375             for (int iRank = 0 ; iRank < iSize ; iRank++)
376             {
377                 pCoefR[iRank * m_iSize + i] = pR[iRank];
378             }
379         }
380     }
381
382     return pCoef;
383 }
384
385 void Polynom::setCoef(Double *_pCoef)
386 {
387     setComplex(_pCoef->isComplex());
388     double *pR = _pCoef->getReal();
389
390     if (isComplex())
391     {
392         double *pI = _pCoef->getImg();
393         for (int i = 0 ; i < m_iSize ; i++)
394         {
395             SinglePoly *pPoly = m_pRealData[i];
396             int iSize = pPoly->getSize();
397             double* pTempR = pPoly->get();
398             double* pTempI = pPoly->getImg();
399
400             for (int iRank = 0 ; iRank < iSize ; iRank++)
401             {
402                 pTempR[iRank] = pR[iRank * m_iSize + i];
403                 pTempI[iRank] = pI[iRank * m_iSize + i];
404             }
405         }
406     }
407     else
408     {
409         for (int i = 0 ; i < m_iSize ; i++)
410         {
411             SinglePoly *pPoly = m_pRealData[i];
412             int iSize = pPoly->getSize();
413             double* pTempR = pPoly->get();
414
415             for (int iRank = 0 ; iRank < iSize ; iRank++)
416             {
417                 pTempR[iRank] = pR[iRank * m_iSize + i];
418             }
419         }
420     }
421 }
422
423 bool Polynom::subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims)
424 {
425     wostringstream osExp;
426     wostringstream osCoef;
427
428     list<wstring>::const_iterator it_Exp;
429     list<wstring>::const_iterator it_Coef;
430     list<wstring> listExpR, listCoefR, listExpI, listCoefI;
431
432
433     if (isScalar())
434     {
435         if (isComplex())
436         {
437             ostr << L"Real part" << endl << endl << endl;
438             get(0)->toStringReal(getVariableName(), &listExpR, &listCoefR);
439             for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
440             {
441                 ostr << *it_Exp << endl << *it_Coef << endl;
442             }
443
444             ostr << L"Imaginary part" << endl << endl << endl ;
445             get(0)->toStringImg(getVariableName(), &listExpI, &listCoefI);
446             for (it_Coef = listCoefI.begin(), it_Exp = listExpI.begin() ; it_Coef != listCoefI.end() ; it_Coef++, it_Exp++)
447             {
448                 ostr << *it_Exp << endl << *it_Coef << endl;
449             }
450         }
451         else
452         {
453             get(0)->toStringReal(getVariableName(), &listExpR, &listCoefR);
454
455             for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
456             {
457                 ostr << *it_Exp << endl << *it_Coef << endl;
458             }
459         }
460     }
461     else if (getRows() == 1)
462     {
463         if (isComplex())
464         {
465             ostr << L"Real part" << endl << endl;
466             ostr << getRowString(_piDims, _iDims, false);
467             ostr << L"Imaginary part" << endl << endl;
468             ostr << getRowString(_piDims, _iDims, true);
469         }
470         else
471         {
472             ostr << getRowString(_piDims, _iDims, false);
473         }
474     }
475     else if (getCols() == 1)
476     {
477         if (isComplex())
478         {
479             ostr << L"Real part" << endl << endl;
480             ostr << getColString(_piDims, _iDims, false);
481             ostr << L"Imaginary part" << endl << endl;
482             ostr << getColString(_piDims, _iDims, true);
483         }
484         else
485         {
486             ostr << getColString(_piDims, _iDims, false);
487         }
488     }
489     else
490     {
491         //Matrix
492         if (isComplex())
493         {
494             ostr << L"Real part" << endl << endl;
495             ostr << getMatrixString(_piDims, _iDims, false);
496             ostr << L"Imaginary part" << endl << endl;
497             ostr << getMatrixString(_piDims, _iDims, true);
498         }
499         else
500         {
501             ostr << getMatrixString(_piDims, _iDims, false);
502         }
503     }
504     return true;
505 }
506
507 wstring Polynom::getMatrixString(int* _piDims, int /*_iDims*/, bool _bComplex)
508 {
509     int iLineLen = ConfigVariable::getConsoleWidth();
510
511     wostringstream ostr;
512     wostringstream osExp;
513     wostringstream osCoef;
514
515     list<wstring>::const_iterator it_Exp;
516     list<wstring>::const_iterator it_Coef;
517     list<wstring> listExpR, listCoefR, listExpI, listCoefI;
518
519     int iLen        = 0;
520     int iLastCol    = 0;
521     bool bWordWarp  = false;
522
523     wstring szExp, szCoef;
524
525
526     int *piMaxLen = new int[abs(getCols())];
527     memset(piMaxLen, 0x00, sizeof(int) * abs(getCols()));
528
529     //find the largest row for each col
530     for (int iCols1 = 0 ; iCols1 < abs(getCols()) ; iCols1++)
531     {
532         for (int iRows1 = 0 ; iRows1 < abs(getRows()) ; iRows1++)
533         {
534             int iLength = 0;
535             _piDims[0] = iRows1;
536             _piDims[1] = iCols1;
537             int iPos = getIndex(_piDims);
538             if (_bComplex)
539             {
540                 get(iPos)->toStringImg(getVariableName(), &listExpR, &listCoefR);
541             }
542             else
543             {
544                 get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
545             }
546
547             if (listExpR.size() > 1)
548             {
549                 for (it_Exp = listExpR.begin() ; it_Exp != listExpR.end() ; it_Exp++)
550                 {
551                     iLength += static_cast<int>((*it_Exp).size());
552                 }
553             }
554             else
555             {
556                 if (listExpR.front().size() != 0)
557                 {
558                     iLength = static_cast<int>(listExpR.front().size());
559                 }
560                 else
561                 {
562                     iLength = static_cast<int>(listCoefR.front().size());
563                 }
564             }
565             piMaxLen[iCols1] = std::min(std::max(piMaxLen[iCols1], iLength), iLineLen);
566             listExpR.clear();
567             listCoefR.clear();
568         }
569
570         //We know the length of the column
571         if (static_cast<int>(iLen + piMaxLen[iCols1]) >= iLineLen && iLen != 0)
572         {
573             //if the max length exceeded
574             wostringstream ostemp;
575             bWordWarp = true;
576             for (int iRows2 = 0 ; iRows2 < abs(getRows()) ; iRows2++)
577             {
578                 bool bMultiLine = false;
579                 for (int iCols2 = iLastCol ; iCols2 < iCols1; iCols2++)
580                 {
581                     _piDims[0] = iRows2;
582                     _piDims[1] = iCols2;
583
584                     int iPos = getIndex(_piDims);
585                     if (_bComplex)
586                     {
587                         get(iPos)->toStringImg(getVariableName(), &listExpR, &listCoefR);
588                     }
589                     else
590                     {
591                         get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
592                     }
593
594                     if (listCoefR.size() > 1)
595                     {
596                         for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
597                         {
598                             osExp << *it_Exp;
599                             addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>((*it_Exp).size()));
600                             osExp << endl;
601                             osExp << *it_Coef;
602                             addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>((*it_Coef).size()));
603                             osExp << endl;
604                             bMultiLine = true;
605                         }
606                     }
607                     else
608                     {
609
610                         osExp << listExpR.front();
611                         addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>(listExpR.front().size()));
612                         osCoef << listCoefR.front();
613                         addSpaces(&osCoef, piMaxLen[iCols2] - static_cast<int>(listCoefR.front().size()));
614                         bMultiLine = false;
615                     }
616                     listExpR.clear();
617                     listCoefR.clear();
618                 }
619
620                 if (bMultiLine == false)
621                 {
622                     osExp << endl;
623                     osCoef << endl;
624                 }
625                 ostemp << osExp.str();
626                 ostemp << osCoef.str() << endl;
627                 osExp.str(L"");
628                 osCoef.str(L"");
629
630             }
631             iLen    = piMaxLen[iCols1];
632
633             //write "column x to y"
634             addColumnString(ostr, iLastCol + 1, iCols1);
635             ostr << ostemp.str() << endl;
636
637             iLastCol = iCols1;
638         }
639         else //if((int)(iLen + piMaxLen[iCols1]) <= iLineLen)
640         {
641             iLen += piMaxLen[iCols1];
642         }
643     }//for(int iCols1 = 0 ; iCols1 < getCols() ; iCols1++)
644
645     if (bWordWarp)
646     {
647         addColumnString(ostr, iLastCol + 1, getCols());
648     }
649
650     //print the end
651     for (int iRows2 = 0 ; iRows2 < abs(getRows()) ; iRows2++)
652     {
653         for (int iCols2 = iLastCol ; iCols2 < abs(getCols()) ; iCols2++)
654         {
655             _piDims[0] = iRows2;
656             _piDims[1] = iCols2;
657
658             int iPos = getIndex(_piDims);
659             if (_bComplex)
660             {
661                 get(iPos)->toStringImg( getVariableName(), &listExpR, &listCoefR);
662             }
663             else
664             {
665                 get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
666             }
667
668             if (listCoefR.size() > 1)
669             {
670                 for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
671                 {
672                     //normally useless ...
673                     osExp << *it_Exp;
674                     addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>((*it_Exp).size()));
675                     osExp << endl;
676
677                     osExp << *it_Coef;
678                     addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>((*it_Coef).size()));
679                     osExp << endl;
680                 }
681             }
682             else
683             {
684                 if (listExpR.front().size() != 0)
685                 {
686                     osExp << listExpR.front();
687                 }
688
689                 addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>(listExpR.front().size()));
690                 osCoef << listCoefR.front();
691                 addSpaces(&osCoef, piMaxLen[iCols2] - static_cast<int>(listCoefR.front().size()));
692             }
693             listExpR.clear();
694             listCoefR.clear();
695         }
696
697         if (osExp.str().size() != 0)
698         {
699             osExp << endl;
700         }
701         osCoef << endl;
702         if (isIdentity())
703         {
704             ostr << L"eye *" << endl << endl;
705         }
706         ostr << osExp.str();
707         ostr << osCoef.str() << endl;
708         osExp.str(L"");
709         osCoef.str(L"");
710     }
711     return ostr.str();
712 }
713
714 wstring Polynom::getRowString(int* _piDims, int /*_iDims*/, bool _bComplex)
715 {
716     int iLineLen = ConfigVariable::getConsoleWidth();
717
718     int iLen        = 0;
719     int iLastFlush  = 0;
720
721     wostringstream ostr;
722     wostringstream osExp;
723     wostringstream osCoef;
724
725     list<wstring>::const_iterator it_Exp;
726     list<wstring>::const_iterator it_Coef;
727     list<wstring> listExpR, listCoefR, listExpI, listCoefI;
728
729     for (int i = 0 ; i < getCols() ; i++)
730     {
731         wstring szExp, szCoef;
732
733         _piDims[1] = 0;
734         _piDims[0] = i;
735         int iPos = getIndex(_piDims);
736         if (_bComplex)
737         {
738             get(iPos)->toStringImg(getVariableName(), &listExpR, &listCoefR);
739         }
740         else
741         {
742             get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
743         }
744
745         if (iLen != 0 && static_cast<int>(listExpR.front().size()) + iLen >= iLineLen - 1)
746         {
747             //flush strean
748             addColumnString(ostr, iLastFlush + 1, i);
749             iLastFlush = i;
750             iLen = 0;
751             ostr << osExp.str() << endl;
752             ostr << osCoef.str() << endl;
753             osExp.str(L" ");
754             osCoef.str(L" ");
755         }
756
757         if (listCoefR.size() > 1)
758         {
759             for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
760             {
761                 osExp << *it_Exp << endl << *it_Coef << endl;
762             }
763         }
764         else
765         {
766             osExp << listExpR.front();
767             osCoef << listCoefR.front();
768         }
769
770         if (osExp.str().size() != 0)
771         {
772             iLen = static_cast<int>(osExp.str().size());
773         }
774         else
775         {
776             iLen = static_cast<int>(osCoef.str().size());
777         }
778
779         listCoefR.clear();
780         listExpR.clear();
781     }
782
783     if (iLastFlush != 0)
784     {
785         //last line of a multiline output
786         addColumnString(ostr, iLastFlush + 1, getSize());
787     }
788     ostr << osExp.str() << endl;
789     ostr << osCoef.str() << endl;
790     return ostr.str();
791 }
792
793 wstring Polynom::getColString(int* _piDims, int /*_iDims*/, bool _bComplex)
794 {
795     wostringstream ostr;
796     wostringstream osExp;
797     wostringstream osCoef;
798
799     list<wstring>::const_iterator it_Exp;
800     list<wstring>::const_iterator it_Coef;
801     list<wstring> listExpR, listCoefR, listExpI, listCoefI;
802
803     for (int i = 0 ; i < getRows() ; i++)
804     {
805         wstring szExp, szCoef;
806
807         _piDims[0] = i;
808         _piDims[1] = 0;
809         int iPos = getIndex(_piDims);
810         if (_bComplex)
811         {
812             get(iPos)->toStringImg(getVariableName(), &listExpR, &listCoefR);
813         }
814         else
815         {
816             get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
817         }
818
819         for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
820         {
821             ostr << *it_Exp << endl << *it_Coef << endl;
822         }
823         ostr << endl;
824         listCoefR.clear();
825         listExpR.clear();
826     }
827     return ostr.str();
828 }
829
830 Double* Polynom::extractCoef(int _iRank)
831 {
832     Double *pdbl = new Double(getRows(), getCols(), isComplex());
833     pdbl->setZeros();
834     double *pReal = pdbl->getReal();
835
836     if (isComplex())
837     {
838         double *pImg = pdbl->getImg();
839         for (int i = 0 ; i < getSize() ; i++)
840         {
841             SinglePoly *pPoly = m_pRealData[i];
842             if (pPoly->getRank() >= _iRank)
843             {
844                 pReal[i] = pPoly->get()[_iRank];
845                 pImg[i]  = pPoly->getImg()[_iRank];
846             }
847         }
848     }
849     else
850     {
851         for (int i = 0 ; i < getSize() ; i++)
852         {
853             SinglePoly *pPoly = m_pRealData[i];
854             if (pPoly->getRank() >= _iRank)
855             {
856                 pReal[i] = pPoly->get()[_iRank];
857             }
858         }
859     }
860
861     return pdbl;
862 }
863
864 bool Polynom::insertCoef(int _iRank, Double* _pCoef)
865 {
866     double *pReal = _pCoef->getReal();
867     if (isComplex())
868     {
869         double *pImg  = _pCoef->getImg();
870         for (int i = 0 ; i < getSize() ; i++)
871         {
872             SinglePoly *pPoly = m_pRealData[i];
873             if (pPoly->getRank() <= _iRank)
874             {
875                 return false;
876             }
877
878             pPoly->get()[_iRank] = pReal[i];
879             pPoly->getImg()[_iRank] = pImg[i];
880         }
881     }
882     else
883     {
884         for (int i = 0 ; i < getSize() ; i++)
885         {
886             SinglePoly *pPoly = m_pRealData[i];
887             if (pPoly->getRank() <= _iRank)
888             {
889                 return false;
890             }
891
892             pPoly->get()[_iRank] = pReal[i];
893         }
894     }
895
896     return true;
897 }
898
899 bool Polynom::operator==(const InternalType& it)
900 {
901     if (const_cast<InternalType &>(it).isPoly() == false)
902     {
903         return false;
904     }
905
906     Polynom* pM = const_cast<InternalType &>(it).getAs<types::Polynom>();
907
908     if (pM->getRows() != getRows() || pM->getCols() != getCols())
909     {
910         return false;
911     }
912
913     for (int i = 0 ; i < getSize() ; i++)
914     {
915         SinglePoly* p1 = get(i);
916         SinglePoly* p2 = pM->get(i);
917
918         if (*p1 != *p2)
919         {
920             return false;
921         }
922     }
923     return true;
924 }
925
926 bool Polynom::operator!=(const InternalType& it)
927 {
928     return !(*this == it);
929 }
930
931 SinglePoly* Polynom::getNullValue()
932 {
933     return new SinglePoly();
934 }
935
936 Polynom* Polynom::createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/)
937 {
938     return new Polynom(getVariableName(), _iDims, _piDims, NULL);
939 }
940
941 SinglePoly* Polynom::copyValue(SinglePoly* _pData)
942 {
943     if (_pData == NULL)
944     {
945         return NULL;
946     }
947     return _pData->clone();
948 }
949
950 void Polynom::deleteAll()
951 {
952     for (int i = 0 ; i < m_iSizeMax ; i++)
953     {
954         delete m_pRealData[i];
955     }
956     delete[] m_pRealData;
957     m_pRealData = NULL;
958     deleteImg();
959 }
960
961 void Polynom::deleteImg()
962 {
963
964 }
965
966 SinglePoly** Polynom::allocData(int _iSize)
967 {
968     SinglePoly** pData = new SinglePoly*[_iSize];
969     memset(pData, 0x00, _iSize * sizeof(SinglePoly*));
970     return pData;
971 }
972
973 void Polynom::deleteData(SinglePoly* data)
974 {
975     if (data)
976     {
977         data->killMe();
978     }
979 }
980
981 //overload to check variable name and call arrayof<>::insert after
982 InternalType* Polynom::insert(typed_list* _pArgs, InternalType* _pSource)
983 {
984     Polynom* p = _pSource->getAs<Polynom>();
985     if (p->getVariableName() != getVariableName())
986     {
987         char szError[512];
988         os_sprintf(szError, _("Input arguments should have the same formal variable name.\n"));
989         wchar_t* pwstError = to_wide_string(szError);
990         std::wstring wstError(pwstError);
991         FREE(pwstError);
992         throw ast::ScilabError(wstError, 999, *new Location());
993     }
994     return ArrayOf<SinglePoly*>::insert(_pArgs, _pSource);
995 }
996
997 }
998