* make std::vector specializations also for Transform and for Quaternion

* update test_stdvector
* Quaternion() does nothing (instead of bug)
* update test_geometry
* some renaming
This commit is contained in:
Benoit Jacob 2009-01-12 16:06:04 +00:00
parent b26e12abcf
commit 4d44ca226e
13 changed files with 192 additions and 44 deletions

View File

@ -132,8 +132,6 @@ class Matrix
protected: protected:
ei_matrix_storage<Scalar, MaxSizeAtCompileTime, RowsAtCompileTime, ColsAtCompileTime, Options> m_storage; ei_matrix_storage<Scalar, MaxSizeAtCompileTime, RowsAtCompileTime, ColsAtCompileTime, Options> m_storage;
Matrix(ei_constructor_without_unaligned_array_assert)
: m_storage(ei_constructor_without_unaligned_array_assert()) {}
public: public:
enum { NeedsToAlign = (Options&AutoAlign) == AutoAlign enum { NeedsToAlign = (Options&AutoAlign) == AutoAlign
@ -339,6 +337,9 @@ class Matrix
ei_assert(RowsAtCompileTime > 0 && ColsAtCompileTime > 0); ei_assert(RowsAtCompileTime > 0 && ColsAtCompileTime > 0);
} }
Matrix(ei_constructor_without_unaligned_array_assert)
: m_storage(ei_constructor_without_unaligned_array_assert()) {}
/** Constructs a vector or row-vector with given dimension. \only_for_vectors /** Constructs a vector or row-vector with given dimension. \only_for_vectors
* *
* Note that this is only useful for dynamic-size vectors. For fixed-size vectors, * Note that this is only useful for dynamic-size vectors. For fixed-size vectors,

View File

@ -303,7 +303,7 @@ inline static int ei_alignmentOffset(const Scalar* ptr, int maxOffset)
EIGEN_WORKAROUND_FOR_QT_BUG_CALLING_WRONG_OPERATOR_NEW EIGEN_WORKAROUND_FOR_QT_BUG_CALLING_WRONG_OPERATOR_NEW
#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true) #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)
#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(Scalar,Size) \ #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar,Size) \
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%16==0)) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%16==0))
/** Deprecated, use the EIGEN_MAKE_ALIGNED_OPERATOR_NEW macro instead in your own class */ /** Deprecated, use the EIGEN_MAKE_ALIGNED_OPERATOR_NEW macro instead in your own class */

View File

