ptems::BasicVector< T, DIM > Struct Template Reference

Vector representing a point in DIM-dimensional space. More...

#include <ptems/vector.hpp>

Public Types
using	ConjugateType = BasicVector< typename std::conditional_t< is_complex_v< T >, T, std::complex< T > >, DIM >
	The type of the conjugate of the vector. More...

Public Member Functions
constexpr	BasicVector ()
	Construct a zero vector. More...
constexpr	BasicVector (T value)
	Construct a vector with all components equal to the specified value. More...
template<typename... F, typename = std::enable_if_t<sizeof...(F) == DIM>>
constexpr	BasicVector (F... pt)
	Construct a vector for the specified point. More...
template<typename U >
constexpr	BasicVector (const BasicVector< U, DIM > rhs)
	Construct a vector by copying the specified vector. More...
template<typename U >
constexpr BasicVector &	operator= (const BasicVector< U, DIM > rhs)
	Copy the specified vector to this. More...
constexpr BasicVector &	operator= (T rhs)
	Set all components tof vector equal to a constants. More...
constexpr BasicVector &	operator+= (T rhs)
	Adds a constant to every component to this vector. More...
template<typename U >
constexpr BasicVector &	operator+= (const BasicVector< U, DIM > &rhs)
	Adds another vector to this vector. More...
constexpr BasicVector &	operator-= (T rhs)
	Subtracts constant from every component to this vector. More...
template<typename U >
constexpr BasicVector &	operator-= (const BasicVector< U, DIM > &rhs)
	Subtracts another vector to this vector. More...
template<typename U >
constexpr BasicVector &	operator/= (U rhs)
	Divides all components of this vector by a constant. More...
template<typename U >
constexpr BasicVector &	operator/= (const BasicVector< U, DIM > &rhs)
	Performs elementwise division of all components of this vector by the other vector. More...
template<typename U >
constexpr BasicVector &	operator*= (U rhs)
	Multiplies all components of this vector by a constant. More...
template<typename U >
constexpr BasicVector &	operator*= (const BasicVector< U, DIM > &rhs)
	Performs elementwise multiplication of all components of this vector by the other vector. More...
constexpr BasicVector	operator- () const
	Returns the negated vector. More...
template<typename U >
constexpr std::common_type_t< T, U >	Dot (const BasicVector< U, DIM > &rhs) const
	Computes the dot product of this vector with the specified vector. More...
constexpr remove_complex_t< T >	Length () const
	Computes the length of the vector. More...
constexpr T	operator[] (std::size_t i) const
	Gets a component of the vector by index. More...
constexpr T &	operator[] (std::size_t i)
	Gets a mutable reference to the component of the vector by index. More...
constexpr remove_complex_t< T >	LengthSquared () const
	Gets the square of the length of the vector. More...
constexpr BasicVector &	Normalise ()
	Normalises the current vector. More...
constexpr BasicVector	Normalised () const
	Gets a new vector which is the normalised version of this vector. More...
ConjugateType	Conjugate () const
	Computes the complex conjugate of the vector. More...
BasicVector &	ConjugateOverwrite () const
	Overwrites the vector with its complex conjugate. More...
std::size_t	size () const
	Gets the number of elements in the vector. More...

Related Functions
(Note that these are not member functions.)
template<typename T , typename U , std::size_t DIM>
constexpr BasicVector< std::common_type_t< T, U >, DIM >	operator+ (const BasicVector< T, DIM > &lhs, const BasicVector< U, DIM > &rhs)
	Computes the vector resulting from the addition of two vectors. More...
template<typename U , typename T , std::size_t DIM>
constexpr BasicVector< T, DIM >	operator+ (BasicVector< T, DIM > lhs, U rhs)
	Computes the vector resulting from adding a scalar to a vector. More...
template<typename U , typename T , std::size_t DIM>
constexpr BasicVector< T, DIM >	operator+ (U lhs, BasicVector< T, DIM > rhs)
	Computes the vector resulting from adding a scalar to a vector. More...
template<typename T , typename U , std::size_t DIM>
constexpr BasicVector< std::common_type_t< T, U >, DIM >	operator- (const BasicVector< T, DIM > &lhs, const BasicVector< U, DIM > &rhs)
	Computes the vector resulting from the subtraction of two vectors. More...
template<typename U , typename T , std::size_t DIM>
constexpr BasicVector< T, DIM >	operator- (BasicVector< T, DIM > lhs, U rhs)
	Computes the vector resulting from subtracting a scalar from a vector. More...
