Include/ENkPolynomial.h

//----------------------------------------------------------------------------
//  EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : ENkPolynomial.h       Data : 12.01.14          Versione : 1.5a2
// Contenuto : Funzioni per polinomi.       
//
//
//
// Modifiche : 12.01.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

//----------------------- Macro per import/export ----------------------------
#undef ENK_EXPORT
#if defined( I_AM_ENK)            // da definirsi solo nella DLL
   #define ENK_EXPORT __declspec( dllexport)
#else
   #define ENK_EXPORT __declspec( dllimport)
#endif

//---------------------------Include------------------------------------------
#include "/EgtDev/Include/ENkCplxCollection.h"


//----------------------------------------------------------------------------
class Polynomial
{
   public :
      ENK_EXPORT Polynomial( void) : m_nDegree( -1) {}
      ENK_EXPORT bool SetDegree( int nDegree) ;
      ENK_EXPORT bool SetCoeff( int nPower, double dC) ;
      ENK_EXPORT bool Set( int nDegree, const DBLVECTOR& vC) ;
      ENK_EXPORT bool SetToConstant( double dC) ;
      ENK_EXPORT const Polynomial& operator =( const Polynomial& polS)
                          { if ( &polS != this) {
                               SetDegree( polS.m_nDegree) ;
                               for ( int i = 0 ; i <= m_nDegree ; ++ i)
                                  m_Coeff[i] = polS.m_Coeff[i] ;}
                            return *this ; }

   public :
      ENK_EXPORT int GetDegree( void) const { return m_nDegree ; }
      ENK_EXPORT double GetCoeff( int nPower) const
                           { if ( nPower < 0  ||  nPower > m_nDegree)
                                return 0 ;
                             return m_Coeff[nPower] ; }
      ENK_EXPORT const Polynomial& operator +=( const Polynomial& polP) ;
      ENK_EXPORT const Polynomial& operator -=( const Polynomial& polP) ;
      ENK_EXPORT const Polynomial& operator *=( const Polynomial& polP) ;
      ENK_EXPORT void Derive( void) ;
      ENK_EXPORT void Derive( const Polynomial& polP) ;
      ENK_EXPORT void AdjustDegree( void) ;
      ENK_EXPORT double Evaluate( double dVal) ;
      ENK_EXPORT int FindRoots( DBLVECTOR& vdRoot) ;

   private :
      bool EnsureDegree( int nDegree) ;

   private :
      int       m_nDegree ;
      DBLVECTOR m_Coeff ;
} ;


//----------------------------------------------------------------------------
// Somma
//----------------------------------------------------------------------------
inline Polynomial 
operator+( const Polynomial& polP1, const Polynomial& polP2)
{
   Polynomial polSumm = polP1 ;
   polSumm += polP2 ;
   return polSumm ;
}

//----------------------------------------------------------------------------
// Differenza
//----------------------------------------------------------------------------
inline Polynomial 
operator-( const Polynomial& polP1, const Polynomial& polP2)
{
   Polynomial polDiff = polP1 ;
   polDiff -= polP2 ;
   return polDiff ;
}

//----------------------------------------------------------------------------
// Moltiplicazione
//----------------------------------------------------------------------------
inline Polynomial 
operator*( const Polynomial& polP1, const Polynomial& polP2)
{
   Polynomial polMul = polP1 ;
   polMul *= polP2 ;
   return polMul ;
}

//----------------------------------------------------------------------------
// Filtro sulle radici
//----------------------------------------------------------------------------
ENK_EXPORT int FilterMultipleAndOutOfRangeRoots( DBLVECTOR& vRoots, double dMin, double dMax, double dEps) ;



#if 0
//----------------------------------------------------------------------------
void
PolynomialSumm( DBLVECTOR& vSou1, DBLVECTOR& vSou2, DBLVECTOR& vSumm)
{
   int nDeg1 = vSou1.size() - 1 ;
   int nDeg2 = vSou2.size() - 1 ;
   int nMin = (( nDeg1 <= nDeg2) ? nDeg1 : nDeg2) ;
   int nMax = (( nDeg1 >= nDeg2) ? nDeg1 : nDeg2) ;
   vSumm.clear() ;
   vSumm.reserve( nMax + 1) ;
   for ( int i = 0 ; i < nMin ; ++ i)
      vSumm.push_back( vSou1[i] + vSou2[i]) ;
   if ( nDeg1 > nDeg2) {
   for ( int i = nMin ; i < nDeg1 ; ++ i)
      vSumm.push_back( vSou1[i]) ;
   }
   else if ( nDeg1 < nDeg2) {
   for ( int i = nMin ; i < nDeg2 ; ++ i)
      vSumm.push_back( vSou2[i]) ;
   }
}

//----------------------------------------------------------------------------
void
PolynomialDiff( DBLVECTOR& vSou1, DBLVECTOR& vSou2, DBLVECTOR& vSumm)
{
   int nDeg1 = vSou1.size() - 1 ;
   int nDeg2 = vSou2.size() - 1 ;
   int nMin = (( nDeg1 <= nDeg2) ? nDeg1 : nDeg2) ;
   int nMax = (( nDeg1 >= nDeg2) ? nDeg1 : nDeg2) ;
   vSumm.clear() ;
   vSumm.reserve( nMax + 1) ;
   for ( int i = 0 ; i < nMin ; ++ i)
      vSumm.push_back( vSou1[i] - vSou2[i]) ;
   if ( nDeg1 > nDeg2) {
   for ( int i = nMin ; i < nDeg1 ; ++ i)
      vSumm.push_back( vSou1[i]) ;
   }
   else if ( nDeg1 < nDeg2) {
   for ( int i = nMin ; i < nDeg2 ; ++ i)
      vSumm.push_back( - vSou2[i]) ;
   }
}

//----------------------------------------------------------------------------
void
PolynomialMult( DBLVECTOR& vSou1, DBLVECTOR& vSou2, DBLVECTOR& vMult)
{
   int nDeg1 = vSou1.size() - 1 ;
   int nDeg2 = vSou2.size() - 1 ;
   int nDim = nDeg1 + nDeg2 + 1 ;
   vMult.clear() ;
   vMult.reserve( nDim) ;
   for ( int i = 0 ; i < nDim ; ++ i)
      vMult.push_back( 0) ;
   for ( int i = 0 ; i <= nDeg1 ; ++ i) {
      for ( int j = 0 ; j <= nDeg2 ; ++ j)
         vMult[i+j] += vSou1[i] * vSou2[j] ;
   }
}

//----------------------------------------------------------------------------
void
PolynomialDerive( DBLVECTOR& vSou, DBLVECTOR& vDer)
{
   int nDeg = vSou.size() - 1 ;
   vDer.clear() ;
   vDer.reserve( nDeg) ;
   for ( int i = 0 ; i < nDeg ; ++ i)
      vDer.push_back( ( i + 1) * vSou[i+1]) ;
}

#endif