tdm::vec< L, T > Struct Template Reference

#include <Vec.h>

Inheritance diagram for tdm::vec< L, T >:

Collaboration diagram for tdm::vec< L, T >:

Public Types
using	value_type = T

Public Member Functions
	vec ()
	~vec ()=default
	vec (const vec &rhs)=default
vec &	operator= (const vec &rhs)=default
	vec (vec &&rhs)=default
vec &	operator= (vec &&rhs)=default
template<typename U >
	vec (const vec< L, U > &rhs)
template<typename U >
vec &	operator= (const vec< L, U > &rhs)
template<typename ... Vs, typename std::enable_if<(sizeof...(Vs)==L)||(sizeof...(Vs)==0)>::type * = nullptr>
	vec (Vs... vs)
template<typename U , typename ... , typename std::enable_if< std::is_convertible< U, T >::value &&(L > 1)>::type * = nullptr>
	vec (U v)
template<typename U , typename ... , typename std::enable_if< std::is_convertible< U, T >::value >::type * = nullptr>
	vec (U *pv)
T &	operator[] (dim_t index)
const T &	operator[] (dim_t index) const
template<typename F >
vec &	apply (F func)
template<typename F >
const vec &	apply (F func) const
vec &	operator++ ()
vec &	operator-- ()
template<typename U >
vec &	operator+= (U rhs)
template<typename U >
vec &	operator+= (const vec< L, U > &rhs)
vec &	operator+= (const vec &rhs)
template<typename U >
vec &	operator-= (U rhs)
template<typename U >
vec &	operator-= (const vec< L, U > &rhs)
vec &	operator-= (const vec &rhs)
template<typename U >
vec &	operator*= (U rhs)
template<typename U >
vec &	operator*= (const vec< L, U > &rhs)
vec &	operator*= (const vec &rhs)
template<typename U >
vec &	operator/= (U rhs)
template<typename U >
vec &	operator/= (const vec< L, U > &rhs)
vec &	operator/= (const vec &rhs)
template<typename ... , typename V = T>
std::enable_if< std::is_floating_point< V >::value, V >::type	length () const
template<typename ... , typename V = T>
std::enable_if< std::is_floating_point< V >::value, vec & >::type	normalize ()
vec &	negate ()
T	sum () const

Static Public Member Functions
static constexpr dim_t	dimensions ()

Public Attributes
value_type	values [L]

Member Typedef Documentation

value_type

template<dim_t L, typename T >

using tdm::vec< L, T >::value_type = T

Constructor & Destructor Documentation

vec() [1/7]

template<dim_t L, typename T >

tdm::vec< L, T >::vec ( )

inline

          : values{} {
    }

~vec()

template<dim_t L, typename T >

tdm::vec< L, T >::~vec ( )

default

vec() [2/7]

template<dim_t L, typename T >

tdm::vec< L, T >::vec ( const vec< L, T > &  rhs )

default

vec() [3/7]

template<dim_t L, typename T >

tdm::vec< L, T >::vec ( vec< L, T > &&  rhs )

default

vec() [4/7]

template<dim_t L, typename T >

template<typename U >

tdm::vec< L, T >::vec ( const vec< L, U > &  rhs )

inline

                              {
        std::copy(std::begin(rhs.values), std::end(rhs.values), std::begin(values));
    }

References extd::copy(), and tdm::vec< L, T >::values.

vec() [5/7]

template<dim_t L, typename T >

template<typename ... Vs, typename std::enable_if<(sizeof...(Vs)==L)||(sizeof...(Vs)==0)>::type * = nullptr>

tdm::vec< L, T >::vec ( Vs...  vs )

inline

                  : values{vs ...} {
    }

vec() [6/7]

template<dim_t L, typename T >

template<typename U , typename ... , typename std::enable_if< std::is_convertible< U, T >::value &&(L > 1)>::type * = nullptr>

tdm::vec< L, T >::vec ( U  v )

inlineexplicit

                      {
        std::fill_n(values, dimensions(), v);
    }

References tdm::vec< L, T >::dimensions(), and tdm::vec< L, T >::values.

vec() [7/7]

template<dim_t L, typename T >

