[ceph.git] / ceph / src / boost / boost / qvm / gen / vec_operations3.hpp

#ifndef BOOST_QVM_GEN_VEC_OPERATIONS3_HPP_INCLUDED
#define BOOST_QVM_GEN_VEC_OPERATIONS3_HPP_INCLUDED

// Copyright 2008-2022 Emil Dotchevski and Reverge Studios, Inc.

// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// This file was generated by a program. Do not edit manually.

#include <boost/qvm/deduce_scalar.hpp>
#include <boost/qvm/deduce_vec.hpp>
#include <boost/qvm/error.hpp>
#include <boost/qvm/gen/vec_assign3.hpp>
#include <boost/qvm/math.hpp>
#include <boost/qvm/static_assert.hpp>
#include <boost/qvm/throw_exception.hpp>

namespace boost { namespace qvm {

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename lazy_enable_if_c<
    vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
    deduce_vec2<A,B,3> >::type
operator+( A const & a, B const & b )
    {
    typedef typename deduce_vec2<A,B,3>::type R;
    BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
    R r;
    vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)+vec_traits<B>::template read_element<0>(b);
    vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)+vec_traits<B>::template read_element<1>(b);
    vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)+vec_traits<B>::template read_element<2>(b);
    return r;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator+;
    }

namespace
qvm_detail
    {
    template <int D>
    struct plus_vv_defined;

    template <>
    struct
    plus_vv_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename lazy_enable_if_c<
    vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
    deduce_vec2<A,B,3> >::type
operator-( A const & a, B const & b )
    {
    typedef typename deduce_vec2<A,B,3>::type R;
    BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
    R r;
    vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)-vec_traits<B>::template read_element<0>(b);
    vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)-vec_traits<B>::template read_element<1>(b);
    vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)-vec_traits<B>::template read_element<2>(b);
    return r;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator-;
    }

namespace
qvm_detail
    {
    template <int D>
    struct minus_vv_defined;

    template <>
    struct
    minus_vv_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
    A &>::type
operator+=( A & a, B const & b )
    {
    vec_traits<A>::template write_element<0>(a)+=vec_traits<B>::template read_element<0>(b);
    vec_traits<A>::template write_element<1>(a)+=vec_traits<B>::template read_element<1>(b);
    vec_traits<A>::template write_element<2>(a)+=vec_traits<B>::template read_element<2>(b);
    return a;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator+=;
    }

namespace
qvm_detail
    {
    template <int D>
    struct plus_eq_vv_defined;

    template <>
    struct
    plus_eq_vv_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
    A &>::type
operator-=( A & a, B const & b )
    {
    vec_traits<A>::template write_element<0>(a)-=vec_traits<B>::template read_element<0>(b);
    vec_traits<A>::template write_element<1>(a)-=vec_traits<B>::template read_element<1>(b);
    vec_traits<A>::template write_element<2>(a)-=vec_traits<B>::template read_element<2>(b);
    return a;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator-=;
    }

namespace
qvm_detail
    {
    template <int D>
    struct minus_eq_vv_defined;

    template <>
    struct
    minus_eq_vv_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename lazy_enable_if_c<
    vec_traits<A>::dim==3 && is_scalar<B>::value,
    deduce_vec2<A,B,vec_traits<A>::dim> >::type
operator*( A const & a, B b )
    {
    typedef typename deduce_vec2<A,B,vec_traits<A>::dim>::type R;
    R r;
    vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)*b;
    vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)*b;
    vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)*b;
    return r;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator*;
    }

