A cartesian 3D vector, 2D homogeneous. More...

#include <NRE_Vector3D.hpp>

Inheritance diagram for NRE::Math::Vector3D< T >:

Public Member Functions
constexpr	Vector3D ()=default

template<class K , class L , class N , typename = UseIfArithmetic<K, L, N>>
constexpr	Vector3D (K nX, L nY, N nZ)

template<class K , typename = UseIfArithmetic<K>>
constexpr	Vector3D (K value)

constexpr	Vector3D (std::initializer_list< T > list)

constexpr	Vector3D (Vector3D const &u)=default

constexpr	Vector3D (Vector3D &&u)=default

template<class K >
constexpr	Vector3D (Vector3D< K > const &u)

template<class K >
constexpr	Vector3D (Vector2D< K > const &u)

template<class K >
constexpr	Vector3D (Vector4D< K > const &u)

template<class K , class L , typename = UseIfArithmetic<L>>
constexpr	Vector3D (Vector2D< K > const &u, L nZ)

	~Vector3D ()=default

constexpr T	getX () const

constexpr T	getY () const

constexpr T	getZ () const

constexpr T	getR () const

constexpr T	getG () const

constexpr T	getB () const

template<class K , typename = UseIfArithmetic<K>>
constexpr void	setX (K nX)

template<class K , typename = UseIfArithmetic<K>>
constexpr void	setY (K nY)

template<class K , typename = UseIfArithmetic<K>>
constexpr void	setZ (K nZ)

template<class K , typename = UseIfArithmetic<K>>
constexpr void	setR (K r)

template<class K , typename = UseIfArithmetic<K>>
constexpr void	setG (K g)

template<class K , typename = UseIfArithmetic<K>>
constexpr void	setB (K b)

template<class K , class L , class N , typename = UseIfArithmetic<K, L, N>>
constexpr void	setCoord (K nX, L nY, N nZ)

template<class K , class L , typename = UseIfArithmetic<L>>
constexpr void	setCoord (Vector2D< K > const &u, L nZ)

template<class K , class L , class N , typename = UseIfArithmetic<K, L, N>>
constexpr void	setRGB (K r, L g, N b)

long double	norm () const

constexpr T	normSquared () const

template<class K >
long double	distance (Vector3D< K > const &v) const

template<class K >
constexpr std::common_type_t< T, K >	distanceSquared (Vector3D< K > const &v) const

Vector3D &	normalize ()

template<class K , typename = UseIfArithmetic<K>>
void	limit (K max)

template<class K , typename = UseIfArithmetic<K>>
Vector3D &	pow (K p)

template<class K >
Vector3D &	pow (Vector3D< K > const &p)

constexpr const T *	value () const

constexpr T &	operator[] (std::size_t index)

constexpr T const &	operator[] (std::size_t index) const

constexpr Vector3D &	operator= (Vector3D const &u)=default

constexpr Vector3D &	operator= (Vector3D &&u)=default

template<class K >
constexpr Vector3D &	operator= (Vector3D< K > const &u)

template<class K >
constexpr Vector3D &	operator= (Vector3D< K > &&u)

template<class K , typename = UseIfArithmetic<K>>
constexpr Vector3D &	operator+= (K k)

template<class K >
constexpr Vector3D &	operator+= (Vector3D< K > const &u)

template<class K , typename = UseIfArithmetic<K>>
constexpr Vector3D &	operator-= (K k)

template<class K >
constexpr Vector3D &	operator-= (Vector3D< K > const &u)

template<class K , typename = UseIfArithmetic<K>>
constexpr Vector3D &	operator*= (K k)

template<class K >
constexpr Vector3D &	operator*= (Vector3D< K > const &u)

template<class K , typename = UseIfArithmetic<K>>
constexpr Vector3D &	operator/= (K k)

template<class K >
constexpr Vector3D &	operator/= (Vector3D< K > const &u)

template<class K >
constexpr std::common_type_t< T, K >	operator\|= (Vector3D< K > const &u) const

