AbstractLinAlgPack_COOMatrixPartitionedViewClassDecl.hpp

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef COO_MATRIX_PARTITIONED_VIEW_CLASS_DECL_H
#define COO_MATRIX_PARTITIONED_VIEW_CLASS_DECL_H

#include "AbstractLinAlgPack_SparseCOOPtrElement.hpp"
#include "AbstractLinAlgPack_TransSparseCOOElementViewIter.hpp"
#include "MiRefCount.h"

namespace AbstractLinAlgPack {

namespace COOMatrixPartitionedViewUtilityPack {
template <class T_Indice, class T_Value> class Partition;
template <class T_Indice, class T_Value> class TransposedPartition;
}

// ///////////////////////////////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////////////////
template <class T_Indice, class T_Value>
class COOMatrixPartitionedView {
public:
  
  // //////////////////////////////////////////////////////////////////////////

  typedef COOMatrixPartitionedViewUtilityPack::Partition<T_Indice,T_Value>
                              partition_type;
  typedef COOMatrixPartitionedViewUtilityPack::TransposedPartition<T_Indice,T_Value>
                              transposed_partition_type;
  typedef T_Indice                    indice_type;
  typedef AbstractLinAlgPack::size_type           size_type;
  typedef ptrdiff_t                   difference_type;
  enum EPartitionOrder { PARTITION_BY_ROW, PARTITION_BY_COL };
  class UninitializedException: public std::logic_error
  {public: UninitializedException(const std::string& what_arg) : std::logic_error(what_arg) {}};


  // ///////////////////////////////////////////////////////////////////////////////////////


  COOMatrixPartitionedView();

  COOMatrixPartitionedView(
        size_type       rows
      , size_type       cols
      , size_type       nz    
      , value_type      val[]
      , const indice_type   ivect[]
      , const indice_type   jvect[]
      , const size_type   inv_row_perm[]
      , const size_type   inv_col_perm[]
      , const size_type   num_row_part
      , const size_type   row_part[]
      , const size_type   num_col_part
      , const size_type   col_part[]
      , const EPartitionOrder partition_order )

    : num_row_part_(0), num_col_part_(0)
  {
    create_view(rows, cols, nz, val, ivect, jvect, inv_row_perm, inv_col_perm, num_row_part
      , row_part, num_col_part, col_part, partition_order);
  }
    // I tried defining this function else where as both an inlined and
    // noninlined function but MS VC++ 5.0 generated
    // a linking error saying that it could not find this function.
    // ToDo: Investagate this problem further at a latter time.

  void create_view(
        size_type       rows
      , size_type       cols
      , size_type       nz    
      , value_type      val[]
      , const indice_type   ivect[]
      , const indice_type   jvect[]
      , const size_type   inv_row_perm[]
      , const size_type   inv_col_perm[]
      , const size_type   num_row_part
      , const size_type   row_part[]
      , const size_type   num_col_part
      , const size_type   col_part[]
      , const EPartitionOrder partition_order );

  void bind(const COOMatrixPartitionedView& coom_view);

  void free();

  bool is_initialized() const;



  size_type rows() const;

  size_type cols() const;

  size_type nz() const;

  size_type num_row_part() const;
  
  size_type num_col_part() const;

  void get_row_part(indice_type row_part[]) const;

  void get_col_part(indice_type col_part[]) const;

  EPartitionOrder partition_order() const;

  size_type overall_part_num(size_type row_p, size_type col_p) const;

  size_type row_part_num(size_type overall_p) const;

  size_type col_part_num(size_type overall_p) const;



//  ///
//  /** Allow an implicit conversion from a COOMatrixPartitionedView
//    * to a partition_type object.
//    *
//    * This conversion is equivalent to calling #partition(Range1D())#.
//    */
//  operator partition_type();
//
//  ///
//  operator const partition_type() const;

  partition_type operator()();

  const partition_type operator()() const;

  partition_type partition(size_type overall_p);

  const partition_type partition(size_type overall_p) const;

  partition_type partition(size_type row_p, size_type col_p);

  const partition_type partition(size_type row_p, size_type col_p) const;

  partition_type partition(Range1D rng_overall_p);

  const partition_type partition(Range1D rng_overall_p) const;



private:
  // ////////////////////////////////////////////////////////////////
  // Private types

  typedef SparseCOOPtrElement<T_Indice,T_Value> element_type;
  typedef std::vector<indice_type>        vector_indice_type;
  typedef std::vector<size_type>          vector_size_type;
  typedef std::vector<element_type>       ele_type;
  typedef MemMngPack::RefCount<
        vector_indice_type>         ref_vector_indice_type;
  typedef MemMngPack::RefCount<
        vector_size_type>         ref_vector_size_type;
  typedef MemMngPack::RefCount<
        ele_type>             ref_ele_type;

