// @HEADER // ***************************************************************************** // Stokhos Package // // Copyright 2009 NTESS and the Stokhos contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER #ifndef SACADO_PCE_ORTHOGPOLY_HPP #define SACADO_PCE_ORTHOGPOLY_HPP #include "Stokhos_ConfigDefs.h" #ifdef HAVE_STOKHOS_SACADO #include "Teuchos_RCP.hpp" #include "Sacado_Traits.hpp" #include "Sacado_Handle.hpp" #include "Sacado_mpl_apply.hpp" #include "Stokhos_OrthogPolyExpansion.hpp" #include "Stokhos_OrthogPolyApprox.hpp" #include "Stokhos_ConstantOrthogPolyExpansion.hpp" #include #include // for std::min and std::max #include // for std::ostream namespace Sacado { //! Namespace for polynomial chaos expansion classes namespace PCE { //! Generalized polynomial chaos expansion class /*! * Uses a handle and a "copy-on-write" strategy for efficient copying, but * no expression templating. */ template class OrthogPoly { public: //! Typename of values typedef T value_type; //! Typename of scalar's (which may be different from T) typedef typename ScalarType::type scalar_type; //! Typename of ordinals typedef int ordinal_type; //! Typename of storage class typedef Storage storage_type; //! Basis type typedef Stokhos::OrthogPolyBasis basis_type; //! Expansion type typedef Stokhos::OrthogPolyExpansion expansion_type; //! Stokhos approximation type typedef Stokhos::OrthogPolyApprox approx_type; typedef typename approx_type::pointer pointer; typedef typename approx_type::const_pointer const_pointer; typedef typename approx_type::reference reference; typedef typename approx_type::const_reference const_reference; //! Turn OrthogPoly into a meta-function class usable with mpl::apply template struct apply { typedef typename Sacado::mpl::apply::type storage_type; typedef OrthogPoly type; }; //! Default constructor /*! * Sets size to 1 and first coefficient to 0 (represents a constant). */ OrthogPoly(); //! Constructor with supplied value \c x /*! * Sets size to 1 and first coefficient to x (represents a constant). */ OrthogPoly(const value_type& x); //! Constructor with expansion \c expansion (General case) /*! * Creates array of correct size and initializes coeffiencts to 0. */ OrthogPoly(const Teuchos::RCP& expansion); //! Constructor with expansion \c expansion and specified size \c sz /*! * Creates array of size \c sz and initializes coeffiencts to 0. */ OrthogPoly(const Teuchos::RCP& expansion, ordinal_type sz); //! Copy constructor OrthogPoly(const OrthogPoly& x); //! Destructor ~OrthogPoly(); //! Initialize coefficients to value void init(const T& v) { th->init(v); } //! Initialize coefficients to an array of values void init(const T* v) { th->init(v); } //! Initialize coefficients from an OrthogPoly with different storage template void init(const OrthogPoly& v) { th->init(v.getOrthogPolyApprox()); } //! Load coefficients to an array of values void load(T* v) { th->load(v); } //! Load coefficients into an OrthogPoly with different storage template void load(OrthogPoly& v) { th->load(v.getOrthogPolyApprox()); } //! Reset expansion /*! * May change size of array. Coefficients are preserved. */ void reset(const Teuchos::RCP& expansion); //! Reset expansion and size /*! * Coefficients are preserved. */ void reset(const Teuchos::RCP& expansion, ordinal_type sz); //! Prepare polynomial for writing /*! * This method prepares the polynomial for writing through coeff() and * fastAccessCoeff() member functions. It ensures the handle for the * %Hermite coefficients is not shared among any other %Hermite polynomial * objects. If the handle is not shared it does nothing, so there * is no cost in calling this method in this case. If the handle is * shared and this method is not called, any changes to the coefficients * by coeff() or fastAccessCoeff() may change other polynomial objects. */ void copyForWrite() { th.makeOwnCopy(); } //! Evaluate polynomial approximation at a point value_type evaluate(const Teuchos::Array& point) const; //! Evaluate polynomial approximation at a point with given basis values value_type evaluate(const Teuchos::Array& point, const Teuchos::Array& bvals) const; //! Compute mean of expansion value_type mean() const {return th->mean(); } //! Compute standard deviation of expansion value_type standard_deviation() const { return th->standard_deviation(); } //! Compute the two-norm of expansion value_type two_norm() const { return th->two_norm(); } //! Compute the squared two-norm of expansion value_type two_norm_squared() const { return th->two_norm_squared(); } //! Compute the L2 inner product of 2 PCEs value_type inner_product(const OrthogPoly& b) const { return th->inner_product(b.getOrthogPolyApprox()); } //! Print approximation in basis std::ostream& print(std::ostream& os) const { return th->print(os); } //! Returns whether two PCE objects have the same values bool isEqualTo(const OrthogPoly& x) const; /*! * @name Assignment operators */ //@{ //! Assignment operator with constant right-hand-side OrthogPoly& operator=(const value_type& val); //! Assignment with OrthogPoly right-hand-side OrthogPoly& operator=(const OrthogPoly& x); //@} /*! * Accessor methods */ //@{ //! Get basis Teuchos::RCP basis() const { return th->basis(); } //! Get expansion Teuchos::RCP expansion() const { return expansion_; } //@} /*! * @name Value accessor methods */ //@{ //! Returns value const_reference val() const { return (*th)[0]; } //! Returns value reference val() { return (*th)[0]; } //@} /*! * @name Coefficient accessor methods */ //@{ //! Returns size of polynomial ordinal_type size() const { return th->size();} //! Returns true if polynomial has size >= sz bool hasFastAccess(ordinal_type sz) const { return th->size()>=sz;} //! Returns Hermite coefficient array const_pointer coeff() const { return th->coeff();} //! Returns Hermite coefficient array pointer coeff() { return th->coeff();} //! Returns degree \c i term with bounds checking value_type coeff(ordinal_type i) const { value_type tmp= isize() ? (*th)[i]:value_type(0.); return tmp;} //! Returns degree \c i term without bounds checking reference fastAccessCoeff(ordinal_type i) { return (*th)[i];} //! Returns degree \c i term without bounds checking value_type fastAccessCoeff(ordinal_type i) const { return (*th)[i];} //! Get coefficient term for given dimension and order reference term(ordinal_type dimension, ordinal_type order) { return th->term(dimension, order); } //! Get coefficient term for given dimension and order const_reference term(ordinal_type dimension, ordinal_type order) const { return th->term(dimension, order); } //! Get orders for a given term Teuchos::Array order(ordinal_type term) const { return th->order(term); } //@} /*! * @name Unary operators */ //@{ //! Unary-plus operator OrthogPoly operator + () const; //! Unary-minus operator OrthogPoly operator - () const; //! Addition-assignment operator with constant right-hand-side OrthogPoly& operator += (const value_type& x); //! Subtraction-assignment operator with constant right-hand-side OrthogPoly& operator -= (const value_type& x); //! Multiplication-assignment operator with constant right-hand-side OrthogPoly& operator *= (const value_type& x); //! Division-assignment operator with constant right-hand-side OrthogPoly& operator /= (const value_type& x); //! Addition-assignment operator with Hermite right-hand-side OrthogPoly& operator += (const OrthogPoly& x); //! Subtraction-assignment operator with Hermite right-hand-side OrthogPoly& operator -= (const OrthogPoly& x); //! Multiplication-assignment operator with Hermite right-hand-side OrthogPoly& operator *= (const OrthogPoly& x); //! Division-assignment operator with Hermite right-hand-side OrthogPoly& operator /= (const OrthogPoly& x); //@} //! Get underlying Stokhos::OrthogPolyApprox const approx_type& getOrthogPolyApprox() const { return *th; } //! Get underlying Stokhos::OrthogPolyApprox approx_type& getOrthogPolyApprox() { return *th; } protected: //! Expansion class Teuchos::RCP expansion_; //! Constant expansion class for constants Teuchos::RCP const_expansion_; Sacado::Handle< Stokhos::OrthogPolyApprox > th; }; // class Hermite // Operations template OrthogPoly operator+(const OrthogPoly& a, const OrthogPoly& b); template OrthogPoly operator+(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template OrthogPoly operator+(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template OrthogPoly operator-(const OrthogPoly& a, const OrthogPoly& b); template OrthogPoly operator-(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template OrthogPoly operator-(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template OrthogPoly operator*(const OrthogPoly& a, const OrthogPoly& b); template OrthogPoly operator*(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template OrthogPoly operator*(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template OrthogPoly operator/(const OrthogPoly& a, const OrthogPoly& b); template OrthogPoly operator/(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template OrthogPoly operator/(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template OrthogPoly exp(const OrthogPoly& a); template OrthogPoly log(const OrthogPoly& a); template void log(OrthogPoly& c, const OrthogPoly& a); template OrthogPoly log10(const OrthogPoly& a); template OrthogPoly sqrt(const OrthogPoly& a); template OrthogPoly cbrt(const OrthogPoly& a); template OrthogPoly pow(const OrthogPoly& a, const OrthogPoly& b); template OrthogPoly pow(const T& a, const OrthogPoly& b); template OrthogPoly pow(const OrthogPoly& a, const T& b); template OrthogPoly cos(const OrthogPoly& a); template OrthogPoly sin(const OrthogPoly& a); template OrthogPoly tan(const OrthogPoly& a); template OrthogPoly cosh(const OrthogPoly& a); template OrthogPoly sinh(const OrthogPoly& a); template OrthogPoly tanh(const OrthogPoly& a); template OrthogPoly acos(const OrthogPoly& a); template OrthogPoly asin(const OrthogPoly& a); template OrthogPoly atan(const OrthogPoly& a); template OrthogPoly atan2(const OrthogPoly& a, const OrthogPoly& b); template OrthogPoly atan2(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template OrthogPoly atan2(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template OrthogPoly acosh(const OrthogPoly& a); template OrthogPoly asinh(const OrthogPoly& a); template OrthogPoly atanh(const OrthogPoly& a); template OrthogPoly abs(const OrthogPoly& a); template OrthogPoly fabs(const OrthogPoly& a); template OrthogPoly max(const OrthogPoly& a, const OrthogPoly& b); template OrthogPoly max(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template OrthogPoly max(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template OrthogPoly min(const OrthogPoly& a, const OrthogPoly& b); template OrthogPoly min(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template OrthogPoly min(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template bool operator==(const OrthogPoly& a, const OrthogPoly& b); template bool operator==(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template bool operator==(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template bool operator!=(const OrthogPoly& a, const OrthogPoly& b); template bool operator!=(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template bool operator!=(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template bool operator<=(const OrthogPoly& a, const OrthogPoly& b); template bool operator<=(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template bool operator<=(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template bool operator>=(const OrthogPoly& a, const OrthogPoly& b); template bool operator>=(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template bool operator>=(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template bool operator<(const OrthogPoly& a, const OrthogPoly& b); template bool operator<(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template bool operator<(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template bool operator>(const OrthogPoly& a, const OrthogPoly& b); template bool operator>(const typename OrthogPoly::value_type& a, const OrthogPoly& b); template bool operator>(const OrthogPoly& a, const typename OrthogPoly::value_type& b); template std::ostream& operator << (std::ostream& os, const OrthogPoly& a); template std::istream& operator >> (std::istream& os, OrthogPoly& a); } // namespace PCE } // namespace Sacado #include "Sacado_PCE_OrthogPolyTraits.hpp" #include "Sacado_PCE_OrthogPolyImp.hpp" #endif // HAVE_STOKHOS_SACADO #endif // SACADO_PCE_ORTHOGPOLY_HPP