FM / qvm

/usr/include/boost/qvm

Name	Size	Mode	Actions
detail/	-	0755	rm
gen/	-	0755	rm
all.hpp	1154	0644	edit dl rm
assert.hpp	319	0644	edit dl rm
deduce_mat.hpp	2667	0644	edit dl rm
deduce_quat.hpp	1634	0644	edit dl rm
deduce_scalar.hpp	10290	0644	edit dl rm
deduce_vec.hpp	2304	0644	edit dl rm
enable_if.hpp	584	0644	edit dl rm
error.hpp	956	0644	edit dl rm
inline.hpp	976	0644	edit dl rm
map.hpp	443	0644	edit dl rm
map_mat_mat.hpp	32426	0644	edit dl rm
map_mat_vec.hpp	17906	0644	edit dl rm
map_vec_mat.hpp	20995	0644	edit dl rm
mat.hpp	2858	0644	edit dl rm
math.hpp	8031	0644	edit dl rm
mat_access.hpp	57007	0644	edit dl rm
mat_operations.hpp	84053	0644	edit dl rm
mat_operations2.hpp	266	0644	edit dl rm
mat_operations3.hpp	266	0644	edit dl rm
mat_operations4.hpp	266	0644	edit dl rm
mat_traits.hpp	775	0644	edit dl rm
mat_traits_array.hpp	3562	0644	edit dl rm
mat_traits_defaults.hpp	2914	0644	edit dl rm
operations.hpp	542	0644	edit dl rm
quat.hpp	1686	0644	edit dl rm
quat_access.hpp	4989	0644	edit dl rm
quat_operations.hpp	53560	0644	edit dl rm
quat_traits.hpp	1113	0644	edit dl rm
quat_traits_array.hpp	3303	0644	edit dl rm
quat_traits_defaults.hpp	1026	0644	edit dl rm
quat_vec_operations.hpp	2288	0644	edit dl rm
scalar_traits.hpp	2958	0644	edit dl rm
static_assert.hpp	347	0644	edit dl rm
swizzle.hpp	434	0644	edit dl rm
swizzle2.hpp	259	0644	edit dl rm
swizzle3.hpp	259	0644	edit dl rm
swizzle4.hpp	259	0644	edit dl rm
throw_exception.hpp	355	0644	edit dl rm
to_string.hpp	724	0644	edit dl rm
vec.hpp	2311	0644	edit dl rm
vec_access.hpp	8377	0644	edit dl rm
vec_mat_operations.hpp	7019	0644	edit dl rm
vec_mat_operations2.hpp	270	0644	edit dl rm
vec_mat_operations3.hpp	270	0644	edit dl rm
vec_mat_operations4.hpp	270	0644	edit dl rm
vec_operations.hpp	30368	0644	edit dl rm
vec_operations2.hpp	266	0644	edit dl rm
vec_operations3.hpp	266	0644	edit dl rm
vec_operations4.hpp	266	0644	edit dl rm
vec_register.hpp	449	0644	edit dl rm
vec_register2.hpp	1358	0644	edit dl rm
vec_register3.hpp	1620	0644	edit dl rm
vec_register4.hpp	1918	0644	edit dl rm
vec_traits.hpp	711	0644	edit dl rm
vec_traits_array.hpp	2875	0644	edit dl rm
vec_traits_defaults.hpp	2690	0644	edit dl rm

Edit: /usr/include/boost/qvm/map_mat_mat.hpp (32426B)

//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_20D98340A3EB11DEB2180CD156D89593
#define BOOST_QVM_20D98340A3EB11DEB2180CD156D89593

#include <boost/qvm/inline.hpp>
#include <boost/qvm/deduce_mat.hpp>
#include <boost/qvm/assert.hpp>
#include <boost/qvm/enable_if.hpp>
#include <boost/qvm/detail/transp_impl.hpp>

