EVOLUTION-MANAGER

Edit File: mat_operations2.hpp

//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)

#ifndef BOOST_QVM_2923BE84E16CD6AE529049F1F1BBE9EB
#define BOOST_QVM_2923BE84E16CD6AE529049F1F1BBE9EB

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

#include <boost/qvm/assert.hpp>
#include <boost/qvm/deduce_mat.hpp>
#include <boost/qvm/deduce_vec.hpp>
#include <boost/qvm/error.hpp>
#include <boost/qvm/gen/mat_assign2.hpp>
#include <boost/qvm/throw_exception.hpp>

namespace
boost
 {
 namespace
 qvm
 {
 template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits::rows==2 &&
 mat_traits<A>::cols==2 && mat_traits::cols==2,
 deduce_mat2<A,B,2,2> >::type
 operator+( A const & a, B const & b )
 {
 typedef typename deduce_mat2<A,B,2,2>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)+mat_traits::template read_element<0,1>(b);
 mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)+mat_traits::template read_element<1,0>(b);
 mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)+mat_traits::template read_element<1,1>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct plus_mm_defined;

template <>
 struct
 plus_mm_defined<2,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits::rows==2 &&
 mat_traits<A>::cols==1 && mat_traits::cols==1,
 deduce_mat2<A,B,2,1> >::type
 operator+( A const & a, B const & b )
 {
 typedef typename deduce_mat2<A,B,2,1>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)+mat_traits::template read_element<1,0>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct plus_mm_defined;

template <>
 struct
 plus_mm_defined<2,1>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==1 && mat_traits::rows==1 &&
 mat_traits<A>::cols==2 && mat_traits::cols==2,
 deduce_mat2<A,B,1,2> >::type
 operator+( A const & a, B const & b )
 {
 typedef typename deduce_mat2<A,B,1,2>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)+mat_traits::template read_element<0,1>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct plus_mm_defined;

template <>
 struct
 plus_mm_defined<1,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits::rows==2 &&
 mat_traits<A>::cols==2 && mat_traits::cols==2,
 deduce_mat2<A,B,2,2> >::type
 operator-( A const & a, B const & b )
 {
 typedef typename deduce_mat2<A,B,2,2>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)-mat_traits::template read_element<0,1>(b);
 mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)-mat_traits::template read_element<1,0>(b);
 mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)-mat_traits::template read_element<1,1>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_mm_defined;

template <>
 struct
 minus_mm_defined<2,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits::rows==2 &&
 mat_traits<A>::cols==1 && mat_traits::cols==1,
 deduce_mat2<A,B,2,1> >::type
 operator-( A const & a, B const & b )
 {
 typedef typename deduce_mat2<A,B,2,1>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)-mat_traits::template read_element<1,0>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_mm_defined;

template <>
 struct
 minus_mm_defined<2,1>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==1 && mat_traits::rows==1 &&
 mat_traits<A>::cols==2 && mat_traits::cols==2,
 deduce_mat2<A,B,1,2> >::type
 operator-( A const & a, B const & b )
 {
 typedef typename deduce_mat2<A,B,1,2>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)-mat_traits::template read_element<0,1>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_mm_defined;

template <>
 struct
 minus_mm_defined<1,2>
 {
 static bool const value=true;
 };
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct plus_eq_mm_defined;

template <>
 struct
 plus_eq_mm_defined<2,2>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct plus_eq_mm_defined;

template <>
 struct
 plus_eq_mm_defined<2,1>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct plus_eq_mm_defined;

template <>
 struct
 plus_eq_mm_defined<1,2>
 {
 static bool const value=true;
 };
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_eq_mm_defined;

template <>
 struct
 minus_eq_mm_defined<2,2>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_eq_mm_defined;

template <>
 struct
 minus_eq_mm_defined<2,1>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_eq_mm_defined;

template <>
 struct
 minus_eq_mm_defined<1,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==2 && is_scalar::value,
 deduce_mat<A> >::type
 operator*( A const & a, B b )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
 mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)*b;
 mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)*b;
 mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)*b;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_ms_defined;

template <>
 struct
 mul_ms_defined<2,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 is_scalar<A>::value && mat_traits::rows==2 && mat_traits::cols==2,
 deduce_mat >::type
 operator*( A a, B const & b )
 {
 typedef typename deduce_mat::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=a*mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<0,1>(r)=a*mat_traits::template read_element<0,1>(b);
 mat_traits<R>::template write_element<1,0>(r)=a*mat_traits::template read_element<1,0>(b);
 mat_traits<R>::template write_element<1,1>(r)=a*mat_traits::template read_element<1,1>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_sm_defined;

template <>
 struct
 mul_sm_defined<2,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==1 && is_scalar::value,
 deduce_mat<A> >::type
 operator*( A const & a, B b )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
 mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)*b;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_ms_defined;

