#include <Vec.h>

Inheritance diagram for sofa::type::Vec< N, ValueType >:

Public Attributes
ArrayType	elems {}

Static Public Attributes
static constexpr sofa::Size	static_size = N

static constexpr Size	total_size = N
	Compile-time constant specifying the number of scalars within this vector (equivalent to static_size and size() method) More...

static constexpr Size	spatial_dimensions = N
	Compile-time constant specifying the number of dimensions of space (equivalent to total_size here) More...

Public Member Functions
constexpr	Vec ()=default
	Default constructor: sets all values to 0. More...

constexpr	Vec (NoInit)
	Fast constructor: no initialization. More...

template<Size NN = N, typename std::enable_if< NN==1, int >::type = 0>
constexpr	Vec (const ValueType r1) noexcept
	Specific constructor for 1-element vectors. More...

template<typename... ArgsT, typename = std::enable_if_t< (std::is_convertible_v<ArgsT, ValueType> && ...) >, typename = std::enable_if_t< (sizeof...(ArgsT) == N && sizeof...(ArgsT) > 1) >>
constexpr	Vec (ArgsT &&... r) noexcept

template<typename R , typename T , Size NN = N, typename std::enable_if< NN==6, int >::type = 0>
	Vec (const Vec< 3, R > &a, const Vec< 3, T > &b)
	Specific constructor for 6-elements vectors, taking two 3-elements vectors. More...

template<Size NN = N, typename std::enable_if< NN==1, int >::type = 0>
constexpr void	set (const ValueType r1) noexcept
	Specific set function for 1-element vectors. More...

template<typename... ArgsT, typename = std::enable_if_t< (std::is_convertible_v<ArgsT, ValueType> && ...) >, typename = std::enable_if_t< (sizeof...(ArgsT) == N && sizeof...(ArgsT) > 1) >>
constexpr void	set (const ArgsT... r) noexcept

template<Size N2, class real2 >
constexpr void	set (const Vec< N2, real2 > &v, ValueType defaultvalue=0) noexcept
	Specific set from a different size vector (given default value and ignored outside entries) More...

template<Size NN = N, typename std::enable_if<(NN >1), int >::type = 0>
constexpr	Vec (const Vec< N-1, ValueType > &v, ValueType r1) noexcept
	Constructor from an N-1 elements vector and an additional value (added at the end). More...

constexpr	Vec (const sofa::type::fixed_array< ValueType, N > &p) noexcept

template<Size N2, typename real2 >
constexpr	Vec (const Vec< N2, real2 > &v) noexcept
	Constructor from a different size vector (null default value and ignoring outside entries) More...

template<typename real2 >
constexpr	Vec (const Vec< N, real2 > &p) noexcept

template<typename real2 >
constexpr	Vec (const real2 *p) noexcept
	Constructor from an array of values. More...

template<Size NN = N, typename std::enable_if<(NN >=1), int >::type = 0>
constexpr ValueType &	x () noexcept
	Special access to first element. More...

template<Size NN = N, typename std::enable_if<(NN >=2), int >::type = 0>
constexpr ValueType &	y () noexcept
	Special access to second element. More...

template<Size NN = N, typename std::enable_if<(NN >=3), int >::type = 0>
constexpr ValueType &	z () noexcept
	Special access to third element. More...

template<Size NN = N, typename std::enable_if<(NN >=4), int >::type = 0>
constexpr ValueType &	w () noexcept
	Special access to fourth element. More...

template<Size NN = N, typename std::enable_if<(NN >=1), int >::type = 0>
constexpr const ValueType &	x () const noexcept
	Special const access to first element. More...

template<Size NN = N, typename std::enable_if<(NN >=2), int >::type = 0>
constexpr const ValueType &	y () const noexcept
	Special const access to second element. More...

template<Size NN = N, typename std::enable_if<(NN >=3), int >::type = 0>
constexpr const ValueType &	z () const noexcept
	Special const access to third element. More...

template<Size NN = N, typename std::enable_if<(NN >=4), int >::type = 0>
constexpr const ValueType &	w () const noexcept
	Special const access to fourth element. More...

