]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // Copyright (c) 2000-2010 | |
3 | // Joerg Walter, Mathias Koch, David Bellot | |
4 | // | |
5 | // Distributed under the Boost Software License, Version 1.0. (See | |
6 | // accompanying file LICENSE_1_0.txt or copy at | |
7 | // http://www.boost.org/LICENSE_1_0.txt) | |
8 | // | |
9 | // The authors gratefully acknowledge the support of | |
10 | // GeNeSys mbH & Co. KG in producing this work. | |
11 | // | |
12 | ||
13 | /// \file fwd.hpp is essentially used to forward declare the main types | |
14 | ||
15 | #ifndef BOOST_UBLAS_FWD_H | |
16 | #define BOOST_UBLAS_FWD_H | |
17 | ||
18 | #include <memory> | |
19 | ||
20 | #ifdef BOOST_UBLAS_CPP_GE_2011 | |
21 | #include <array> | |
22 | #endif | |
23 | ||
24 | namespace boost { namespace numeric { namespace ublas { | |
25 | ||
26 | // Storage types | |
27 | template<class T, class ALLOC = std::allocator<T> > | |
28 | class unbounded_array; | |
29 | ||
30 | template<class T, std::size_t N, class ALLOC = std::allocator<T> > | |
31 | class bounded_array; | |
32 | ||
33 | template <class Z = std::size_t, class D = std::ptrdiff_t> | |
34 | class basic_range; | |
35 | template <class Z = std::size_t, class D = std::ptrdiff_t> | |
36 | class basic_slice; | |
37 | typedef basic_range<> range; | |
38 | typedef basic_slice<> slice; | |
39 | template<class A = unbounded_array<std::size_t> > | |
40 | class indirect_array; | |
41 | ||
42 | template<class I, class T, class ALLOC = std::allocator<std::pair<const I, T> > > | |
43 | class map_std; | |
44 | template<class I, class T, class ALLOC = std::allocator<std::pair<I, T> > > | |
45 | class map_array; | |
46 | ||
47 | // Expression types | |
48 | struct scalar_tag {}; | |
49 | ||
50 | struct vector_tag {}; | |
51 | template<class E> | |
52 | class vector_expression; | |
53 | template<class C> | |
54 | class vector_container; | |
55 | ||
56 | template<class E> | |
57 | class vector_reference; | |
58 | ||
59 | struct matrix_tag {}; | |
60 | ||
61 | template<class E> | |
62 | class matrix_expression; | |
63 | template<class C> | |
64 | class matrix_container; | |
65 | ||
66 | template<class E> | |
67 | class matrix_reference; | |
68 | ||
69 | template<class V> | |
70 | class vector_range; | |
71 | template<class V> | |
72 | class vector_slice; | |
73 | template<class V, class IA = indirect_array<> > | |
74 | class vector_indirect; | |
75 | ||
76 | template<class M> | |
77 | class matrix_row; | |
78 | template<class M> | |
79 | class matrix_column; | |
80 | template<class M> | |
81 | class matrix_vector_range; | |
82 | template<class M> | |
83 | class matrix_vector_slice; | |
84 | template<class M, class IA = indirect_array<> > | |
85 | class matrix_vector_indirect; | |
86 | template<class M> | |
87 | class matrix_range; | |
88 | template<class M> | |
89 | class matrix_slice; | |
90 | template<class M, class IA = indirect_array<> > | |
91 | class matrix_indirect; | |
92 | ||
93 | template<class T, class A = unbounded_array<T> > | |
94 | class vector; | |
95 | #ifdef BOOST_UBLAS_CPP_GE_2011 | |
96 | template<class T, std::size_t N, class A = std::array<T, N> > | |
97 | class fixed_vector; | |
98 | #endif | |
99 | template<class T, std::size_t N> | |
100 | class bounded_vector; | |
101 | ||
102 | template<class T = int, class ALLOC = std::allocator<T> > | |
103 | class unit_vector; | |
104 | template<class T = int, class ALLOC = std::allocator<T> > | |
105 | class zero_vector; | |
106 | template<class T = int, class ALLOC = std::allocator<T> > | |
107 | class scalar_vector; | |
108 | ||
109 | template<class T, std::size_t N> | |
110 | class c_vector; | |
111 | ||
112 | // Sparse vectors | |
113 | template<class T, class A = map_std<std::size_t, T> > | |
114 | class mapped_vector; | |
115 | template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> > | |
116 | class compressed_vector; | |
117 | template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> > | |
118 | class coordinate_vector; | |
119 | ||
120 | // Matrix orientation type | |
121 | struct unknown_orientation_tag {}; | |
122 | struct row_major_tag {}; | |
123 | struct column_major_tag {}; | |
124 | ||
125 | // Matrix storage layout parameterisation | |
126 | template <class Z = std::size_t, class D = std::ptrdiff_t> | |
127 | struct basic_row_major; | |
128 | typedef basic_row_major<> row_major; | |
129 | ||
130 | template <class Z = std::size_t, class D = std::ptrdiff_t> | |
131 | struct basic_column_major; | |
132 | typedef basic_column_major<> column_major; | |
133 | ||
134 | template<class T, class L = row_major, class A = unbounded_array<T> > | |
135 | class matrix; | |
136 | #ifdef BOOST_UBLAS_CPP_GE_2011 | |
137 | template<class T, std::size_t M, std::size_t N, class L = row_major, class A = std::array<T, M*N> > | |
138 | class fixed_matrix; | |
139 | #endif | |
140 | template<class T, std::size_t M, std::size_t N, class L = row_major> | |
141 | class bounded_matrix; | |
142 | ||
143 | template<class T = int, class ALLOC = std::allocator<T> > | |
144 | class identity_matrix; | |
145 | template<class T = int, class ALLOC = std::allocator<T> > | |
146 | class zero_matrix; | |
147 | template<class T = int, class ALLOC = std::allocator<T> > | |
148 | class scalar_matrix; | |
149 | ||
150 | template<class T, std::size_t M, std::size_t N> | |
151 | class c_matrix; | |
152 | ||
153 | template<class T, class L = row_major, class A = unbounded_array<unbounded_array<T> > > | |
154 | class vector_of_vector; | |
155 | ||
156 | template<class T, class L = row_major, class A = vector<compressed_vector<T> > > | |
157 | class generalized_vector_of_vector; | |
158 | ||
159 | // Triangular matrix type | |
160 | struct lower_tag {}; | |
161 | struct upper_tag {}; | |
162 | struct unit_lower_tag : public lower_tag {}; | |
163 | struct unit_upper_tag : public upper_tag {}; | |
164 | struct strict_lower_tag : public lower_tag {}; | |
165 | struct strict_upper_tag : public upper_tag {}; | |
166 | ||
167 | // Triangular matrix parameterisation | |
168 | template <class Z = std::size_t> | |
169 | struct basic_full; | |
170 | typedef basic_full<> full; | |
171 | ||
172 | template <class Z = std::size_t> | |
173 | struct basic_lower; | |
174 | typedef basic_lower<> lower; | |
175 | ||
176 | template <class Z = std::size_t> | |
177 | struct basic_upper; | |
178 | typedef basic_upper<> upper; | |
179 | ||
180 | template <class Z = std::size_t> | |
181 | struct basic_unit_lower; | |
182 | typedef basic_unit_lower<> unit_lower; | |
183 | ||
184 | template <class Z = std::size_t> | |
185 | struct basic_unit_upper; | |
186 | typedef basic_unit_upper<> unit_upper; | |
187 | ||
188 | template <class Z = std::size_t> | |
189 | struct basic_strict_lower; | |
190 | typedef basic_strict_lower<> strict_lower; | |
191 | ||
192 | template <class Z = std::size_t> | |
193 | struct basic_strict_upper; | |
194 | typedef basic_strict_upper<> strict_upper; | |
195 | ||
196 | // Special matrices | |
197 | template<class T, class L = row_major, class A = unbounded_array<T> > | |
198 | class banded_matrix; | |
199 | template<class T, class L = row_major, class A = unbounded_array<T> > | |
200 | class diagonal_matrix; | |
201 | ||
202 | template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> > | |
203 | class triangular_matrix; | |
204 | template<class M, class TRI = lower> | |
205 | class triangular_adaptor; | |
206 | ||
207 | template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> > | |
208 | class symmetric_matrix; | |
209 | template<class M, class TRI = lower> | |
210 | class symmetric_adaptor; | |
211 | ||
212 | template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> > | |
213 | class hermitian_matrix; | |
214 | template<class M, class TRI = lower> | |
215 | class hermitian_adaptor; | |
216 | ||
217 | // Sparse matrices | |
218 | template<class T, class L = row_major, class A = map_std<std::size_t, T> > | |
219 | class mapped_matrix; | |
220 | template<class T, class L = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > > | |
221 | class mapped_vector_of_mapped_vector; | |
222 | template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> > | |
223 | class compressed_matrix; | |
224 | template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> > | |
225 | class coordinate_matrix; | |
226 | ||
227 | }}} | |
228 | ||
229 | #endif |