template <>
 struct
 mul_ms_defined<2,1>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 is_scalar<A>::value && mat_traits::rows==2 && mat_traits::cols==1,
 deduce_mat >::type
 operator*( A a, B const & b )
 {
 typedef typename deduce_mat::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=a*mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<1,0>(r)=a*mat_traits::template read_element<1,0>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_sm_defined;

template <>
 struct
 mul_sm_defined<2,1>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==1 && mat_traits<A>::cols==2 && is_scalar::value,
 deduce_mat<A> >::type
 operator*( A const & a, B b )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
 mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)*b;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_ms_defined;

template <>
 struct
 mul_ms_defined<1,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 is_scalar<A>::value && mat_traits::rows==1 && mat_traits::cols==2,
 deduce_mat >::type
 operator*( A a, B const & b )
 {
 typedef typename deduce_mat::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=a*mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<0,1>(r)=a*mat_traits::template read_element<0,1>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_sm_defined;

template <>
 struct
 mul_sm_defined<1,2>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_eq_ms_defined;

template <>
 struct
 mul_eq_ms_defined<2,2>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_eq_ms_defined;

template <>
 struct
 mul_eq_ms_defined<2,1>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct mul_eq_ms_defined;

template <>
 struct
 mul_eq_ms_defined<1,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==2 && is_scalar::value,
 deduce_mat<A> >::type
 operator/( A const & a, B b )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
 mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)/b;
 mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)/b;
 mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)/b;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct div_ms_defined;

template <>
 struct
 div_ms_defined<2,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 is_scalar<A>::value && mat_traits::rows==2 && mat_traits::cols==2,
 deduce_mat >::type
 operator/( A a, B const & b )
 {
 typedef typename deduce_mat::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=a/mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<0,1>(r)=a/mat_traits::template read_element<0,1>(b);
 mat_traits<R>::template write_element<1,0>(r)=a/mat_traits::template read_element<1,0>(b);
 mat_traits<R>::template write_element<1,1>(r)=a/mat_traits::template read_element<1,1>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct div_sm_defined;

template <>
 struct
 div_sm_defined<2,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==1 && is_scalar::value,
 deduce_mat<A> >::type
 operator/( A const & a, B b )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
 mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)/b;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct div_ms_defined;

template <>
 struct
 div_ms_defined<2,1>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 is_scalar<A>::value && mat_traits::rows==2 && mat_traits::cols==1,
 deduce_mat >::type
 operator/( A a, B const & b )
 {
 typedef typename deduce_mat::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=a/mat_traits::template read_element<0,0>(b);
 mat_traits<R>::template write_element<1,0>(r)=a/mat_traits::template read_element<1,0>(b);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct div_sm_defined;

template <>
 struct
 div_sm_defined<2,1>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==1 && mat_traits<A>::cols==2 && is_scalar::value,
 deduce_mat<A> >::type
 operator/( A const & a, B b )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
 mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)/b;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct div_ms_defined;

template <>
 struct
 div_ms_defined<1,2>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct div_eq_ms_defined;

template <>
 struct
 div_eq_ms_defined<2,2>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct div_eq_ms_defined;

template <>
 struct
 div_eq_ms_defined<2,1>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct div_eq_ms_defined;

template <>
 struct
 div_eq_ms_defined<1,2>
 {
 static bool const value=true;
 };
 }

template <class R,class A>
 BOOST_QVM_INLINE_OPERATIONS
 typename enable_if_c<
 mat_traits<R>::rows==2 && mat_traits<A>::rows==2 &&
 mat_traits<R>::cols==2 && mat_traits<A>::cols==2,
 R>::type
 convert_to( A const & a )
 {
 R r;
 mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
 mat_traits<R>::template write_element<0,1>(r) = mat_traits<A>::template read_element<0,1>(a);
 mat_traits<R>::template write_element<1,0>(r) = mat_traits<A>::template read_element<1,0>(a);
 mat_traits<R>::template write_element<1,1>(r) = mat_traits<A>::template read_element<1,1>(a);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct convert_to_m_defined;

template <>
 struct
 convert_to_m_defined<2,2>
 {
 static bool const value=true;
 };
 }

template <class R,class A>
 BOOST_QVM_INLINE_OPERATIONS
 typename enable_if_c<
 mat_traits<R>::rows==2 && mat_traits<A>::rows==2 &&
 mat_traits<R>::cols==1 && mat_traits<A>::cols==1,
 R>::type
 convert_to( A const & a )
 {
 R r;
 mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
 mat_traits<R>::template write_element<1,0>(r) = mat_traits<A>::template read_element<1,0>(a);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct convert_to_m_defined;

template <>
 struct
 convert_to_m_defined<2,1>
 {
 static bool const value=true;
 };
 }

