PointVector.h

#pragma once

#if defined(PointVector_RECURSES)
#error Recursive header files inclusion detected in PointVector.h
#else // defined(PointVector_RECURSES)

#define PointVector_RECURSES

#if !defined PointVector_h

#define PointVector_h

// Inclusions
#include <iostream>
#include <string>
#include <bitset>
#include <algorithm>

#ifdef CPP11_ARRAY
#include <array>
#else
#include <boost/array.hpp>
#endif 

#include <vector>

#include "DGtal/base/Common.h"
#include "DGtal/base/CBidirectionalRange.h"
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/kernel/CEuclideanRing.h"

//#include "DGtal/io/boards/Board2D.h"
#include "DGtal/io/Color.h"
//#include "DGtal/io/Display3D.h"

#ifdef _MSC_VER
#if defined( max )
#undef max 
#define _HAS_MSVC_MAX_ true
#endif
#if defined( min )
#undef min 
#define _HAS_MSVC_MIN_ true
#endif
#endif


namespace DGtal
{
  template<Dimension dim, typename Container>
  std::bitset<dim> setDimensionsIn( const Container &dimensions );

  template<Dimension dim, typename Container>
  std::bitset<dim> setDimensionsNotIn( const Container &dimensions );

  // class PointVector
  template < DGtal::Dimension dim, typename TEuclideanRing >
  class PointVector
  {
    // ----------------------- Standard services ------------------------------
  public:
    
    BOOST_CONCEPT_ASSERT(( CEuclideanRing<TEuclideanRing> ) );

    typedef PointVector<dim, TEuclideanRing> Self;

    typedef TEuclideanRing Component;
  
    typedef Component Coordinate;

    typedef typename NumberTraits<Component>::UnsignedVersion UnsignedComponent;
    
    typedef DGtal::Dimension Dimension;

    static const Dimension dimension = dim;

#ifdef CPP11_ARRAY
    typedef typename std::array<Component, dimension>::iterator Iterator;
    typedef typename std::array<Component, dimension>::const_iterator ConstIterator;
    typedef typename std::array<Component, dimension>::reverse_iterator ReverseIterator;
    typedef typename std::array<Component, dimension>::const_reverse_iterator ConstReverseIterator;
#else
    typedef typename boost::array<Component, dimension>::iterator Iterator;
    typedef typename boost::array<Component, dimension>::const_iterator ConstIterator;
    typedef typename boost::array<Component, dimension>::reverse_iterator ReverseIterator;
    typedef typename boost::array<Component, dimension>::const_reverse_iterator ConstReverseIterator;
#endif

    PointVector();

    explicit PointVector( const Component* ptrValues );

    PointVector( const Component & x, const Component & y );

    PointVector( const Component & x, const Component & y, const Component & z );

    PointVector( const Component & x, const Component & y, const Component & z, const Component & t );

#ifdef CPP11_INITIALIZER_LIST

    PointVector( std::initializer_list<Component> init );
#endif // CPP11_INITIALIZER_LIST

    template<typename Functor>
    PointVector( const Self& apoint1, const Self& apoint2,
                 const Functor& f );

    ~PointVector();

    // ----------------------- Iterator services ------------------------------
  public:
    PointVector( const Self & other );

    template <typename OtherComponent>
    PointVector( const PointVector<dim,OtherComponent> & other );

    Self & operator= ( const Self & pv );


#ifdef CPP11_INITIALIZER_LIST

    Self& partialCopy (const Self & pv,
                       std::initializer_list<Dimension> dimensions);

    Self& partialCopyInv (const Self & pv,
                          std::initializer_list<Dimension> dimensions);
#endif

    Self& partialCopy (const Self & pv,
                       const std::vector<Dimension> &dimensions);

    Self& partialCopyInv (const Self & pv,
                          const std::vector<Dimension> &dimensions);

    bool partialEqual ( const Self & pv,
                        const std::vector<Dimension> &dimensions )  const;

    bool partialEqualInv ( const Self & pv,
                           const std::vector<Dimension> &dimensions )  const;
    
    // ----------------------- Iterator services ------------------------------
  public:
    Iterator begin();

    Iterator end();

    ConstIterator begin() const;

    ConstIterator end() const;

    ReverseIterator rbegin();

    ReverseIterator rend();

    ConstReverseIterator rbegin() const;
    
    ConstReverseIterator rend() const;

    // ----------------------- Array services ------------------------------
  public:
    static Dimension size();

    const Component& at( Dimension i ) const;

    Component& at( Dimension i );

    const Component& operator[]( Dimension i ) const;

    Component& operator[](Dimension i );

    // ----------------------- Comparison operations --------------------------
  public:
    bool operator== ( const Self & pv ) const;

    bool operator!= ( const Self & pv ) const;

    bool operator< ( const Self & pv ) const;

    bool operator<= ( const Self & pv ) const;

    bool operator> ( const Self & pv ) const;
    
    bool operator>= ( const Self & pv ) const;

    // ----------------------- Operations ------------------------------
  public:
    PointVector & operator*= ( Component coeff );

    PointVector operator*( Component coeff ) const;
    
    Component dot( const Self &v) const;

    Self & operator+= ( const Self & v );

    Self operator+ ( const Self & v ) const;

    Self & operator-= ( const Self & v );

    Self operator- ( const Self & v ) const;

    
    Self & operator/= ( const Self & v );

    Self  operator/ ( const Self & v ) const ;
  
    Self operator/ ( const Component coeff );
    
    Self & operator/= ( const Component coeff );
   
    template<typename AnotherComponent>
    Self & operator= ( const PointVector<dim,AnotherComponent> & v );
  
    
    void reset();

    Self inf( const Self& apoint ) const;

    Self sup( const Self& apoint ) const;

    bool isLower( const Self& p ) const;

    bool isUpper( const Self& p ) const;

    Component max() const;
   
    Component min() const;

    Iterator maxElement();
   
    Iterator minElement();

    void negate();

    enum NormType { L_2, L_1, L_infty };

    double norm( const NormType type = L_2 ) const;

    UnsignedComponent norm1() const;

    UnsignedComponent normInfinity() const;


    PointVector<dim, double> getNormalized() const;
    

    // ------------------------- Standard vectors ------------------------------
  public:

    static Self diagonal( Component val = 1 );

    static Self base( Dimension k, Component val = 1 );

    // ------------------------- Private Datas -------------------------------
  private:



    // --------------- CDrawableWithBoard2D realization -------------------
  public:

    //DrawableWithBoard2D* defaultStyle( std::string mode = "" ) const;
    

    
    std::string className() const;

    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay( std::ostream & out ) const;

    bool isValid() const;

    static Self zero;
    
    // ------------------------- Hidden services ------------------------------
  //protected:
    
#ifdef CPP11_ARRAY
    std::array<Component, dimension> myArray;
#else
    boost::array<Component, dimension> myArray;
#endif

  }; // end of class PointVector

  template<Dimension dim, typename Component>
  std::ostream&
  operator<<( std::ostream & out, const PointVector<dim, Component> & object );

  template< Dimension dim, typename Component>
  PointVector<dim, Component>  PointVector<dim, Component>::zero;
} // namespace DGtal

// Includes inline functions
#include "DGtal/kernel/PointVector.ih"

//                                                                           //

#endif // !defined PointVector_h

#undef PointVector_RECURSES
#endif // else defined(PointVector_RECURSES)