AbstractLinAlgPack_MatrixSparseCOORSerial.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 MATRIX_SPARSE_COOR_SERIAL_H
#define MATRIX_SPARSE_COOR_SERIAL_H

#include "AbstractLinAlgPack_MatrixOp.hpp"
#include "AbstractLinAlgPack_VectorSpaceSerial.hpp"
#include "AbstractLinAlgPack_MatrixLoadSparseElements.hpp"
#include "AbstractLinAlgPack_MatrixExtractSparseElements.hpp"
#include "ReleaseResource.hpp"

namespace AbstractLinAlgPack {

class MatrixSparseCOORSerial
  : virtual public AbstractLinAlgPack::MatrixOp
  , virtual public MatrixLoadSparseElements
  , virtual public MatrixExtractSparseElements
{
public:

  
  typedef Teuchos::RCP<
    MemMngPack::ReleaseResource>     release_resource_ptr_t;
  class ReleaseValRowColArrays
    : public MemMngPack::ReleaseResource
  {
  public:
    ReleaseValRowColArrays(
      value_type   *val
      ,index_type  *row_i
      ,index_type  *col_j
      )
      :val_(val)
      ,row_i_(row_i)
      ,col_j_(col_j)
      ,owns_mem_(true)
    {}
    // Calls delete on buffers if <tt>this->owns_memory() == true</tt>
    ~ReleaseValRowColArrays();
    bool resource_is_bound() const;
    void release_ownership() { owns_mem_ = false; }
    value_type* val()   { return val_; }
    index_type* row_i() { return row_i_; }
    index_type* col_j() { return col_j_; }
  private:
    value_type  *val_;
    index_type  *row_i_;
    index_type  *col_j_;
    bool        owns_mem_;
    // not defined and not to be called
    ReleaseValRowColArrays();
    ReleaseValRowColArrays(const ReleaseValRowColArrays&);
    ReleaseValRowColArrays& operator=(const ReleaseValRowColArrays&);
  }; // end class ReleaseValRowColArrays



  MatrixSparseCOORSerial();

  void set_buffers(
    size_type                      max_nz
    ,value_type                    *val
    ,index_type                    *row_i
    ,index_type                    *col_j
    ,const release_resource_ptr_t  &release_resource
    ,size_type                     rows                = 0
    ,size_type                     cols                = 0
    ,size_type                     nz                  = 0
    ,bool                          check_input         = false
    );
    
  void set_uninitialized();



  value_type* val();
  const value_type* val() const;
  index_type* row_i();
  const index_type* row_i() const;
  index_type* col_j();
  const index_type* col_j() const;
  const release_resource_ptr_t& release_resource() const;



  size_type rows() const;
  size_type cols() const;
  size_type nz() const;



  const VectorSpace& space_cols() const;
  const VectorSpace& space_rows() const;
  MatrixOp& operator=(const MatrixOp& M);
  std::ostream& output(std::ostream& out) const;
  void Vp_StMtV(
    VectorMutable* vs_lhs, value_type alpha, BLAS_Cpp::Transp trans_rhs1
    , const Vector& v_rhs2, value_type beta) const;

  // ToDo: Add more method overrides as they are needed!
  
  

  void reinitialize(
    size_type                  rows
    ,size_type                 cols
    ,size_type                 max_nz
    ,EAssumeElementUniqueness  element_uniqueness
    );
  void reset_to_load_values();
  void get_load_nonzeros_buffers(
    size_type      max_nz_load
    ,value_type    **val
    ,index_type    **row_i
    ,index_type    **col_j
    );
  void commit_load_nonzeros_buffers(
    size_type      nz_commit
    ,value_type    **val
    ,index_type    **row_i
    ,index_type    **col_j
    );
  void finish_construction( bool test_setup );



  index_type count_nonzeros(
    EElementUniqueness    element_uniqueness
    ,const index_type     inv_row_perm[]
    ,const index_type     inv_col_perm[]
    ,const Range1D        &row_rng
    ,const Range1D        &col_rng
    ,index_type           dl
    ,index_type           du
    ) const;
  void coor_extract_nonzeros(
    EElementUniqueness    element_uniqueness
    ,const index_type     inv_row_perm[]
    ,const index_type     inv_col_perm[]
    ,const Range1D        &row_rng
    ,const Range1D        &col_rng
    ,index_type           dl
    ,index_type           du
    ,value_type           alpha
    ,const index_type     len_Aval
    ,value_type           Aval[]
    ,const index_type     len_Aij
    ,index_type           Arow[]
    ,index_type           Acol[]
    ,const index_type     row_offset
    ,const index_type     col_offset
    ) const;


private:

  // //////////////////////////////
  // Private types

  // //////////////////////////////
  // Public types

  size_type                 rows_;
  size_type                 cols_;
  size_type                 max_nz_;
  EAssumeElementUniqueness  element_uniqueness_;
  size_type                 nz_;
  value_type                *val_;
  index_type                *row_i_;
  index_type                *col_j_;
  release_resource_ptr_t    release_resource_;

  bool                      self_allocate_; // True if this allocates the memory

  VectorSpaceSerial         space_cols_;
  VectorSpaceSerial         space_rows_;

  size_type                 max_nz_load_;     // cashed
  bool                      reload_val_only_; // cashed
  size_type                 reload_val_only_nz_last_; // cashed

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

  void make_storage_unique();

  // static
  static release_resource_ptr_t  release_resource_null_;

}; // end class MatrixSparseCOORSerial

// //////////////////////////////////
// Inline members

inline
value_type* MatrixSparseCOORSerial::val()
{
  make_storage_unique();
  return val_;
}

inline
const value_type* MatrixSparseCOORSerial::val() const
{
  return val_;
}

inline
index_type* MatrixSparseCOORSerial::row_i()
{
  make_storage_unique();
  return row_i_;
}

inline
const index_type* MatrixSparseCOORSerial::row_i() const
{
  return row_i_;
}

inline
index_type* MatrixSparseCOORSerial::col_j()
{
  make_storage_unique();
  return col_j_;
}

inline
const index_type* MatrixSparseCOORSerial::col_j() const
{
  return col_j_;
}

inline
const MatrixSparseCOORSerial::release_resource_ptr_t&
MatrixSparseCOORSerial::release_resource() const
{
  return self_allocate_ ? release_resource_null_ : release_resource_;
}

} // end namespace AbstractLinAlgPack

#endif // MATRIX_SPARSE_COOR_SERIAL_H