namespace
qvm_detail
    {
    template <int D>
    struct mul_vs_defined;

    template <>
    struct
    mul_vs_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename lazy_enable_if_c<
    is_scalar<A>::value && vec_traits<B>::dim==3,
    deduce_vec2<A,B,vec_traits<B>::dim> >::type
operator*( A a, B const & b )
    {
    typedef typename deduce_vec2<A,B,vec_traits<B>::dim>::type R;
    R r;
    vec_traits<R>::template write_element<0>(r)=a*vec_traits<B>::template read_element<0>(b);
    vec_traits<R>::template write_element<1>(r)=a*vec_traits<B>::template read_element<1>(b);
    vec_traits<R>::template write_element<2>(r)=a*vec_traits<B>::template read_element<2>(b);
    return r;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator*;
    }

namespace
qvm_detail
    {
    template <int D>
    struct mul_sv_defined;

    template <>
    struct
    mul_sv_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class  B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    vec_traits<A>::dim==3 && is_scalar<B>::value,
    A &>::type
operator*=( A & a, B b )
    {
    vec_traits<A>::template write_element<0>(a)*=b;
    vec_traits<A>::template write_element<1>(a)*=b;
    vec_traits<A>::template write_element<2>(a)*=b;
    return a;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator*=;
    }

namespace
qvm_detail
    {
    template <int D>
    struct mul_eq_vs_defined;

    template <>
    struct
    mul_eq_vs_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename lazy_enable_if_c<
    vec_traits<A>::dim==3 && is_scalar<B>::value,
    deduce_vec2<A,B,vec_traits<A>::dim> >::type
operator/( A const & a, B b )
    {
    typedef typename deduce_vec2<A,B,vec_traits<A>::dim>::type R;
    R r;
    vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)/b;
    vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)/b;
    vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)/b;
    return r;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator/;
    }

namespace
qvm_detail
    {
    template <int D>
    struct div_vs_defined;

    template <>
    struct
    div_vs_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class  B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    vec_traits<A>::dim==3 && is_scalar<B>::value,
    A &>::type
operator/=( A & a, B b )
    {
    vec_traits<A>::template write_element<0>(a)/=b;
    vec_traits<A>::template write_element<1>(a)/=b;
    vec_traits<A>::template write_element<2>(a)/=b;
    return a;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator/=;
    }

namespace
qvm_detail
    {
    template <int D>
    struct div_eq_vs_defined;

    template <>
    struct
    div_eq_vs_defined<3>
        {
        static bool const value=true;
        };
    }

template <class R,class A>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    is_vec<A>::value &&
    vec_traits<R>::dim==3 && vec_traits<A>::dim==3,
    R>::type
convert_to( A const & a )
    {
    R r;
    vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a);
    vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a);
    vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a);
    return r;
    }

namespace
sfinae
    {
    using ::boost::qvm::convert_to;
    }

namespace
qvm_detail
    {
    template <int D>
    struct convert_to_v_defined;

    template <>
    struct
    convert_to_v_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
bool>::type
operator==( A const & a, B const & b )
    {
    return
        vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b) &&
        vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b) &&
        vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b);
    }

namespace
sfinae
    {
    using ::boost::qvm::operator==;
    }

namespace
qvm_detail
    {
    template <int D>
    struct eq_vv_defined;

    template <>
    struct
    eq_vv_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
bool>::type
operator!=( A const & a, B const & b )
    {
    return
        !(vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b)) ||
        !(vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b)) ||
        !(vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b));
    }

namespace
sfinae
    {
    using ::boost::qvm::operator!=;
    }

