realpoly.cpp
上传用户:jtjnyq9001
上传日期:2014-11-21
资源大小:3974k
文件大小:8k
源码类别:

3G开发

开发平台:

Visual C++

  1. //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2. //
  3. //  File = poly.cpp
  4. //
  5. //  class that implements a polynomial with
  6. //  real-valued coefficients
  7. //
  8. #include <math.h>
  9. #include "realpoly.h"
  10. //======================================================
  11. //  default constructor
  12. RealPolynomial::RealPolynomial( )
  13. {
  14.  Poly_Degree = 0;
  15.  Poly_Coeff = new double[1];
  16.  Poly_Coeff[0] = 0.0;
  17.  return;
  18. };
  19. //===================================================================
  20. //  initializing constructor
  21. RealPolynomial::RealPolynomial( const int degree, const double* const coefficient)
  22.   {
  23.   Poly_Degree  = degree;
  24.   Poly_Coeff = new double[Poly_Degree+1];
  25.   for(int idx=0; idx<=degree; idx++){
  26.     Poly_Coeff[idx] = coefficient[idx];
  27.     }
  28.   };
  29. //===================================================================
  30. //  constructor for initializing a constant
  31. RealPolynomial::RealPolynomial( const double coeff_0 )
  32. {
  33.  Poly_Degree = 0;
  34.  Poly_Coeff = new double[1];
  35.  Poly_Coeff[0] = coeff_0;
  36.  return;
  37. };
  38. //===================================================================
  39. //  copy constructor
  40. RealPolynomial::RealPolynomial( const RealPolynomial& original )
  41. {
  42.  Poly_Degree = original.Poly_Degree;
  43.  Poly_Coeff = new double[Poly_Degree+1];
  44.  
  45.  for( int i=0; i<=Poly_Degree; i++){
  46.     Poly_Coeff[i] = original.Poly_Coeff[i];
  47.    }
  48.  return;
  49. };
  50. //===================================================================
  51. //  conversion constructors
  52. RealPolynomial::RealPolynomial( const CmplxPolynomial& original )
  53. {
  54.  Poly_Degree = original.Poly_Degree;
  55.  Poly_Coeff = new double[Poly_Degree+1];
  56.  
  57.  for( int i=0; i<=Poly_Degree; i++){
  58.     Poly_Coeff[i] = (original.Poly_Coeff[i]).real();
  59.    }
  60.  return;
  61. };
  62. //===================================================================
  63. //  constructor for initializing a binomial
  64. RealPolynomial::RealPolynomial( const double coeff_1,
  65.                         const double coeff_0 )
  66. {
  67.  Poly_Degree = 1;
  68.  Poly_Coeff = new double[2];
  69.  
  70.  Poly_Coeff[0] = coeff_0;
  71.  Poly_Coeff[1] = coeff_1;
  72.  
  73.  return;
  74. }
  75. //===================================================================
  76. //  constructor for initializing a quadratic
  77. RealPolynomial::RealPolynomial( const double coeff_2,
  78.                         const double coeff_1,
  79.                         const double coeff_0 )
  80. {
  81.  Poly_Degree = 2;
  82.  Poly_Coeff = new double[3];
  83.  
  84.  Poly_Coeff[0] = coeff_0;
  85.  Poly_Coeff[1] = coeff_1;
  86.  Poly_Coeff[2] = coeff_2;
  87.  
  88.  return;
  89. }
  90. //=================================================================
  91. //  assignment operator
  92. RealPolynomial& RealPolynomial::operator= (const RealPolynomial& right)
  93. {
  94.  if (Poly_Coeff != right.Poly_Coeff)
  95.    {
  96.     //-------------------------------------------------------------
  97.     // Get rid of old coefficient array to make way for a new one
  98.     // of the correct length for the new polynomial being assigned 
  99.     
  100.     delete [] Poly_Coeff;
  101.     
  102.     Poly_Degree = right.Poly_Degree;
  103.     Poly_Coeff = new double[Poly_Degree+1];
  104.     
  105.     for( int i=0; i<=Poly_Degree; i++){
  106.        Poly_Coeff[i] = right.Poly_Coeff[i];
  107.       }
  108.    }
  109.  return *this;
  110. }
  111. //===================================================================
  112. // multiply assign operator        
  113. RealPolynomial& RealPolynomial::operator*= (const RealPolynomial &right)
  114. {
  115.  //-----------------------------------------------------
  116.  // save pointer to original coefficient array so that 
  117.  // this array can be deleted once no longer needed
  118.  
  119.  double *orig_coeff = Poly_Coeff;
  120.  int orig_degree = Poly_Degree;
  121.  
  122.  //-------------------------------------------------------
  123.  //  create new longer array to hold the new coefficients 
  124.  
  125.  Poly_Degree += right.Poly_Degree;
  126.  Poly_Coeff = new double[Poly_Degree+1];
  127.  
  128.  for( int i=0; i<=Poly_Degree; i++)
  129.     Poly_Coeff[i] = 0.0;
  130.     
  131.  //---------------------------------
  132.  //  perform multiplication
  133.  
  134.  for( int rgt_indx=0; rgt_indx<= right.Poly_Degree; rgt_indx++){
  135.     for( int orig_indx=0; orig_indx <= orig_degree; orig_indx++){
  136.        Poly_Coeff[orig_indx+rgt_indx] +=
  137.               (orig_coeff[orig_indx] * right.Poly_Coeff[rgt_indx]);
  138.       }
  139.    }
  140.  return *this;
  141. }    
  142. //===================================================================
  143. // add assign operator        
  144. RealPolynomial& RealPolynomial::operator+= (const RealPolynomial &right)
  145. {
  146.   //-----------------------------------------------------
  147.   // save pointer to original coefficient array so that 
  148.   // this array can be deleted once no longer needed
  149.   double *orig_coeff = Poly_Coeff;
  150.   int orig_degree = Poly_Degree;
  151.  
  152.   if(right.Poly_Degree > Poly_Degree){
  153.     Poly_Degree = right.Poly_Degree;
  154.     Poly_Coeff = new double[Poly_Degree+1];
  155.     for( int i=0; i<=orig_degree; i++)
  156.       Poly_Coeff[i] = orig_coeff[i] + right.Poly_Coeff[i];
  157.     for( i=orig_degree+1; i<=Poly_Degree; i++)
  158.       Poly_Coeff[i] = right.Poly_Coeff[i];
  159.     delete[] orig_coeff;
  160.     }
  161.   else{
  162.     for(int i=0; i<=right.Poly_Degree; i++)
  163.       Poly_Coeff[i] += right.Poly_Coeff[i];
  164.     }
  165.  return *this;
  166. }    
  167. //===================================================================
  168. // multiply by another polynomial
  169. RealPolynomial RealPolynomial::operator *(const RealPolynomial &right)
  170. {
  171.   RealPolynomial result(Poly_Degree, Poly_Coeff);
  172.   result *= right;
  173.   return result;
  174. }
  175. //===================================================================
  176. // add another polynomial
  177. RealPolynomial RealPolynomial::operator +(const RealPolynomial &right)
  178. {
  179.   RealPolynomial result(Poly_Degree, Poly_Coeff);
  180.   result += right;
  181.   return result;
  182. }
  183. //===================================================================
  184. // multiply by double and assign operator        
  185. RealPolynomial& RealPolynomial::operator*= (double right)
  186. {
  187.  //---------------------------------
  188.  //  perform multiplication
  189.  
  190.  for( int indx=0; indx<= Poly_Degree; indx++){
  191.    Poly_Coeff[indx] *= right;
  192.    }
  193.  return *this;
  194. }    
  195. //===================================================================
  196. // multiply RealPolynomial times double        
  197. RealPolynomial operator* (const RealPolynomial &poly, const double d_val)
  198. {
  199.   RealPolynomial result(poly);
  200.   result *= d_val;
  201.   return result;
  202. }    
  203. //===================================================================
  204. // multiply double times RealPolynomial        
  205. RealPolynomial operator* (const double d_val, const RealPolynomial &poly)
  206. {
  207.   RealPolynomial result(poly);
  208.   result *= d_val;
  209.   return result;
  210. }    
  211. //===================================================================
  212. // divide assign operator        
  213. RealPolynomial& RealPolynomial::operator/= (const RealPolynomial &right)
  214. {
  215.  //-----------------------------------------------------
  216.  // save pointer to original coefficient array so that 
  217.  // this array can be deleted once no longer needed
  218.  
  219.  double *orig_coeff = Poly_Coeff;
  220.  int orig_degree = Poly_Degree;
  221.  
  222.  //-------------------------------------------------------
  223.  //  create new longer array to hold the new coefficients 
  224.  
  225.  Poly_Degree += right.Poly_Degree;
  226.  Poly_Coeff = new double[Poly_Degree+1];
  227.  
  228.  for( int i=0; i<=Poly_Degree; i++)
  229.     Poly_Coeff[i] = 0.0;
  230.     
  231.  //---------------------------------
  232.  //  perform multiplication
  233.  
  234.  for( int rgt_indx=0; rgt_indx<= right.Poly_Degree; rgt_indx++){
  235.     for( int orig_indx=0; orig_indx <= orig_degree; orig_indx++){
  236.        Poly_Coeff[orig_indx+rgt_indx] +=
  237.               (orig_coeff[orig_indx] * right.Poly_Coeff[rgt_indx]);
  238.       }
  239.    }
  240.  return *this;
  241. }    
  242. //=========================================================
  243. //  dump polynomial to an output stream
  244. void RealPolynomial::DumpToStream( ofstream* output_stream)
  245. {
  246.  (*output_stream) << "Poly_Degree = " << Poly_Degree << endl;
  247.  
  248.  for(int i=Poly_Degree; i>=0; i--){
  249.     (*output_stream) << "Coeff[" << i << "] = " 
  250.                      << Poly_Coeff[i] << endl;
  251.    }
  252.  return;
  253. }  
  254. //====================================================
  255. //
  256. int RealPolynomial::GetDegree(void)
  257. {
  258.    return(Poly_Degree);
  259. }
  260. //==================================================
  261. //
  262. double RealPolynomial::GetCoefficient(int k)
  263. {
  264.    return Poly_Coeff[k];
  265. }