Zoltan2_OrderingSolution.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_ORDERINGSOLUTION_HPP_
#define _ZOLTAN2_ORDERINGSOLUTION_HPP_
 
#include <Zoltan2_Standards.hpp>
#include <Zoltan2_Solution.hpp>
 
namespace Zoltan2 {
 
template <typename index_t>
class OrderingSolution : public Solution
{
public:
 
  OrderingSolution(index_t perm_size) : separatorColBlocks_(0)
  {
    HELLO;
    perm_size_        = perm_size;
    perm_             = ArrayRCP<index_t>(perm_size_);
    invperm_          = ArrayRCP<index_t>(perm_size_);
    separatorRange_   = ArrayRCP<index_t>(perm_size_+1);
    separatorTree_    = ArrayRCP<index_t>(perm_size_);
 
    havePerm_ = false;
    haveInverse_ = false;
    haveSeparatorRange_ = false;
    haveSeparatorTree_ = false;
  }
 
  bool havePerm() const
  {
    return havePerm_; 
  }
 
  void setHavePerm(bool status)
  {
    havePerm_ = status; 
  }
 
 
  bool haveInverse() const
  {
    return haveInverse_; 
  }
 
  void setHaveInverse(bool status)
  {
    haveInverse_ = status; 
  }
 
 void setHaveSeparator(bool status) {
    this->setHavePerm(status);
    this->setHaveInverse(status);
    this->setHaveSeparatorRange(status);
    this->setHaveSeparatorTree(status);
 } 
  bool haveSeparatorRange() const
  {
    return haveSeparatorRange_; 
  }
 
  void setHaveSeparatorRange(bool status)
  {
    haveSeparatorRange_ = status; 
  }
  
  bool haveSeparatorTree() const
  {
    return haveSeparatorTree_; 
  }
  
  bool haveSeparators() const
  {
    return haveSeparatorRange() && haveSeparatorTree(); 
  }
 
  void setHaveSeparatorTree(bool status)
  {
    haveSeparatorTree_ = status; 
  }
 
  void computePerm()
  {
    if (haveInverse_) {
      for(size_t i=0; i<perm_size_; i++) {
        perm_[invperm_[i]] = i;
      }
      havePerm_ = true;
    }
    else {
      // TODO: throw exception
      std::cerr << "No inverse!" << std::endl;
    }
  }
 
  void computeInverse()
  {
    if (havePerm_) {
      for(size_t i=0; i<perm_size_; i++) {
        invperm_[perm_[i]] = i;
      }
      haveInverse_ = true;
    }
    else {
      // TODO: throw exception
      std::cerr << "No perm!" << std::endl;
    }
  }
 
  inline void setNumSeparatorBlocks(index_t nblks) {separatorColBlocks_ = nblks;}
 
  // Accessor functions, allowing algorithms to get ptrs to solution memory.
  // Algorithms can then load the memory.
  // Non-RCP versions are provided for applications to use.
 
  inline size_t getPermutationSize() const {return perm_size_;}
  
  inline index_t getNumSeparatorBlocks() const {return separatorColBlocks_;}
 
 // inline ArrayRCP<index_t>  &getGidsRCP()  {return gids_;}
 
  inline const ArrayRCP<index_t> &getPermutationRCP(bool inverse=false) const
  {
    if (inverse)
      return invperm_;
    else
      return perm_;
  }
  
  bool getVertexSeparator (index_t &numBlocks,
                           index_t *range,
                           index_t *tree) const {
 
    if (this->haveSeparators()) {
      numBlocks = this->getNumSeparatorBlocks();
      range = this->getSeparatorRangeView();
      tree = this->getSeparatorTreeView();
      return true;
    }
 
    return false;
  }
 
  inline const ArrayRCP<index_t> &getSeparatorRangeRCP() const
  {
    return separatorRange_;
  }
  
  inline const ArrayRCP<index_t> &getSeparatorTreeRCP() const
  {
    return separatorTree_;
  }
 
 // inline ArrayRCP<index_t>  &getGidsRCPConst()  const
 // {
 //   return const_cast<ArrayRCP<index_t>& > (gids_);
 // }
 
  inline ArrayRCP<index_t> &getPermutationRCPConst(bool inverse=false) const
  {
    if (inverse)
      return const_cast<ArrayRCP<index_t>& > (invperm_);
    else
      return const_cast<ArrayRCP<index_t>& > (perm_);
  }
  
  inline ArrayRCP<index_t> &getSeparatorRangeRCPConst() const
  {
    return const_cast<ArrayRCP<index_t> & > (separatorRange_);
  }
  
  inline ArrayRCP<index_t> &getSeparatorTreeRCPConst() const
  {
    return const_cast<ArrayRCP<index_t> & > (separatorTree_);
  }
 
  inline index_t *getPermutationView(bool inverse = false) const
  {
    if (perm_size_) {
      if (inverse)
        return invperm_.getRawPtr();
      else
        return perm_.getRawPtr();
    }
    else
      return NULL;
  }
  
  inline index_t *getSeparatorRangeView() const
  {
    // Here, don't need to check perm_size_ before calling getRawPtr.
    // separatorRange_ always has some length, since it is allocated larger
    // than other arrays.
    return separatorRange_.getRawPtr();
  }
 
  inline index_t *getSeparatorTreeView() const
  {
    if (perm_size_)
      return separatorTree_.getRawPtr();
    else
      return NULL;
  }
  
  inline index_t &NumSeparatorBlocks()
  {
    return separatorColBlocks_; 
  }
 
  int validatePerm()
  {
    size_t n = getPermutationSize();
 
    if(!havePerm_) {
      return -1;
    }
 
    std::vector<int> count(getPermutationSize());
    for (size_t i = 0; i < n; i++) {
      count[i] = 0;
    }
 
    for (size_t i = 0; i < n; i++) {
      if ( (perm_[i] < 0) || (perm_[i] >= static_cast<index_t>(n)) )
        return -1;
      else
        count[perm_[i]]++;
    }
 
    // Each index should occur exactly once (count==1)
    for (size_t i = 0; i < n; i++) {
      if (count[i] != 1){
        return -2;
      }
    }
 
    return 0;
  }
 
protected:
  // Ordering solution consists of permutation vector(s).
  // Either perm or invperm should be computed by the algorithm.
  size_t perm_size_;
  bool havePerm_;                    // has perm_ been computed yet?
  bool haveInverse_;                 // has invperm_ been computed yet?
  bool haveSeparatorRange_;          // has sepRange_ been computed yet?
  bool haveSeparatorTree_;           // has sepTree_ been computed yet?
  ArrayRCP<index_t> perm_;           // zero-based local permutation
  ArrayRCP<index_t> invperm_;        // inverse of permutation above
  ArrayRCP<index_t> separatorRange_; // range iterator for separator tree
  ArrayRCP<index_t> separatorTree_;  // separator tree
  index_t separatorColBlocks_;       // number of column blocks in separator
};
 
template <typename lno_t>
class LocalOrderingSolution : public OrderingSolution<lno_t>
{
public:
  LocalOrderingSolution(lno_t perm_size) : OrderingSolution<lno_t>(perm_size) {}
};
 
template <typename gno_t>
class GlobalOrderingSolution : public OrderingSolution<gno_t>
{
public:
  GlobalOrderingSolution(gno_t perm_size) : OrderingSolution<gno_t>(perm_size) {}
};
 
}
 
#endif