Sacado_Fad_Vector.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                           Sacado Package
//
// Copyright 2006 NTESS and the Sacado contributors.
// SPDX-License-Identifier: LGPL-2.1-or-later
// *****************************************************************************
// @HEADER

#ifndef SACADO_FAD_VECTOR_HPP
#define SACADO_FAD_VECTOR_HPP

#include <vector>
#include "Sacado_Fad_DVFad.hpp"

namespace Sacado {

  namespace Fad {

    enum VectorDerivOrientation {
      Row,      
      Column    
    };

    template <typename OrdinalType, typename FadType >
    class Vector {
    public:

      typedef typename Sacado::ValueType<FadType>::type ValueType;

      Vector(OrdinalType vec_size, OrdinalType deriv_sz,
       VectorDerivOrientation orient = Row) :
  deriv_size_(deriv_sz), vec_(vec_size) {
  for (OrdinalType i=0; i<vec_size; i++)
    vec_[i] = FadType(deriv_size_, ValueType(0.0));
      }

      Vector(const Vector& fv) : deriv_size_(fv.deriv_size_), vec_(fv.vec_) {}

      ~Vector() {}

      Vector& operator=(const Vector& fv) {
  deriv_size_ = fv.deriv_size_;
  vec_ = fv.vec_;
  return *this;
      }

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

      OrdinalType deriv_size() const { return deriv_size_; }

      OrdinalType deriv_stride() const { return 1; }

      VectorDerivOrientation deriv_orientation() const { return Column; }

      FadType& operator[] (OrdinalType i) { return vec_[i]; }

      const FadType& operator[](OrdinalType i) const { return vec_[i]; }

    protected:

      OrdinalType deriv_size_;

      std::vector<FadType> vec_;

    }; // class Vector

    template <typename OrdinalType, typename ValueType>
    class Vector< OrdinalType, Sacado::Fad::DVFad<ValueType> > {
    public:

      typedef Sacado::Fad::DVFad<ValueType> FadType;

      Vector(OrdinalType vec_size, OrdinalType deriv_size, 
       VectorDerivOrientation orient = Row);

      Vector(const Vector& fv);

      ~Vector();

      Vector& operator=(const Vector& fv);

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

      OrdinalType deriv_size() const { return deriv_size_; }

      OrdinalType deriv_stride() const { return stride_; }

      VectorDerivOrientation deriv_orientation() const { return orient_; }

      FadType& operator[] (OrdinalType i) { return vec_[i]; }

      const FadType& operator[](OrdinalType i) const { return vec_[i]; }

      ValueType* vals();

      const ValueType* vals() const;

      ValueType* dx();

      const ValueType* dx() const;

    protected:

      OrdinalType deriv_size_;

      VectorDerivOrientation orient_;

      OrdinalType stride_;

      std::vector<FadType> vec_;

    }; // class Vector

  } // namespace Fad

} // namespace Sacado

#include "Sacado_Fad_VectorImp.hpp"

#endif // SACADO_FAD_VECTOR_HPP