Storage class for math vectors with support for x, y, z, and w members for appropriate dimensions. More...

Classes
struct	mi::math::Vector_struct<T, DIM>
	Generic storage class template for math vector representations storing `DIM` elements of type `T`. More...

struct	mi::math::Vector_struct<T, 1>
	Specialization for dimension 1 to create x member. More...

struct	mi::math::Vector_struct<T, 2>
	Specialization for dimension 2 to create x and y member. More...

struct	mi::math::Vector_struct<T, 3>
	Specialization for dimension 3 to create x, y, and z members. More...

struct	mi::math::Vector_struct<T, 4>
	Specialization for dimension 4 to create x, y, z, and w members. More...

class	mi::math::Vector<T, DIM>
	Fixed-size math vector class template with generic operations. More...

Typedefs
typedef Vector_struct<T, DIM>	mi::math::Vector<T, DIM>::Pod_type
	POD class corresponding to this vector. More...

typedef Vector_struct<T, DIM>	mi::math::Vector<T, DIM>::storage_type
	Storage class used by this vector. More...

typedef T	mi::math::Vector<T, DIM>::value_type
	Element type. More...

typedef Size	mi::math::Vector<T, DIM>::size_type
	Size type, unsigned. More...

typedef Difference	mi::math::Vector<T, DIM>::difference_type
	Difference type, signed. More...

typedef T *	mi::math::Vector<T, DIM>::pointer
	Mutable pointer to element. More...

typedef const T *	mi::math::Vector<T, DIM>::const_pointer
	Const pointer to element. More...

typedef T &	mi::math::Vector<T, DIM>::reference
	Mutable reference to element. More...

typedef const T &	mi::math::Vector<T, DIM>::const_reference
	Const reference to element. More...

Functions
template<typename T , Size DIM>
T *	mi::math::vector_base_ptr (Vector_struct<T, DIM> &vec)
	Returns the base pointer to the vector data. More...

template<typename T , Size DIM>
const T *	mi::math::vector_base_ptr (const Vector_struct<T, DIM> &vec)
	Returns the base pointer to the vector data. More...

template<typename T>
T *	mi::math::vector_base_ptr (Vector_struct<T, 1> &vec)
	Returns the base pointer to the vector data, specialization for `DIM==1`. More...

template<typename T>
const T *	mi::math::vector_base_ptr (const Vector_struct<T, 1> &vec)
	Returns the base pointer to the vector data, specialization for `DIM==1`. More...

template<typename T>
T *	mi::math::vector_base_ptr (Vector_struct<T, 2> &vec)
	Returns the base pointer to the vector data, specialization for `DIM==2`. More...

template<typename T>
const T *	mi::math::vector_base_ptr (const Vector_struct<T, 2> &vec)
	Returns the base pointer to the vector data, specialization for `DIM==2`. More...

template<typename T>
T *	mi::math::vector_base_ptr (Vector_struct<T, 3> &vec)
	Returns the base pointer to the vector data, specialization for `DIM==3`. More...

template<typename T>
const T *	mi::math::vector_base_ptr (const Vector_struct<T, 3> &vec)
	Returns the base pointer to the vector data, specialization for `DIM==3`. More...

template<typename T>
T *	mi::math::vector_base_ptr (Vector_struct<T, 4> &vec)
	Returns the base pointer to the vector data, specialization for `DIM==4`. More...

template<typename T>
const T *	mi::math::vector_base_ptr (const Vector_struct<T, 4> &vec)
	Returns the base pointer to the vector data, specialization for `DIM==4`. More...

static Size	mi::math::Vector<T, DIM>::size ()
	Constant size of the vector. More...

static Size	mi::math::Vector<T, DIM>::max_size ()
	Constant maximum size of the vector. More...

T *	mi::math::Vector<T, DIM>::begin ()
	Returns the pointer to the first vector element. More...

const T *	mi::math::Vector<T, DIM>::begin () const
	Returns the pointer to the first vector element. More...

T *	mi::math::Vector<T, DIM>::end ()
	Returns the past-the-end pointer. More...

const T *	mi::math::Vector<T, DIM>::end () const
	Returns the past-the-end pointer. More...

	mi::math::Vector<T, DIM>::Vector ()
	The default constructor leaves the vector elements uninitialized. More...

	mi::math::Vector<T, DIM>::Vector (const Vector<T, DIM> &vec)=default
	Default copy constructor. More...

	mi::math::Vector<T, DIM>::Vector (const Vector_struct<T, DIM> &vec)
	Constructor from underlying storage type. More...

	mi::math::Vector<T, DIM>::Vector (T v)
	Constructor initializes all vector elements to the value `v`. More...

template<typename Iterator>
	mi::math::Vector<T, DIM>::Vector (From_iterator_tag, Iterator p)
	Constructor requires the mi::math::FROM_ITERATOR tag as first argument and initializes the vector elements with the first `DIM` elements from the sequence starting at the iterator `p`. More...

template<typename T2>
	mi::math::Vector<T, DIM>::Vector (T2 const (&array)[DIM])
	Constructor initializes the vector elements from an `array` of dimension `DIM`. More...

template<typename T2>
	mi::math::Vector<T, DIM>::Vector (const Vector<T2, DIM> &other)
	Template constructor that allows explicit conversions from other vectors with assignment compatible element value type. More...

template<typename T2>
	mi::math::Vector<T, DIM>::Vector (const Vector_struct<T2, DIM> &other)
	Template constructor that allows explicit conversions from underlying storage type with assignment compatible element value type. More...

	mi::math::Vector<T, DIM>::Vector (T v1, T v2)
	Dedicated constructor, for dimension 2 only, that initializes the vector elements from the two elements (v1,v2). More...

	mi::math::Vector<T, DIM>::Vector (T v1, T v2, T v3)
	Dedicated constructor, for dimension 3 only, that initializes the vector elements from the three elements (v1,v2,v3). More...

	mi::math::Vector<T, DIM>::Vector (T v1, const Vector<T, 2> &v2)
	Dedicated constructor, for dimension 3 only, that initializes the vector elements from the three elements (v1,v2.x,v2.y). More...

	mi::math::Vector<T, DIM>::Vector (const Vector<T, 2> &v1, T v2)
	Dedicated constructor, for dimension 3 only, that initializes the vector elements from the three elements (v1.x,v1.y,v2). More...

	mi::math::Vector<T, DIM>::Vector (T v1, T v2, T v3, T v4)
	Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1,v2,v3,v4). More...

	mi::math::Vector<T, DIM>::Vector (T v1, T v2, const Vector<T, 2> &v3)
	Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1,v2,v3.x,v3.y). More...

	mi::math::Vector<T, DIM>::Vector (T v1, const Vector<T, 2> &v2, T v3)
	Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1,v2.x,v2.y,v3). More...

	mi::math::Vector<T, DIM>::Vector (const Vector<T, 2> &v1, T v2, T v3)
	Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1.x,v1.y,v2,v3). More...

	mi::math::Vector<T, DIM>::Vector (const Vector<T, 2> &v1, const Vector<T, 2> &v2)
	Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1.x,v1.y,v2.x,v2.y). More...

	mi::math::Vector<T, DIM>::Vector (T v1, const Vector<T, 3> &v2)
	Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1,v2.x,v2.y,v2.z). More...

	mi::math::Vector<T, DIM>::Vector (const Vector<T, 3> &v1, T v2)
	Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1.x,v1.y,v1.z,v2). More...

	mi::math::Vector<T, DIM>::Vector (const Color_struct &color)
	Dedicated constructor, for dimension 4 only, that initializes the vector elements from a color interpreted as a vector (r,g,b,a). More...

Vector &	mi::math::Vector<T, DIM>::operator= (const Vector &other)=default
	Assignment. More...

Vector &	mi::math::Vector<T, DIM>::operator= (T s)
	Assignment from a scalar, setting all elements to `s`. More...

Vector &	mi::math::Vector<T, DIM>::operator= (const Color_struct &color)
	Assignment, for dimension 4 only, that assigns color interpreted as a vector (r,g,b,a) to this vector. More...

