inet::math::Point< T > Class Template Reference

N-dimensional point. More...

#include <Point.h>

Inheritance diagram for inet::math::Point< T >:

Public Types
typedef std::tuple< T ... >	type

Public Member Functions
	Point (T ... t)
double	get (int index) const
void	set (int index, double value)
Point< T ... >	operator- () const
Point< T ... >	operator+ (const Point< T ... > &o) const
Point< T ... >	operator- (const Point< T ... > &o) const
Point< T ... >	operator* (double d) const
Point< T ... >	operator/ (double d) const
template<typename P , int DIMS>
void	copyTo (P &p) const
	Copy the dimensions selected by the 1 bits of DIMS into p. More...
template<typename P , int DIMS>
void	copyFrom (const P &p)
	Copy the coordinates selected by the 1 bits of DIMS from p. More...
template<typename X , int DIMENSION>
Point< T ... >	getReplaced (X x) const
std::string	str () const

Static Public Member Functions
static Point< T ... >	getZero ()
static Point< T ... >	getLowerBounds ()
static Point< T ... >	getUpperBounds ()

Protected Member Functions
template<size_t ... IS>
double	getImpl (int index, std::integer_sequence< size_t, IS... >) const
template<size_t ... IS>
void	setImpl (int index, double value, std::integer_sequence< size_t, IS... >)
template<size_t ... IS>
Point< T ... >	add (const Point< T ... > &o, std::integer_sequence< size_t, IS ... >) const
template<size_t ... IS>
Point< T ... >	subtract (const Point< T ... > &o, std::integer_sequence< size_t, IS ... >) const
template<size_t ... IS>
Point< T ... >	multiply (double d, std::integer_sequence< size_t, IS ... >) const
template<size_t ... IS>
Point< T ... >	divide (double d, std::integer_sequence< size_t, IS ... >) const

Detailed Description

template<typename... T>
class inet::math::Point< T >

N-dimensional point.

Supports algebraic operations.

Member Typedef Documentation

type

template<typename... T>

typedef std::tuple<T ...> inet::math::Point< T >::type

Constructor & Destructor Documentation

Point()

template<typename... T>

inet::math::Point< T >::Point ( T ...  t )

inline

: std::tuple<T ...>(t...) {}

Member Function Documentation

add()

template<typename... T>

template<size_t ... IS>

Point<T ...> inet::math::Point< T >::add ( const Point< T ... > &  o, std::integer_sequence< size_t, IS ... >    ) const

inlineprotected

                                                                                       {
        return Point<T ...>{ (std::get<IS>(*this) + std::get<IS>(o)) ... };
    }

copyFrom()

template<typename... T>

template<typename P , int DIMS>

void inet::math::Point< T >::copyFrom ( const P &  p )

inline

Copy the coordinates selected by the 1 bits of DIMS from p.

                              {
        internal::copyTupleElements(p, internal::make_bits_to_indices_sequence<DIMS, std::tuple_size<typename P::type>::value>{}, *this, std::index_sequence_for<T ...>{});
    }

copyTo()

template<typename... T>

template<typename P , int DIMS>

void inet::math::Point< T >::copyTo ( P &  p ) const

inline

Copy the dimensions selected by the 1 bits of DIMS into p.

                            {
        internal::copyTupleElements(*this, std::index_sequence_for<T ...>{}, p, internal::make_bits_to_indices_sequence<DIMS, std::tuple_size<typename P::type>::value>{});
    }

divide()

template<typename... T>

template<size_t ... IS>

Point<T ...> inet::math::Point< T >::divide ( double  d, std::integer_sequence< size_t, IS ... >    ) const

inlineprotected

                                                                             {
        return Point<T ...>{ (std::get<IS>(*this) / d) ... };
    }

get()

template<typename... T>

double inet::math::Point< T >::get ( int  index ) const

inline

                                {
        return getImpl(index, std::index_sequence_for<T ...>{});
    }

getImpl()

template<typename... T>

template<size_t ... IS>

double inet::math::Point< T >::getImpl ( int  index, std::integer_sequence< size_t, IS... >    ) const

inlineprotected

                                                                        {
        double result = 0;
        (void)std::initializer_list<double>{ result = (IS == index ? toDouble(std::get<IS>(*this)) : result) ... };
        return result;
    }

getLowerBounds()

template<typename... T>

static Point<T ...> inet::math::Point< T >::getLowerBounds ( )

inlinestatic

                                         {
        return Point<T ...>{ (getLowerBound<T>()) ... };
    }

getReplaced()

template<typename... T>

template<typename X , int DIMENSION>

Point<T ...> inet::math::Point< T >::getReplaced ( X  x ) const

inline

                                        {
        Point<T ...> p = *this;
        std::get<DIMENSION>(p) = x;
        return p;
    }

getUpperBounds()

template<typename... T>

static Point<T ...> inet::math::Point< T >::getUpperBounds ( )

inlinestatic

                                         {
        return Point<T ...>{ (getUpperBound<T>()) ... };
    }

getZero()

template<typename... T>

static Point<T ...> inet::math::Point< T >::getZero ( )

inlinestatic

                                  {
        return Point<T ...>{ T(0) ... };
    }

multiply()

template<typename... T>

template<size_t ... IS>

Point<T ...> inet::math::Point< T >::multiply ( double  d, std::integer_sequence< size_t, IS ... >    ) const

inlineprotected

                                                                               {
        return Point<T ...>{ (std::get<IS>(*this) * d) ... };
    }

operator*()

template<typename... T>

Point<T ...> inet::math::Point< T >::operator* ( double  d ) const

inline

                                           {
        return multiply(d, std::index_sequence_for<T ...>{});
    }

operator+()

template<typename... T>

Point<T ...> inet::math::Point< T >::operator+ ( const Point< T ... > &  o ) const

inline

                                                        {
        return add(o, std::index_sequence_for<T ...>{});
    }

operator-() [1/2]

template<typename... T>

Point<T ...> inet::math::Point< T >::operator- ( ) const

inline

                                   {
        return multiply(-1, std::index_sequence_for<T ...>{});
    }

operator-() [2/2]

template<typename... T>

Point<T ...> inet::math::Point< T >::operator- ( const Point< T ... > &  o ) const

inline

                                                        {
        return subtract(o, std::index_sequence_for<T ...>{});
    }

operator/()

template<typename... T>

Point<T ...> inet::math::Point< T >::operator/ ( double  d ) const

inline

                                           {
        return divide(d, std::index_sequence_for<T ...>{});
    }

set()

template<typename... T>

void inet::math::Point< T >::set ( int  index, double  value  )

inline

                                      {
        return setImpl(index, value, std::index_sequence_for<T ...>{});
    }

setImpl()

template<typename... T>

template<size_t ... IS>

void inet::math::Point< T >::setImpl ( int  index, double  value, std::integer_sequence< size_t, IS... >    )

inlineprotected

                                                                              {
        (void)std::initializer_list<double>{ (IS == index ? toDouble(std::get<IS>(*this) = T(value)) : 0) ... };
    }

str()

template<typename... T>

std::string inet::math::Point< T >::str ( ) const

inline

                          {
        std::stringstream os;
        os << *this;
        return os.str();
    }

subtract()

template<typename... T>

template<size_t ... IS>

Point<T ...> inet::math::Point< T >::subtract ( const Point< T ... > &  o, std::integer_sequence< size_t, IS ... >    ) const

inlineprotected

                                                                                            {
        return Point<T ...>{ (std::get<IS>(*this) - std::get<IS>(o)) ... };
    }

---

The documentation for this class was generated from the following file:

• Point.h