New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
fwd.hpp in vendors/XIOS/current/extern/boost/include/boost/numeric/ublas – NEMO

source: vendors/XIOS/current/extern/boost/include/boost/numeric/ublas/fwd.hpp @ 3408

Last change on this file since 3408 was 3408, checked in by rblod, 12 years ago

importing initial XIOS vendor drop

  • Property svn:keywords set to Id
File size: 6.7 KB
Line 
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
20namespace boost { namespace numeric { namespace ublas {
21
22    // Storage types
23    template<class T, class ALLOC = std::allocator<T> >
24    class unbounded_array;
25
26    template<class T, std::size_t N, class ALLOC = std::allocator<T> >
27    class bounded_array;
28
29    template <class Z = std::size_t, class D = std::ptrdiff_t>
30    class basic_range;
31    template <class Z = std::size_t, class D = std::ptrdiff_t>
32    class basic_slice;
33    typedef basic_range<> range;
34    typedef basic_slice<> slice;
35    template<class A = unbounded_array<std::size_t> >
36    class indirect_array;
37
38    template<class I, class T, class ALLOC = std::allocator<std::pair<const I, T> > >
39    class map_std;
40    template<class I, class T, class ALLOC = std::allocator<std::pair<I, T> > >
41    class map_array;
42
43    // Expression types
44    struct scalar_tag {};
45   
46    struct vector_tag {};
47    template<class E>
48    class vector_expression;
49    template<class C>
50    class vector_container;
51
52    template<class E>
53    class vector_reference;
54
55    struct matrix_tag {};
56
57    template<class E>
58    class matrix_expression;
59    template<class C>
60    class matrix_container;
61
62    template<class E>
63    class matrix_reference;
64
65    template<class V>
66    class vector_range;
67    template<class V>
68    class vector_slice;
69    template<class V, class IA = indirect_array<> >
70    class vector_indirect;
71
72    template<class M>
73    class matrix_row;
74    template<class M>
75    class matrix_column;
76    template<class M>
77    class matrix_vector_range;
78    template<class M>
79    class matrix_vector_slice;
80    template<class M, class IA = indirect_array<> >
81    class matrix_vector_indirect;
82    template<class M>
83    class matrix_range;
84    template<class M>
85    class matrix_slice;
86    template<class M, class IA = indirect_array<> >
87    class matrix_indirect;
88
89    template<class T, class A = unbounded_array<T> >
90    class vector;
91    template<class T, std::size_t N>
92    class bounded_vector;
93
94    template<class T = int, class ALLOC = std::allocator<T> >
95    class unit_vector;
96    template<class T = int, class ALLOC = std::allocator<T> >
97    class zero_vector;
98    template<class T = int, class ALLOC = std::allocator<T> >
99    class scalar_vector;
100
101    template<class T, std::size_t N>
102    class c_vector;
103
104    // Sparse vectors
105    template<class T, class A = map_std<std::size_t, T> >
106    class mapped_vector;
107    template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
108    class compressed_vector;
109    template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
110    class coordinate_vector;
111
112    // Matrix orientation type
113    struct unknown_orientation_tag {};
114    struct row_major_tag {};
115    struct column_major_tag {};
116
117    // Matrix storage layout parameterisation
118    template <class Z = std::size_t, class D = std::ptrdiff_t>
119    struct basic_row_major;
120    typedef basic_row_major<> row_major;
121
122    template <class Z = std::size_t, class D = std::ptrdiff_t>
123    struct basic_column_major;
124    typedef basic_column_major<> column_major;
125
126    template<class T, class L = row_major, class A = unbounded_array<T> >
127    class matrix;
128    template<class T, std::size_t M, std::size_t N, class L = row_major>
129    class bounded_matrix;
130
131    template<class T = int, class ALLOC = std::allocator<T> >
132    class identity_matrix;
133    template<class T = int, class ALLOC = std::allocator<T> >
134    class zero_matrix;
135    template<class T = int, class ALLOC = std::allocator<T> >
136    class scalar_matrix;
137
138    template<class T, std::size_t M, std::size_t N>
139    class c_matrix;
140
141    template<class T, class L = row_major, class A = unbounded_array<unbounded_array<T> > >
142    class vector_of_vector;
143
144    template<class T, class L = row_major, class A = vector<compressed_vector<T> > >
145    class generalized_vector_of_vector;
146
147    // Triangular matrix type
148    struct lower_tag {};
149    struct upper_tag {};
150    struct unit_lower_tag : public lower_tag {};
151    struct unit_upper_tag : public upper_tag {};
152    struct strict_lower_tag : public lower_tag {};
153    struct strict_upper_tag : public upper_tag {};
154
155    // Triangular matrix parameterisation
156    template <class Z = std::size_t>
157    struct basic_full;
158    typedef basic_full<> full;
159
160    template <class Z = std::size_t>
161    struct basic_lower;
162    typedef basic_lower<> lower;
163
164    template <class Z = std::size_t>
165    struct basic_upper;
166    typedef basic_upper<> upper;
167
168    template <class Z = std::size_t>
169    struct basic_unit_lower;
170    typedef basic_unit_lower<> unit_lower;
171
172    template <class Z = std::size_t>
173    struct basic_unit_upper;
174    typedef basic_unit_upper<> unit_upper;
175
176    template <class Z = std::size_t>
177    struct basic_strict_lower;
178    typedef basic_strict_lower<> strict_lower;
179
180    template <class Z = std::size_t>
181    struct basic_strict_upper;
182    typedef basic_strict_upper<> strict_upper;
183
184    // Special matrices
185    template<class T, class L = row_major, class A = unbounded_array<T> >
186    class banded_matrix;
187    template<class T, class L = row_major, class A = unbounded_array<T> >
188    class diagonal_matrix;
189
190    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
191    class triangular_matrix;
192    template<class M, class TRI = lower>
193    class triangular_adaptor;
194
195    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
196    class symmetric_matrix;
197    template<class M, class TRI = lower>
198    class symmetric_adaptor;
199
200    template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
201    class hermitian_matrix;
202    template<class M, class TRI = lower>
203    class hermitian_adaptor;
204
205    // Sparse matrices
206    template<class T, class L = row_major, class A = map_std<std::size_t, T> >
207    class mapped_matrix;
208    template<class T, class L = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > >
209    class mapped_vector_of_mapped_vector;
210    template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
211    class compressed_matrix;
212    template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
213    class coordinate_matrix;
214
215}}}
216
217#endif
Note: See TracBrowser for help on using the repository browser.