Sacado_Tay_CacheTaylor.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//                           Sacado Package
//                 Copyright (2006) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
// USA
// Questions? Contact David M. Gay (dmgay@sandia.gov) or Eric T. Phipps
// (etphipp@sandia.gov).
//
// ***********************************************************************
// @HEADER

#ifndef SACADO_TAY_CACHETAYLOR_HPP
#define SACADO_TAY_CACHETAYLOR_HPP

#include <valarray>

#include "Sacado_Tay_CacheTaylorExpr.hpp"

// forward decalarations
namespace Sacado {
  namespace Tay {
    template <class ExprT> class UnaryPlusOp;
    template <class ExprT> class UnaryMinusOp;
  }
}

namespace Sacado {

  namespace Tay {

    // Forward declaration
    template <typename T> class CacheTaylor;


    template <typename T>
    class CacheTaylorImplementation {

    public:

      typedef T value_type;

      typedef typename ScalarType<T>::type scalar_type;

      CacheTaylorImplementation() : coeff_(T(0.),1) {}


      CacheTaylorImplementation(const T& x) : coeff_(x,1) {}


      CacheTaylorImplementation(int d, const T & x) :
        coeff_(T(0.),d+1) {
        coeff_[0] = x;
      }

      CacheTaylorImplementation(const CacheTaylorImplementation& x) :
        coeff_(x.coeff_) {}

      ~CacheTaylorImplementation() {}


      void resize(int d, bool keep_coeffs) {
        if (keep_coeffs)
          resizeCoeffs(d);
        else
          coeff_.resize(d+1, T(0.));
      }


      const T& val() const { return coeff_[0];}

      T& val() { return coeff_[0];}



      int degree() const { return coeff_size()-1;}

      bool hasFastAccess(int d) const { return coeff_size()>=d+1;}

      const std::valarray<T>& coeff() const { return coeff_;}

      const T coeff(int i) const {
        T tmp= i<coeff_size() ? coeff_[i]:T(0.); return tmp;}

      T coeff(int i) {
        T tmp= i<coeff_size() ? coeff_[i]:T(0.); return tmp;}

      T& fastAccessCoeff(int i) { return coeff_[i];}

      const T& fastAccessCoeff(int i) const { return coeff_[i];}

      void allocateCache(int d) const {}

      template <typename S>
      bool isEqualTo(const Expr<S>& x) const {
        typedef IsEqual<value_type> IE;
        if (x.degree() != this->degree()) return false;
        bool eq = true;
        for (int i=0; i<=this->degree(); i++)
          eq = eq && IE::eval(x.coeff(i), this->coeff(i));
        return eq;
      }


    protected:

      void resizeCoeffs(int dnew) {
        std::valarray<T> tmp = coeff_;
        int sz = coeff_size();
        coeff_.resize(dnew+1,T(0.));
        if (sz > dnew+1) {
          std::slice s(0,dnew+1,1);
          coeff_ = tmp[s];
        }
        else {
          std::slice s(0,sz,1);
          coeff_[s] = tmp;
        }
      }

      int coeff_size() const { return coeff_.size(); }

    protected:

      std::valarray<T> coeff_;

    }; // class CacheTaylorImplementation


    template <typename T>
    class Expr< CacheTaylorImplementation<T> > :
      public CacheTaylorImplementation<T> {

    public:

      typedef CacheTaylor<T> base_expr_type;

      Expr() : CacheTaylorImplementation<T>() {}


      Expr(const T & x) : CacheTaylorImplementation<T>(x) {}


      Expr(int d, const T & x) : CacheTaylorImplementation<T>(d,x) {}

      Expr(const Expr& x) : CacheTaylorImplementation<T>(x) {}

    }; // class Expr< CacheTaylorImplementation<T> >


    template <typename T>
    class CacheTaylor : public Expr< CacheTaylorImplementation<T> > {

    public:

      typedef T value_type;

      typedef typename ScalarType<T>::type scalar_type;

      template <typename U>
      struct apply {
        typedef CacheTaylor<U> type;
      };


      CacheTaylor() : Expr< CacheTaylorImplementation<T> >() {}


      CacheTaylor(const T & x) : Expr< CacheTaylorImplementation<T> >(x) {}


      CacheTaylor(const typename dummy<value_type,scalar_type>::type& x) :
        Expr< CacheTaylorImplementation<T> >(value_type(x)) {}


      CacheTaylor(int d, const T & x) :
        Expr< CacheTaylorImplementation<T> >(d,x) {}

      CacheTaylor(const CacheTaylor& x) : Expr< CacheTaylorImplementation<T> >(x) {}

      template <typename S> CacheTaylor(const Expr<S>& x);


      ~CacheTaylor() {}


      CacheTaylor<T>& operator=(const T& v);


      CacheTaylor<T>&
      operator=(const typename dummy<value_type,scalar_type>::type& val) {
        return operator=(value_type(val));
      }

      CacheTaylor<T>& operator=(const CacheTaylor<T>& x);

      template <typename S> CacheTaylor<T>& operator=(const Expr<S>& x);



      inline Expr< UnaryExpr< CacheTaylor<T>, UnaryPlusOp > >
      operator + () const {
        typedef UnaryExpr< CacheTaylor<T>, UnaryPlusOp > expr_t;
        return Expr<expr_t>(expr_t(*this));
      }

      inline Expr< UnaryExpr< CacheTaylor<T>, UnaryMinusOp > >
      operator - () const {
        typedef UnaryExpr< CacheTaylor<T>, UnaryMinusOp > expr_t;
        return Expr<expr_t>(expr_t(*this));
      }

      CacheTaylor<T>& operator += (const T& x);

      CacheTaylor<T>& operator -= (const T& x);

      CacheTaylor<T>& operator *= (const T& x);

      CacheTaylor<T>& operator /= (const T& x);

      template <typename S> CacheTaylor<T>& operator += (const S& x);

      template <typename S> CacheTaylor<T>& operator -= (const S& x);

      template <typename S> CacheTaylor<T>& operator *= (const S& x);

      template <typename S> CacheTaylor<T>& operator /= (const S& x);


    }; // class CacheTaylor<T>

  } // namespace Tay

} // namespace Sacado

#include "Sacado_Tay_CacheTaylorTraits.hpp"
#include "Sacado_Tay_CacheTaylorImp.hpp"
#include "Sacado_Tay_CacheTaylorOps.hpp"

#endif // SACADO_TAYLOR_CACHETAYLOR_HPP