template<class K >
constexpr Vector3D &	operator^= (Vector3D< K > const &u)

template<class K , typename = UseIfArithmetic<K>>
constexpr Vector3D< std::common_type_t< T, K > >	operator+ (K k) const

template<class K >
constexpr Vector3D< std::common_type_t< T, K > >	operator+ (Vector3D< K > const &u) const

template<class K , typename = UseIfArithmetic<K>>
constexpr Vector3D< std::common_type_t< T, K > >	operator- (K k) const

template<class K >
constexpr Vector3D< std::common_type_t< T, K > >	operator- (Vector3D< K > const &u) const

constexpr Vector3D	operator- () const

template<class K , typename = UseIfArithmetic<K>>
constexpr Vector3D< std::common_type_t< T, K > >	operator* (K k) const

template<class K >
constexpr Vector3D< std::common_type_t< T, K > >	operator* (Vector3D< K > const &u) const

template<class K , typename = UseIfArithmetic<K>>
constexpr Vector3D< std::common_type_t< T, K > >	operator/ (K k) const

template<class K >
constexpr Vector3D< std::common_type_t< T, K > >	operator/ (Vector3D< K > const &u) const

template<class K >
constexpr std::common_type_t< T, K >	operator\| (Vector3D< K > const &u) const

template<class K >
constexpr Vector3D< std::common_type_t< T, K > >	operator^ (Vector3D< K > const &u) const

template<class K >
constexpr bool	operator== (Vector3D< K > const &u) const

template<class K >
constexpr bool	operator!= (Vector3D< K > const &u) const

template<class K >
constexpr bool	operator< (Vector3D< K > const &u) const

template<class K >
constexpr bool	operator> (Vector3D< K > const &u) const

template<class K >
constexpr bool	operator<= (Vector3D< K > const &u) const

template<class K >
constexpr bool	operator>= (Vector3D< K > const &u) const

Utility::String	toString () const

Detailed Description

template<class T>
class NRE::Math::Vector3D< T >

A cartesian 3D vector, 2D homogeneous.

Constructor & Destructor Documentation

template<class T>

constexpr NRE::Math::Vector3D< T >::Vector3D ( )

default

Construct the null vector

template<class T>

template<class K , class L , class N , typename = UseIfArithmetic<K, L, N>>

constexpr NRE::Math::Vector3D< T >::Vector3D	(	K	nX,
		L	nY,
		N	nZ
	)

inline

Construct a vector with passed values

Parameters

nX	new x value
nY	new y value
nZ	new z value

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr NRE::Math::Vector3D< T >::Vector3D ( K value )

inline

Construct a vector with an unique value for all coordinates

Parameters

value new x, y and z values

template<class T>

constexpr NRE::Math::Vector3D< T >::Vector3D ( std::initializer_list< T > list )

Construct a vector from an initializer list

Parameters

list	the construction list

template<class T>

constexpr NRE::Math::Vector3D< T >::Vector3D ( Vector3D< T > const & u )

default

Copy u into this

Parameters

u	the object to copy

template<class T>

constexpr NRE::Math::Vector3D< T >::Vector3D ( Vector3D< T > && u )

default

Move u into this

Parameters

u	the object to move

template<class T>

template<class K >

constexpr NRE::Math::Vector3D< T >::Vector3D ( Vector3D< K > const & u )

Convert a K-type vector into a T-type vector

Parameters

u	the K-type vector to convert

template<class T>

template<class K >

constexpr NRE::Math::Vector3D< T >::Vector3D ( Vector2D< K > const & u )

Convert a 2D vector into a 3D vector with a default z value

Parameters

u	the 2D vector to convert

template<class T>

template<class K >

constexpr NRE::Math::Vector3D< T >::Vector3D ( Vector4D< K > const & u )

Convert a K-type 4D vector into a T-type 3D vector

Parameters

u	the K-type 4D vector to convert

template<class T>

template<class K , class L , typename = UseIfArithmetic<L>>

