// -*- c++ -*-
//
// $COPYRIGHT$
//
//===========================================================================


#ifndef _MTL_MATRIX_H_
#define _MTL_MATRIX_H_


/* namespace polution from <sys/sysmacros.h> */
#undef major
#undef minor

#include <set>
#include <list>
#include <vector>

#include "mtl/meta_equal.h"
#include "mtl/meta_if.h"

#include "mtl/matrix_traits.h"
#include "mtl/compressed1D.h"

#include "mtl/matrix_implementation.h"
#include "mtl/rect_indexer.h"
#include "mtl/banded_indexer.h"
#include "mtl/diagonal_indexer.h"

#include "mtl/dense2D.h"
#include "mtl/array2D.h"
#include "mtl/compressed2D.h"
#include "mtl/envelope2D.h"
#include <mtl/packed_matrix.h>
#include <mtl/triangle_banded_matrix.h>
#include <mtl/diagonal_matrix.h>

#include "mtl/linalg_vec.h"
#include "mtl/sparse1D.h"
#include "mtl/entry.h"
#include "mtl/uplo.h"
#include "mtl/selectors.h"

namespace mtl {

  /* Shapes */



  //: generators for oned
  //!noindex:
  template <class T, class Storage, class Order>
  struct generate_oned {
    enum { Storage_oned_id = Storage::oned_id, 
           Storage_index = Storage::index };
    typedef typename IF< EQUAL< Storage_oned_id,DENSE>::RET,
                         dense1D<T, dynamic_size, Order>,
                     typename IF< EQUAL< Storage_oned_id,COMPRESSED>::RET,
                         compressed1D<T, typename Storage::size_type, 
                                         Storage_index, Order>,
                     typename IF< EQUAL< Storage_oned_id,SPARSE_PAIR>::RET,
                         sparse1D< mtl::dense1D< entry1<T> > >,
                     typename IF< EQUAL< Storage_oned_id,TREE>::RET,
                         sparse1D< std::set< entry1<T> > >,
                     typename IF< EQUAL< Storage_oned_id,LINKED_LIST>::RET,
                         sparse1D< std::list< entry1<T> > >,
                         generators_error
                       >::RET
                       >::RET
                       >::RET
                       >::RET
                       >::RET RET;
  };

  //: blah
  //!noindex:
  template <class T, class Storage, class Order, int M, int N>
  struct generate_internal {
    enum { Storage_id = Storage::id, Storage_index = Storage::index };
    typedef typename IF< EQUAL< Storage_id, DENSE>::RET,
                         gen_dense2D<T, gen_rect_offset<M,N>,M,N>,
                     typename IF< EQUAL< Storage_id, COMPRESSED >::RET,
                         gen_compressed2D<T, typename Storage::size_type,
                                          Storage_index,M,N>,
                     typename IF< EQUAL< Storage_id, ENVELOPE >::RET,
                         gen_envelope2D<T,M,N>,
                     typename IF< EQUAL< Storage_id, PACKED >::RET,
                         gen_dense2D<T, gen_packed_offset<M,N>,M,N>,
                     typename IF< EQUAL< Storage_id, BAND >::RET,
                         gen_dense2D<T, gen_banded_offset<M,N>,M,N>,
                     typename IF< EQUAL< Storage_id, BAND_VIEW >::RET,
                         gen_dense2D<T, gen_banded_view_offset<M,N>,M,N>,
                     typename IF< EQUAL< Storage_id, ARRAY >::RET,
                         gen_array2D< typename generate_oned<T,Storage,Order>::RET >,
                         generators_error
                     >::RET
                     >::RET
                     >::RET
                     >::RET
                     >::RET
                     >::RET
                     >::RET RET;
  };

