synaps/topology/point.h

/*********************************************************************
*      This file is part of the source code of SYNAPS library          *
*   Author(s): G. Gatellier                                          *
*              A. Labrouzy                                           *
*              B. Mourrain, GALAAD, INRIA                            *
**********************************************************************/
#ifndef synaps_topology_point_H
#define synaps_topology_point_H
/*********************************************************************/
#include <vector>
#include <synaps/init.h>
#include <synaps/base/shared_object.h>
//#include <synaps/arithm/QQ.h>
//#include <synaps/arithm/RR.h>
/*********************************************************************/
__BEGIN_NAMESPACE_SYNAPS
//--------------------------------------------------------------------

namespace topology
{

  template<class C, class R = shared_object<std::vector<C> > >
  struct point 
  {
    typedef unsigned size_type;
    typedef typename ReferTo<R>::value_type::iterator        iterator;
    typedef typename ReferTo<R>::value_type::const_iterator  const_iterator;

    typedef typename ReferTo<C>::value_type coeff_t;

    R data;

    point():data() {}

    ~point() {}

    point(const R & r): data(r) {}
    
    point(const point<C,R> & P): data(P.data) {}

    point(unsigned d, C* t):data() 
      {
        rep(data).resize(d);
        iterator it = rep(data).begin();
        C* v=t;
        for(unsigned i = 0; i < d; ++i) *it++=*v++;
      }

    point(unsigned d, char *str):data() 
      {
        rep(data).resize(d);
        std::istringstream ins(str);
        for(unsigned i = 0; i < d; ++i) ins >> rep(data)[i];
      }

    point(unsigned d):data() 
      {
        rep(data).resize(d);
      }

    point(const C* b, const C* e):data() 
      {
        rep(data).resize(std::distance(b,e));
        iterator it = rep(data).begin(); 
        const C* tt = b;
        for(;tt != e; ) *it++ = *tt++;
      }

    point(const coeff_t & x, const coeff_t & y)
      {
        rep(data).resize(2);
        rep(data)[0] = x;
        rep(data)[1] = y;
      }
    
    point(const coeff_t & x, const coeff_t & y, const coeff_t & z)
      {
        rep(data).resize(3);
        rep(data)[0] = x;
        rep(data)[1] = y;
        rep(data)[2] = z;
      }
    
    typename ReferTo<R>::value_type::size_type size() const   
      { return rep(data).size(); }


    iterator       begin()   {return rep(data).begin();}
    const_iterator begin() const  {return rep(data).begin();}
    iterator       end()   {return rep(data).end();}
    const_iterator end() const  {return rep(data).end();}


    void resize(int d)   
      { rep(data).resize(d); }
    
    C   operator[](unsigned i) const 
      {if(i<size()) return (rep(data))[i]; else return C(0); }

    C & operator[](unsigned i)       {assert(i<size()); return (rep(data))[i];}
    
    bool operator==(const point<C,R>& p) const {return this == &p;}

    bool operator!=(const point<C,R>& p) {return !(rep(data)==rep(p.data));}

    point<C,R> operator=(const point<C,R>& p)
      {
        rep(data).resize(rep(p.data).size());
        for(int i = 0; i < (int)rep(data).size(); ++i)
          rep(data)[i] = rep(p.data)[i];        
        return (*this);
      }

    point<C,R> operator+(point<C,R>& p) const 
      {
        assert(rep(data).size() == rep(p.data).size());
        C* tab = new C[rep(data).size()];
        for(int i = 0; i < rep(data).size(); ++i)
          rep(tab)[i] = rep(data)[i]+rep(p.data)[i];
        return point(rep(data).size(),rep(tab));
      }

    point<C,R> operator+=(point<C,R>& p)
      {
        assert(rep(data).size() == rep(p.data).size());
        for(int i = 0; i < rep(data).size(); ++i)
          rep(data)[i] += rep(p.data)[i];
        return *this;
      }

