for std::pair More...

Namespaces
	pairwise

	trait

Classes
class	BoundingBox

class	TBoundingBox

class	BoundingBox2D
	bounding rectangle More...

class	BoundingBox1D
	bounding interval More...

class	DualQuatCoord3

class	fixed_array

class	Frame

class	Vec

class	VecNoInit
	Same as Vec except the values are not initialized by default. More...

class	Mat

class	MatNoInit
	Same as Mat except the values are not initialized by default. More...

class	Quat

struct	CleanupCheck

struct	detect

struct	detect< T, Op, void_t< Op< T > > >

class	Material

class	MatSym

class	PrimitiveGroup

struct	qNoInit

class	QuatNoInit
	Same as Quat except the values are not initialized by default. More...

class	Ray

class	RGBAColor
	encode a 4 RGBA component color More...

class	SpatialVector

class	SVector
	Same as type::vector, + delimitors on serialization. More...

struct	HasRebindTypedef

struct	HasRebindTypedef< T, OtherType, std::void_t< typename T::template rebind_to< OtherType > > >

struct	Rebind

struct	Rebind< _T, _OtherType, std::enable_if_t< HasRebindTypedef< _T, _OtherType >::value > >
	Specialization for types that do have a nested rebind_to member. In this implementation, Rebind has a public member typedef to. It corresponds to the typedef rebind_to. More...

struct	Rebind< _T, _OtherType, std::enable_if_t<!HasRebindTypedef< _T, _OtherType >::value > >
	Specialization for types that do NOT have a nested rebind_to member. In this implementation, Rebind has no public member typedef to. If this implementation is chosen by the compiler (the number of template parameters is probably different from 1), a compilation error occurs. More...

struct	Rebind< _T< A >, _OtherType, std::enable_if_t<!HasRebindTypedef< _T< A >, _OtherType >::value > >
	Specialization for types that do NOT have a nested rebind_to member. In this implementation, Rebind has a public member typedef to. More...

class	Transform

struct	NoInit

class	vector_device

class	CPUMemoryManager

class	vector

Typedefs
typedef Vec< 1, float >	Vec1f

typedef Vec< 1, double >	Vec1d

typedef Vec< 1, int >	Vec1i

typedef Vec< 1, unsigned >	Vec1u

typedef Vec< 1, SReal >	Vec1

typedef Vec< 2, float >	Vec2f

typedef Vec< 2, double >	Vec2d

typedef Vec< 2, int >	Vec2i

typedef Vec< 2, unsigned >	Vec2u

typedef Vec< 2, SReal >	Vec2

typedef Vec< 3, float >	Vec3f

typedef Vec< 3, double >	Vec3d

typedef Vec< 3, int >	Vec3i

typedef Vec< 3, unsigned >	Vec3u

typedef Vec< 3, SReal >	Vec3

typedef Vec< 4, float >	Vec4f

typedef Vec< 4, double >	Vec4d

typedef Vec< 4, int >	Vec4i

typedef Vec< 4, unsigned >	Vec4u

typedef Vec< 4, SReal >	Vec4

typedef Vec< 6, float >	Vec6f

typedef Vec< 6, double >	Vec6d

typedef Vec< 6, int >	Vec6i

typedef Vec< 6, unsigned >	Vec6u

typedef Vec< 6, SReal >	Vec6

typedef Mat< 1, 1, float >	Mat1x1f

typedef Mat< 1, 1, double >	Mat1x1d

typedef Mat< 2, 2, float >	Mat2x2f

typedef Mat< 2, 2, double >	Mat2x2d

typedef Mat< 3, 3, float >	Mat3x3f

typedef Mat< 3, 3, double >	Mat3x3d

typedef Mat< 3, 4, float >	Mat3x4f

typedef Mat< 3, 4, double >	Mat3x4d

typedef Mat< 4, 4, float >	Mat4x4f

typedef Mat< 4, 4, double >	Mat4x4d

typedef Mat< 6, 6, float >	Mat6x6f

typedef Mat< 6, 6, double >	Mat6x6d

typedef Mat< 2, 2, SReal >	Mat2x2

typedef Mat< 3, 3, SReal >	Mat3x3

typedef Mat< 4, 4, SReal >	Mat4x4

typedef Mat< 6, 6, SReal >	Mat6x6

typedef Mat< 2, 2, SReal >	Matrix2

typedef Mat< 3, 3, SReal >	Matrix3

typedef Mat< 4, 4, SReal >	Matrix4

using	Quatd = type::Quat< double >

using	Quatf = type::Quat< float >

using	BoundingBox3D = BoundingBox

using	FixedArray1i = fixed_array< int, 1 >

using	FixedArray1I = fixed_array< unsigned int, 1 >

using	FixedArray2i = fixed_array< int, 2 >

using	FixedArray2I = fixed_array< unsigned int, 2 >

using	FixedArray3i = fixed_array< int, 3 >

using	FixedArray3I = fixed_array< unsigned int, 3 >

using	FixedArray4i = fixed_array< int, 4 >

using	FixedArray4I = fixed_array< unsigned int, 4 >

using	FixedArray5i = fixed_array< int, 5 >

using	FixedArray5I = fixed_array< unsigned int, 5 >

using	FixedArray6i = fixed_array< int, 6 >

using	FixedArray6I = fixed_array< unsigned int, 6 >

using	FixedArray7i = fixed_array< int, 7 >

using	FixedArray7I = fixed_array< unsigned int, 7 >

using	FixedArray8i = fixed_array< int, 8 >

using	FixedArray8I = fixed_array< unsigned int, 8 >

using	FixedArray1f = fixed_array< float, 1 >

using	FixedArray1d = fixed_array< double, 1 >

using	FixedArray2f = fixed_array< float, 2 >

using	FixedArray2d = fixed_array< double, 2 >

using	FixedArray3f = fixed_array< float, 3 >

using	FixedArray3d = fixed_array< double, 3 >

using	FixedArray4f = fixed_array< float, 4 >

using	FixedArray4d = fixed_array< double, 4 >

using	FixedArray5f = fixed_array< float, 5 >

using	FixedArray5d = fixed_array< double, 5 >

using	FixedArray6f = fixed_array< float, 6 >

using	FixedArray6d = fixed_array< double, 6 >

using	FixedArray7f = fixed_array< float, 7 >

using	FixedArray7d = fixed_array< double, 7 >

using	FixedArray8f = fixed_array< float, 8 >

using	FixedArray8d = fixed_array< double, 8 >

template<typename... >
using	void_t = void

template<typename T >
using	isRigid_t = decltype(std::declval< typename T::Coord >().getOrientation())

template<typename T >
using	isRigidType = detect< T, isRigid_t >

template<class T , class A = std::allocator<T>>
using	stable_vector = boost::container::stable_vector< T, A >

template<class T , class B >
using	rebind_to = typename Rebind< T, B >::to

Functions
BoundingBox::bbox_t	make_neutralBBox ()

template<typename... Ts>
constexpr auto	make_array (Ts &&... ts) -> fixed_array< std::common_type_t< Ts... >, sizeof...(Ts)>

template<typename T , sofa::Size N>
constexpr sofa::type::fixed_array< T, N >	makeHomogeneousArray (const T &value)
	Builds a fixed_array in which all elements have the same value. More...

template<typename FixedArray >
constexpr FixedArray	makeHomogeneousArray (const typename FixedArray::value_type &value)
	Builds a fixed_array in which all elements have the same value. More...

template<typename T , sofa::Size N>
constexpr bool	operator< (const fixed_array< T, N > &v1, const fixed_array< T, N > &v2) noexcept
	Checks if v1 is lexicographically less than v2. Similar to std::lexicographical_compare. More...

template<typename T , sofa::Size N>
constexpr bool	operator> (const fixed_array< T, N > &v1, const fixed_array< T, N > &v2) noexcept

