Sacado_Tay_Taylor.hpp

Go to the documentation of this file.

// $Id$ 
// $Source$ 
// @HEADER
// ***********************************************************************
// 
//                           Sacado Package
//                 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.
// 
// 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_TAYLOR_HPP
#define SACADO_TAY_TAYLOR_HPP

#include "Sacado_Handle.hpp"
#include <cmath>
#include <algorithm>  // for std::min and std::max
#include <ostream>  // for std::ostream
#include "Sacado_dummy_arg.hpp"

namespace Sacado {

  namespace Tay {


    template <typename T> 
    class Taylor {
    public:

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

      typedef T value_type;

      typedef typename ScalarType<value_type>::type scalar_type;

      Taylor();


      Taylor(const T& x);


      Taylor(const typename dummy<value_type,scalar_type>::type& x);


      Taylor(unsigned int d, const T & x);


      Taylor(unsigned int d);

      Taylor(const Taylor& x);

      ~Taylor();


      void resize(unsigned int d, bool keep_coeffs);


      void reserve(unsigned int d);


      void copyForWrite() { th.makeOwnCopy(); }

      bool isEqualTo(const Taylor& 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;
      }


      Taylor<T>& operator=(const T& val);


      Taylor<T>& operator=(const typename dummy<value_type,scalar_type>::type& val);

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



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

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



      unsigned int degree() const { return th->deg_;}

      bool hasFastAccess(unsigned int d) const { return th->deg_>=d;}

      const T* coeff() const { return th->coeff_;}

      T* coeff() { return th->coeff_;}

      T coeff(unsigned int i) const { 
  T tmp= i<=th->deg_ ? th->coeff_[i]:T(0.); return tmp;}
    
      T& fastAccessCoeff(unsigned int i) { return th->coeff_[i];}

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


      Taylor<T> operator + () const;

      Taylor<T> operator - () const;

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

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

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

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

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

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

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


    protected:

      unsigned int length() const { return th->len_; }

      void resizeCoeffs(unsigned int len);

    protected:

      struct TaylorData {

  T* coeff_;

  unsigned int deg_;

  unsigned int len_;

  TaylorData();

  TaylorData(const T& x);

  TaylorData(unsigned int d, const T & x);

  TaylorData(unsigned int d);

  TaylorData(unsigned int d, unsigned int l);

  TaylorData(const TaylorData& x);

  ~TaylorData();

  TaylorData& operator=(const TaylorData& x);

      };

      Sacado::Handle<TaylorData> th;

    }; // class Taylor