    point<C,R> operator-(point<C,R>& p) const 
      { 
        assert(rep(data).size() == rep(p.data).size());
        C* tab = new C[rep(data).size()];
        for(int i = 0; i < rep(data).size(); ++i)
          rep(tab)[i] = rep(data)[i]-rep(p.data)[i];
        return point(rep(data).size(),rep(tab));
      }

    point<C,R> operator-=(point<C,R>& p)
      {
        assert(rep(data).size() == rep(p.data).size());
        for(int i = 0; i < rep(data).size(); ++i)
          rep(data)[i] -= rep(p.data)[i];
        return *this;
      }

    point<C,R> operator-() const 
      {
        C* tab = new C[rep(data).size()];
        for(int i = 0; i < rep(data).size(); ++i)
          rep(tab)[i] = -rep(data)[i];
        return point(rep(data).size(),rep(tab));
      }

    point<C,R> operator+() const {return this;}

    point<C,R> operator*(C cte) const 
      {
        C* tab = new C[rep(data).size()];
        for(int i = 0; i < rep(data).size(); ++i)
          rep(tab)[i] = rep(data)[i]*cte;
        return point(rep(data).size(),rep(tab));
      }

    point<C,R> operator/(C cte) const 
      {
        C* tab = new C[rep(data).size()];
        for(int i = 0; i < rep(data).size(); ++i)
          rep(tab)[i] = rep(data)[i]/cte;
        return point(rep(data).size(),rep(tab));
      }

    friend point<C,R> operator*(C cte, point<C,R>& p) {return p*cte;}

    friend point<C,R> operator/(C cte, point<C,R>& p) {return p/cte;}

    bool operator<(const point<C,R>& p) const
      {                              
        C eps = 1e-5;
        for(int j = 0; j < (int)rep(data).size(); ++j)
          {
            if (rep(p.data)[j]>rep(data)[j]+eps)
              return true;
            else if(rep(p.data)[j]<rep(data)[j]-eps)
              return false;
          }
        return false;
      }
    
  };

  template<class C,class R>
  int 
  ptcmp(const topology::point<C,R> & p1, const topology::point<C,R> & p2)
  {
    assert( p1.size() == p2.size() );
    for(int i = 0; i < (int)p1.size(); ++i)
      {
        if ( (rep(p1.data)[i] > rep(p2.data)[i]))
          return 1;
        else if ( (rep(p1.data)[i] < rep(p2.data)[i]))
          return -1;
      }
    return 0;
  }

#ifdef synaps_HAVE_LIBGMP

  template<class R>
  std::ostream & 
  operator<<(std::ostream & os, const topology::point<QQ,R>& P)
  {
    os <<"Point(";
    if((int)rep(P.data).size())
      {
        int i=0;
        os<<P[0].get_d();
        for(int i = 1; i < (int)rep(P.data).size(); ++i)
          os <<","<< P[i].get_d();
      }
    os <<")";
   return os;
  }

  template<class R>
  std::ostream & 
  operator<<(std::ostream & os, const topology::point<RR,R>& P)
  {
    os <<"Point(";
    if((int)rep(P.data).size())
      {
        int i=0;
        os<<P[0].get_d();
        for(int i = 1; i < (int)rep(P.data).size(); ++i)
          os <<","<< P[i].get_d();
      }
    os <<")";
   return os;
  }

#endif // synaps_HAVE_LIBGMP

  template<class C, class R>
  std::ostream & 
  operator<<(std::ostream & os, const topology::point<C,R>& P)
  {
    os <<"Point(";
    if((int)rep(P.data).size())
      {
        os<<P[0];
        for(int i = 1; i < (int)rep(P.data).size(); ++i)
          os <<","<< P[i];
      }
    os <<")";
    return os;
  }
  
  template<class C, class R>
  std::istream &
  operator>>(std::istream & is, topology::point<C,R>& P)
  {
    rep(P.data).resize(3);
    is>>P[0]>>P[1]>>P[2];
    return is;
  }

}


//--------------------------------------------------------------------
__END_NAMESPACE_SYNAPS
/*********************************************************************/
#endif // synaps_topology_point_H