template<Size NN = N, typename std::enable_if< NN==1, int >::type = 0>
constexpr void	operator= (const ValueType r1) noexcept
	Specific Assignment operator for 1-element vectors. More...

template<typename real2 >
constexpr void	operator= (const real2 *p) noexcept
	Assignment operator from an array of values. More...

template<Size M, typename real2 >
constexpr void	operator= (const Vec< M, real2 > &v) noexcept
	Assignment from a vector with different dimensions. More...

constexpr void	assign (const ValueType &value) noexcept

constexpr void	clear () noexcept
	Sets every element to 0. More...

constexpr void	fill (ValueType r) noexcept
	Sets every element to r. More...

constexpr ValueType &	operator() (Size i) noexcept
	Access to i-th element. More...

constexpr const ValueType &	operator() (Size i) const noexcept
	Const access to i-th element. More...

constexpr const ValueType *	ptr () const noexcept
	Cast into a const array of values. More...

constexpr ValueType *	ptr () noexcept
	Cast into an array of values. More...

template<Size N2, std::enable_if_t<(N2< N), bool > = true>
constexpr void	getsub (const Size i, Vec< N2, ValueType > &m) const noexcept

constexpr void	getsub (const Size i, ValueType &m) const noexcept

constexpr Vec< N, ValueType >	mulscalar (const ValueType f) const noexcept

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr Vec< N, ValueType >	mulscalar (const real2 f) const noexcept
	Multiplication by a scalar f. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr Vec< N, ValueType >	operator* (const real2 f) const noexcept

constexpr void	eqmulscalar (const ValueType f) noexcept
	In-place multiplication by a scalar f. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr void	eqmulscalar (const real2 f) noexcept

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr void	operator*= (const real2 f) noexcept

constexpr Vec< N, ValueType >	divscalar (const ValueType f) const noexcept
	Division by a scalar f. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr Vec< N, ValueType >	divscalar (const real2 f) const noexcept

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr Vec< N, ValueType >	operator/ (const real2 f) const noexcept

constexpr void	eqdivscalar (const ValueType f) noexcept
	In-place division by a scalar f. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr void	eqdivscalar (const real2 f) noexcept

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr void	operator/= (const real2 f) noexcept

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr ValueType	operator* (const Vec< N, real2 > &v) const noexcept
	Dot product. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr Vec< N, ValueType >	linearProduct (const Vec< N, real2 > &v) const noexcept
	linear product. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr Vec< N, ValueType >	linearDivision (const Vec< N, real2 > &v) const noexcept
	linear division. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr Vec< N, ValueType >	operator+ (const Vec< N, real2 > &v) const noexcept
	Vector addition. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr void	operator+= (const Vec< N, real2 > &v) noexcept
	In-place vector addition. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr Vec< N, ValueType >	operator- (const Vec< N, real2 > &v) const noexcept
	Vector subtraction. More...

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>
constexpr void	operator-= (const Vec< N, real2 > &v) noexcept
	In-place vector subtraction. More...

template<typename T = ValueType, std::enable_if_t< !std::is_unsigned_v< T >, int > = 0>
constexpr Vec< N, ValueType >	operator- () const noexcept
	Vector negation. More...

constexpr ValueType	norm2 () const noexcept
	Squared norm. More...

ValueType	norm () const noexcept
	Euclidean norm. More...

ValueType	lNorm (int l) const

constexpr bool	normalizeWithNorm (ValueType norm, ValueType threshold=std::numeric_limits< ValueType >::epsilon()) noexcept

bool	normalize (ValueType threshold=std::numeric_limits< ValueType >::epsilon()) noexcept

void	normalize (Vec< N, ValueType > failsafe, ValueType threshold=std::numeric_limits< ValueType >::epsilon()) noexcept

Vec< N, ValueType >	normalized () const noexcept

bool	isNormalized (ValueType threshold=std::numeric_limits< ValueType >::epsilon() *(ValueType) 10) const
	return true if norm()==1 More...

template<typename R , Size NN = N, typename std::enable_if<(NN==3), int >::type = 0>
constexpr Vec	cross (const Vec< 3, R > &b) const noexcept

constexpr ValueType	sum () const noexcept
	sum of all elements of the vector More...

