SmallVector< numberOfRows > Class Template Reference

#include <SmallVector.h>

Public Member Functions
	SmallVector ()
	SmallVector (const SmallVector &other)
	SmallVector (SmallVector &&other)
	SmallVector (const Mdouble array[])
	SmallVector (std::initializer_list< Mdouble > data)
SmallVector &	operator= (const SmallVector &right)
SmallVector &	operator= (const std::array< Mdouble, numberOfRows > l)
SmallVector	operator+ (const SmallVector &right) const
SmallVector	operator- (const SmallVector &right) const
SmallVector	operator* (const Mdouble &right) const
Mdouble	operator* (const SmallVector &right) const
	Computes inner product between two vectors. More...
SmallVector &	operator/= (const Mdouble &right)
SmallVector	operator/ (const Mdouble &right) const
void	axpy (Mdouble a, const SmallVector &x)
bool	operator== (const SmallVector &right) const
bool	operator< (const SmallVector &right) const
SmallVector &	operator+= (const SmallVector &right)
SmallVector &	operator-= (const SmallVector &right)
SmallVector &	operator*= (const double &right)
Mdouble &	operator[] (unsigned int n)
const Mdouble &	operator[] (unsigned int n) const
Mdouble &	operator() (unsigned int n)
const Mdouble &	operator() (unsigned int n) const
unsigned int	size () const
const Mdouble *	data () const
Mdouble *	data ()
SmallVector	operator- () const
Mdouble	length () const
SmallVector< numberOfRows >	getNormalised () const

Private Attributes
std::array< Mdouble, numberOfRows >	data_

Detailed Description

template<unsigned int numberOfRows>
class SmallVector< numberOfRows >

Implementation of a 3D vector (by Vitaliy). Modifications 21:9:2009 - Added the inclusion guards and some include objects

Todo:

Need to generalize this to n-dimensional vectors of any type

Constructor & Destructor Documentation

SmallVector() [1/5]

template<unsigned int numberOfRows>

SmallVector< numberOfRows >::SmallVector ( )

inline

            : data_()
    {
    }

SmallVector() [2/5]

template<unsigned int numberOfRows>

SmallVector< numberOfRows >::SmallVector ( const SmallVector< numberOfRows > &  other )

inline

            : data_(other.data_)
    {
    }

SmallVector() [3/5]

template<unsigned int numberOfRows>

SmallVector< numberOfRows >::SmallVector ( SmallVector< numberOfRows > &&  other )

inline

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

SmallVector() [4/5]

template<unsigned int numberOfRows>

SmallVector< numberOfRows >::SmallVector ( const Mdouble  array[] )

inline

            : data_()
    {
        std::copy(array, array + numberOfRows, data_.begin());
    }

References SmallVector< numberOfRows >::data_.

SmallVector() [5/5]

template<unsigned int numberOfRows>

SmallVector< numberOfRows >::SmallVector ( std::initializer_list< Mdouble >  data )

inline

            : data_()
    {
        logger.assert_debug(data.size() == numberOfRows, "provided array has size %, but should have size %",
                      data.size(), numberOfRows);
        std::copy(data.begin(), data.end(), data_.begin());
    }

References SmallVector< numberOfRows >::data(), SmallVector< numberOfRows >::data_, and logger.

Member Function Documentation

axpy()

template<unsigned int numberOfRows>

void SmallVector< numberOfRows >::axpy ( Mdouble  a, const SmallVector< numberOfRows > &  x  )

inline

    {
        for (unsigned int i = 0; i < numberOfRows; ++i)
        {
            data_[i] += a * x[i];
        }
    }

References SmallVector< numberOfRows >::data_, and constants::i.

Referenced by main().

data() [1/2]

template<unsigned int numberOfRows>

Mdouble* SmallVector< numberOfRows >::data ( )

inline

    {
        return data_.data();
    }

References SmallVector< numberOfRows >::data_.

data() [2/2]

template<unsigned int numberOfRows>

const Mdouble* SmallVector< numberOfRows >::data ( ) const

inline

    {
        return data_.data();
    }

References SmallVector< numberOfRows >::data_.

Referenced by main(), SmallMatrix< numberOfRows, numberOfColumns >::operator*(), operator*(), SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix(), SmallVector< numberOfRows >::SmallVector(), and SmallMatrix< numberOfRows, numberOfColumns >::solve().

