Sacado_PCE_Hermite.hpp

Go to the documentation of this file.

// $Id: Sacado_PCE_Hermite.hpp,v 1.2 2008/01/22 17:56:14 etphipp Exp $ 
// $Source: /space/CVS/Trilinos/packages/sacado/src/pce/Sacado_PCE_Hermite.hpp,v $ 
// @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_PCE_HERMITE_HPP
#define SACADO_PCE_HERMITE_HPP

#include "Sacado_Handle.hpp"
#include "Sacado_PCE_HermiteBasis.hpp"
#include "Sacado_PCE_HermiteEBasis.hpp"
#include "Sacado_PCE_UnitHermiteBasis.hpp"
#include "Sacado_PCE_Workspace.hpp"

#include <cmath>
#include <algorithm>  // for std::min and std::max
#include <ostream>  // for std::ostream

namespace Sacado {

  namespace PCE {


    template <typename T> 
    class Hermite {
    public:

      typedef T value_type;

      Hermite();


      Hermite(const T& x);


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


      Hermite(unsigned int d);

      Hermite(const Hermite& x);

      ~Hermite();


      void resize(unsigned int d, bool keep_coeffs);


      void reserve(unsigned int d);


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


      static void initWorkspace(unsigned int d);

      StandardPoly<T> toStandardBasis() const;


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

      Hermite<T>& operator=(const Hermite<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];}

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


      Hermite<T> operator + () const;

      Hermite<T> operator - () const;

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

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

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

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

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

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

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


    protected:

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

      void resizeCoeffs(unsigned int len);

    protected:

      struct HermiteData {

  T* coeff_;

  unsigned int deg_;

  unsigned int len_;

  HermiteData();

  HermiteData(const T& x);

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

  HermiteData(unsigned int d);

  HermiteData(unsigned int d, unsigned int l);

  HermiteData(const HermiteData& x);

  ~HermiteData();

  HermiteData& operator=(const HermiteData& x);

      };

      Sacado::Handle<HermiteData> th;

    public:

      typedef Workspace< HermiteEBasis<T> > ws_type;

      static ws_type workspace;

    }; // class Hermite

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

  } // namespace PCE

} // namespace Sacado

#include "Sacado_PCE_HermiteTraits.hpp"
#include "Sacado_PCE_HermiteImp.hpp"

#endif // SACADO_PCE_HERMITE_HPP

---