T &	mi::math::Vector<T, DIM>::operator[] (Size i)
	Accesses the `i-th` vector element. More...

const T &	mi::math::Vector<T, DIM>::operator[] (Size i) const
	Accesses the `i-th` vector element. More...

const T &	mi::math::Vector<T, DIM>::get (Size i) const
	Returns the `i-th` vector element. More...

void	mi::math::Vector<T, DIM>::set (Size i, T value)
	Sets the `i-th` vector element to `value`. More...

bool	mi::math::Vector<T, DIM>::normalize ()
	Normalizes this vector to unit length. More...

bool	mi::math::Vector<T, DIM>::operator== (Vector<T, DIM> rhs) const
	Returns `true` if `lhs` is elementwise equal to `rhs`. More...

bool	mi::math::Vector<T, DIM>::operator!= (Vector<T, DIM> rhs) const
	Returns `true` if `lhs` is elementwise not equal to `rhs`. More...

bool	mi::math::Vector<T, DIM>::operator< (Vector<T, DIM> rhs) const
	Returns `true` if `lhs` is lexicographically less than `rhs`. More...

bool	mi::math::Vector<T, DIM>::operator<= (Vector<T, DIM> rhs) const
	Returns `true` if `lhs` is lexicographically less than or equal to `rhs`. More...

bool	mi::math::Vector<T, DIM>::operator> (Vector<T, DIM> rhs) const
	Returns `true` if `lhs` is lexicographically greater than `rhs`. More...