template<typename U , typename T , std::size_t DIM>
constexpr BasicVector< T, DIM >	operator- (U lhs, const BasicVector< T, DIM > &rhs)
	Computes the vector resulting from subtracting a vector from a scalar. More...
template<typename T , typename U , std::size_t DIM>
constexpr BasicVector< std::common_type_t< T, U >, DIM >	operator/ (const BasicVector< T, DIM > &lhs, const BasicVector< U, DIM > &rhs)
	Computes the vector resulting from dividing all components of the first vector by the matching component of the second vector (elementwise division) More...
template<typename U , typename T , std::size_t DIM>
constexpr BasicVector< T, DIM >	operator/ (BasicVector< T, DIM > lhs, U rhs)
	Computes the vector resulting from dividing all components of the specified vector by a constant. More...
template<typename T , typename U , std::size_t DIM>
constexpr BasicVector< std::common_type_t< T, U >, DIM >	operator/ (U lhs, const BasicVector< T, DIM > &rhs)
	Computes the vector resulting from dividing a constant by every component of a vector (elementwise division) More...
template<typename T , typename U , std::size_t DIM>
constexpr BasicVector< std::common_type_t< T, U >, DIM >	operator* (const BasicVector< T, DIM > &lhs, const BasicVector< U, DIM > &rhs)
	Computes the vector resulting from multiplying all components of the first vector by the matching component of the second vector (elementwise multiplication) More...
template<typename U , typename T , std::size_t DIM>
constexpr BasicVector< T, DIM >	operator* (BasicVector< T, DIM > lhs, U rhs)
	Computes the vector resulting from (right) multiplying all components of the specified vector by a constant. More...
template<typename U , typename T , std::size_t DIM>
constexpr BasicVector< T, DIM >	operator* (U lhs, BasicVector< T, DIM > rhs)
	Computes the vector resulting from (left) multiplying all components of the specified vector by a constant. More...
template<typename T , std::size_t DIM>
std::istream &	operator>> (std::istream &is, BasicVector< T, DIM > &vec)
	Reads a vector from an input stream. More...
template<typename T , std::size_t DIM>
std::ostream &	operator<< (std::ostream &os, const BasicVector< T, DIM > &vec)
	Writes a vector to an output stream. More...
template<typename T , typename U , std::size_t DIM>
constexpr bool	operator== (const BasicVector< T, DIM > &lhs, const BasicVector< U, DIM > &rhs)
	Compares two vectors for equality - all components are equal. More...
template<typename T , typename U , std::size_t DIM>
constexpr bool	operator!= (const BasicVector< T, DIM > &lhs, const BasicVector< U, DIM > &rhs)
	Compares two vectors for inequality - any components are different. More...
template<typename U , typename T >
constexpr bool	operator== (const BasicVector< T, 1 > &lhs, U rhs)
	Compares 1D vector with a scalar. More...
template<typename U , typename T >
constexpr bool	operator== (U lhs, const BasicVector< T, 1 > &rhs)
	Compares 1D vector with a scalar. More...
template<typename U , typename T >
constexpr bool	operator!= (const BasicVector< T, 1 > &lhs, U rhs)
	Compares 1D vector with a scalar for inequality. More...
template<typename U , typename T >
constexpr bool	operator!= (U lhs, const BasicVector< T, 1 > &rhs)
	Compares 1D vector with a scalar for inequality. More...
template<typename T , std::size_t DIM>
constexpr BasicVector< T, DIM >::ConjugateType	Conjugate (const BasicVector< T, DIM > &vec)
	Computes the complex conjugate of a vector. More...
template<typename T , std::size_t DIM, typename = std::enable_if_t<is_complex_v<T>>>
constexpr BasicVector< T, DIM >::ConjugateType	Conjugate (BasicVector< T, DIM > &&vec)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

Detailed Description

template<typename T, std::size_t DIM>
struct ptems::BasicVector< T, DIM >

Vector representing a point in DIM-dimensional space.

Template Parameters

T	The type of the vector component
DIM	The dimension of the space

Member Typedef Documentation

ConjugateType

template<typename T , std::size_t DIM>

using ptems::BasicVector< T, DIM >::ConjugateType = BasicVector<typename std::conditional_t<is_complex_v<T>, T, std::complex<T> >,DIM>

The type of the conjugate of the vector.

Will either be the same type if T is complex, otherwise a vector of std::complex<T>.

Constructor & Destructor Documentation

BasicVector() [1/4]

template<typename T , std::size_t DIM>