  // ///////////////////////////////////////////////////////////////
  // Private data members

  size_type         num_row_part_;
  // The number of partions the COO matrix is sliced up into by rows.

  size_type         num_col_part_;
  // The number of partions the COO matrix is sliced up into by columns.

  ref_vector_size_type    ref_row_part_;
  //
  // row_part = { row_p_1_i, row_p_2_i,...,row_p_nrp_i, row_p_nrp_last_i + 1 }
  //    where:  row_p_k_i is the row indice for row partition k
  //        nrp = num_row_part
  //        row_p_nrp_last_i is the last row indice in the last row partition
  //
  // vector (length num_row_part_ + 1) of row indices for the start of the row partitions.
  // row_part[i - 1] is the row indice for the start of the ith row partition (i = 1,...,num_row_part_).
  // The last indice gives the row indice that is one past the last row of the last
  // row partition.  It is included for the efficient calculation of the number of rows
  // in a partition or a set of partitions.

  ref_vector_size_type    ref_col_part_;
  //
  // col_part = { col_p_1_i, col_p_2_i,...,col_p_nrp_i, col_p_nrp_last_i + 1 }
  //    where:  col_p_k_i is the col indice for col partition k
  //        nrp = num_col_part
  //        col_p_nrp_last_i is the last col indice in the last col partition
  //
  // vector (length num_row_part_ + 1) of column indices for the start of the columns partitions.
  // col_part[j - 1] is the column indice for the start of the jth column partition (j = 1,...,num_col_part_).
  // The last indice gives the column indice that is one past the last column of the last
  // column partition.  It is included for the efficient calculation of the number of columns
  // in a partition or a set of partitions.
  
  EPartitionOrder       partition_order_;
  // Specifies wheather the partitions are to be orded by columns or rows

  ref_ele_type        ref_ele_;
  // ToDo: replace with a RefCount<std::vector<element_type>> when you get compiler bug fix.
  // The storage array (dynamically allocated) for the elements in the COO matrix.
  // The elements in this array are ordered into partitions defined by the partition_order_.
  //
  //        ele_
  //    ---------------------
  //    |pval row_i col_i| 
  //    ||  | |   | |   ||-
  //    ||  | |   | |   ||  parition  1
  //    ||  | |   | |   ||
  //    ||  | |   | |   ||-
  //    ||  | |   | |   ||  parition  2
  //    ||  | |   | |   ||
  //    ||  | |   | |   ||-
  //    ||  | |   | |   ||  .
  //    ||  | |   | |   ||  .
  //    ||  | |   | |   ||  .
  //    ||  | |   | |   ||
  //    ||  | |   | |   ||-
  //    ||  | |   | |   ||  partition num_row_part * num_col_part
  //    ||  | |   | |   ||
  //    ||  | |   | |   ||-
  //    ---------------------

  ref_vector_size_type    ref_part_start_;
  //
  // part_start = { start_1 = 0, start_2,..., start_n, total_nz }
  //
  // vector (length num_row_part * num_col_part_ + 1) of the start for the elements in
  // each partition.  ele_[part_start_[overall_p - 1]] gives the first element of partion
  // overal_p and ele_[part_start_[overall_p] - 1] gives the last element in the partition.
  // This array is also used to calculate the number of nonzero elements in each parition
  // and in the overall partition.  The last element part_start_[num_row_part * num_col_part_]
  // gives the total number of nonzeros in all of the partitions and is also used
  // to allow the calculation of the number of nonzero elements in the last partition.

  // When the view is uninitialized then ele_, row_part_, col_part_ and part_start_ will
  // all uninitialized.

  // ///////////////////////////////////////////////////////////////
  // Private member functions

  // assert that the object is initialized
  void assert_initialized() const;

  size_type imp_overall_part_num(size_type row_p, size_type col_p) const;

  size_type imp_row_part_num(size_type overall_p) const;

  size_type imp_col_part_num(size_type overall_p) const;

  // Return the partition number given an indice.
  // Passing the partition vector is an optimization
  // that allows us to only call .obj() once
  // on the reference object and thus same some
  // unnecessary work.
  size_type part_num(const vector_size_type& part, size_type indice);

  // Return the overall partition number
  size_type overall_p_from_ij(const vector_size_type& row_part
    , const vector_size_type& col_part, size_type i, size_type j);

  // Return a non-const partition.  This is the function
  // that implements all partition creations.
  partition_type create_partition(Range1D rng_overall_p) const;

