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>
#include <array>
#include <vector>

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


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,
             typename TContainer=std::array<TEuclideanRing,dim> >
  class PointVector
  {
    // ----------------------- Standard services ------------------------------
  public:
    
    BOOST_CONCEPT_ASSERT(( concepts::CEuclideanRing<TEuclideanRing> ) );
    
  
    typedef PointVector<dim, TEuclideanRing, TContainer> Self;

    typedef TEuclideanRing Component;
  
    typedef Component Coordinate;

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

    static const Dimension dimension = dim;

    typedef Component Scalar;
    typedef Dimension Index;

    typedef TContainer Container;


    typedef typename Container::iterator Iterator;
    typedef typename Container::const_iterator ConstIterator;
    typedef typename Container::reverse_iterator ReverseIterator;
    typedef typename Container::const_reverse_iterator ConstReverseIterator;

    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 );

    PointVector( std::initializer_list<Component> init );

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

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

    ~PointVector();

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

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

    Self & operator= ( const Self & pv );

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

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

    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();
                inline Dimension rows() const { return dim; }

    const Component& operator[]( Dimension i ) const;
    inline const Component& operator()( Dimension i ) const { return (*this)[i]; }

    Component& operator[](Dimension i );
    Component& operator()(Dimension i ) { return (*this)[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 crossProduct( const Self &v) const;

    double cosineSimilarity ( 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 & operator/= ( const Self & v );

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

                inline void clear() { 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, std::array<double,dim> > getNormalized() const;
    

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

    static Self diagonal( Component val = 1 );

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

    // --------------- CDrawableWithBoard2D realization -------------------
  public:
 
    std::string className() const;

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

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

    bool isValid() const;

    static Self zero;
    
    // ------------------------- Hidden services ------------------------------
  protected:
    
    Container myArray;

  }; // end of class PointVector

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

  template<Dimension dim, typename Component, typename Container>
  PointVector<dim, Component,Container> 
  operator*( Component coeff,
             const PointVector<dim, Component,Container> & aVector );


  template< Dimension dim, typename Component, typename TC>
  PointVector<dim, Component,TC>  PointVector<dim, Component,TC>::zero;

  
} // namespace DGtal

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

//                                                                           //

#endif // !defined PointVector_h

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