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