SparsityPatternView.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2020, 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

// Source includes
#include "ArrayOfSetsView.hpp"

// System includes
#include <limits>

#ifdef LVARRAY_BOUNDS_CHECK

#define SPARSITYPATTERN_COLUMN_CHECK( col ) \
  LVARRAY_ERROR_IF( !arrayManipulation::isPositive( col ) || col >= this->numColumns(), \
                    "Column Check Failed: col=" << col << " numColumns=" << this->numColumns() )

#else // LVARRAY_BOUNDS_CHECK

#define SPARSITYPATTERN_COLUMN_CHECK( col )

#endif

namespace LvArray
{

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

  using typename ParentClass::INDEX_TYPE_NC;

  using typename ParentClass::SIZE_TYPE;

public:
  static_assert( std::is_integral< COL_TYPE >::value, "COL_TYPE must be integral." );
  static_assert( std::is_integral< INDEX_TYPE >::value, "INDEX_TYPE must be integral." );
  static_assert( std::numeric_limits< INDEX_TYPE >::max() >= std::numeric_limits< COL_TYPE >::max(),
                 "INDEX_TYPE must be able to hold values at least as large as COL_TYPE." );

  using ColType = COL_TYPE;
  using typename ParentClass::IndexType;


  SparsityPatternView() = default;

  inline
  SparsityPatternView( SparsityPatternView const & ) = default;

  inline
  SparsityPatternView( SparsityPatternView && src ):
    ParentClass( std::move( src ) ),
    m_numCols( src.m_numCols )
  { src.m_numCols = 0; }

  LVARRAY_HOST_DEVICE constexpr inline
  SparsityPatternView( INDEX_TYPE const nRows,
                       INDEX_TYPE const nCols,
                       BUFFER_TYPE< INDEX_TYPE > const & offsets,
                       BUFFER_TYPE< SIZE_TYPE > const & nnz,
                       BUFFER_TYPE< COL_TYPE > const & columns ):
    ParentClass( nRows, offsets, nnz, columns ),
    m_numCols( nCols )
  {}

  inline
  SparsityPatternView & operator=( SparsityPatternView const & ) = default;

  inline
  SparsityPatternView & operator=( SparsityPatternView && src )
  {
    ParentClass::operator=( std::move( src ) );
    m_numCols = src.m_numCols;
    src.m_numCols = 0;
    return *this;
  }




  LVARRAY_HOST_DEVICE constexpr inline
  SparsityPatternView< COL_TYPE, INDEX_TYPE const, BUFFER_TYPE >
  toView() const
  {
    return SparsityPatternView< COL_TYPE, INDEX_TYPE const, BUFFER_TYPE >( numRows(),
                                                                           numColumns(),
                                                                           this->m_offsets,
                                                                           this->m_sizes,
                                                                           this->m_values );
  }

  LVARRAY_HOST_DEVICE constexpr inline
  SparsityPatternView< COL_TYPE const, INDEX_TYPE const, BUFFER_TYPE >
  toViewConst() const
  {
    return SparsityPatternView< COL_TYPE const, INDEX_TYPE const, BUFFER_TYPE >( numRows(),
                                                                                 numColumns(),
                                                                                 this->m_offsets,
                                                                                 this->m_sizes,
                                                                                 this->m_values );
  }



  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC numRows() const
  { return ParentClass::size(); }

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC numColumns() const
  { return m_numCols; }

  LVARRAY_HOST_DEVICE inline
  INDEX_TYPE_NC numNonZeros() const
  {
    INDEX_TYPE_NC nnz = 0;
    for( INDEX_TYPE_NC row = 0; row < numRows(); ++row )
    {
      nnz += numNonZeros( row );
    }

    return nnz;
  }

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC numNonZeros( INDEX_TYPE const row ) const
  { return ParentClass::sizeOfSet( row ); }

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC nonZeroCapacity() const
  { return ParentClass::valueCapacity(); }

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC nonZeroCapacity( INDEX_TYPE const row ) const
  { return ParentClass::capacityOfSet( row ); }

  LVARRAY_HOST_DEVICE inline
  bool empty() const
  { return numNonZeros() == 0; }

  LVARRAY_HOST_DEVICE constexpr inline
  bool empty( INDEX_TYPE const row ) const
  { return numNonZeros( row ) == 0; }

  LVARRAY_HOST_DEVICE inline
  bool empty( INDEX_TYPE const row, COL_TYPE const col ) const
  { return !ParentClass::contains( row, col ); }



  LVARRAY_HOST_DEVICE constexpr inline
  ArraySlice< COL_TYPE const, 1, 0, INDEX_TYPE_NC >getColumns( INDEX_TYPE const row ) const
  { return (*this)[row]; }

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE const * getOffsets() const
  { return this->m_offsets.data(); }



  LVARRAY_HOST_DEVICE inline
  bool insertNonZero( INDEX_TYPE const row, COL_TYPE const col ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( row );
    SPARSITYPATTERN_COLUMN_CHECK( col );
    return ParentClass::insertIntoSet( row, col );
  }

  template< typename ITER >
  LVARRAY_HOST_DEVICE inline
  INDEX_TYPE_NC insertNonZeros( INDEX_TYPE const row, ITER const first, ITER const last ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( row );

  #ifdef LVARRAY_BOUNDS_CHECK
    for( ITER iter = first; iter != last; ++iter )
    { SPARSITYPATTERN_COLUMN_CHECK( *iter ); }
  #endif

    return ParentClass::insertIntoSet( row, first, last );
  }

  LVARRAY_HOST_DEVICE inline
  bool removeNonZero( INDEX_TYPE const row, COL_TYPE const col ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( row );
    SPARSITYPATTERN_COLUMN_CHECK( col );
    return ParentClass::removeFromSet( row, col );
  }

  DISABLE_HD_WARNING
  template< typename ITER >
  LVARRAY_HOST_DEVICE inline
  INDEX_TYPE_NC removeNonZeros( INDEX_TYPE const row, ITER const first, ITER const last ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( row );

  #ifdef LVARRAY_BOUNDS_CHECK
    for( ITER iter = first; iter != last; ++iter )
    { SPARSITYPATTERN_COLUMN_CHECK( *iter ); }
  #endif

    return ParentClass::removeFromSet( row, first, last );
  }



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


protected:

  SparsityPatternView( bool ):
    ParentClass( true )
  {};

  void assimilate( SparsityPatternView && src )
  {
    ParentClass::free();
    *this = std::move( src );
  }

  template< class ... BUFFERS >
  void resize( INDEX_TYPE const nrows,
               INDEX_TYPE const ncols,
               INDEX_TYPE_NC initialRowCapacity,
               BUFFERS & ... buffers )
  {
    LVARRAY_ERROR_IF( !arrayManipulation::isPositive( nrows ), "nrows must be positive." );
    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 << "]." );

    m_numCols = ncols;
    ParentClass::resizeImpl( nrows, initialRowCapacity, buffers ... );
  }

  INDEX_TYPE_NC m_numCols;
};

} // namespace LvArray