fix warning in ast module.
[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
332     Double *pCoef = new Double(getRows(), iColsOut, isComplex());
333     pCoef->setZeros();
334     double *pCoefR = pCoef->getReal();
335
336     if (isComplex())
337     {
338         double *pCoefI = pCoef->getImg();
339         for (int i = 0 ; i < m_iSize ; i++)
340         {
341             SinglePoly *pPoly = m_pRealData[i];
342             int iSize = pPoly->getSize();
343             double *pR = pPoly->get();
344             double *pI = pPoly->getImg();
345
346             for (int iRank = 0 ; iRank < iSize ; iRank++)
347             {
348                 pCoefR[iRank * m_iSize + i] = pR[iRank];
349                 pCoefI[iRank * m_iSize + i] = pI[iRank];
350             }
351         }
352     }
353     else
354     {
355         for (int i = 0 ; i < m_iSize ; i++)
356         {
357             SinglePoly *pPoly = m_pRealData[i];
358             int iSize = pPoly->getSize();
359             double *pR = pPoly->get();
360             for (int iRank = 0 ; iRank < iSize ; iRank++)
361             {
362                 pCoefR[iRank * m_iSize + i] = pR[iRank];
363             }
364         }
365     }
366
367     return pCoef;
368 }
369
370 void Polynom::setCoef(Double *_pCoef)
371 {
372     setComplex(_pCoef->isComplex());
373     double *pR = _pCoef->getReal();
374
375     if (isComplex())
376     {
377         double *pI = _pCoef->getImg();
378         for (int i = 0 ; i < m_iSize ; i++)
379         {
380             SinglePoly *pPoly = m_pRealData[i];
381             int iSize = pPoly->getSize();
382             double* pTempR = pPoly->get();
383             double* pTempI = pPoly->getImg();
384
385             for (int iRank = 0 ; iRank < iSize ; iRank++)
386             {
387                 pTempR[iRank] = pR[iRank * m_iSize + i];
388                 pTempI[iRank] = pI[iRank * m_iSize + i];
389             }
390         }
391     }
392     else
393     {
394         for (int i = 0 ; i < m_iSize ; i++)
395         {
396             SinglePoly *pPoly = m_pRealData[i];
397             int iSize = pPoly->getSize();
398             double* pTempR = pPoly->get();
399
400             for (int iRank = 0 ; iRank < iSize ; iRank++)
401             {
402                 pTempR[iRank] = pR[iRank * m_iSize + i];
403             }
404         }
405     }
406 }
407
408 bool Polynom::subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims)
409 {
410     wostringstream osExp;
411     wostringstream osCoef;
412
413     list<wstring>::const_iterator it_Exp;
414     list<wstring>::const_iterator it_Coef;
415     list<wstring> listExpR, listCoefR, listExpI, listCoefI;
416
417     if (isScalar())
418     {
419         if (isComplex())
420         {
421             ostr << L"Real part" << endl << endl << endl;
422             get(0)->toStringReal(getVariableName(), &listExpR, &listCoefR);
423             for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
424             {
425                 ostr << *it_Exp << endl << *it_Coef << endl;
426             }
427
428             ostr << L"Imaginary part" << endl << endl << endl ;
429             get(0)->toStringImg(getVariableName(), &listExpI, &listCoefI);
430             for (it_Coef = listCoefI.begin(), it_Exp = listExpI.begin() ; it_Coef != listCoefI.end() ; it_Coef++, it_Exp++)
431             {
432                 ostr << *it_Exp << endl << *it_Coef << endl;
433             }
434         }
435         else
436         {
437             get(0)->toStringReal(getVariableName(), &listExpR, &listCoefR);
438
439             for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
440             {
441                 ostr << *it_Exp << endl << *it_Coef << endl;
442             }
443         }
444     }
445     else if (getRows() == 1)
446     {
447         if (isComplex())
448         {
449             ostr << L"Real part" << endl << endl;
450             ostr << getRowString(_piDims, _iDims, false);
451             ostr << L"Imaginary part" << endl << endl;
452             ostr << getRowString(_piDims, _iDims, true);
453         }
454         else
455         {
456             ostr << getRowString(_piDims, _iDims, false);
457         }
458     }
459     else if (getCols() == 1)
460     {
461         if (isComplex())
462         {
463             ostr << L"Real part" << endl << endl;
464             ostr << getColString(_piDims, _iDims, false);
465             ostr << L"Imaginary part" << endl << endl;
466             ostr << getColString(_piDims, _iDims, true);
467         }
468         else
469         {
470             ostr << getColString(_piDims, _iDims, false);
471         }
472     }
473     else
474     {
475         //Matrix
476         if (isComplex())
477         {
478             ostr << L"Real part" << endl << endl;
479             ostr << getMatrixString(_piDims, _iDims, false);
480             ostr << L"Imaginary part" << endl << endl;
481             ostr << getMatrixString(_piDims, _iDims, true);
482         }
483         else
484         {
485             ostr << getMatrixString(_piDims, _iDims, false);
486         }
487     }
488     return true;
489 }
490
491 wstring Polynom::getMatrixString(int* _piDims, int /*_iDims*/, bool _bComplex)
492 {
493     int iLineLen = ConfigVariable::getConsoleWidth();
494
495     wostringstream ostr;
496     wostringstream osExp;
497     wostringstream osCoef;
498
499     list<wstring>::const_iterator it_Exp;
500     list<wstring>::const_iterator it_Coef;
501     list<wstring> listExpR, listCoefR, listExpI, listCoefI;
502
503     int iLen        = 0;
504     int iLastCol    = 0;
505     bool bWordWarp  = false;
506
507     wstring szExp, szCoef;
508
509     int *piMaxLen = new int[getCols()];
510     memset(piMaxLen, 0x00, sizeof(int) * getCols());
511
512     //find the largest row for each col
513     for (int iCols1 = 0 ; iCols1 < getCols() ; iCols1++)
514     {
515         for (int iRows1 = 0 ; iRows1 < getRows() ; iRows1++)
516         {
517             // FIXME : iLen shadow previous declaration
518             int iLen = 0;
519             _piDims[0] = iRows1;
520             _piDims[1] = iCols1;
521             int iPos = getIndex(_piDims);
522             if (_bComplex)
523             {
524                 get(iPos)->toStringImg(getVariableName(), &listExpR, &listCoefR);
525             }
526             else
527             {
528                 get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
529             }
530
531             if (listExpR.size() > 1)
532             {
533                 for (it_Exp = listExpR.begin() ; it_Exp != listExpR.end() ; it_Exp++)
534                 {
535                     iLen += static_cast<int>((*it_Exp).size());
536                 }
537             }
538             else
539             {
540                 if (listExpR.front().size() != 0)
541                 {
542                     iLen = static_cast<int>(listExpR.front().size());
543                 }
544                 else
545                 {
546                     iLen = static_cast<int>(listCoefR.front().size());
547                 }
548             }
549             piMaxLen[iCols1] = std::min(std::max(piMaxLen[iCols1], iLen), iLineLen);
550             listExpR.clear();
551             listCoefR.clear();
552         }
553
554         //We know the length of the column
555
556         if (static_cast<int>(iLen + piMaxLen[iCols1]) >= iLineLen && iLen != 0)
557         {
558             //if the max length exceeded
559             wostringstream ostemp;
560             bWordWarp = true;
561             for (int iRows2 = 0 ; iRows2 < getRows() ; iRows2++)
562             {
563                 bool bMultiLine = false;
564                 for (int iCols2 = iLastCol ; iCols2 < iCols1; iCols2++)
565                 {
566                     _piDims[0] = iRows2;
567                     _piDims[1] = iCols2;
568
569                     int iPos = getIndex(_piDims);
570                     if (_bComplex)
571                     {
572                         get(iPos)->toStringImg(getVariableName(), &listExpR, &listCoefR);
573                     }
574                     else
575                     {
576                         get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
577                     }
578
579                     if (listCoefR.size() > 1)
580                     {
581                         for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
582                         {
583                             osExp << *it_Exp;
584                             addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>((*it_Exp).size()));
585                             osExp << endl;
586
587                             osExp << *it_Coef;
588                             addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>((*it_Coef).size()));
589                             osExp << endl;
590                             bMultiLine = true;
591                         }
592                     }
593                     else
594                     {
595                         osExp << listExpR.front();
596                         addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>(listExpR.front().size()));
597                         osCoef << listCoefR.front();
598                         addSpaces(&osCoef, piMaxLen[iCols2] - static_cast<int>(listCoefR.front().size()));
599                         bMultiLine = false;
600                     }
601                     listExpR.clear();
602                     listCoefR.clear();
603                 }
604
605                 if (bMultiLine == false)
606                 {
607                     osExp << endl;
608                     osCoef << endl;
609                 }
610                 ostemp << osExp.str();
611                 ostemp << osCoef.str() << endl;
612                 osExp.str(L"");
613                 osCoef.str(L"");
614
615             }
616             iLen    = piMaxLen[iCols1];
617
618             //write "column x to y"
619             if (iLastCol + 1 == iCols1)
620             {
621                 ostr << endl << L"         Column " << iCols1 << endl << endl;
622             }
623             else
624             {
625                 ostr << endl << L"         Column " << iLastCol + 1 << L" to " << iCols1 << endl << endl;
626             }
627
628             ostr << ostemp.str() << endl;
629
630             iLastCol = iCols1;
631         }
632         else //if((int)(iLen + piMaxLen[iCols1]) <= iLineLen)
633         {
634             iLen += piMaxLen[iCols1];
635         }
636     }//for(int iCols1 = 0 ; iCols1 < getCols() ; iCols1++)
637
638     if (bWordWarp)
639     {
640         if (iLastCol + 1 == getCols())
641         {
642             ostr << endl << L"         Column " << getCols() << endl << endl;
643         }
644         else
645         {
646             ostr << endl << L"         Column " << iLastCol + 1 << L" to " << getCols() << endl << endl;
647         }
648     }
649
650     //print the end
651     for (int iRows2 = 0 ; iRows2 < getRows() ; iRows2++)
652     {
653         for (int iCols2 = iLastCol ; iCols2 < getCols() ; iCols2++)
654         {
655             _piDims[0] = iRows2;
656             _piDims[1] = iCols2;
657
658             int iPos = getIndex(_piDims);
659             if (_bComplex)
660             {
661                 get(iPos)->toStringImg( getVariableName(), &listExpR, &listCoefR);
662             }
663             else
664             {
665                 get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
666             }
667
668             if (listCoefR.size() > 1)
669             {
670                 for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
671                 {
672                     //normally useless ...
673                     osExp << *it_Exp;
674                     addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>((*it_Exp).size()));
675                     osExp << endl;
676
677                     osExp << *it_Coef;
678                     addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>((*it_Coef).size()));
679                     osExp << endl;
680                 }
681             }
682             else
683             {
684                 if (listExpR.front().size() != 0)
685                 {
686                     osExp << listExpR.front();
687                 }
688
689                 addSpaces(&osExp, piMaxLen[iCols2] - static_cast<int>(listExpR.front().size()));
690                 osCoef << listCoefR.front();
691                 addSpaces(&osCoef, piMaxLen[iCols2] - static_cast<int>(listCoefR.front().size()));
692             }
693             listExpR.clear();
694             listCoefR.clear();
695         }
696
697         if (osExp.str().size() != 0)
698         {
699             osExp << endl;
700         }
701         osCoef << endl;
702         ostr << osExp.str();
703         ostr << osCoef.str() << endl;
704         osExp.str(L"");
705         osCoef.str(L"");
706     }
707     return ostr.str();
708 }
709
710 wstring Polynom::getRowString(int* _piDims, int /*_iDims*/, bool _bComplex)
711 {
712     int iLineLen = ConfigVariable::getConsoleWidth();
713
714     int iLen        = 0;
715     int iLastFlush  = 0;
716
717     wostringstream ostr;
718     wostringstream osExp;
719     wostringstream osCoef;
720
721     list<wstring>::const_iterator it_Exp;
722     list<wstring>::const_iterator it_Coef;
723     list<wstring> listExpR, listCoefR, listExpI, listCoefI;
724
725     for (int i = 0 ; i < getCols() ; i++)
726     {
727         wstring szExp, szCoef;
728
729         _piDims[1] = 0;
730         _piDims[0] = i;
731         int iPos = getIndex(_piDims);
732         if (_bComplex)
733         {
734             get(iPos)->toStringImg(getVariableName(), &listExpR, &listCoefR);
735         }
736         else
737         {
738             get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
739         }
740
741         if (iLen != 0 && static_cast<int>(listExpR.front().size()) + iLen >= iLineLen - 1)
742         {
743             //flush strean
744             if (i == iLastFlush + 1)
745             {
746                 ostr << endl << L"         Column " << i << endl << endl;
747             }
748             else
749             {
750                 ostr << endl << L"         Column " << iLastFlush + 1 /* 2 is better than 1, no ? */ << L" to " << i << endl << endl;
751             }
752
753             iLastFlush = i;
754             iLen = 0;
755             ostr << osExp.str() << endl;
756             ostr << osCoef.str() << endl;
757             osExp.str(L" ");
758             osCoef.str(L" ");
759         }
760
761         if (listCoefR.size() > 1)
762         {
763             for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
764             {
765                 osExp << *it_Exp << endl << *it_Coef << endl;
766             }
767         }
768         else
769         {
770             osExp << listExpR.front();
771             osCoef << listCoefR.front();
772         }
773
774         if (osExp.str().size() != 0)
775         {
776             iLen = static_cast<int>(osExp.str().size());
777         }
778         else
779         {
780             iLen = static_cast<int>(osCoef.str().size());
781         }
782
783         listCoefR.clear();
784         listExpR.clear();
785     }
786
787     if (iLastFlush != 0)
788     {
789         //last line of a multiline output
790         if (iLastFlush + 1 == getSize())
791         {
792             ostr << endl << L"         Column " << getSize() << endl << endl;
793         }
794         else
795         {
796             ostr << endl << L"         Column " << iLastFlush + 1 << L" to " << getSize() << endl << endl;
797         }
798     }
799     ostr << osExp.str() << endl;
800     ostr << osCoef.str() << endl;
801     return ostr.str();
802 }
803
804 wstring Polynom::getColString(int* _piDims, int /*_iDims*/, bool _bComplex)
805 {
806     wostringstream ostr;
807     wostringstream osExp;
808     wostringstream osCoef;
809
810     list<wstring>::const_iterator it_Exp;
811     list<wstring>::const_iterator it_Coef;
812     list<wstring> listExpR, listCoefR, listExpI, listCoefI;
813
814     for (int i = 0 ; i < getRows() ; i++)
815     {
816         wstring szExp, szCoef;
817
818         _piDims[0] = i;
819         _piDims[1] = 0;
820         int iPos = getIndex(_piDims);
821         if (_bComplex)
822         {
823             get(iPos)->toStringImg(getVariableName(), &listExpR, &listCoefR);
824         }
825         else
826         {
827             get(iPos)->toStringReal(getVariableName(), &listExpR, &listCoefR);
828         }
829
830         for (it_Coef = listCoefR.begin(), it_Exp = listExpR.begin() ; it_Coef != listCoefR.end() ; it_Coef++, it_Exp++)
831         {
832             ostr << *it_Exp << endl << *it_Coef << endl;
833         }
834         ostr << endl;
835         listCoefR.clear();
836         listExpR.clear();
837     }
838     return ostr.str();
839 }
840
841 Double* Polynom::extractCoef(int _iRank)
842 {
843     Double *pdbl = new Double(getRows(), getCols(), isComplex());
844     pdbl->setZeros();
845     double *pReal = pdbl->getReal();
846
847     if (isComplex())
848     {
849         double *pImg = pdbl->getImg();
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                 pImg[i]  = pPoly->getImg()[_iRank];
857             }
858         }
859     }
860     else
861     {
862         for (int i = 0 ; i < getSize() ; i++)
863         {
864             SinglePoly *pPoly = m_pRealData[i];
865             if (pPoly->getRank() >= _iRank)
866             {
867                 pReal[i] = pPoly->get()[_iRank];
868             }
869         }
870     }
871
872     return pdbl;
873 }
874 bool Polynom::insertCoef(int _iRank, Double* _pCoef)
875 {
876     double *pReal = _pCoef->getReal();
877     if (isComplex())
878     {
879         double *pImg  = _pCoef->getImg();
880         for (int i = 0 ; i < getSize() ; i++)
881         {
882             SinglePoly *pPoly = m_pRealData[i];
883             if (pPoly->getRank() <= _iRank)
884             {
885                 return false;
886             }
887
888             pPoly->get()[_iRank] = pReal[i];
889             pPoly->getImg()[_iRank] = pImg[i];
890         }
891     }
892     else
893     {
894         for (int i = 0 ; i < getSize() ; i++)
895         {
896             SinglePoly *pPoly = m_pRealData[i];
897             if (pPoly->getRank() <= _iRank)
898             {
899                 return false;
900             }
901
902             pPoly->get()[_iRank] = pReal[i];
903         }
904     }
905
906     return true;
907 }
908
909 bool Polynom::operator==(const InternalType& it)
910 {
911     if (const_cast<InternalType &>(it).isPoly() == false)
912     {
913         return false;
914     }
915
916     Polynom* pM = const_cast<InternalType &>(it).getAs<types::Polynom>();
917
918     if (pM->getRows() != getRows() || pM->getCols() != getCols())
919     {
920         return false;
921     }
922
923     if (pM->isComplex() != isComplex())
924     {
925         return false;
926     }
927
928     for (int i = 0 ; i < getSize() ; i++)
929     {
930         SinglePoly* p1 = get(i);
931         SinglePoly* p2 = pM->get(i);
932
933         if (*p1 != *p2)
934         {
935             return false;
936         }
937     }
938     return true;
939 }
940
941 bool Polynom::operator!=(const InternalType& it)
942 {
943     return !(*this == it);
944 }
945
946 SinglePoly* Polynom::getNullValue()
947 {
948     return new SinglePoly();
949 }
950
951 Polynom* Polynom::createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/)
952 {
953     return new Polynom(getVariableName(), _iDims, _piDims, NULL);
954 }
955
956 SinglePoly* Polynom::copyValue(SinglePoly* _pData)
957 {
958     if (_pData == NULL)
959     {
960         return NULL;
961     }
962     return _pData->clone();
963 }
964
965 void Polynom::deleteAll()
966 {
967     for (int i = 0 ; i < getSize() ; i++)
968     {
969         delete m_pRealData[i];
970     }
971     delete[] m_pRealData;
972     m_pRealData = NULL;
973     deleteImg();
974 }
975
976 void Polynom::deleteImg()
977 {
978
979 }
980
981 SinglePoly** Polynom::allocData(int _iSize)
982 {
983     SinglePoly** pData = new SinglePoly*[_iSize];
984     memset(pData, 0x00, _iSize * sizeof(SinglePoly*));
985     return pData;
986 }
987 }
988