Tests operators
constexpr bool	operator== (const Vec &b) const noexcept

constexpr bool	operator!= (const Vec &b) const noexcept

constexpr reference	operator[] (size_type i)

constexpr const_reference	operator[] (size_type i) const

constexpr const ValueType *	data () const noexcept

constexpr iterator	begin () noexcept

constexpr const_iterator	begin () const noexcept

constexpr iterator	end () noexcept

constexpr const_iterator	end () const noexcept

constexpr reference	front ()

constexpr const_reference	front () const

constexpr reference	back ()

constexpr const_reference	back () const

Static Public Member Functions
static constexpr sofa::Size	size ()

Attribute details

◆ elems

template<sofa::Size N, typename ValueType >

ArrayType sofa::type::Vec< N, ValueType >::elems {}

◆ spatial_dimensions

template<sofa::Size N, typename ValueType >

constexpr Size sofa::type::Vec< N, ValueType >::spatial_dimensions = N

staticconstexpr

Compile-time constant specifying the number of dimensions of space (equivalent to total_size here)

◆ static_size

template<sofa::Size N, typename ValueType >

constexpr sofa::Size sofa::type::Vec< N, ValueType >::static_size = N

staticconstexpr

◆ total_size

template<sofa::Size N, typename ValueType >

constexpr Size sofa::type::Vec< N, ValueType >::total_size = N

staticconstexpr

Compile-time constant specifying the number of scalars within this vector (equivalent to static_size and size() method)

Constructor details

◆ Vec() [1/10]

template<sofa::Size N, typename ValueType >

constexpr sofa::type::Vec< N, ValueType >::Vec ( )

constexprdefault

Default constructor: sets all values to 0.

◆ Vec() [2/10]

template<sofa::Size N, typename ValueType >

constexpr sofa::type::Vec< N, ValueType >::Vec ( NoInit )

inlineexplicitconstexpr

Fast constructor: no initialization.

◆ Vec() [3/10]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if< NN==1, int >::type = 0>

constexpr sofa::type::Vec< N, ValueType >::Vec ( const ValueType r1 )

inlineexplicitconstexprnoexcept

Specific constructor for 1-element vectors.

◆ Vec() [4/10]

template<sofa::Size N, typename ValueType >

template<typename... ArgsT, typename = std::enable_if_t< (std::is_convertible_v<ArgsT, ValueType> && ...) >, typename = std::enable_if_t< (sizeof...(ArgsT) == N && sizeof...(ArgsT) > 1) >>

constexpr sofa::type::Vec< N, ValueType >::Vec ( ArgsT &&... r )

inlineconstexprnoexcept

◆ Vec() [5/10]

template<sofa::Size N, typename ValueType >

template<typename R , typename T , Size NN = N, typename std::enable_if< NN==6, int >::type = 0>

sofa::type::Vec< N, ValueType >::Vec	(	const Vec< 3, R > &	a,
		const Vec< 3, T > &	b
	)

inline

Specific constructor for 6-elements vectors, taking two 3-elements vectors.

◆ Vec() [6/10]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >1), int >::type = 0>

constexpr sofa::type::Vec< N, ValueType >::Vec	(	const Vec< N-1, ValueType > &	v,
		ValueType	r1
	)

inlineconstexprnoexcept

Constructor from an N-1 elements vector and an additional value (added at the end).

◆ Vec() [7/10]

template<sofa::Size N, typename ValueType >

constexpr sofa::type::Vec< N, ValueType >::Vec ( const sofa::type::fixed_array< ValueType, N > & p )

inlineconstexprnoexcept

◆ Vec() [8/10]

template<sofa::Size N, typename ValueType >

template<Size N2, typename real2 >

constexpr sofa::type::Vec< N, ValueType >::Vec ( const Vec< N2, real2 > & v )

inlineexplicitconstexprnoexcept

Constructor from a different size vector (null default value and ignoring outside entries)

◆ Vec() [9/10]

template<sofa::Size N, typename ValueType >

template<typename real2 >

constexpr sofa::type::Vec< N, ValueType >::Vec ( const Vec< N, real2 > & p )

inlineconstexprnoexcept

◆ Vec() [10/10]