  //: blah
  //!noindex:
  template <class T, class Storage, class Order, int M, int N>
  struct generate_external {
    enum { Storage_id = Storage::id, Storage_index = Storage::index };
    typedef typename IF< EQUAL< Storage_id, DENSE>::RET,
                         gen_external2D<T, gen_rect_offset<M,N>, M,N>,
                     typename IF< EQUAL< Storage_id, COMPRESSED >::RET,
                         gen_ext_comp2D<T, typename Storage::size_type,
                                        Storage_index,M,N>,
                     typename IF< EQUAL< Storage_id, ENVELOPE >::RET,
                         gen_envelope2D<T,M,N>,
                     typename IF< EQUAL< Storage_id, PACKED >::RET,
                         gen_external2D<T, gen_packed_offset<M,N>,M,N>,
                     typename IF< EQUAL< Storage_id, BAND >::RET,
                         gen_external2D<T, gen_banded_offset<M,N>,M,N>,
                     typename IF< EQUAL< Storage_id, BAND_VIEW >::RET,
                         gen_external2D<T, gen_banded_view_offset<M,N>,M,N>,
                     typename IF< EQUAL< Storage_id, ARRAY >::RET,
                         gen_array2D< typename generate_oned<T,Storage,Order>::RET >,
                         generators_error
                     >::RET
                     >::RET
                     >::RET
                     >::RET
                     >::RET
                     >::RET
                     >::RET RET;
  };

  //: blah
  //!noindex:
  template <class T, class Storage, class Order, int M, int N>
  struct generate_storage {
    enum { Storage_ext = Storage::ext };
    typedef typename IF< Storage_ext, 
                         typename generate_external<T,Storage,Order,M,N>::RET,
                         typename generate_internal<T, Storage,Order,M,N>::RET 
                       >::RET RET;
  };


  template <class T, class Orien, class Alloc, bool Strided>
  class dense_matrix;

  template <class T, class Orien, int M, int N, bool Strided>
  class external_dense_matrix;

  template <class T, int M, int N, class Orien>
  class static_dense_matrix;
  

  //: blah
  //!noindex:
  template <class T, class Orientation, class Storage, int M, int N>
  struct generate_rect {
    enum { Orientation_id = Orientation::id };
#if 0
    typedef typename generate_storage<T,Storage,M,N>::RET storage_t;
    typedef typename storage_t::type::size_type size_type;
    typedef typename IF< EQUAL<Orientation_id, ROW_MAJOR>::RET,
                           row_matrix< storage_t,
                              gen_rect_indexer<row_orien,M,N, size_type> >,
                     typename IF< EQUAL<Orientation_id, COL_MAJOR>::RET,
                           column_matrix< storage_t,
                               gen_rect_indexer<column_orien,M,N,size_type> >,
                        generators_error
                       >::RET
                       >::RET RET;
#else
    enum {  Storage_id = Storage::id,
            Storage_issparse = Storage::issparse,
            Storage_ext = Storage::ext };
  
    //    typedef typename storage_t::type::size_type size_type;
    typedef int size_type; // JGS!!
    typedef
     typename IF< EQUAL<Storage_id, DENSE>::RET,
        typename IF< Storage_ext, 
           external_dense_matrix<T, Orientation, M, N>,
           dense_matrix<T, Orientation> >::RET, 
       typename IF< EQUAL<Storage_id, ARRAY>::RET,
          typename IF< EQUAL<Orientation_id, ROW_MAJOR>::RET,
                      row_matrix< typename generate_storage<T,Storage,Orientation,M,N>::RET,
                         gen_rect_indexer<row_orien,M,N, size_type> >,
                     typename IF< EQUAL<Orientation_id, COL_MAJOR>::RET,
                           column_matrix< typename generate_storage<T,Storage,Orientation,M,N>::RET,
                               gen_rect_indexer<column_orien,M,N,size_type> >,
                        generators_error
                       >::RET
                       >::RET,
    typename IF< Storage_issparse,
       typename IF< EQUAL<Orientation_id, ROW_MAJOR>::RET,
                           row_matrix< typename generate_storage<T,Storage,Orientation,M,N>::RET,
                              gen_rect_indexer<row_orien,M,N, size_type> >,
                     typename IF< EQUAL<Orientation_id, COL_MAJOR>::RET,
                           column_matrix< typename generate_storage<T,Storage,Orientation,M,N>::RET,
                               gen_rect_indexer<column_orien,M,N,size_type> >,
                        generators_error
                       >::RET
                       >::RET,
        generators_error
      >::RET >::RET >::RET RET;
#endif
  };