getNormalised()

template<unsigned int numberOfRows>

SmallVector<numberOfRows> SmallVector< numberOfRows >::getNormalised ( ) const

inline

    {
        return (*this) / length();
    }

References SmallVector< numberOfRows >::length().

length()

template<unsigned int numberOfRows>

Mdouble SmallVector< numberOfRows >::length ( ) const

inline

    {
        Mdouble sum = 0;
        for (Mdouble x : data_)
        {
            sum += x * x;
            logger(DEBUG, "x: %, sum: %", x, sum);
        }
        return std::sqrt(sum);
    }

References SmallVector< numberOfRows >::data_, DEBUG, and logger.

Referenced by SuperQuadricParticle::getCurvature(), and SmallVector< numberOfRows >::getNormalised().

operator()() [1/2]

template<unsigned int numberOfRows>

Mdouble& SmallVector< numberOfRows >::operator() ( unsigned int  n )

inline

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

References SmallVector< numberOfRows >::data_, logger, and n.

operator()() [2/2]

template<unsigned int numberOfRows>

const Mdouble& SmallVector< numberOfRows >::operator() ( unsigned int  n ) const

inline

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

References SmallVector< numberOfRows >::data_, logger, and n.

operator*() [1/2]

template<unsigned int numberOfRows>

SmallVector SmallVector< numberOfRows >::operator* ( const Mdouble &  right ) const

inline

    {
        SmallVector result;
        std::transform(data_.begin(), data_.end(), result.data_.begin(), std::bind(std::multiplies<Mdouble>(),
                                                                                   std::placeholders::_1, right));
        return result;
    }

References SmallVector< numberOfRows >::data_.

operator*() [2/2]

template<unsigned int numberOfRows>

Mdouble SmallVector< numberOfRows >::operator* ( const SmallVector< numberOfRows > &  right ) const

inline

Computes inner product between two vectors.

    {
        return std::inner_product(right.data_.begin(), right.data_.end(), data_.begin(), 0.0);
    }

References SmallVector< numberOfRows >::data_.

operator*=()

template<unsigned int numberOfRows>

SmallVector& SmallVector< numberOfRows >::operator*= ( const double &  right )

inline

    {
        std::transform(data_.begin(), data_.end(), data_.begin(), std::bind(std::multiplies<Mdouble>(),
                                                                            std::placeholders::_1, right));
        return *this;
    }

References SmallVector< numberOfRows >::data_.

operator+()

template<unsigned int numberOfRows>

SmallVector SmallVector< numberOfRows >::operator+ ( const SmallVector< numberOfRows > &  right ) const

inline

    {
        SmallVector result;
        std::transform(data_.begin(), data_.end(), right.data_.begin(), result.data_.begin(), std::plus<Mdouble>());
        return result;
    }

References SmallVector< numberOfRows >::data_.

operator+=()

template<unsigned int numberOfRows>

SmallVector& SmallVector< numberOfRows >::operator+= ( const SmallVector< numberOfRows > &  right )

inline

    {
        std::transform(data_.begin(), data_.end(), right.data_.begin(), data_.begin(), std::plus<Mdouble>());
        return *this;
    }

References SmallVector< numberOfRows >::data_.

operator-() [1/2]

template<unsigned int numberOfRows>

SmallVector SmallVector< numberOfRows >::operator- ( ) const

inline

    {
        return *this * -1.0;
    }

operator-() [2/2]

template<unsigned int numberOfRows>

SmallVector SmallVector< numberOfRows >::operator- ( const SmallVector< numberOfRows > &  right ) const

inline

    {
        SmallVector result;
        std::transform(data_.begin(), data_.end(), right.data_.begin(), result.data_.begin(), std::minus<Mdouble>());
        return result;
    }

References SmallVector< numberOfRows >::data_.

operator-=()

template<unsigned int numberOfRows>

SmallVector& SmallVector< numberOfRows >::operator-= ( const SmallVector< numberOfRows > &  right )

inline

    {
        std::transform(data_.begin(), data_.end(), right.data_.begin(), data_.begin(), std::minus<Mdouble>());
        return *this;
    }

References SmallVector< numberOfRows >::data_.