bool	mi::math::Vector<T, DIM>::operator>= (Vector<T, DIM> rhs) const
	Returns `true` if `lhs` is lexicographically greater than or equal to `rhs`. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator+= (Vector<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Adds `rhs` elementwise to `lhs` and returns the modified `lhs`. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator-= (Vector<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Subtracts `rhs` elementwise from `lhs` and returns the modified `lhs`. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator*= (Vector<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Multiplies `rhs` elementwise with `lhs` and returns the modified `lhs`. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator%= (Vector<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Computes `lhs` modulo `rhs` elementwise and returns the modified `lhs`. More...

template<typename T , typename U , Size DIM>
Vector<T, DIM> &	mi::math::operator/= (Vector<T, DIM> &lhs, const Vector_struct<U, DIM> &rhs)
	Divides `lhs` elementwise by `rhs` and returns the modified `lhs`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator+ (const Vector_struct<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Adds `lhs` and `rhs` elementwise and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator- (const Vector_struct<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Subtracts `rhs` elementwise from `lhs` and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator* (const Vector_struct<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Multiplies `rhs` elementwise with `lhs` and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator% (const Vector_struct<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Computes `lhs` modulo `rhs` elementwise and returns the new result. More...

template<typename T , typename U , Size DIM>
Vector<T, DIM>	mi::math::operator/ (const Vector_struct<T, DIM> &lhs, const Vector_struct<U, DIM> &rhs)
	Divides `rhs` elementwise by `lhs` and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator- (const Vector_struct<T, DIM> &v)
	Negates the vector `v` elementwise and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator+= (Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Adds `rhs` elementwise to `lhs` and returns the modified `lhs`. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator-= (Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Subtracts `rhs` elementwise from `lhs` and returns the modified `lhs`. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator*= (Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Multiplies `rhs` elementwise with `lhs` and returns the modified `lhs`. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator%= (Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Computes `lhs` modulo `rhs` elementwise and returns the modified `lhs`. More...

template<typename T , typename U , Size DIM>
Vector<T, DIM> &	mi::math::operator/= (Vector<T, DIM> &lhs, const Vector<U, DIM> &rhs)
	Divides `lhs` elementwise by `rhs` and returns the modified `lhs`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator+ (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Adds `lhs` and `rhs` elementwise and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator- (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Subtracts `rhs` elementwise from `lhs` and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator* (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Multiplies `rhs` elementwise with `lhs` and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator% (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Computes `lhs` modulo `rhs` elementwise and returns the new result. More...

template<typename T , typename U , Size DIM>
Vector<T, DIM>	mi::math::operator/ (const Vector<T, DIM> &lhs, const Vector<U, DIM> &rhs)
	Divides `rhs` elementwise by `lhs` and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::operator- (const Vector<T, DIM> &v)
	Negates the vector `v` elementwise and returns the new result. More...

template<typename T , typename TT , Size DIM>
Vector<T, DIM> &	mi::math::operator*= (Vector<T, DIM> &v, TT s)
	Multiplies the vector `v` elementwise with the scalar `s` and returns the modified vector `v`. More...

template<typename T , typename TT , Size DIM>
Vector<T, DIM> &	mi::math::operator%= (Vector<T, DIM> &v, TT s)
	Computes `v` modulo `s` elementwise and returns the modified vector `v`. More...

template<typename T , typename TT , Size DIM>
Vector<T, DIM> &	mi::math::operator/= (Vector<T, DIM> &v, TT s)
	Divides the vector `v` elementwise by the scalar `s` and returns the modified vector `v`. More...

template<typename T , typename TT , Size DIM>
Vector<T, DIM>	mi::math::operator* (const Vector_struct<T, DIM> &v, TT s)
	Multiplies the vector `v` elementwise with the scalar `s` and returns the new result. More...

template<typename T , typename TT , Size DIM>
Vector<T, DIM>	mi::math::operator* (TT s, const Vector_struct<T, DIM> &v)
	Multiplies the vector `v` elementwise with the scalar `s` and returns the new result. More...

template<typename T , typename TT , Size DIM>
Vector<T, DIM>	mi::math::operator% (const Vector_struct<T, DIM> &v, TT s)
	Computes `v` modulo `s` elementwise and returns the new result. More...

template<typename T , typename TT , Size DIM>
Vector<T, DIM>	mi::math::operator/ (const Vector_struct<T, DIM> &v, TT s)
	Divides the vector `v` elementwise by the scalar `s` and returns the new result. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator++ (Vector<T, DIM> &vec)
	Pre-increments all elements of `vec` and returns the result. Modifies `vec`. More...

template<typename T , Size DIM>
Vector<T, DIM> &	mi::math::operator-- (Vector<T, DIM> &vec)
	Pre-decrements all elements of `vec` and returns the result. Modifies `vec`. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator&& (const Vector<bool, DIM> &lhs, const Vector<bool, DIM> &rhs)
	Returns the elementwise logical and of two boolean vectors. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator&& (bool lhs, const Vector<bool, DIM> &rhs)
	Returns the elementwise logical and of a bool and a boolean vector. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator&& (const Vector<bool, DIM> &lhs, bool rhs)
	Returns the elementwise logical and of a boolean vector and a bool. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator\|\| (const Vector<bool, DIM> &lhs, const Vector<bool, DIM> &rhs)
	Returns the elementwise logical or of two boolean vectors. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator\|\| (bool lhs, const Vector<bool, DIM> &rhs)
	Returns the elementwise logical or of a bool and a boolean vector. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator\|\| (const Vector<bool, DIM> &lhs, bool rhs)
	Returns the elementwise logical or of a boolean vector and a bool. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator^ (const Vector<bool, DIM> &lhs, const Vector<bool, DIM> &rhs)
	Returns the elementwise logical xor of two boolean vectors. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator^ (bool lhs, const Vector<bool, DIM> &rhs)
	Returns the elementwise logical xor of a bool and a boolean vector. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator^ (const Vector<bool, DIM> &lhs, bool rhs)
	Returns the elementwise logical xor of a boolean vector and a bool. More...

template<Size DIM>
Vector<bool, DIM>	mi::math::operator! (const Vector<bool, DIM> &vec)
	Returns the elementwise logical not of a boolean vector. More...

template<typename T , Size DIM>
Vector<bool, DIM>	mi::math::elementwise_is_equal (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Returns the boolean vector result of an elementwise equality comparison. More...

template<typename T , Size DIM>
Vector<bool, DIM>	mi::math::elementwise_is_not_equal (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Returns the boolean vector result of an elementwise inequality comparison. More...

template<typename T , Size DIM>
Vector<bool, DIM>	mi::math::elementwise_is_less_than (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Returns the boolean vector result of an elementwise less-than comparison. More...

template<typename T , Size DIM>
Vector<bool, DIM>	mi::math::elementwise_is_less_than_or_equal (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Returns the boolean vector result of an elementwise less-than-or-equal comparison. More...

template<typename T , Size DIM>
Vector<bool, DIM>	mi::math::elementwise_is_greater_than (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Returns the boolean vector result of an elementwise greater-than comparison. More...

template<typename T , Size DIM>
Vector<bool, DIM>	mi::math::elementwise_is_greater_than_or_equal (const Vector<T, DIM> &lhs, const Vector<T, DIM> &rhs)
	Returns the boolean vector result of an elementwise greater-than-or-equal comparison. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::abs (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise absolute values of the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::acos (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise arc cosine of the vector `v`. More...

template<typename T , Size DIM>
bool	mi::math::all (const Vector_struct<T, DIM> &v)
	Returns `true` if `all` of all elements of `v` returns `true`. More...

template<typename T , Size DIM>
bool	mi::math::any (const Vector_struct<T, DIM> &v)
	Returns `true` if `any` of any element of `v` returns `true`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::asin (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise arc sine of the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::atan (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise arc tangent of the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::atan2 (const Vector_struct<T, DIM> &v, const Vector_struct<T, DIM> &w)
	Returns a vector with the elementwise arc tangent of the vector `v` / `w`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::ceil (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise smallest integral value that is not less than the element in vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::clamp (const Vector_struct<T, DIM> &v, const Vector_struct<T, DIM> &low, const Vector_struct<T, DIM> &high)
	Returns the vector `v` elementwise clamped to the range [`low`, `high`]. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::clamp (const Vector_struct<T, DIM> &v, const Vector_struct<T, DIM> &low, T high)
	Returns the vector `v` elementwise clamped to the range [`low`, `high`]. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::clamp (const Vector_struct<T, DIM> &v, T low, const Vector_struct<T, DIM> &high)
	Returns the vector `v` elementwise clamped to the range [`low`, `high`]. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::clamp (const Vector_struct<T, DIM> &v, T low, T high)
	Returns the vector `v` elementwise clamped to the range [`low`, `high`]. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::cos (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise cosine of the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::degrees (const Vector_struct<T, DIM> &v)
	Converts elementwise radians in `v` to degrees. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::elementwise_max (const Vector_struct<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Returns elementwise maximum of two vectors. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::elementwise_min (const Vector_struct<T, DIM> &lhs, const Vector_struct<T, DIM> &rhs)
	Returns elementwise minimum of two vectors. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::exp (const Vector_struct<T, DIM> &v)
	Returns a vector with elementwise `e` to the power of the element in the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::exp2 (const Vector_struct<T, DIM> &v)
	Returns a vector with elementwise `2` to the power of the element in the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::floor (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise largest integral value that is not greater than the element in vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::fmod (const Vector_struct<T, DIM> &a, const Vector_struct<T, DIM> &b)
	Returns elementwise `a` modulo `b`, in other words, the remainder of a/b. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::fmod (const Vector_struct<T, DIM> &a, T b)
	Returns elementwise `a` modulo `b`, in other words, the remainder of a/b. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::frac (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise positive fractional part of the vector `v`. More...

template<typename T , Size DIM>
bool	mi::math::is_approx_equal (const Vector_struct<T, DIM> &left, const Vector_struct<T, DIM> &right, T e)
	Compares the two given values elementwise for equality within the given epsilon. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::lerp (const Vector_struct<T, DIM> &v1, const Vector_struct<T, DIM> &v2, const Vector_struct<T, DIM> &t)
	Returns the elementwise linear interpolation between `v1` and `v2`, i.e., it returns `(1-t) * v1 + t * v2`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::lerp (const Vector_struct<T, DIM> &v1, const Vector_struct<T, DIM> &v2, T t)
	Returns the linear interpolation between `v1` and `v2`, i.e., it returns `(1-t) * v1 + t * v2`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::log (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise natural logarithm of the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::log2 (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise base 2 logarithm of the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::log10 (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise base 10 logarithm of the vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::modf (const Vector_struct<T, DIM> &v, Vector<T, DIM> &i)
	Returns the elementwise fractional part of `v` and stores the elementwise integral part of `v` in `i`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::pow (const Vector_struct<T, DIM> &a, const Vector_struct<T, DIM> &b)
	Returns the vector `a` elementwise to the power of `b`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::pow (const Vector_struct<T, DIM> &a, T b)
	Returns the vector `a` elementwise to the power of `b`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::radians (const Vector_struct<T, DIM> &v)
	Converts elementwise degrees in `v` to radians. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::round (const Vector_struct<T, DIM> &v)
	Returns a vector with the elements of vector `v` rounded to nearest integers. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::rsqrt (const Vector_struct<T, DIM> &v)
	Returns the reciprocal of the square root of each element of `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::saturate (const Vector_struct<T, DIM> &v)
	Returns the vector `v` clamped elementwise to the range [0,1]. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::sign (const Vector_struct<T, DIM> &v)
	Returns the elementwise sign of vector `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::sin (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise sine of the vector `v`. More...

template<typename T , Size DIM>
void	mi::math::sincos (const Vector_struct<T, DIM> &a, Vector<T, DIM> &s, Vector<T, DIM> &c)
	Computes elementwise the sine `s` and cosine `c` of angles `a` simultaneously. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::smoothstep (const Vector_struct<T, DIM> &a, const Vector_struct<T, DIM> &b, const Vector_struct<T, DIM> &v)
	Returns 0 if `v` is less than `a` and 1 if `v` is greater than `b` in an elementwise fashion. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::smoothstep (const Vector_struct<T, DIM> &a, const Vector_struct<T, DIM> &b, T x)
	Returns 0 if `x` is less than `a` and 1 if `x` is greater than `b` in an elementwise fashion. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::sqrt (const Vector_struct<T, DIM> &v)
	Returns the square root of each element of `v`. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::step (const Vector_struct<T, DIM> &a, const Vector_struct<T, DIM> &v)
	Returns elementwise 0 if `v` is less than `a` and 1 otherwise. More...

template<typename T , Size DIM>
Vector<T, DIM>	mi::math::tan (const Vector_struct<T, DIM> &v)
	Returns a vector with the elementwise tangent of the vector `v`. More...

template<typename T>
T	mi::math::cross (const Vector_struct<T, 2> &lhs, const Vector_struct<T, 2> &rhs)
	Returns the two-times-two determinant result for the two vectors `lhs` and `rhs`. More...

template<typename T>
Vector<T, 3>	mi::math::cross (const Vector_struct<T, 3> &lhs, const Vector_struct<T, 3> &rhs)
	Returns the three-dimensional cross product result for the two vectors `lhs` and `rhs`. More...

template<typename T>
void	mi::math::make_basis (const Vector<T, 3> &n, Vector<T, 3> u, Vector<T, 3> v)
	Computes a basis of 3D space with one given vector. More...

template<typename T>
void	mi::math::make_basis (const Vector<T, 3> &n, const Vector<T, 3> &u, const Vector<T, 3> &v, Vector<T, 3> t, Vector<T, 3> b)
	Computes a basis of 3D space with one given vector, plane, and direction. More...

template<typename T2 , Size DIM2, typename T1 , Size DIM1>
Vector<T2, DIM2>	mi::math::convert_vector (const Vector<T1, DIM1> &v, const T2 &fill=T2(0))
	Converts the vector `v` of type `Vector<T1, DIM1>` to a vector of type `Vector<T2, DIM2>`. More...

Variables
Float32	mi::math::Color_struct::r
	Red color component. More...

Float32	mi::math::Color_struct::g
	Green color component. More...

Float32	mi::math::Color_struct::b
	Blue color component. More...

Float32	mi::math::Color_struct::a
	Alpha value, 0.0 is fully transparent and 1.0 is opaque; value can lie outside that range. More...

T	mi::math::Vector_struct<T, DIM>::elements [DIM]
	coordinates. More...

T	mi::math::Vector_struct<T, 1>::x
	x-coordinate. More...

T	mi::math::Vector_struct<T, 2>::x
	x-coordinate. More...

T	mi::math::Vector_struct<T, 2>::y
	y-coordinate. More...

T	mi::math::Vector_struct<T, 3>::x
	x-coordinate. More...

T	mi::math::Vector_struct<T, 3>::y
	y-coordinate. More...

T	mi::math::Vector_struct<T, 3>::z
	z-coordinate. More...

T	mi::math::Vector_struct<T, 4>::x
	x-coordinate. More...

T	mi::math::Vector_struct<T, 4>::y
	y-coordinate. More...

T	mi::math::Vector_struct<T, 4>::z
	z-coordinate. More...

T	mi::math::Vector_struct<T, 4>::w
	w-coordinate. More...

static const Size	mi::math::Vector<T, DIM>::DIMENSION = DIM
	Constant dimension of the vector. More...

static const Size	mi::math::Vector<T, DIM>::SIZE = DIM
	Constant size of the vector. More...

Detailed Description

Storage class for math vectors with support for x, y, z, and w members for appropriate dimensions.

Use the mi::math::Vector template in your programs and this storage class only if you need a POD type, for example for parameter passing.

Include File:: #include <mi/math/vector.h>

Typedef Documentation

^◆ const_pointer

template<class T , Size DIM>

typedef const T* mi::math::Vector<T, DIM>::const_pointer

Const pointer to element.

^◆ const_reference

template<class T , Size DIM>

typedef const T& mi::math::Vector<T, DIM>::const_reference

Const reference to element.

^◆ difference_type

template<class T , Size DIM>

typedef Difference mi::math::Vector<T, DIM>::difference_type

Difference type, signed.

^◆ Pod_type

template<class T , Size DIM>

typedef Vector_struct<T,DIM> mi::math::Vector<T, DIM>::Pod_type

POD class corresponding to this vector.

^◆ pointer

template<class T , Size DIM>

typedef T* mi::math::Vector<T, DIM>::pointer

Mutable pointer to element.

^◆ reference

template<class T , Size DIM>

typedef T& mi::math::Vector<T, DIM>::reference

Mutable reference to element.

^◆ size_type

template<class T , Size DIM>

typedef Size mi::math::Vector<T, DIM>::size_type

Size type, unsigned.

^◆ storage_type

template<class T , Size DIM>

typedef Vector_struct<T,DIM> mi::math::Vector<T, DIM>::storage_type

Storage class used by this vector.

^◆ value_type

template<class T , Size DIM>

typedef T mi::math::Vector<T, DIM>::value_type

Element type.

Function Documentation

^◆ abs()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::abs ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise absolute values of the vector v.

^◆ acos()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::acos ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise arc cosine of the vector v.

^◆ all()

template<typename T , Size DIM>

bool mi::math::all ( const Vector_struct<T, DIM> & v )

inline

Returns true if all of all elements of v returns true.

^◆ any()

template<typename T , Size DIM>

bool mi::math::any ( const Vector_struct<T, DIM> & v )

inline

Returns true if any of any element of v returns true.

^◆ asin()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::asin ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise arc sine of the vector v.

^◆ atan()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::atan ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise arc tangent of the vector v.

^◆ atan2()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::atan2	(	const Vector_struct<T, DIM> &	v,
		const Vector_struct<T, DIM> &	w
	)

inline

Returns a vector with the elementwise arc tangent of the vector v / w.

The signs of the elements of v and w are used to determine the quadrant of the results.

^◆ begin() [1/2]

template<class T , Size DIM>

T * mi::math::Vector<T, DIM>::begin ( )

inline

Returns the pointer to the first vector element.

^◆ begin() [2/2]

template<class T , Size DIM>

const T * mi::math::Vector<T, DIM>::begin ( ) const

inline

Returns the pointer to the first vector element.

^◆ ceil()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::ceil ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise smallest integral value that is not less than the element in vector v.

^◆ clamp() [1/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::clamp	(	const Vector_struct<T, DIM> &	v,
		const Vector_struct<T, DIM> &	low,
		const Vector_struct<T, DIM> &	high
	)

inline

Returns the vector v elementwise clamped to the range [low, high].

^◆ clamp() [2/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::clamp	(	const Vector_struct<T, DIM> &	v,
		const Vector_struct<T, DIM> &	low,
		T	high
	)

inline

Returns the vector v elementwise clamped to the range [low, high].

^◆ clamp() [3/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::clamp	(	const Vector_struct<T, DIM> &	v,
		T	low,
		const Vector_struct<T, DIM> &	high
	)

inline

Returns the vector v elementwise clamped to the range [low, high].

^◆ clamp() [4/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::clamp	(	const Vector_struct<T, DIM> &	v,
		T	low,
		T	high
	)

inline

Returns the vector v elementwise clamped to the range [low, high].

^◆ convert_vector()

template<typename T2 , Size DIM2, typename T1 , Size DIM1>

Vector<T2, DIM2> mi::math::convert_vector	(	const Vector<T1, DIM1> &	v,
		const T2 &	fill = `T2(0)`
	)

inline

Converts the vector v of type Vector<T1, DIM1> to a vector of type Vector<T2, DIM2>.

If DIM1 < DIM2, the remaining values are filled with fill. If DIM1 > DIM2, the values that do not fit into the result vector are discarded. The conversion from T1 to T2 must be possible.

^◆ cos()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::cos ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise cosine of the vector v.

^◆ cross() [1/2]

template<typename T>

T mi::math::cross	(	const Vector_struct<T, 2> &	lhs,
		const Vector_struct<T, 2> &	rhs
	)

inline

Returns the two-times-two determinant result for the two vectors lhs and rhs.

^◆ cross() [2/2]

template<typename T>

Vector<T, 3> mi::math::cross	(	const Vector_struct<T, 3> &	lhs,
		const Vector_struct<T, 3> &	rhs
	)

inline

Returns the three-dimensional cross product result for the two vectors lhs and rhs.

^◆ degrees()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::degrees ( const Vector_struct<T, DIM> & v )

inline

Converts elementwise radians in v to degrees.

^◆ elementwise_is_equal()

template<typename T , Size DIM>

Vector<bool, DIM> mi::math::elementwise_is_equal	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Returns the boolean vector result of an elementwise equality comparison.

^◆ elementwise_is_greater_than()

template<typename T , Size DIM>

Vector<bool, DIM> mi::math::elementwise_is_greater_than	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Returns the boolean vector result of an elementwise greater-than comparison.

^◆ elementwise_is_greater_than_or_equal()

template<typename T , Size DIM>

Vector<bool, DIM> mi::math::elementwise_is_greater_than_or_equal	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Returns the boolean vector result of an elementwise greater-than-or-equal comparison.

^◆ elementwise_is_less_than()

template<typename T , Size DIM>

Vector<bool, DIM> mi::math::elementwise_is_less_than	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Returns the boolean vector result of an elementwise less-than comparison.

^◆ elementwise_is_less_than_or_equal()

template<typename T , Size DIM>

Vector<bool, DIM> mi::math::elementwise_is_less_than_or_equal	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Returns the boolean vector result of an elementwise less-than-or-equal comparison.

^◆ elementwise_is_not_equal()

template<typename T , Size DIM>

Vector<bool, DIM> mi::math::elementwise_is_not_equal	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Returns the boolean vector result of an elementwise inequality comparison.

^◆ elementwise_max()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::elementwise_max	(	const Vector_struct<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Returns elementwise maximum of two vectors.

^◆ elementwise_min()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::elementwise_min	(	const Vector_struct<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Returns elementwise minimum of two vectors.

^◆ end() [1/2]

template<class T , Size DIM>

T * mi::math::Vector<T, DIM>::end ( )

inline

Returns the past-the-end pointer.

The range [begin(),end()) forms the range over all vector elements.

^◆ end() [2/2]

template<class T , Size DIM>

const T * mi::math::Vector<T, DIM>::end ( ) const

inline

Returns the past-the-end pointer.

The range [begin(),end()) forms the range over all vector elements.

^◆ exp()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::exp ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with elementwise e to the power of the element in the vector v.

^◆ exp2()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::exp2 ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with elementwise 2 to the power of the element in the vector v.

^◆ floor()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::floor ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise largest integral value that is not greater than the element in vector v.

^◆ fmod() [1/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::fmod	(	const Vector_struct<T, DIM> &	a,
		const Vector_struct<T, DIM> &	b
	)

inline

Returns elementwise a modulo b, in other words, the remainder of a/b.

The elementwise result has the same sign as a.

^◆ fmod() [2/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::fmod	(	const Vector_struct<T, DIM> &	a,
		T	b
	)

inline

Returns elementwise a modulo b, in other words, the remainder of a/b.

The elementwise result has the same sign as a.

^◆ frac()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::frac ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise positive fractional part of the vector v.

^◆ get()

template<class T , Size DIM>

const T & mi::math::Vector<T, DIM>::get ( Size i ) const

inline

Returns the i-th vector element.

Precondition: 0 <= i < size()

^◆ is_approx_equal()

template<typename T , Size DIM>

bool mi::math::is_approx_equal	(	const Vector_struct<T, DIM> &	left,
		const Vector_struct<T, DIM> &	right,
		T	e
	)

inline

Compares the two given values elementwise for equality within the given epsilon.

^◆ lerp() [1/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::lerp	(	const Vector_struct<T, DIM> &	v1,
		const Vector_struct<T, DIM> &	v2,
		const Vector_struct<T, DIM> &	t
	)

inline

Returns the elementwise linear interpolation between v1 and v2, i.e., it returns (1-t) * v1 + t * v2.

Parameters

v1	one vector
v2	second vector
t	interpolation parameter in [0,1]

^◆ lerp() [2/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::lerp	(	const Vector_struct<T, DIM> &	v1,
		const Vector_struct<T, DIM> &	v2,
		T	t
	)

inline

Returns the linear interpolation between v1 and v2, i.e., it returns (1-t) * v1 + t * v2.

Parameters

v1	one vector
v2	second vector
t	interpolation parameter in [0,1]

^◆ log()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::log ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise natural logarithm of the vector v.

^◆ log10()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::log10 ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise base 10 logarithm of the vector v.

^◆ log2()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::log2 ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise base 2 logarithm of the vector v.

^◆ make_basis() [1/2]

template<typename T>

void mi::math::make_basis	(	const Vector<T, 3> &	n,
		const Vector<T, 3> &	u,
		const Vector<T, 3> &	v,
		Vector<T, 3> *	t,
		Vector<T, 3> *	b
	)

inline

Computes a basis of 3D space with one given vector, plane, and direction.

Given a unit length vector n, and two non-colinear and non-zero vectors u and v, this function computes two vectors t and b such that (t, n, b) forms an orthonormal basis (t and b are unit length), t lies in the plane formed by n and u, and b has the same orientation as v, i.e., dot(b, v) >= 0.

Parameters

n	input, normal vector
u	input, first direction vector
v	input, second direction vector
t	output, first vector in tangent plane
b	output, second vector in tangent plane

^◆ make_basis() [2/2]

template<typename T>

void mi::math::make_basis	(	const Vector<T, 3> &	n,
		Vector<T, 3> *	u,
		Vector<T, 3> *	v
	)

inline

Computes a basis of 3D space with one given vector.

Given a unit length vector n, computes two vectors u and v such that (u, n, v) forms an orthonormal basis (u and v are unit length). This function is not continuous with respect to n: in some cases, a small perturbation on n will flip the basis.

Parameters

n	input, normal vector
u	output, first vector in tangent plane
v	output, second vector in tangent plane

^◆ max_size()

template<class T , Size DIM>

static Size mi::math::Vector<T, DIM>::max_size ( )

inlinestatic

Constant maximum size of the vector.

^◆ modf()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::modf	(	const Vector_struct<T, DIM> &	v,
		Vector<T, DIM> &	i
	)

inline

Returns the elementwise fractional part of v and stores the elementwise integral part of v in i.

Both parts have elementwise the same sign as v.

^◆ normalize()

template<class T , Size DIM>

bool mi::math::Vector<T, DIM>::normalize ( )

inline

Normalizes this vector to unit length.

Returns false if normalization fails because the vector norm is zero, and true otherwise. This vector remains unchanged if normalization failed.

Uses an unqualified call to sqrt(...) on the vector element type.

^◆ operator!()

template<Size DIM>

Vector<bool, DIM> mi::math::operator! ( const Vector<bool, DIM> & vec )

inline

Returns the elementwise logical not of a boolean vector.

^◆ operator!=()

template<class T , Size DIM>

bool mi::math::Vector<T, DIM>::operator!= ( Vector<T, DIM> rhs ) const

inline

Returns true if lhs is elementwise not equal to rhs.

^◆ operator%() [1/3]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator%	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Computes lhs modulo rhs elementwise and returns the new result.

Only defined for typenames T having the % operator.

^◆ operator%() [2/3]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator%	(	const Vector_struct<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Computes lhs modulo rhs elementwise and returns the new result.

Only defined for typenames T having the % operator.

^◆ operator%() [3/3]

template<typename T , typename TT , Size DIM>

Vector<T, DIM> mi::math::operator%	(	const Vector_struct<T, DIM> &	v,
		TT	s
	)

inline

Computes v modulo s elementwise and returns the new result.

Only defined for typenames T having the % operator for TT arguments.

^◆ operator%=() [1/3]

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator%=	(	Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Computes lhs modulo rhs elementwise and returns the modified lhs.

Only defined for typenames T having the % operator.

^◆ operator%=() [2/3]

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator%=	(	Vector<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Computes lhs modulo rhs elementwise and returns the modified lhs.

Only defined for typenames T having the % operator.

^◆ operator%=() [3/3]

template<typename T , typename TT , Size DIM>

Vector<T, DIM> & mi::math::operator%=	(	Vector<T, DIM> &	v,
		TT	s
	)

inline

Computes v modulo s elementwise and returns the modified vector v.

Only defined for typenames T having the % operator for TT arguments.

^◆ operator&&() [1/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator&&	(	bool	lhs,
		const Vector<bool, DIM> &	rhs
	)

inline

Returns the elementwise logical and of a bool and a boolean vector.

^◆ operator&&() [2/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator&&	(	const Vector<bool, DIM> &	lhs,
		bool	rhs
	)

inline

Returns the elementwise logical and of a boolean vector and a bool.

^◆ operator&&() [3/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator&&	(	const Vector<bool, DIM> &	lhs,
		const Vector<bool, DIM> &	rhs
	)

inline

Returns the elementwise logical and of two boolean vectors.

^◆ operator*() [1/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator*	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Multiplies rhs elementwise with lhs and returns the new result.

^◆ operator*() [2/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator*	(	const Vector_struct<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Multiplies rhs elementwise with lhs and returns the new result.

^◆ operator*() [3/4]

template<typename T , typename TT , Size DIM>

Vector<T, DIM> mi::math::operator*	(	const Vector_struct<T, DIM> &	v,
		TT	s
	)

inline

Multiplies the vector v elementwise with the scalar s and returns the new result.

^◆ operator*() [4/4]

template<typename T , typename TT , Size DIM>

Vector<T, DIM> mi::math::operator*	(	TT	s,
		const Vector_struct<T, DIM> &	v
	)

inline

Multiplies the vector v elementwise with the scalar s and returns the new result.

^◆ operator*=() [1/3]

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator*=	(	Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Multiplies rhs elementwise with lhs and returns the modified lhs.

^◆ operator*=() [2/3]

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator*=	(	Vector<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Multiplies rhs elementwise with lhs and returns the modified lhs.

^◆ operator*=() [3/3]

template<typename T , typename TT , Size DIM>

Vector<T, DIM> & mi::math::operator*=	(	Vector<T, DIM> &	v,
		TT	s
	)

inline

Multiplies the vector v elementwise with the scalar s and returns the modified vector v.

^◆ operator+() [1/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator+	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Adds lhs and rhs elementwise and returns the new result.

^◆ operator+() [2/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator+	(	const Vector_struct<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Adds lhs and rhs elementwise and returns the new result.

^◆ operator++()

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator++ ( Vector<T, DIM> & vec )

inline

Pre-increments all elements of vec and returns the result. Modifies vec.

^◆ operator+=() [1/2]

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator+=	(	Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Adds rhs elementwise to lhs and returns the modified lhs.

^◆ operator+=() [2/2]

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator+=	(	Vector<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Adds rhs elementwise to lhs and returns the modified lhs.

^◆ operator-() [1/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator-	(	const Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Subtracts rhs elementwise from lhs and returns the new result.

^◆ operator-() [2/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator- ( const Vector<T, DIM> & v )

inline

Negates the vector v elementwise and returns the new result.

^◆ operator-() [3/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator-	(	const Vector_struct<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Subtracts rhs elementwise from lhs and returns the new result.

^◆ operator-() [4/4]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::operator- ( const Vector_struct<T, DIM> & v )

inline

Negates the vector v elementwise and returns the new result.

^◆ operator--()

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator-- ( Vector<T, DIM> & vec )

inline

Pre-decrements all elements of vec and returns the result. Modifies vec.

^◆ operator-=() [1/2]

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator-=	(	Vector<T, DIM> &	lhs,
		const Vector<T, DIM> &	rhs
	)

inline

Subtracts rhs elementwise from lhs and returns the modified lhs.

^◆ operator-=() [2/2]

template<typename T , Size DIM>

Vector<T, DIM> & mi::math::operator-=	(	Vector<T, DIM> &	lhs,
		const Vector_struct<T, DIM> &	rhs
	)

inline

Subtracts rhs elementwise from lhs and returns the modified lhs.

^◆ operator/() [1/3]

template<typename T , typename U , Size DIM>

Vector<T, DIM> mi::math::operator/	(	const Vector<T, DIM> &	lhs,
		const Vector<U, DIM> &	rhs
	)

inline

Divides rhs elementwise by lhs and returns the new result.

^◆ operator/() [2/3]

template<typename T , typename U , Size DIM>

Vector<T, DIM> mi::math::operator/	(	const Vector_struct<T, DIM> &	lhs,
		const Vector_struct<U, DIM> &	rhs
	)

inline

Divides rhs elementwise by lhs and returns the new result.

^◆ operator/() [3/3]

template<typename T , typename TT , Size DIM>

Vector<T, DIM> mi::math::operator/	(	const Vector_struct<T, DIM> &	v,
		TT	s
	)

inline

Divides the vector v elementwise by the scalar s and returns the new result.

^◆ operator/=() [1/3]

template<typename T , typename U , Size DIM>

Vector<T, DIM> & mi::math::operator/=	(	Vector<T, DIM> &	lhs,
		const Vector<U, DIM> &	rhs
	)

inline

Divides lhs elementwise by rhs and returns the modified lhs.

^◆ operator/=() [2/3]

template<typename T , typename U , Size DIM>

Vector<T, DIM> & mi::math::operator/=	(	Vector<T, DIM> &	lhs,
		const Vector_struct<U, DIM> &	rhs
	)

inline

Divides lhs elementwise by rhs and returns the modified lhs.

^◆ operator/=() [3/3]

template<typename T , typename TT , Size DIM>

Vector<T, DIM> & mi::math::operator/=	(	Vector<T, DIM> &	v,
		TT	s
	)

inline

Divides the vector v elementwise by the scalar s and returns the modified vector v.

^◆ operator<()

template<class T , Size DIM>

bool mi::math::Vector<T, DIM>::operator< ( Vector<T, DIM> rhs ) const

inline

Returns true if lhs is lexicographically less than rhs.

See also: Definition: Lexicographic order and comparison

^◆ operator<=()

template<class T , Size DIM>

bool mi::math::Vector<T, DIM>::operator<= ( Vector<T, DIM> rhs ) const

inline

Returns true if lhs is lexicographically less than or equal to rhs.

See also: Definition: Lexicographic order and comparison

^◆ operator=() [1/3]

template<class T , Size DIM>

Vector & mi::math::Vector<T, DIM>::operator= ( const Color_struct & color )

inline

Assignment, for dimension 4 only, that assigns color interpreted as a vector (r,g,b,a) to this vector.

Precondition: DIM == 4

^◆ operator=() [2/3]

template<class T , Size DIM>

Vector & mi::math::Vector<T, DIM>::operator= ( const Vector<T, DIM> & other )

default

Assignment.

^◆ operator=() [3/3]

template<class T , Size DIM>

Vector & mi::math::Vector<T, DIM>::operator= ( T s )

inline

Assignment from a scalar, setting all elements to s.

^◆ operator==()

template<class T , Size DIM>

bool mi::math::Vector<T, DIM>::operator== ( Vector<T, DIM> rhs ) const

inline

Returns true if lhs is elementwise equal to rhs.

^◆ operator>()

template<class T , Size DIM>

bool mi::math::Vector<T, DIM>::operator> ( Vector<T, DIM> rhs ) const

inline

Returns true if lhs is lexicographically greater than rhs.

See also: Definition: Lexicographic order and comparison

^◆ operator>=()

template<class T , Size DIM>

bool mi::math::Vector<T, DIM>::operator>= ( Vector<T, DIM> rhs ) const

inline

Returns true if lhs is lexicographically greater than or equal to rhs.

See also: Definition: Lexicographic order and comparison

^◆ operator[]() [1/2]

template<class T , Size DIM>

T & mi::math::Vector<T, DIM>::operator[] ( Size i )

inline

Accesses the i-th vector element.

Precondition: 0 <= i < size()

^◆ operator[]() [2/2]

template<class T , Size DIM>

const T & mi::math::Vector<T, DIM>::operator[] ( Size i ) const

inline

Accesses the i-th vector element.

Precondition: 0 <= i < size()

^◆ operator^() [1/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator^	(	bool	lhs,
		const Vector<bool, DIM> &	rhs
	)

inline

Returns the elementwise logical xor of a bool and a boolean vector.

^◆ operator^() [2/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator^	(	const Vector<bool, DIM> &	lhs,
		bool	rhs
	)

inline

Returns the elementwise logical xor of a boolean vector and a bool.

^◆ operator^() [3/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator^	(	const Vector<bool, DIM> &	lhs,
		const Vector<bool, DIM> &	rhs
	)

inline

Returns the elementwise logical xor of two boolean vectors.

^◆ operator||() [1/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator\|\|	(	bool	lhs,
		const Vector<bool, DIM> &	rhs
	)

inline

Returns the elementwise logical or of a bool and a boolean vector.

^◆ operator||() [2/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator\|\|	(	const Vector<bool, DIM> &	lhs,
		bool	rhs
	)

inline

Returns the elementwise logical or of a boolean vector and a bool.

^◆ operator||() [3/3]

template<Size DIM>

Vector<bool, DIM> mi::math::operator\|\|	(	const Vector<bool, DIM> &	lhs,
		const Vector<bool, DIM> &	rhs
	)

inline

Returns the elementwise logical or of two boolean vectors.

^◆ pow() [1/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::pow	(	const Vector_struct<T, DIM> &	a,
		const Vector_struct<T, DIM> &	b
	)

inline

Returns the vector a elementwise to the power of b.

^◆ pow() [2/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::pow	(	const Vector_struct<T, DIM> &	a,
		T	b
	)

inline

Returns the vector a elementwise to the power of b.

^◆ radians()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::radians ( const Vector_struct<T, DIM> & v )

inline

Converts elementwise degrees in v to radians.

^◆ round()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::round ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elements of vector v rounded to nearest integers.

^◆ rsqrt()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::rsqrt ( const Vector_struct<T, DIM> & v )

inline

Returns the reciprocal of the square root of each element of v.

^◆ saturate()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::saturate ( const Vector_struct<T, DIM> & v )

inline

Returns the vector v clamped elementwise to the range [0,1].

^◆ set()

template<class T , Size DIM>

void mi::math::Vector<T, DIM>::set	(	Size	i,
		T	value
	)

inline

Sets the i-th vector element to value.

Precondition: 0 <= i < size()

^◆ sign()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::sign ( const Vector_struct<T, DIM> & v )

inline

Returns the elementwise sign of vector v.

^◆ sin()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::sin ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise sine of the vector v.

^◆ sincos()

template<typename T , Size DIM>

void mi::math::sincos	(	const Vector_struct<T, DIM> &	a,
		Vector<T, DIM> &	s,
		Vector<T, DIM> &	c
	)

inline

Computes elementwise the sine s and cosine c of angles a simultaneously.

The angles a are specified in radians.

^◆ size()

template<class T , Size DIM>

static Size mi::math::Vector<T, DIM>::size ( )

inlinestatic

Constant size of the vector.

^◆ smoothstep() [1/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::smoothstep	(	const Vector_struct<T, DIM> &	a,
		const Vector_struct<T, DIM> &	b,
		const Vector_struct<T, DIM> &	v
	)

inline

Returns 0 if v is less than a and 1 if v is greater than b in an elementwise fashion.

A smooth curve is applied in-between so that the return values vary continuously from 0 to 1 as elements in v vary from a to b.

^◆ smoothstep() [2/2]

template<typename T , Size DIM>

Vector<T, DIM> mi::math::smoothstep	(	const Vector_struct<T, DIM> &	a,
		const Vector_struct<T, DIM> &	b,
		T	x
	)

inline

Returns 0 if x is less than a and 1 if x is greater than b in an elementwise fashion.

A smooth curve is applied in-between so that the return values vary continuously from 0 to 1 as x varies from a to b.

^◆ sqrt()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::sqrt ( const Vector_struct<T, DIM> & v )

inline

Returns the square root of each element of v.

^◆ step()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::step	(	const Vector_struct<T, DIM> &	a,
		const Vector_struct<T, DIM> &	v
	)

inline

Returns elementwise 0 if v is less than a and 1 otherwise.

^◆ tan()

template<typename T , Size DIM>

Vector<T, DIM> mi::math::tan ( const Vector_struct<T, DIM> & v )

inline

Returns a vector with the elementwise tangent of the vector v.

^◆ Vector() [1/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector ( )

inline

The default constructor leaves the vector elements uninitialized.

^◆ Vector() [2/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector ( const Color_struct & color )

inlineexplicit

Dedicated constructor, for dimension 4 only, that initializes the vector elements from a color interpreted as a vector (r,g,b,a).

Precondition: DIM == 4

^◆ Vector() [3/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	const Vector<T, 2> &	v1,
		const Vector<T, 2> &	v2
	)

inline

Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1.x,v1.y,v2.x,v2.y).

Precondition: DIM == 4

^◆ Vector() [4/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	const Vector<T, 2> &	v1,
		T	v2
	)

inline

Dedicated constructor, for dimension 3 only, that initializes the vector elements from the three elements (v1.x,v1.y,v2).

Precondition: DIM == 3

^◆ Vector() [5/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	const Vector<T, 2> &	v1,
		T	v2,
		T	v3
	)

inline

Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1.x,v1.y,v2,v3).

Precondition: DIM == 4

^◆ Vector() [6/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	const Vector<T, 3> &	v1,
		T	v2
	)

inline

Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1.x,v1.y,v1.z,v2).

Precondition: DIM == 4

^◆ Vector() [7/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector ( const Vector<T, DIM> & vec )

default

Default copy constructor.

^◆ Vector() [8/20]

template<class T , Size DIM>

template<typename T2>

mi::math::Vector<T, DIM>::Vector ( const Vector<T2, DIM> & other )

inlineexplicit

Template constructor that allows explicit conversions from other vectors with assignment compatible element value type.

^◆ Vector() [9/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector ( const Vector_struct<T, DIM> & vec )

inline

Constructor from underlying storage type.

^◆ Vector() [10/20]

template<class T , Size DIM>

template<typename T2>

mi::math::Vector<T, DIM>::Vector ( const Vector_struct<T2, DIM> & other )

inlineexplicit

Template constructor that allows explicit conversions from underlying storage type with assignment compatible element value type.

^◆ Vector() [11/20]

template<class T , Size DIM>

template<typename Iterator>

mi::math::Vector<T, DIM>::Vector	(	From_iterator_tag	,
		Iterator	p
	)

inline

Constructor requires the mi::math::FROM_ITERATOR tag as first argument and initializes the vector elements with the first DIM elements from the sequence starting at the iterator p.

Iterator must be a model of an input iterator. The value type of Iterator must be assignment compatible with the vector elements type T.

An example:

std::vector<int> data( 10, 42); // ten elements of value 42

mi::math::Vector<mi::Float64, 3> vec( mi::math::FROM_ITERATOR, data.begin());

mi::math::Vector

Fixed-size math vector class template with generic operations.

Definition: vector.h:286

mi::math::FROM_ITERATOR

@ FROM_ITERATOR

Unique enumerator of From_iterator_tag.

Definition: vector.h:37

^◆ Vector() [12/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector ( T v )

inlineexplicit

Constructor initializes all vector elements to the value v.

^◆ Vector() [13/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	T	v1,
		const Vector<T, 2> &	v2
	)

inline

Dedicated constructor, for dimension 3 only, that initializes the vector elements from the three elements (v1,v2.x,v2.y).

Precondition: DIM == 3

^◆ Vector() [14/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	T	v1,
		const Vector<T, 2> &	v2,
		T	v3
	)

inline

Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1,v2.x,v2.y,v3).

Precondition: DIM == 4

^◆ Vector() [15/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	T	v1,
		const Vector<T, 3> &	v2
	)

inline

Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1,v2.x,v2.y,v2.z).

Precondition: DIM == 4

^◆ Vector() [16/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	T	v1,
		T	v2
	)

inline

Dedicated constructor, for dimension 2 only, that initializes the vector elements from the two elements (v1,v2).

Precondition: DIM == 2

^◆ Vector() [17/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	T	v1,
		T	v2,
		const Vector<T, 2> &	v3
	)

inline

Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1,v2,v3.x,v3.y).

Precondition: DIM == 4

^◆ Vector() [18/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	T	v1,
		T	v2,
		T	v3
	)

inline

Dedicated constructor, for dimension 3 only, that initializes the vector elements from the three elements (v1,v2,v3).

Precondition: DIM == 3

^◆ Vector() [19/20]

template<class T , Size DIM>

mi::math::Vector<T, DIM>::Vector	(	T	v1,
		T	v2,
		T	v3,
		T	v4
	)

inline

Dedicated constructor, for dimension 4 only, that initializes the vector elements from the four elements (v1,v2,v3,v4).

Precondition: DIM == 4

^◆ Vector() [20/20]

template<class T , Size DIM>

template<typename T2>

mi::math::Vector<T, DIM>::Vector ( T2 const (&) array[DIM] )

inlineexplicit

Constructor initializes the vector elements from an array of dimension DIM.

The value type T2 of the array must be assignment compatible with the vector elements type T.

An example:

int data[3] = { 1, 2, 4};

mi::math::Vector<mi::Float64, 3> vec( data);

^◆ vector_base_ptr() [1/10]

template<typename T>

const T * mi::math::vector_base_ptr ( const Vector_struct<T, 1> & vec )

inline

Returns the base pointer to the vector data, specialization for DIM==1.

^◆ vector_base_ptr() [2/10]

template<typename T>

const T * mi::math::vector_base_ptr ( const Vector_struct<T, 2> & vec )

inline

Returns the base pointer to the vector data, specialization for DIM==2.

^◆ vector_base_ptr() [3/10]

template<typename T>

const T * mi::math::vector_base_ptr ( const Vector_struct<T, 3> & vec )

inline

Returns the base pointer to the vector data, specialization for DIM==3.

^◆ vector_base_ptr() [4/10]

template<typename T>

const T * mi::math::vector_base_ptr ( const Vector_struct<T, 4> & vec )

inline

Returns the base pointer to the vector data, specialization for DIM==4.

^◆ vector_base_ptr() [5/10]

template<typename T , Size DIM>

const T * mi::math::vector_base_ptr ( const Vector_struct<T, DIM> & vec )

inline

Returns the base pointer to the vector data.

^◆ vector_base_ptr() [6/10]

template<typename T>

T * mi::math::vector_base_ptr ( Vector_struct<T, 1> & vec )

inline

Returns the base pointer to the vector data, specialization for DIM==1.

^◆ vector_base_ptr() [7/10]

template<typename T>

T * mi::math::vector_base_ptr ( Vector_struct<T, 2> & vec )

inline

Returns the base pointer to the vector data, specialization for DIM==2.

^◆ vector_base_ptr() [8/10]

template<typename T>

T * mi::math::vector_base_ptr ( Vector_struct<T, 3> & vec )

inline

Returns the base pointer to the vector data, specialization for DIM==3.

^◆ vector_base_ptr() [9/10]

template<typename T>

T * mi::math::vector_base_ptr ( Vector_struct<T, 4> & vec )

inline

Returns the base pointer to the vector data, specialization for DIM==4.

^◆ vector_base_ptr() [10/10]

template<typename T , Size DIM>

T * mi::math::vector_base_ptr ( Vector_struct<T, DIM> & vec )

inline

Returns the base pointer to the vector data.

Variable Documentation

^◆ a

Float32 mi::math::Color_struct::a

Alpha value, 0.0 is fully transparent and 1.0 is opaque; value can lie outside that range.

^◆ b

Float32 mi::math::Color_struct::b

Blue color component.

^◆ DIMENSION

template<class T , Size DIM>

const Size mi::math::Vector<T, DIM>::DIMENSION = DIM

static

Constant dimension of the vector.

^◆ elements

template<typename T , Size DIM>

T mi::math::Vector_struct<T, DIM>::elements[DIM]

coordinates.

^◆ g

Float32 mi::math::Color_struct::g

Green color component.

^◆ r

Float32 mi::math::Color_struct::r

Red color component.

^◆ SIZE

template<class T , Size DIM>

const Size mi::math::Vector<T, DIM>::SIZE = DIM

static

Constant size of the vector.

^◆ w

template<typename T>

T mi::math::Vector_struct<T, 4>::w

w-coordinate.

^◆ x [1/4]

template<typename T>

T mi::math::Vector_struct<T, 1>::x

x-coordinate.

^◆ x [2/4]

template<typename T>

T mi::math::Vector_struct<T, 2>::x

x-coordinate.

^◆ x [3/4]

template<typename T>

T mi::math::Vector_struct<T, 3>::x

x-coordinate.

^◆ x [4/4]

template<typename T>

T mi::math::Vector_struct<T, 4>::x

x-coordinate.

^◆ y [1/3]

template<typename T>

T mi::math::Vector_struct<T, 2>::y

y-coordinate.

^◆ y [2/3]

template<typename T>

T mi::math::Vector_struct<T, 3>::y

y-coordinate.

^◆ y [3/3]

template<typename T>

T mi::math::Vector_struct<T, 4>::y

y-coordinate.

^◆ z [1/2]

template<typename T>

T mi::math::Vector_struct<T, 3>::z

z-coordinate.

^◆ z [2/2]

template<typename T>

T mi::math::Vector_struct<T, 4>::z

z-coordinate.

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ const_pointer

◆ const_reference

◆ difference_type

◆ Pod_type

◆ pointer

◆ reference

◆ size_type

◆ storage_type

◆ value_type

Function Documentation

◆ abs()

◆ acos()

◆ all()

◆ any()

◆ asin()

◆ atan()

◆ atan2()

◆ begin() [1/2]

◆ begin() [2/2]

◆ ceil()

◆ clamp() [1/4]

◆ clamp() [2/4]

◆ clamp() [3/4]

◆ clamp() [4/4]

◆ convert_vector()

◆ cos()

◆ cross() [1/2]

◆ cross() [2/2]

◆ degrees()

◆ elementwise_is_equal()

◆ elementwise_is_greater_than()

◆ elementwise_is_greater_than_or_equal()

◆ elementwise_is_less_than()

◆ elementwise_is_less_than_or_equal()

◆ elementwise_is_not_equal()

◆ elementwise_max()

◆ elementwise_min()

◆ end() [1/2]

◆ end() [2/2]

◆ exp()

◆ exp2()

◆ floor()

◆ fmod() [1/2]

◆ fmod() [2/2]

◆ frac()

◆ get()

◆ is_approx_equal()

◆ lerp() [1/2]

◆ lerp() [2/2]

◆ log()

◆ log10()

◆ log2()

◆ make_basis() [1/2]

◆ make_basis() [2/2]

◆ max_size()

◆ modf()

◆ normalize()

◆ operator!()

◆ operator!=()

◆ operator%() [1/3]

◆ operator%() [2/3]

◆ operator%() [3/3]

◆ operator%=() [1/3]

◆ operator%=() [2/3]

◆ operator%=() [3/3]

◆ operator&&() [1/3]

◆ operator&&() [2/3]

◆ operator&&() [3/3]

◆ operator*() [1/4]

◆ operator*() [2/4]

◆ operator*() [3/4]

◆ operator*() [4/4]

◆ operator*=() [1/3]

◆ operator*=() [2/3]

^◆ const_pointer

^◆ const_reference

^◆ difference_type

^◆ Pod_type

^◆ pointer

^◆ reference

^◆ size_type

^◆ storage_type

^◆ value_type

^◆ abs()

^◆ acos()

^◆ all()

^◆ any()

^◆ asin()

^◆ atan()

^◆ atan2()

^◆ begin() [1/2]

^◆ begin() [2/2]

^◆ ceil()

^◆ clamp() [1/4]

^◆ clamp() [2/4]

^◆ clamp() [3/4]

^◆ clamp() [4/4]

^◆ convert_vector()

^◆ cos()

^◆ cross() [1/2]

^◆ cross() [2/2]

^◆ degrees()

^◆ elementwise_is_equal()

^◆ elementwise_is_greater_than()

^◆ elementwise_is_greater_than_or_equal()

^◆ elementwise_is_less_than()

^◆ elementwise_is_less_than_or_equal()

^◆ elementwise_is_not_equal()

^◆ elementwise_max()

^◆ elementwise_min()

^◆ end() [1/2]

^◆ end() [2/2]

^◆ exp()

^◆ exp2()

^◆ floor()

^◆ fmod() [1/2]

^◆ fmod() [2/2]

^◆ frac()

^◆ get()

^◆ is_approx_equal()

^◆ lerp() [1/2]

^◆ lerp() [2/2]

^◆ log()

^◆ log10()

^◆ log2()

^◆ make_basis() [1/2]

^◆ make_basis() [2/2]

^◆ max_size()

^◆ modf()

^◆ normalize()

^◆ operator!()

^◆ operator!=()

^◆ operator%() [1/3]

^◆ operator%() [2/3]

^◆ operator%() [3/3]

^◆ operator%=() [1/3]

^◆ operator%=() [2/3]

^◆ operator%=() [3/3]

^◆ operator&&() [1/3]

^◆ operator&&() [2/3]

^◆ operator&&() [3/3]

^◆ operator*() [1/4]

^◆ operator*() [2/4]

^◆ operator*() [3/4]

^◆ operator*() [4/4]

^◆ operator*=() [1/3]

^◆ operator*=() [2/3]

^◆ operator*=() [3/3]

^◆ operator+() [1/2]

^◆ operator+() [2/2]

^◆ operator++()

^◆ operator+=() [1/2]

^◆ operator+=() [2/2]

^◆ operator-() [1/4]