  //: blah
  //!noindex:
  template <class T, class Orientation, class Storage, int M, int N>
  struct generate_banded {
    enum { Orientation_id = Orientation::id };
    enum {  Storage_id = Storage::id,
            Storage_issparse = Storage::issparse,
            Storage_ext = Storage::ext };
    typedef typename generate_storage<T,Storage,Orientation,M,N>::RET storage_t;
    typedef typename storage_t::type::size_type size_type;

    typedef typename IF< EQUAL<Storage_id, BAND>::RET,
          typename IF<Storage_ext,
              external_banded_matrix<T, Orientation>,
              banded_matrix<T, Orientation> >::RET,
       typename IF< EQUAL<Orientation_id, ROW_MAJOR>::RET,
                        row_matrix< storage_t,
                             gen_banded_indexer<row_orien,M,N,size_type> >,
                   typename IF< EQUAL<Orientation_id, COL_MAJOR>::RET,
                          column_matrix< storage_t,
                           gen_banded_indexer<column_orien,N,M,size_type> >,
                           generators_error
                       >::RET
       >::RET >::RET RET;
  };

  //: blah
  //!noindex:
  template <class T, class Storage, int M, int N>
  struct generate_diagonal {
    typedef typename generate_storage<T,Storage,mtl::row_major,M,N>::RET storage_type;
    typedef typename storage_type::type::size_type size_type;
    typedef gen_diagonal_indexer<row_orien, M, N, size_type> indexer_gen;
    typedef diagonal_matrix_old<storage_type, indexer_gen> RET;
  };

  //: blah
  //!noindex:
  template <uplo_e Uplo>
  struct generate_uplo {
    typedef typename IF< EQUAL< Uplo, upper >::RET, upper__,
          typename IF< EQUAL< Uplo, unit_upper >::RET, unit_upper__,
          typename IF< EQUAL< Uplo, lower>::RET, lower__, 
          typename IF< EQUAL< Uplo, unit_lower>::RET, unit_lower__,
          dynamic_uplo__
      >::RET
      >::RET
      >::RET
      >::RET RET;
  };