operator/()

template<unsigned int numberOfRows>

SmallVector SmallVector< numberOfRows >::operator/ ( const Mdouble &  right ) const

inline

    {
        SmallVector result;
        std::transform(data_.begin(), data_.end(), result.data_.begin(), std::bind(std::divides<Mdouble>(),
                                                                                   std::placeholders::_1, right));
        return result;
    }

References SmallVector< numberOfRows >::data_.

operator/=()

template<unsigned int numberOfRows>

SmallVector& SmallVector< numberOfRows >::operator/= ( const Mdouble &  right )

inline

    {
        std::transform(data_.begin(), data_.end(), data_.begin(), std::bind(std::divides<Mdouble>(),
                                                                            std::placeholders::_1, right));
        return *this;
    }

References SmallVector< numberOfRows >::data_.

operator<()

template<unsigned int numberOfRows>

bool SmallVector< numberOfRows >::operator< ( const SmallVector< numberOfRows > &  right ) const

inline

This function is dangerous to use, since it compares doubles without a tolerance interval to see if they are equal.

    {
        for (unsigned int i = 0; i < numberOfRows; ++i)
        {
            if (data_[i] < right[i])
            {
                return true;
            }
            if (data_[i] > right[i])
            {
                return false;
            }
        }
        return false;
    }

References SmallVector< numberOfRows >::data_, and constants::i.

operator=() [1/2]

template<unsigned int numberOfRows>

SmallVector& SmallVector< numberOfRows >::operator= ( const SmallVector< numberOfRows > &  right )

inline

    {
        std::copy(right.data_.begin(), right.data_.end(), data_.begin());
        return *this;
    }

References SmallVector< numberOfRows >::data_.

operator=() [2/2]

template<unsigned int numberOfRows>

SmallVector& SmallVector< numberOfRows >::operator= ( const std::array< Mdouble, numberOfRows >  l )

inline

    {
        std::copy(l.begin(), l.end(), data_.begin());
        return *this;
    }

References SmallVector< numberOfRows >::data_.

operator==()

template<unsigned int numberOfRows>

bool SmallVector< numberOfRows >::operator== ( const SmallVector< numberOfRows > &  right ) const

inline

This function is dangerous to use, since it compares doubles without a tolerance interval to see if they are equal.

    {
        for (unsigned int i = 0; i < numberOfRows; ++i)
        {
            if (data_[i] != right[i])
            {
                return false;
            }
        }
        return true;
    }

References SmallVector< numberOfRows >::data_, and constants::i.

operator[]() [1/2]

template<unsigned int numberOfRows>

Mdouble& SmallVector< numberOfRows >::operator[] ( unsigned int  n )

inline

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

References SmallVector< numberOfRows >::data_, logger, and n.

operator[]() [2/2]

template<unsigned int numberOfRows>

const Mdouble& SmallVector< numberOfRows >::operator[] ( unsigned int  n ) const

inline

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

References SmallVector< numberOfRows >::data_, logger, and n.

size()

template<unsigned int numberOfRows>

unsigned int SmallVector< numberOfRows >::size ( ) const

inline

    {
        return numberOfRows;
    }

Referenced by main(), SmallMatrix< numberOfRows, numberOfColumns >::operator*(), and operator*().

Member Data Documentation

data_

template<unsigned int numberOfRows>

std::array<Mdouble, numberOfRows> SmallVector< numberOfRows >::data_

private

Referenced by SmallVector< numberOfRows >::axpy(), SmallVector< numberOfRows >::data(), SmallVector< numberOfRows >::length(), SmallVector< numberOfRows >::operator()(), SmallVector< numberOfRows >::operator*(), SmallVector< numberOfRows >::operator*=(), SmallVector< numberOfRows >::operator+(), SmallVector< numberOfRows >::operator+=(), SmallVector< numberOfRows >::operator-(), SmallVector< numberOfRows >::operator-=(), SmallVector< numberOfRows >::operator/(), SmallVector< numberOfRows >::operator/=(), SmallVector< numberOfRows >::operator<(), SmallVector< numberOfRows >::operator=(), SmallVector< numberOfRows >::operator==(), SmallVector< numberOfRows >::operator[](), and SmallVector< numberOfRows >::SmallVector().

---

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

• SmallVector.h