osc::Vector< T, N > Class Template Reference

#include <vector.h>

Public Types
using	value_type = T
using	size_type = size_t
using	difference_type = ptrdiff_t
using	reference = value_type &
using	const_reference = const value_type &
using	pointer = T *
using	const_pointer = const T *
using	iterator = T *
using	const_iterator = const T *

Public Member Functions
constexpr	Vector ()=default
constexpr	Vector (const Vector &)=default
constexpr	Vector (Vector &&)=default
constexpr	Vector (const T &value)
template<typename... Elements> requires ( (sizeof...(Elements) == N) and (std::constructible_from<T, Elements> and ...) )
	not (std::convertible_to< Elements, T > and ...)) const expr Vector(Elements &&... elements)
template<std::ranges::contiguous_range R> requires ( detail::CompileTimeSizeGreaterThanOrEqualTo<R, N> and std::constructible_from<T, typename std::remove_cvref_t<R>::value_type> )
not std::convertible_to< typename std::remove_cvref_t< R >::value_type, T > constexpr	Vector (R &&r)
template<typename U , size_t M, typename... Elements> requires ( M < N and ((M + sizeof...(Elements)) == N) and std::constructible_from<T, U> and (std::constructible_from<T, Elements> and ...) )
constexpr	Vector (const Vector< U, M > &v, Elements &&... elements)
	~Vector () noexcept=default
constexpr Vector &	operator= (const Vector &)=default
constexpr Vector &	operator= (Vector &&)=default
template<std::ranges::contiguous_range R> requires ( detail::CompileTimeSizeGreaterThanOrEqualTo<R, N> and std::assignable_from<T&, typename std::remove_cvref_t<R>::value_type> )
constexpr Vector &	operator= (R &&r)
constexpr size_type	size () const
constexpr pointer	data ()
constexpr const_pointer	data () const
constexpr iterator	begin ()
constexpr const_iterator	begin () const
constexpr iterator	end ()
constexpr const_iterator	end () const
constexpr reference	operator[] (size_type pos)
constexpr const_reference	operator[] (size_type pos) const
constexpr reference	x ()
	Returns (*this)[0]
constexpr const_reference	x () const
	Returns (*this)[0]
constexpr reference	y ()
	Returns (*this)[1]
constexpr const_reference	y () const
	Returns (*this)[0]
constexpr reference	z ()
	Returns (*this)[2]
constexpr const_reference	z () const
	Returns (*this)[0]
constexpr reference	w ()
	Returns (*this)[3]
constexpr const_reference	w () const
	Returns (*this)[0]
constexpr Vector< T, 2 >	xy () const
	Returns Vector<T, 2>{x(), y()}
constexpr Vector< T, 2 >	xz () const
	Returns Vector<T, 2>{x(), z()}
constexpr Vector< T, 2 >	yx () const
	Returns Vector<T, 2>{y(), x()}
constexpr Vector< T, 2 >	yz () const
	Returns {y(), z()}
constexpr Vector< T, 2 >	zx () const
	Returns {z(), x()}
constexpr Vector< T, 2 >	zy () const
	Returns {z(), y()}
constexpr	operator std::span< T, N > ()
constexpr	operator std::span< const T, N > () const
template<typename U > requires (requires (T& lhs, const U& rhs) { lhs += rhs; })
constexpr Vector &	operator+= (const U &rhs)
template<std::ranges::contiguous_range R> requires ( detail::CompileTimeSizeEqualTo<R, N> and requires (T& lhs, const R& rhs) { lhs += rhs[0]; } )
constexpr Vector &	operator+= (const R &rhs)
template<typename U > requires (requires (T& lhs, const U& rhs) { lhs -= rhs; })
constexpr Vector &	operator-= (const U &rhs)
template<std::ranges::contiguous_range R> requires ( detail::CompileTimeSizeEqualTo<R, N> and requires (T& lhs, const R& rhs) { lhs -= rhs[0]; } )
constexpr Vector &	operator-= (const R &rhs)
template<typename U > requires (requires (T& lhs, const U& rhs) { lhs *= rhs; })
constexpr Vector &	operator*= (const U &rhs)
template<std::ranges::contiguous_range R> requires ( detail::CompileTimeSizeEqualTo<R, N> and requires (T& lhs, const R& rhs) { lhs *= rhs[0]; } )
constexpr Vector &	operator*= (const R &rhs)
template<typename U > requires (requires (T& lhs, const U& rhs) { lhs /= rhs; })
constexpr Vector &	operator/= (const U &rhs)
template<std::ranges::contiguous_range R> requires ( detail::CompileTimeSizeEqualTo<R, N> and requires (T& lhs, const R& rhs) { lhs /= rhs[0]; } )
constexpr Vector &	operator/= (const R &rhs)
constexpr Vector &	operator++ ()
constexpr Vector &	operator-- ()
constexpr Vector	operator++ (int)
constexpr Vector	operator-- (int)
template<typename U > requires std::constructible_from<T, U>
constexpr Vector	with_element (size_type pos, U value) const