template<sofa::Size N, typename ValueType >

template<typename real2 >

constexpr sofa::type::Vec< N, ValueType >::Vec ( const real2 * p )

inlineexplicitconstexprnoexcept

Constructor from an array of values.

Function details

◆ assign()

template<sofa::Size N, typename ValueType >

constexpr void sofa::type::Vec< N, ValueType >::assign ( const ValueType & value )

inlineconstexprnoexcept

◆ back() [1/2]

template<sofa::Size N, typename ValueType >

constexpr reference sofa::type::Vec< N, ValueType >::back ( )

inlineconstexpr

◆ back() [2/2]

template<sofa::Size N, typename ValueType >

constexpr const_reference sofa::type::Vec< N, ValueType >::back ( ) const

inlineconstexpr

◆ begin() [1/2]

template<sofa::Size N, typename ValueType >

constexpr const_iterator sofa::type::Vec< N, ValueType >::begin ( ) const

inlineconstexprnoexcept

◆ begin() [2/2]

template<sofa::Size N, typename ValueType >

constexpr iterator sofa::type::Vec< N, ValueType >::begin ( )

inlineconstexprnoexcept

◆ clear()

template<sofa::Size N, typename ValueType >

constexpr void sofa::type::Vec< N, ValueType >::clear ( )

inlineconstexprnoexcept

Sets every element to 0.

◆ cross()

template<sofa::Size N, typename ValueType >

template<typename R , Size NN = N, typename std::enable_if<(NN==3), int >::type = 0>

constexpr Vec sofa::type::Vec< N, ValueType >::cross ( const Vec< 3, R > & b ) const

inlineconstexprnoexcept

◆ data()

template<sofa::Size N, typename ValueType >

constexpr const ValueType* sofa::type::Vec< N, ValueType >::data ( ) const

inlineconstexprnoexcept

◆ divscalar() [1/2]

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::divscalar ( const real2 f ) const

inlineconstexprnoexcept

◆ divscalar() [2/2]

template<sofa::Size N, typename ValueType >

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::divscalar ( const ValueType f ) const

inlineconstexprnoexcept

Division by a scalar f.

◆ end() [1/2]

template<sofa::Size N, typename ValueType >

constexpr const_iterator sofa::type::Vec< N, ValueType >::end ( ) const

inlineconstexprnoexcept

◆ end() [2/2]

template<sofa::Size N, typename ValueType >

constexpr iterator sofa::type::Vec< N, ValueType >::end ( )

inlineconstexprnoexcept

◆ eqdivscalar() [1/2]

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr void sofa::type::Vec< N, ValueType >::eqdivscalar ( const real2 f )

inlineconstexprnoexcept

◆ eqdivscalar() [2/2]

template<sofa::Size N, typename ValueType >

constexpr void sofa::type::Vec< N, ValueType >::eqdivscalar ( const ValueType f )

inlineconstexprnoexcept

In-place division by a scalar f.

◆ eqmulscalar() [1/2]

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr void sofa::type::Vec< N, ValueType >::eqmulscalar ( const real2 f )

inlineconstexprnoexcept

◆ eqmulscalar() [2/2]

template<sofa::Size N, typename ValueType >

constexpr void sofa::type::Vec< N, ValueType >::eqmulscalar ( const ValueType f )

inlineconstexprnoexcept

In-place multiplication by a scalar f.

◆ fill()

template<sofa::Size N, typename ValueType >

constexpr void sofa::type::Vec< N, ValueType >::fill ( ValueType r )

inlineconstexprnoexcept

Sets every element to r.

◆ front() [1/2]

template<sofa::Size N, typename ValueType >

constexpr reference sofa::type::Vec< N, ValueType >::front ( )

inlineconstexpr

◆ front() [2/2]

template<sofa::Size N, typename ValueType >

constexpr const_reference sofa::type::Vec< N, ValueType >::front ( ) const

inlineconstexpr

◆ getsub() [1/2]

template<sofa::Size N, typename ValueType >

constexpr void sofa::type::Vec< N, ValueType >::getsub	(	const Size	i,
		ValueType &	m
	)		const

inlineconstexprnoexcept

◆ getsub() [2/2]

