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