Friends
constexpr bool	operator== (const Vector &, const Vector &)=default
constexpr auto	operator<=> (const Vector &, const Vector &)=default

Member Typedef Documentation

const_iterator

template<typename T , size_t N>

using osc::Vector< T, N >::const_iterator = const T*

const_pointer

template<typename T , size_t N>

using osc::Vector< T, N >::const_pointer = const T*

const_reference

template<typename T , size_t N>

using osc::Vector< T, N >::const_reference = const value_type&

difference_type

template<typename T , size_t N>

using osc::Vector< T, N >::difference_type = ptrdiff_t

iterator

template<typename T , size_t N>

using osc::Vector< T, N >::iterator = T*

pointer

template<typename T , size_t N>

using osc::Vector< T, N >::pointer = T*

reference

template<typename T , size_t N>

using osc::Vector< T, N >::reference = value_type&

size_type

template<typename T , size_t N>

using osc::Vector< T, N >::size_type = size_t

value_type

template<typename T , size_t N>

using osc::Vector< T, N >::value_type = T

Constructor & Destructor Documentation

Vector() [1/6]

template<typename T , size_t N>

constexpr osc::Vector< T, N >::Vector ( )

constexprdefault

Vector() [2/6]

template<typename T , size_t N>

constexpr osc::Vector< T, N >::Vector ( const Vector< T, N > &  )

constexprdefault

Vector() [3/6]

template<typename T , size_t N>

constexpr osc::Vector< T, N >::Vector ( Vector< T, N > &&  )

constexprdefault

Vector() [4/6]

template<typename T , size_t N>

constexpr osc::Vector< T, N >::Vector ( const T &  value )

inlineexplicitconstexpr

Vector() [5/6]

template<typename T , size_t N>

template<std::ranges::contiguous_range R>
requires ( detail::CompileTimeSizeGreaterThanOrEqualTo<R, N> and std::constructible_from<T, typename std::remove_cvref_t<R>::value_type> )

not std::convertible_to< typename std::remove_cvref_t< R >::value_type, T > constexpr osc::Vector< T, N >::Vector ( R &&  r )

inlineexplicitconstexpr

Vector() [6/6]

template<typename T , size_t N>

template<typename U , size_t M, typename... Elements>
requires ( M < N and ((M + sizeof...(Elements)) == N) and std::constructible_from<T, U> and (std::constructible_from<T, Elements> and ...) )

constexpr osc::Vector< T, N >::Vector ( const Vector< U, M > &  v, Elements &&...  elements  )

inlineconstexpr

~Vector()

template<typename T , size_t N>

osc::Vector< T, N >::~Vector ( )

defaultnoexcept

Member Function Documentation

begin() [1/2]

template<typename T , size_t N>

constexpr iterator osc::Vector< T, N >::begin ( )

inlineconstexpr

begin() [2/2]

template<typename T , size_t N>

constexpr const_iterator osc::Vector< T, N >::begin ( ) const

inlineconstexpr

data() [1/2]

template<typename T , size_t N>

constexpr pointer osc::Vector< T, N >::data ( )

inlineconstexpr

data() [2/2]

template<typename T , size_t N>

constexpr const_pointer osc::Vector< T, N >::data ( ) const

