Boost.uBlas 1.49
Linear Algebra in C++: matrices, vectors and numeric algorithms

fwd.hpp

Go to the documentation of this file.
00001 //
00002 //  Copyright (c) 2000-2010
00003 //  Joerg Walter, Mathias Koch, David Bellot
00004 //
00005 //  Distributed under the Boost Software License, Version 1.0. (See
00006 //  accompanying file LICENSE_1_0.txt or copy at
00007 //  http://www.boost.org/LICENSE_1_0.txt)
00008 //
00009 //  The authors gratefully acknowledge the support of
00010 //  GeNeSys mbH & Co. KG in producing this work.
00011 //
00012 
00014 
00015 #ifndef BOOST_UBLAS_FWD_H
00016 #define BOOST_UBLAS_FWD_H
00017 
00018 #include <memory>
00019 
00020 namespace boost { namespace numeric { namespace ublas {
00021 
00022     // Storage types
00023     template<class T, class ALLOC = std::allocator<T> >
00024     class unbounded_array;
00025 
00026     template<class T, std::size_t N, class ALLOC = std::allocator<T> >
00027     class bounded_array;
00028 
00029     template <class Z = std::size_t, class D = std::ptrdiff_t>
00030     class basic_range;
00031     template <class Z = std::size_t, class D = std::ptrdiff_t>
00032     class basic_slice;
00033     typedef basic_range<> range;
00034     typedef basic_slice<> slice;
00035     template<class A = unbounded_array<std::size_t> >
00036     class indirect_array;
00037 
00038     template<class I, class T, class ALLOC = std::allocator<std::pair<const I, T> > >
00039     class map_std;
00040     template<class I, class T, class ALLOC = std::allocator<std::pair<I, T> > >
00041     class map_array;
00042 
00043     // Expression types
00044     struct scalar_tag {};
00045     
00046     struct vector_tag {};
00047     template<class E>
00048     class vector_expression;
00049     template<class C>
00050     class vector_container;
00051 
00052     template<class E>
00053     class vector_reference;
00054 
00055     struct matrix_tag {};
00056 
00057     template<class E>
00058     class matrix_expression;
00059     template<class C>
00060     class matrix_container;
00061 
00062     template<class E>
00063     class matrix_reference;
00064 
00065     template<class V>
00066     class vector_range;
00067     template<class V>
00068     class vector_slice;
00069     template<class V, class IA = indirect_array<> >
00070     class vector_indirect;
00071 
00072     template<class M>
00073     class matrix_row;
00074     template<class M>
00075     class matrix_column;
00076     template<class M>
00077     class matrix_vector_range;
00078     template<class M>
00079     class matrix_vector_slice;
00080     template<class M, class IA = indirect_array<> >
00081     class matrix_vector_indirect;
00082     template<class M>
00083     class matrix_range;
00084     template<class M>
00085     class matrix_slice;
00086     template<class M, class IA = indirect_array<> >
00087     class matrix_indirect;
00088 
00089     template<class T, class A = unbounded_array<T> >
00090     class vector;
00091     template<class T, std::size_t N>
00092     class bounded_vector;
00093 
00094     template<class T = int, class ALLOC = std::allocator<T> >
00095     class unit_vector;
00096     template<class T = int, class ALLOC = std::allocator<T> >
00097     class zero_vector;
00098     template<class T = int, class ALLOC = std::allocator<T> >
00099     class scalar_vector;
00100 
00101     template<class T, std::size_t N>
00102     class c_vector;
00103 
00104     // Sparse vectors
00105     template<class T, class A = map_std<std::size_t, T> >
00106     class mapped_vector;
00107     template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
00108     class compressed_vector;
00109     template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
00110     class coordinate_vector;
00111 
00112     // Matrix orientation type
00113     struct unknown_orientation_tag {};
00114     struct row_major_tag {};
00115     struct column_major_tag {};
00116 
00117     // Matrix storage layout parameterisation
00118     template <class Z = std::size_t, class D = std::ptrdiff_t>
00119     struct basic_row_major;
00120     typedef basic_row_major<> row_major;
00121 
00122     template <class Z = std::size_t, class D = std::ptrdiff_t>
00123     struct basic_column_major;
00124     typedef basic_column_major<> column_major;
00125 
00126     template<class T, class L = row_major, class A = unbounded_array<T> >
00127     class matrix;
00128     template<class T, std::size_t M, std::size_t N, class L = row_major>
00129     class bounded_matrix;
00130 
00131     template<class T = int, class ALLOC = std::allocator<T> >
00132     class identity_matrix;
00133     template<class T = int, class ALLOC = std::allocator<T> >
00134     class zero_matrix;
00135     template<class T = int, class ALLOC = std::allocator<T> >
00136     class scalar_matrix;
00137 
00138     template<class T, std::size_t M, std::size_t N>
00139     class c_matrix;
00140 
00141     template<class T, class L = row_major, class A = unbounded_array<unbounded_array<T> > >
00142     class vector_of_vector;
00143 
00144     template<class T, class L = row_major, class A = vector<compressed_vector<T> > >
00145     class generalized_vector_of_vector;
00146 
00147     // Triangular matrix type
00148     struct lower_tag {};
00149     struct upper_tag {};
00150     struct unit_lower_tag : public lower_tag {};
00151     struct unit_upper_tag : public upper_tag {};
00152     struct strict_lower_tag : public lower_tag {};
00153     struct strict_upper_tag : public upper_tag {};
00154 
00155     // Triangular matrix parameterisation
00156     template <class Z = std::size_t>
00157     struct basic_full;
00158     typedef basic_full<> full;
00159 
00160     template <class Z = std::size_t>
00161     struct basic_lower;
00162     typedef basic_lower<> lower;
00163 
00164     template <class Z = std::size_t>
00165     struct basic_upper;
00166     typedef basic_upper<> upper;
00167 
00168     template <class Z = std::size_t>
00169     struct basic_unit_lower;
00170     typedef basic_unit_lower<> unit_lower;
00171 
00172     template <class Z = std::size_t>
00173     struct basic_unit_upper;
00174     typedef basic_unit_upper<> unit_upper;
00175 
00176     template <class Z = std::size_t>
00177     struct basic_strict_lower;
00178     typedef basic_strict_lower<> strict_lower;
00179 
00180     template <class Z = std::size_t>
00181     struct basic_strict_upper;
00182     typedef basic_strict_upper<> strict_upper;
00183 
00184     // Special matrices
00185     template<class T, class L = row_major, class A = unbounded_array<T> >
00186     class banded_matrix;
00187     template<class T, class L = row_major, class A = unbounded_array<T> >
00188     class diagonal_matrix;
00189 
00190     template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
00191     class triangular_matrix;
00192     template<class M, class TRI = lower>
00193     class triangular_adaptor;
00194 
00195     template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
00196     class symmetric_matrix;
00197     template<class M, class TRI = lower>
00198     class symmetric_adaptor;
00199 
00200     template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
00201     class hermitian_matrix;
00202     template<class M, class TRI = lower>
00203     class hermitian_adaptor;
00204 
00205     // Sparse matrices
00206     template<class T, class L = row_major, class A = map_std<std::size_t, T> >
00207     class mapped_matrix;
00208     template<class T, class L = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > >
00209     class mapped_vector_of_mapped_vector;
00210     template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
00211     class compressed_matrix;
00212     template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
00213     class coordinate_matrix;
00214 
00215 }}}
00216 
00217 #endif