# QVM: Quaternions, Vectors, Matrices

### Generic Programming Utilities

#include <boost/qvm/deduce_quat.hpp>
#include <boost/qvm/deduce_vec.hpp>
#include <boost/qvm/deduce_mat.hpp>
#include <boost/qvm/deduce_scalar.hpp>

    namespace boost
    {
        namespace qvm
        {
            //*** Generic programming utilities ***

            template <class Q>
            struct deduce_quat
            {
                typedef Q type;
            };

            template <class A,class B>
            struct deduce_quat2
            {
                typedef /*unspecified*/ type;
            };

            template <
                class V,
                int Dim=vec_traits<Vector>::dim>
            struct deduce_vec
            {
                typedef /*unspecified*/ type;
            };

            template <class A,class B,int Dim>
            struct deduce_vec2
            {
                typedef /*unspecified*/ type;
            };

            template <
                class M,
                int Rows=mat_traits<Matrix>::rows,
                int Cols=mat_traits<Matrix>::cols>
            struct deduce_mat
            {
                typedef /*unspecified*/ type;
            };

            template <class A,class B,int Rows,int Cols>
            struct deduce_mat2
            {
                typedef /*unspecified*/ type;
            };

            template <class A,class B>
            struct deduce_scalar
            {
                typedef typename impl<A,B>::type type;
            };

            template <class Scalar>
            struct scalar_traits
            {
                BOOST_QVM_INLINE_CRITICAL
                static Scalar value( int v )
                {
                    return Scalar(v);
                }
            };

            template <class T>
            struct scalar
            {
                typedef /*exact definition unspecified*/ type;
            };
        }
    }

See also: Boost QVM | Synopsis