Collaboration diagram for Vector4D Types:

Modules
	4D Vector Algebra

	Checks

	Assertions

Classes
struct	BasicVector4D< Type >::BasicRef< RType >

Typedefs
using	Ref = BasicRef< Type >

using	ConstRef = BasicRef< const Type >

Functions
constexpr	BasicRef (RType &x_in, RType &y_in, RType &z_in, RType &w_in)

constexpr	BasicRef (const BasicRef &)=default

constexpr	BasicRef (const BasicVector4D< RType > &other)

constexpr BasicRef &	operator= (BasicRef input)

constexpr BasicRef &	operator= (const BasicVector4D< RType > &input)

constexpr	operator BasicVector4D< RType > () const

constexpr	operator std::tuple< RType, RType, RType, RType > () const

constexpr value_type	normSquared () const

constexpr value_type	norm () const

constexpr value_type	magnitudeSquared () const

constexpr value_type	magnitude () const

constexpr BasicVector4D< Type >	normalized () const

Variables
RType &	x

RType &	y

RType &	z

RType &	w

Friends
template<class U > requires Concept::SameUnqualified<RType, U>
constexpr bool	operator== (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr bool	operator== (BasicRef left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator+ (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator+ (BasicRef left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator- (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator- (BasicRef left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator* (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator* (BasicRef left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator* (BasicRef left, const U &scalar)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator* (const U &scalar, BasicRef right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator/ (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator/ (BasicRef left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	operator/ (BasicRef left, const U &scalar)

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
constexpr bool	approximately_equal_to (BasicRef value_to_test, BasicRef< U > value_it_should_be, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
constexpr bool	approximately_equal_to (BasicRef value_to_test, const BasicVector4D< U > &value_it_should_be, OT tolerance=OT{0.0002})

constexpr RType	accumulate (BasicRef input)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr RType	dot (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr RType	dot (BasicRef left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr RType	dot_normalized (BasicRef left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr RType	dot_normalized (BasicRef left, const BasicVector4D< U > &right)

constexpr BasicVector4D< RType >	normalized (BasicRef input)

constexpr BasicVector4D< RType >	abs (BasicRef input)

BasicVector4D< RType >	fract (BasicRef input)

constexpr BasicVector4D< RType >	saturate (BasicRef input, RType lower_bound, RType upper_bound)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	lerp (BasicRef input_lower_bound, BasicRef< U > input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	lerp (BasicRef input_lower_bound, BasicVector4D< U > &input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	mix (BasicRef input_lower_bound, BasicRef< U > input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<RType, U>
constexpr BasicVector4D< RType >	mix (BasicRef input_lower_bound, BasicVector4D< U > &input_upper_bound, float percentage_zero_to_one)

std::string	format (BasicRef input)

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
bool	check_if_equal (BasicRef input, BasicRef< U > near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
bool	check_if_equal (BasicRef input, const BasicVector4D< U > &near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
bool	check_if_not_equal (BasicRef input, BasicRef near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
bool	check_if_not_equal (BasicRef input, const BasicVector4D< U > &near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
void	CHECK_IF_NOT_EQUAL (BasicRef input, BasicRef< U > near_to, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<RType, U>
void	CHECK_IF_NOT_EQUAL (BasicRef input, const BasicVector4D< U > &near_to, OT tolerance=OT{0.0002})

template<std::floating_point OT = float>
void	CHECK_IF_ZERO (BasicRef input, OT tolerance=OT{0.0002})

Types
using	value_type = Type
	The underlying implementation type.

Types
using	value_type = RType
	The underlying implementation type.

Type Aliases
using	Vector4Df = BasicVector4D< float >

using	Vector4Dd = BasicVector4D< double >

using	Vector4D = BasicVector4D< double >

using	Vector4Dl = BasicVector4D< long double >

Element Access
value_type	x {}

value_type	y {}

value_type	z {}

value_type	w {}

Constructors
constexpr	BasicVector4D ()=default

constexpr	BasicVector4D (const Type &x_in, const Type &y_in=0, const Type &z_in=0, const Type &w_in=0)

constexpr	BasicVector4D (const BasicVector3D< Type > &first3, const Type &w_in=0)

constexpr	BasicVector4D (const BasicVector2D< Type > &first2, const BasicVector2D< Type > &second2)

constexpr	BasicVector4D (const Type &x_in, const BasicVector3D< Type > &last3)

Assignment
constexpr BasicVector4D< Type > &	operator= (const BasicVector4D &other)=default

constexpr BasicVector4D< Type > &	operator= (Ref other)

Conversion Operators
constexpr	operator std::tuple< Type, Type, Type, Type > () const

Constants
static constexpr BasicVector4D< Type >	unit_x ()

static constexpr BasicVector4D< Type >	unit_y ()

static constexpr BasicVector4D< Type >	unit_z ()

static constexpr BasicVector4D< Type >	unit_w ()

static constexpr BasicVector4D< Type >	zero ()

Invalid Value Check
bool	isNaN () const

bool	isInf () const

Swizzle operations
constexpr BasicVector2D< Type >::ConstRef	xy () const &

constexpr BasicVector2D< Type >::Ref	xy () &

constexpr BasicVector2D< Type >	xy () &&

constexpr BasicVector2D< Type >::ConstRef	xz () const &

constexpr BasicVector2D< Type >::Ref	xz () &

constexpr BasicVector2D< Type >	xz () &&

constexpr BasicVector2D< Type >::ConstRef	yx () const &

constexpr BasicVector2D< Type >::Ref	yx () &

constexpr BasicVector2D< Type >	yx () &&

constexpr BasicVector2D< Type >::ConstRef	yz () const &

constexpr BasicVector2D< Type >::Ref	yz () &

constexpr BasicVector2D< Type >	yz () &&

constexpr BasicVector2D< Type >::ConstRef	zx () const &

constexpr BasicVector2D< Type >::Ref	zx () &

constexpr BasicVector2D< Type >	zx () &&

constexpr BasicVector3D< Type >::ConstRef	xyz () const &

constexpr BasicVector3D< Type >::Ref	xyz () &

constexpr BasicVector3D< Type >	xyz () &&

constexpr BasicVector3D< Type >::ConstRef	xzy () const &

constexpr BasicVector3D< Type >::Ref	xzy () &

constexpr BasicVector3D< Type >	xzy () &&

constexpr BasicVector3D< Type >::ConstRef	zxy () const &

constexpr BasicVector3D< Type >::Ref	zxy () &

constexpr BasicVector3D< Type >	zxy () &&

constexpr BasicVector3D< Type >::ConstRef	zyx () const &

constexpr BasicVector3D< Type >::Ref	zyx () &

constexpr BasicVector3D< Type >	zyx () &&

constexpr BasicVector3D< Type >::ConstRef	xxx () const &

constexpr BasicVector3D< Type >::Ref	xxx () &

constexpr BasicVector3D< Type >	xxx () &&

constexpr BasicVector3D< Type >::ConstRef	yyy () const &

constexpr BasicVector3D< Type >::Ref	yyy () &

constexpr BasicVector3D< Type >	yyy () &&

constexpr BasicVector3D< Type >::ConstRef	zzz () const &

constexpr BasicVector3D< Type >::Ref	zzz () &

constexpr BasicVector3D< Type >	zzz () &&

constexpr BasicVector3D< Type >::ConstRef	www () const &

constexpr BasicVector3D< Type >::Ref	www () &

constexpr BasicVector3D< Type >	www () &&

Equality
template<class U > requires Concept::SameUnqualified<Type, U>
constexpr bool	operator== (const BasicVector4D &left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr bool	operator== (const BasicVector4D &left, BasicRef< U > right)

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<Type, U>
constexpr bool	approximately_equal_to (const BasicVector4D &value_to_test, const BasicVector4D< U > &value_it_should_be, OT tolerance=OT{0.0002})

template<class U , std::floating_point OT = float> requires Concept::SameUnqualified<Type, U>
constexpr bool	approximately_equal_to (const BasicVector4D &value_to_test, BasicRef< U > value_it_should_be, OT tolerance=OT{0.0002})

Global Functions
constexpr Type	accumulate (const BasicVector4D< Type > &input)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr Type	dot (const BasicVector4D &left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr Type	dot (const BasicVector4D &left, BasicRef< U > right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr Type	dot_normalized (const BasicVector4D &left, const BasicVector4D< U > &right)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr Type	dot_normalized (const BasicVector4D &left, BasicRef< U > right)

constexpr BasicVector4D< Type >	normalized (const BasicVector4D< Type > &input)

constexpr BasicVector4D< Type >	abs (const BasicVector4D< Type > &input)

BasicVector4D< Type >	fract (const BasicVector4D< Type > &input)

constexpr BasicVector4D< Type >	saturate (const BasicVector4D< Type > &input, Type lower_bound, Type upper_bound)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector4D< Type >	lerp (const BasicVector4D &input_lower_bound, const BasicVector4D< U > &input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector4D< Type >	lerp (const BasicVector4D &input_lower_bound, BasicRef< U > input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector4D< Type >	mix (const BasicVector4D &input_lower_bound, const BasicVector4D< U > &input_upper_bound, float percentage_zero_to_one)

template<class U > requires Concept::SameUnqualified<Type, U>
constexpr BasicVector4D< Type >	mix (const BasicVector4D &input_lower_bound, BasicRef< U > input_upper_bound, float percentage_zero_to_one)

std::string	format (const BasicVector4D &input)

Detailed Description

Here are the type aliases for BasicVector4D

Typedef Documentation

◆ ConstRef

template<class Type >

using ConstRef = BasicRef<const Type>

Definition at line 429 of file Vector4D.hpp.

◆ Ref

template<class Type >

using Ref = BasicRef<Type>

Definition at line 428 of file Vector4D.hpp.

◆ value_type [1/2]

template<class Type >

using value_type = Type

The underlying implementation type.

Definition at line 29 of file Vector4D.hpp.

◆ value_type [2/2]

template<class Type >

template<class RType >

using value_type = RType

The underlying implementation type.

Definition at line 44 of file Vector4D.hpp.

◆ Vector4D

template<class Type >

using Vector4D = BasicVector4D<double>

◆ Vector4Dd

template<class Type >

using Vector4Dd = BasicVector4D<double>

◆ Vector4Df

template<class Type >

using Vector4Df = BasicVector4D<float>

◆ Vector4Dl

template<class Type >

using Vector4Dl = BasicVector4D<long double>

Function Documentation

◆ BasicRef() [1/3]

template<class Type >

template<class RType >

constexpr BasicRef ( const BasicRef< RType > & )

constexprdefault

#include <lib/include/Math/math/Vector4D.hpp>

◆ BasicRef() [2/3]

template<class Type >

template<class RType >

constexpr BasicRef ( const BasicVector4D< RType > & other )

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 49 of file Vector4D.hpp.

◆ BasicRef() [3/3]

template<class Type >

template<class RType >

constexpr BasicRef	(	RType &	x_in,
		RType &	y_in,
		RType &	z_in,
		RType &	w_in
	)

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 47 of file Vector4D.hpp.

◆ BasicVector4D() [1/5]

template<class Type >

constexpr BasicVector4D ( )

constexprdefault

#include <lib/include/Math/math/Vector4D.hpp>

◆ BasicVector4D() [2/5]

template<class Type >

constexpr BasicVector4D	(	const BasicVector2D< Type > &	first2,
		const BasicVector2D< Type > &	second2
	)

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 451 of file Vector4D.hpp.

◆ BasicVector4D() [3/5]

template<class Type >

constexpr BasicVector4D	(	const BasicVector3D< Type > &	first3,
		const Type &	w_in = `0`
	)

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 443 of file Vector4D.hpp.

◆ BasicVector4D() [4/5]

template<class Type >

constexpr BasicVector4D	(	const Type &	x_in,
		const BasicVector3D< Type > &	last3
	)

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 459 of file Vector4D.hpp.

◆ BasicVector4D() [5/5]

template<class Type >

constexpr BasicVector4D	(	const Type &	x_in,
		const Type &	y_in = `0`,
		const Type &	z_in = `0`,
		const Type &	w_in = `0`
	)

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 435 of file Vector4D.hpp.

◆ isInf()

template<class Type >

bool isInf ( ) const

inline

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 517 of file Vector4D.hpp.

◆ isNaN()

template<class Type >

bool isNaN ( ) const

inline

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 516 of file Vector4D.hpp.

◆ magnitude()

template<class Type >

constexpr value_type magnitude ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 504 of file Vector4D.hpp.

◆ magnitudeSquared()

template<class Type >

constexpr value_type magnitudeSquared ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 503 of file Vector4D.hpp.

◆ norm()

template<class Type >

constexpr value_type norm ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Todo:: See if we need to use std::hypot()

Definition at line 501 of file Vector4D.hpp.

◆ normalized()

template<class Type >

constexpr BasicVector4D< Type > normalized ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 506 of file Vector4D.hpp.

◆ normSquared()

template<class Type >

constexpr value_type normSquared ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 500 of file Vector4D.hpp.

◆ operator BasicVector4D< RType >()

template<class Type >

template<class RType >

constexpr operator BasicVector4D< RType > ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 69 of file Vector4D.hpp.

◆ operator std::tuple< RType, RType, RType, RType >()

template<class Type >

template<class RType >

constexpr operator std::tuple< RType, RType, RType, RType > ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 71 of file Vector4D.hpp.

◆ operator std::tuple< Type, Type, Type, Type >()

template<class Type >

constexpr operator std::tuple< Type, Type, Type, Type > ( ) const

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 486 of file Vector4D.hpp.

◆ operator=() [1/4]

template<class Type >

template<class RType >

constexpr BasicRef & operator= ( BasicRef< RType > input )

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 51 of file Vector4D.hpp.

◆ operator=() [2/4]

template<class Type >

constexpr BasicVector4D< Type > & operator= ( const BasicVector4D< Type > & other )

constexprdefault

#include <lib/include/Math/math/Vector4D.hpp>

◆ operator=() [3/4]

template<class Type >

template<class RType >

constexpr BasicRef & operator= ( const BasicVector4D< RType > & input )

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 60 of file Vector4D.hpp.

◆ operator=() [4/4]

template<class Type >

constexpr BasicVector4D< Type > & operator= ( Ref other )

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 473 of file Vector4D.hpp.

◆ unit_w()

template<class Type >

static constexpr BasicVector4D< Type > unit_w ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 495 of file Vector4D.hpp.

◆ unit_x()

template<class Type >

static constexpr BasicVector4D< Type > unit_x ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 492 of file Vector4D.hpp.

◆ unit_y()

template<class Type >

static constexpr BasicVector4D< Type > unit_y ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 493 of file Vector4D.hpp.

◆ unit_z()

template<class Type >

static constexpr BasicVector4D< Type > unit_z ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 494 of file Vector4D.hpp.

◆ www() [1/3]

template<class Type >

constexpr BasicVector3D< Type >::Ref www ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 572 of file Vector4D.hpp.

◆ www() [2/3]

template<class Type >

constexpr BasicVector3D< Type > www ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 573 of file Vector4D.hpp.

◆ www() [3/3]

template<class Type >

constexpr BasicVector3D< Type >::ConstRef www ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 571 of file Vector4D.hpp.

◆ xxx() [1/3]

template<class Type >

constexpr BasicVector3D< Type >::Ref xxx ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 560 of file Vector4D.hpp.

◆ xxx() [2/3]

template<class Type >

constexpr BasicVector3D< Type > xxx ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 561 of file Vector4D.hpp.

◆ xxx() [3/3]

template<class Type >

constexpr BasicVector3D< Type >::ConstRef xxx ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 559 of file Vector4D.hpp.

◆ xy() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref xy ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 524 of file Vector4D.hpp.

◆ xy() [2/3]

template<class Type >

constexpr BasicVector2D< Type > xy ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 525 of file Vector4D.hpp.

◆ xy() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef xy ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 523 of file Vector4D.hpp.

◆ xyz() [1/3]

template<class Type >

constexpr BasicVector3D< Type >::Ref xyz ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 544 of file Vector4D.hpp.

◆ xyz() [2/3]

template<class Type >

constexpr BasicVector3D< Type > xyz ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 545 of file Vector4D.hpp.

◆ xyz() [3/3]

template<class Type >

constexpr BasicVector3D< Type >::ConstRef xyz ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 543 of file Vector4D.hpp.

◆ xz() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref xz ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 528 of file Vector4D.hpp.

◆ xz() [2/3]

template<class Type >

constexpr BasicVector2D< Type > xz ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 529 of file Vector4D.hpp.

◆ xz() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef xz ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 527 of file Vector4D.hpp.

◆ xzy() [1/3]

template<class Type >

constexpr BasicVector3D< Type >::Ref xzy ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 548 of file Vector4D.hpp.

◆ xzy() [2/3]

template<class Type >

constexpr BasicVector3D< Type > xzy ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 549 of file Vector4D.hpp.

◆ xzy() [3/3]

template<class Type >

constexpr BasicVector3D< Type >::ConstRef xzy ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 547 of file Vector4D.hpp.

◆ yx() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref yx ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 532 of file Vector4D.hpp.

◆ yx() [2/3]

template<class Type >

constexpr BasicVector2D< Type > yx ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 533 of file Vector4D.hpp.

◆ yx() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef yx ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 531 of file Vector4D.hpp.

◆ yyy() [1/3]

template<class Type >

constexpr BasicVector3D< Type >::Ref yyy ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 564 of file Vector4D.hpp.

◆ yyy() [2/3]

template<class Type >

constexpr BasicVector3D< Type > yyy ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 565 of file Vector4D.hpp.

◆ yyy() [3/3]

template<class Type >

constexpr BasicVector3D< Type >::ConstRef yyy ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 563 of file Vector4D.hpp.

◆ yz() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref yz ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 536 of file Vector4D.hpp.

◆ yz() [2/3]

template<class Type >

constexpr BasicVector2D< Type > yz ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 537 of file Vector4D.hpp.

◆ yz() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef yz ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 535 of file Vector4D.hpp.

◆ zero()

template<class Type >

static constexpr BasicVector4D< Type > zero ( )

inlinestaticconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 497 of file Vector4D.hpp.

◆ zx() [1/3]

template<class Type >

constexpr BasicVector2D< Type >::Ref zx ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 540 of file Vector4D.hpp.

◆ zx() [2/3]

template<class Type >

constexpr BasicVector2D< Type > zx ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 541 of file Vector4D.hpp.

◆ zx() [3/3]

template<class Type >

constexpr BasicVector2D< Type >::ConstRef zx ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 539 of file Vector4D.hpp.

◆ zxy() [1/3]

template<class Type >

constexpr BasicVector3D< Type >::Ref zxy ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 552 of file Vector4D.hpp.

◆ zxy() [2/3]

template<class Type >

constexpr BasicVector3D< Type > zxy ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 553 of file Vector4D.hpp.

◆ zxy() [3/3]

template<class Type >

constexpr BasicVector3D< Type >::ConstRef zxy ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 551 of file Vector4D.hpp.

◆ zyx() [1/3]

template<class Type >

constexpr BasicVector3D< Type >::Ref zyx ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 556 of file Vector4D.hpp.

◆ zyx() [2/3]

template<class Type >

constexpr BasicVector3D< Type > zyx ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 557 of file Vector4D.hpp.

◆ zyx() [3/3]

template<class Type >

constexpr BasicVector3D< Type >::ConstRef zyx ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 555 of file Vector4D.hpp.

◆ zzz() [1/3]

template<class Type >

constexpr BasicVector3D< Type >::Ref zzz ( ) &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 568 of file Vector4D.hpp.

◆ zzz() [2/3]

template<class Type >

constexpr BasicVector3D< Type > zzz ( ) &&

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 569 of file Vector4D.hpp.

◆ zzz() [3/3]

template<class Type >

constexpr BasicVector3D< Type >::ConstRef zzz ( ) const &

inlineconstexpr

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 567 of file Vector4D.hpp.

Variable Documentation

◆ w [1/2]

template<class Type >

template<class RType >

RType& w

Definition at line 76 of file Vector4D.hpp.

◆ w [2/2]

template<class Type >

value_type w {}

Definition at line 582 of file Vector4D.hpp.

◆ x [1/2]

template<class Type >

template<class RType >

RType& x

Definition at line 73 of file Vector4D.hpp.

◆ x [2/2]

template<class Type >

value_type x {}

Definition at line 579 of file Vector4D.hpp.

◆ y [1/2]

template<class Type >

template<class RType >

RType& y

Definition at line 74 of file Vector4D.hpp.

◆ y [2/2]

template<class Type >

value_type y {}

Definition at line 580 of file Vector4D.hpp.

◆ z [1/2]

template<class Type >

template<class RType >

RType& z

Definition at line 75 of file Vector4D.hpp.

◆ z [2/2]

template<class Type >

value_type z {}

Definition at line 581 of file Vector4D.hpp.

Friends

◆ abs [1/2]

template<class Type >

template<class RType >

constexpr BasicVector4D< RType > abs ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 255 of file Vector4D.hpp.

◆ abs [2/2]

template<class Type >

constexpr BasicVector4D< Type > abs ( const BasicVector4D< Type > & input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Calculate the absolute value of all components of a BasicVector4D

Parameters

input The BasicVector4D to operate on

Returns: The BasicVector4D with only positive values

Definition at line 857 of file Vector4D.hpp.

◆ accumulate [1/2]

template<class Type >

template<class RType >

constexpr RType accumulate ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 217 of file Vector4D.hpp.

◆ accumulate [2/2]

template<class Type >

constexpr Type accumulate ( const BasicVector4D< Type > & input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Sums up the components of input

Parameters

input The BasicVector4D to operate on

Returns: The sum of all the components

Definition at line 763 of file Vector4D.hpp.

◆ approximately_equal_to [1/4]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

constexpr bool approximately_equal_to	(	BasicRef< RType >	value_to_test,
		BasicRef< U >	value_it_should_be,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 195 of file Vector4D.hpp.

◆ approximately_equal_to [2/4]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

constexpr bool approximately_equal_to	(	BasicRef< RType >	value_to_test,
		const BasicVector4D< U > &	value_it_should_be,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 207 of file Vector4D.hpp.

◆ approximately_equal_to [3/4]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

constexpr bool approximately_equal_to	(	const BasicVector4D< Type > &	value_to_test,
		BasicRef< U >	value_it_should_be,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Compares two BasicVector4D inputs equal, component-wise, to within a tolerance

Parameters

value_to_test
value_it_should_be
tolerance	How close they should be to be considered equal

Returns: true if they are equal

Definition at line 649 of file Vector4D.hpp.

◆ approximately_equal_to [4/4]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

constexpr bool approximately_equal_to	(	const BasicVector4D< Type > &	value_to_test,
		const BasicVector4D< U > &	value_it_should_be,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Compares two BasicVector4D inputs equal, component-wise, to within a tolerance

Parameters

value_to_test
value_it_should_be
tolerance	How close they should be to be considered equal

Returns: true if they are equal

Definition at line 629 of file Vector4D.hpp.

◆ check_if_equal [1/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

bool check_if_equal	(	BasicRef< RType >	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 321 of file Vector4D.hpp.

◆ check_if_equal [2/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

bool check_if_equal	(	BasicRef< RType >	input,
		const BasicVector4D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 342 of file Vector4D.hpp.

◆ check_if_not_equal [1/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

bool check_if_not_equal	(	BasicRef< RType >	input,
		BasicRef< RType >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 363 of file Vector4D.hpp.

◆ CHECK_IF_NOT_EQUAL [1/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

void CHECK_IF_NOT_EQUAL	(	BasicRef< RType >	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 405 of file Vector4D.hpp.

◆ check_if_not_equal [2/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

bool check_if_not_equal	(	BasicRef< RType >	input,
		const BasicVector4D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 384 of file Vector4D.hpp.

◆ CHECK_IF_NOT_EQUAL [2/2]

template<class Type >

template<class RType >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<RType, U>

void CHECK_IF_NOT_EQUAL	(	BasicRef< RType >	input,
		const BasicVector4D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 414 of file Vector4D.hpp.

◆ CHECK_IF_ZERO

template<class Type >

template<class RType >

template<std::floating_point OT = float>

void CHECK_IF_ZERO	(	BasicRef< RType >	input,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 422 of file Vector4D.hpp.

◆ dot [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr RType dot	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 224 of file Vector4D.hpp.

◆ dot [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr RType dot	(	BasicRef< RType >	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 231 of file Vector4D.hpp.

◆ dot [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr Type dot	(	const BasicVector4D< Type > &	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Calculate the dot product of two BasicVector4D objects

Parameters

left	The first vector
right	The second vector

Returns: The dot product of the two input vectors

Note: This is only a strict dot product and thus a normalized result will depend on if the input vectors are both normalized!

Definition at line 799 of file Vector4D.hpp.

◆ dot [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr Type dot	(	const BasicVector4D< Type > &	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Calculate the dot product of two BasicVector4D objects

Parameters

left	The first vector
right	The second vector

Returns: The dot product of the two input vectors

Note: This is only a strict dot product and thus a normalized result will depend on if the input vectors are both normalized!

Definition at line 781 of file Vector4D.hpp.

◆ dot_normalized [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr RType dot_normalized	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 238 of file Vector4D.hpp.

◆ dot_normalized [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr RType dot_normalized	(	BasicRef< RType >	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 245 of file Vector4D.hpp.

◆ dot_normalized [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr Type dot_normalized	(	const BasicVector4D< Type > &	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Calculate the normalized dot product of two BasicVector4D objects

The input vectors are not assumed to be normalized, so we go ahead and divide through by both the input vectors to arrive at a normalized output.

Parameters

left	The first vector
right	The second vector

Returns: The dot product of the two input vectors

Definition at line 835 of file Vector4D.hpp.

◆ dot_normalized [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr Type dot_normalized	(	const BasicVector4D< Type > &	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Calculate the normalized dot product of two BasicVector4D objects

The input vectors are not assumed to be normalized, so we go ahead and divide through by both the input vectors to arrive at a normalized output.

Parameters

left	The first vector
right	The second vector

Returns: The dot product of the two input vectors

Definition at line 817 of file Vector4D.hpp.

◆ format [1/2]

template<class Type >

template<class RType >

std::string format ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 314 of file Vector4D.hpp.

◆ format [2/2]

template<class Type >

std::string format ( const BasicVector4D< Type > & input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 927 of file Vector4D.hpp.

◆ fract [1/2]

template<class Type >

template<class RType >

BasicVector4D< RType > fract ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 260 of file Vector4D.hpp.

◆ fract [2/2]

template<class Type >

BasicVector4D< Type > fract ( const BasicVector4D< Type > & input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Calculate the fractional part of all components of a BasicVector4D

Parameters

input The BasicVector4D to operate on

Returns: The BasicVector4D with only fractional values

Definition at line 871 of file Vector4D.hpp.

◆ lerp [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > lerp	(	BasicRef< RType >	input_lower_bound,
		BasicRef< U >	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 280 of file Vector4D.hpp.

◆ lerp [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > lerp	(	BasicRef< RType >	input_lower_bound,
		BasicVector4D< U > &	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 289 of file Vector4D.hpp.

◆ lerp [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector4D< Type > lerp	(	const BasicVector4D< Type > &	input_lower_bound,
		BasicRef< U >	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 902 of file Vector4D.hpp.

◆ lerp [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector4D< Type > lerp	(	const BasicVector4D< Type > &	input_lower_bound,
		const BasicVector4D< U > &	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 893 of file Vector4D.hpp.

◆ mix [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > mix	(	BasicRef< RType >	input_lower_bound,
		BasicRef< U >	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 298 of file Vector4D.hpp.

◆ mix [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > mix	(	BasicRef< RType >	input_lower_bound,
		BasicVector4D< U > &	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 307 of file Vector4D.hpp.

◆ mix [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector4D< Type > mix	(	const BasicVector4D< Type > &	input_lower_bound,
		BasicRef< U >	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 920 of file Vector4D.hpp.

◆ mix [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr BasicVector4D< Type > mix	(	const BasicVector4D< Type > &	input_lower_bound,
		const BasicVector4D< U > &	input_upper_bound,
		float	percentage_zero_to_one
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 911 of file Vector4D.hpp.

◆ normalized [1/2]

template<class Type >

template<class RType >

constexpr BasicVector4D< RType > normalized ( BasicRef< RType > input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 250 of file Vector4D.hpp.

◆ normalized [2/2]

template<class Type >

constexpr BasicVector4D< Type > normalized ( const BasicVector4D< Type > & input )

friend

#include <lib/include/Math/math/Vector4D.hpp>

Creates the normalized form of a BasicVector4D

Parameters

input The BasicVector4D to normalize

Returns: The normalized version of input

Definition at line 846 of file Vector4D.hpp.

◆ operator* [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator*	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 134 of file Vector4D.hpp.

◆ operator* [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator*	(	BasicRef< RType >	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 144 of file Vector4D.hpp.

◆ operator* [3/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator*	(	BasicRef< RType >	left,
		const U &	scalar
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 154 of file Vector4D.hpp.

◆ operator* [4/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator*	(	const U &	scalar,
		BasicRef< RType >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 161 of file Vector4D.hpp.

◆ operator+ [1/2]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator+	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 94 of file Vector4D.hpp.

◆ operator+ [2/2]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator+	(	BasicRef< RType >	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 104 of file Vector4D.hpp.

◆ operator- [1/2]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator-	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 114 of file Vector4D.hpp.

◆ operator- [2/2]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator-	(	BasicRef< RType >	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 124 of file Vector4D.hpp.

◆ operator/ [1/3]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator/	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 168 of file Vector4D.hpp.

◆ operator/ [2/3]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator/	(	BasicRef< RType >	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 178 of file Vector4D.hpp.

◆ operator/ [3/3]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr BasicVector4D< RType > operator/	(	BasicRef< RType >	left,
		const U &	scalar
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 188 of file Vector4D.hpp.

◆ operator== [1/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr bool operator==	(	BasicRef< RType >	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 80 of file Vector4D.hpp.

◆ operator== [2/4]

template<class Type >

template<class RType >

template<class U >
requires Concept::SameUnqualified<RType, U>

constexpr bool operator==	(	BasicRef< RType >	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 87 of file Vector4D.hpp.

◆ operator== [3/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr bool operator==	(	const BasicVector4D< Type > &	left,
		BasicRef< U >	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Defines equality of a BasicVector4D and BasicRef objects

Note: Uses approximately_equal_to under-the-hood

See also: Equality

Definition at line 614 of file Vector4D.hpp.

◆ operator== [4/4]

template<class Type >

template<class U >
requires Concept::SameUnqualified<Type, U>

constexpr bool operator==	(	const BasicVector4D< Type > &	left,
		const BasicVector4D< U > &	right
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Defines equality of two BasicVector4D objects

Note: Uses approximately_equal_to under-the-hood

See also: Equality

Definition at line 601 of file Vector4D.hpp.

◆ saturate [1/2]

template<class Type >

template<class RType >

constexpr BasicVector4D< RType > saturate	(	BasicRef< RType >	input,
		RType	lower_bound,
		RType	upper_bound
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 270 of file Vector4D.hpp.

◆ saturate [2/2]

template<class Type >

constexpr BasicVector4D< Type > saturate	(	const BasicVector4D< Type > &	input,
		Type	lower_bound,
		Type	upper_bound
	)

friend

#include <lib/include/Math/math/Vector4D.hpp>

Definition at line 881 of file Vector4D.hpp.

Modules

Classes

Typedefs

Functions

Variables

Friends

Types

Types

Type Aliases

Element Access

Constructors

Assignment

Conversion Operators

Constants

Invalid Value Check

Swizzle operations

Equality

Global Functions

Detailed Description

Typedef Documentation

◆ ConstRef

◆ Ref

◆ value_type [1/2]

◆ value_type [2/2]

◆ Vector4D

◆ Vector4Dd

◆ Vector4Df

◆ Vector4Dl

Function Documentation

◆ BasicRef() [1/3]

◆ BasicRef() [2/3]

◆ BasicRef() [3/3]

◆ BasicVector4D() [1/5]

◆ BasicVector4D() [2/5]

◆ BasicVector4D() [3/5]

◆ BasicVector4D() [4/5]

◆ BasicVector4D() [5/5]

◆ isInf()

◆ isNaN()

◆ magnitude()

◆ magnitudeSquared()

◆ norm()

◆ normalized()

◆ normSquared()

◆ operator BasicVector4D< RType >()

◆ operator std::tuple< RType, RType, RType, RType >()

◆ operator std::tuple< Type, Type, Type, Type >()

◆ operator=() [1/4]

◆ operator=() [2/4]

◆ operator=() [3/4]

◆ operator=() [4/4]

◆ unit_w()

◆ unit_x()

◆ unit_y()

◆ unit_z()

◆ www() [1/3]

◆ www() [2/3]

◆ www() [3/3]

◆ xxx() [1/3]

◆ xxx() [2/3]

◆ xxx() [3/3]

◆ xy() [1/3]

◆ xy() [2/3]

◆ xy() [3/3]

◆ xyz() [1/3]

◆ xyz() [2/3]

◆ xyz() [3/3]

◆ xz() [1/3]

◆ xz() [2/3]

◆ xz() [3/3]

◆ xzy() [1/3]

◆ xzy() [2/3]

◆ xzy() [3/3]

◆ yx() [1/3]

◆ yx() [2/3]

◆ yx() [3/3]

◆ yyy() [1/3]

◆ yyy() [2/3]

◆ yyy() [3/3]

◆ yz() [1/3]