// To try our PolarComplex

#include <iostream>
#include <cmath>
#include "Complex.h"

// ----------------------------
// A quadratic ploynomial class

class QuadraticPolynomial
{
public:
  float value( float ordinate ) ;
  Complex root1() ;
  Complex root2() ;
  float derivative( float ordinate ) ;
  // For keen ones 
  QuadraticPolynomial derivative( ) ;

  // Constructor
  QuadraticPolynomial( float a, float b, float c ) ;

private:
  float m_a, m_b, m_c ;
  bool  m_imagRoots ;
  float firstbit() ;
  float secondbit() ;
};


//-----------------------------
// .cpp code for it


//--------
QuadraticPolynomial::QuadraticPolynomial( float a, float b, float c )
{
  m_a = a ;
  m_b = b ;
  m_c = c ;

  m_imagRoots = (m_b*m_b) < (4.0*m_a*m_c);
}

//---------
float QuadraticPolynomial::value( float ord )
{
  return (m_a*ord*ord) + (m_b*ord) + m_c ;
}


//-------
Complex QuadraticPolynomial::root1()
{
  // Plus root
 
  float re, im ;

  if( m_imagRoots ) 
  {
    re = firstbit() ;
    im = secondbit() ;
  }
  else
  {
    re = firstbit() + secondbit() ;
    im = 0.;
  }

  return Complex( re, im ) ;
}

                                    
//-------
Complex QuadraticPolynomial::root2()
{
  // Minus root
 
  float re, im ;

  if( m_imagRoots ) 
  {
    re = firstbit() ;
    im = -secondbit() ;
  }
  else
  {
    re = firstbit() - secondbit() ;
    im = 0.;
  }

  return Complex( re, im ) ;
}

                                    
//----------

float QuadraticPolynomial::derivative( float ord )
{
  return (2.0*m_a*ord) + (m_b) ;
}

//----------

QuadraticPolynomial QuadraticPolynomial::derivative(  )
{
  return QuadraticPolynomial( 0., 2.0*m_a, m_b );
}


// ........

float QuadraticPolynomial::firstbit() 
{
  return - m_b /2.0 /m_a ;
}

float QuadraticPolynomial::secondbit()
{
  float val = sqrt( fabs( m_b*m_b - 4.0*m_a*m_c ) ) ;
  val /= (2.0*m_a) ;
  return val ;
}





//===================

int main()
{

  QuadraticPolynomial p( 1., -1. , 6. ) ;

  for( int ind=0; ind < 20 ; ++ind ) std::cout << ind << " " << p.value(float(ind)) << std::endl;


  Complex r1, r2 ;

  r1 = p.root1();
  r2 = p.root2() ;

  std::cout << " Root 1 is " << std::endl ;
  r1.print();
  std::cout << " Root 2 is " << std::endl ;
  r2.print();

}