template<typename U , typename ... , typename std::enable_if< std::is_convertible< U, T >::value >::type * = nullptr>

tdm::vec< L, T >::vec ( U *  pv )

inlineexplicit

                        {
        std::copy_n(pv, dimensions(), std::begin(values));
    }

References tdm::vec< L, T >::dimensions(), and tdm::vec< L, T >::values.

Member Function Documentation

apply() [1/2]

template<dim_t L, typename T >

template<typename F >

vec & tdm::vec< L, T >::apply ( F  func )

inline

                       {
        for (dim_t i{}; i < dimensions(); ++i) {
            func(values[i], i);
        }
        return *this;
    }

References tdm::vec< L, T >::dimensions(), and tdm::vec< L, T >::values.

Referenced by tdm::mat< R, C, T >::mat(), tdm::vec< L, T >::negate(), tdm::operator*(), tdm::vec< L, T >::operator*=(), tdm::vec< L, T >::operator++(), tdm::vec< L, T >::operator+=(), tdm::vec< L, T >::operator--(), tdm::vec< L, T >::operator-=(), tdm::vec< L, T >::operator/=(), tdm::operator==(), tdm::mat< R, C, T >::submat(), and tdm::vec< L, T >::sum().

apply() [2/2]

template<dim_t L, typename T >

template<typename F >

const vec & tdm::vec< L, T >::apply ( F  func ) const

inline

                                   {
        for (dim_t i{}; i < dimensions(); ++i) {
            func(values[i], i);
        }
        return *this;
    }

References tdm::vec< L, T >::dimensions(), and tdm::vec< L, T >::values.

dimensions()

template<dim_t L, typename T >

static constexpr dim_t tdm::vec< L, T >::dimensions ( )

inlinestaticconstexpr

                                        {
        return L;
    }

Referenced by tdm::vec< L, T >::apply(), tdm::vec< L, T >::operator[](), tdm::mat< R, C, T >::rows(), and tdm::vec< L, T >::vec().

length()

template<dim_t L, typename T >

template<typename ... , typename V = T>

std::enable_if< std::is_floating_point< V >::value, V >::type tdm::vec< L, T >::length ( ) const

inline

                                                                              {
        const auto& v = *this;
        return std::sqrt((v * v).sum());
    }

References tdm::vec< L, T >::sum().

Referenced by tdm::length(), and tdm::vec< L, T >::normalize().

negate()

template<dim_t L, typename T >

vec & tdm::vec< L, T >::negate ( )

inline

                  {
        return apply([](T& v, dim_t  /*unused*/) {
                v = -v;
            });
    }

References tdm::vec< L, T >::apply().

Referenced by tdm::mat< R, C, T >::negate(), tdm::negate(), and tdm::operator-().

normalize()

template<dim_t L, typename T >

template<typename ... , typename V = T>

std::enable_if< std::is_floating_point< V >::value, vec & >::type tdm::vec< L, T >::normalize ( )

inline

                                                                              {
        return operator/=(length());
    }

References tdm::vec< L, T >::length(), and tdm::vec< L, T >::operator/=().

Referenced by tdm::normalize().

operator*=() [1/3]

template<dim_t L, typename T >

vec & tdm::vec< L, T >::operator*= ( const vec< L, T > &  rhs )

inline

                                    {
        return operator*=<T>(rhs);
    }