template <class R,class A>
 BOOST_QVM_INLINE_OPERATIONS
 typename enable_if_c<
 mat_traits<R>::rows==1 && mat_traits<A>::rows==1 &&
 mat_traits<R>::cols==2 && mat_traits<A>::cols==2,
 R>::type
 convert_to( A const & a )
 {
 R r;
 mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
 mat_traits<R>::template write_element<0,1>(r) = mat_traits<A>::template read_element<0,1>(a);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct convert_to_m_defined;

template <>
 struct
 convert_to_m_defined<1,2>
 {
 static bool const value=true;
 };
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct eq_mm_defined;

template <>
 struct
 eq_mm_defined<2,2>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct eq_mm_defined;

template <>
 struct
 eq_mm_defined<2,1>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct eq_mm_defined;

template <>
 struct
 eq_mm_defined<1,2>
 {
 static bool const value=true;
 };
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct neq_mm_defined;

template <>
 struct
 neq_mm_defined<2,2>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct neq_mm_defined;

template <>
 struct
 neq_mm_defined<2,1>
 {
 static bool const value=true;
 };
 }

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

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct neq_mm_defined;

template <>
 struct
 neq_mm_defined<1,2>
 {
 static bool const value=true;
 };
 }

template <class A>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==2,
 deduce_mat<A> >::type
 operator-( A const & a )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
 mat_traits<R>::template write_element<0,1>(r)=-mat_traits<A>::template read_element<0,1>(a);
 mat_traits<R>::template write_element<1,0>(r)=-mat_traits<A>::template read_element<1,0>(a);
 mat_traits<R>::template write_element<1,1>(r)=-mat_traits<A>::template read_element<1,1>(a);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_m_defined;

template <>
 struct
 minus_m_defined<2,2>
 {
 static bool const value=true;
 };
 }

template <class A>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==1,
 deduce_mat<A> >::type
 operator-( A const & a )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
 mat_traits<R>::template write_element<1,0>(r)=-mat_traits<A>::template read_element<1,0>(a);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_m_defined;

template <>
 struct
 minus_m_defined<2,1>
 {
 static bool const value=true;
 };
 }

template <class A>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==1 && mat_traits<A>::cols==2,
 deduce_mat<A> >::type
 operator-( A const & a )
 {
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
 mat_traits<R>::template write_element<0,1>(r)=-mat_traits<A>::template read_element<0,1>(a);
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int C>
 struct minus_m_defined;

template <>
 struct
 minus_m_defined<1,2>
 {
 static bool const value=true;
 };
 }

template <class A>
 BOOST_QVM_INLINE_OPERATIONS
 typename enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==2,
 typename mat_traits<A>::scalar_type>::type
 determinant( A const & a )
 {
 typedef typename mat_traits<A>::scalar_type T;
 T const a00=mat_traits<A>::template read_element<0,0>(a);
 T const a01=mat_traits<A>::template read_element<0,1>(a);
 T const a10=mat_traits<A>::template read_element<1,0>(a);
 T const a11=mat_traits<A>::template read_element<1,1>(a);
 T det=(a00*a11-a01*a10);
 return det;
 }

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