    // Operations
    template <typename T> Taylor<T> operator+(const Taylor<T>& a,
                const Taylor<T>& b);
    template <typename T> Taylor<T> operator+(const T& a, 
                const Taylor<T>& b);
    template <typename T> Taylor<T> operator+(const Taylor<T>& a, 
                const T& b);
    template <typename T> Taylor<T> operator-(const Taylor<T>& a, 
                const Taylor<T>& b);
    template <typename T> Taylor<T> operator-(const T& a, 
                const Taylor<T>& b);
    template <typename T> Taylor<T> operator-(const Taylor<T>& a, 
                const T& b);
    template <typename T> Taylor<T> operator*(const Taylor<T>& a, 
                const Taylor<T>& b);
    template <typename T> Taylor<T> operator*(const T& a, 
                const Taylor<T>& b);
    template <typename T> Taylor<T> operator*(const Taylor<T>& a, 
                const T& b);
    template <typename T> Taylor<T> operator/(const Taylor<T>& a, 
                const Taylor<T>& b);
    template <typename T> Taylor<T> operator/(const T& a, 
                const Taylor<T>& b);
    template <typename T> Taylor<T> operator/(const Taylor<T>& a, 
                const T& b);
    template <typename T> Taylor<T> exp(const Taylor<T>& a);
    template <typename T> Taylor<T> log(const Taylor<T>& a);
    template <typename T> Taylor<T> log10(const Taylor<T>& a);
    template <typename T> Taylor<T> sqrt(const Taylor<T>& a);
    template <typename T> Taylor<T> pow(const Taylor<T>& a, 
          const Taylor<T>& b);
    template <typename T> Taylor<T> pow(const T& a,
          const Taylor<T>& b);
    template <typename T> Taylor<T> pow(const Taylor<T>& a,
          const T& b);
    template <typename T> void sincos(const Taylor<T>& a,
              Taylor<T>& s, Taylor<T>& c);
    template <typename T> Taylor<T> cos(const Taylor<T>& a);
    template <typename T> Taylor<T> sin(const Taylor<T>& a);
    template <typename T> Taylor<T> tan(const Taylor<T>& a);
    template <typename T> void sinhcosh(const Taylor<T>& a,
          Taylor<T>& s, Taylor<T>& c);
    template <typename T> Taylor<T> cosh(const Taylor<T>& a);
    template <typename T> Taylor<T> sinh(const Taylor<T>& a);
    template <typename T> Taylor<T> tanh(const Taylor<T>& a);
    template <typename T> Taylor<T> quad(const T& c0,
           const Taylor<T>& a,
           const Taylor<T>& b);
    template <typename T> Taylor<T> acos(const Taylor<T>& a);
    template <typename T> Taylor<T> asin(const Taylor<T>& a);
    template <typename T> Taylor<T> atan(const Taylor<T>& a);
    template <typename T> Taylor<T> atan2(const Taylor<T>& a,
            const Taylor<T>& b);
    template <typename T> Taylor<T> atan2(const T& a,
            const Taylor<T>& b);
    template <typename T> Taylor<T> atan2(const Taylor<T>& a,
            const T& b);
    template <typename T> Taylor<T> acosh(const Taylor<T>& a);
    template <typename T> Taylor<T> asinh(const Taylor<T>& a);
    template <typename T> Taylor<T> atanh(const Taylor<T>& a);
    template <typename T> Taylor<T> abs(const Taylor<T>& a);
    template <typename T> Taylor<T> fabs(const Taylor<T>& a);
    template <typename T> Taylor<T> max(const Taylor<T>& a,
          const Taylor<T>& b);
    template <typename T> Taylor<T> max(const T& a,
          const Taylor<T>& b);
    template <typename T> Taylor<T> max(const Taylor<T>& a,
          const T& b);
    template <typename T> Taylor<T> min(const Taylor<T>& a,
          const Taylor<T>& b);
    template <typename T> Taylor<T> min(const T& a,
          const Taylor<T>& b);
    template <typename T> Taylor<T> min(const Taylor<T>& a,
          const T& b);
    template <typename T> bool operator==(const Taylor<T>& a,
            const Taylor<T>& b);
    template <typename T> bool operator==(const T& a,
            const Taylor<T>& b);
    template <typename T> bool operator==(const Taylor<T>& a,
            const T& b);
    template <typename T> bool operator!=(const Taylor<T>& a,
            const Taylor<T>& b);
    template <typename T> bool operator!=(const T& a,
            const Taylor<T>& b);
    template <typename T> bool operator!=(const Taylor<T>& a,
            const T& b);
    template <typename T> bool operator<=(const Taylor<T>& a,
            const Taylor<T>& b);
    template <typename T> bool operator<=(const T& a,
            const Taylor<T>& b);
    template <typename T> bool operator<=(const Taylor<T>& a,
            const T& b);
    template <typename T> bool operator>=(const Taylor<T>& a,
            const Taylor<T>& b);
    template <typename T> bool operator>=(const T& a,
            const Taylor<T>& b);
    template <typename T> bool operator>=(const Taylor<T>& a,
            const T& b);
    template <typename T> bool operator<(const Taylor<T>& a,
           const Taylor<T>& b);
    template <typename T> bool operator<(const T& a,
           const Taylor<T>& b);
    template <typename T> bool operator<(const Taylor<T>& a,
           const T& b);
    template <typename T> bool operator>(const Taylor<T>& a,
           const Taylor<T>& b);
    template <typename T> bool operator>(const T& a,
           const Taylor<T>& b);
    template <typename T> bool operator>(const Taylor<T>& a,
           const T& b);
    template <typename T> std::ostream& operator << (std::ostream& os,
                 const Taylor<T>& a);

  } // namespace Tay

} // namespace Sacado

#include "Sacado_Tay_TaylorTraits.hpp"
#include "Sacado_Tay_TaylorImp.hpp"

#endif // SACADO_TAY_TAYLOR_HPP