ublas: fwd.hpp Source File

- Main Page
- Related Pages
- Classes
- Files

- File List

# fwd.hpp

    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