constexpr ptems::BasicVector< T, DIM >::BasicVector ( )

inlineconstexpr

Construct a zero vector.

BasicVector() [2/4]

template<typename T , std::size_t DIM>

constexpr ptems::BasicVector< T, DIM >::BasicVector ( T  value )

inlineexplicitconstexpr

Construct a vector with all components equal to the specified value.

Parameters

value

Value to fill in each component of the vector

BasicVector() [3/4]

template<typename T , std::size_t DIM>

template<typename... F, typename = std::enable_if_t<sizeof...(F) == DIM>>

constexpr ptems::BasicVector< T, DIM >::BasicVector ( F...  pt )

inlineconstexpr

Construct a vector for the specified point.

Template Parameters

F	Any type explicitly convertible to T

Parameters

pt	The components of the vector, must be exactly DIM components

BasicVector() [4/4]

template<typename T , std::size_t DIM>

template<typename U >

constexpr ptems::BasicVector< T, DIM >::BasicVector ( const BasicVector< U, DIM >  rhs )

inlineconstexpr

Construct a vector by copying the specified vector.

Template Parameters

U	Type of the vector to copy

Parameters

rhs	Vector to copy

Member Function Documentation

Conjugate()

template<typename T , std::size_t DIM>

ConjugateType ptems::BasicVector< T, DIM >::Conjugate ( ) const

inline

Computes the complex conjugate of the vector.

Returns

The complex conjugate of the vector

ConjugateOverwrite()

template<typename T , std::size_t DIM>

BasicVector& ptems::BasicVector< T, DIM >::ConjugateOverwrite ( ) const

inline

Overwrites the vector with its complex conjugate.

Returns

this

Dot()

template<typename T , std::size_t DIM>

template<typename U >

constexpr std::common_type_t<T,U> ptems::BasicVector< T, DIM >::Dot ( const BasicVector< U, DIM > &  rhs ) const

inlineconstexpr

Computes the dot product of this vector with the specified vector.

Template Parameters

U	Type of the components of the vector to dot product with

Parameters

rhs	Vector to dot product with this vector

Returns

The result of the dot product

Length()

template<typename T , std::size_t DIM>

constexpr remove_complex_t<T> ptems::BasicVector< T, DIM >::Length ( ) const

inlineconstexpr

Computes the length of the vector.

Returns

The vector length.

LengthSquared()

template<typename T , std::size_t DIM>

constexpr remove_complex_t<T> ptems::BasicVector< T, DIM >::LengthSquared ( ) const

inlineconstexpr

Gets the square of the length of the vector.

Returns

The length squared.

Normalise()

template<typename T , std::size_t DIM>

constexpr BasicVector& ptems::BasicVector< T, DIM >::Normalise ( )

inlineconstexpr

Normalises the current vector.

Returns

Reference to this vector after normalisation.

Normalised()

template<typename T , std::size_t DIM>

constexpr BasicVector ptems::BasicVector< T, DIM >::Normalised ( ) const

inlineconstexpr

Gets a new vector which is the normalised version of this vector.

Returns

The normalised vector

operator*=() [1/2]

template<typename T , std::size_t DIM>

template<typename U >

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator*= ( const BasicVector< U, DIM > &  rhs )

inlineconstexpr

Performs elementwise multiplication of all components of this vector by the other vector.

Template Parameters

U	Type of the components of the vector to multiply by

Parameters

rhs	Vector to multiply by elementwise

Returns

Reference to this vector after multiplying by rhs

operator*=() [2/2]

template<typename T , std::size_t DIM>

template<typename U >

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator*= ( U  rhs )

inlineconstexpr

Multiplies all components of this vector by a constant.

Template Parameters

U	Type of right hand side

Parameters

rhs	Constant to multiple vector by

Returns

Reference to this vector after multiplying by rhs

operator+=() [1/2]

template<typename T , std::size_t DIM>

template<typename U >

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator+= ( const BasicVector< U, DIM > &  rhs )

inlineconstexpr

Adds another vector to this vector.

Template Parameters

U	Type of the components of the vector to add

Parameters

rhs	Vector to add

Returns

Reference to this vector after adding rhs

operator+=() [2/2]

template<typename T , std::size_t DIM>

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator+= ( T  rhs )

inlineconstexpr

Adds a constant to every component to this vector.

Parameters

rhs	Constant to add

Returns

Reference to this vector after adding rhs

operator-()

template<typename T , std::size_t DIM>

