source: NonGTP/Boost/boost/numeric/ublas/fwd.hpp @ 857

Revision 857, 6.6 KB checked in by igarcia, 19 years ago (diff)
Line 
1//
2//  Copyright (c) 2000-2002
3//  Joerg Walter, Mathias Koch
4//
5//  Permission to use, copy, modify, distribute and sell this software
6//  and its documentation for any purpose is hereby granted without fee,
7//  provided that the above copyright notice appear in all copies and
8//  that both that copyright notice and this permission notice appear
9//  in supporting documentation.  The authors make no representations
10//  about the suitability of this software for any purpose.
11//  It is provided "as is" without express or implied warranty.
12//
13//  The authors gratefully acknowledge the support of
14//  GeNeSys mbH & Co. KG in producing this work.
15//
16
17#ifndef BOOST_UBLAS_FWD_H
18#define BOOST_UBLAS_FWD_H
19
20#include <memory>
21
22namespace boost { namespace numeric { namespace ublas {
23
24    // Storage types
25    template<class T, class ALLOC = std::allocator<T> >
26    class unbounded_array;
27
28    template<class T, std::size_t N, class ALLOC = std::allocator<T> >
29    class bounded_array;
30
31    template <class Z = std::size_t, class D = std::ptrdiff_t>
32    class basic_range;
33    template <class Z = std::size_t, class D = std::ptrdiff_t>
34    class basic_slice;
35    typedef basic_range<> range;
36    typedef basic_slice<> slice;
37    template<class A = unbounded_array<std::size_t> >
38    class indirect_array;
39
40    template<class I, class T, class ALLOC = std::allocator<std::pair<const I, T> > >
41    class map_std;
42    template<class I, class T, class ALLOC = std::allocator<std::pair<I, T> > >
43    class map_array;
44
45    // Expression types
46    struct scalar_tag {};
47   
48    struct vector_tag {};
49    template<class E>
50    class vector_expression;
51    template<class C>
52    class vector_container;
53
54    template<class E>
55    class vector_reference;
56
57    struct matrix_tag {};
58
59    template<class E>
60    class matrix_expression;
61    template<class C>
62    class matrix_container;
63
64    template<class E>
65    class matrix_reference;
66
67    template<class E>
68    class vector_range;
69    template<class E>
70    class vector_slice;
71    template<class E, class IA = indirect_array<> >
72    class vector_indirect;
73
74    template<class E>
75    class matrix_row;
76    template<class E>
77    class matrix_column;
78    template<class E>
79    class matrix_range;
80    template<class E>
81    class matrix_slice;
82    template<class E, class IA = indirect_array<> >
83    class matrix_indirect;
84
85    template<class T, class A = unbounded_array<T> >
86    class vector;
87    template<class T, std::size_t N>
88    class bounded_vector;
89
90    template<class T = int>
91    class unit_vector;
92    template<class T = int>
93    class zero_vector;
94    template<class T = int>
95    class scalar_vector;
96
97    template<class T, std::size_t N>
98    class c_vector;
99
100    // Sparse vectors
101    template<class T, class A = map_std<std::size_t, T> >
102    class mapped_vector;
103    template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
104    class compressed_vector;
105    template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
106    class coordinate_vector;
107
108    // Matrix orientation type
109    struct unknown_orientation_tag {};
110    struct row_major_tag {};
111    struct column_major_tag {};
112
113    // Matrix storage layout parameterisation
114    template <class Z = std::size_t, class D = std::ptrdiff_t>
115    struct basic_row_major;
116    typedef basic_row_major<> row_major;
117
118    template <class Z = std::size_t, class D = std::ptrdiff_t>
119    struct basic_column_major;
120    typedef basic_column_major<> column_major;
121
122    template<class T, class L = row_major, class A = unbounded_array<T> >
123    class matrix;
124    template<class T, std::size_t M, std::size_t N, class L = row_major>
125    class bounded_matrix;
126
127    template<class T = int>
128    class identity_matrix;
129    template<class T = int>
130    class zero_matrix;
131    template<class T = int>
132    class scalar_matrix;
133
134    template<class T, std::size_t M, std::size_t N>
135    class c_matrix;
136
137    template<class T, class L = row_major, class A = unbounded_array<unbounded_array<T> > >
138    class vector_of_vector;
139
140    // Triangular matrix type
141    struct lower_tag {};
142    struct upper_tag {};
143    struct unit_lower_tag : public lower_tag {};
144    struct unit_upper_tag : public upper_tag {};
145    struct strict_lower_tag : public lower_tag {};
146    struct strict_upper_tag : public upper_tag {};
147
148    // Triangular matrix parameterisation
149    template <class Z = std::size_t>
150    struct basic_full;
151    typedef basic_full<> full;
152
153    template <class Z = std::size_t>
154    struct basic_lower;
155    typedef basic_lower<> lower;
156
157    template <class Z = std::size_t>
158    struct basic_upper;
159    typedef basic_upper<> upper;
160
161    template <class Z = std::size_t>
162    struct basic_unit_lower;
163    typedef basic_unit_lower<> unit_lower;
164
165    template <class Z = std::size_t>
166    struct basic_unit_upper;
167    typedef basic_unit_upper<> unit_upper;
168
169    template <class Z = std::size_t>
170    struct basic_strict_lower;
171    typedef basic_strict_lower<> strict_lower;
172
173    template <class Z = std::size_t>
174    struct basic_strict_upper;
175    typedef basic_strict_upper<> strict_upper;
176
177    // Special matrices
178    template<class T, class L = row_major, class A = unbounded_array<T> >
179    class banded_matrix;
180    template<class T, class L = row_major, class A = unbounded_array<T> >
181    class diagonal_matrix;
182
183    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
184    class triangular_matrix;
185    template<class M, class TRI = lower>
186    class triangular_adaptor;
187
188    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
189    class symmetric_matrix;
190    template<class M, class TRI = lower>
191    class symmetric_adaptor;
192
193    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
194    class hermitian_matrix;
195    template<class M, class TRI = lower>
196    class hermitian_adaptor;
197
198    // Sparse matrices
199    template<class T, class L = row_major, class A = map_std<std::size_t, T> >
200    class mapped_matrix;
201    template<class T, class L = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > >
202    class mapped_vector_of_mapped_vector;
203    template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
204    class compressed_matrix;
205    template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
206    class coordinate_matrix;
207
208}}}
209
210#endif
Note: See TracBrowser for help on using the repository browser.