  //: blah
  //!noindex:
  template <class T, class Shape, class Orien, class Storage, int M, int N>
  struct generate_triangle {
    enum { Orien_id = Orien::id, 
           Shape_uplo = Shape::uplo, 
	   //           Shape_diag = Shape::diag, 
           Storage_id = Storage::id,
           Storage_issparse = Storage::issparse,
           Storage_isext = Storage::ext };
    enum { UnitDiag = convert_diag<(uplo_e)Shape_uplo>::RET, 
           newUplo = convert_uplo<(uplo_e)Shape_uplo>::RET };
    typedef typename generate_storage<T,Storage,Orien,M,N>::RET storage_type;
    typedef typename storage_type::type::size_type size_type;
    typedef typename
     IF< Storage_issparse, 
       typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
         triangle_matrix_old<row_matrix< storage_type,
            gen_banded_indexer<row_orien,M,N,size_type> >, 
            typename generate_uplo<(uplo_e)Shape_uplo>::RET >,
         triangle_matrix_old<column_matrix< storage_type,
            gen_banded_indexer<column_orien,M,N,size_type> >,
            typename generate_uplo<(uplo_e)Shape_uplo>::RET >
                     >::RET
     ,
#if 0
       typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
         triangle_matrix<row_matrix< storage_type,
            gen_banded_indexer<row_orien,M,N,size_type> >,
            typename generate_uplo<(uplo_e)Shape_uplo>::RET >,
         triangle_matrix<column_matrix< storage_type,
            gen_banded_indexer<column_orien,M,N,size_type> >, 
            typename generate_uplo<(uplo_e)Shape_uplo>::RET >
                     >::RET
       typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
         triangle_matrix<row_matrix< storage_type,
            gen_banded_indexer<row_orien,M,N,size_type> >,
            typename generate_uplo<(uplo_e)Shape_uplo>::RET >,
         triangle_matrix<column_matrix< storage_type,
            gen_banded_indexer<column_orien,M,N,size_type> >, 
            typename generate_uplo<(uplo_e)Shape_uplo>::RET >
                     >::RET
#else
    // packed
    typename IF< EQUAL< Storage_id, PACKED>::RET,
      typename IF< Storage_isext,
        external_triangle_packed_matrix<T, Orien,
          (uplo_e)newUplo, (diag_e)UnitDiag>,
        triangle_packed_matrix<T, Orien, 
          (uplo_e)newUplo, (diag_e)UnitDiag> >::RET,
    // banded
    typename IF< EQUAL< Storage_id, BAND>::RET,
      typename IF< Storage_isext,
        external_triangle_banded_matrix<T, Orien,
          (uplo_e)newUplo, (diag_e)UnitDiag>,
        triangle_banded_matrix<T, Orien, 
          (uplo_e)newUplo, (diag_e)UnitDiag> >::RET,
    // regular
    typename IF< EQUAL< Storage_id, BAND_VIEW>::RET,
      typename IF< Storage_isext,
        external_triangle_matrix<T, Orien,
          (uplo_e)newUplo, (diag_e)UnitDiag>,
        triangle_matrix<T, Orien, 
          (uplo_e)newUplo, (diag_e)UnitDiag> >::RET,
    // old school
       typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
         triangle_matrix_old<row_matrix< storage_type,
            gen_banded_indexer<row_orien,M,N,size_type> >, 
            typename generate_uplo<(uplo_e)Shape_uplo>::RET >,
         triangle_matrix_old<column_matrix< storage_type,
            gen_banded_indexer<column_orien,M,N,size_type> >,
            typename generate_uplo<(uplo_e)Shape_uplo>::RET >
                     >::RET

    >::RET
    >::RET
    >::RET
#endif
     >::RET RET;
  };


  /* if storage is sparse, use rect indexer, otherwise use
   banded indexer */

  //: blah
  //!noindex:
  template <class T, class Shape, class Orien, class Storage,
           int M, int N, int IsHerm>
  struct generate_symmetric {
    enum { Shape_uplo = Shape::uplo, Orien_id = Orien::id, 
           Storage_isext = Storage::ext,
           Storage_id = Storage::id,
           Storage_issparse = Storage::issparse };
    enum { newUplo = convert_uplo<(uplo_e)Shape_uplo>::RET };
    typedef typename generate_storage<T,Storage,Orien,M,N>::RET storage_type;
    typedef typename storage_type::type::size_type size_type;
    typedef typename
     IF< Storage_issparse, 
       typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
       symmetric_matrix_old<row_matrix< storage_type,
           gen_rect_indexer<row_orien,M,N,size_type> >, 
           typename generate_uplo<(uplo_e)Shape_uplo>::RET, IsHerm >,
       symmetric_matrix_old<column_matrix< storage_type,
           gen_rect_indexer<column_orien,N,M,size_type> >, 
           typename generate_uplo<(uplo_e)Shape_uplo>::RET, IsHerm >
                     >::RET
     ,
#if 0
       typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
       symmetric_matrix<row_matrix< storage_type,
           gen_banded_indexer<row_orien,M,N,size_type> >, 
           typename generate_uplo<(uplo_e)Shape_uplo>::RET, IsHerm >,
       symmetric_matrix<column_matrix< storage_type,
           gen_banded_indexer<column_orien,N,M,size_type> >, 
           typename generate_uplo<(uplo_e)Shape_uplo>::RET, IsHerm >
                     >::RET 
#else
    // packed
    typename IF< EQUAL< Storage_id, PACKED>::RET,
      typename IF< Storage_isext,
        external_symmetric_packed_matrix<T, Orien,
          (uplo_e)newUplo, IsHerm>,
        symmetric_packed_matrix<T, Orien, 
          (uplo_e)newUplo, IsHerm> >::RET,
    // banded
    typename IF< EQUAL< Storage_id, BAND>::RET,
      typename IF< Storage_isext,
        external_symmetric_banded_matrix<T, Orien,
          (uplo_e)newUplo, IsHerm>,
        symmetric_banded_matrix<T, Orien, 
          (uplo_e)newUplo, IsHerm> >::RET,
    // regular
    typename IF< EQUAL< Storage_id, BAND_VIEW>::RET,
      typename IF< Storage_isext,
        external_symmetric_matrix<T, Orien,
          (uplo_e)newUplo, IsHerm>,
        symmetric_matrix<T, Orien, 
          (uplo_e)newUplo, IsHerm> >::RET,
    // old school
       typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
       symmetric_matrix_old<row_matrix< storage_type,
           gen_rect_indexer<row_orien,M,N,size_type> >, 
           typename generate_uplo<(uplo_e)Shape_uplo>::RET, IsHerm >,
       symmetric_matrix_old<column_matrix< storage_type,
           gen_rect_indexer<column_orien,N,M,size_type> >, 
           typename generate_uplo<(uplo_e)Shape_uplo>::RET, IsHerm >
                     >::RET

