Zoltan2_MatrixAdapter.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//   Zoltan2: A package of combinatorial algorithms for scientific computing
//
// Copyright 2012 NTESS and the Zoltan2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef _ZOLTAN2_MATRIXADAPTER_HPP_
#define _ZOLTAN2_MATRIXADAPTER_HPP_
 
#include <Zoltan2_Adapter.hpp>
#include <Zoltan2_VectorAdapter.hpp>
 
namespace Zoltan2 {
 
enum MatrixEntityType {
  MATRIX_ROW,
  MATRIX_COLUMN,
  MATRIX_NONZERO
};
 
template <typename User, typename UserCoord=User>
  class MatrixAdapter : public AdapterWithCoordsWrapper<User, UserCoord> {
private:
  enum MatrixEntityType primaryEntityType_;
  VectorAdapter<UserCoord> *coordinateInput_;
  bool haveCoordinateInput_;
 
public:
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  using scalar_t = typename InputTraits<User>::scalar_t;
  using lno_t = typename InputTraits<User>::lno_t;
  using gno_t = typename InputTraits<User>::gno_t;
  using part_t = typename InputTraits<User>::part_t;
  using node_t = typename InputTraits<User>::node_t;
  using offset_t = typename InputTraits<User>::offset_t;
  using user_t = User;
  using userCoord_t = UserCoord;
  using base_adapter_t = MatrixAdapter<User,UserCoord>;
  using device_t = typename node_t::device_type;
#endif
 
  enum BaseAdapterType adapterType() const override {return MatrixAdapterType;}
 
  // Constructor; sets default primaryEntityType to MATRIX_ROW.
  MatrixAdapter() : primaryEntityType_(MATRIX_ROW),
                    coordinateInput_(),
                    haveCoordinateInput_(false) {}
 
  virtual size_t getLocalNumRows() const = 0;
 
  virtual size_t getLocalNumColumns() const = 0;
 
  virtual size_t getLocalNumEntries() const = 0;
 
 
 
  virtual bool CRSViewAvailable() const { return false; }
 