constexpr NRE::Math::Vector3D< T >::Vector3D	(	Vector2D< K > const &	u,
		L	nZ
	)

inline

Convert a 2D vector into a 3D point with a passed z value

Parameters

u	the 2D vector to convert
nZ	the new z value

template<class T>

NRE::Math::Vector3D< T >::~Vector3D ( )

default

Vector3D Deconstructor

Member Function Documentation

template<class T>

template<class K >

long double NRE::Math::Vector3D< T >::distance ( Vector3D< K > const & v ) const

Returns: the distance to another vector

template<class T>

template<class K >

constexpr std::common_type_t<T, K> NRE::Math::Vector3D< T >::distanceSquared ( Vector3D< K > const & v ) const

Returns: the squared distance to another vector

template<class T>

constexpr T NRE::Math::Vector3D< T >::getB ( ) const

Returns: the z value

template<class T>

constexpr T NRE::Math::Vector3D< T >::getG ( ) const

Returns: the y value

template<class T>

constexpr T NRE::Math::Vector3D< T >::getR ( ) const

Returns: the x value

template<class T>

constexpr T NRE::Math::Vector3D< T >::getX ( ) const

Returns: the x value

template<class T>

constexpr T NRE::Math::Vector3D< T >::getY ( ) const

Returns: the y value

template<class T>

constexpr T NRE::Math::Vector3D< T >::getZ ( ) const

Returns: the z value

template<class T>

template<class K , typename = UseIfArithmetic<K>>

void NRE::Math::Vector3D< T >::limit ( K max )

inline

Limit the vector value to the given max, if to high then normalize it

Parameters

max	the maximum value

template<class T>

long double NRE::Math::Vector3D< T >::norm ( ) const

Returns: the vector's norm

template<class T>

Vector3D& NRE::Math::Vector3D< T >::normalize ( )

Normalize the vector

Returns: the reference of himself

template<class T>

constexpr T NRE::Math::Vector3D< T >::normSquared ( ) const

Returns: the squared vector's norm

template<class T>

template<class K >

constexpr bool NRE::Math::Vector3D< T >::operator!= ( Vector3D< K > const & u ) const

Difference test between this and u

Parameters

u	the vector to test with this

Returns: the test's result

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator* ( K k ) const

inline

Compute the vector resulting in the multiplication of this by k

Parameters

k	the multiplication factor

Returns: the computed vector

template<class T>

template<class K >

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator* ( Vector3D< K > const & u ) const

Compute the vector resulting in the multiplication of this by u

Parameters

u	the multiplication vector

Returns: the computed vector

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr Vector3D& NRE::Math::Vector3D< T >::operator*= ( K k )

inline

Multiply this by a factor k

Parameters

k	the multiplication factor

Returns: the reference of himself

template<class T>

template<class K >

constexpr Vector3D& NRE::Math::Vector3D< T >::operator*= ( Vector3D< K > const & u )

Multiply this by a vector u, component by component

Parameters

u	the multiplication vector

Returns: the reference of himself

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator+ ( K k ) const

inline

Compute the vector resulting in the addition of k into this

Parameters

k	the scalar to add

Returns: the computed vector

template<class T>

template<class K >

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator+ ( Vector3D< K > const & u ) const

Compute the vector resulting in the addition of u into this

Parameters

u	the vector to add

Returns: the computed vector

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr Vector3D& NRE::Math::Vector3D< T >::operator+= ( K k )

inline

Add a scalar to all components

Parameters

k	the scalar to add

Returns: the reference of himself

template<class T>

template<class K >

constexpr Vector3D& NRE::Math::Vector3D< T >::operator+= ( Vector3D< K > const & u )

Add a vector into this

Parameters

u	the vector to add into this

Returns: the reference of himself

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator- ( K k ) const

inline

Compute the vector resulting in the subtraction of k into this

Parameters

k	the scalar to add

Returns: the computed vector

template<class T>

template<class K >

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator- ( Vector3D< K > const & u ) const

