Zoltan2_StridedData.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_STRIDEDDATA_HPP_
#define _ZOLTAN2_STRIDEDDATA_HPP_

#include <Zoltan2_Standards.hpp>
#include <Zoltan2_Environment.hpp>
#include <typeinfo>

namespace Zoltan2{

template<typename lno_t, typename scalar_t>
class StridedData {
private:
  ArrayRCP<const scalar_t> vec_;
  int stride_;

public:

  StridedData(ArrayRCP<const scalar_t> x, int stride) :  
    vec_(x), stride_(stride)
    { }

  StridedData(): vec_(), stride_(0)
    { }

  lno_t size() const { return vec_.size(); }

  scalar_t operator[](lno_t idx) const { return vec_[idx*stride_]; }

  template <typename T> void getInputArray(ArrayRCP<const T> &array) const;

  void getStridedList(ArrayRCP<const scalar_t> &vec, int &stride) const
  {
    vec = vec_;
    stride = stride_;
  }

  void getStridedList(size_t &len, const scalar_t *&vec, int &stride) const
  {
    len = vec_.size();
    if (len != 0) vec = vec_.getRawPtr();
    else          vec = NULL;
    stride = stride_;
  }

  StridedData & operator= (const StridedData &sInput)
  {
    if (this != &sInput)
      sInput.getStridedList(vec_, stride_);

    return *this;
  }
};

// Helper function needed for T=scalar_t specialization
// Separate function needed // because, with T != scalar_t, 
// "array = vec_" // would not compile; 
// ArrayRCP does not overload "=" operator for different types.
// Separate helper function needed (outside StridedData class)
// because cannot specialize member function of templated class.
template<typename scalar_t, typename T>
static void getInputArrayHelper(
  ArrayRCP<const T> &target,
  const ArrayRCP<const scalar_t> &src)
{
  // Create a copy of desired type T
  // From logic in getInputArray, we know stride == 1.
  size_t n = src.size();
  T *tmp = new T [n];

  if (!tmp){
    std::cerr << "Error: " << __FILE__ << ", " << __LINE__<< std::endl;
    std::cerr << n << " objects" << std::endl;
    throw std::bad_alloc();
  }

  for (size_t i=0; i < n; i++){
    tmp[i] = static_cast<T>(src[i]);
  }
  target = arcp(tmp, 0, n);
}

// Specialization with T == scalar_t:  just copy ArrayRCP
template<typename scalar_t>
static void getInputArrayHelper(
  ArrayRCP<const scalar_t> &target,
  const ArrayRCP<const scalar_t> &src)
{
  target = src;
}

// Member function for getting unstrided view/copy of StridedData.
template<typename lno_t, typename scalar_t>
  template<typename T>
     void StridedData<lno_t, scalar_t>::getInputArray(
       ArrayRCP<const T> &array) const
{
  if (vec_.size() < 1){
    array = ArrayRCP<const T>();
  }
  else if (stride_ > 1) {
    // Create an unstrided copy
    size_t n = vec_.size() / stride_;
    T *tmp = new T [n];

    if (!tmp){
      std::cerr << "Error: " << __FILE__ << ", " << __LINE__<< std::endl;
      std::cerr << n << " objects" << std::endl;
      throw std::bad_alloc();
    }

    for (size_t i=0,j=0; i < n; i++,j+=stride_){
      tmp[i] = static_cast<T>(vec_[j]);
    }
    array = arcp(tmp, 0, n);
  }
  else { // stride == 1
    Zoltan2::getInputArrayHelper<scalar_t, T>(array, vec_);
  }
  return;
}

}  // namespace Zoltan2

#endif