RTOpPack_SparseSubVectorT.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
// RTOp: Interfaces and Support Software for Vector Reduction Transformation
//       Operations
//                Copyright (2006) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER


#ifndef RTOPPACK_SPARSE_SUB_VECTOR_T_HPP
#define RTOPPACK_SPARSE_SUB_VECTOR_T_HPP


#include "RTOpPack_Types.hpp"
#include "Teuchos_Assert.hpp"


namespace RTOpPack {


template<class Scalar>
class SparseSubVectorT {
public:
  SparseSubVectorT()
    :globalOffset_(0), subDim_(0), subNz_(0),
     valuesStride_(0), indicesStride_(0), localOffset_(0),
     isSorted_(false)
    {}
  SparseSubVectorT(
    Teuchos_Ordinal globalOffset_in, Teuchos_Ordinal subDim_in, Teuchos_Ordinal subNz_in,
    const ArrayRCP<const Scalar> &values_in, ptrdiff_t valuesStride_in,
    const ArrayRCP<const Teuchos_Ordinal> &indices_in, ptrdiff_t indicesStride_in,
    ptrdiff_t localOffset_in, bool isSorted_in
    )
    :globalOffset_(globalOffset_in), subDim_(subDim_in), subNz_(subNz_in),
     values_(values_in), valuesStride_(valuesStride_in), indices_(indices_in),
     indicesStride_(indicesStride_in), localOffset_(localOffset_in), isSorted_(isSorted_in)
    {
#ifdef TEUCHOS_DEBUG
      // Call initialize(...) just to check the preconditions
      initialize(globalOffset_in, subDim_in, subNz_in, values_in, valuesStride_in,
        indices_in, indicesStride_in, localOffset_in, isSorted_in);
#endif
    }
  SparseSubVectorT(
    Teuchos_Ordinal globalOffset_in, Teuchos_Ordinal subDim_in,
    const ArrayRCP<const Scalar> &values_in, ptrdiff_t valuesStride_in
    )
    :globalOffset_(globalOffset_in), subDim_(subDim_in), subNz_(subDim_in),
     values_(values_in), valuesStride_(valuesStride_in),
     indicesStride_(0), localOffset_(0), isSorted_(true)
    {
#ifdef TEUCHOS_DEBUG
      // Call initialize(...) just to check the preconditions
      initialize(globalOffset_in, subDim_in, values_in, valuesStride_in);
#endif
    }
  SparseSubVectorT( const ConstSubVectorView<Scalar>& sv )
    :globalOffset_(sv.globalOffset()), subDim_(sv.subDim()), subNz_(sv.subDim()),
     values_(sv.values()),  valuesStride_(sv.stride()), indicesStride_(0),
     localOffset_(0), isSorted_(true)
    {}
  void initialize(
    Teuchos_Ordinal globalOffset_in, Teuchos_Ordinal subDim_in, Teuchos_Ordinal subNz_in,
    const ArrayRCP<const Scalar> &values_in, ptrdiff_t valuesStride_in,
    const ArrayRCP<const Teuchos_Ordinal> &indices_in, ptrdiff_t indicesStride_in,
    ptrdiff_t localOffset_in, bool isSorted_in
    )
    {
      using Teuchos::as;
#ifdef TEUCHOS_DEBUG
      TEUCHOS_ASSERT(globalOffset_in >= 0);
      TEUCHOS_ASSERT(subDim_in > 0);
      TEUCHOS_ASSERT_IN_RANGE_UPPER_EXCLUSIVE(subNz_in, 0, subDim_in+1);
      TEUCHOS_ASSERT_EQUALITY(values_in.lowerOffset(), 0);
      TEUCHOS_ASSERT(valuesStride_in != 0);
      TEUCHOS_ASSERT_EQUALITY(values_in.size(),
        subNz_in*as<Teuchos_Ordinal>(std::abs(as<int>(valuesStride_in))));
      if (!is_null(indices_in)) {
        TEUCHOS_ASSERT(indicesStride_in != 0);
        TEUCHOS_ASSERT_EQUALITY(indices_in.size(),
          subNz_in*as<Teuchos_Ordinal>(std::abs(as<int>(indicesStride_in))));
        // Note: localOffset can be +, -, or 0 so there is nothing to assert!
        if (isSorted_in) {
          for (int k = 0; k < subNz_in-1; ++k) {
            const Teuchos_Ordinal idx_k = indices_in[k*indicesStride_in];
            const Teuchos_Ordinal idx_kp1 = indices_in[(k+1)*indicesStride_in];
            TEUCHOS_TEST_FOR_EXCEPTION( !(idx_k < idx_kp1), std::out_of_range,
              "Error indices["<<k<<"]="<<idx_k<<" >= indices["<<k+1<<"]="<<idx_kp1
              <<"!" );
          }
        }
      }
#endif
      globalOffset_ = globalOffset_in;
      subDim_ = subDim_in;
      subNz_ = subNz_in;
      values_ = values_in;
      valuesStride_ = valuesStride_in;
      indices_ = indices_in;
      indicesStride_ = indicesStride_in;
      localOffset_ = localOffset_in;
      isSorted_ = isSorted_in;
    }
  void initialize(
    Teuchos_Ordinal globalOffset_in, Teuchos_Ordinal subDim_in,
    const ArrayRCP<const Scalar> &values_in, ptrdiff_t valuesStride_in
    )
    {
      initialize(globalOffset_in, subDim_in, subDim_in, values_in, valuesStride_in,
        Teuchos::null, 0, 0, true);
    }
  void uninitialize()
    {
      globalOffset_ = 0; subDim_ = 0; subNz_ = 0;
      values_ = Teuchos::null; valuesStride_ = 0; indices_ = Teuchos::null;
      indicesStride_ = 0; localOffset_ = 0; isSorted_ = false;
    }
  void setGlobalOffset(Teuchos_Ordinal globalOffset_in) { globalOffset_ = globalOffset_in; } 
  Teuchos_Ordinal globalOffset() const { return globalOffset_; } 
  Teuchos_Ordinal subDim() const { return subDim_; }
  Teuchos_Ordinal subNz() const { return subNz_; }
  const ArrayRCP<const Scalar> values() const { return values_; }
  ptrdiff_t valuesStride() const { return valuesStride_; }
  const ArrayRCP<const Teuchos_Ordinal> indices() const { return indices_; }
  ptrdiff_t indicesStride() const { return indicesStride_; }
  ptrdiff_t localOffset() const { return localOffset_; }
  bool isSorted() const { return isSorted_; }
private:
  Teuchos_Ordinal globalOffset_;
  Teuchos_Ordinal subDim_;
  Teuchos_Ordinal subNz_;
  ArrayRCP<const Scalar> values_;
  ptrdiff_t valuesStride_;
  ArrayRCP<const Teuchos_Ordinal> indices_;
  ptrdiff_t indicesStride_;
  ptrdiff_t localOffset_;
  bool isSorted_;
public:
};


} // namespace RTOpPack


#endif // RTOPPACK_SPARSE_SUB_VECTOR_T_HPP