    >::RET
    >::RET
    >::RET
#endif
     >::RET RET;
  };

  //: Matrix type generators class.
  //  
  // Matrices that occur in real engineering and scientific applications
  // often have special structure, especially in terms of how many zeros
  // are in the matrix, and where the non-zeros are located in the matrix.
  // This means that space and time saving can be acheived by using various
  // types of compressed storage. There are a multitude of matrix storage
  // formats in use today, and the MTL tries to support many of the more
  // common storage formats. The following discussion will describe how the
  // user of MTL can select the type of matrix he or she wishes to use.
  //
  // To create a MTL matrix, one first needs to construct the
  // appropriate matrix type. This is done using the <tt>matrix</tt>
  // type generation class, which is easier to think of as a function. It
  // takes as input the characteristics of the matrix type that you want
  // and then returns the appropriate MTL matrix. The <tt>matrix</tt> type
  // generators ``function'' has defaults defined, so in order to create a
  // normal rectangular matrix type, one merely does the following:
  //
  // <codeblock>
  // typedef matrix< double >::type MyMatrix;
  // MyMatrix A(M, N);
  // </codeblock>
  //
  // The matrix type generators can take up to four arguments, the
  // element type, the matrix shape, the storage
  // format, and the orientation. The following is the
  // ``prototype'' for the <tt>matrix</tt> type generators.
  //
  // <codeblock>
  // matrix< EltType, Shape, Storage, Orientation >::type 
  // </codeblock>
  //
  // This type of "generative" interface technique was developed by by
  // <a href="http://nero.prakinf.tu-ilmenau.de:80/~czarn/">Krzysztof
  // Czarnecki</a> and <a
  // href="http://home.t-online.de/home/Ulrich.Eisenecker/">Ulrich
  // Eisenecker</a> in their work on the <a href="http://nero.prakinf.tu-ilmenau.de:80/~czarn/gmcl/">Generative Matrix Computation Library</a>.
  //  <p>
  //  *Storage can be made external by specifying such in the storage
  //   parameter. eg. dense&lt;external&gt;, packed&lt;external&gt;.
  //
  //!tparam: EltType - Valid choices for this argument include <tt>double</tt>, <tt>complex<float></tt>, and <tt>bool</tt>.  In essence, any builtin or user defined type can be used for the <tt>EltType</tt>, however, if one uses the matrix with a particular algorithm, the <tt>EltType</tt> must support the operations required by the algorithm. For MTL algorithms these typically include the usual numerical operators such as addition and multiplication. The <tt>std::complex</tt> class is a good example of what is required in a numerical type. The documentation for each algorithm will include the requirements on the element type.
  //  
  //!tparam: Shape - This argument specifies the general positioning of the non zero elements in the matrix, but does not specify the actual storage format.  In addition it specifies certain properties such as symmetry.  The choices for this argument include <tt>rectangle</tt>, <tt>banded</tt>, <tt>diagonal</tt>, <tt>triangle</tt>, and <tt>symmetric</tt>. Hermitian is not yet implemented.
  //  
  //!tparam: Storage - The argument specifies the storage scheme used to lay out the matrix elements (and sometimes the element indices) in memory. The storage formats include <tt>dense</tt> , <tt>banded</tt>, <tt>packed</tt> , <tt>banded_view</tt>, <tt>compressed</tt>, <tt>envelope</tt>, and <tt>array</tt>.
  //
  //!tparam: Orientation - The storage order for an MTL matrix can either be <tt>row_major</tt> or <tt>column_major</tt>.
  //
  //!category: containers, generators
  //!component: type
  //!definition: matrix.h
  //
  template < class T, class Shape = rectangle<>, class Storage = dense<>, class Orientation = row_major >
  struct matrix {
    enum { Shape_id = Shape::id, Shape_M = Shape::M, Shape_N = Shape::N };
    //: The generated type
    typedef typename IF< EQUAL< Shape_id, RECT>::RET,
                        typename generate_rect<T,Orientation,Storage,
                                               Shape_M, Shape_N>::RET,
                    typename IF< EQUAL< Shape_id, DIAG>::RET,
                        typename generate_diagonal<T,Storage,
                                               Shape_M, Shape_N>::RET,
                    typename IF< EQUAL< Shape_id, BAND>::RET,
                        typename generate_banded<T,Orientation,Storage,
                                               Shape_M, Shape_N>::RET,
                    typename IF< EQUAL< Shape_id, TRI>::RET,
                        typename generate_triangle<T,Shape,
                                               Orientation,Storage,
                                               Shape_M, Shape_N>::RET,
                    typename IF< EQUAL< Shape_id, SYMM>::RET,
                        typename generate_symmetric<T,Shape,
                                              Orientation,Storage,
                                               Shape_M, Shape_N,0>::RET,
                    typename IF< EQUAL< Shape_id, HERM>::RET,
                        typename generate_symmetric<T,Shape,
                                              Orientation,Storage,
                                               Shape_M, Shape_N,1>::RET,