  // Not defined and not to be called
  COOMatrixPartitionedView& operator=(const COOMatrixPartitionedView&);

};  // end class COOMatrixPartitionedView


namespace COOMatrixPartitionedViewUtilityPack {


// ///////////////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////
template <class T_Indice, class T_Value>
class Partition {
public:
  // /////////////////////////////////////////////////////
  
  typedef AbstractLinAlgPack::size_type       size_type;
  typedef Partition<T_Indice,T_Value>       partition_type;
  typedef ptrdiff_t               difference_type;
  typedef SparseCOOPtrElement<T_Indice,T_Value> element_type;
  typedef element_type*             iterator;
  typedef const element_type*           const_iterator;


  // /////////////////////////////////////////////////////

  
  Partition();

  Partition(
        size_type     rows
      , size_type     cols
      , size_type     nz
      , element_type*   ele
      , difference_type row_offset
      , difference_type col_offset );

  void initialize(
        size_type     rows
      , size_type     cols
      , size_type     nz
      , element_type*   ele
      , difference_type row_offset
      , difference_type col_offset );

  void bind(const partition_type& partition);



  size_type rows() const;
  size_type cols() const ;
  size_type nz() const;
  difference_type row_offset() const;
  difference_type col_offset() const;
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;



private:
  // //////////////////////////////////////////////////////
  // Private types

  // //////////////////////////////////////////////////////
  // Private data members

  size_type   rows_,  // The number of rows in this COO matrix
          cols_,  // The number of columns in this COO matrix
          nz_;  // The number of nonzero elements in this COO matrix
  element_type  *ele_;  // pointer to array of elements in this COO matrix
  difference_type row_offset_,  // offset for each row indice stored in ele
          col_offset_;  // offset for each column indice stored in ele

  // //////////////////////////////////////////////////////
  // Private member functions

  // assert that we are initialized
  void assert_initialized() const;

  // not defined and not to be called
  Partition& operator=(const Partition&);

};  // end class Partition

// /////////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////////
template <class T_Indice, class T_Value>
class TransposedPartition {
public:
  // /////////////////////////////////////////////////////
  
  typedef Partition<T_Indice,T_Value>       partition_type;
  typedef AbstractLinAlgPack::size_type       size_type;
  typedef ptrdiff_t               difference_type;
  typedef SparseCOOPtrElement<T_Indice,T_Value> element_type;
  typedef TransSparseCOOElementViewIter<
          element_type*
        , std::random_access_iterator_tag
        , typename element_type::indice_type
        , typename element_type::value_type&
        , difference_type>          iterator;
  typedef TransSparseCOOElementViewIter<
          const element_type*
        , std::random_access_iterator_tag
        , typename element_type::indice_type
        , const typename element_type::value_type&
        , difference_type>          const_iterator;


  // /////////////////////////////////////////////////////


  TransposedPartition(const partition_type& partition);

  void bind(const partition_type& partition);



  size_type rows() const;
  size_type cols() const;
  size_type nz() const;
  difference_type row_offset() const;
  difference_type col_offset() const;
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;



private:
  partition_type      partition_; // actually stores a partition object.