inlineconstexpr

end() [1/2]

template<typename T , size_t N>

constexpr iterator osc::Vector< T, N >::end ( )

inlineconstexpr

end() [2/2]

template<typename T , size_t N>

constexpr const_iterator osc::Vector< T, N >::end ( ) const

inlineconstexpr

not()

template<typename T , size_t N>

template<typename... Elements>
requires ( (sizeof...(Elements) == N) and (std::constructible_from<T, Elements> and ...) )

osc::Vector< T, N >::not ( std::convertible_to< Elements, T >  and ... ) const &&

inlineexplicit

operator std::span< const T, N >()

template<typename T , size_t N>

constexpr osc::Vector< T, N >::operator std::span< const T, N > ( ) const

inlineconstexpr

operator std::span< T, N >()

template<typename T , size_t N>

constexpr osc::Vector< T, N >::operator std::span< T, N > ( )

inlineconstexpr

operator*=() [1/2]

template<typename T , size_t N>

template<std::ranges::contiguous_range R>
requires ( detail::CompileTimeSizeEqualTo<R, N> and requires (T& lhs, const R& rhs) { lhs *= rhs[0]; } )

constexpr Vector & osc::Vector< T, N >::operator*= ( const R &  rhs )

inlineconstexpr

operator*=() [2/2]

template<typename T , size_t N>

template<typename U >
requires (requires (T& lhs, const U& rhs) { lhs *= rhs; })

constexpr Vector & osc::Vector< T, N >::operator*= ( const U &  rhs )

inlineconstexpr

operator++() [1/2]

template<typename T , size_t N>

constexpr Vector & osc::Vector< T, N >::operator++ ( )

inlineconstexpr

operator++() [2/2]

template<typename T , size_t N>

constexpr Vector osc::Vector< T, N >::operator++ ( int  )

inlineconstexpr

operator+=() [1/2]

template<typename T , size_t N>

template<std::ranges::contiguous_range R>
requires ( detail::CompileTimeSizeEqualTo<R, N> and requires (T& lhs, const R& rhs) { lhs += rhs[0]; } )

constexpr Vector & osc::Vector< T, N >::operator+= ( const R &  rhs )

inlineconstexpr

operator+=() [2/2]

template<typename T , size_t N>

template<typename U >
requires (requires (T& lhs, const U& rhs) { lhs += rhs; })

constexpr Vector & osc::Vector< T, N >::operator+= ( const U &  rhs )

inlineconstexpr

operator--() [1/2]

template<typename T , size_t N>

constexpr Vector & osc::Vector< T, N >::operator-- ( )

inlineconstexpr

operator--() [2/2]

template<typename T , size_t N>

constexpr Vector osc::Vector< T, N >::operator-- ( int  )

inlineconstexpr

operator-=() [1/2]

template<typename T , size_t N>

template<std::ranges::contiguous_range R>
requires ( detail::CompileTimeSizeEqualTo<R, N> and requires (T& lhs, const R& rhs) { lhs -= rhs[0]; } )

constexpr Vector & osc::Vector< T, N >::operator-= ( const R &  rhs )

inlineconstexpr

operator-=() [2/2]

template<typename T , size_t N>

template<typename U >
requires (requires (T& lhs, const U& rhs) { lhs -= rhs; })

constexpr Vector & osc::Vector< T, N >::operator-= ( const U &  rhs )

inlineconstexpr

operator/=() [1/2]

template<typename T , size_t N>

template<std::ranges::contiguous_range R>
requires ( detail::CompileTimeSizeEqualTo<R, N> and requires (T& lhs, const R& rhs) { lhs /= rhs[0]; } )

constexpr Vector & osc::Vector< T, N >::operator/= ( const R &  rhs )

inlineconstexpr

operator/=() [2/2]

template<typename T , size_t N>

template<typename U >
requires (requires (T& lhs, const U& rhs) { lhs /= rhs; })

constexpr Vector & osc::Vector< T, N >::operator/= ( const U &  rhs )

inlineconstexpr

operator=() [1/3]

template<typename T , size_t N>

constexpr Vector & osc::Vector< T, N >::operator= ( const Vector< T, N > &  )