std::ostream &	operator<< (std::ostream &out, const sofa::type::Frame &c)

SOFA_TYPE_API void	init ()
	Initialize the SofaHelper library. More...

SOFA_TYPE_API bool	isInitialized ()
	Return true if and only if the SofaHelper library has been initialized. More...

SOFA_TYPE_API void	cleanup ()
	Clean up the resources used by the SofaHelper library. More...

SOFA_TYPE_API bool	isCleanedUp ()
	Return true if and only if the SofaHelper library has been cleaned up. More...

SOFA_TYPE_API void	printUninitializedLibraryWarning (const std::string &library, const std::string &initFunction)
	Print a warning about a library not being initialized (meant for internal use). More...

SOFA_TYPE_API void	printLibraryNotCleanedUpWarning (const std::string &library, const std::string &cleanupFunction)
	Print a warning about a library not being cleaned up (meant for internal use). More...

template<sofa::Size L, sofa::Size C, sofa::Size P, class real >
constexpr Mat< C, P, real >	multTranspose (const Mat< L, C, real > &m1, const Mat< L, P, real > &m2) noexcept

template<class real >
constexpr real	determinant (const Mat< 3, 3, real > &m) noexcept
	Determinant of a 3x3 matrix. More...

template<class real >
constexpr real	determinant (const Mat< 2, 2, real > &m) noexcept
	Determinant of a 2x2 matrix. More...

template<class real >
constexpr real	determinant (const Mat< 2, 3, real > &m) noexcept

template<class real >
constexpr real	determinant (const Mat< 3, 2, real > &m) noexcept

template<class real >
real	oneNorm (const Mat< 3, 3, real > &A)

template<class real >
real	infNorm (const Mat< 3, 3, real > &A)

template<sofa::Size N, class real >
constexpr real	trace (const Mat< N, N, real > &m) noexcept
	trace of a square matrix More...

template<sofa::Size N, class real >
constexpr Vec< N, real >	diagonal (const Mat< N, N, real > &m)
	diagonal of a square matrix More...

template<sofa::Size S, class real >
bool	invertMatrix (Mat< S, S, real > &dest, const Mat< S, S, real > &from)
	Matrix inversion (general case). More...

template<class real >
constexpr bool	invertMatrix (Mat< 3, 3, real > &dest, const Mat< 3, 3, real > &from)
	Matrix inversion (special case 3x3). More...

template<class real >
constexpr bool	invertMatrix (Mat< 2, 2, real > &dest, const Mat< 2, 2, real > &from)
	Matrix inversion (special case 2x2). More...

template<class real >
constexpr bool	invertMatrix (Mat< 1, 1, real > &dest, const Mat< 1, 1, real > &from)
	Matrix inversion (special case 1x1). More...

template<sofa::Size S, class real >
constexpr bool	transformInvertMatrix (Mat< S, S, real > &dest, const Mat< S, S, real > &from)
	Inverse Matrix considering the matrix as a transformation. More...

template<sofa::Size L, sofa::Size C, typename real >
std::ostream &	operator<< (std::ostream &o, const Mat< L, C, real > &m)

template<sofa::Size L, sofa::Size C, typename real >
std::istream &	operator>> (std::istream &in, Mat< L, C, real > &m)

template<sofa::Size L, sofa::Size C, typename real >
void	printMatlab (std::ostream &o, const Mat< L, C, real > &m)
	printing in other software formats More...

template<sofa::Size L, sofa::Size C, typename real >
void	printMaple (std::ostream &o, const Mat< L, C, real > &m)

template<class Tu , class Tv >
constexpr Mat< Tu::size(), Tv::size(), typename Tu::value_type >	dyad (const Tu &u, const Tv &v) noexcept
	Create a matrix as . More...

template<sofa::Size L, sofa::Size C, typename real >
constexpr real	scalarProduct (const Mat< L, C, real > &left, const Mat< L, C, real > &right) noexcept
	Compute the scalar product of two matrix (sum of product of all terms) More...

template<class Real >
constexpr Mat< 3, 3, Real >	crossProductMatrix (const Vec< 3, Real > &v) noexcept

template<sofa::Size L, class Real >
constexpr Mat< L, L, Real >	tensorProduct (const Vec< L, Real > &a, const Vec< L, Real > &b) noexcept
	return a * b^T More...

template<sofa::Size L, sofa::Size C, sofa::Size P, class real >
constexpr Mat< L, P, real >	operator* (const Mat< L, C, real > &m1, const Mat< C, P, real > &m2) noexcept

template<class real >
constexpr Mat< 3, 3, real >	operator* (const Mat< 3, 3, real > &m1, const Mat< 3, 3, real > &m2) noexcept

template<class real >
constexpr Mat< 3, 3, real >	multTranspose (const Mat< 3, 3, real > &m1, const Mat< 3, 3, real > &m2) noexcept

template<Size n, class real >
bool	cholDcmp (Mat< n, n, real > &L, const Mat< n, n, real > &M)

template<Size n, class real >
void	cholBksb (Vec< n, real > &x, const Mat< n, n, real > &L, const Vec< n, real > &b)

template<Size n, class real >
bool	cholSlv (Vec< n, real > &x, const Mat< n, n, real > &M, const Vec< n, real > &b)

template<Size n, class real >
bool	cholInv (Mat< n, n, real > &Inv, const Mat< n, n, real > &M)

template<Size dim, typename real >
bool	solveLCP (const Vec< dim, real > &q, const Mat< dim, dim, real > &M, Vec< dim *2, real > &res)

template<int n, typename Real >
void	ludcmp (Mat< n, n, Real > &a, Vec< n, int > &indx)
	Compute the LU decomposition of matrix a. a is replaced by its pivoted LU decomposition. indx stores pivoting indices. More...

template<int n, typename Real >
void	lubksb (const Mat< n, n, Real > &a, const Vec< n, int > &indx, Vec< n, Real > &b)
	Compute the solution of Mx=b. b is replaced by x. a and indx together represent the LU decomposition of m, as given my method ludcmp. More...

template<int n, typename Real >
void	luinv (Mat< n, n, Real > &inv, Mat< n, n, Real > &m)

template<class T1 , class T2 >
const T1	S_MAX (const T1 &a, const T2 &b)
	return the max of two values More...

template<class T1 , class T2 >
const T1	S_MIN (const T1 &a, const T2 &b)
	return the min of two values More...

template<class T1 , class T2 >
const T1	S_SIGN (const T1 &a, const T2 &b)

template<class T >
const T	S_SQR (const T a)

template<class T1 , class T2 >
T1	pythag (const T1 a, const T2 b)
	Computes sqrt(a^2 + b^2) without destructive underflow or overflow. More...

template<int m, int n, typename Real >
void	svddcmp (Mat< m, n, Real > &a, Vec< n, Real > &w, Mat< n, m, Real > &v)
	Compute the SVD decomposition of matrix a (from nr). a is replaced by its pivoted LU decomposition. indx stores pivoting indices. More...

template<int m, int n, typename Real >
Real	cond (Mat< m, n, Real > &a)
	return the condition number of the matrix a following the euclidian norm (using the svd decomposition to find singular values) More...

std::ostream &	operator<< (std::ostream &out, const Material &m)

std::istream &	operator>> (std::istream &in, Material &m)

template<sofa::Size D, class real >
Mat< D, D, real >	operator* (const Mat< D, D, real > &a, const MatSym< D, real > &b)

template<class real >
real	determinant (const MatSym< 3, real > &m)
	Determinant of a 3x3 matrix. More...

template<class real >
real	determinant (const MatSym< 2, real > &m)
	Determinant of a 2x2 matrix. More...

template<class real >
real	trace (const MatSym< 3, real > &m)
	Trace of a 3x3 matrix. More...

