liuxiaolong
2021-07-20 58d904a328c0d849769b483e901a0be9426b8209
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
//Copyright (c) 2008-2016 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)
 
#ifndef BOOST_QVM_FA3ED0DCA17911DEA6BBA09955D89593
#define BOOST_QVM_FA3ED0DCA17911DEA6BBA09955D89593
 
#include <boost/qvm/inline.hpp>
#include <boost/qvm/deduce_mat.hpp>
#include <boost/qvm/detail/remove_const.hpp>
#include <boost/qvm/assert.hpp>
 
namespace
boost
    {
    namespace
    qvm
        {
        template <class T,int R,int Q,int C>
        struct
        mat_traits<T[R][Q][C]>
            {
            static int const rows=0;
            static int const cols=0;
            typedef void scalar_type;
            };
 
        template <class T,int Rows,int Cols>
        struct
        mat_traits<T[Rows][Cols]>
            {
            typedef T this_matrix[Rows][Cols];
            typedef typename qvm_detail::remove_const<T>::type scalar_type;
            static int const rows=Rows;
            static int const cols=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 x[Row][Col];
                }
 
            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 x[Row][Col];
                }
 
            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 x[row][col];
                }
 
            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 x[row][col];
                }
            };
 
        template <class T,int Rows,int Cols,int R,int C>
        struct
        deduce_mat<T[Rows][Cols],R,C>
            {
            typedef mat<T,R,C> type;
            };
 
        template <class T,int Rows,int Cols,int R,int C>
        struct
        deduce_mat<T const[Rows][Cols],R,C>
            {
            typedef mat<T,R,C> type;
            };
 
        template <class T1,class T2,int Rows,int Cols,int R,int C>
        struct
        deduce_mat2<T1[Rows][Cols],T2[Rows][Cols],R,C>
            {
            typedef mat<typename deduce_scalar<T1,T2>::type,R,C> type;
            };
 
        template <int Rows,int Cols,class T>
        T (&ptr_mref( T * ptr ))[Rows][Cols]
            {
            return *reinterpret_cast<T (*)[Rows][Cols]>(ptr);
            }
        }
    }
 
#endif