constexpr BasicVector ptems::BasicVector< T, DIM >::operator- ( ) const

inlineconstexpr

Returns the negated vector.

Parameters

rhs	Vector to negate

Returns

The negated vector

operator-=() [1/2]

template<typename T , std::size_t DIM>

template<typename U >

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator-= ( const BasicVector< U, DIM > &  rhs )

inlineconstexpr

Subtracts another vector to this vector.

Template Parameters

U	Type of the components of the vector to subtract

Parameters

rhs	Vector to subtract

Returns

Reference to this vector after subtracting rhs

operator-=() [2/2]

template<typename T , std::size_t DIM>

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator-= ( T  rhs )

inlineconstexpr

Subtracts constant from every component to this vector.

Parameters

rhs	Constant to subtract

Returns

Reference to this vector after subtracting rhs

operator/=() [1/2]

template<typename T , std::size_t DIM>

template<typename U >

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator/= ( const BasicVector< U, DIM > &  rhs )

inlineconstexpr

Performs elementwise division of all components of this vector by the other vector.

Template Parameters

U	Type of the components of the vector to divide by

Parameters

rhs	Vector to divide by elementwise

Returns

Reference to this vector after dividing by rhs

operator/=() [2/2]

template<typename T , std::size_t DIM>

template<typename U >

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator/= ( U  rhs )

inlineconstexpr

Divides all components of this vector by a constant.

Template Parameters

U	Type of right hand side

Parameters

rhs	Constant to divide vector by

Returns

Reference to this vector after dividing by rhs

operator=() [1/2]

template<typename T , std::size_t DIM>

template<typename U >

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator= ( const BasicVector< U, DIM >  rhs )

inlineconstexpr

Copy the specified vector to this.

Template Parameters

U	Type of the vector to copy

Parameters

rhs	Vector to copy

operator=() [2/2]

template<typename T , std::size_t DIM>

constexpr BasicVector& ptems::BasicVector< T, DIM >::operator= ( T  rhs )

inlineconstexpr

Set all components tof vector equal to a constants.

Parameters

rhs	Scalar to set vector to

operator[]() [1/2]

template<typename T , std::size_t DIM>

constexpr T& ptems::BasicVector< T, DIM >::operator[] ( std::size_t  i )

inlineconstexpr

Gets a mutable reference to the component of the vector by index.

Parameters

i	The index of the component of the vector to get (must be less than DIM).

Exceptions

std::out_of_range

If i is not less than DIM.

Returns

Mutable reference to the value at the specified component

operator[]() [2/2]

template<typename T , std::size_t DIM>

constexpr T ptems::BasicVector< T, DIM >::operator[] ( std::size_t  i ) const

inlineconstexpr

Gets a component of the vector by index.

Parameters

i	The index of the component of the vector to get (must be less than DIM).

Exceptions

std::out_of_range

If i is not less than DIM.

Returns

Value at the specified component

size()

template<typename T , std::size_t DIM>

std::size_t ptems::BasicVector< T, DIM >::size ( ) const

inline

Gets the number of elements in the vector.

Returns

DIM

Friends And Related Function Documentation

Conjugate() [1/2]

template<typename T , std::size_t DIM, typename = std::enable_if_t<is_complex_v<T>>>

constexpr BasicVector< T, DIM >::ConjugateType Conjugate ( BasicVector< T, DIM > &&  vec )

related

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Conjugate() [2/2]

template<typename T , std::size_t DIM>

constexpr BasicVector< T, DIM >::ConjugateType Conjugate ( const BasicVector< T, DIM > &  vec )

related

Computes the complex conjugate of a vector.

Template Parameters

T	Type of the components of the vector

Parameters

vec	The vector to conjugate

Returns

The conjugated vector

operator!=() [1/3]

template<typename U , typename T >

constexpr bool operator!= ( const BasicVector< T, 1 > &  lhs, U  rhs  )

related

Compares 1D vector with a scalar for inequality.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the scalar

Parameters

lhs	The left hand side vector to compare
rhs	The right hand side scalar to compare

Returns

false if the only vector component is equal to the scalar value, true otherwise

operator!=() [2/3]

template<typename T , typename U , std::size_t DIM>

constexpr bool operator!= ( const BasicVector< T, DIM > &  lhs, const BasicVector< U, DIM > &  rhs  )

related

Compares two vectors for inequality - any components are different.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the components of the right hand vector
DIM	The dimension of the vectors to compare.

Parameters

lhs	The left hand side vector to compare
rhs	The right hand side vector to compare