template<class real >
real	trace (const MatSym< 2, real > &m)
	Trace of a 2x2 matrix. More...

template<sofa::Size S, class real >
bool	invertMatrix (MatSym< S, real > &dest, const MatSym< S, real > &from)
	Matrix inversion (general case). More...

template<class real >
bool	invertMatrix (MatSym< 3, real > &dest, const MatSym< 3, real > &from)
	Matrix inversion (special case 3x3). More...

template<class real >
bool	invertMatrix (MatSym< 2, real > &dest, const MatSym< 2, real > &from)
	Matrix inversion (special case 2x2). More...

template<sofa::Size D, class real >
std::ostream &	operator<< (std::ostream &o, const MatSym< D, real > &m)

template<sofa::Size D, class real >
std::istream &	operator>> (std::istream &in, MatSym< D, real > &m)

template<sofa::Size D, typename real >
real	scalarProduct (const MatSym< D, real > &left, const MatSym< D, real > &right)
	Compute the scalar product of two matrix (sum of product of all terms) More...

template<sofa::Size D, typename real >
real	scalarProduct (const MatSym< D, real > &left, const Mat< D, D, real > &right)

template<sofa::Size D, typename real >
real	scalarProduct (const Mat< D, D, real > &left, const MatSym< D, real > &right)

std::ostream &	operator<< (std::ostream &out, const PrimitiveGroup &g)

std::istream &	operator>> (std::istream &in, PrimitiveGroup &g)

template SOFA_TYPE_API std::ostream &	operator<< (std::ostream &out, const Quat< double > &v)

template SOFA_TYPE_API std::istream &	operator>> (std::istream &in, Quat< double > &v)

template SOFA_TYPE_API std::ostream &	operator<< (std::ostream &out, const Quat< float > &v)

template SOFA_TYPE_API std::istream &	operator>> (std::istream &in, Quat< float > &v)

template<class Real >
SOFA_TYPE_API std::ostream &	operator<< (std::ostream &out, const Quat< Real > &v)
	write to an output stream More...

template<class Real >
SOFA_TYPE_API std::istream &	operator>> (std::istream &in, Quat< Real > &v)
	read from an input stream More...

template<class Real >
std::ostream &	operator<< (std::ostream &out, const Quat< Real > &v)
	write to an output stream More...

template<class Real >
std::istream &	operator>> (std::istream &in, Quat< Real > &v)
	read from an input stream More...

SOFA_TYPE_API std::istream &	operator>> (std::istream &i, RGBAColor &t)

SOFA_TYPE_API std::ostream &	operator<< (std::ostream &out, const RGBAColor &t)
	Write to an output stream. More...

constexpr RGBAColor	operator- (const RGBAColor &l, const RGBAColor &r)

constexpr RGBAColor	operator+ (const RGBAColor &l, const RGBAColor &r)

constexpr RGBAColor	operator/ (const RGBAColor &l, const float div)

template<sofa::Size N, typename Real >
std::istream &	operator>> (std::istream &in, Vec< N, Real > &v)
	Read from an input stream. More...

template<sofa::Size N, typename Real >
std::ostream &	operator<< (std::ostream &out, const Vec< N, Real > &v)
	Write to an output stream. More...

template<typename real1 , typename real2 >
constexpr Vec< 3, real1 >	cross (const Vec< 3, real1 > &a, const Vec< 3, real2 > &b) noexcept
	Cross product for 3-elements vectors. More...

template<typename real1 , typename real2 >
constexpr real1	cross (const type::Vec< 2, real1 > &a, const type::Vec< 2, real2 > &b) noexcept
	Cross product for 2-elements vectors. More...

template<sofa::Size N, typename real >
constexpr real	dot (const Vec< N, real > &a, const Vec< N, real > &b) noexcept
	Dot product (alias for operator*) More...

template<sofa::Size N, typename real >
constexpr Vec< N, real >	operator* (const double &a, const Vec< N, real > &V) noexcept

template<sofa::Size N, typename real >
constexpr Vec< N, real >	operator* (const float &a, const Vec< N, real > &V) noexcept

template<typename T , sofa::Size N>
constexpr bool	operator< (const Vec< N, T > &v1, const Vec< N, T > &v2) noexcept
	Checks if v1 is lexicographically less than v2. Similar to std::lexicographical_compare. More...

void SOFA_TYPE_API	vector_access_failure (const void *vec, const std::size_t size, const std::size_t i, const std::type_info &type)

template<class T1 , class T2 >
void	remove (T1 &v, const T2 &elem)

template<class T1 , class T2 >
void	removeValue (T1 &v, const T2 &elem)

template<class T , class TT >
void	removeIndex (std::vector< T, TT > &v, size_t index)
	Remove value at given index, replace it by the value at the last index, other values are not changed. More...

SOFA_TYPE_API int	getInteger (const std::string &s, std::stringstream &msg, unsigned int &numErrors)

SOFA_TYPE_API unsigned int	getUnsignedInteger (const std::string &s, std::stringstream &msg, unsigned int &numErrors)

linear algebra on standard vectors
template<class V1 , class V2 >
SReal	dot (const V1 &vector1, const V2 &vector2)
	Dot product of two vectors. More...

template<class V >
SReal	norm (const V &v)
	Norm of a vector. More...

template<class V1 , class Scalar , class V2 , class V3 >
void	axpy (V1 &result, Scalar a, const V2 &x, const V3 &y)
	Vector operation: result = ax + y. More...

Variables
template class SOFA_TYPE_API	DualQuatCoord3< double >

template class SOFA_TYPE_API	DualQuatCoord3< float >

template class SOFA_TYPE_API	fixed_array< float, 2 >

template class SOFA_TYPE_API	fixed_array< double, 2 >

template class SOFA_TYPE_API	fixed_array< float, 3 >

template class SOFA_TYPE_API	fixed_array< double, 3 >

template class SOFA_TYPE_API	fixed_array< float, 4 >

template class SOFA_TYPE_API	fixed_array< double, 4 >

template class SOFA_TYPE_API	fixed_array< float, 5 >

template class SOFA_TYPE_API	fixed_array< double, 5 >

template class SOFA_TYPE_API	fixed_array< float, 6 >

template class SOFA_TYPE_API	fixed_array< double, 6 >

template class SOFA_TYPE_API	fixed_array< float, 7 >

template class SOFA_TYPE_API	fixed_array< double, 7 >

template class SOFA_TYPE_API	Quat< double >
	Explicit instanciation of the quaternions for double precision. More...

template class SOFA_TYPE_API	Quat< float >
	Explicit instanciation of the quaternions for single precision. More...

constexpr qNoInit	QNOINIT

constexpr RGBAColor	g_white {1.0f,1.0f,1.0f,1.0f}

constexpr RGBAColor	g_black {0.0f,0.0f,0.0f,1.0f}

constexpr RGBAColor	g_red {1.0f,0.0f,0.0f,1.0f}

constexpr RGBAColor	g_green {0.0f,1.0f,0.0f,1.0f}

constexpr RGBAColor	g_blue {0.0f,0.0f,1.0f,1.0f}

constexpr RGBAColor	g_cyan {0.0f,1.0f,1.0f,1.0f}

constexpr RGBAColor	g_magenta {1.0f,0.0f,1.0f,1.0f}

constexpr RGBAColor	g_yellow {1.0f,1.0f,0.0f,1.0f}

constexpr RGBAColor	g_gray {0.5f,0.5f,0.5f,1.0f}

constexpr RGBAColor	g_darkgray {0.25f,0.25f,0.25f,1.0f}

constexpr RGBAColor	g_lightgray {0.75f,0.75f,0.75f,1.0f}

template class SOFA_TYPE_API	SpatialVector< double >

template class SOFA_TYPE_API	SpatialVector< float >