Compute the vector resulting in the subtraction of u into this

Parameters

u	the vector to subtract

Returns: the computed vector

template<class T>

constexpr Vector3D NRE::Math::Vector3D< T >::operator- ( ) const

Compute the opposite version of this

Returns: the opposite vector

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr Vector3D& NRE::Math::Vector3D< T >::operator-= ( K k )

inline

Subtract a scalar to all components

Parameters

k	the scalar to add

Returns: the reference of himself

template<class T>

template<class K >

constexpr Vector3D& NRE::Math::Vector3D< T >::operator-= ( Vector3D< K > const & u )

Subtract a vector into this

Parameters

u	the vector to subtract into this

Returns: the reference of himself

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator/ ( K k ) const

inline

Compute the vector resulting in the division of this by k

Parameters

k	the division factor

Returns: the computed vector

template<class T>

template<class K >

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator/ ( Vector3D< K > const & u ) const

Compute the vector resulting in the division of this by u

Parameters

u	the division vector

Returns: the computed vector

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr Vector3D& NRE::Math::Vector3D< T >::operator/= ( K k )

inline

Divide this by a factor k

Parameters

k	the division factor

Returns: the reference of himself

template<class T>

template<class K >

constexpr Vector3D& NRE::Math::Vector3D< T >::operator/= ( Vector3D< K > const & u )

Divide this by a vector u, component by component

Parameters

u	the division vector

Returns: the reference of himself

template<class T>

template<class K >

constexpr bool NRE::Math::Vector3D< T >::operator< ( Vector3D< K > const & u ) const

Inferior test between this and u

Parameters

u	the vector to test with this

Returns: the test's result

template<class T>

template<class K >

constexpr bool NRE::Math::Vector3D< T >::operator<= ( Vector3D< K > const & u ) const

Inferior or Equal test between this and u

Parameters

u	the vector to test with this

Returns: the test's result

template<class T>

constexpr Vector3D& NRE::Math::Vector3D< T >::operator= ( Vector3D< T > const & u )

default

Copy u into this

Parameters

u	the object to copy into this

Returns: the reference of himself

template<class T>

constexpr Vector3D& NRE::Math::Vector3D< T >::operator= ( Vector3D< T > && u )

default

Move u into this

Parameters

u	the object to move into this

Returns: the reference of himself

template<class T>

template<class K >

constexpr Vector3D& NRE::Math::Vector3D< T >::operator= ( Vector3D< K > const & u )

Copy u into this

Parameters

u	the object to copy into this

Returns: the reference of himself

template<class T>

template<class K >

constexpr Vector3D& NRE::Math::Vector3D< T >::operator= ( Vector3D< K > && u )

Move u into this

Parameters

u	the object to move into this

Returns: the reference of himself

template<class T>

template<class K >

constexpr bool NRE::Math::Vector3D< T >::operator== ( Vector3D< K > const & u ) const

Equality test between this and u

Parameters

u	the vector to test with this

Returns: the test's result

template<class T>

template<class K >

constexpr bool NRE::Math::Vector3D< T >::operator> ( Vector3D< K > const & u ) const

Superior test between this and u

Parameters

u	the vector to test with this

Returns: the test's result

template<class T>

template<class K >

constexpr bool NRE::Math::Vector3D< T >::operator>= ( Vector3D< K > const & u ) const

Superior or Equal test between this and u

Parameters

u	the vector to test with this

Returns: the test's result

template<class T>

constexpr T& NRE::Math::Vector3D< T >::operator[] ( std::size_t index )

Return a reference on a vector's object

Warning: No range check performed

Parameters

index the object's index

Returns: the object's reference

template<class T>

constexpr T const& NRE::Math::Vector3D< T >::operator[] ( std::size_t index ) const

Return a const reference on a vector's object

Warning: No range check performed

Parameters

index the object's index

Returns: the object's reference

template<class T>

template<class K >

constexpr Vector3D<std::common_type_t<T, K> > NRE::Math::Vector3D< T >::operator^ ( Vector3D< K > const & u ) const