namespace
qvm_detail
    {
    template <int D>
    struct neq_vv_defined;

    template <>
    struct
    neq_vv_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename lazy_enable_if_c<
    vec_traits<A>::dim==3,
    deduce_vec<A> >::type
operator-( A const & a )
    {
    typedef typename deduce_vec<A>::type R;
    R r;
    vec_traits<R>::template write_element<0>(r)=-vec_traits<A>::template read_element<0>(a);
    vec_traits<R>::template write_element<1>(r)=-vec_traits<A>::template read_element<1>(a);
    vec_traits<R>::template write_element<2>(r)=-vec_traits<A>::template read_element<2>(a);
    return r;
    }

namespace
sfinae
    {
    using ::boost::qvm::operator-;
    }

namespace
qvm_detail
    {
    template <int D>
    struct minus_v_defined;

    template <>
    struct
    minus_v_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    is_vec<A>::value && vec_traits<A>::dim==3,
    typename vec_traits<A>::scalar_type>::type
mag( A const & a )
    {
    typedef typename vec_traits<A>::scalar_type T;
    T const a0=vec_traits<A>::template read_element<0>(a);
    T const a1=vec_traits<A>::template read_element<1>(a);
    T const a2=vec_traits<A>::template read_element<2>(a);
    T const m2=a0*a0+a1*a1+a2*a2;
    T const mag=sqrt(m2);
    return mag;
    }

namespace
sfinae
    {
    using ::boost::qvm::mag;
    }

namespace
qvm_detail
    {
    template <int D>
    struct mag_v_defined;

    template <>
    struct
    mag_v_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    is_vec<A>::value && vec_traits<A>::dim==3,
    typename vec_traits<A>::scalar_type>::type
mag_sqr( A const & a )
    {
    typedef typename vec_traits<A>::scalar_type T;
    T const a0=vec_traits<A>::template read_element<0>(a);
    T const a1=vec_traits<A>::template read_element<1>(a);
    T const a2=vec_traits<A>::template read_element<2>(a);
    T const m2=a0*a0+a1*a1+a2*a2;
    return m2;
    }

namespace
sfinae
    {
    using ::boost::qvm::mag_sqr;
    }

namespace
qvm_detail
    {
    template <int D>
    struct mag_sqr_v_defined;

    template <>
    struct
    mag_sqr_v_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename lazy_enable_if_c<
    vec_traits<A>::dim==3,
    deduce_vec<A> >::type
normalized( A const & a )
    {
    typedef typename vec_traits<A>::scalar_type T;
    T const a0=vec_traits<A>::template read_element<0>(a);
    T const a1=vec_traits<A>::template read_element<1>(a);
    T const a2=vec_traits<A>::template read_element<2>(a);
    T const m2=a0*a0+a1*a1+a2*a2;
    if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
        BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
    T const rm=scalar_traits<T>::value(1)/sqrt(m2);
    typedef typename deduce_vec<A>::type R;
    R r;
    vec_traits<R>::template write_element<0>(r)=a0*rm;
    vec_traits<R>::template write_element<1>(r)=a1*rm;
    vec_traits<R>::template write_element<2>(r)=a2*rm;
    return r;
    }

namespace
sfinae
    {
    using ::boost::qvm::normalized;
    }

template <class A>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename enable_if_c<
    vec_traits<A>::dim==3,
    void>::type
normalize( A & a )
    {
    typedef typename vec_traits<A>::scalar_type T;
    T const a0=vec_traits<A>::template read_element<0>(a);
    T const a1=vec_traits<A>::template read_element<1>(a);
    T const a2=vec_traits<A>::template read_element<2>(a);
    T const m2=a0*a0+a1*a1+a2*a2;
    if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
        BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
    T const rm=scalar_traits<T>::value(1)/sqrt(m2);
    vec_traits<A>::template write_element<0>(a)*=rm;
    vec_traits<A>::template write_element<1>(a)*=rm;
    vec_traits<A>::template write_element<2>(a)*=rm;
    }

namespace
sfinae
    {
    using ::boost::qvm::normalize;
    }

namespace
qvm_detail
    {
    template <int D>
    struct normalize_v_defined;

    template <>
    struct
    normalize_v_defined<3>
        {
        static bool const value=true;
        };
    }

template <class A,class B>
BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
typename lazy_enable_if_c<
    vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
    deduce_scalar<typename vec_traits<A>::scalar_type,typename vec_traits<B>::scalar_type> >::type
dot( A const & a, B const & b )
    {
    typedef typename vec_traits<A>::scalar_type Ta;
    typedef typename vec_traits<B>::scalar_type Tb;
    typedef typename deduce_scalar<Ta,Tb>::type Tr;
    Ta const a0=vec_traits<A>::template read_element<0>(a);
    Ta const a1=vec_traits<A>::template read_element<1>(a);
    Ta const a2=vec_traits<A>::template read_element<2>(a);
    Tb const b0=vec_traits<B>::template read_element<0>(b);
    Tb const b1=vec_traits<B>::template read_element<1>(b);
    Tb const b2=vec_traits<B>::template read_element<2>(b);
    Tr const dot=a0*b0+a1*b1+a2*b2;
    return dot;
    }

namespace
sfinae
    {
    using ::boost::qvm::dot;
    }

namespace
qvm_detail
    {
    template <int D>
    struct dot_vv_defined;

    template <>
    struct
    dot_vv_defined<3>
        {
        static bool const value=true;
        };
    }

} }

#endif
Commit	Line	Data
1e59de90 TL	1	#ifndef BOOST_QVM_GEN_VEC_OPERATIONS3_HPP_INCLUDED
1e59de90 TL	2	#define BOOST_QVM_GEN_VEC_OPERATIONS3_HPP_INCLUDED
92f5a8d4	3
1e59de90	4	// Copyright 2008-2022 Emil Dotchevski and Reverge Studios, Inc.
92f5a8d4	5
1e59de90 TL	6	// Distributed under the Boost Software License, Version 1.0. (See accompanying
1e59de90 TL	7	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
92f5a8d4	8
1e59de90	9	// This file was generated by a program. Do not edit manually.
92f5a8d4 TL	10
	11	#include <boost/qvm/deduce_scalar.hpp>
	12	#include <boost/qvm/deduce_vec.hpp>
	13	#include <boost/qvm/error.hpp>
	14	#include <boost/qvm/gen/vec_assign3.hpp>
	15	#include <boost/qvm/math.hpp>
	16	#include <boost/qvm/static_assert.hpp>
	17	#include <boost/qvm/throw_exception.hpp>
	18
1e59de90 TL	19	namespace boost { namespace qvm {
	20
	21	template <class A,class B>
	22	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
	23	typename lazy_enable_if_c<
	24	vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
	25	deduce_vec2<A,B,3> >::type
	26	operator+( A const & a, B const & b )
	27	{
	28	typedef typename deduce_vec2<A,B,3>::type R;
	29	BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
	30	R r;
	31	vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)+vec_traits<B>::template read_element<0>(b);
	32	vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)+vec_traits<B>::template read_element<1>(b);
	33	vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)+vec_traits<B>::template read_element<2>(b);
	34	return r;
	35	}
	36
	37	namespace
	38	sfinae
	39	{
	40	using ::boost::qvm::operator+;
	41	}
	42
92f5a8d4	43	namespace
1e59de90	44	qvm_detail
92f5a8d4	45	{
1e59de90 TL	46	template <int D>
	47	struct plus_vv_defined;
	48
	49	template <>
	50	struct
	51	plus_vv_defined<3>
	52	{
	53	static bool const value=true;
	54	};
	55	}
	56
	57	template <class A,class B>
	58	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
	59	typename lazy_enable_if_c<
	60	vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
	61	deduce_vec2<A,B,3> >::type
	62	operator-( A const & a, B const & b )
	63	{
	64	typedef typename deduce_vec2<A,B,3>::type R;
	65	BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
	66	R r;
	67	vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)-vec_traits<B>::template read_element<0>(b);
	68	vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)-vec_traits<B>::template read_element<1>(b);
	69	vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)-vec_traits<B>::template read_element<2>(b);
	70	return r;
	71	}
	72
	73	namespace
	74	sfinae
	75	{
	76	using ::boost::qvm::operator-;
	77	}
	78
	79	namespace
	80	qvm_detail
	81	{
	82	template <int D>
	83	struct minus_vv_defined;
	84
	85	template <>
	86	struct
	87	minus_vv_defined<3>
	88	{
	89	static bool const value=true;
	90	};
	91	}
	92
	93	template <class A,class B>
	94	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
	95	typename enable_if_c<
	96	vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
	97	A &>::type
	98	operator+=( A & a, B const & b )
	99	{
	100	vec_traits<A>::template write_element<0>(a)+=vec_traits<B>::template read_element<0>(b);
	101	vec_traits<A>::template write_element<1>(a)+=vec_traits<B>::template read_element<1>(b);
	102	vec_traits<A>::template write_element<2>(a)+=vec_traits<B>::template read_element<2>(b);
	103	return a;
	104	}
	105
	106	namespace
	107	sfinae
	108	{
	109	using ::boost::qvm::operator+=;
110	}
111
112	namespace
113	qvm_detail
114	{
115	template <int D>
116	struct plus_eq_vv_defined;
117
118	template <>
119	struct
120	plus_eq_vv_defined<3>
121	{
122	static bool const value=true;
123	};
124	}
125
126	template <class A,class B>
127	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
128	typename enable_if_c<
129	vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
130	A &>::type
131	operator-=( A & a, B const & b )
132	{
133	vec_traits<A>::template write_element<0>(a)-=vec_traits<B>::template read_element<0>(b);
134	vec_traits<A>::template write_element<1>(a)-=vec_traits<B>::template read_element<1>(b);
135	vec_traits<A>::template write_element<2>(a)-=vec_traits<B>::template read_element<2>(b);
136	return a;
137	}
138
139	namespace
140	sfinae
141	{
142	using ::boost::qvm::operator-=;
143	}
144
145	namespace
146	qvm_detail
147	{
148	template <int D>
149	struct minus_eq_vv_defined;
150
151	template <>
152	struct
153	minus_eq_vv_defined<3>
154	{
155	static bool const value=true;
156	};
157	}
158
159	template <class A,class B>
160	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
161	typename lazy_enable_if_c<
162	vec_traits<A>::dim==3 && is_scalar<B>::value,
163	deduce_vec2<A,B,vec_traits<A>::dim> >::type
164	operator*( A const & a, B b )
165	{
166	typedef typename deduce_vec2<A,B,vec_traits<A>::dim>::type R;
167	R r;
168	vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)*b;
169	vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)*b;
170	vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)*b;
171	return r;
172	}
173
174	namespace
175	sfinae
176	{
177	using ::boost::qvm::operator*;
178	}
179
180	namespace
181	qvm_detail
182	{
183	template <int D>
184	struct mul_vs_defined;
185
186	template <>
187	struct
188	mul_vs_defined<3>
189	{
190	static bool const value=true;
191	};
192	}
193
194	template <class A,class B>
195	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
196	typename lazy_enable_if_c<
197	is_scalar<A>::value && vec_traits<B>::dim==3,
198	deduce_vec2<A,B,vec_traits<B>::dim> >::type
199	operator*( A a, B const & b )
200	{
201	typedef typename deduce_vec2<A,B,vec_traits<B>::dim>::type R;
202	R r;
203	vec_traits<R>::template write_element<0>(r)=a*vec_traits<B>::template read_element<0>(b);
204	vec_traits<R>::template write_element<1>(r)=a*vec_traits<B>::template read_element<1>(b);
205	vec_traits<R>::template write_element<2>(r)=a*vec_traits<B>::template read_element<2>(b);
206	return r;
207	}
208
209	namespace
210	sfinae
211	{
212	using ::boost::qvm::operator*;
213	}
214
215	namespace
216	qvm_detail
217	{
218	template <int D>
219	struct mul_sv_defined;
220
221	template <>
222	struct
223	mul_sv_defined<3>
224	{
225	static bool const value=true;
226	};
227	}
228
229	template <class A,class B>
230	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
231	typename enable_if_c<
232	vec_traits<A>::dim==3 && is_scalar<B>::value,
233	A &>::type
234	operator*=( A & a, B b )
235	{
236	vec_traits<A>::template write_element<0>(a)*=b;
237	vec_traits<A>::template write_element<1>(a)*=b;
238	vec_traits<A>::template write_element<2>(a)*=b;
239	return a;
240	}
241
242	namespace
243	sfinae
244	{
245	using ::boost::qvm::operator*=;
246	}
247
248	namespace
249	qvm_detail
250	{
251	template <int D>
252	struct mul_eq_vs_defined;
253
254	template <>
255	struct
256	mul_eq_vs_defined<3>
257	{
258	static bool const value=true;
259	};
260	}
261
262	template <class A,class B>
263	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
264	typename lazy_enable_if_c<
265	vec_traits<A>::dim==3 && is_scalar<B>::value,
266	deduce_vec2<A,B,vec_traits<A>::dim> >::type
267	operator/( A const & a, B b )
268	{
269	typedef typename deduce_vec2<A,B,vec_traits<A>::dim>::type R;
270	R r;
271	vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)/b;
272	vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)/b;
273	vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)/b;
274	return r;
275	}
276
277	namespace
278	sfinae
279	{
280	using ::boost::qvm::operator/;
281	}
282
283	namespace
284	qvm_detail
285	{
286	template <int D>
287	struct div_vs_defined;
288
289	template <>
290	struct
291	div_vs_defined<3>
292	{
293	static bool const value=true;
294	};
295	}
296
297	template <class A,class B>
298	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
299	typename enable_if_c<
300	vec_traits<A>::dim==3 && is_scalar<B>::value,
301	A &>::type
302	operator/=( A & a, B b )
303	{
304	vec_traits<A>::template write_element<0>(a)/=b;
305	vec_traits<A>::template write_element<1>(a)/=b;
306	vec_traits<A>::template write_element<2>(a)/=b;
307	return a;
308	}
309
310	namespace
311	sfinae
312	{
313	using ::boost::qvm::operator/=;
314	}
315
316	namespace
317	qvm_detail
318	{
319	template <int D>
320	struct div_eq_vs_defined;
321
322	template <>
323	struct
324	div_eq_vs_defined<3>
92f5a8d4	325	{
1e59de90 TL	326	static bool const value=true;
1e59de90 TL	327	};
92f5a8d4 TL	328	}
92f5a8d4 TL	329
1e59de90 TL	330	template <class R,class A>
	331	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
	332	typename enable_if_c<
	333	is_vec<A>::value &&
	334	vec_traits<R>::dim==3 && vec_traits<A>::dim==3,
	335	R>::type
	336	convert_to( A const & a )
	337	{
	338	R r;
	339	vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a);
	340	vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a);
	341	vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a);
	342	return r;
	343	}
	344
	345	namespace
	346	sfinae
	347	{
	348	using ::boost::qvm::convert_to;
	349	}
	350
	351	namespace
	352	qvm_detail
	353	{
	354	template <int D>
	355	struct convert_to_v_defined;
	356
	357	template <>
	358	struct
	359	convert_to_v_defined<3>
	360	{
	361	static bool const value=true;
	362	};
	363	}
	364
	365	template <class A,class B>
	366	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
	367	typename enable_if_c<
	368	vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
	369	bool>::type
	370	operator==( A const & a, B const & b )
	371	{
	372	return
	373	vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b) &&
	374	vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b) &&
	375	vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b);
	376	}
	377
	378	namespace
	379	sfinae
	380	{
	381	using ::boost::qvm::operator==;
	382	}
	383
	384	namespace
	385	qvm_detail
	386	{
	387	template <int D>
	388	struct eq_vv_defined;
	389
	390	template <>
	391	struct
	392	eq_vv_defined<3>
	393	{
394	static bool const value=true;
395	};
396	}
397
398	template <class A,class B>
399	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
400	typename enable_if_c<
401	vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
402	bool>::type
403	operator!=( A const & a, B const & b )
404	{
405	return
406	!(vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b)) \|\|
407	!(vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b)) \|\|
408	!(vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b));
409	}
410
411	namespace
412	sfinae
413	{
414	using ::boost::qvm::operator!=;
415	}
416
417	namespace
418	qvm_detail
419	{
420	template <int D>
421	struct neq_vv_defined;
422
423	template <>
424	struct
425	neq_vv_defined<3>
426	{
427	static bool const value=true;
428	};
429	}
430
431	template <class A>
432	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
433	typename lazy_enable_if_c<
434	vec_traits<A>::dim==3,
435	deduce_vec<A> >::type
436	operator-( A const & a )
437	{
438	typedef typename deduce_vec<A>::type R;
439	R r;
440	vec_traits<R>::template write_element<0>(r)=-vec_traits<A>::template read_element<0>(a);
441	vec_traits<R>::template write_element<1>(r)=-vec_traits<A>::template read_element<1>(a);
442	vec_traits<R>::template write_element<2>(r)=-vec_traits<A>::template read_element<2>(a);
443	return r;
444	}
445
446	namespace
447	sfinae
448	{
449	using ::boost::qvm::operator-;
450	}
451
452	namespace
453	qvm_detail
454	{
455	template <int D>
456	struct minus_v_defined;
457
458	template <>
459	struct
460	minus_v_defined<3>
461	{
462	static bool const value=true;
463	};
464	}
465
466	template <class A>
467	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
468	typename enable_if_c<
469	is_vec<A>::value && vec_traits<A>::dim==3,
470	typename vec_traits<A>::scalar_type>::type
471	mag( A const & a )
472	{
473	typedef typename vec_traits<A>::scalar_type T;
474	T const a0=vec_traits<A>::template read_element<0>(a);
475	T const a1=vec_traits<A>::template read_element<1>(a);
476	T const a2=vec_traits<A>::template read_element<2>(a);
477	T const m2=a0a0+a1a1+a2*a2;
478	T const mag=sqrt(m2);
479	return mag;
480	}
481
482	namespace
483	sfinae
484	{
485	using ::boost::qvm::mag;
486	}
487
488	namespace
489	qvm_detail
490	{
491	template <int D>
492	struct mag_v_defined;
493
494	template <>
495	struct
496	mag_v_defined<3>
497	{
498	static bool const value=true;
499	};
500	}
501
502	template <class A>
503	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
504	typename enable_if_c<
505	is_vec<A>::value && vec_traits<A>::dim==3,
506	typename vec_traits<A>::scalar_type>::type
507	mag_sqr( A const & a )
508	{
509	typedef typename vec_traits<A>::scalar_type T;
510	T const a0=vec_traits<A>::template read_element<0>(a);
511	T const a1=vec_traits<A>::template read_element<1>(a);
512	T const a2=vec_traits<A>::template read_element<2>(a);
513	T const m2=a0a0+a1a1+a2*a2;
514	return m2;
515	}
516
517	namespace
518	sfinae
519	{
520	using ::boost::qvm::mag_sqr;
521	}
522
523	namespace
524	qvm_detail
525	{
526	template <int D>
527	struct mag_sqr_v_defined;
528
529	template <>
530	struct
531	mag_sqr_v_defined<3>
532	{
533	static bool const value=true;
534	};
535	}
536
537	template <class A>
538	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
539	typename lazy_enable_if_c<
540	vec_traits<A>::dim==3,
541	deduce_vec<A> >::type
542	normalized( A const & a )
543	{
544	typedef typename vec_traits<A>::scalar_type T;
545	T const a0=vec_traits<A>::template read_element<0>(a);
546	T const a1=vec_traits<A>::template read_element<1>(a);
547	T const a2=vec_traits<A>::template read_element<2>(a);
548	T const m2=a0a0+a1a1+a2*a2;
549	if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
550	BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
551	T const rm=scalar_traits<T>::value(1)/sqrt(m2);
552	typedef typename deduce_vec<A>::type R;
553	R r;
554	vec_traits<R>::template write_element<0>(r)=a0*rm;
555	vec_traits<R>::template write_element<1>(r)=a1*rm;
556	vec_traits<R>::template write_element<2>(r)=a2*rm;
557	return r;
558	}
559
560	namespace
561	sfinae
562	{
563	using ::boost::qvm::normalized;
564	}
565
566	template <class A>
567	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
568	typename enable_if_c<
569	vec_traits<A>::dim==3,
570	void>::type
571	normalize( A & a )
572	{
573	typedef typename vec_traits<A>::scalar_type T;
574	T const a0=vec_traits<A>::template read_element<0>(a);
575	T const a1=vec_traits<A>::template read_element<1>(a);
576	T const a2=vec_traits<A>::template read_element<2>(a);
577	T const m2=a0a0+a1a1+a2*a2;
578	if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
579	BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
580	T const rm=scalar_traits<T>::value(1)/sqrt(m2);
581	vec_traits<A>::template write_element<0>(a)*=rm;
582	vec_traits<A>::template write_element<1>(a)*=rm;
583	vec_traits<A>::template write_element<2>(a)*=rm;
584	}
585
586	namespace
587	sfinae
588	{
589	using ::boost::qvm::normalize;
590	}
591
592	namespace
593	qvm_detail
594	{
595	template <int D>
596	struct normalize_v_defined;
597
598	template <>
599	struct
600	normalize_v_defined<3>
601	{
602	static bool const value=true;
603	};
604	}
605
606	template <class A,class B>
607	BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_OPERATIONS
608	typename lazy_enable_if_c<
609	vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
610	deduce_scalar<typename vec_traits<A>::scalar_type,typename vec_traits<B>::scalar_type> >::type
611	dot( A const & a, B const & b )
612	{
613	typedef typename vec_traits<A>::scalar_type Ta;
614	typedef typename vec_traits<B>::scalar_type Tb;
615	typedef typename deduce_scalar<Ta,Tb>::type Tr;
616	Ta const a0=vec_traits<A>::template read_element<0>(a);
617	Ta const a1=vec_traits<A>::template read_element<1>(a);
618	Ta const a2=vec_traits<A>::template read_element<2>(a);
619	Tb const b0=vec_traits<B>::template read_element<0>(b);
620	Tb const b1=vec_traits<B>::template read_element<1>(b);
621	Tb const b2=vec_traits<B>::template read_element<2>(b);
622	Tr const dot=a0b0+a1b1+a2*b2;
623	return dot;
624	}
625
626	namespace
627	sfinae
628	{
629	using ::boost::qvm::dot;
630	}
631
632	namespace
633	qvm_detail
634	{
635	template <int D>
636	struct dot_vv_defined;
637
638	template <>
639	struct
640	dot_vv_defined<3>
641	{
642	static bool const value=true;
643	};
644	}
645
646	} }
647
92f5a8d4	648	#endif