template<class... >
constexpr auto	deny = false

template class SOFA_TYPE_API	Transform< double >

template class SOFA_TYPE_API	Transform< float >

template class SOFA_TYPE_API	Vec< 2, float >

template class SOFA_TYPE_API	Vec< 2, int >

template class SOFA_TYPE_API	Vec< 2, double >

template class SOFA_TYPE_API	Vec< 2, unsigned >

template class SOFA_TYPE_API	Vec< 3, float >

template class SOFA_TYPE_API	Vec< 3, int >

template class SOFA_TYPE_API	Vec< 3, double >

template class SOFA_TYPE_API	Vec< 3, unsigned >

template class SOFA_TYPE_API	Vec< 4, float >

template class SOFA_TYPE_API	Vec< 4, int >

template class SOFA_TYPE_API	Vec< 4, double >

template class SOFA_TYPE_API	Vec< 4, unsigned >

template class SOFA_TYPE_API	Vec< 6, float >

template class SOFA_TYPE_API	Vec< 6, int >

template class SOFA_TYPE_API	Vec< 6, double >

template class SOFA_TYPE_API	Vec< 6, unsigned >

constexpr NoInit	NOINIT

Detailed Description

for std::pair

All integral types are considered as extern templates.

Typedef Documentation

◆ BoundingBox3D

using sofa::type::BoundingBox3D = typedef BoundingBox

◆ FixedArray1d

using sofa::type::FixedArray1d = typedef fixed_array<double, 1>

◆ FixedArray1f

using sofa::type::FixedArray1f = typedef fixed_array<float, 1>

◆ FixedArray1i

using sofa::type::FixedArray1i = typedef fixed_array<int, 1>

◆ FixedArray1I

using sofa::type::FixedArray1I = typedef fixed_array<unsigned int, 1>

◆ FixedArray2d

using sofa::type::FixedArray2d = typedef fixed_array<double, 2>

◆ FixedArray2f

using sofa::type::FixedArray2f = typedef fixed_array<float, 2>

◆ FixedArray2i

using sofa::type::FixedArray2i = typedef fixed_array<int, 2>

◆ FixedArray2I

using sofa::type::FixedArray2I = typedef fixed_array<unsigned int, 2>

◆ FixedArray3d

using sofa::type::FixedArray3d = typedef fixed_array<double, 3>

◆ FixedArray3f

using sofa::type::FixedArray3f = typedef fixed_array<float, 3>

◆ FixedArray3i

using sofa::type::FixedArray3i = typedef fixed_array<int, 3>

◆ FixedArray3I

using sofa::type::FixedArray3I = typedef fixed_array<unsigned int, 3>

◆ FixedArray4d

using sofa::type::FixedArray4d = typedef fixed_array<double, 4>

◆ FixedArray4f

using sofa::type::FixedArray4f = typedef fixed_array<float, 4>

◆ FixedArray4i

using sofa::type::FixedArray4i = typedef fixed_array<int, 4>

◆ FixedArray4I

using sofa::type::FixedArray4I = typedef fixed_array<unsigned int, 4>

◆ FixedArray5d

using sofa::type::FixedArray5d = typedef fixed_array<double, 5>

◆ FixedArray5f

using sofa::type::FixedArray5f = typedef fixed_array<float, 5>

◆ FixedArray5i

using sofa::type::FixedArray5i = typedef fixed_array<int, 5>

◆ FixedArray5I

using sofa::type::FixedArray5I = typedef fixed_array<unsigned int, 5>

◆ FixedArray6d

using sofa::type::FixedArray6d = typedef fixed_array<double, 6>

◆ FixedArray6f

using sofa::type::FixedArray6f = typedef fixed_array<float, 6>

◆ FixedArray6i

using sofa::type::FixedArray6i = typedef fixed_array<int, 6>

◆ FixedArray6I

using sofa::type::FixedArray6I = typedef fixed_array<unsigned int, 6>

◆ FixedArray7d

using sofa::type::FixedArray7d = typedef fixed_array<double, 7>

◆ FixedArray7f

using sofa::type::FixedArray7f = typedef fixed_array<float, 7>

◆ FixedArray7i

using sofa::type::FixedArray7i = typedef fixed_array<int, 7>

◆ FixedArray7I

using sofa::type::FixedArray7I = typedef fixed_array<unsigned int, 7>

◆ FixedArray8d

using sofa::type::FixedArray8d = typedef fixed_array<double, 8>

◆ FixedArray8f

using sofa::type::FixedArray8f = typedef fixed_array<float, 8>

◆ FixedArray8i

using sofa::type::FixedArray8i = typedef fixed_array<int, 8>

◆ FixedArray8I

using sofa::type::FixedArray8I = typedef fixed_array<unsigned int, 8>

◆ isRigid_t

template<typename T >

using sofa::type::isRigid_t = typedef decltype(std::declval<typename T::Coord>().getOrientation())

◆ isRigidType

template<typename T >

using sofa::type::isRigidType = typedef detect<T, isRigid_t>

◆ Mat1x1d

typedef Mat<1,1,double> sofa::type::Mat1x1d

◆ Mat1x1f

typedef Mat<1,1,float> sofa::type::Mat1x1f

◆ Mat2x2

typedef Mat<2,2,SReal> sofa::type::Mat2x2

◆ Mat2x2d

typedef Mat<2,2,double> sofa::type::Mat2x2d

◆ Mat2x2f

typedef Mat<2,2,float> sofa::type::Mat2x2f

◆ Mat3x3

typedef Mat<3,3,SReal> sofa::type::Mat3x3

◆ Mat3x3d

typedef Mat<3,3,double> sofa::type::Mat3x3d

◆ Mat3x3f

typedef Mat<3,3,float> sofa::type::Mat3x3f

◆ Mat3x4d

typedef Mat<3,4,double> sofa::type::Mat3x4d

◆ Mat3x4f

typedef Mat<3,4,float> sofa::type::Mat3x4f

◆ Mat4x4

typedef Mat<4,4,SReal> sofa::type::Mat4x4

◆ Mat4x4d

typedef Mat<4,4,double> sofa::type::Mat4x4d

◆ Mat4x4f

typedef Mat<4,4,float> sofa::type::Mat4x4f

◆ Mat6x6

typedef Mat<6,6,SReal> sofa::type::Mat6x6

◆ Mat6x6d

typedef Mat<6, 6, double> sofa::type::Mat6x6d

◆ Mat6x6f

typedef Mat<6, 6, float> sofa::type::Mat6x6f

◆ Matrix2

typedef Mat<2,2,SReal> sofa::type::Matrix2

◆ Matrix3

typedef Mat<3,3,SReal> sofa::type::Matrix3

◆ Matrix4

typedef Mat<4,4,SReal> sofa::type::Matrix4

◆ Quatd

using sofa::type::Quatd = typedef type::Quat<double>

◆ Quatf

using sofa::type::Quatf = typedef type::Quat<float>

◆ rebind_to

template<class T , class B >

using sofa::type::rebind_to = typedef typename Rebind<T, B>::to

Conveniant alias to ease usage of Rebind.

Example: 1) sofa::type::rebind_to< sofa::type::vector<int>, float> is of type sofa::type::vector<float>. In this example, sofa::type::vector has a typedef rebind_to that will be used to deduce the type. 2) sofa::type::rebind_to< sofa::type::Quat<float>, double> is of type sofa::type::Quat<double>. In this example, sofa::type::Quat does not have a typdef rebind_to. 3) It makes no sense to use sofa::type::rebind on types having more than one template parameter, such as sofa::type::fixed_array. A compilation error would occur.

◆ stable_vector

template<class T , class A = std::allocator<T>>

using sofa::type::stable_vector = typedef boost::container::stable_vector<T,A>

◆ Vec1

