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