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
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
|
/**
* -*- c++ -*-
*
* \file begin.hpp
*
* \brief The \c begin operation.
*
* Copyright (c) 2009, Marco Guazzone
*
* 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)
*
* \author Marco Guazzone, marco.guazzone@gmail.com
*/
#ifndef BOOST_NUMERIC_UBLAS_OPERATION_BEGIN_HPP
#define BOOST_NUMERIC_UBLAS_OPERATION_BEGIN_HPP
#include <boost/numeric/ublas/expression_types.hpp>
#include <boost/numeric/ublas/fwd.hpp>
#include <boost/numeric/ublas/traits/const_iterator_type.hpp>
#include <boost/numeric/ublas/traits/iterator_type.hpp>
namespace boost { namespace numeric { namespace ublas {
namespace detail {
/**
* \brief Auxiliary class for implementing the \c begin operation.
* \tparam CategoryT The expression category type (e.g., vector_tag).
* \tparam TagT The dimension type tag (e.g., tag::major).
* \tparam OrientationT The orientation category type (e.g., row_major_tag).
*/
template <typename CategoryT, typename TagT=void, typename OrientationT=void>
struct begin_impl;
/// \brief Specialization of \c begin_impl for iterating vector expressions.
template <>
struct begin_impl<vector_tag,void,void>
{
/**
* \brief Return an iterator to the first element of the given vector
* expression.
* \tparam ExprT A model of VectorExpression type.
* \param e A vector expression.
* \return An iterator over the given vector expression.
*/
template <typename ExprT>
static typename ExprT::iterator apply(ExprT& e)
{
return e.begin();
}
/**
* \brief Return a const iterator to the first element of the given vector
* expression.
* \tparam ExprT A model of VectorExpression type.
* \param e A vector expression.
* \return A const iterator to the first element of the given vector
* expression.
*/
template <typename ExprT>
static typename ExprT::const_iterator apply(ExprT const& e)
{
return e.begin();
}
};
/// \brief Specialization of \c begin_impl for iterating matrix expressions with
/// a row-major orientation over the major dimension.
template <>
struct begin_impl<matrix_tag,tag::major,row_major_tag>
{
/**
* \brief Return an iterator to the first element of the given row-major
* matrix expression over the major dimension.
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return An iterator over the major dimension of the given matrix
* expression.
*/
template <typename ExprT>
static typename ExprT::iterator1 apply(ExprT& e)
{
return e.begin1();
}
/**
* \brief Return a const iterator to the first element of the given
* row-major matrix expression over the major dimension.
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return A const iterator over the major dimension of the given matrix
* expression.
*/
template <typename ExprT>
static typename ExprT::const_iterator1 apply(ExprT const& e)
{
return e.begin1();
}
};
/// \brief Specialization of \c begin_impl for iterating matrix expressions with
/// a column-major orientation over the major dimension.
template <>
struct begin_impl<matrix_tag,tag::major,column_major_tag>
{
/**
* \brief Return an iterator to the first element of the given column-major
* matrix expression over the major dimension.
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return An iterator over the major dimension of the given matrix
* expression.
*/
template <typename ExprT>
static typename ExprT::iterator2 apply(ExprT& e)
{
return e.begin2();
}
/**
* \brief Return a const iterator to the first element of the given
* column-major matrix expression over the major dimension.
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return A const iterator over the major dimension of the given matrix
* expression.
*/
template <typename ExprT>
static typename ExprT::const_iterator2 apply(ExprT const& e)
{
return e.begin2();
}
};
/// \brief Specialization of \c begin_impl for iterating matrix expressions with
/// a row-major orientation over the minor dimension.
template <>
struct begin_impl<matrix_tag,tag::minor,row_major_tag>
{
/**
* \brief Return an iterator to the first element of the given row-major
* matrix expression over the minor dimension.
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return An iterator over the minor dimension of the given matrix
* expression.
*/
template <typename ExprT>
static typename ExprT::iterator2 apply(ExprT& e)
{
return e.begin2();
}
/**
* \brief Return a const iterator to the first element of the given
* row-major matrix expression over the minor dimension.
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return A const iterator over the minor dimension of the given matrix
* expression.
*/
template <typename ExprT>
static typename ExprT::const_iterator2 apply(ExprT const& e)
{
return e.begin2();
}
};
/// \brief Specialization of \c begin_impl for iterating matrix expressions with
/// a column-major orientation over the minor dimension.
template <>
struct begin_impl<matrix_tag,tag::minor,column_major_tag>
{
/**
* \brief Return an iterator to the first element of the given column-major
* matrix expression over the minor dimension.
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return An iterator over the minor dimension of the given matrix
* expression.
*/
template <typename ExprT>
static typename ExprT::iterator1 apply(ExprT& e)
{
return e.begin1();
}
/**
* \brief Return a const iterator to the first element of the given
* column-major matrix expression over the minor dimension.
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return A const iterator over the minor dimension of the given matrix
* expression.
*/
template <typename ExprT>
static typename ExprT::const_iterator1 apply(ExprT const& e)
{
return e.begin1();
}
};
} // Namespace detail
/**
* \brief An iterator to the first element of the given vector expression.
* \tparam ExprT A model of VectorExpression type.
* \param e A vector expression.
* \return An iterator to the first element of the given vector expression.
*/
template <typename ExprT>
BOOST_UBLAS_INLINE
typename ExprT::iterator begin(vector_expression<ExprT>& e)
{
return detail::begin_impl<typename ExprT::type_category>::apply(e());
}
/**
* \brief A const iterator to the first element of the given vector expression.
* \tparam ExprT A model of VectorExpression type.
* \param e A vector expression.
* \return A const iterator to the first element of the given vector expression.
*/
template <typename ExprT>
BOOST_UBLAS_INLINE
typename ExprT::const_iterator begin(vector_expression<ExprT> const& e)
{
return detail::begin_impl<typename ExprT::type_category>::apply(e());
}
/**
* \brief An iterator to the first element of the given matrix expression
* according to its orientation.
* \tparam DimTagT A dimension tag type (e.g., tag::major).
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return An iterator to the first element of the given matrix expression
* according to its orientation.
*/
template <typename TagT, typename ExprT>
BOOST_UBLAS_INLINE
typename iterator_type<ExprT,TagT>::type begin(matrix_expression<ExprT>& e)
{
return detail::begin_impl<typename ExprT::type_category, TagT, typename ExprT::orientation_category>::apply(e());
}
/**
* \brief A const iterator to the first element of the given matrix expression
* according to its orientation.
* \tparam TagT A dimension tag type (e.g., tag::major).
* \tparam ExprT A model of MatrixExpression type.
* \param e A matrix expression.
* \return A const iterator to the first element of the given matrix expression
* according to its orientation.
*/
template <typename TagT, typename ExprT>
BOOST_UBLAS_INLINE
typename const_iterator_type<ExprT,TagT>::type begin(matrix_expression<ExprT> const& e)
{
return detail::begin_impl<typename ExprT::type_category, TagT, typename ExprT::orientation_category>::apply(e());
}
/**
* \brief An iterator to the first element over the dual dimension of the given
* iterator.
* \tparam IteratorT A model of Iterator type.
* \param it An iterator.
* \return An iterator to the first element over the dual dimension of the given
* iterator.
*/
template <typename IteratorT>
BOOST_UBLAS_INLINE
typename IteratorT::dual_iterator_type begin(IteratorT& it)
{
return it.begin();
}
/**
* \brief A const iterator to the first element over the dual dimension of the
* given iterator.
* \tparam IteratorT A model of Iterator type.
* \param it An iterator.
* \return A const iterator to the first element over the dual dimension of the
* given iterator.
*/
template <typename IteratorT>
BOOST_UBLAS_INLINE
typename IteratorT::dual_iterator_type begin(IteratorT const& it)
{
return it.begin();
}
}}} // Namespace boost::numeric::ublas
#endif // BOOST_NUMERIC_UBLAS_OPERATION_BEGIN_HPP
|