Compute the vector resulting in the cross product of this and u

Parameters

u	the vector

Returns: the computed vector

template<class T>

template<class K >

constexpr Vector3D& NRE::Math::Vector3D< T >::operator^= ( Vector3D< K > const & u )

Replace this by the cross product between this and u

Parameters

u	the vector

Returns: the reference of himself

template<class T>

template<class K >

constexpr std::common_type_t<T, K> NRE::Math::Vector3D< T >::operator| ( Vector3D< K > const & u ) const

Compute the scalar product between this and u

Parameters

u	the vector

Returns: the scalar product

template<class T>

template<class K >

constexpr std::common_type_t<T, K> NRE::Math::Vector3D< T >::operator|= ( Vector3D< K > const & u ) const

Compute the scalar product between this and u

Parameters

u	the vector

Returns: the scalar product

template<class T>

template<class K , typename = UseIfArithmetic<K>>

Vector3D& NRE::Math::Vector3D< T >::pow ( K p )

inline

Raise all components to the given power

Parameters

p	the power to which to raise this

Returns: the reference of himself

template<class T>

template<class K >

Vector3D& NRE::Math::Vector3D< T >::pow ( Vector3D< K > const & p )

Raise all components to the given power vector

Parameters

p	the set of power to which to raise this

Returns: the reference of himself

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr void NRE::Math::Vector3D< T >::setB ( K b )

inline

Z setter

Parameters

b	the new value for z

template<class T>

template<class K , class L , class N , typename = UseIfArithmetic<K, L, N>>

constexpr void NRE::Math::Vector3D< T >::setCoord	(	K	nX,
		L	nY,
		N	nZ
	)

inline

Set the values for x, y and z

Parameters

nX	the new value for x
nY	the new value for y
nZ	the new value for z

template<class T>

template<class K , class L , typename = UseIfArithmetic<L>>

constexpr void NRE::Math::Vector3D< T >::setCoord	(	Vector2D< K > const &	u,
		L	nZ
	)

inline

Set the values for x, y and z with a base 2D vector

Parameters

u	the base 2D vector for x and y values
nZ	the new value for z

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr void NRE::Math::Vector3D< T >::setG ( K g )

inline

Y setter

Parameters

g	the new value for y

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr void NRE::Math::Vector3D< T >::setR ( K r )

inline

X setter

Parameters

r	the new value for x

template<class T>

template<class K , class L , class N , typename = UseIfArithmetic<K, L, N>>

constexpr void NRE::Math::Vector3D< T >::setRGB	(	K	r,
		L	g,
		N	b
	)

inline

Set the values for x, y and z

Parameters

r	the new value for x
g	the new value for y
b	the new value for z

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr void NRE::Math::Vector3D< T >::setX ( K nX )

inline

X setter

Parameters

nX	the new value for x

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr void NRE::Math::Vector3D< T >::setY ( K nY )

inline

Y setter

Parameters

nY	the new value for y

template<class T>

template<class K , typename = UseIfArithmetic<K>>

constexpr void NRE::Math::Vector3D< T >::setZ ( K nZ )

inline

Z setter

Parameters

nZ	the new value for z

template<class T>

Utility::String NRE::Math::Vector3D< T >::toString ( ) const

Convert the vector into a string

Returns: the converted vector

template<class T>

constexpr const T* NRE::Math::Vector3D< T >::value ( ) const

Returns: a pointer to the vector's data

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

/mnt/c/Users/abell/Documents/GitHub/NRE-Math/src/Math/Matrix/3D/NRE_Matrix3x3.hpp
/mnt/c/Users/abell/Documents/GitHub/NRE-Math/src/Math/Vector/3D/NRE_Vector3D.hpp

Public Member Functions

Detailed Description

template<class T> class NRE::Math::Vector3D< T >

Constructor & Destructor Documentation

Member Function Documentation

template<class T>
class NRE::Math::Vector3D< T >