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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
|
// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
// Copyright 2008-2016 National ICT Australia (NICTA)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
//! \addtogroup subview_cube
//! @{
//! Class for storing data required to construct or apply operations to a subcube
//! (ie. where the subcube starts and ends as well as a reference/pointer to the original cube),
template<typename eT>
class subview_cube : public BaseCube< eT, subview_cube<eT> >
{
public:
typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type;
arma_aligned const Cube<eT>& m;
const uword aux_row1;
const uword aux_col1;
const uword aux_slice1;
const uword n_rows;
const uword n_cols;
const uword n_elem_slice;
const uword n_slices;
const uword n_elem;
protected:
arma_inline subview_cube(const Cube<eT>& in_m, const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_n_rows, const uword in_n_cols, const uword in_n_slices);
public:
inline ~subview_cube();
inline subview_cube() = delete;
inline subview_cube(const subview_cube& in);
inline subview_cube( subview_cube&& in);
template<typename op_type > inline void inplace_op(const eT val );
template<typename op_type, typename T1> inline void inplace_op(const BaseCube<eT,T1>& x, const char* identifier);
template<typename op_type > inline void inplace_op(const subview_cube<eT>& x, const char* identifier);
inline void operator= (const eT val);
inline void operator+= (const eT val);
inline void operator-= (const eT val);
inline void operator*= (const eT val);
inline void operator/= (const eT val);
// deliberately returning void
template<typename T1> inline void operator= (const BaseCube<eT,T1>& x);
template<typename T1> inline void operator+= (const BaseCube<eT,T1>& x);
template<typename T1> inline void operator-= (const BaseCube<eT,T1>& x);
template<typename T1> inline void operator%= (const BaseCube<eT,T1>& x);
template<typename T1> inline void operator/= (const BaseCube<eT,T1>& x);
inline void operator= (const subview_cube& x);
inline void operator+= (const subview_cube& x);
inline void operator-= (const subview_cube& x);
inline void operator%= (const subview_cube& x);
inline void operator/= (const subview_cube& x);
template<typename T1> inline void operator= (const Base<eT,T1>& x);
template<typename T1> inline void operator+= (const Base<eT,T1>& x);
template<typename T1> inline void operator-= (const Base<eT,T1>& x);
template<typename T1> inline void operator%= (const Base<eT,T1>& x);
template<typename T1> inline void operator/= (const Base<eT,T1>& x);
template<typename gen_type> inline void operator=(const GenCube<eT,gen_type>& x);
inline static void extract(Cube<eT>& out, const subview_cube& in);
inline static void plus_inplace(Cube<eT>& out, const subview_cube& in);
inline static void minus_inplace(Cube<eT>& out, const subview_cube& in);
inline static void schur_inplace(Cube<eT>& out, const subview_cube& in);
inline static void div_inplace(Cube<eT>& out, const subview_cube& in);
inline static void extract(Mat<eT>& out, const subview_cube& in);
inline static void plus_inplace(Mat<eT>& out, const subview_cube& in);
inline static void minus_inplace(Mat<eT>& out, const subview_cube& in);
inline static void schur_inplace(Mat<eT>& out, const subview_cube& in);
inline static void div_inplace(Mat<eT>& out, const subview_cube& in);
template<typename functor> inline void for_each(functor F);
template<typename functor> inline void for_each(functor F) const;
template<typename functor> inline void transform(functor F);
template<typename functor> inline void imbue(functor F);
inline void each_slice(const std::function< void( Mat<eT>&) >& F);
inline void each_slice(const std::function< void(const Mat<eT>&) >& F) const;
inline void replace(const eT old_val, const eT new_val);
inline void clean(const pod_type threshold);
inline void clamp(const eT min_val, const eT max_val);
inline void fill(const eT val);
inline void zeros();
inline void ones();
inline void randu();
inline void randn();
arma_warn_unused inline bool is_finite() const;
arma_warn_unused inline bool is_zero(const pod_type tol = 0) const;
arma_warn_unused inline bool has_inf() const;
arma_warn_unused inline bool has_nan() const;
arma_warn_unused inline bool has_nonfinite() const;
inline eT at_alt (const uword i) const;
inline eT& operator[](const uword i);
inline eT operator[](const uword i) const;
inline eT& operator()(const uword i);
inline eT operator()(const uword i) const;
arma_inline eT& operator()(const uword in_row, const uword in_col, const uword in_slice);
arma_inline eT operator()(const uword in_row, const uword in_col, const uword in_slice) const;
arma_inline eT& at(const uword in_row, const uword in_col, const uword in_slice);
arma_inline eT at(const uword in_row, const uword in_col, const uword in_slice) const;
arma_inline eT* slice_colptr(const uword in_slice, const uword in_col);
arma_inline const eT* slice_colptr(const uword in_slice, const uword in_col) const;
template<typename eT2>
inline bool check_overlap(const subview_cube<eT2>& x) const;
inline bool check_overlap(const Mat<eT>& x) const;
class const_iterator;
class iterator
{
public:
inline iterator();
inline iterator(const iterator& X);
inline iterator(subview_cube<eT>& in_sv, const uword in_row, const uword in_col, const uword in_slice);
arma_warn_unused inline eT& operator*();
inline iterator& operator++();
arma_warn_unused inline iterator operator++(int);
arma_warn_unused inline bool operator==(const iterator& rhs) const;
arma_warn_unused inline bool operator!=(const iterator& rhs) const;
arma_warn_unused inline bool operator==(const const_iterator& rhs) const;
arma_warn_unused inline bool operator!=(const const_iterator& rhs) const;
typedef std::forward_iterator_tag iterator_category;
typedef eT value_type;
typedef std::ptrdiff_t difference_type; // TODO: not certain on this one
typedef eT* pointer;
typedef eT& reference;
arma_aligned Cube<eT>* M;
arma_aligned eT* current_ptr;
arma_aligned uword current_row;
arma_aligned uword current_col;
arma_aligned uword current_slice;
arma_aligned const uword aux_row1;
arma_aligned const uword aux_col1;
arma_aligned const uword aux_row2_p1;
arma_aligned const uword aux_col2_p1;
};
class const_iterator
{
public:
inline const_iterator();
inline const_iterator(const iterator& X);
inline const_iterator(const const_iterator& X);
inline const_iterator(const subview_cube<eT>& in_sv, const uword in_row, const uword in_col, const uword in_slice);
arma_warn_unused inline const eT& operator*();
inline const_iterator& operator++();
arma_warn_unused inline const_iterator operator++(int);
arma_warn_unused inline bool operator==(const iterator& rhs) const;
arma_warn_unused inline bool operator!=(const iterator& rhs) const;
arma_warn_unused inline bool operator==(const const_iterator& rhs) const;
arma_warn_unused inline bool operator!=(const const_iterator& rhs) const;
// So that we satisfy the STL iterator types.
typedef std::forward_iterator_tag iterator_category;
typedef eT value_type;
typedef std::ptrdiff_t difference_type; // TODO: not certain on this one
typedef const eT* pointer;
typedef const eT& reference;
arma_aligned const Cube<eT>* M;
arma_aligned const eT* current_ptr;
arma_aligned uword current_row;
arma_aligned uword current_col;
arma_aligned uword current_slice;
arma_aligned const uword aux_row1;
arma_aligned const uword aux_col1;
arma_aligned const uword aux_row2_p1;
arma_aligned const uword aux_col2_p1;
};
inline iterator begin();
inline const_iterator begin() const;
inline const_iterator cbegin() const;
inline iterator end();
inline const_iterator end() const;
inline const_iterator cend() const;
friend class Mat<eT>;
friend class Cube<eT>;
};
//! @}
|