Returns

false if all components are equal, true otherwise

operator!=() [3/3]

template<typename U , typename T >

constexpr bool operator!= ( U  lhs, const BasicVector< T, 1 > &  rhs  )

related

Compares 1D vector with a scalar for inequality.

Template Parameters

T	Type of the components of the right hand vector
U	Type of the scalar

Parameters

lhs	The left hand side scalar to compare
rhs	The right hand side vector to compare

Returns

false if the only vector component is equal to the scalar value, true otherwise

operator*() [1/3]

template<typename U , typename T , std::size_t DIM>

constexpr BasicVector< T, DIM > operator* ( BasicVector< T, DIM >  lhs, U  rhs  )

related

Computes the vector resulting from (right) multiplying all components of the specified vector by a constant.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the scalar
DIM	The dimension of the vector

Parameters

lhs	The vector to multiply all components by a scalar
rhs	The scalar to multiply the vector by

Returns

The vector resulting from multiplying lhs by rhs

operator*() [2/3]

template<typename T , typename U , std::size_t DIM>

constexpr BasicVector< std::common_type_t< T, U >, DIM > operator* ( const BasicVector< T, DIM > &  lhs, const BasicVector< U, DIM > &  rhs  )

related

Computes the vector resulting from multiplying all components of the first vector by the matching component of the second vector (elementwise multiplication)

Template Parameters

T	Type of the components of the left hand vector
U	Type of the components of the right hand vector
DIM	The dimension of the vector

Parameters

lhs	The vector to multiply all components
rhs	The vector to multiply by

Returns

The vector resulting from multiplying lhs by rhs

operator*() [3/3]

template<typename U , typename T , std::size_t DIM>

constexpr BasicVector< T, DIM > operator* ( U  lhs, BasicVector< T, DIM >  rhs  )

related

Computes the vector resulting from (left) multiplying all components of the specified vector by a constant.

Template Parameters

T	Type of the components of the right hand vector
U	Type of the scalar
DIM	The dimension of the vector

Parameters

lhs	The scalar to multiply the vector by
rhs	The vector to multiply all components by a scalar

Returns

The vector resulting from multiplying rhs by lhs

operator+() [1/3]

template<typename U , typename T , std::size_t DIM>

constexpr BasicVector< T, DIM > operator+ ( BasicVector< T, DIM >  lhs, U  rhs  )

related

Computes the vector resulting from adding a scalar to a vector.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the scalar
DIM	The dimension of the vectors

Parameters

lhs	The left hand side vector of the addition
rhs	The right hand side scalar of the addition

Returns

The vector resulting from adding lhs and rhs

operator+() [2/3]

template<typename T , typename U , std::size_t DIM>

constexpr BasicVector< std::common_type_t< T, U >, DIM > operator+ ( const BasicVector< T, DIM > &  lhs, const BasicVector< U, DIM > &  rhs  )

related

Computes the vector resulting from the addition of two vectors.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the components of the right hand vector
DIM	The dimension of the vectors

Parameters

lhs	The left hand side vector of the addition
rhs	The right hand side of the addition

Returns

The vector resulting from adding lhs and rhs

operator+() [3/3]

template<typename U , typename T , std::size_t DIM>

constexpr BasicVector< T, DIM > operator+ ( U  lhs, BasicVector< T, DIM >  rhs  )

related

Computes the vector resulting from adding a scalar to a vector.

Template Parameters

U	Type of the scalar
T	Type of the components of the right hand vector
DIM	The dimension of the vectors

Parameters

lhs	The left hand side scalar of the addition
rhs	The right hand side vector of the addition

Returns

The vector resulting from adding lhs and rhs

operator-() [1/3]

template<typename U , typename T , std::size_t DIM>

constexpr BasicVector< T, DIM > operator- ( BasicVector< T, DIM >  lhs, U  rhs  )

related

Computes the vector resulting from subtracting a scalar from a vector.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the scalar
DIM	The dimension of the vectors

Parameters

lhs	The vector to subtract from
rhs	The scalar to subtract

Returns

The vector resulting from subtracting rhs from lhs

operator-() [2/3]

template<typename T , typename U , std::size_t DIM>

constexpr BasicVector< std::common_type_t< T, U >, DIM > operator- ( const BasicVector< T, DIM > &  lhs, const BasicVector< U, DIM > &  rhs  )

related

Computes the vector resulting from the subtraction of two vectors.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the components of the right hand vector
DIM	The dimension of the vectors

Parameters