  // Not defined and not to be called
  TransposedPartition&  operator=(const TransposedPartition&);

};  // end class TransposedPartition

//  end COOMatrixPartitionedViewUtilityPack

} // end namespace COOMatrixPartitionedViewUtilityPack


// //////////////////////////////////////////////////////////////////////////
// Nonmember functions

template<class T_Indice, class T_Value>
inline COOMatrixPartitionedViewUtilityPack::TransposedPartition<T_Indice,T_Value>
trans(COOMatrixPartitionedViewUtilityPack::Partition<T_Indice,T_Value>& part)
{
  typedef COOMatrixPartitionedViewUtilityPack::TransposedPartition<T_Indice,T_Value>
        transposed_partition_type;
  return transposed_partition_type(part);
}

// ///////////////////////////////////////////////////////////////////////////
// Inline member function definitions

namespace COOMatrixPartitionedViewUtilityPack {

// ///////////////////////////////////////////////////////////////////////////
// Inline members for class COOMatrixPartitionedViewUtilityPack::Partition<>

// Constructors and initializes

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::Partition()
  : rows_(0), cols_(0), nz_(0), ele_(0), row_offset_(0), col_offset_(0)
{}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::Partition(
      size_type     rows
    , size_type     cols
    , size_type     nz
    , element_type*   ele
    , difference_type row_offset
    , difference_type col_offset )
  : rows_(rows), cols_(cols), nz_(nz), ele_(ele), row_offset_(row_offset)
    , col_offset_(col_offset)
{}

template <class T_Indice, class T_Value>
inline void Partition<T_Indice,T_Value>::initialize(
      size_type     rows
    , size_type     cols
    , size_type     nz
    , element_type*   ele
    , difference_type row_offset
    , difference_type col_offset )
{
  rows_   = rows;
  cols_   = cols;
  nz_     = nz;
  ele_    = ele;
  row_offset_ = row_offset;
  col_offset_ = col_offset;
}

template <class T_Indice, class T_Value>
inline void Partition<T_Indice,T_Value>::bind(const partition_type& partition) {
  initialize(partition.rows_,partition.cols_,partition.nz_,partition.ele_
    ,partition.row_offset_,partition.col_offset_);
}

// COOMatrixTemplateInterface interface 

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::size_type
Partition<T_Indice,T_Value>::rows() const
{
  return rows_;
}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::size_type
Partition<T_Indice,T_Value>::cols() const
{
  return cols_;
}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::size_type
Partition<T_Indice,T_Value>::nz() const
{
  return nz_;
}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::difference_type
Partition<T_Indice,T_Value>::row_offset() const
{
  return row_offset_;
}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::difference_type
Partition<T_Indice,T_Value>::col_offset() const
{
  return col_offset_;
}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::iterator
Partition<T_Indice,T_Value>::begin()
{
  assert_initialized();
  return ele_;
}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::const_iterator
Partition<T_Indice,T_Value>::begin() const
{
  assert_initialized();
  return ele_;
}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::iterator
Partition<T_Indice,T_Value>::end()
{
  assert_initialized();
  return ele_ + nz_;
}

template <class T_Indice, class T_Value>
inline Partition<T_Indice,T_Value>::const_iterator
Partition<T_Indice,T_Value>::end() const
{
  assert_initialized();
  return ele_ + nz_;
}

// Private member functions

template <class T_Indice, class T_Value>
inline void Partition<T_Indice,T_Value>::assert_initialized() const {
  if(!ele_)
    throw std::logic_error("Partition<...> :"
        "The COO matrix was not initizlized");
}


// ///////////////////////////////////////////////////////////////////////////
// Inline members for class COOMatrixPartitionedViewUtilityPack::TransposedPartition<>

// Constructors and initializes

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::TransposedPartition(const partition_type& partition)
  : partition_(partition)
{}

template <class T_Indice, class T_Value>
inline void TransposedPartition<T_Indice,T_Value>::bind(const partition_type& partition) {
  partition_.bind(partition);
}

// COOMatrixTemplateInterface interface

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::size_type
TransposedPartition<T_Indice,T_Value>::rows() const
{
  return partition_.cols();
}

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::size_type
TransposedPartition<T_Indice,T_Value>::cols() const
{
  return partition_.rows();
}

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::size_type
TransposedPartition<T_Indice,T_Value>::nz() const
{
  return partition_.nz();
}

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::difference_type
TransposedPartition<T_Indice,T_Value>::row_offset() const
{
  return partition_.col_offset();
}

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::difference_type
TransposedPartition<T_Indice,T_Value>::col_offset() const
{
  return partition_.row_offset();
}

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::iterator
TransposedPartition<T_Indice,T_Value>::begin()
{
  return iterator(partition_.begin());
}

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::const_iterator
TransposedPartition<T_Indice,T_Value>::begin() const
{
  return const_iterator(partition_.begin());
}

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::iterator
TransposedPartition<T_Indice,T_Value>::end()
{
  return iterator(partition_.end());
}

template <class T_Indice, class T_Value>
inline TransposedPartition<T_Indice,T_Value>::const_iterator
TransposedPartition<T_Indice,T_Value>::end() const
{
  return const_iterator(partition_.end());
}

} // end namespace COOMatrixPartitionViewUtilityPack


// ///////////////////////////////////////////////////////////////////////////
// Inline members for class COOMatrixPartitionedView<>

// Constructors and initializes

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::COOMatrixPartitionedView()
  : num_row_part_(0), num_col_part_(0)
{}

template <class T_Indice, class T_Value>
inline bool COOMatrixPartitionedView<T_Indice,T_Value>::is_initialized() const {
  return ref_ele_.has_ref_set();
}

// Partitioning information

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::rows() const
{
  assert_initialized();
  const std::vector<size_type> &row_part = ref_row_part_.const_obj();
  return row_part[num_row_part_] - row_part[0];
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::cols() const
{
  assert_initialized();
  const std::vector<size_type> &col_part = ref_col_part_.const_obj();
  return col_part[num_col_part_] - col_part[0];
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::nz() const
{
  assert_initialized();
  return ref_part_start_.const_obj()[num_row_part_ * num_col_part_];
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::num_row_part() const
{
  return num_row_part_;
}
  
template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::num_col_part() const
{
  return num_col_part_;
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::EPartitionOrder
COOMatrixPartitionedView<T_Indice,T_Value>::partition_order() const
{
  assert_initialized();
  return partition_order_;
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::overall_part_num(size_type row_p, size_type col_p) const
{
  assert_initialized();
  return imp_overall_part_num(row_p, col_p);
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::row_part_num(size_type overall_p) const
{
  assert_initialized();
  return imp_row_part_num(overall_p); 
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::col_part_num(size_type overall_p) const
{
  assert_initialized();
  return imp_col_part_num(overall_p); 
}

// Partition access

//template <class T_Indice, class T_Value>
//inline COOMatrixPartitionedView<T_Indice,T_Value>::operator
//COOMatrixPartitionedView<T_Indice,T_Value>::partition_type()
//{
//  return partition(Range1D());
//}

//template <class T_Indice, class T_Value>
//inline COOMatrixPartitionedView<T_Indice,T_Value>::operator
//const COOMatrixPartitionedView<T_Indice,T_Value>::partition_type() const
//{
//  return partition(Range1D());
//}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::partition_type
COOMatrixPartitionedView<T_Indice,T_Value>::operator()()
{
  return partition(Range1D());
}

template <class T_Indice, class T_Value>
inline const COOMatrixPartitionedView<T_Indice,T_Value>::partition_type
COOMatrixPartitionedView<T_Indice,T_Value>::operator()() const
{
  return partition(Range1D());
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::partition_type
COOMatrixPartitionedView<T_Indice,T_Value>::partition(size_type overall_p)
{
  return partition(Range1D(overall_p,overall_p));
}

template <class T_Indice, class T_Value>
inline const COOMatrixPartitionedView<T_Indice,T_Value>::partition_type
COOMatrixPartitionedView<T_Indice,T_Value>::partition(size_type overall_p) const
{
  return partition(Range1D(overall_p,overall_p));
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::partition_type
COOMatrixPartitionedView<T_Indice,T_Value>::partition(size_type row_p, size_type col_p)
{
  return partition(overall_part_num(row_p,col_p));
}

template <class T_Indice, class T_Value>
inline const COOMatrixPartitionedView<T_Indice,T_Value>::partition_type
COOMatrixPartitionedView<T_Indice,T_Value>::partition(size_type row_p, size_type col_p) const
{
  return partition(overall_part_num(row_p,col_p));
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::partition_type
COOMatrixPartitionedView<T_Indice,T_Value>::partition(Range1D rng_overall_p)
{
  return create_partition(rng_overall_p);
}

template <class T_Indice, class T_Value>
inline const COOMatrixPartitionedView<T_Indice,T_Value>::partition_type
COOMatrixPartitionedView<T_Indice,T_Value>::partition(Range1D rng_overall_p) const
{
  return create_partition(rng_overall_p);
}

// Private member functions

template <class T_Indice, class T_Value>
inline void COOMatrixPartitionedView<T_Indice,T_Value>::assert_initialized() const {
  if(!is_initialized())
    throw UninitializedException("COOMatrixPartitionedView<..>::assert_initialized() :"
        " The partitioned view has not been initialized.");
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::imp_overall_part_num(size_type row_p, size_type col_p) const
{
  return (partition_order_ == PARTITION_BY_ROW) ?
        (row_p - 1) * num_col_part_ + col_p :
        (col_p - 1) * num_row_part_ + row_p; 
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::imp_row_part_num(size_type overall_p) const
{
  return (partition_order_ == PARTITION_BY_ROW) ?
        (overall_p - 1) / num_col_part_ + 1 :
        (overall_p - 1) % num_row_part_ + 1 ; 
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::imp_col_part_num(size_type overall_p) const
{
  return (partition_order_ == PARTITION_BY_COL) ?
        (overall_p - 1) / num_row_part_ + 1 :
        (overall_p - 1) % num_col_part_ + 1 ; 
}

template <class T_Indice, class T_Value>
inline COOMatrixPartitionedView<T_Indice,T_Value>::size_type
COOMatrixPartitionedView<T_Indice,T_Value>::overall_p_from_ij(const vector_size_type& row_part
  , const vector_size_type& col_part, size_type i, size_type j)
{
  return imp_overall_part_num(   part_num(row_part,i)
                 , part_num(col_part,j) );
}

} // end namespace AbstractLinAlgPack 

#endif // COO_MATRIX_PARTITIONED_VIEW_CLASS_DECL_H