template<sofa::Size N, typename ValueType >

template<Size N2, std::enable_if_t<(N2< N), bool > = true>

constexpr void sofa::type::Vec< N, ValueType >::getsub	(	const Size	i,
		Vec< N2, ValueType > &	m
	)		const

inlineconstexprnoexcept

◆ isNormalized()

template<sofa::Size N, typename ValueType >

bool sofa::type::Vec< N, ValueType >::isNormalized ( ValueType threshold = std::numeric_limits<ValueType>::epsilon()*(ValueType)10 ) const

inline

return true if norm()==1

◆ linearDivision()

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::linearDivision ( const Vec< N, real2 > & v ) const

inlineconstexprnoexcept

linear division.

◆ linearProduct()

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::linearProduct ( const Vec< N, real2 > & v ) const

inlineconstexprnoexcept

linear product.

◆ lNorm()

template<sofa::Size N, typename ValueType >

ValueType sofa::type::Vec< N, ValueType >::lNorm ( int l ) const

inline

l-norm of the vector The type of norm is set by parameter l. Use l<0 for the infinite norm.

◆ mulscalar() [1/2]

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::mulscalar ( const real2 f ) const

inlineconstexprnoexcept

Multiplication by a scalar f.

◆ mulscalar() [2/2]

template<sofa::Size N, typename ValueType >

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::mulscalar ( const ValueType f ) const

inlineconstexprnoexcept

◆ norm()

template<sofa::Size N, typename ValueType >

ValueType sofa::type::Vec< N, ValueType >::norm ( ) const

inlinenoexcept

Euclidean norm.

◆ norm2()

template<sofa::Size N, typename ValueType >

constexpr ValueType sofa::type::Vec< N, ValueType >::norm2 ( ) const

inlineconstexprnoexcept

Squared norm.

◆ normalize() [1/2]

template<sofa::Size N, typename ValueType >

bool sofa::type::Vec< N, ValueType >::normalize ( ValueType threshold = std::numeric_limits<ValueType>::epsilon() )

inlinenoexcept

Normalize the vector. returns false iff the norm is too small

◆ normalize() [2/2]

template<sofa::Size N, typename ValueType >

void sofa::type::Vec< N, ValueType >::normalize	(	Vec< N, ValueType >	failsafe,
		ValueType	threshold = `std::numeric_limits<ValueType>::epsilon()`
	)

inlinenoexcept

Normalize the vector with a failsafe. If the norm is too small, the vector becomes the failsafe.

◆ normalized()

template<sofa::Size N, typename ValueType >

Vec<N,ValueType> sofa::type::Vec< N, ValueType >::normalized ( ) const

inlinenoexcept

Return the normalized vector.

Warning: 'this' is not normalized.

◆ normalizeWithNorm()

template<sofa::Size N, typename ValueType >

constexpr bool sofa::type::Vec< N, ValueType >::normalizeWithNorm	(	ValueType	norm,
		ValueType	threshold = `std::numeric_limits<ValueType>::epsilon()`
	)

inlineconstexprnoexcept

Normalize the vector taking advantage of its already computed norm, equivalent to /=norm returns false iff the norm is too small

◆ operator!=()

template<sofa::Size N, typename ValueType >

constexpr bool sofa::type::Vec< N, ValueType >::operator!= ( const Vec< N, ValueType > & b ) const

inlineconstexprnoexcept

◆ operator()() [1/2]

template<sofa::Size N, typename ValueType >

constexpr const ValueType& sofa::type::Vec< N, ValueType >::operator() ( Size i ) const

inlineconstexprnoexcept

Const access to i-th element.

◆ operator()() [2/2]

template<sofa::Size N, typename ValueType >

constexpr ValueType& sofa::type::Vec< N, ValueType >::operator() ( Size i )

inlineconstexprnoexcept

Access to i-th element.

◆ operator*() [1/2]

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::operator* ( const real2 f ) const

inlineconstexprnoexcept

◆ operator*() [2/2]

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr ValueType sofa::type::Vec< N, ValueType >::operator* ( const Vec< N, real2 > & v ) const

inlineconstexprnoexcept

Dot product.

◆ operator*=()

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr void sofa::type::Vec< N, ValueType >::operator*= ( const real2 f )

