Boost QVM

#include <boost/qvm/v.hpp>

namespace boost
{
    namespace qvm
    {
        //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 );
    }
}