  virtual void getRowIDsView(const gno_t *&rowIds) const
  {
    rowIds = NULL;
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getRowIDsHostView(typename BaseAdapter<User>::ConstIdsHostView& rowIds) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getRowIDsDeviceView(typename BaseAdapter<User>::ConstIdsDeviceView& rowIds) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getCRSView(ArrayRCP<const offset_t> &offsets, ArrayRCP<const gno_t> &colIds) const
  {
    // Default implementation; no CRS view provided.
    offsets = ArrayRCP<const offset_t>();
    colIds = ArrayRCP<const gno_t>();
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getCRSHostView(typename BaseAdapter<User>::ConstOffsetsHostView& offsets,
                              typename BaseAdapter<User>::ConstIdsHostView& colIds) const
  {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getCRSDeviceView(typename BaseAdapter<User>::ConstOffsetsDeviceView& offsets,
                                typename BaseAdapter<User>::ConstIdsDeviceView& colIds) const
  {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
 
  virtual void getCRSView(ArrayRCP<const offset_t> &offsets,
                          ArrayRCP<const gno_t> &colIds,
                          ArrayRCP<const scalar_t> &values) const
  {
    // Default implementation; no CRS view provided.
    offsets = ArrayRCP<const offset_t>();
    colIds = ArrayRCP<const gno_t>();
    values = ArrayRCP<const scalar_t>();
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getCRSHostView(typename BaseAdapter<User>::ConstOffsetsHostView& offsets,
                              typename BaseAdapter<User>::ConstIdsHostView& colIds,
                              typename BaseAdapter<User>::ConstScalarsHostView& values) const
  {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getCRSDeviceView(typename BaseAdapter<User>::ConstOffsetsDeviceView& offsets,
                                typename BaseAdapter<User>::ConstIdsDeviceView& colIds,
                                typename BaseAdapter<User>::ConstScalarsDeviceView& values) const
  {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
 
  virtual int getNumWeightsPerRow() const { return 0;}
 
  virtual void getRowWeightsView(const scalar_t *&weights, int &stride,
                                 int idx = 0) const
  {
    // Default implementation
    weights = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getRowWeightsHostView(typename BaseAdapter<User>::WeightsHostView1D& weights,
                                     int /* idx */ = 0) const {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getRowWeightsHostView(typename BaseAdapter<User>::WeightsHostView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getRowWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView1D& weights,
                                       int /* idx */ = 0) const {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getRowWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual bool useNumNonzerosAsRowWeight(int idx) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual bool CCSViewAvailable() const { return false; }
 
  virtual void getColumnIDsView(const gno_t *&colIds) const
  {
    colIds = NULL;
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getColumnIDsHostView(typename BaseAdapter<User>::ConstIdsHostView& colIds) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getColumnIDsDeviceView(typename BaseAdapter<User>::ConstIdsDeviceView& colIds) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getCCSView(ArrayRCP<const offset_t> &offsets,
                          ArrayRCP<const gno_t> &rowIds) const
  {
    // Default implementation; no CCS view provided.
    offsets = ArrayRCP<const offset_t>();
    rowIds = ArrayRCP<const gno_t>();
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getCCSView(ArrayRCP<const offset_t> &offsets,
                          ArrayRCP<const gno_t> &rowIds,
                          ArrayRCP<const scalar_t> &values) const
  {
    // Default implementation; no CCS view provided.
    offsets = ArrayRCP<const offset_t>();
    rowIds = ArrayRCP<const gno_t>();
    values = ArrayRCP<const scalar_t>();
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual int getNumWeightsPerColumn() const { return 0; }
 
  virtual void getColumnWeightsView(const scalar_t *&weights, int &stride,
                                    int idx = 0) const
  {
    // Default implementation
    weights = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getColumnWeightsHostView(typename BaseAdapter<User>::WeightsHostView1D& weights,
                                     int /* idx */ = 0) const {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getColumnWeightsHostView(typename BaseAdapter<User>::WeightsHostView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getColumnWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView1D& weights,
                                       int /* idx */ = 0) const {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getColumnWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual bool useNumNonzerosAsColumnWeight(int idx) const { return 0; }
 
#ifdef FUTURE_FEATURE
  virtual bool symmetricStorage() const {return false;}
#endif
 
  void setCoordinateInput(VectorAdapter<UserCoord> *coordData) override
  {
    coordinateInput_ = coordData;
    haveCoordinateInput_ = true;
  }
 
  bool coordinatesAvailable() const { return haveCoordinateInput_; }
 
  VectorAdapter<UserCoord> *getCoordinateInput() const override
  {
    return coordinateInput_;
  }
 
  // Implementations of base-class methods and other methods shared by all
 
  inline enum MatrixEntityType getPrimaryEntityType() const
  {
    return this->primaryEntityType_;
  }
 
  void setPrimaryEntityType(std::string typestr)
  {
    if (typestr == "row") {
      this->primaryEntityType = MATRIX_ROW;
    }
    else if (typestr == "column") {
      this->primaryEntityType = MATRIX_COLUMN;
    }
    else if (typestr == "nonzero") {
      this->primaryEntityType = MATRIX_NONZERO;
    }
    else {
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  Invalid MatrixEntityType " << typestr << std::endl;
      emsg << "Valid values are 'row', 'column' and 'nonzero'." << std::endl;
      throw std::runtime_error(emsg.str());
    }
  }
 
  // Functions from the BaseAdapter interface
  size_t getLocalNumIDs() const override
  {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      return getLocalNumRows();
    case MATRIX_COLUMN:
      return getLocalNumColumns();
    case MATRIX_NONZERO:
      return getLocalNumEntries();
    default:   // Shouldn't reach default; just making compiler happy
      return 0;
    }
  }
 
  void getIDsView(const gno_t *&Ids) const override
  {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      getRowIDsView(Ids);
      break;
    case MATRIX_COLUMN:
      getColumnIDsView(Ids);
      break;
    case MATRIX_NONZERO: {
      // TODO:  Need getNonzeroIDsView?  What is a Nonzero ID?
      // TODO:  std::pair<gno_t, gno_t>?
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  getIDsView not yet supported for matrix nonzeros."
           << std::endl;
      throw std::runtime_error(emsg.str());
      }
    default:   // Shouldn't reach default; just making compiler happy
      break;
    }
  }
 
  void getIDsHostView(typename BaseAdapter<User>::ConstIdsHostView& ids) const override {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      getRowIDsHostView(ids);
      break;
    case MATRIX_COLUMN:
      getColumnIDsHostView(ids);
      break;
    case MATRIX_NONZERO: {
      // TODO:  Need getNonzeroIDsHostView?  What is a Nonzero ID?
      // TODO:  std::pair<gno_t, gno_t>?
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  getIDsView not yet supported for matrix nonzeros."
           << std::endl;
      throw std::runtime_error(emsg.str());
      }
    default:   // Shouldn't reach default; just making compiler happy
      break;
    }
  }
 
  void getIDsDeviceView(typename BaseAdapter<User>::ConstIdsDeviceView& ids) const override {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      getRowIDsDeviceView(ids);
      break;
    case MATRIX_COLUMN:
      getColumnIDsDeviceView(ids);
      break;
    case MATRIX_NONZERO: {
      // TODO:  Need getNonzeroIDsDeviceView?  What is a Nonzero ID?
      // TODO:  std::pair<gno_t, gno_t>?
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  getIDsView not yet supported for matrix nonzeros."
           << std::endl;
      throw std::runtime_error(emsg.str());
      }
    default:   // Shouldn't reach default; just making compiler happy
      break;
    }
  }
 
  int getNumWeightsPerID() const override
  {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      return getNumWeightsPerRow();
    case MATRIX_COLUMN:
      return getNumWeightsPerColumn();
    case MATRIX_NONZERO:
      return 0;  //TODO: weights not yet supported for nonzeros
    default:   // Shouldn't reach default; just making compiler happy
      return 0;
    }
  }
 
  void getWeightsView(const scalar_t *&wgt, int &stride,
                      int idx = 0) const override
  {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      getRowWeightsView(wgt, stride, idx);
      break;
    case MATRIX_COLUMN:
      getColumnWeightsView(wgt, stride, idx);
      break;
    case MATRIX_NONZERO:
      {
      // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
      // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  getWeightsView not yet supported for matrix nonzeros."
           << std::endl;
      throw std::runtime_error(emsg.str());
      }
    default:   // Shouldn't reach default; just making compiler happy
      break;
    }
  }
 
  void getWeightsHostView(typename BaseAdapter<User>::WeightsHostView &hostWgts) const override {
      switch (getPrimaryEntityType()) {
      case MATRIX_ROW:
        getRowWeightsHostView(hostWgts);
        break;
      case MATRIX_COLUMN:
        getColumnWeightsHostView(hostWgts);
        break;
      case MATRIX_NONZERO:
        {
        // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
        // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  getWeightsView not yet supported for matrix nonzeros."
             << std::endl;
        throw std::runtime_error(emsg.str());
        }
      default:   // Shouldn't reach default; just making compiler happy
        break;
      }  }
 
  void getWeightsHostView(typename BaseAdapter<User>::WeightsHostView1D &hostWgts,
                                  int idx = 0) const override {
      switch (getPrimaryEntityType()) {
      case MATRIX_ROW:
        getRowWeightsHostView(hostWgts, idx);
        break;
      case MATRIX_COLUMN:
        getColumnWeightsHostView(hostWgts, idx);
        break;
      case MATRIX_NONZERO:
        {
        // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
        // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  getWeightsView not yet supported for matrix nonzeros."
             << std::endl;
        throw std::runtime_error(emsg.str());
        }
      default:   // Shouldn't reach default; just making compiler happy
        break;
      }  }
 
  void getWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView& deviceWgts) const override {
      switch (getPrimaryEntityType()) {
      case MATRIX_ROW:
        getRowWeightsDeviceView(deviceWgts);
        break;
      case MATRIX_COLUMN:
        getColumnWeightsDeviceView(deviceWgts);
        break;
      case MATRIX_NONZERO:
        {
        // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
        // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  getWeightsView not yet supported for matrix nonzeros."
             << std::endl;
        throw std::runtime_error(emsg.str());
        }
      default:   // Shouldn't reach default; just making compiler happy
        break;
      }  }
 
  void getWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView1D& deviceWgts,
                                    int idx = 0) const override {
      switch (getPrimaryEntityType()) {
      case MATRIX_ROW:
        getRowWeightsDeviceView(deviceWgts, idx);
        break;
      case MATRIX_COLUMN:
        getColumnWeightsDeviceView(deviceWgts, idx);
        break;
      case MATRIX_NONZERO:
        {
        // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
        // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  getWeightsView not yet supported for matrix nonzeros."
             << std::endl;
        throw std::runtime_error(emsg.str());
        }
      default:   // Shouldn't reach default; just making compiler happy
        break;
      }  }
 
  bool useDegreeAsWeight(int idx) const
  {
    if (this->getPrimaryEntityType() == MATRIX_ROW)
      return useNumNonzerosAsRowWeight(idx);
    else {
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  useDegreeAsWeight is currently supported only for rows"
           << std::endl;
      throw std::runtime_error(emsg.str());
    }
  }
};
 
}  //namespace Zoltan2
 
#endif