EgtGeomKernel/PolynomialPoint3d.h

//----------------------------------------------------------------------------
//  EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : PolynomialPoint3d.h       Data : 11.01.14          Versione : 1.5a2
// Contenuto : Dichiarazione classe polinomio con coefficienti Point3d.       
//
//
//
// Modifiche : 11.01.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

#include "/EgtDev/Include/ENkPolynomial.h"
#include "/EgtDev/Include/EGkGeoCollection.h"


//----------------------------------------------------------------------------
class PolynomialPoint3d
{
   public :
      PolynomialPoint3d( void) : m_nDegree( -1) {}
      bool SetDegree( int nDegree) ;
      bool SetCoeff( int nPower, Point3d& ptP) ;
      bool Set( int nDegree, const PNTVECTOR& vP) ;
      bool SetToConstant( const Point3d& ptP) ;
      const PolynomialPoint3d& operator =( const PolynomialPoint3d& pol3S)
               { if ( &pol3S != this) {
                    SetDegree( pol3S.m_nDegree) ;
                    for ( int i = 0 ; i <= m_nDegree ; ++ i)
                       m_Coeff[i] = pol3S.m_Coeff[i] ;}
                 return *this ; }

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

   private :
      bool EnsureDegree( int nDegree) ;

   private :
      int       m_nDegree ;
      PNTVECTOR m_Coeff ;
} ;


//----------------------------------------------------------------------------
// Somma
//----------------------------------------------------------------------------
inline PolynomialPoint3d 
operator+( const PolynomialPoint3d& pol3P1, const PolynomialPoint3d& pol3P2)
{
   PolynomialPoint3d pol3Summ = pol3P1 ;
   pol3Summ += pol3P2 ;
   return pol3Summ ;
}

//----------------------------------------------------------------------------
// Differenza
//----------------------------------------------------------------------------
inline PolynomialPoint3d 
operator-( const PolynomialPoint3d& pol3P1, const PolynomialPoint3d& pol3P2)
{
   PolynomialPoint3d pol3Diff = pol3P1 ;
   pol3Diff -= pol3P2 ;
   return pol3Diff ;
}

//----------------------------------------------------------------------------
// Moltiplicazione con un polinomio di numeri
//----------------------------------------------------------------------------
inline PolynomialPoint3d 
operator*( const PolynomialPoint3d& pol3P1, const Polynomial& polP2)
{
   PolynomialPoint3d pol3Mul = pol3P1 ;
   pol3Mul *= polP2 ;
   return pol3Mul ;
}


#if 0
//----------------------------------------------------------------------------
void
PolynomialSumm( PNTVECTOR& vSou1, PNTVECTOR& vSou2, PNTVECTOR& 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( PNTVECTOR& vSou1, PNTVECTOR& vSou2, PNTVECTOR& 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( Point3d() + ( - vSou2[i])) ;
   }
}

//----------------------------------------------------------------------------
void
PolynomialMult( PNTVECTOR& vSou1, DBLVECTOR& vSou2, PNTVECTOR& 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( Point3d()) ;
   for ( int i = 0 ; i <= nDeg1 ; ++ i) {
      for ( int j = 0 ; j <= nDeg2 ; ++ j)
         vMult[i+j] += vSou1[i] * vSou2[j] ;
   }
}

//----------------------------------------------------------------------------
void
PolynomialDerive( PNTVECTOR& vSou, PNTVECTOR& 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]) ;
}

//----------------------------------------------------------------------------
void
PolynomialGetMainCompo( PNTVECTOR& vSou, DBLVECTOR& vCompo)
{
   int nDim = vSou.size() ;
   vCompo.clear() ;
   vCompo.reserve( nDim) ;
   Point3d ptSumm ;
   for ( int i = 0 ; i < nDim ; ++ i) {
      ptSumm.x += fabs( vSou[i].x) ;
      ptSumm.y += fabs( vSou[i].y) ;
      ptSumm.z += fabs( vSou[i].z) ;
   }
   if ( ptSumm.x > ptSumm.y  &&  ptSumm.x > ptSumm.z) {
      for ( int i = 0 ; i < nDim ; ++ i)
         vCompo.push_back( vSou[i].x) ;
   }
   else if ( ptSumm.y > ptSumm.z) {
      for ( int i = 0 ; i < nDim ; ++ i)
         vCompo.push_back( vSou[i].y) ;
   }
   else {
      for ( int i = 0 ; i < nDim ; ++ i)
         vCompo.push_back( vSou[i].z) ;
   }
}
#endif