typedef Vec<1,SReal> sofa::type::Vec1

◆ Vec1d

typedef Vec<1,double> sofa::type::Vec1d

◆ Vec1f

typedef Vec<1,float> sofa::type::Vec1f

◆ Vec1i

typedef Vec<1,int> sofa::type::Vec1i

◆ Vec1u

typedef Vec<1,unsigned> sofa::type::Vec1u

◆ Vec2

typedef Vec<2,SReal> sofa::type::Vec2

◆ Vec2d

typedef Vec<2,double> sofa::type::Vec2d

◆ Vec2f

typedef Vec<2,float> sofa::type::Vec2f

◆ Vec2i

typedef Vec<2,int> sofa::type::Vec2i

◆ Vec2u

typedef Vec<2,unsigned> sofa::type::Vec2u

◆ Vec3

typedef Vec<3,SReal> sofa::type::Vec3

◆ Vec3d

typedef Vec<3,double> sofa::type::Vec3d

◆ Vec3f

typedef Vec<3,float> sofa::type::Vec3f

◆ Vec3i

typedef Vec<3,int> sofa::type::Vec3i

◆ Vec3u

typedef Vec<3,unsigned> sofa::type::Vec3u

◆ Vec4

typedef Vec<4,SReal> sofa::type::Vec4

◆ Vec4d

typedef Vec<4,double> sofa::type::Vec4d

◆ Vec4f

typedef Vec<4,float> sofa::type::Vec4f

◆ Vec4i

typedef Vec<4,int> sofa::type::Vec4i

◆ Vec4u

typedef Vec<4,unsigned> sofa::type::Vec4u

◆ Vec6

typedef Vec<6,SReal> sofa::type::Vec6

◆ Vec6d

typedef Vec<6,double> sofa::type::Vec6d

◆ Vec6f

typedef Vec<6,float> sofa::type::Vec6f

◆ Vec6i

typedef Vec<6,int> sofa::type::Vec6i

◆ Vec6u

typedef Vec<6,unsigned> sofa::type::Vec6u

◆ void_t

template<typename... >

using sofa::type::void_t = typedef void

Function Documentation

◆ axpy()

template<class V1 , class Scalar , class V2 , class V3 >

void sofa::type::axpy	(	V1 &	result,
		Scalar	a,
		const V2 &	x,
		const V3 &	y
	)

Vector operation: result = ax + y.

◆ cholBksb()

template<Size n, class real >

void sofa::type::cholBksb	(	Vec< n, real > &	x,
		const Mat< n, n, real > &	L,
		const Vec< n, real > &	b
	)

Cholesky back-substitution: solve the system Mx=b using the triangular matrix L such that M=L.Lt

Precondition: L was computed using the Cholesky decomposition of L

◆ cholDcmp()

template<Size n, class real >

bool sofa::type::cholDcmp	(	Mat< n, n, real > &	L,
		const Mat< n, n, real > &	M
	)

Cholesky decomposition: compute triangular matrix L such that M=L.Lt

Precondition: M must be symmetric positive definite returns false is the decomposition fails

◆ cholInv()

template<Size n, class real >

bool sofa::type::cholInv	(	Mat< n, n, real > &	Inv,
		const Mat< n, n, real > &	M
	)

Inversion of a positive symmetric definite (PSD) matrix using a Cholesky decomposition. Returns false if the matrix is not PSD.

◆ cholSlv()

template<Size n, class real >

bool sofa::type::cholSlv	(	Vec< n, real > &	x,
		const Mat< n, n, real > &	M,
		const Vec< n, real > &	b
	)

Cholesky solution: solve the system Mx=b using a Cholesky decomposition.

Precondition: M must be symmetric positive definite Returns false is the decomposition fails. If you have several solutions to perform with the same matrix M and different vectors b, it is more efficient to factor the matrix once and then use back-substitution for each vector.

◆ cleanup()

SOFA_TYPE_API void sofa::type::cleanup ( )

Clean up the resources used by the SofaHelper library.

◆ cond()

template<int m, int n, typename Real >

Real sofa::type::cond ( Mat< m, n, Real > & a )

return the condition number of the matrix a following the euclidian norm (using the svd decomposition to find singular values)

◆ cross() [1/2]

template<typename real1 , typename real2 >

constexpr real1 sofa::type::cross	(	const type::Vec< 2, real1 > &	a,
		const type::Vec< 2, real2 > &	b
	)

constexprnoexcept

Cross product for 2-elements vectors.

◆ cross() [2/2]

template<typename real1 , typename real2 >

constexpr Vec<3,real1> sofa::type::cross	(	const Vec< 3, real1 > &	a,
		const Vec< 3, real2 > &	b
	)

constexprnoexcept

Cross product for 3-elements vectors.

◆ crossProductMatrix()

template<class Real >

constexpr Mat<3, 3, Real> sofa::type::crossProductMatrix ( const Vec< 3, Real > & v )

constexprnoexcept

skew-symmetric mapping crossProductMatrix(v) * x = v.cross(x)

◆ determinant() [1/6]

template<class real >

constexpr real sofa::type::determinant ( const Mat< 2, 2, real > & m )

constexprnoexcept

Determinant of a 2x2 matrix.

◆ determinant() [2/6]

template<class real >

constexpr real sofa::type::determinant ( const Mat< 2, 3, real > & m )

constexprnoexcept

Generalized-determinant of a 2x3 matrix. Mirko Radi, "About a Determinant of Rectangular 2×n Matrix and its Geometric Interpretation"

◆ determinant() [3/6]

template<class real >

constexpr real sofa::type::determinant ( const Mat< 3, 2, real > & m )

constexprnoexcept

Generalized-determinant of a 3x2 matrix. Mirko Radi, "About a Determinant of Rectangular 2×n Matrix and its Geometric Interpretation"

◆ determinant() [4/6]

template<class real >

constexpr real sofa::type::determinant ( const Mat< 3, 3, real > & m )

constexprnoexcept

Determinant of a 3x3 matrix.

◆ determinant() [5/6]

template<class real >

real sofa::type::determinant ( const MatSym< 2, real > & m )

inline

Determinant of a 2x2 matrix.

◆ determinant() [6/6]

template<class real >

real sofa::type::determinant ( const MatSym< 3, real > & m )

inline

Determinant of a 3x3 matrix.

◆ diagonal()

template<sofa::Size N, class real >

constexpr Vec<N,real> sofa::type::diagonal ( const Mat< N, N, real > & m )

constexpr

diagonal of a square matrix

◆ dot() [1/2]

template<class V1 , class V2 >

SReal sofa::type::dot	(	const V1 &	vector1,
		const V2 &	vector2
	)

Dot product of two vectors.

◆ dot() [2/2]

template<sofa::Size N, typename real >

constexpr real sofa::type::dot	(	const Vec< N, real > &	a,
		const Vec< N, real > &	b
	)

constexprnoexcept

Dot product (alias for operator*)

◆ dyad()

template<class Tu , class Tv >

constexpr Mat<Tu::size(), Tv::size(), typename Tu::value_type> sofa::type::dyad	(	const Tu &	u,
		const Tv &	v
	)

constexprnoexcept

Create a matrix as $ u v^T $ .

◆ getInteger()

SOFA_TYPE_API int sofa::type::getInteger	(	const std::string &	s,
		std::stringstream &	msg,
		unsigned int &	numErrors
	)

Convert the string 's' into an unsigned int. The error are reported in msg & numErrors is incremented.

◆ getUnsignedInteger()

SOFA_TYPE_API unsigned int sofa::type::getUnsignedInteger	(	const std::string &	s,
		std::stringstream &	msg,
		unsigned int &	numErrors
	)

Convert the string 's' into an unsigned int. The error are reported in msg & numErrors is incremented.

◆ infNorm()

