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
|
//
// Copyright (c) 2000-2010
// Joerg Walter, Mathias Koch, David Bellot
//
// 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)
//
// The authors gratefully acknowledge the support of
// GeNeSys mbH & Co. KG in producing this work.
//
/// \file fwd.hpp is essentially used to forward declare the main types
#ifndef BOOST_UBLAS_FWD_H
#define BOOST_UBLAS_FWD_H
#include <memory>
#ifdef BOOST_UBLAS_CPP_GE_2011
#include <array>
#endif
namespace boost { namespace numeric { namespace ublas {
// Storage types
template<class T, class ALLOC = std::allocator<T> >
class unbounded_array;
template<class T, std::size_t N, class ALLOC = std::allocator<T> >
class bounded_array;
template <class Z = std::size_t, class D = std::ptrdiff_t>
class basic_range;
template <class Z = std::size_t, class D = std::ptrdiff_t>
class basic_slice;
typedef basic_range<> range;
typedef basic_slice<> slice;
template<class A = unbounded_array<std::size_t> >
class indirect_array;
template<class I, class T, class ALLOC = std::allocator<std::pair<const I, T> > >
class map_std;
template<class I, class T, class ALLOC = std::allocator<std::pair<I, T> > >
class map_array;
// Expression types
struct scalar_tag {};
struct vector_tag {};
template<class E>
class vector_expression;
template<class C>
class vector_container;
template<class E>
class vector_reference;
struct matrix_tag {};
template<class E>
class matrix_expression;
template<class C>
class matrix_container;
template<class E>
class matrix_reference;
template<class V>
class vector_range;
template<class V>
class vector_slice;
template<class V, class IA = indirect_array<> >
class vector_indirect;
template<class M>
class matrix_row;
template<class M>
class matrix_column;
template<class M>
class matrix_vector_range;
template<class M>
class matrix_vector_slice;
template<class M, class IA = indirect_array<> >
class matrix_vector_indirect;
template<class M>
class matrix_range;
template<class M>
class matrix_slice;
template<class M, class IA = indirect_array<> >
class matrix_indirect;
template<class T, class A = unbounded_array<T> >
class vector;
#ifdef BOOST_UBLAS_CPP_GE_2011
template<class T, std::size_t N, class A = std::array<T, N> >
class fixed_vector;
#endif
template<class T, std::size_t N>
class bounded_vector;
template<class T = int, class ALLOC = std::allocator<T> >
class unit_vector;
template<class T = int, class ALLOC = std::allocator<T> >
class zero_vector;
template<class T = int, class ALLOC = std::allocator<T> >
class scalar_vector;
template<class T, std::size_t N>
class c_vector;
// Sparse vectors
template<class T, class A = map_std<std::size_t, T> >
class mapped_vector;
template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
class compressed_vector;
template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
class coordinate_vector;
// Matrix orientation type
struct unknown_orientation_tag {};
struct row_major_tag {};
struct column_major_tag {};
// Matrix storage layout parameterisation
template <class Z = std::size_t, class D = std::ptrdiff_t>
struct basic_row_major;
typedef basic_row_major<> row_major;
template <class Z = std::size_t, class D = std::ptrdiff_t>
struct basic_column_major;
typedef basic_column_major<> column_major;
template<class T, class L = row_major, class A = unbounded_array<T> >
class matrix;
#ifdef BOOST_UBLAS_CPP_GE_2011
template<class T, std::size_t M, std::size_t N, class L = row_major, class A = std::array<T, M*N> >
class fixed_matrix;
#endif
template<class T, std::size_t M, std::size_t N, class L = row_major>
class bounded_matrix;
template<class T = int, class ALLOC = std::allocator<T> >
class identity_matrix;
template<class T = int, class ALLOC = std::allocator<T> >
class zero_matrix;
template<class T = int, class ALLOC = std::allocator<T> >
class scalar_matrix;
template<class T, std::size_t M, std::size_t N>
class c_matrix;
template<class T, class L = row_major, class A = unbounded_array<unbounded_array<T> > >
class vector_of_vector;
template<class T, class L = row_major, class A = vector<compressed_vector<T> > >
class generalized_vector_of_vector;
// Triangular matrix type
struct lower_tag {};
struct upper_tag {};
struct unit_lower_tag : public lower_tag {};
struct unit_upper_tag : public upper_tag {};
struct strict_lower_tag : public lower_tag {};
struct strict_upper_tag : public upper_tag {};
// Triangular matrix parameterisation
template <class Z = std::size_t>
struct basic_full;
typedef basic_full<> full;
template <class Z = std::size_t>
struct basic_lower;
typedef basic_lower<> lower;
template <class Z = std::size_t>
struct basic_upper;
typedef basic_upper<> upper;
template <class Z = std::size_t>
struct basic_unit_lower;
typedef basic_unit_lower<> unit_lower;
template <class Z = std::size_t>
struct basic_unit_upper;
typedef basic_unit_upper<> unit_upper;
template <class Z = std::size_t>
struct basic_strict_lower;
typedef basic_strict_lower<> strict_lower;
template <class Z = std::size_t>
struct basic_strict_upper;
typedef basic_strict_upper<> strict_upper;
// Special matrices
template<class T, class L = row_major, class A = unbounded_array<T> >
class banded_matrix;
template<class T, class L = row_major, class A = unbounded_array<T> >
class diagonal_matrix;
template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
class triangular_matrix;
template<class M, class TRI = lower>
class triangular_adaptor;
template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
class symmetric_matrix;
template<class M, class TRI = lower>
class symmetric_adaptor;
template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
class hermitian_matrix;
template<class M, class TRI = lower>
class hermitian_adaptor;
// Sparse matrices
template<class T, class L = row_major, class A = map_std<std::size_t, T> >
class mapped_matrix;
template<class T, class L = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > >
class mapped_vector_of_mapped_vector;
template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
class compressed_matrix;
template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
class coordinate_matrix;
}}}
#endif
|
