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