Synopsis
#include <boost/qvm/all.hpp>
namespace boost
{
namespace qvm
{
//*** Type traits ***
template <class T>
struct is_q
{
static bool const value=/*unspecified*/;
};
template <class Q>
struct q_traits
{
/*main template members unspecified*/
};
/*
User-defined (possibly partial) specializations:
template <>
struct q_traits<Q>
{
typedef /*user-defined*/ scalar_type;
template <int I> static inline scalar_type r( Quaternion const & q );
template <int I> static inline scalar_type & w( Quaternion & q );
};
*/
template <class T>
struct is_v
{
static bool const value=/*unspecified*/;
};
template <class V>
struct v_traits
{
/*main template members unspecified*/
};
/*
User-defined (possibly partial) specializations:
template <>
struct v_traits<V>
{
static int const dim = /*user-defined*/;
typedef /*user-defined*/ scalar_type;
template <int I> static inline scalar_type r( Vector const & v );
template <int I> static inline scalar_type & w( Vector & v );
static inline scalar_type ir( int i, Vector const & v );
static inline scalar_type & iw( int i, Vector & v );
};
*/
template <class T>
struct is_m
{
static bool const value=/*unspecified*/;
};
template <class M>
struct m_traits
{
/*main template members unspecified*/
};
/*
User-defined (possibly partial) specializations:
template <>
struct m_traits<M>
{
static int const rows = /*user-defined*/;
static int const cols = /*user-defined*/;
typedef /*user-defined*/ scalar_type;
template <int R,int C> static inline scalar_type r( Matrix const & m );
template <int R,int C> static inline scalar_type & w( Matrix & m );
static inline scalar_type ir( int r, int c, Matrix const & m );
static inline scalar_type & iw( int r, int c, Matrix & m );
};
*/
//*** Quaternion, vector and matrix types ***
template <class T>
struct quat
{
T a[4];
template <class R>
operator R() const
{
R r;
assign(r,*this);
return r;
}
};
template <class Quaternion>
struct q_traits;
template <class T>
struct q_traits< quat<T> >
{
typedef T scalar_type;
template <int I> static scalar_type r( quat<T> const & x ) { return x.a[I]; }
template <int I> static scalar_type & w( quat<T> & x ) { return x.a[I]; }
};
template <class T,int Dim>
struct vec
{
T a[Dim];
template <class R>
operator R() const
{
R r;
assign(r,*this);
return r;
}
};
template <class Vector>
struct v_traits;
template <class T,int Dim>
struct v_traits< vec<T,Dim> >
{
typedef T scalar_type;
static int const dim=Dim;
template <int I> static scalar_type r( vec<T,Dim> const & x ) { return x.a[I]; }
template <int I> static scalar_type & w( vec<T,Dim> & x ) { return x.a[I]; }
static scalar_type ir( int i, vec<T,Dim> const & x ) { return x.a[i]; }
static scalar_type & iw( int i, vec<T,Dim> & x ) { return x.a[i]; }
};
template <class T,int Rows,int Cols>
struct mat
{
T a[Rows][Cols];
template <class R>
operator R() const
{
R r;
assign(r,*this);
return r;
}
};
template <class Matrix>
struct m_traits;
template <class T,int Rows,int Cols>
struct m_traits< mat<T,Rows,Cols> >
{
typedef T scalar_type;
static int const rows=Rows;
static int const cols=Cols;
template <int Row,int Col> static scalar_type r( mat<T,Rows,Cols> const & x ) { return x.a[Row][Col]; }
template <int Row,int Col> static scalar_type & w( mat<T,Rows,Cols> & x ) { return x.a[Row][Col]; }
static scalar_type ir( int row, int col, mat<T,Rows,Cols> const & x ) { return x.a[row][col]; }
static scalar_type & iw( int row, int col, mat<T,Rows,Cols> & x ) { return x.a[row][col]; }
};
//*** Accessing quaternion elements ***
-unspecified-return-type- V();
-unspecified-return-type- S();
//*** Accessing vector elements, swizzling ***
template <int I>
-unspecified-return-type- A();
-unspecified-return-type- A0();
-unspecified-return-type- A1();
...
-unspecified-return-type- A9();
-unspecified-return-type- X();
-unspecified-return-type- Y();
-unspecified-return-type- Z();
-unspecified-return-type- W();
struct _x_;
struct _y_;
struct _z_;
struct _w_;
struct _0_;
struct _1_;
template <int I1,int I2,...int IN>
-unspecified-return-type- sw();
template <class A1,class A2,...class AN>
-unspecified-return-type- sw();
//2D view proxies:
-unspecified-return-type- XX();
-unspecified-return-type- XY();
-unspecified-return-type- XZ();
-unspecified-return-type- XW();
-unspecified-return-type- X0();
-unspecified-return-type- X1();
-unspecified-return-type- YX();
-unspecified-return-type- YY();
-unspecified-return-type- YZ();
-unspecified-return-type- YW();
-unspecified-return-type- Y0();
-unspecified-return-type- Y1();
-unspecified-return-type- ZX();
-unspecified-return-type- ZY();
-unspecified-return-type- ZZ();
-unspecified-return-type- ZW();
-unspecified-return-type- Z0();
-unspecified-return-type- Z1();
-unspecified-return-type- WX();
-unspecified-return-type- WY();
-unspecified-return-type- WZ();
-unspecified-return-type- WW();
-unspecified-return-type- W0();
-unspecified-return-type- W1();
//3D view proxies:
-unspecified-return-type- XXX();
...
-unspecified-return-type- XXW();
-unspecified-return-type- XX0();
-unspecified-return-type- XX1();
-unspecified-return-type- XYX();
...
-unspecified-return-type- XY1();
...
-unspecified-return-type- WW1();
//4D view proxies:
-unspecified-return-type- XXXX();
...
-unspecified-return-type- XXXW();
-unspecified-return-type- XXX0();
-unspecified-return-type- XXX1();
-unspecified-return-type- XXYX();
...
-unspecified-return-type- XXY1();
...
-unspecified-return-type- WWW1();
//*** Indexing vector elements ***
//Only enabled if:
// is_v<A>::value
template <class A>
typename v_traits<A>::scalar_type
v_index_read( A const & a, int i );
//Only enabled if:
// is_v<A>::value
template <class A>
typename v_traits<A>::scalar_type &
v_index_write( A & a, int i );
//*** Accessing matrix elements ***
template <int R,int C>
-unspecified-return-type- A();
-unspecified-return-type- A00();
-unspecified-return-type- A01();
...
-unspecified-return-type- A09();
-unspecified-return-type- A10();
...
...
-unspecified-return-type- A99();
//*** Indexing matrix elements ***
//Only enabled if:
// is_m<A>::value
template <class A>
typename m_traits<A>::scalar_type
m_index_read( A const & a, int r, int c );
//Only enabled if:
// is_m<A>::value
template <class A>
typename m_traits<A>::scalar_type &
m_index_write( A & a, int r, int c );
//*** Quaternion operations ***
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
A & assign( A & a, B const & b );
//Only enabled if:
// is_q<R>::value && is_q<A>::value
template <class R,class A>
R make( A const & a );
//Only enabled if:
// is_q<R>::value && is_m<A>::value &&
// m_traits<A>::rows==3 && m_traits<A>::cols==3
template <class R,class A>
R make( A const & m );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
A & operator-=( A & a, B const & b );
//Only enabled if: is_q<A>::value
template <class A>
typename deduce_q<A>::type
operator-( A const & a );
//Only enabled if:
// is_q<A>::value && is_q<B>::value &&
template <class A,class B>
typename deduce_q2<A,B>::type
operator-( A const & a, B const & b );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
A & operator+=( A & a, B const & b );
//Only enabled if:
// is_q<A>::value && is_q<B>::value &&
template <class A,class B>
typename deduce_q2<A,B>::type
operator+( A const & a, B const & b );
//Only enabled if: is_q<A>::value
template <class A>
A & operator/=( A & a, q_traits<A>::scalar_type s );
//Only enabled if: is_q<A>::value
template <class A>
typename deduce_q<A>::type
operator/( A const & a, q_traits<A>::scalar_type s );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
A & operator*=( A & a, B const & b );
//Only enabled if: is_q<A>::value
template <class A>
A & operator*=( A & a, q_traits<A>::scalar_type s );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
typename deduce_q2<A,B>::type
operator*( A const & a, B const & b );
//Only enabled if: is_q<A>::value
template <class A>
typename deduce_q<A>::type
operator*( A const & a, q_traits<A>::scalar_type s );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
bool operator==( A const & a, B const & b );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
bool operator!=( A const & a, B const & b );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B,class Cmp>
bool cmp( A const & a, B const & b, Cmp pred );
//Only enabled if: is_q<A>::value
template <class A>
typename q_traits<A>::scalar_type
mag2( A const & a );
//Only enabled if: is_q<A>::value
template <class A>
typename q_traits<A>::scalar_type
mag( A const & a );
//Only enabled if: is_q<A>::value
template <class A>
typename deduce_q<A>::type
normalized( A const & a );
//Only enabled if: is_q<A>::value
template <class A>
void normalize( A & a );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
typename deduce_s<A,B>::type
dot( A const & a, B const & b );
//Only enabled if: is_q<A>::value
template <class A>
typename deduce_q<A>::type
conjugate( A const & a );
//Only enabled if: is_q<A>::value
template <class A>
typename deduce_q<A>::type
inverse( A const & a );
//Only enabled if:
// is_q<A>::value && is_q<B>::value
template <class A,class B>
typename deduce_q2<A,B> >::type
slerp( A const & a, B const & b, typename q_traits<typename deduce_q2<A,B>::type>::scalar_type t );
template <class T>
-unspecified-return-type- zero_q();
//Only enabled if: is_q<A>::value
template <class A>
void set_zero( A & a );
template <class S>
-unspecified-return-type- identity_q();
//Only enabled if: is_q<A>::value
template <class A>
void set_identity( A & a );
//Only enabled if:
// is_v<A>::value && v_traits<A>::dim==3
template <class A>
-unspecified-return-type- rot_q( A const & axis, typename v_traits<A>::scalar_type angle );
//Only enabled if:
// is_q<A>::value &&
// is_v<B>::value && v_traits<B>::dim==3
template <class A>
void set_rot( A & a, B const & axis, typename v_traits<B>::scalar_type angle );
//Only enabled if:
// is_q<A>::value &&
// is_v<B>::value && v_traits<B>::dim==3
template <class A,class B>
void rotate( A & a, B const & axis, typename q_traits<A>::scalar_type angle );
template <class Angle>
-unspecified-return-type- rotx_q( Angle const & angle );
//Only enabled if: is_q<A>::value
template <class A>
void set_rotx( A & a, typename q_traits<A>::scalar_type angle );
//Only enabled if: is_q<A>::value
template <class A>
void rotate_x( A & a, typename q_traits<A>::scalar_type angle );
template <class Angle>
-unspecified-return-type- roty_q( Angle const & angle );
//Only enabled if: is_q<A>::value
template <class A>
void set_rotz( A & a, typename q_traits<A>::scalar_type angle );
//Only enabled if: is_q<A>::value
template <class A>
void rotate_y( A & a, typename q_traits<A>::scalar_type angle );
template <class Angle>
-unspecified-return-type- rotz_q( Angle const & angle );
//Only enabled if: is_q<A>::value
template <class A>
void set_rotz( A & a, typename q_traits<A>::scalar_type angle );
//Only enabled if: is_q<A>::value
template <class A>
void rotate_z( A & a, typename q_traits<A>::scalar_type angle );
//Only enabled if: is_q<A>::value
template <class Scalar,class A>
-unspecified-return_type- scalar_cast( A const & a );
//Only enabled if: is_q<A>::value
template <class A>
-unspecified-return-type- qref( A & a );
//*** Vector operations ***
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B>
A & assign( A & a, B const & b );
//Only enabled if:
// is_v<R>::value && is_v<A>::value &&
// v_traits<R>::dim==v_traits<A>::dim
template <class R,class A>
R make( A const & a );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B>
A & operator-=( A & a, B const & b );
//Only enabled if: is_v<A>::value
template <class A>
typename deduce_v<A>::type
operator-( A const & a );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B>
typename deduce_v2<A,B,v_traits<A>::dim>::type
operator-( A const & a, B const & b );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B>
A & operator+=( A & a, B const & b );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B>
typename deduce_v2<A,B,v_traits<A>::dim>::type
operator+( A const & a, B const & b );
//Only enabled if: is_v<A>::value
template <class A>
A & operator/=( A & a, v_traits<A>::scalar_type s );
//Only enabled if: is_v<A>::value
template <class A>
typename deduce_v<A>::type
operator/( A const & a, v_traits<A>::scalar_type s );
//Only enabled if: is_v<A>::value
template <class A>
A & operator*=( A & a, v_traits<A>::scalar_type s );
//Only enabled if: is_v<A>::value
template <class A>
typename deduce_v<A>::type
operator*( A const & a, v_traits<A>::scalar_type s );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B>
bool operator==( A const & a, B const & b );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B>
bool operator!=( A const & a, B const & b );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B,class Cmp>
bool cmp( A const & a, B const & b, Cmp pred );
//Only enabled if:
// is_v<A>::value
template <class A>
typename v_traits<A>::scalar_type
mag2( A const & a );
//Only enabled if:
// is_v<A>::value
template <class A>
typename v_traits<A>::scalar_type
mag( A const & a );
//Only enabled if:
// is_v<A>::value
template <class A>
typename deduce_v<A>::type
normalized( A const & a );
//Only enabled if:
// is_v<A>::value
template <class A>
void normalize( A & a );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==v_traits<B>::dim
template <class A,class B>
typename deduce_s<A,B>::type
dot( A const & a, B const & b );
//Only enabled if:
// is_v<A>::value && is_v<B>::value &&
// v_traits<A>::dim==3 && v_traits<B>::dim==3
template <class A,class B>
typename deduce_v2<A,B,3>::type
cross( A const & a, B const & b );
template <class T,int S>
-unspecified-return-type- zero_v();
//Only enabled if:
// is_v<A>::value
template <class A>
void set_zero( A & a );
//Only enabled if: is_v<A>::value
template <class A>
-unspecified-return-type- vref( A & a );
//Only enabled if: is_v<A>::value
template <class Scalar,class A>
-unspecified-return_type- scalar_cast( A const & a );
//*** Matrix operations ***
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B>
A & assign( A & a, B const & b );
//Only enabled if:
// is_m<R>::value && is_m<A>::value &&
// m_traits<R>::rows==m_traits<A>::rows &&
// m_traits<R>::cols==m_traits<A>::cols
template <class R,class A>
R make( A const & a );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B>
A & operator-=( A & a, B const & b );
//Only enabled if: is_m<A>::value
template <class A>
typename deduce_m<A>::type
operator-( A const & a );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B>
typename deduce_m2<A,B,m_traits<A>::rows,m_traits<A>::cols>::type
operator-( A const & a, B const & b );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B>
A & operator+=( A & a, B const & b );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B>
typename deduce_m2<A,B,m_traits<A>::rows,m_traits<A>::cols>::type
operator+( A const & a, B const & b );
//Only enabled if: is_m<A>::value
template <class A>
A & operator/=( A & a, m_traits<A>::scalar_type s );
//Only enabled if: is_m<A>::value
template <class A>
typename deduce_m<A>::type
operator/( A const & a, m_traits<A>::scalar_type s );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<A>::cols &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B>
A & operator*=( A & a, B const & b );
//Only enabled if: is_m<A>::value
template <class A>
A & operator*=( A & a, m_traits<A>::scalar_type s );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::cols==m_traits<B>::rows
template <class A,class B>
typename deduce_m2<A,B,m_traits<A>::rows,m_traits<B>::cols>::type
operator*( A const & a, B const & b );
//Only enabled if: is_m<A>::value
template <class A>
typename deduce_m<A>::type
operator*( A const & a, m_traits<A>::scalar_type s );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B>
bool operator==( A const & a, B const & b );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B>
bool operator!=( A const & a, B const & b );
//Only enabled if:
// is_m<A>::value && is_m<B>::value &&
// m_traits<A>::rows==m_traits<B>::rows &&
// m_traits<A>::cols==m_traits<B>::cols
template <class A,class B,class Cmp>
bool cmp( A const & a, B const & b, Cmp pred );
//Only enabled if:
// is_m<A>::value &&
// m_traits<A>::rows==m_traits<A>::cols
template <class A>
typename deduce_m<A>::type
inverse( A const & a, m_traits<A>::scalar_type det );
template <class A>
typename deduce_m<A>::type
inverse( A const & a );
template <class T,int D>
-unspecified-return-type- zero_m();
template <class T,int R,int C>
-unspecified-return-type- zero_m();
//Only enabled if:
// is_m<A>::value
template <class A>
void set_zero( A & a );
template <class S,int D>
-unspecified-return-type- identity_m();
//Only enabled if:
// is_m<A>::value &&
// m_traits<A>::cols==m_traits<A>::rows
template <class A>
void set_identity( A & a );
//Only enabled if:
// is_v<A>::value && v_traits<A>::dim==3
template <int Dim,class A>
-unspecified-return-type
rot_m( A const & axis, typename v_traits<A>::scalar_type angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows>=3 &&
// m_traits<A>::rows==m_traits<A>::cols &&
// is_v<B>::value && v_traits<B>::dim==3
template <class A>
void set_rot( A & a, B const & axis, typename v_traits<B>::scalar_type angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows>=3 &&
// m_traits<A>::rows==m_traits<A>::cols &&
// is_v<B>::value && v_traits<B>::dim==3
template <class A,class B>
void rotate( A & a, B const & axis, typename m_traits<A>::scalar_type angle );
template <int Dim,class Angle>
-unspecified-return-type- rotx_m( Angle angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows>=3 &&
// m_traits<A>::rows==m_traits<A>::cols
template <class A>
void set_rotx( A & a, typename m_traits<A>::scalar_type angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows>=3 &&
// m_traits<A>::rows==m_traits<A>::cols
template <class A>
void rotate_x( A & a, typename m_traits<A>::scalar_type angle );
template <int Dim,class Angle>
-unspecified-return-type- roty_m( Angle angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows>=3 &&
// m_traits<A>::rows==m_traits<A>::cols
template <class A>
void set_roty( A & a, typename m_traits<A>::scalar_type angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows>=3 &&
// m_traits<A>::rows==m_traits<A>::cols
template <class A>
void rotate_y( A & a, typename m_traits<A>::scalar_type angle );
template <int Dim,class Angle>
-unspecified-return-type- rotz_m( Angle angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows>=3 &&
// m_traits<A>::rows==m_traits<A>::cols
template <class A>
void set_rotz( A & a, typename m_traits<A>::scalar_type angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows>=3 &&
// m_traits<A>::rows==m_traits<A>::cols
template <class A>
void rotate_z( A & a, typename m_traits<A>::scalar_type angle );
//Only enabled if:
// is_m<A>::value && m_traits<A>::rows==m_traits<A>::cols
template <class A>
m_traits<A>::scalar_type
determinant( A const & a );
template <class T>
-unspecified-return-type
perspective_lh( T fov_y, T aspect, T zn, T zf );
template <class T>
-unspecified-return-type
perspective_rh( T fov_y, T aspect, T zn, T zf );
//Only enabled if: is_m<A>::value
template <class A>
-unspecified-return-type- mref( A & a );
//Only enabled if: is_m<A>::value
template <class Scalar,class A>
-unspecified-return_type- scalar_cast( A const & a );
//*** Quaternion-Vector operations ***
//Only enabled if:
// is_q<A>::value &&
// is_v<B>::value && v_traits<B>::dim==3
template <class A,class B>
typename deduce_v2<A,B,3>::type
operator*( A const & a, B const & b );
//*** Vector-Matrix operations ***
//Only enabled if:
// is_m<A>::value && is_v<B>::value &&
// m_traits<A>::cols==v_traits<B>::dim
template <class A,class B>
typename deduce_v2<A,B,m_traits<A>::rows>::type
operator*( A const & a, B const & b );
//Only enabled if:
// is_m<A>::value && is_v<B>::value &&
// m_traits<A>::rows==4 && m_traits<A>::cols==4 &&
// v_traits<B>::dim==3
template <class A,class B>
deduce_v2<A,B,3> >::type
transform_vector( A const & a, B const & b );
//Only enabled if:
// is_m<A>::value && is_v<B>::value &&
// m_traits<A>::rows==4 && m_traits<A>::cols==4 &&
// v_traits<B>::dim==3
template <class A,class B>
deduce_v2<A,B,3> >::type
transform_point( A const & a, B const & b );
//*** Matrix-to-matrix view proxies ***
template <int R>
-unspecified-return-type- delr();
template <int C>
-unspecified-return-type- delc();
template <int R,int C>
-unspecified-return-type- delrc();
template <int R>
-unspecified-return-type- negr();
template <int C>
-unspecified-return-type- negc();
-unspecified-return-type- transp();
//*** Vector-to-matrix view proxies ***
//Only enabled if: is_v<A>::value
template <iclass A>
-unspecified-return-type- col_m( A & a );
//Only enabled if: is_v<A>::value
template <iclass A>
-unspecified-return-type- row_m( A & a );
//Only enabled if: is_v<A>::value
template <iclass A>
-unspecified-return-type- trans_m( A & a );
//Only enabled if: is_v<A>::value
template <iclass A>
-unspecified-return-type- diag_m( A & a );
//*** Matrix-to-vector view proxies ***
//Only enabled if: is_m<A>::value
template <int C,class A>
-unspecified-return-type- col( A & a );
//Only enabled if: is_m<A>::value
template <int C,class A>
-unspecified-return-type- row( A & a );
//Only enabled if: is_m<A>::value
template <class A>
-unspecified-return-type- diag( A & a );
//Only enabled if:
// is_m<A>::value &&
// m_traits<A>::rows==m_traits<A>::cols && m_traits<A>::rows>=3
template <class A>
-unspecified-return-type- trans( A & a );
//*** Generic programming utilities ***
template <class Q>
struct deduce_q
{
typedef Q type;
};
template <class A,class B>
struct deduce_q2
{
typedef /*unspecified*/ type;
};
template <
class V,
int Dim=v_traits<Vector>::dim>
struct deduce_v
{
typedef /*unspecified*/ type;
};
template <class A,class B,int Dim>
struct deduce_v2
{
typedef /*unspecified*/ type;
};
template <
class M,
int Rows=m_traits<Matrix>::rows,
int Cols=m_traits<Matrix>::cols>
struct deduce_m
{
typedef /*unspecified*/ type;
};
template <class A,class B,int Rows,int Cols>
struct deduce_m2
{
typedef /*unspecified*/ type;
};
template <class A,class B>
struct deduce_s
{
typedef typename impl<A,B>::type type;
};
template <class Scalar>
struct s_traits
{
BOOST_QVM_INLINE_CRITICAL
static Scalar value( int v )
{
return Scalar(v);
}
};
template <class T>
struct scalar
{
typedef /*exact definition unspecified*/ type;
};
//*** Exception types ***
struct error:
virtual boost::exception,
virtual std::exception
{
};
struct zero_determinant_error: virtual error { };
struct zero_magnitude_error: virtual error { };
}
}
//*** Macros ***
#ifndef BOOST_QVM_FORCE_INLINE
#define BOOST_QVM_FORCE_INLINE /*platform-specific*/
#endif
#ifndef BOOST_QVM_INLINE
#define BOOST_QVM_INLINE inline
#endif
#ifndef BOOST_QVM_INLINE_TRIVIAL
#define BOOST_QVM_INLINE_TRIVIAL BOOST_QVM_FORCE_INLINE
#endif
#ifndef BOOST_QVM_INLINE_CRITICAL
#define BOOST_QVM_INLINE_CRITICAL BOOST_QVM_FORCE_INLINE
#endif
#ifndef BOOST_QVM_INLINE_OPERATIONS
#define BOOST_QVM_INLINE_OPERATIONS BOOST_QVM_INLINE
#endif
#ifndef BOOST_QVM_INLINE_RECURSION
#define BOOST_QVM_INLINE_RECURSION BOOST_QVM_INLINE_OPERATIONS
#endif
#ifndef BOOST_QVM_ASSERT
#include <boost/assert.hpp>
#define BOOST_QVM_ASSERT BOOST_ASSERT
#endif
#include <boost/static_assert.hpp>
#define BOOST_QVM_STATIC_ASSERT BOOST_STATIC_ASSERT
Copyright (c) 2008-2013 by Emil Dotchevski and Reverge Studios, Inc.
Distributed under the Boost Software License, Version 1.0.