Sacado_Tay_CacheTaylor.hpp

Go to the documentation of this file.

// $Id$ 
// $Source$ 
// @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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// 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 {


    template <typename T> 
    class CacheTaylorImplementation {

    public:

      typedef T value_type;

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


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


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

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

      ~CacheTaylorImplementation() {}


      void resize(unsigned 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];}



      unsigned int degree() const { return coeff_.size()-1;}

      bool hasFastAccess(unsigned int d) const { return coeff_.size()>=d+1;}

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

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

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

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

      void allocateCache(unsigned 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 (unsigned int i=0; i<=this->degree(); i++)
    eq = eq && IE::eval(x.coeff(i), this->coeff(i));
  return eq;
      }
    

    protected:

      void resizeCoeffs(unsigned int dnew) {
  std::valarray<T> tmp = coeff_;
  unsigned 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;
  }
      }

    protected:

      std::valarray<T> coeff_;

    }; // class CacheTaylorImplementation


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

    public:

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


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


      Expr(unsigned 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(unsigned 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