template<class real >

real sofa::type::infNorm ( const Mat< 3, 3, real > & A )

◆ init()

SOFA_TYPE_API void sofa::type::init ( )

Initialize the SofaHelper library.

◆ invertMatrix() [1/7]

template<class real >

constexpr bool sofa::type::invertMatrix	(	Mat< 1, 1, real > &	dest,
		const Mat< 1, 1, real > &	from
	)

constexpr

Matrix inversion (special case 1x1).

◆ invertMatrix() [2/7]

template<class real >

constexpr bool sofa::type::invertMatrix	(	Mat< 2, 2, real > &	dest,
		const Mat< 2, 2, real > &	from
	)

constexpr

Matrix inversion (special case 2x2).

◆ invertMatrix() [3/7]

template<class real >

constexpr bool sofa::type::invertMatrix	(	Mat< 3, 3, real > &	dest,
		const Mat< 3, 3, real > &	from
	)

constexpr

Matrix inversion (special case 3x3).

◆ invertMatrix() [4/7]

template<sofa::Size S, class real >

bool sofa::type::invertMatrix	(	Mat< S, S, real > &	dest,
		const Mat< S, S, real > &	from
	)

Matrix inversion (general case).

◆ invertMatrix() [5/7]

template<class real >

bool sofa::type::invertMatrix	(	MatSym< 2, real > &	dest,
		const MatSym< 2, real > &	from
	)

Matrix inversion (special case 2x2).

◆ invertMatrix() [6/7]

template<class real >

bool sofa::type::invertMatrix	(	MatSym< 3, real > &	dest,
		const MatSym< 3, real > &	from
	)

Matrix inversion (special case 3x3).

◆ invertMatrix() [7/7]

template<sofa::Size S, class real >

bool sofa::type::invertMatrix	(	MatSym< S, real > &	dest,
		const MatSym< S, real > &	from
	)

Matrix inversion (general case).

◆ isCleanedUp()

SOFA_TYPE_API bool sofa::type::isCleanedUp ( )

Return true if and only if the SofaHelper library has been cleaned up.

◆ isInitialized()

SOFA_TYPE_API bool sofa::type::isInitialized ( )

Return true if and only if the SofaHelper library has been initialized.

◆ lubksb()

template<int n, typename Real >

void sofa::type::lubksb	(	const Mat< n, n, Real > &	a,
		const Vec< n, int > &	indx,
		Vec< n, Real > &	b
	)

Compute the solution of Mx=b. b is replaced by x. a and indx together represent the LU decomposition of m, as given my method ludcmp.

◆ ludcmp()

template<int n, typename Real >

void sofa::type::ludcmp	(	Mat< n, n, Real > &	a,
		Vec< n, int > &	indx
	)

Compute the LU decomposition of matrix a. a is replaced by its pivoted LU decomposition. indx stores pivoting indices.

◆ luinv()

template<int n, typename Real >

void sofa::type::luinv	(	Mat< n, n, Real > &	inv,
		Mat< n, n, Real > &	m
	)

Compute the inverse of matrix m.

Warning: Matrix m is replaced by its LU decomposition.

◆ make_array()

template<typename... Ts>

constexpr auto sofa::type::make_array ( Ts &&... ts ) -> fixed_array<std::common_type_t<Ts...>, sizeof...(Ts)>

constexpr

◆ make_neutralBBox()

BoundingBox::bbox_t sofa::type::make_neutralBBox ( )

◆ makeHomogeneousArray() [1/2]

template<typename T , sofa::Size N>

constexpr sofa::type::fixed_array<T, N> sofa::type::makeHomogeneousArray ( const T & value )

constexpr

Builds a fixed_array in which all elements have the same value.

◆ makeHomogeneousArray() [2/2]

template<typename FixedArray >

constexpr FixedArray sofa::type::makeHomogeneousArray ( const typename FixedArray::value_type & value )

constexpr

Builds a fixed_array in which all elements have the same value.

◆ multTranspose() [1/2]

template<class real >

constexpr Mat<3,3,real> sofa::type::multTranspose	(	const Mat< 3, 3, real > &	m1,
		const Mat< 3, 3, real > &	m2
	)

constexprnoexcept

◆ multTranspose() [2/2]

template<sofa::Size L, sofa::Size C, sofa::Size P, class real >

constexpr Mat< C, P, real > sofa::type::multTranspose	(	const Mat< L, C, real > &	m1,
		const Mat< L, P, real > &	m2
	)

constexprnoexcept

◆ norm()

template<class V >

SReal sofa::type::norm ( const V & v )

Norm of a vector.

◆ oneNorm()

template<class real >

real sofa::type::oneNorm ( const Mat< 3, 3, real > & A )

◆ operator*() [1/5]

template<sofa::Size N, typename real >

constexpr Vec<N,real> sofa::type::operator*	(	const double &	a,
		const Vec< N, real > &	V
	)

constexprnoexcept

◆ operator*() [2/5]

template<sofa::Size N, typename real >

constexpr Vec<N,real> sofa::type::operator*	(	const float &	a,
		const Vec< N, real > &	V
	)

constexprnoexcept

◆ operator*() [3/5]

template<class real >

constexpr Mat<3,3,real> sofa::type::operator*	(	const Mat< 3, 3, real > &	m1,
		const Mat< 3, 3, real > &	m2
	)

constexprnoexcept

◆ operator*() [4/5]

template<sofa::Size D, class real >

Mat<D, D, real> sofa::type::operator*	(	const Mat< D, D, real > &	a,
		const MatSym< D, real > &	b
	)

◆ operator*() [5/5]

template<sofa::Size L, sofa::Size C, sofa::Size P, class real >

constexpr Mat<L,P,real> sofa::type::operator*	(	const Mat< L, C, real > &	m1,
		const Mat< C, P, real > &	m2
	)

constexprnoexcept

◆ operator+()

constexpr RGBAColor sofa::type::operator+	(	const RGBAColor &	l,
		const RGBAColor &	r
	)

constexpr

◆ operator-()

constexpr RGBAColor sofa::type::operator-	(	const RGBAColor &	l,
		const RGBAColor &	r
	)

constexpr

◆ operator/()

constexpr RGBAColor sofa::type::operator/	(	const RGBAColor &	l,
		const float	div
	)

constexpr

◆ operator<() [1/2]

template<typename T , sofa::Size N>

constexpr bool sofa::type::operator<	(	const fixed_array< T, N > &	v1,
		const fixed_array< T, N > &	v2
	)

constexprnoexcept

Checks if v1 is lexicographically less than v2. Similar to std::lexicographical_compare.

◆ operator<() [2/2]

template<typename T , sofa::Size N>

constexpr bool sofa::type::operator<	(	const Vec< N, T > &	v1,
		const Vec< N, T > &	v2
	)

constexprnoexcept

Checks if v1 is lexicographically less than v2. Similar to std::lexicographical_compare.

◆ operator<<() [1/11]

template<sofa::Size L, sofa::Size C, typename real >

std::ostream& sofa::type::operator<<	(	std::ostream &	o,
		const Mat< L, C, real > &	m
	)

◆ operator<<() [2/11]

template<sofa::Size D, class real >

std::ostream& sofa::type::operator<<	(	std::ostream &	o,
		const MatSym< D, real > &	m
	)

◆ operator<<() [3/11]

std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const Material &	m
	)

◆ operator<<() [4/11]

std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const PrimitiveGroup &	g
	)

◆ operator<<() [5/11]

template SOFA_TYPE_API std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const Quat< double > &	v
	)

◆ operator<<() [6/11]

template SOFA_TYPE_API std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const Quat< float > &	v
	)

◆ operator<<() [7/11]

template<class Real >

SOFA_TYPE_API std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const Quat< Real > &	v
	)

write to an output stream