constexprdefault

operator=() [2/3]

template<typename T , size_t N>

template<std::ranges::contiguous_range R>
requires ( detail::CompileTimeSizeGreaterThanOrEqualTo<R, N> and std::assignable_from<T&, typename std::remove_cvref_t<R>::value_type> )

constexpr Vector & osc::Vector< T, N >::operator= ( R &&  r )

inlineconstexpr

operator=() [3/3]

template<typename T , size_t N>

constexpr Vector & osc::Vector< T, N >::operator= ( Vector< T, N > &&  )

constexprdefault

operator[]() [1/2]

template<typename T , size_t N>

constexpr reference osc::Vector< T, N >::operator[] ( size_type  pos )

inlineconstexpr

operator[]() [2/2]

template<typename T , size_t N>

constexpr const_reference osc::Vector< T, N >::operator[] ( size_type  pos ) const

inlineconstexpr

size()

template<typename T , size_t N>

constexpr size_type osc::Vector< T, N >::size ( ) const

inlineconstexpr

w() [1/2]

template<typename T , size_t N>

constexpr reference osc::Vector< T, N >::w ( )

inlineconstexpr

Returns (*this)[3]

w() [2/2]

template<typename T , size_t N>

constexpr const_reference osc::Vector< T, N >::w ( ) const

inlineconstexpr

Returns (*this)[0]

with_element()

template<typename T , size_t N>

template<typename U >
requires std::constructible_from<T, U>

constexpr Vector osc::Vector< T, N >::with_element ( size_type  pos, U  value  ) const

inlineconstexpr

x() [1/2]

template<typename T , size_t N>

constexpr reference osc::Vector< T, N >::x ( )

inlineconstexpr

Returns (*this)[0]

x() [2/2]

template<typename T , size_t N>

constexpr const_reference osc::Vector< T, N >::x ( ) const

inlineconstexpr

Returns (*this)[0]

xy()

template<typename T , size_t N>

constexpr Vector< T, 2 > osc::Vector< T, N >::xy ( ) const

inlineconstexpr

Returns Vector<T, 2>{x(), y()}

xz()

template<typename T , size_t N>

constexpr Vector< T, 2 > osc::Vector< T, N >::xz ( ) const

inlineconstexpr

Returns Vector<T, 2>{x(), z()}

y() [1/2]

template<typename T , size_t N>

constexpr reference osc::Vector< T, N >::y ( )

inlineconstexpr

Returns (*this)[1]

y() [2/2]

template<typename T , size_t N>

constexpr const_reference osc::Vector< T, N >::y ( ) const

inlineconstexpr

Returns (*this)[0]

yx()

template<typename T , size_t N>

constexpr Vector< T, 2 > osc::Vector< T, N >::yx ( ) const

inlineconstexpr

Returns Vector<T, 2>{y(), x()}

yz()

template<typename T , size_t N>

constexpr Vector< T, 2 > osc::Vector< T, N >::yz ( ) const

inlineconstexpr

Returns {y(), z()}

z() [1/2]

template<typename T , size_t N>

constexpr reference osc::Vector< T, N >::z ( )

inlineconstexpr

Returns (*this)[2]

z() [2/2]

template<typename T , size_t N>

constexpr const_reference osc::Vector< T, N >::z ( ) const

inlineconstexpr

Returns (*this)[0]

zx()

template<typename T , size_t N>

constexpr Vector< T, 2 > osc::Vector< T, N >::zx ( ) const

inlineconstexpr

Returns {z(), x()}

zy()

template<typename T , size_t N>

constexpr Vector< T, 2 > osc::Vector< T, N >::zy ( ) const

inlineconstexpr

Returns {z(), y()}

Friends And Related Symbol Documentation

operator<=>

template<typename T , size_t N>

constexpr auto operator<=> ( const Vector< T, N > &  , const Vector< T, N > &    )

friend

operator==

template<typename T , size_t N>

constexpr bool operator== ( const Vector< T, N > &  , const Vector< T, N > &    )

friend

---

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

• /home/adam/Desktop/opensim-creator/third_party/opynsim/liboscar/maths/vector.h