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 230