NumericalVector< T > Class Template Reference

#include <NumericalVector.h>

Public Member Functions
	NumericalVector ()
	NumericalVector (std::size_t m)
	NumericalVector (std::initializer_list< T > l)
	NumericalVector (const NumericalVector &other)
	NumericalVector (NumericalVector &&other)
	NumericalVector (const T array[], std::size_t size)
void	resize (std::size_t size)
NumericalVector< T > &	operator= (const NumericalVector< T > &right)
NumericalVector< T > &	operator= (const std::initializer_list< T > l)
NumericalVector< T >	operator+ (const NumericalVector< T > &right) const
NumericalVector< T >	operator- (const NumericalVector< T > &right) const
NumericalVector< T >	operator* (const T &right) const
T	operator* (const NumericalVector &right) const
NumericalVector< T > &	operator/= (const T &right)
NumericalVector< T >	operator/ (const T &right) const
NumericalVector< T > &	operator+= (const NumericalVector< T > &right)
NumericalVector< T > &	operator-= (const NumericalVector< T > &right)
NumericalVector< T > &	operator*= (const T &right)
T &	operator[] (std::size_t n)
const T &	operator[] (std::size_t n) const
T &	operator() (std::size_t n)
const T &	operator() (std::size_t n) const
std::size_t	size () const
const T *	data () const
T *	data ()

Private Attributes
std::vector< T >	data_

Constructor & Destructor Documentation

NumericalVector() [1/6]

template<typename T = Mdouble>

NumericalVector< T >::NumericalVector ( )

inline

            : data_()
    {
    }

NumericalVector() [2/6]

template<typename T = Mdouble>

NumericalVector< T >::NumericalVector ( std::size_t  m )

inlineexplicit

            : data_(m)
    {
    }

NumericalVector() [3/6]

template<typename T = Mdouble>

NumericalVector< T >::NumericalVector ( std::initializer_list< T >  l )

inline

            : data_(l)
    {
    }

NumericalVector() [4/6]

template<typename T = Mdouble>

NumericalVector< T >::NumericalVector ( const NumericalVector< T > &  other )

inline

            : data_(other.data_)
    {
    }

NumericalVector() [5/6]

template<typename T = Mdouble>

NumericalVector< T >::NumericalVector ( NumericalVector< T > &&  other )

inline

            : data_(std::move(other.data_))
    {
    }

NumericalVector() [6/6]

template<typename T = Mdouble>

NumericalVector< T >::NumericalVector ( const T  array[], std::size_t  size  )

inline

            : data_(array, array + size)
    {
    }

Member Function Documentation

data() [1/2]

template<typename T = Mdouble>

T* NumericalVector< T >::data ( )

inline

    {
        return data_.data();
    }

References NumericalVector< T >::data_.

Referenced by gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

data() [2/2]

template<typename T = Mdouble>

const T* NumericalVector< T >::data ( ) const

inline

    {
        return data_.data();
    }

References NumericalVector< T >::data_.

Referenced by gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

operator()() [1/2]

template<typename T = Mdouble>

T& NumericalVector< T >::operator() ( std::size_t  n )

inline

    {
        logger.assert_debug(n < data_.size(), "Requested entry %, but there are only % entries", n, data_.size());
        return data_[n];
    }

References NumericalVector< T >::data_, logger, and n.

operator()() [2/2]

template<typename T = Mdouble>

const T& NumericalVector< T >::operator() ( std::size_t  n ) const

inline

    {
        logger.assert_debug(n < data_.size(), "Requested entry %, but there are only % entries", n, data_.size());
        return data_[n];
    }

References NumericalVector< T >::data_, logger, and n.

operator*() [1/2]

template<typename T = Mdouble>

T NumericalVector< T >::operator* ( const NumericalVector< T > &  right ) const

inline

    {
        logger.assert_debug(data_.size() == right.data_.size(), "Vectors don't have equal length.");
        T sum = 0;
        for (std::size_t i = 0; i < data_.size(); i++)
            sum += data_[i] * right.data_[i];
        return sum;
    }

References NumericalVector< T >::data_, i, and logger.

operator*() [2/2]

template<typename T = Mdouble>

NumericalVector<T> NumericalVector< T >::operator* ( const T &  right ) const

inline

    {
        NumericalVector<T> result(*this);
        for (T& d : result.data_)
            d *= right;
        return result;
    }

operator*=()

template<typename T = Mdouble>

NumericalVector<T>& NumericalVector< T >::operator*= ( const T &  right )

inline

    {
        for (T& d : data_)
            d *= right;
        return *this;
    }

References NumericalVector< T >::data_.

operator+()

