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