inlineconstexprnoexcept

◆ operator+()

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::operator+ ( const Vec< N, real2 > & v ) const

inlineconstexprnoexcept

Vector addition.

◆ operator+=()

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr void sofa::type::Vec< N, ValueType >::operator+= ( const Vec< N, real2 > & v )

inlineconstexprnoexcept

In-place vector addition.

◆ operator-() [1/2]

template<sofa::Size N, typename ValueType >

template<typename T = ValueType, std::enable_if_t< !std::is_unsigned_v< T >, int > = 0>

constexpr Vec<N, ValueType> sofa::type::Vec< N, ValueType >::operator- ( ) const

inlineconstexprnoexcept

Vector negation.

◆ operator-() [2/2]

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr Vec<N,ValueType> sofa::type::Vec< N, ValueType >::operator- ( const Vec< N, real2 > & v ) const

inlineconstexprnoexcept

Vector subtraction.

◆ operator-=()

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr void sofa::type::Vec< N, ValueType >::operator-= ( const Vec< N, real2 > & v )

inlineconstexprnoexcept

In-place vector subtraction.

◆ operator/()

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr Vec<N, ValueType> sofa::type::Vec< N, ValueType >::operator/ ( const real2 f ) const

inlineconstexprnoexcept

◆ operator/=()

template<sofa::Size N, typename ValueType >

template<class real2 , std::enable_if_t< std::is_convertible_v< real2, ValueType >, bool > = true>

constexpr void sofa::type::Vec< N, ValueType >::operator/= ( const real2 f )

inlineconstexprnoexcept

◆ operator=() [1/3]

template<sofa::Size N, typename ValueType >

template<typename real2 >

constexpr void sofa::type::Vec< N, ValueType >::operator= ( const real2 * p )

inlineconstexprnoexcept

Assignment operator from an array of values.

◆ operator=() [2/3]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if< NN==1, int >::type = 0>

constexpr void sofa::type::Vec< N, ValueType >::operator= ( const ValueType r1 )

inlineconstexprnoexcept

Specific Assignment operator for 1-element vectors.

◆ operator=() [3/3]

template<sofa::Size N, typename ValueType >

template<Size M, typename real2 >

constexpr void sofa::type::Vec< N, ValueType >::operator= ( const Vec< M, real2 > & v )

inlineconstexprnoexcept

Assignment from a vector with different dimensions.

◆ operator==()

template<sofa::Size N, typename ValueType >

constexpr bool sofa::type::Vec< N, ValueType >::operator== ( const Vec< N, ValueType > & b ) const

inlineconstexprnoexcept

◆ operator[]() [1/2]

template<sofa::Size N, typename ValueType >

constexpr reference sofa::type::Vec< N, ValueType >::operator[] ( size_type i )

inlineconstexpr

◆ operator[]() [2/2]

template<sofa::Size N, typename ValueType >

constexpr const_reference sofa::type::Vec< N, ValueType >::operator[] ( size_type i ) const

inlineconstexpr

◆ ptr() [1/2]

template<sofa::Size N, typename ValueType >

constexpr const ValueType* sofa::type::Vec< N, ValueType >::ptr ( ) const

inlineconstexprnoexcept

Cast into a const array of values.

◆ ptr() [2/2]

template<sofa::Size N, typename ValueType >

constexpr ValueType* sofa::type::Vec< N, ValueType >::ptr ( )

inlineconstexprnoexcept

Cast into an array of values.

◆ set() [1/3]

template<sofa::Size N, typename ValueType >

template<typename... ArgsT, typename = std::enable_if_t< (std::is_convertible_v<ArgsT, ValueType> && ...) >, typename = std::enable_if_t< (sizeof...(ArgsT) == N && sizeof...(ArgsT) > 1) >>

constexpr void sofa::type::Vec< N, ValueType >::set ( const ArgsT... r )

inlineconstexprnoexcept

◆ set() [2/3]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if< NN==1, int >::type = 0>

constexpr void sofa::type::Vec< N, ValueType >::set ( const ValueType r1 )

inlineconstexprnoexcept

Specific set function for 1-element vectors.

◆ set() [3/3]