                        generators_error
                        >::RET
                        >::RET
                        >::RET
                        >::RET
                        >::RET
                        >::RET type;
  };



#ifndef MTL_DISABLE_BLOCKING

  //: Block View Matrix Type Constructor
  //
  // <codeblock>
  // block_view<Matrix> bA = blocked<>(A, 16, 16);
  // or
  // block_view<Matrix,BM,BN> bA = blocked<BM,BN>(A);
  // </codeblock>
  //
  // Note: currently not supported for egcs (internal compiler error).
  //
  //!category: containers, generators
  //!component: type
  //!example: blocked_matrix.cc
  //!definition: matrix.h
  //!tparam: Matrix - The type of the Matrix to be blocked, must be dense
  //!tparam: BM - The blocking factor for the rows (M dimension) - 0 for dynamic size
  //!tparam: BN - The blocking factor for the columns (N dimension) - 0 for dynamic size
  template <class Matrix, int BM = 0, int BN = 0>
  struct block_view {
    //: The generated type
    typedef typename Matrix:: MTL_TEMPLATE blocked_view<BM,BN>::type type;
  };

  template <int BM, int BN>
  struct blk { enum { M = BM, N = BN }; };

  //: Blocked Matrix Generator
  //
  // <codeblock>
  // block_view<Matrix> bA = blocked<>(A, 16, 16);
  // </codeblock>
  //
  // Note: currently not supported for egcs (internal compiler error).
  //
  //!category: containers
  //!component: function
  //!example: blocked_matrix.cc
  //!definition: matrix.h
  //!tparam: Matrix - The type of the Matrix to be blocked, must be dense
  template <class Matrix>
  typename block_view<Matrix, 0, 0>::type 
  blocked(const Matrix& A, int bm, int bn) {
    typedef dimension<typename Matrix::size_type, 0,0> bdt;
    return typename block_view<Matrix, 0, 0>::type(A, bdt(bm, bn));
  }