lhs	The vector to subtract from
rhs	The vector to subtract

Returns

The vector resulting from subtracting rhs from lhs

operator-() [3/3]

template<typename U , typename T , std::size_t DIM>

constexpr BasicVector< T, DIM > operator- ( U  lhs, const BasicVector< T, DIM > &  rhs  )

related

Computes the vector resulting from subtracting a vector from a scalar.

Template Parameters

T	Type of the components of the right hand vector
U	Type of the scalar
DIM	The dimension of the vectors

Parameters

lhs	The scalar to subtract from
rhs	The vector to subtract

Returns

The vector resulting from subtracting rhs from lhs

operator/() [1/3]

template<typename U , typename T , std::size_t DIM>

constexpr BasicVector< T, DIM > operator/ ( BasicVector< T, DIM >  lhs, U  rhs  )

related

Computes the vector resulting from dividing all components of the specified vector by a constant.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the scalar
DIM	The dimension of the vector

Parameters

lhs	The vector to divide all components by a scalar
rhs	The scalar to divide the vector by

Returns

The vector resulting from dividing lhs by rhs

operator/() [2/3]

template<typename T , typename U , std::size_t DIM>

constexpr BasicVector< std::common_type_t< T, U >, DIM > operator/ ( const BasicVector< T, DIM > &  lhs, const BasicVector< U, DIM > &  rhs  )

related

Computes the vector resulting from dividing all components of the first vector by the matching component of the second vector (elementwise division)

Template Parameters

T	Type of the components of the left hand vector
U	Type of the components of the right hand vector
DIM	The dimension of the vector

Parameters

lhs	The vector to divide all components of
rhs	The vector to divide by

Returns

The vector resulting from dividing lhs by rhs

operator/() [3/3]

template<typename T , typename U , std::size_t DIM>

constexpr BasicVector< std::common_type_t< T, U >, DIM > operator/ ( U  lhs, const BasicVector< T, DIM > &  rhs  )

related

Computes the vector resulting from dividing a constant by every component of a vector (elementwise division)

Template Parameters

T	Type of the components of the right hand vector
U	Type of the scalar
DIM	The dimension of the vector

Parameters

lhs	The scalar to divide by all components of a vector
rhs	The vector to divide the constant by component-wise

Returns

The vector resulting from dividing lhs by rhs

operator<<()

template<typename T , std::size_t DIM>

std::ostream & operator<< ( std::ostream &  os, const BasicVector< T, DIM > &  vec  )

related

Writes a vector to an output stream.

A vector will be written as a comma-separated list of DIM floating point values.

Template Parameters

T	Type of the components of the vector
DIM	The dimension of the vector to write.

Parameters

os	The stream to write the vector to
vec	The vector to write

Returns

os

operator==() [1/3]

template<typename U , typename T >

constexpr bool operator== ( const BasicVector< T, 1 > &  lhs, U  rhs  )

related

Compares 1D vector with a scalar.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the scalar

Parameters

lhs	The left hand side vector to compare
rhs	The right hand side scalar to compare

Returns

true if the only vector component is equal to the scalar value, false otherwise

operator==() [2/3]

template<typename T , typename U , std::size_t DIM>

constexpr bool operator== ( const BasicVector< T, DIM > &  lhs, const BasicVector< U, DIM > &  rhs  )

related

Compares two vectors for equality - all components are equal.

Template Parameters

T	Type of the components of the left hand vector
U	Type of the components of the right hand vector
DIM	The dimension of the vectors to compare.

Parameters

lhs	The left hand side vector to compare
rhs	The right hand side vector to compare

Returns

true if all components are equal, false otherwise

operator==() [3/3]

template<typename U , typename T >

constexpr bool operator== ( U  lhs, const BasicVector< T, 1 > &  rhs  )

related

Compares 1D vector with a scalar.

Template Parameters

T	Type of the components of the right hand vector
U	Type of the scalar

Parameters

lhs	The left hand side scalar to compare
rhs	The right hand side vector to compare

Returns

true if the only vector component is equal to the scalar value, false otherwise

operator>>()

template<typename T , std::size_t DIM>

std::istream & operator>> ( std::istream &  is, BasicVector< T, DIM > &  vec  )

related

Reads a vector from an input stream.

A vector should be a comma-separated list of DIM floating point values.

Template Parameters

T	Type of the components of the vector
DIM	The dimension of the vector to read.

Parameters

is	The stream to read the vector from
vec	The vector to read into

Returns

is

---

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

• ptems/vector.hpp