SparsityPattern.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2021, Lawrence Livermore National Security, LLC and LvArray contributors.
 * All rights reserved.
 * See the LICENSE file for details.
 * SPDX-License-Identifier: (BSD-3-Clause)
 */

#pragma once

#include "SparsityPatternView.hpp"

namespace LvArray
{

template< typename COL_TYPE,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
class SparsityPattern : protected SparsityPatternView< COL_TYPE, INDEX_TYPE, BUFFER_TYPE >
{
  using ParentClass = SparsityPatternView< COL_TYPE, INDEX_TYPE, BUFFER_TYPE >;

public:

  using typename ParentClass::ColType;
  using typename ParentClass::ColTypeNC;
  using typename ParentClass::IndexType;


  inline
  SparsityPattern( INDEX_TYPE const nrows=0,
                   ColTypeNC const ncols=0,
                   INDEX_TYPE initialRowCapacity=0 ):
    ParentClass( true )
  {
    resize( nrows, ncols, initialRowCapacity );
    setName( "" );
  }

  inline
  SparsityPattern( SparsityPattern const & src ):
    ParentClass( true )
  { *this = src; }

  inline
  SparsityPattern( SparsityPattern && ) = default;

  inline
  ~SparsityPattern()
  { ParentClass::free(); }



  inline
  SparsityPattern & operator=( SparsityPattern const & src )
  {
    this->m_numCols = src.m_numCols;
    ParentClass::setEqualTo( src.m_numArrays,
                             src.m_offsets[ src.m_numArrays ],
                             src.m_offsets,
                             src.m_sizes,
                             src.m_values );
    return *this;
  }

  inline
  SparsityPattern & operator=( SparsityPattern && src )
  {
    ParentClass::free();
    ParentClass::operator=( std::move( src ) );
    return *this;
  }

  template< typename POLICY >
  void resizeFromRowCapacities( INDEX_TYPE const nRows, ColTypeNC const nCols, INDEX_TYPE const * const rowCapacities )
  {
    LVARRAY_ERROR_IF( !arrayManipulation::isPositive( nCols ), "nCols must be positive." );
    LVARRAY_ERROR_IF( nCols - 1 > std::numeric_limits< COL_TYPE >::max(),
                      "COL_TYPE must be able to hold the range of columns: [0, " << nCols - 1 << "]." );

    this->m_numCols = nCols;
    ParentClass::template resizeFromCapacities< POLICY >( nRows, rowCapacities );
  }



  constexpr inline
  SparsityPatternView< COL_TYPE, INDEX_TYPE const, BUFFER_TYPE >
  toView() const &
  { return ParentClass::toView(); }

  constexpr inline
  SparsityPatternView< COL_TYPE, INDEX_TYPE const, BUFFER_TYPE >
  toView() const && = delete;

  LVARRAY_HOST_DEVICE constexpr inline
  SparsityPatternView< COL_TYPE const, INDEX_TYPE const, BUFFER_TYPE >
  toViewConst() const &
  { return ParentClass::toViewConst(); }

  LVARRAY_HOST_DEVICE constexpr inline
  SparsityPatternView< COL_TYPE const, INDEX_TYPE const, BUFFER_TYPE >
  toViewConst() const && = delete;



  using ParentClass::numRows;
  using ParentClass::numColumns;
  using ParentClass::numNonZeros;
  using ParentClass::nonZeroCapacity;
  using ParentClass::empty;



  using ParentClass::getColumns;
  using ParentClass::getOffsets;



  inline
  void reserveRows( INDEX_TYPE const rowCapacity )
  { ParentClass::reserve( rowCapacity ); }

  inline
  void reserveNonZeros( INDEX_TYPE const nnz )
  { ParentClass::reserveValues( nnz ); }

  inline
  void reserveNonZeros( INDEX_TYPE const row, INDEX_TYPE const nnz )
  {
    if( nonZeroCapacity( row ) >= nnz ) return;
    setRowCapacity( row, nnz );
  }

  inline
  void setRowCapacity( INDEX_TYPE const row, INDEX_TYPE newCapacity )
  {
    if( newCapacity > numColumns() ) newCapacity = numColumns();
    ParentClass::setCapacityOfArray( row, newCapacity );
  }

  inline
  void compress()
  { ParentClass::compress(); }



  void resize( INDEX_TYPE const nRows, ColTypeNC const nCols, INDEX_TYPE const initialRowCapacity )
  { ParentClass::resize( nRows, nCols, initialRowCapacity ); }


  inline
  void appendRow( INDEX_TYPE const nzCapacity=0 )
  {
    INDEX_TYPE const maxOffset = this->m_offsets[ this->m_numArrays ];
    bufferManipulation::emplaceBack( this->m_offsets, this->m_numArrays + 1, maxOffset );
    bufferManipulation::emplaceBack( this->m_sizes, this->m_numArrays, 0 );
    ++this->m_numArrays;

    setRowCapacity( this->m_numArrays - 1, nzCapacity );
  }



  inline
  bool insertNonZero( INDEX_TYPE const row, COL_TYPE const col )
  { return ParentClass::insertIntoSetImpl( row, col, CallBacks( *this, row ) ); }

  template< typename ITER >
  inline
  INDEX_TYPE insertNonZeros( INDEX_TYPE const row, ITER const first, ITER const last )
  { return ParentClass::insertIntoSetImpl( row, first, last, CallBacks( *this, row ) ); }

  using ParentClass::removeNonZero;

  template< typename ITER >
  inline INDEX_TYPE
  removeNonZeros( INDEX_TYPE const row, ITER const first, ITER const last ) const
  { return ParentClass::removeNonZeros( row, first, last ); }



  void move( MemorySpace const space, bool const touch=true ) const
  { return ParentClass::move( space, touch ); }


  void setName( std::string const & name )
  { ParentClass::template setName< decltype( *this ) >( name ); }

private:

  inline
  void dynamicallyGrowRow( INDEX_TYPE const row, INDEX_TYPE const newNNZ )
  { setRowCapacity( row, newNNZ * 2 ); }

  class CallBacks : public sortedArrayManipulation::CallBacks< COL_TYPE >
  {
public:

    inline
    CallBacks( SparsityPattern & sp, INDEX_TYPE const row ):
      m_sp( sp ),
      m_row( row )
    {}

    inline
    COL_TYPE * incrementSize( COL_TYPE * const curPtr, INDEX_TYPE const nToAdd ) const
    {
      LVARRAY_UNUSED_VARIABLE( curPtr );
      INDEX_TYPE const newNNZ = m_sp.numNonZeros( m_row ) + nToAdd;
      if( newNNZ > m_sp.nonZeroCapacity( m_row ) )
      {
        m_sp.dynamicallyGrowRow( m_row, newNNZ );
      }

      return m_sp.getSetValues( m_row );
    }

private:
    SparsityPattern & m_sp;

    INDEX_TYPE const m_row;
  };
};

} /* namespace LvArray */