// @HEADER // ***************************************************************************** // Rapid Optimization Library (ROL) Package // // Copyright 2014 NTESS and the ROL contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER #ifndef ROL_OED_COVARIANCE_OPERATOR_HPP #define ROL_OED_COVARIANCE_OPERATOR_HPP #include "ROL_Ptr.hpp" #include "ROL_SampleGenerator.hpp" #include "ROL_ProbabilityVector.hpp" #include "ROL_ConjugateResiduals.hpp" #include "ROL_UpdateType.hpp" #include "ROL_Types.hpp" #include "ROL_OED_Factors.hpp" #include "ROL_OED_Noise.hpp" #include "ROL_OED_ProfiledClass.hpp" #include namespace ROL { namespace OED { enum RegressionType { LEASTSQUARES = 0, QUANTILE, SUPERQUANTILE, EXPONENTIAL, REGTYPE_LAST }; inline std::string RegressionTypeToString(RegressionType tr) { std::string retString; switch(tr) { case LEASTSQUARES: retString = "Least Squares"; break; case QUANTILE: retString = "Quantile"; break; case SUPERQUANTILE: retString = "Superquantile"; break; case EXPONENTIAL: retString = "Exponential"; break; case REGTYPE_LAST: retString = "Last Type (Dummy)"; break; default: retString = "INVALID RegressionType"; } return retString; } inline int isValidStep(RegressionType ls) { return( (ls == LEASTSQUARES) || (ls == QUANTILE) || (ls == SUPERQUANTILE) ) ; } inline RegressionType & operator++(RegressionType &type) { return type = static_cast(type+1); } inline RegressionType operator++(RegressionType &type, int) { RegressionType oldval = type; ++type; return oldval; } inline RegressionType & operator--(RegressionType &type) { return type = static_cast(type-1); } inline RegressionType operator--(RegressionType &type, int) { RegressionType oldval = type; --type; return oldval; } inline RegressionType StringToRegressionType(std::string s) { s = removeStringFormat(s); for ( RegressionType st = LEASTSQUARES; st < REGTYPE_LAST; ++st ) { if ( !s.compare(removeStringFormat(RegressionTypeToString(st))) ) { return st; } } return REGTYPE_LAST; } template class MomentOperator : public ProfiledClass { private: RegressionType regType_; bool homNoise_; Ptr> noise_; int matNum_; Ptr> sum_; Ptr> krylov_; bool setSolver_; Ptr> pOp_; class moment : public LinearOperator { private: const Ptr> factors_; const Ptr> pOp_; Ptr> sum_; Ptr> p_; public: moment(const Ptr> &factors, const Ptr> &pOp) : factors_(factors), pOp_(pOp) { sum_ = factors_->createParameterVector(true); } void setProbabilityVector(const ProbabilityVector &p) { p_ = makePtrFromRef(p); } void apply(Vector &Mx, const Vector &x, Real &tol) const { int nsamples = factors_->numMySamples(); sum_->zero(); for (int i = 0; i < nsamples; ++i) { factors_->applyProduct(Mx,x,i); sum_->axpy(p_->getProbability(i),Mx); } Mx.zero(); p_->getBatchManager()->sumAll(*sum_,Mx); if (pOp_ != nullPtr) { sum_->zero(); pOp_->apply(*sum_,x,tol); Mx.plus(*sum_); } } }; class precond : public LinearOperator { public: void apply(Vector &Hv, const Vector &v, Real &tol) const { Hv.set(v.dual()); } void applyInverse(Vector &Hv, const Vector &v, Real &tol) const { Hv.set(v.dual()); } }; Ptr M_; Ptr P_; protected: Ptr> factors_; /***************************************************************************/ /* Begin Accessor Functions */ /***************************************************************************/ Real get(const Vector &x, int i) const; void set(Vector &x, int i, Real val) const; std::vector& getLocalDesign(Vector &p) const; const std::vector& getConstLocalDesign(const Vector &p) const; void sumAll(const Vector &p, Real* input, Real* output, int size) const; void applyPerturbation(Vector &Px, const Vector &x) const; /***************************************************************************/ /* End Accessor Functions */ /***************************************************************************/ using ProfiledClass::startTimer; using ProfiledClass::stopTimer; public: virtual ~MomentOperator() {} MomentOperator(RegressionType regType = LEASTSQUARES, bool homNoise = true, const Ptr> &noise = nullPtr); virtual Ptr> clone() const; void setMatrixNumber(int matNum); virtual void update(const Vector &p, UpdateType type, int iter = -1) {} virtual void setFactors(const Ptr> &factors); virtual void setPerturbation(const Ptr> &pOp); // Compute M(p)x where M(p) = p_1 X_1 S_1 X_1' + ... + p_N X_N S_N X_N' virtual void apply(Vector &Mx, const Vector &x, const Vector &p); // Compute M(q)x where M(q) = q_1 X_1 S_1 X_1' + ... + q_N X_N S_N X_N' // This function is distinct from apply to allow the user to store M(p) virtual void applyDeriv(Vector &Mx, const Vector &x, const Vector &q); // Compute inv(M(p))x where M(p) = p_1 X_1 S_1 X_1' + ... + p_N X_N S_N X_N' virtual void applyInverse(Vector &Mx, const Vector &x, const Vector &p); virtual void applySampleMatrices(Vector &uXv, const Vector &u, const Vector &v); void setNoise(const Ptr> &noise, bool isHom = false); Real getNoise(int k) const; void getRegressionInfo(RegressionType ®Type, bool &homNoise, Ptr> &noise) const; virtual Real logDeterminant(const Vector &z); }; // class MomentOperator } // End OED Namespace } // End ROL Namespace #include "ROL_OED_MomentOperator_Def.hpp" #endif