partitionequ.h

Go to the documentation of this file.

#ifndef PARTITIONEQU_H
#define PARTITIONEQU_H

#include <typedefs.h>
#include <partitionspace.h>



template< typename P, typename Q >
class partitionequmult;

template< typename Q >
class partitionequnot;

template< typename P, typename Q >
class partitionequadd 
{
public:

  P left;
  Q right;

  partitionequadd
  ( 
    P const & _left,
    Q const & _right
  )
    : left(_left), right(_right) {}

  template< typename W >
  partitionequmult< partitionequadd<P,Q>, W > operator * ( W const & x )
    { return partitionequmult< partitionequadd<P,Q>, W >(*this,x); }

  template< typename W >
  partitionequadd< partitionequadd<P,Q>, W > operator + ( W const & x )
    { return partitionequadd< partitionequadd<P,Q>, W >(*this,x); }

  partitionequnot< partitionequadd<P,Q> > operator ! ()
    { return partitionequnot< partitionequadd<P,Q> >(*this); }

  template< typename W >
  partitionequmult< partitionequadd<P,Q>, partitionequnot<W> > operator - ( W const & x )
    { return partitionequmult< partitionequadd<P,Q>, partitionequnot<W> >(*this,partitionequnot<W>(x)); }

  template< typename T >
  boolc isInside( T const & x ) const
  {
    if (left.isInside(x)==true)
      return true;

    return right.isInside(x);
  }

};


template< typename P, typename Q >
class partitionequmult 
{
public:

  P left;
  Q right;

  partitionequmult
  ( 
    P const & _left,
    Q const & _right
  )
    : left(_left), right(_right) {}

  template< typename W >
  partitionequmult< partitionequmult<P,Q>, W > operator * ( W const & x )
    { return partitionequmult< partitionequmult<P,Q>, W >(*this,x); }

  template< typename W >
  partitionequadd< partitionequmult<P,Q>, W > operator + ( W const & x )
    { return partitionequadd< partitionequmult<P,Q>, W >(*this,x); }

  partitionequnot< partitionequmult<P,Q> > operator ! ()
    { return partitionequnot< partitionequmult<P,Q> >(*this); }

  template< typename W >
  partitionequmult< partitionequmult<P,Q>, partitionequnot<W> > operator - ( W const & x )
    { return partitionequmult< partitionequmult<P,Q>, partitionequnot<W> >(*this,partitionequnot<W>(x)); }

  template< typename T >
  boolc isInside( T const & x ) const
  {
    if (left.isInside(x)==false)
      return false;

    return right.isInside(x);
  }

};

template< typename Q >
class partitionequnot
{
public:
  Q right;
 
  partitionequnot( Q const & _right )
    : right(_right) {}

  template< typename W >
  partitionequadd< partitionequnot<Q>, W > operator + ( W const & x )
    { return partitionequadd< partitionequnot<Q>, W >(*this,x); }

  template< typename W >
  partitionequmult< partitionequnot<Q>, W > operator * ( W const & x )
    { return partitionequmult< partitionequnot<Q>, W >(*this,x); }

  partitionequnot< partitionequnot<Q> > operator ! ()
    { return partitionequnot< partitionequnot<Q> >(*this); }

  template< typename W >
  partitionequmult< partitionequnot<Q>, partitionequnot<W> > operator - ( W const & x )
    { return partitionequmult< partitionequnot<Q>, partitionequnot<W> >(*this,partitionequnot<W>(x)); }

  template< typename T >
  boolc isInside( T const & x ) const
    { return ! right.isInside(x); } 

};



/*
\brief Provide a base type and forward equation compilation to other classes.

Use Peq to convert to partitiondata.

\par Example
\verbatim
  d2halfspace< pt2, double > L[4];

  L[0].set( pt2(0.4,0.8), pt2(0.3,0.3) );
  L[1].set( pt2(0.3,0.3), pt2(0.7,0.2) );
  L[2].set( pt2(0.7,0.2), pt2(0.4,0.5) );
  L[3].set( pt2(0.4,0.5), pt2(0.4,0.8) );

  PeqCapture(ps,Peq(L[0])*Peq(L[1])*(Peq(L[2])+Peq(L[3])));
\endverbatim
*/
template< typename T >
class partitiondata
{
public:

  partitionspace<T> * data;

  boolc isInside( T const & x ) const
    { return data->isInside(x); }

  template< typename W >
  partitionequadd< partitiondata<T>, W > operator + ( W const & x )
    { return partitionequadd< partitiondata<T>, W >(*this,x); }

  template< typename W >
  partitionequmult< partitiondata<T>, W > operator * ( W const & x )
    { return partitionequmult< partitiondata<T>, W >(*this,x); }

  partitionequnot< partitiondata<T> > operator ! ()
    { return partitionequnot< partitiondata<T> >(*this); }

  template< typename W >
  partitionequmult< partitiondata<T>, partitionequnot<W> > operator - ( W const & x )
    { return partitionequmult< partitiondata<T>, partitionequnot<W> >(*this,partitionequnot<W>(x)); }

  partitiondata(partitionspace<T> * _data)
    : data(_data) {}
};

template< typename T >
partitiondata<T> Peq(partitionspace<T> & p)
  { return partitiondata<T>(&p); }


template< typename FN, typename T >
class partitionF : public partitionspace<T>
{
  FN fn;
public:

  partitionF(FN _fn) 
    : fn(_fn) {}

  boolc isInside(T const & w) const
    { return fn.isInside(w); }
};

template< typename FN, typename T >
void PeqCapture( partitionspace<T>* & p, FN const & fn )
  { p = new partitionF<FN,T>(fn); }




#endif