include/shape/plane.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * Plane
 * 2008-06-24
 * Julien Wintz
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_plane_hpp
# define shape_plane_hpp

//# include <realroot/polynomial_monomialtensor.hpp>
#include <realroot/ring_monomial_tensor.hpp>

# include <shape/shape.hpp>
# define TMPL template<class K>
# define Shape geometric<K>
# define Plane plane<K>
# define POLYNOMIAL polynomial< double,with<MonomialTensor> >

namespace mmx {

namespace shape {
TMPL
class plane : public Shape
{
public:
  plane(void) ;
  plane(const char * equation) ;
  plane(const Plane & other) ;
  
  inline double a(void) const ;
  inline double b(void) const ;
  inline double c(void) const ;
  inline double d(void) const ;
  
  POLYNOMIAL equation(void) const ;
  
  bool     operator == (const Plane & other) const ;
  bool     operator != (const Plane & other) const ;
  Plane  & operator  = (const Plane & other) ;
  double & operator [] (const int & i) ;

private:
  POLYNOMIAL m_polynomial ;
};

TMPL Plane::plane(void)
{
    this->m_polynomial =POLYNOMIAL("x") ;
}

TMPL Plane::plane(const char * equation)
{
    this->m_polynomial =POLYNOMIAL(equation) ;
}

TMPL Plane::plane(const Plane & other) {
  m_polynomial = other.m_polynomial ;
}

TMPL double 
Plane::a(void) const {
  return m_polynomial[1] ;
}

TMPL double 
Plane::b(void) const {
    return m_polynomial[2] ;
}

TMPL double 
Plane::c(void) const {
  return m_polynomial[3] ;
}

TMPL double 
Plane::d(void) const {
  return m_polynomial[0] ;
}

TMPL POLYNOMIAL 
Plane::equation(void) const {
  return m_polynomial ;
}

TMPL bool 
Plane::operator == (const Plane & other) const {
  return (this->m_polynomial == other.m_polynomial) ;
}

TMPL bool 
Plane::operator != (const Plane & other) const {
  return !(m_polynomial == other.m_polynomial) ;
}

TMPL Plane& 
Plane::operator = (const Plane & other) {
  if(this == &other)
    return *this ;
    
  this->m_polynomial = other.equation() ;
  
  return * this ;
}

TMPL double & 
Plane::operator [] (const int & i) {
  switch(i) {
  case 0:
    return m_polynomial[1] ; 
    break ;
  case 1:
    return m_polynomial[2] ;
        break ;
  case 2:
    return m_polynomial[3] ;
    break ;
  case 3:
    return m_polynomial[0] ;
    break ;
  default:
    break ;
  }
  
  return *(new double(0.0)) ;
}


} ; // namespace shape
} ; // namespace mmx
# undef TMPL
# undef Plane
# undef POLYNOMIAL
# undef Shape
# endif // shape_plane_hpp

---