template<sofa::Size N, typename ValueType >

template<Size N2, class real2 >

constexpr void sofa::type::Vec< N, ValueType >::set	(	const Vec< N2, real2 > &	v,
		ValueType	defaultvalue = `0`
	)

inlineconstexprnoexcept

Specific set from a different size vector (given default value and ignored outside entries)

◆ size()

template<sofa::Size N, typename ValueType >

static constexpr sofa::Size sofa::type::Vec< N, ValueType >::size ( void )

inlinestaticconstexpr

◆ sum()

template<sofa::Size N, typename ValueType >

constexpr ValueType sofa::type::Vec< N, ValueType >::sum ( ) const

inlineconstexprnoexcept

sum of all elements of the vector

◆ w() [1/2]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >=4), int >::type = 0>

constexpr const ValueType& sofa::type::Vec< N, ValueType >::w ( ) const

inlineconstexprnoexcept

Special const access to fourth element.

◆ w() [2/2]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >=4), int >::type = 0>

constexpr ValueType& sofa::type::Vec< N, ValueType >::w ( )

inlineconstexprnoexcept

Special access to fourth element.

◆ x() [1/2]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >=1), int >::type = 0>

constexpr const ValueType& sofa::type::Vec< N, ValueType >::x ( ) const

inlineconstexprnoexcept

Special const access to first element.

◆ x() [2/2]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >=1), int >::type = 0>

constexpr ValueType& sofa::type::Vec< N, ValueType >::x ( )

inlineconstexprnoexcept

Special access to first element.

◆ y() [1/2]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >=2), int >::type = 0>

constexpr const ValueType& sofa::type::Vec< N, ValueType >::y ( ) const

inlineconstexprnoexcept

Special const access to second element.

◆ y() [2/2]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >=2), int >::type = 0>

constexpr ValueType& sofa::type::Vec< N, ValueType >::y ( )

inlineconstexprnoexcept

Special access to second element.

◆ z() [1/2]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >=3), int >::type = 0>

constexpr const ValueType& sofa::type::Vec< N, ValueType >::z ( ) const

inlineconstexprnoexcept

Special const access to third element.

◆ z() [2/2]

template<sofa::Size N, typename ValueType >

template<Size NN = N, typename std::enable_if<(NN >=3), int >::type = 0>

constexpr ValueType& sofa::type::Vec< N, ValueType >::z ( )

inlineconstexprnoexcept

Special access to third element.

Public Attributes

Static Public Attributes

Public Member Functions

Static Public Member Functions

Attribute details

◆ elems

◆ spatial_dimensions

◆ static_size

◆ total_size

Constructor details

◆ Vec() [1/10]

◆ Vec() [2/10]

◆ Vec() [3/10]

◆ Vec() [4/10]

◆ Vec() [5/10]

◆ Vec() [6/10]

◆ Vec() [7/10]

◆ Vec() [8/10]

◆ Vec() [9/10]

◆ Vec() [10/10]

Function details

◆ assign()

◆ back() [1/2]

◆ back() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ clear()

◆ cross()

◆ data()

◆ divscalar() [1/2]

◆ divscalar() [2/2]

◆ end() [1/2]

◆ end() [2/2]

◆ eqdivscalar() [1/2]

◆ eqdivscalar() [2/2]

◆ eqmulscalar() [1/2]

◆ eqmulscalar() [2/2]

◆ fill()

◆ front() [1/2]

◆ front() [2/2]

◆ getsub() [1/2]

◆ getsub() [2/2]

◆ isNormalized()

◆ linearDivision()

◆ linearProduct()

◆ lNorm()

◆ mulscalar() [1/2]

◆ mulscalar() [2/2]

◆ norm()

◆ norm2()

◆ normalize() [1/2]

◆ normalize() [2/2]

◆ normalized()

◆ normalizeWithNorm()

◆ operator!=()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator*=()

◆ operator+()

◆ operator+=()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator-=()

◆ operator/()

◆ operator/=()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ operator==()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ ptr() [1/2]

◆ ptr() [2/2]

◆ set() [1/3]

◆ set() [2/3]

◆ set() [3/3]

◆ size()

◆ sum()