Squashed 'third_party/boostorg/ublas/' content from commit e8607b3
Change-Id: Ia06afd642157a24e17fa9ddea28fb8601810b78e
git-subtree-dir: third_party/boostorg/ublas
git-subtree-split: e8607b3eea238e590eca93bfe498c21f470155c1
diff --git a/include/boost/numeric/ublas/fwd.hpp b/include/boost/numeric/ublas/fwd.hpp
new file mode 100644
index 0000000..69b3dd2
--- /dev/null
+++ b/include/boost/numeric/ublas/fwd.hpp
@@ -0,0 +1,229 @@
+//
+// Copyright (c) 2000-2010
+// Joerg Walter, Mathias Koch, David Bellot
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// The authors gratefully acknowledge the support of
+// GeNeSys mbH & Co. KG in producing this work.
+//
+
+/// \file fwd.hpp is essentially used to forward declare the main types
+
+#ifndef BOOST_UBLAS_FWD_H
+#define BOOST_UBLAS_FWD_H
+
+#include <memory>
+
+#ifdef BOOST_UBLAS_CPP_GE_2011
+#include <array>
+#endif
+
+namespace boost { namespace numeric { namespace ublas {
+
+ // Storage types
+ template<class T, class ALLOC = std::allocator<T> >
+ class unbounded_array;
+
+ template<class T, std::size_t N, class ALLOC = std::allocator<T> >
+ class bounded_array;
+
+ template <class Z = std::size_t, class D = std::ptrdiff_t>
+ class basic_range;
+ template <class Z = std::size_t, class D = std::ptrdiff_t>
+ class basic_slice;
+ typedef basic_range<> range;
+ typedef basic_slice<> slice;
+ template<class A = unbounded_array<std::size_t> >
+ class indirect_array;
+
+ template<class I, class T, class ALLOC = std::allocator<std::pair<const I, T> > >
+ class map_std;
+ template<class I, class T, class ALLOC = std::allocator<std::pair<I, T> > >
+ class map_array;
+
+ // Expression types
+ struct scalar_tag {};
+
+ struct vector_tag {};
+ template<class E>
+ class vector_expression;
+ template<class C>
+ class vector_container;
+
+ template<class E>
+ class vector_reference;
+
+ struct matrix_tag {};
+
+ template<class E>
+ class matrix_expression;
+ template<class C>
+ class matrix_container;
+
+ template<class E>
+ class matrix_reference;
+
+ template<class V>
+ class vector_range;
+ template<class V>
+ class vector_slice;
+ template<class V, class IA = indirect_array<> >
+ class vector_indirect;
+
+ template<class M>
+ class matrix_row;
+ template<class M>
+ class matrix_column;
+ template<class M>
+ class matrix_vector_range;
+ template<class M>
+ class matrix_vector_slice;
+ template<class M, class IA = indirect_array<> >
+ class matrix_vector_indirect;
+ template<class M>
+ class matrix_range;
+ template<class M>
+ class matrix_slice;
+ template<class M, class IA = indirect_array<> >
+ class matrix_indirect;
+
+ template<class T, class A = unbounded_array<T> >
+ class vector;
+#ifdef BOOST_UBLAS_CPP_GE_2011
+ template<class T, std::size_t N, class A = std::array<T, N> >
+ class fixed_vector;
+#endif
+ template<class T, std::size_t N>
+ class bounded_vector;
+
+ template<class T = int, class ALLOC = std::allocator<T> >
+ class unit_vector;
+ template<class T = int, class ALLOC = std::allocator<T> >
+ class zero_vector;
+ template<class T = int, class ALLOC = std::allocator<T> >
+ class scalar_vector;
+
+ template<class T, std::size_t N>
+ class c_vector;
+
+ // Sparse vectors
+ template<class T, class A = map_std<std::size_t, T> >
+ class mapped_vector;
+ template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
+ class compressed_vector;
+ template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
+ class coordinate_vector;
+
+ // Matrix orientation type
+ struct unknown_orientation_tag {};
+ struct row_major_tag {};
+ struct column_major_tag {};
+
+ // Matrix storage layout parameterisation
+ template <class Z = std::size_t, class D = std::ptrdiff_t>
+ struct basic_row_major;
+ typedef basic_row_major<> row_major;
+
+ template <class Z = std::size_t, class D = std::ptrdiff_t>
+ struct basic_column_major;
+ typedef basic_column_major<> column_major;
+
+ template<class T, class L = row_major, class A = unbounded_array<T> >
+ class matrix;
+#ifdef BOOST_UBLAS_CPP_GE_2011
+ template<class T, std::size_t M, std::size_t N, class L = row_major, class A = std::array<T, M*N> >
+ class fixed_matrix;
+#endif
+ template<class T, std::size_t M, std::size_t N, class L = row_major>
+ class bounded_matrix;
+
+ template<class T = int, class ALLOC = std::allocator<T> >
+ class identity_matrix;
+ template<class T = int, class ALLOC = std::allocator<T> >
+ class zero_matrix;
+ template<class T = int, class ALLOC = std::allocator<T> >
+ class scalar_matrix;
+
+ template<class T, std::size_t M, std::size_t N>
+ class c_matrix;
+
+ template<class T, class L = row_major, class A = unbounded_array<unbounded_array<T> > >
+ class vector_of_vector;
+
+ template<class T, class L = row_major, class A = vector<compressed_vector<T> > >
+ class generalized_vector_of_vector;
+
+ // Triangular matrix type
+ struct lower_tag {};
+ struct upper_tag {};
+ struct unit_lower_tag : public lower_tag {};
+ struct unit_upper_tag : public upper_tag {};
+ struct strict_lower_tag : public lower_tag {};
+ struct strict_upper_tag : public upper_tag {};
+
+ // Triangular matrix parameterisation
+ template <class Z = std::size_t>
+ struct basic_full;
+ typedef basic_full<> full;
+
+ template <class Z = std::size_t>
+ struct basic_lower;
+ typedef basic_lower<> lower;
+
+ template <class Z = std::size_t>
+ struct basic_upper;
+ typedef basic_upper<> upper;
+
+ template <class Z = std::size_t>
+ struct basic_unit_lower;
+ typedef basic_unit_lower<> unit_lower;
+
+ template <class Z = std::size_t>
+ struct basic_unit_upper;
+ typedef basic_unit_upper<> unit_upper;
+
+ template <class Z = std::size_t>
+ struct basic_strict_lower;
+ typedef basic_strict_lower<> strict_lower;
+
+ template <class Z = std::size_t>
+ struct basic_strict_upper;
+ typedef basic_strict_upper<> strict_upper;
+
+ // Special matrices
+ template<class T, class L = row_major, class A = unbounded_array<T> >
+ class banded_matrix;
+ template<class T, class L = row_major, class A = unbounded_array<T> >
+ class diagonal_matrix;
+
+ template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
+ class triangular_matrix;
+ template<class M, class TRI = lower>
+ class triangular_adaptor;
+
+ template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
+ class symmetric_matrix;
+ template<class M, class TRI = lower>
+ class symmetric_adaptor;
+
+ template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
+ class hermitian_matrix;
+ template<class M, class TRI = lower>
+ class hermitian_adaptor;
+
+ // Sparse matrices
+ template<class T, class L = row_major, class A = map_std<std::size_t, T> >
+ class mapped_matrix;
+ template<class T, class L = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > >
+ class mapped_vector_of_mapped_vector;
+ template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
+ class compressed_matrix;
+ template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
+ class coordinate_matrix;
+
+}}}
+
+#endif