@ -41,7 +41,7 @@ template <typename _Scalar, int _AmbientDim>
class AlignedBox class AlignedBox
{ {
public: public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
enum { AmbientDimAtCompileTime = _AmbientDim }; enum { AmbientDimAtCompileTime = _AmbientDim };
typedef _Scalar Scalar; typedef _Scalar Scalar;
typedef typename NumTraits<Scalar>::Real RealScalar; typedef typename NumTraits<Scalar>::Real RealScalar;

View File

@ -47,7 +47,7 @@ template <typename _Scalar, int _AmbientDim>
class Hyperplane class Hyperplane
{ {
public: public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
enum { AmbientDimAtCompileTime = _AmbientDim }; enum { AmbientDimAtCompileTime = _AmbientDim };
typedef _Scalar Scalar; typedef _Scalar Scalar;
typedef typename NumTraits<Scalar>::Real RealScalar; typedef typename NumTraits<Scalar>::Real RealScalar;

View File

@ -43,7 +43,7 @@ template <typename _Scalar, int _AmbientDim>
class ParametrizedLine class ParametrizedLine
{ {
public: public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_AmbientDim) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
enum { AmbientDimAtCompileTime = _AmbientDim }; enum { AmbientDimAtCompileTime = _AmbientDim };
typedef _Scalar Scalar; typedef _Scalar Scalar;
typedef typename NumTraits<Scalar>::Real RealScalar; typedef typename NumTraits<Scalar>::Real RealScalar;

View File

@ -61,17 +61,17 @@ template<typename _Scalar>
class Quaternion : public RotationBase<Quaternion<_Scalar>,3> class Quaternion : public RotationBase<Quaternion<_Scalar>,3>
{ {
typedef RotationBase<Quaternion<_Scalar>,3> Base; typedef RotationBase<Quaternion<_Scalar>,3> Base;
typedef Matrix<_Scalar, 4, 1> Coefficients;
Coefficients m_coeffs;
public: public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,4) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,4)
using Base::operator*; using Base::operator*;
/** the scalar type of the coefficients */ /** the scalar type of the coefficients */
typedef _Scalar Scalar; typedef _Scalar Scalar;
/** the type of the Coefficients 4-vector */
typedef Matrix<Scalar, 4, 1> Coefficients;
/** the type of a 3D vector */ /** the type of a 3D vector */
typedef Matrix<Scalar,3,1> Vector3; typedef Matrix<Scalar,3,1> Vector3;
/** the equivalent rotation matrix type */ /** the equivalent rotation matrix type */
@ -110,8 +110,11 @@ public:
inline Coefficients& coeffs() { return m_coeffs; } inline Coefficients& coeffs() { return m_coeffs; }
/** Default constructor and initializing an identity quaternion. */ /** Default constructor and initializing an identity quaternion. */
inline Quaternion() inline Quaternion() {}
{ m_coeffs << 0, 0, 0, 1; }
inline Quaternion(ei_constructor_without_unaligned_array_assert)
: m_coeffs(ei_constructor_without_unaligned_array_assert()) {}
/** Constructs and initializes the quaternion \f$ w+xi+yj+zk \f$ from /** Constructs and initializes the quaternion \f$ w+xi+yj+zk \f$ from
* its four coefficients \a w, \a x, \a y and \a z. * its four coefficients \a w, \a x, \a y and \a z.
@ -149,7 +152,7 @@ public:
/** \sa Quaternion::Identity(), MatrixBase::setIdentity() /** \sa Quaternion::Identity(), MatrixBase::setIdentity()
*/ */
inline Quaternion& setIdentity() { m_coeffs << 1, 0, 0, 0; return *this; } inline Quaternion& setIdentity() { m_coeffs << 0, 0, 0, 1; return *this; }
/** \returns the squared norm of the quaternion's coefficients /** \returns the squared norm of the quaternion's coefficients
* \sa Quaternion::norm(), MatrixBase::squaredNorm() * \sa Quaternion::norm(), MatrixBase::squaredNorm()
@ -214,6 +217,8 @@ public:
bool isApprox(const Quaternion& other, typename NumTraits<Scalar>::Real prec = precision<Scalar>()) const bool isApprox(const Quaternion& other, typename NumTraits<Scalar>::Real prec = precision<Scalar>()) const
{ return m_coeffs.isApprox(other.m_coeffs, prec); } { return m_coeffs.isApprox(other.m_coeffs, prec); }
protected:
Coefficients m_coeffs;
}; };
/** \ingroup GeometryModule /** \ingroup GeometryModule

View File

@ -43,7 +43,7 @@ template<typename _Scalar, int _Dim>
class Scaling class Scaling
{ {
public: public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_Dim) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
/** dimension of the space */ /** dimension of the space */
enum { Dim = _Dim }; enum { Dim = _Dim };
/** the scalar type of the coefficients */ /** the scalar type of the coefficients */

View File

@ -63,7 +63,7 @@ template<typename _Scalar, int _Dim>
class Transform class Transform
{ {
public: public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1)) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1))
enum { enum {
Dim = _Dim, ///< space dimension in which the transformation holds Dim = _Dim, ///< space dimension in which the transformation holds
HDim = _Dim+1 ///< size of a respective homogeneous vector HDim = _Dim+1 ///< size of a respective homogeneous vector
@ -94,6 +94,9 @@ public:
/** Default constructor without initialization of the coefficients. */ /** Default constructor without initialization of the coefficients. */
inline Transform() { } inline Transform() { }
inline Transform(ei_constructor_without_unaligned_array_assert)
: m_matrix(ei_constructor_without_unaligned_array_assert()) {}
inline Transform(const Transform& other) inline Transform(const Transform& other)
{ {
m_matrix = other.m_matrix; m_matrix = other.m_matrix;

View File

@ -43,7 +43,7 @@ template<typename _Scalar, int _Dim>
class Translation class Translation
{ {
public: public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_Dim) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
/** dimension of the space */ /** dimension of the space */
enum { Dim = _Dim }; enum { Dim = _Dim };
/** the scalar type of the coefficients */ /** the scalar type of the coefficients */

View File

@ -26,6 +26,20 @@
#ifndef EIGEN_STDVECTOR_H #ifndef EIGEN_STDVECTOR_H
#define EIGEN_STDVECTOR_H #define EIGEN_STDVECTOR_H
#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \
typedef Eigen::aligned_allocator<value_type> allocator_type; \
typedef vector<value_type, allocator_type > unaligned_base; \
typedef typename unaligned_base::size_type size_type; \
typedef typename unaligned_base::iterator iterator; \
explicit vector(const allocator_type& __a = allocator_type()) : unaligned_base(__a) {} \
vector(const vector& c) : unaligned_base(c) {} \
vector(size_type num, const value_type& val = value_type()) : unaligned_base(num, val) {}\
vector(iterator start, iterator end) : unaligned_base(start, end) {} \
vector& operator=(const vector& __x) { \
unaligned_base::operator=(__x); \
return *this; \
}
template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename _Alloc> template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename _Alloc>
class vector<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols>, _Alloc> class vector<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols>, _Alloc>
: public vector<Eigen::ei_unaligned_type<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> >, : public vector<Eigen::ei_unaligned_type<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> >,
@ -33,19 +47,27 @@ class vector<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols>, _All
{ {
public: public:
typedef Eigen::ei_unaligned_type<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> > value_type; typedef Eigen::ei_unaligned_type<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> > value_type;
typedef Eigen::aligned_allocator<value_type> allocator_type; EIGEN_STD_VECTOR_SPECIALIZATION_BODY
typedef vector<value_type, allocator_type > unaligned_base; };
typedef typename unaligned_base::size_type size_type;
typedef typename unaligned_base::iterator iterator;
explicit vector(const allocator_type& __a = allocator_type()) : unaligned_base(__a) {} template <typename _Scalar, int _Dim, typename _Alloc>
vector(const vector& c) : unaligned_base(c) {} class vector<Eigen::Transform<_Scalar,_Dim>, _Alloc>
vector(size_type num, const value_type& val = value_type()) : unaligned_base(num, val) {} : public vector<Eigen::ei_unaligned_type<Eigen::Transform<_Scalar,_Dim> >,
vector(iterator start, iterator end) : unaligned_base(start, end) {} Eigen::aligned_allocator<Eigen::ei_unaligned_type<Eigen::Transform<_Scalar,_Dim> > > >
vector& operator=(const vector& __x) { {
unaligned_base::operator=(__x); public:
return *this; typedef Eigen::ei_unaligned_type<Eigen::Transform<_Scalar,_Dim> > value_type;
} EIGEN_STD_VECTOR_SPECIALIZATION_BODY
};
template <typename _Scalar, typename _Alloc>
class vector<Eigen::Quaternion<_Scalar>, _Alloc>
: public vector<Eigen::ei_unaligned_type<Eigen::Quaternion<_Scalar> >,
Eigen::aligned_allocator<Eigen::ei_unaligned_type<Eigen::Quaternion<_Scalar> > > >
{
public:
typedef Eigen::ei_unaligned_type<Eigen::Quaternion<_Scalar> > value_type;
EIGEN_STD_VECTOR_SPECIALIZATION_BODY
}; };
#endif // EIGEN_STDVECTOR_H #endif // EIGEN_STDVECTOR_H

View File

@ -35,12 +35,42 @@ class ei_unaligned_type<Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> >
public: public:
typedef Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> aligned_base; typedef Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> aligned_base;
ei_unaligned_type() : aligned_base(ei_constructor_without_unaligned_array_assert()) {} ei_unaligned_type() : aligned_base(ei_constructor_without_unaligned_array_assert()) {}
ei_unaligned_type(const aligned_base& other) ei_unaligned_type(const aligned_base& other) : aligned_base(ei_constructor_without_unaligned_array_assert())
: aligned_base(ei_constructor_without_unaligned_array_assert())
{ {
resize(other.rows(), other.cols()); resize(other.rows(), other.cols());
ei_assign_impl<ei_unaligned_type,aligned_base,NoVectorization>::run(*this, other); ei_assign_impl<ei_unaligned_type,aligned_base,NoVectorization>::run(*this, other);
} }
}; };
template<typename _Scalar, int _Dim>
class ei_unaligned_type<Transform<_Scalar,_Dim> >
: public Transform<_Scalar,_Dim>
{
public:
typedef Transform<_Scalar,_Dim> aligned_base;
typedef typename aligned_base::MatrixType MatrixType;
ei_unaligned_type() : aligned_base(ei_constructor_without_unaligned_array_assert()) {}
ei_unaligned_type(const aligned_base& other) : aligned_base(ei_constructor_without_unaligned_array_assert())
{
// no resizing here, it's fixed-size anyway
ei_assign_impl<MatrixType,MatrixType,NoVectorization>::run(this->matrix(), other.matrix());
}
};
template<typename _Scalar>
class ei_unaligned_type<Quaternion<_Scalar> >
: public Quaternion<_Scalar>
{
public:
typedef Quaternion<_Scalar> aligned_base;
typedef typename aligned_base::Coefficients Coefficients;
ei_unaligned_type() : aligned_base(ei_constructor_without_unaligned_array_assert()) {}
ei_unaligned_type(const aligned_base& other) : aligned_base(ei_constructor_without_unaligned_array_assert())
{
// no resizing here, it's fixed-size anyway
ei_assign_impl<Coefficients,Coefficients,NoVectorization>::run(this->coeffs(), other.coeffs());
}
};
#endif // EIGEN_UNALIGNEDTYPE_H #endif // EIGEN_UNALIGNEDTYPE_H

View File

@ -52,7 +52,6 @@ template<typename Scalar> void geometry(void)
if (ei_is_same_type<Scalar,float>::ret) if (ei_is_same_type<Scalar,float>::ret)
largeEps = 1e-3f; largeEps = 1e-3f;
Quaternionx q1, q2;
Vector3 v0 = Vector3::Random(), Vector3 v0 = Vector3::Random(),
v1 = Vector3::Random(), v1 = Vector3::Random(),
v2 = Vector3::Random(); v2 = Vector3::Random();
@ -69,6 +68,13 @@ template<typename Scalar> void geometry(void)
(v0.cross(v1).cross(v0)).normalized(); (v0.cross(v1).cross(v0)).normalized();
VERIFY(m.isUnitary()); VERIFY(m.isUnitary());
// Quaternion: Identity(), setIdentity();
Quaternionx q1, q2;
q2.setIdentity();
VERIFY_IS_APPROX(Quaternionx(Quaternionx::Identity()).coeffs(), q2.coeffs());
q1.coeffs().setRandom();
VERIFY_IS_APPROX(q1.coeffs(), (q1*q2).coeffs());
// unitOrthogonal // unitOrthogonal
VERIFY_IS_MUCH_SMALLER_THAN(u0.unitOrthogonal().dot(u0), Scalar(1)); VERIFY_IS_MUCH_SMALLER_THAN(u0.unitOrthogonal().dot(u0), Scalar(1));
VERIFY_IS_MUCH_SMALLER_THAN(v0.unitOrthogonal().dot(v0), Scalar(1)); VERIFY_IS_MUCH_SMALLER_THAN(v0.unitOrthogonal().dot(v0), Scalar(1));

View File

@ -24,9 +24,10 @@
#include "main.h" #include "main.h"
#include <Eigen/StdVector> #include <Eigen/StdVector>
#include <Eigen/Geometry>
template<typename MatrixType> template<typename MatrixType>
void check_stdvector(const MatrixType& m) void check_stdvector_matrix(const MatrixType& m)
{ {
int rows = m.rows(); int rows = m.rows();
int cols = m.cols(); int cols = m.cols();
@ -61,22 +62,102 @@ void check_stdvector(const MatrixType& m)
} }
} }
template<typename TransformType>
void check_stdvector_transform(const TransformType&)
{
typedef typename TransformType::MatrixType MatrixType;
TransformType x(MatrixType::Random()), y(MatrixType::Random());
std::vector<TransformType> v(10), w(20, y);
v[5] = x;
w[6] = v[5];
VERIFY_IS_APPROX(w[6], v[5]);
v = w;
for(int i = 0; i < 20; i++)
{
VERIFY_IS_APPROX(w[i], v[i]);
}
v.resize(21);
v[20] = x;
VERIFY_IS_APPROX(v[20], x);
v.resize(22,y);
VERIFY_IS_APPROX(v[21], y);
v.push_back(x);
VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(TransformType));
// do a lot of push_back such that the vector gets internally resized
// (with memory reallocation)
TransformType* ref = &w[0];
for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
v.push_back(w[i%w.size()]);
for(unsigned int i=23; i<v.size(); ++i)
{
VERIFY(v[i].matrix()==w[(i-23)%w.size()].matrix());
}
}
template<typename QuaternionType>
void check_stdvector_quaternion(const QuaternionType&)
{
typedef typename QuaternionType::Coefficients Coefficients;
QuaternionType x(Coefficients::Random()), y(Coefficients::Random());
std::vector<QuaternionType> v(10), w(20, y);
v[5] = x;
w[6] = v[5];
VERIFY_IS_APPROX(w[6], v[5]);
v = w;
for(int i = 0; i < 20; i++)
{
VERIFY_IS_APPROX(w[i], v[i]);
}
v.resize(21);
v[20] = x;
VERIFY_IS_APPROX(v[20], x);
v.resize(22,y);
VERIFY_IS_APPROX(v[21], y);
v.push_back(x);
VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(QuaternionType));
// do a lot of push_back such that the vector gets internally resized
// (with memory reallocation)
QuaternionType* ref = &w[0];
for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
v.push_back(w[i%w.size()]);
for(unsigned int i=23; i<v.size(); ++i)
{
VERIFY(v[i].coeffs()==w[(i-23)%w.size()].coeffs());
}
}
void test_stdvector() void test_stdvector()
{ {
// some non vectorizable fixed sizes // some non vectorizable fixed sizes
CALL_SUBTEST(check_stdvector(Vector2f())); CALL_SUBTEST(check_stdvector_matrix(Vector2f()));
CALL_SUBTEST(check_stdvector(Matrix3f())); CALL_SUBTEST(check_stdvector_matrix(Matrix3f()));
CALL_SUBTEST(check_stdvector(Matrix3d())); CALL_SUBTEST(check_stdvector_matrix(Matrix3d()));
// some vectorizable fixed sizes // some vectorizable fixed sizes
CALL_SUBTEST(check_stdvector(Matrix2f())); CALL_SUBTEST(check_stdvector_matrix(Matrix2f()));
CALL_SUBTEST(check_stdvector(Vector4f())); CALL_SUBTEST(check_stdvector_matrix(Vector4f()));
CALL_SUBTEST(check_stdvector(Matrix4f())); CALL_SUBTEST(check_stdvector_matrix(Matrix4f()));
CALL_SUBTEST(check_stdvector(Matrix4d())); CALL_SUBTEST(check_stdvector_matrix(Matrix4d()));
// some dynamic sizes // some dynamic sizes
CALL_SUBTEST(check_stdvector(MatrixXd(1,1))); CALL_SUBTEST(check_stdvector_matrix(MatrixXd(1,1)));
CALL_SUBTEST(check_stdvector(VectorXd(20))); CALL_SUBTEST(check_stdvector_matrix(VectorXd(20)));
CALL_SUBTEST(check_stdvector(RowVectorXf(20))); CALL_SUBTEST(check_stdvector_matrix(RowVectorXf(20)));
CALL_SUBTEST(check_stdvector(MatrixXcf(10,10))); CALL_SUBTEST(check_stdvector_matrix(MatrixXcf(10,10)));
// some Transform
CALL_SUBTEST(check_stdvector_transform(Transform2f()));
CALL_SUBTEST(check_stdvector_transform(Transform3f()));
CALL_SUBTEST(check_stdvector_transform(Transform3d()));
//CALL_SUBTEST(check_stdvector_transform(Transform4d()));
// some Quaternion
CALL_SUBTEST(check_stdvector_quaternion(Quaternionf()));
CALL_SUBTEST(check_stdvector_quaternion(Quaternionf()));
} }