//

//  Copyright (c) 2000-2002

//  Joerg Walter, Mathias Koch

//

//  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.

//



#ifndef BOOST_UBLAS_FWD_H

#define BOOST_UBLAS_FWD_H



#include <memory>



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;

    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;

    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;



    // 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