operator*=() [2/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator*= ( const vec< L, U > &  rhs )

inline

                                          {
        return apply([&rhs](T& v, dim_t i) {
                v *= rhs[i];
            });
    }

References tdm::vec< L, T >::apply().

operator*=() [3/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator*= ( U  rhs )

inline

                           {
        return apply([rhs](T& v, dim_t  /*unused*/) {
                v *= rhs;
            });
    }

References tdm::vec< L, T >::apply().

operator++()

template<dim_t L, typename T >

vec & tdm::vec< L, T >::operator++ ( )

inline

                      {
        return apply([](T& v, dim_t  /*unused*/) {
                ++v;
            });
    }

References tdm::vec< L, T >::apply().

operator+=() [1/3]

template<dim_t L, typename T >

vec & tdm::vec< L, T >::operator+= ( const vec< L, T > &  rhs )

inline

                                    {
        return operator+=<T>(rhs);
    }

operator+=() [2/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator+= ( const vec< L, U > &  rhs )

inline

                                          {
        return apply([&rhs](T& v, dim_t i) {
                v += rhs[i];
            });
    }

References tdm::vec< L, T >::apply().

operator+=() [3/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator+= ( U  rhs )

inline

                           {
        return apply([rhs](T& v, dim_t  /*unused*/) {
                v += rhs;
            });
    }

References tdm::vec< L, T >::apply().

operator--()

template<dim_t L, typename T >

vec & tdm::vec< L, T >::operator-- ( )

inline

                      {
        return apply([](T& v, dim_t  /*unused*/) {
                --v;
            });
    }

References tdm::vec< L, T >::apply().

operator-=() [1/3]

template<dim_t L, typename T >

vec & tdm::vec< L, T >::operator-= ( const vec< L, T > &  rhs )

inline

                                    {
        return operator-=<T>(rhs);
    }

operator-=() [2/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator-= ( const vec< L, U > &  rhs )

inline

                                          {
        return apply([&rhs](T& v, dim_t i) {
                v -= rhs[i];
            });
    }

References tdm::vec< L, T >::apply().

operator-=() [3/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator-= ( U  rhs )

inline

                           {
        return apply([rhs](T& v, dim_t  /*unused*/) {
                v -= rhs;
            });
    }

References tdm::vec< L, T >::apply().

operator/=() [1/3]

template<dim_t L, typename T >

vec & tdm::vec< L, T >::operator/= ( const vec< L, T > &  rhs )

inline

                                    {
        return operator/=<T>(rhs);
    }

operator/=() [2/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator/= ( const vec< L, U > &  rhs )

inline

                                          {
        return apply([&rhs](T& v, dim_t i) {
                v /= rhs[i];
            });
    }

References tdm::vec< L, T >::apply().

operator/=() [3/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator/= ( U  rhs )

inline

                           {
        return apply([rhs](T& v, dim_t  /*unused*/) {
                v /= rhs;
            });
    }

References tdm::vec< L, T >::apply().

Referenced by tdm::vec< L, T >::normalize().

operator=() [1/3]

template<dim_t L, typename T >

vec & tdm::vec< L, T >::operator= ( const vec< L, T > &  rhs )

default

operator=() [2/3]

template<dim_t L, typename T >

template<typename U >

vec & tdm::vec< L, T >::operator= ( const vec< L, U > &  rhs )

inline

                                         {
        std::copy(std::begin(rhs.values), std::end(rhs.values), std::begin(values));
        return *this;
    }

References extd::copy(), and tdm::vec< L, T >::values.

operator=() [3/3]

template<dim_t L, typename T >

vec & tdm::vec< L, T >::operator= ( vec< L, T > &&  rhs )

default

operator[]() [1/2]

template<dim_t L, typename T >

T & tdm::vec< L, T >::operator[] ( dim_t  index )

inline

                               {
        assert(index < dimensions());
        return values[index];
    }

References tdm::vec< L, T >::dimensions(), and tdm::vec< L, T >::values.

operator[]() [2/2]

template<dim_t L, typename T >

const T & tdm::vec< L, T >::operator[] ( dim_t  index ) const

inline

                                           {
        assert(index < dimensions());
        return values[index];
    }

References tdm::vec< L, T >::dimensions(), and tdm::vec< L, T >::values.

sum()

template<dim_t L, typename T >

T tdm::vec< L, T >::sum ( ) const

inline

                  {
        T retval{};
        apply([&retval](const T& v, dim_t  /*unused*/) {
                retval += v;
            });
        return retval;
    }

References tdm::vec< L, T >::apply().

Referenced by tdm::vec< L, T >::length().

Member Data Documentation

values

template<dim_t L, typename T >

value_type tdm::vec< L, T >::values[L]

Referenced by tdm::vec< L, T >::apply(), tdm::vec< L, T >::operator=(), tdm::vec< L, T >::operator[](), and tdm::vec< L, T >::vec().

---

The documentation for this struct was generated from the following files:

• Types.h
• Vec.h