template<typename T = Mdouble>

NumericalVector<T> NumericalVector< T >::operator+ ( const NumericalVector< T > &  right ) const

inline

    {
        NumericalVector<T> result(*this);
        logger.assert_debug(data_.size() == right.data_.size(), "Vectors don't have the same size");
        for (std::size_t i = 0; i < data_.size(); i++)
            result.data_[i] += right.data_[i];
        return result;
    }

References NumericalVector< T >::data_, i, and logger.

operator+=()

template<typename T = Mdouble>

NumericalVector<T>& NumericalVector< T >::operator+= ( const NumericalVector< T > &  right )

inline

    {
        logger.assert_debug(data_.size() == right.data_.size(), "Vectors don't have the same size");
        for (std::size_t i = 0; i < data_.size(); i++)
            data_[i] += right.data_[i];
        return *this;
    }

References NumericalVector< T >::data_, i, and logger.

operator-()

template<typename T = Mdouble>

NumericalVector<T> NumericalVector< T >::operator- ( const NumericalVector< T > &  right ) const

inline

    {
        NumericalVector<T> result(*this);
        logger.assert_debug(data_.size() == right.data_.size(), "Vectors don't have the same size");
        for (std::size_t i = 0; i < data_.size(); i++)
            result.data_[i] -= right.data_[i];
        return result;
    }

References NumericalVector< T >::data_, i, and logger.

operator-=()

template<typename T = Mdouble>

NumericalVector<T>& NumericalVector< T >::operator-= ( const NumericalVector< T > &  right )

inline

    {
        logger.assert_debug(data_.size() == right.data_.size(), "Vectors don't have the same size");
        for (std::size_t i = 0; i < data_.size(); i++)
            data_[i] -= right.data_[i];
        return *this;
    }

References NumericalVector< T >::data_, i, and logger.

operator/()

template<typename T = Mdouble>

NumericalVector<T> NumericalVector< T >::operator/ ( const T &  right ) const

inline

    {
        NumericalVector<T> result(*this);
        return (result /= right);
        
    }

operator/=()

template<typename T = Mdouble>

NumericalVector<T>& NumericalVector< T >::operator/= ( const T &  right )

inline

    {
        for (T& d : data_)
            d /= right;
        
        return *this;
    }

References NumericalVector< T >::data_.

operator=() [1/2]

template<typename T = Mdouble>

NumericalVector<T>& NumericalVector< T >::operator= ( const NumericalVector< T > &  right )

inline

    {
        data_ = right.data_;
        return *this;
    }

References NumericalVector< T >::data_.

operator=() [2/2]

template<typename T = Mdouble>

NumericalVector<T>& NumericalVector< T >::operator= ( const std::initializer_list< T >  l )

inline

    {
        data_ = l;
        return *this;
    }

References NumericalVector< T >::data_.

operator[]() [1/2]

template<typename T = Mdouble>

T& NumericalVector< T >::operator[] ( std::size_t  n )

inline

    {
        logger.assert_debug(n < data_.size(), "Requested entry %, but there are only % entries", n, data_.size());
        return data_[n];
    }

References NumericalVector< T >::data_, logger, and n.

operator[]() [2/2]

template<typename T = Mdouble>

const T& NumericalVector< T >::operator[] ( std::size_t  n ) const

inline

    {
        logger.assert_debug(n < data_.size(), "Requested entry %, but there are only % entries", n, data_.size());
        return data_[n];
    }

References NumericalVector< T >::data_, logger, and n.

resize()

template<typename T = Mdouble>

void NumericalVector< T >::resize ( std::size_t  size )

inline

    {
        if (size != data_.size())
        {
            data_.resize(size);
        }
    }

References NumericalVector< T >::data_, and NumericalVector< T >::size().

size()

template<typename T = Mdouble>

std::size_t NumericalVector< T >::size ( ) const

inline

    {
        return data_.size();
    }

References NumericalVector< T >::data_.

Referenced by NumericalVector< T >::resize().

Member Data Documentation

data_

template<typename T = Mdouble>

std::vector<T> NumericalVector< T >::data_

private

Referenced by NumericalVector< T >::data(), NumericalVector< T >::operator()(), NumericalVector< T >::operator*(), NumericalVector< T >::operator*=(), NumericalVector< T >::operator+(), NumericalVector< T >::operator+=(), NumericalVector< T >::operator-(), NumericalVector< T >::operator-=(), NumericalVector< T >::operator/=(), NumericalVector< T >::operator=(), NumericalVector< T >::operator[](), NumericalVector< T >::resize(), and NumericalVector< T >::size().

---

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

• NumericalVector.h