  //: Blocked Matrix Generator
  //
  // This version of the blocked matrix generator is for statically
  // sized blocks.
  //
  // <codeblock>
  // block_view<Matrix,BM,BN> bA = blocked<BM,BN>(A);
  // </codeblock>
  //
  // Note: currently not supported for egcs (internal compiler error).
  //
  //!category: containers
  //!component: function
  //!example: blocked_matrix.cc
  //!definition: matrix.h
  //!tparam: Matrix - The type of the Matrix to be blocked, must be dense
  //!tparam: BM - The blocking factor for the rows (M dimension)
  //!tparam: BN - The blocking factor for the columns (N dimension)
  template <class Matrix, int BM, int BN>
  typename block_view<Matrix, BM, BN>::type
  blocked(const Matrix& A, blk<BM,BN>) {
    typedef dimension<typename Matrix::size_type, BM, BN> bdt;
    return typename block_view<Matrix, BM, BN>::type(A, bdt(BM, BN));
  }
#endif

  //: Band View Matrix Type Constructor
  // A helper class for creating a banded_view into an existing dense matrix.
  //!category: containers, generators
  //!component: type
  //!example: banded_view_test.cc
  //!definition: matrix.h
  //!tparam: Matrix - The type of the Matrix to be viewed, must be dense
  template <class Matrix>
  struct band_view {
    //: The generated type
    typedef typename Matrix::banded_view_type type;
  };

  //: Triangle View Matrix Type Constructor
  // A helper class for creating a triangle view into an existing dense
  //   or sparse matrix. For sparse matrices, the matrix must already
  //   have elements in the appropriate triangular portion of the matrix.
  //   This just provides the proper triangular matrix interface.
  //!category: containers, generators
  //!component: type
  //!example: banded_view_test.cc
  //!definition: matrix.h
  //!tparam: Matrix - The type of the Matrix to be viewed, must be dense
  //!tparam: Uplo - Whether to view the upper or lower triangle of the matrix
  template <class Matrix, uplo_e Uplo>
  struct triangle_view {
    typedef typename Matrix::sparsity Sparsity;
    enum { Sparsity_id = Sparsity::id };
    //: The generated type
    typedef typename IF< EQUAL< Sparsity_id, DENSE>::RET,
      triangle_matrix_old< typename Matrix::banded_view_type, 
                       typename generate_uplo<Uplo>::RET>,
                triangle_matrix_old< Matrix, typename generate_uplo<Uplo>::RET>
              >::RET type;
  };

  //: Triangle View Creation Helper Fuctor
  // Example: tri_view<upper>()(A)
  //!category: containers, generators
  //!component: type
  //!example: banded_view_test.cc
  //!definition: matrix.h
  //!tparam: Uplo - Whether to view the upper or lower triangle of the matrix
  template <uplo_e Uplo>
  struct tri_view {
    template <class Matrix>
    inline typename triangle_view<Matrix, Uplo>::type operator()(Matrix x) {
      typedef typename triangle_view<Matrix, Uplo>::type TriView;
      return TriView(x);
    }
  };
  

  //: Symmetric View Matrix Type Constructor
  // A helper class for creating a symmetric view into an existing dense
  //   or sparse matrix. For sparse matrices, the matrix must already
  //   have elements in the appropriate lower/upper portion of the matrix.
  //   This just provides the proper symmetric matrix interface.
  //!category: containers, generators
  //!component: type
  //!definition: matrix.h
  //!tparam: Matrix - The type of the Matrix to be viewed, must be dense
  //!tparam: Uplo - Whether to view the upper or lower triangle of the matrix
  template <class Matrix, uplo_e Uplo>
  struct symmetric_view {
    typedef typename Matrix::sparsity Sparsity;
          enum { Sparsity_id = Sparsity::id };
    //: The generated type
    typedef typename IF< EQUAL< Sparsity_id, DENSE>::RET,
      symmetric_matrix_old< typename Matrix::banded_view_type, 
                        typename generate_uplo<Uplo>::RET, 0>,
           symmetric_matrix_old< Matrix, typename generate_uplo<Uplo>::RET,0>
              >::RET type;
  };


} /* namespace mtl */

#endif /* _MTL_MATRIX_H_ */