namespace
 qvm_detail
 {
 template <int D>
 struct determinant_defined;

template <>
 struct
 determinant_defined<2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==2 && is_scalar::value,
 deduce_mat<A> >::type
 inverse( A const & a, B det )
 {
 typedef typename mat_traits<A>::scalar_type T;
 BOOST_QVM_ASSERT(det!=scalar_traits::value(0));
 T const a00=mat_traits<A>::template read_element<0,0>(a);
 T const a01=mat_traits<A>::template read_element<0,1>(a);
 T const a10=mat_traits<A>::template read_element<1,0>(a);
 T const a11=mat_traits<A>::template read_element<1,1>(a);
 T const f=scalar_traits<T>::value(1)/det;
 typedef typename deduce_mat<A>::type R;
 R r;
 mat_traits<R>::template write_element<0,0>(r)= f*a11;
 mat_traits<R>::template write_element<0,1>(r)=-f*a01;
 mat_traits<R>::template write_element<1,0>(r)=-f*a10;
 mat_traits<R>::template write_element<1,1>(r)= f*a00;
 return r;
 }

template <class A>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits<A>::cols==2,
 deduce_mat<A> >::type
 inverse( A const & a )
 {
 typedef typename mat_traits<A>::scalar_type T;
 T det=determinant(a);
 if( det==scalar_traits<T>::value(0) )
 BOOST_QVM_THROW_EXCEPTION(zero_determinant_error());
 return inverse(a,det);
 }

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

namespace
 qvm_detail
 {
 template <int D>
 struct inverse_m_defined;

template <>
 struct
 inverse_m_defined<2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits::rows==2 &&
 mat_traits<A>::cols==2 && mat_traits::cols==2,
 deduce_mat2<A,B,2,2> >::type
 operator*( A const & a, B const & b )
 {
 typedef typename mat_traits<A>::scalar_type Ta;
 typedef typename mat_traits::scalar_type Tb;
 Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
 Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
 Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
 Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
 Tb const b00 = mat_traits::template read_element<0,0>(b);
 Tb const b01 = mat_traits::template read_element<0,1>(b);
 Tb const b10 = mat_traits::template read_element<1,0>(b);
 Tb const b11 = mat_traits::template read_element<1,1>(b);
 typedef typename deduce_mat2<A,B,2,2>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10;
 mat_traits<R>::template write_element<0,1>(r)=a00*b01+a01*b11;
 mat_traits<R>::template write_element<1,0>(r)=a10*b00+a11*b10;
 mat_traits<R>::template write_element<1,1>(r)=a10*b01+a11*b11;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int CR,int C>
 struct mul_mm_defined;

template <>
 struct
 mul_mm_defined<2,2,2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename enable_if_c<
 mat_traits<A>::rows==2 && mat_traits::rows==2 &&
 mat_traits<A>::cols==2 && mat_traits::cols==2,
 A &>::type
 operator*=( A & a, B const & b )
 {
 typedef typename mat_traits<A>::scalar_type Ta;
 typedef typename mat_traits::scalar_type Tb;
 Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
 Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
 Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
 Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
 Tb const b00 = mat_traits::template read_element<0,0>(b);
 Tb const b01 = mat_traits::template read_element<0,1>(b);
 Tb const b10 = mat_traits::template read_element<1,0>(b);
 Tb const b11 = mat_traits::template read_element<1,1>(b);
 mat_traits<A>::template write_element<0,0>(a)=a00*b00+a01*b10;
 mat_traits<A>::template write_element<0,1>(a)=a00*b01+a01*b11;
 mat_traits<A>::template write_element<1,0>(a)=a10*b00+a11*b10;
 mat_traits<A>::template write_element<1,1>(a)=a10*b01+a11*b11;
 return a;
 }

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

namespace
 qvm_detail
 {
 template <int D>
 struct mul_eq_mm_defined;

template <>
 struct
 mul_eq_mm_defined<2>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==2 && mat_traits::rows==2 &&
 mat_traits<A>::cols==2 && mat_traits::cols==1,
 deduce_mat2<A,B,2,1> >::type
 operator*( A const & a, B const & b )
 {
 typedef typename mat_traits<A>::scalar_type Ta;
 typedef typename mat_traits::scalar_type Tb;
 Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
 Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
 Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
 Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
 Tb const b00 = mat_traits::template read_element<0,0>(b);
 Tb const b10 = mat_traits::template read_element<1,0>(b);
 typedef typename deduce_mat2<A,B,2,1>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10;
 mat_traits<R>::template write_element<1,0>(r)=a10*b00+a11*b10;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int CR,int C>
 struct mul_mm_defined;

template <>
 struct
 mul_mm_defined<2,2,1>
 {
 static bool const value=true;
 };
 }

template <class A,class B>
 BOOST_QVM_INLINE_OPERATIONS
 typename lazy_enable_if_c<
 mat_traits<A>::rows==1 && mat_traits::rows==2 &&
 mat_traits<A>::cols==2 && mat_traits::cols==2,
 deduce_mat2<A,B,1,2> >::type
 operator*( A const & a, B const & b )
 {
 typedef typename mat_traits<A>::scalar_type Ta;
 typedef typename mat_traits::scalar_type Tb;
 Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
 Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
 Tb const b00 = mat_traits::template read_element<0,0>(b);
 Tb const b01 = mat_traits::template read_element<0,1>(b);
 Tb const b10 = mat_traits::template read_element<1,0>(b);
 Tb const b11 = mat_traits::template read_element<1,1>(b);
 typedef typename deduce_mat2<A,B,1,2>::type R;
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
 BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
 R r;
 mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10;
 mat_traits<R>::template write_element<0,1>(r)=a00*b01+a01*b11;
 return r;
 }

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

namespace
 qvm_detail
 {
 template <int R,int CR,int C>
 struct mul_mm_defined;

template <>
 struct
 mul_mm_defined<1,2,2>
 {
 static bool const value=true;
 };
 }

}
    }

#endif