◆ operator<<() [8/11]

template<class Real >

std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const Quat< Real > &	v
	)

write to an output stream

◆ operator<<() [9/11]

SOFA_TYPE_API std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const RGBAColor &	t
	)

Write to an output stream.

◆ operator<<() [10/11]

std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const sofa::type::Frame &	c
	)

◆ operator<<() [11/11]

template<sofa::Size N, typename Real >

std::ostream& sofa::type::operator<<	(	std::ostream &	out,
		const Vec< N, Real > &	v
	)

Write to an output stream.

◆ operator>()

template<typename T , sofa::Size N>

constexpr bool sofa::type::operator>	(	const fixed_array< T, N > &	v1,
		const fixed_array< T, N > &	v2
	)

constexprnoexcept

◆ operator>>() [1/10]

SOFA_TYPE_API std::istream& sofa::type::operator>>	(	std::istream &	i,
		RGBAColor &	t
	)

◆ operator>>() [2/10]

template<sofa::Size L, sofa::Size C, typename real >

std::istream& sofa::type::operator>>	(	std::istream &	in,
		Mat< L, C, real > &	m
	)

◆ operator>>() [3/10]

std::istream& sofa::type::operator>>	(	std::istream &	in,
		Material &	m
	)

◆ operator>>() [4/10]

template<sofa::Size D, class real >

std::istream& sofa::type::operator>>	(	std::istream &	in,
		MatSym< D, real > &	m
	)

◆ operator>>() [5/10]

std::istream& sofa::type::operator>>	(	std::istream &	in,
		PrimitiveGroup &	g
	)

◆ operator>>() [6/10]

template SOFA_TYPE_API std::istream& sofa::type::operator>>	(	std::istream &	in,
		Quat< double > &	v
	)

◆ operator>>() [7/10]

template SOFA_TYPE_API std::istream& sofa::type::operator>>	(	std::istream &	in,
		Quat< float > &	v
	)

◆ operator>>() [8/10]

template<class Real >

SOFA_TYPE_API std::istream& sofa::type::operator>>	(	std::istream &	in,
		Quat< Real > &	v
	)

read from an input stream

◆ operator>>() [9/10]

template<class Real >

std::istream& sofa::type::operator>>	(	std::istream &	in,
		Quat< Real > &	v
	)

read from an input stream

◆ operator>>() [10/10]

template<sofa::Size N, typename Real >

std::istream& sofa::type::operator>>	(	std::istream &	in,
		Vec< N, Real > &	v
	)

Read from an input stream.

◆ printLibraryNotCleanedUpWarning()

SOFA_TYPE_API void sofa::type::printLibraryNotCleanedUpWarning	(	const std::string &	library,
		const std::string &	cleanupFunction
	)

Print a warning about a library not being cleaned up (meant for internal use).

◆ printMaple()

template<sofa::Size L, sofa::Size C, typename real >

void sofa::type::printMaple	(	std::ostream &	o,
		const Mat< L, C, real > &	m
	)

◆ printMatlab()

template<sofa::Size L, sofa::Size C, typename real >

void sofa::type::printMatlab	(	std::ostream &	o,
		const Mat< L, C, real > &	m
	)

printing in other software formats

◆ printUninitializedLibraryWarning()

SOFA_TYPE_API void sofa::type::printUninitializedLibraryWarning	(	const std::string &	library,
		const std::string &	initFunction
	)

Print a warning about a library not being initialized (meant for internal use).

◆ pythag()

template<class T1 , class T2 >

T1 sofa::type::pythag	(	const T1	a,
		const T2	b
	)

Computes sqrt(a^2 + b^2) without destructive underflow or overflow.

◆ remove()

template<class T1 , class T2 >

void sofa::type::remove	(	T1 &	v,
		const T2 &	elem
	)

Remove the first occurence of a given value. The remaining values are shifted.

◆ removeIndex()

template<class T , class TT >

void sofa::type::removeIndex	(	std::vector< T, TT > &	v,
		size_t	index
	)

Remove value at given index, replace it by the value at the last index, other values are not changed.

◆ removeValue()

template<class T1 , class T2 >

void sofa::type::removeValue	(	T1 &	v,
		const T2 &	elem
	)

Remove the first occurence of a given value.

The last value is moved to where the value was found, and the other values are not shifted.

◆ S_MAX()

template<class T1 , class T2 >

const T1 sofa::type::S_MAX	(	const T1 &	a,
		const T2 &	b
	)

inline

return the max of two values

◆ S_MIN()

template<class T1 , class T2 >

const T1 sofa::type::S_MIN	(	const T1 &	a,
		const T2 &	b
	)

inline

return the min of two values

◆ S_SIGN()

template<class T1 , class T2 >

const T1 sofa::type::S_SIGN	(	const T1 &	a,
		const T2 &	b
	)

inline

◆ S_SQR()

template<class T >

const T sofa::type::S_SQR ( const T a )

inline

◆ scalarProduct() [1/4]

template<sofa::Size D, typename real >

real sofa::type::scalarProduct	(	const Mat< D, D, real > &	left,
		const MatSym< D, real > &	right
	)

inline

◆ scalarProduct() [2/4]

template<sofa::Size L, sofa::Size C, typename real >

constexpr real sofa::type::scalarProduct	(	const Mat< L, C, real > &	left,
		const Mat< L, C, real > &	right
	)

constexprnoexcept

Compute the scalar product of two matrix (sum of product of all terms)

◆ scalarProduct() [3/4]

template<sofa::Size D, typename real >

real sofa::type::scalarProduct	(	const MatSym< D, real > &	left,
		const Mat< D, D, real > &	right
	)

inline

◆ scalarProduct() [4/4]

template<sofa::Size D, typename real >

real sofa::type::scalarProduct	(	const MatSym< D, real > &	left,
		const MatSym< D, real > &	right
	)

inline

Compute the scalar product of two matrix (sum of product of all terms)

◆ solveLCP()

template<Size dim, typename real >

bool sofa::type::solveLCP	(	const Vec< dim, real > &	q,
		const Mat< dim, dim, real > &	M,
		Vec< dim *2, real > &	res
	)

◆ svddcmp()

template<int m, int n, typename Real >

void sofa::type::svddcmp	(	Mat< m, n, Real > &	a,
		Vec< n, Real > &	w,
		Mat< n, m, Real > &	v
	)

Compute the SVD decomposition of matrix a (from nr). a is replaced by its pivoted LU decomposition. indx stores pivoting indices.

SVD decomposition a = u.w.vt

Precondition: a: original matrix, destroyed to become u; w: diagonal vector; v: matrix

◆ tensorProduct()

template<sofa::Size L, class Real >

constexpr Mat<L,L,Real> sofa::type::tensorProduct	(	const Vec< L, Real > &	a,
		const Vec< L, Real > &	b
	)

constexprnoexcept

return a * b^T

◆ trace() [1/3]

template<sofa::Size N, class real >

constexpr real sofa::type::trace ( const Mat< N, N, real > & m )

constexprnoexcept

trace of a square matrix

◆ trace() [2/3]

template<class real >

real sofa::type::trace ( const MatSym< 2, real > & m )

inline

Trace of a 2x2 matrix.

◆ trace() [3/3]

template<class real >

real sofa::type::trace ( const MatSym< 3, real > & m )

inline

Trace of a 3x3 matrix.

◆ transformInvertMatrix()

template<sofa::Size S, class real >

constexpr bool sofa::type::transformInvertMatrix	(	Mat< S, S, real > &	dest,
		const Mat< S, S, real > &	from
	)

constexpr

Inverse Matrix considering the matrix as a transformation.

◆ vector_access_failure()

void SOFA_TYPE_API sofa::type::vector_access_failure	(	const void *	vec,
		const std::size_t	size,
		const std::size_t	i,
		const std::type_info &	type
	)