namespace
boost
    {
    namespace
    qvm
        {
        ////////////////////////////////////////////////

namespace
        qvm_detail
            {
            template <int Row,class OriginalMatrix>
            class
            del_row_
                {
                del_row_( del_row_ const & );
                del_row_ & operator=( del_row_ const & );
                ~del_row_();

public:

template <class T>
                BOOST_QVM_INLINE_TRIVIAL
                del_row_ &
                operator=( T const & x )
                    {
                    assign(*this,x);
                    return *this;
                    }

template <class R>
                BOOST_QVM_INLINE_TRIVIAL
                operator R() const
                    {
                    R r;
                    assign(r,*this);
                    return r;
                    }
                };
            }

template <int I,class OriginalMatrix>
        struct
        mat_traits< qvm_detail::del_row_<I,OriginalMatrix> >
            {
            typedef qvm_detail::del_row_<I,OriginalMatrix> this_matrix;
            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
            static int const rows=mat_traits<OriginalMatrix>::rows-1;
            static int const cols=mat_traits<OriginalMatrix>::cols;

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element( this_matrix const & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template read_element<Row+(Row>=I),Col>(reinterpret_cast<OriginalMatrix const &>(x));
                }

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element( this_matrix & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template write_element<Row+(Row>=I),Col>(reinterpret_cast<OriginalMatrix &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element_idx( int row, int col, this_matrix const & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::read_element_idx(row+(row>=I),col,reinterpret_cast<OriginalMatrix const &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element_idx( int row, int col, this_matrix & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::write_element_idx(row+(row>=I),col,reinterpret_cast<OriginalMatrix &>(x));
                }
            };

template <int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat<qvm_detail::del_row_<J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat2<qvm_detail::del_row_<J,OriginalMatrix>,qvm_detail::del_row_<J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int Row,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::del_row_<Row,A> const &>::type
        BOOST_QVM_INLINE_TRIVIAL
        del_row( A const & a )
            {
            return reinterpret_cast<typename qvm_detail::del_row_<Row,A> const &>(a);
            }

template <int Row,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::del_row_<Row,A> &>::type
        BOOST_QVM_INLINE_TRIVIAL
        del_row( A & a )
            {
            return reinterpret_cast<typename qvm_detail::del_row_<Row,A> &>(a);
            }

////////////////////////////////////////////////

namespace
        qvm_detail
            {
            template <int Col,class OriginalMatrix>
            class
            del_col_
                {
                del_col_( del_col_ const & );
                del_col_ & operator=( del_col_ const & );
                ~del_col_();

public:

template <class T>
                BOOST_QVM_INLINE_TRIVIAL
                del_col_ &
                operator=( T const & x )
                    {
                    assign(*this,x);
                    return *this;
                    }

template <int J,class OriginalMatrix>
        struct
        mat_traits< qvm_detail::del_col_<J,OriginalMatrix> >
            {
            typedef qvm_detail::del_col_<J,OriginalMatrix> this_matrix;
            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
            static int const rows=mat_traits<OriginalMatrix>::rows;
            static int const cols=mat_traits<OriginalMatrix>::cols-1;

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element( this_matrix const & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template read_element<Row,Col+(Col>=J)>(reinterpret_cast<OriginalMatrix const &>(x));
                }

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element( this_matrix & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template write_element<Row,Col+(Col>=J)>(reinterpret_cast<OriginalMatrix &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element_idx( int row, int col, this_matrix const & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::read_element_idx(row,col+(col>=J),reinterpret_cast<OriginalMatrix const &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element_idx( int row, int col, this_matrix & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::write_element_idx(row,col+(col>=J),reinterpret_cast<OriginalMatrix &>(x));
                }
            };

template <int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat<qvm_detail::del_col_<J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat2<qvm_detail::del_col_<J,OriginalMatrix>,qvm_detail::del_col_<J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int Col,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::del_col_<Col,A> const &>::type
        BOOST_QVM_INLINE_TRIVIAL
        del_col( A const & a )
            {
            return reinterpret_cast<typename qvm_detail::del_col_<Col,A> const &>(a);
            }

template <int Col,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::del_col_<Col,A> &>::type
        BOOST_QVM_INLINE_TRIVIAL
        del_col( A & a )
            {
            return reinterpret_cast<typename qvm_detail::del_col_<Col,A> &>(a);
            }

////////////////////////////////////////////////

namespace
        qvm_detail
            {
            template <int Row,int Col,class OriginalMatrix>
            class
            del_row_col_
                {
                del_row_col_( del_row_col_ const & );
                ~del_row_col_();

public:

BOOST_QVM_INLINE_TRIVIAL
                del_row_col_ &
                operator=( del_row_col_ const & x )
                    {
                    assign(*this,x);
                    return *this;
                    }

template <class T>
                BOOST_QVM_INLINE_TRIVIAL
                del_row_col_ &
                operator=( T const & x )
                    {
                    assign(*this,x);
                    return *this;
                    }

template <int I,int J,class OriginalMatrix>
        struct
        mat_traits< qvm_detail::del_row_col_<I,J,OriginalMatrix> >
            {
            typedef qvm_detail::del_row_col_<I,J,OriginalMatrix> this_matrix;
            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
            static int const rows=mat_traits<OriginalMatrix>::rows-1;
            static int const cols=mat_traits<OriginalMatrix>::cols-1;

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element( this_matrix const & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template read_element<Row+(Row>=I),Col+(Col>=J)>(reinterpret_cast<OriginalMatrix const &>(x));
                }

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element( this_matrix & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template write_element<Row+(Row>=I),Col+(Col>=J)>(reinterpret_cast<OriginalMatrix &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element_idx( int row, int col, this_matrix const & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::read_element_idx(row+(row>=I),col+(col>=J),reinterpret_cast<OriginalMatrix const &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element_idx( int row, int col, this_matrix & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::write_element_idx(row+(row>=I),col+(col>=J),reinterpret_cast<OriginalMatrix &>(x));
                }
            };

template <int I,int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat<qvm_detail::del_row_col_<I,J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int I,int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat2<qvm_detail::del_row_col_<I,J,OriginalMatrix>,qvm_detail::del_row_col_<I,J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int Row,int Col,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::del_row_col_<Row,Col,A> const &>::type
        BOOST_QVM_INLINE_TRIVIAL
        del_row_col( A const & a )
            {
            return reinterpret_cast<typename qvm_detail::del_row_col_<Row,Col,A> const &>(a);
            }

template <int Row,int Col,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::del_row_col_<Row,Col,A> &>::type
        BOOST_QVM_INLINE_TRIVIAL
        del_row_col( A & a )
            {
            return reinterpret_cast<typename qvm_detail::del_row_col_<Row,Col,A> &>(a);
            }

////////////////////////////////////////////////

namespace
        qvm_detail
            {
            template <int Row,class OriginalMatrix>
            class
            neg_row_
                {
                neg_row_( neg_row_ const & );
                neg_row_ & operator=( neg_row_ const & );
                ~neg_row_();

public:

template <class T>
                BOOST_QVM_INLINE_TRIVIAL
                neg_row_ &
                operator=( T const & x )
                    {
                    assign(*this,x);
                    return *this;
                    }

template <int I,class OriginalMatrix>
        struct
        mat_traits< qvm_detail::neg_row_<I,OriginalMatrix> >
            {
            typedef qvm_detail::neg_row_<I,OriginalMatrix> this_matrix;
            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
            static int const rows=mat_traits<OriginalMatrix>::rows;
            static int const cols=mat_traits<OriginalMatrix>::cols;

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element( this_matrix const & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return Row==I ?
                    -mat_traits<OriginalMatrix>::template read_element<Row,Col>(reinterpret_cast<OriginalMatrix const &>(x)) :
                    mat_traits<OriginalMatrix>::template read_element<Row,Col>(reinterpret_cast<OriginalMatrix const &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element_idx( int row, int col, this_matrix const & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return row==I?
                    -mat_traits<OriginalMatrix>::read_element_idx(row,col,reinterpret_cast<OriginalMatrix const &>(x)) :
                    mat_traits<OriginalMatrix>::read_element_idx(row,col,reinterpret_cast<OriginalMatrix const &>(x));
                }
            };

template <int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat<qvm_detail::neg_row_<J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat2<qvm_detail::neg_row_<J,OriginalMatrix>,qvm_detail::neg_row_<J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int Row,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::neg_row_<Row,A> const &>::type
        BOOST_QVM_INLINE_TRIVIAL
        neg_row( A const & a )
            {
            return reinterpret_cast<typename qvm_detail::neg_row_<Row,A> const &>(a);
            }

////////////////////////////////////////////////

namespace
        qvm_detail
            {
            template <int Col,class OriginalMatrix>
            class
            neg_col_
                {
                neg_col_( neg_col_ const & );
                neg_col_ & operator=( neg_col_ const & );
                ~neg_col_();

public:

template <class T>
                BOOST_QVM_INLINE_TRIVIAL
                neg_col_ &
                operator=( T const & x )
                    {
                    assign(*this,x);
                    return *this;
                    }

template <int J,class OriginalMatrix>
        struct
        mat_traits< qvm_detail::neg_col_<J,OriginalMatrix> >
            {
            typedef qvm_detail::neg_col_<J,OriginalMatrix> this_matrix;
            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
            static int const rows=mat_traits<OriginalMatrix>::rows;
            static int const cols=mat_traits<OriginalMatrix>::cols;

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element( this_matrix const & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return Col==J?
                    -mat_traits<OriginalMatrix>::template read_element<Row,Col>(reinterpret_cast<OriginalMatrix const &>(x)) :
                    mat_traits<OriginalMatrix>::template read_element<Row,Col>(reinterpret_cast<OriginalMatrix const &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element_idx( int row, int col, this_matrix const & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return col==J?
                    -mat_traits<OriginalMatrix>::read_element_idx(row,col,reinterpret_cast<OriginalMatrix const &>(x)) :
                    mat_traits<OriginalMatrix>::read_element_idx(row,col,reinterpret_cast<OriginalMatrix const &>(x));
                }
            };

template <int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat<qvm_detail::neg_col_<J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int J,class OriginalMatrix,int R,int C>
        struct
        deduce_mat2<qvm_detail::neg_col_<J,OriginalMatrix>,qvm_detail::neg_col_<J,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int Col,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::neg_col_<Col,A> const &>::type
        BOOST_QVM_INLINE_TRIVIAL
        neg_col( A const & a )
            {
            return reinterpret_cast<typename qvm_detail::neg_col_<Col,A> const &>(a);
            }

////////////////////////////////////////////////

template <class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::transposed_<A> const &>::type
        BOOST_QVM_INLINE_TRIVIAL
        transposed( A const & a )
            {
            return reinterpret_cast<typename qvm_detail::transposed_<A> const &>(a);
            }

template <class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::transposed_<A> &>::type
        BOOST_QVM_INLINE_TRIVIAL
        transposed( A & a )
            {
            return reinterpret_cast<typename qvm_detail::transposed_<A> &>(a);
            }

////////////////////////////////////////////////

namespace
        qvm_detail
            {
            template <int Row1,int Row2,class OriginalMatrix>
            class
            swap_rows_
                {
                swap_rows_( swap_rows_ const & );
                swap_rows_ & operator=( swap_rows_ const & );
                ~swap_rows_();

public:

template <class T>
                BOOST_QVM_INLINE_TRIVIAL
                swap_rows_ &
                operator=( T const & x )
                    {
                    assign(*this,x);
                    return *this;
                    }

template <int R1,int R2,class OriginalMatrix>
        struct
        mat_traits< qvm_detail::swap_rows_<R1,R2,OriginalMatrix> >
            {
            typedef qvm_detail::swap_rows_<R1,R2,OriginalMatrix> this_matrix;
            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
            static int const rows=mat_traits<OriginalMatrix>::rows;
            static int const cols=mat_traits<OriginalMatrix>::cols;

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element( this_matrix const & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template read_element<(Row==R1 && R1!=R2)*R2+(Row==R2 && R1!=R2)*R1+((Row!=R1 && Row!=R2) || R1==R2)*Row,Col>(reinterpret_cast<OriginalMatrix const &>(x));
                }

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element( this_matrix & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template write_element<(Row==R1 && R1!=R2)*R2+(Row==R2 && R1!=R2)*R1+((Row!=R1 && Row!=R2) || R1==R2)*Row,Col>(reinterpret_cast<OriginalMatrix &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element_idx( int row, int col, this_matrix const & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::read_element_idx(row==R1?R2:row==R2?R1:row,col,reinterpret_cast<OriginalMatrix const &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element_idx( int row, int col, this_matrix & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::write_element_idx(row==R1?R2:row==R2?R1:row,col,reinterpret_cast<OriginalMatrix &>(x));
                }
            };

template <int R1,int R2,class OriginalMatrix,int R,int C>
        struct
        deduce_mat<qvm_detail::swap_rows_<R1,R2,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int R1,int R2,class OriginalMatrix,int R,int C>
        struct
        deduce_mat2<qvm_detail::swap_rows_<R1,R2,OriginalMatrix>,qvm_detail::swap_rows_<R1,R2,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int R1,int R2,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::swap_rows_<R1,R2,A> const &>::type
        BOOST_QVM_INLINE_TRIVIAL
        swap_rows( A const & a )
            {
            return reinterpret_cast<typename qvm_detail::swap_rows_<R1,R2,A> const &>(a);
            }

template <int R1,int R2,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::swap_rows_<R1,R2,A> &>::type
        BOOST_QVM_INLINE_TRIVIAL
        swap_rows( A & a )
            {
            return reinterpret_cast<typename qvm_detail::swap_rows_<R1,R2,A> &>(a);
            }

////////////////////////////////////////////////

namespace
        qvm_detail
            {
            template <int Row1,int Row2,class OriginalMatrix>
            class
            swap_cols_
                {
                swap_cols_( swap_cols_ const & );
                swap_cols_ & operator=( swap_cols_ const & );
                ~swap_cols_();

public:

template <class T>
                BOOST_QVM_INLINE_TRIVIAL
                swap_cols_ &
                operator=( T const & x )
                    {
                    assign(*this,x);
                    return *this;
                    }

template <int C1,int C2,class OriginalMatrix>
        struct
        mat_traits< qvm_detail::swap_cols_<C1,C2,OriginalMatrix> >
            {
            typedef qvm_detail::swap_cols_<C1,C2,OriginalMatrix> this_matrix;
            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
            static int const rows=mat_traits<OriginalMatrix>::rows;
            static int const cols=mat_traits<OriginalMatrix>::cols;

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element( this_matrix const & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template read_element<Row,(Col==C1 && C1!=C2)*C2+(Col==C2 && C1!=C2)*C1+((Col!=C1 && Col!=C2) || C1==C2)*Col>(reinterpret_cast<OriginalMatrix const &>(x));
                }

template <int Row,int Col>
            static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element( this_matrix & x )
                {
                BOOST_QVM_STATIC_ASSERT(Row>=0);
                BOOST_QVM_STATIC_ASSERT(Row<rows);
                BOOST_QVM_STATIC_ASSERT(Col>=0);
                BOOST_QVM_STATIC_ASSERT(Col<cols);
                return mat_traits<OriginalMatrix>::template write_element<Row,(Col==C1 && C1!=C2)*C2+(Col==C2 && C1!=C2)*C1+((Col!=C1 && Col!=C2) || C1==C2)*Col>(reinterpret_cast<OriginalMatrix &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type
            read_element_idx( int row, int col, this_matrix const & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::read_element_idx(row,col==C1?C2:col==C2?C1:col,reinterpret_cast<OriginalMatrix const &>(x));
                }

static
            BOOST_QVM_INLINE_CRITICAL
            scalar_type &
            write_element_idx( int row, int col, this_matrix & x )
                {
                BOOST_QVM_ASSERT(row>=0);
                BOOST_QVM_ASSERT(row<rows);
                BOOST_QVM_ASSERT(col>=0);
                BOOST_QVM_ASSERT(col<cols);
                return mat_traits<OriginalMatrix>::write_element_idx(row,col==C1?C2:col==C2?C1:col,reinterpret_cast<OriginalMatrix &>(x));
                }
            };

template <int C1,int C2,class OriginalMatrix,int R,int C>
        struct
        deduce_mat<qvm_detail::swap_cols_<C1,C2,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int C1,int C2,class OriginalMatrix,int R,int C>
        struct
        deduce_mat2<qvm_detail::swap_cols_<C1,C2,OriginalMatrix>,qvm_detail::swap_cols_<C1,C2,OriginalMatrix>,R,C>
            {
            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
            };

template <int C1,int C2,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::swap_cols_<C1,C2,A> const &>::type
        BOOST_QVM_INLINE_TRIVIAL
        swap_cols( A const & a )
            {
            return reinterpret_cast<typename qvm_detail::swap_cols_<C1,C2,A> const &>(a);
            }

template <int C1,int C2,class A>
        typename boost::enable_if_c<
            is_mat<A>::value,
            qvm_detail::swap_cols_<C1,C2,A> &>::type
        BOOST_QVM_INLINE_TRIVIAL
        swap_cols( A & a )
            {
            return reinterpret_cast<typename qvm_detail::swap_cols_<C1,C2,A> &>(a);
            }

////////////////////////////////////////////////
        }
    }

#endif