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