Variable Documentation

◆ deny

template<class... >

constexpr auto sofa::type::deny = false

inlineconstexpr

◆ DualQuatCoord3< double >

template class SOFA_TYPE_API sofa::type::DualQuatCoord3< double >

◆ DualQuatCoord3< float >

template class SOFA_TYPE_API sofa::type::DualQuatCoord3< float >

◆ fixed_array< double, 2 >

template class SOFA_TYPE_API sofa::type::fixed_array< double, 2 >

◆ fixed_array< double, 3 >

template class SOFA_TYPE_API sofa::type::fixed_array< double, 3 >

◆ fixed_array< double, 4 >

template class SOFA_TYPE_API sofa::type::fixed_array< double, 4 >

◆ fixed_array< double, 5 >

template class SOFA_TYPE_API sofa::type::fixed_array< double, 5 >

◆ fixed_array< double, 6 >

template class SOFA_TYPE_API sofa::type::fixed_array< double, 6 >

◆ fixed_array< double, 7 >

template class SOFA_TYPE_API sofa::type::fixed_array< double, 7 >

◆ fixed_array< float, 2 >

template class SOFA_TYPE_API sofa::type::fixed_array< float, 2 >

◆ fixed_array< float, 3 >

template class SOFA_TYPE_API sofa::type::fixed_array< float, 3 >

◆ fixed_array< float, 4 >

template class SOFA_TYPE_API sofa::type::fixed_array< float, 4 >

◆ fixed_array< float, 5 >

template class SOFA_TYPE_API sofa::type::fixed_array< float, 5 >

◆ fixed_array< float, 6 >

template class SOFA_TYPE_API sofa::type::fixed_array< float, 6 >

◆ fixed_array< float, 7 >

template class SOFA_TYPE_API sofa::type::fixed_array< float, 7 >

◆ g_black

constexpr RGBAColor sofa::type::g_black {0.0f,0.0f,0.0f,1.0f}

constexpr

◆ g_blue

constexpr RGBAColor sofa::type::g_blue {0.0f,0.0f,1.0f,1.0f}

constexpr

◆ g_cyan

constexpr RGBAColor sofa::type::g_cyan {0.0f,1.0f,1.0f,1.0f}

constexpr

◆ g_darkgray

constexpr RGBAColor sofa::type::g_darkgray {0.25f,0.25f,0.25f,1.0f}

constexpr

◆ g_gray

constexpr RGBAColor sofa::type::g_gray {0.5f,0.5f,0.5f,1.0f}

constexpr

◆ g_green

constexpr RGBAColor sofa::type::g_green {0.0f,1.0f,0.0f,1.0f}

constexpr

◆ g_lightgray

constexpr RGBAColor sofa::type::g_lightgray {0.75f,0.75f,0.75f,1.0f}

constexpr

◆ g_magenta

constexpr RGBAColor sofa::type::g_magenta {1.0f,0.0f,1.0f,1.0f}

constexpr

◆ g_red

constexpr RGBAColor sofa::type::g_red {1.0f,0.0f,0.0f,1.0f}

constexpr

◆ g_white

constexpr RGBAColor sofa::type::g_white {1.0f,1.0f,1.0f,1.0f}

constexpr

◆ g_yellow

constexpr RGBAColor sofa::type::g_yellow {1.0f,1.0f,0.0f,1.0f}

constexpr

◆ NOINIT

constexpr NoInit sofa::type::NOINIT

constexpr

◆ QNOINIT

constexpr qNoInit sofa::type::QNOINIT

constexpr

◆ Quat< double >

template class SOFA_TYPE_API sofa::type::Quat< double >

Explicit instanciation of the quaternions for double precision.

◆ Quat< float >

template class SOFA_TYPE_API sofa::type::Quat< float >

Explicit instanciation of the quaternions for single precision.

◆ SpatialVector< double >

template class SOFA_TYPE_API sofa::type::SpatialVector< double >

◆ SpatialVector< float >

template class SOFA_TYPE_API sofa::type::SpatialVector< float >

◆ Transform< double >

template class SOFA_TYPE_API sofa::type::Transform< double >

◆ Transform< float >

template class SOFA_TYPE_API sofa::type::Transform< float >

◆ Vec< 2, double >

template class SOFA_TYPE_API sofa::type::Vec< 2, double >

◆ Vec< 2, float >

template class SOFA_TYPE_API sofa::type::Vec< 2, float >

◆ Vec< 2, int >

template class SOFA_TYPE_API sofa::type::Vec< 2, int >

◆ Vec< 2, unsigned >

template class SOFA_TYPE_API sofa::type::Vec< 2, unsigned >

◆ Vec< 3, double >

template class SOFA_TYPE_API sofa::type::Vec< 3, double >

◆ Vec< 3, float >

template class SOFA_TYPE_API sofa::type::Vec< 3, float >

◆ Vec< 3, int >

template class SOFA_TYPE_API sofa::type::Vec< 3, int >

◆ Vec< 3, unsigned >

template class SOFA_TYPE_API sofa::type::Vec< 3, unsigned >

◆ Vec< 4, double >

template class SOFA_TYPE_API sofa::type::Vec< 4, double >

◆ Vec< 4, float >

template class SOFA_TYPE_API sofa::type::Vec< 4, float >

◆ Vec< 4, int >

template class SOFA_TYPE_API sofa::type::Vec< 4, int >

◆ Vec< 4, unsigned >

template class SOFA_TYPE_API sofa::type::Vec< 4, unsigned >

◆ Vec< 6, double >

template class SOFA_TYPE_API sofa::type::Vec< 6, double >

◆ Vec< 6, float >

template class SOFA_TYPE_API sofa::type::Vec< 6, float >

◆ Vec< 6, int >

template class SOFA_TYPE_API sofa::type::Vec< 6, int >

◆ Vec< 6, unsigned >

template class SOFA_TYPE_API sofa::type::Vec< 6, unsigned >

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ BoundingBox3D

◆ FixedArray1d

◆ FixedArray1f

◆ FixedArray1i

◆ FixedArray1I

◆ FixedArray2d

◆ FixedArray2f

◆ FixedArray2i

◆ FixedArray2I

◆ FixedArray3d

◆ FixedArray3f

◆ FixedArray3i

◆ FixedArray3I

◆ FixedArray4d

◆ FixedArray4f

◆ FixedArray4i

◆ FixedArray4I

◆ FixedArray5d

◆ FixedArray5f

◆ FixedArray5i

◆ FixedArray5I

◆ FixedArray6d

◆ FixedArray6f

◆ FixedArray6i

◆ FixedArray6I

◆ FixedArray7d

◆ FixedArray7f

◆ FixedArray7i

◆ FixedArray7I

◆ FixedArray8d

◆ FixedArray8f

◆ FixedArray8i

◆ FixedArray8I

◆ isRigid_t

◆ isRigidType

◆ Mat1x1d

◆ Mat1x1f

◆ Mat2x2

◆ Mat2x2d

◆ Mat2x2f

◆ Mat3x3

◆ Mat3x3d

◆ Mat3x3f

◆ Mat3x4d

◆ Mat3x4f

◆ Mat4x4

◆ Mat4x4d

◆ Mat4x4f

◆ Mat6x6

◆ Mat6x6d

◆ Mat6x6f

◆ Matrix2

◆ Matrix3

◆ Matrix4

◆ Quatd

◆ Quatf

◆ rebind_to

◆ stable_vector

◆ Vec1

◆ Vec1d

◆ Vec1f

◆ Vec1i

◆ Vec1u

◆ Vec2

◆ Vec2d

◆ Vec2f

◆ Vec2i

◆ Vec2u

◆ Vec3

◆ Vec3d

◆ Vec3f

◆ Vec3i

◆ Vec3u