1D1DFunction.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// QUESO - a library to support the Quantification of Uncertainty
// for Estimation, Simulation and Optimization
//
// Copyright (C) 2008-2015 The PECOS Development Team
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Version 2.1 GNU Lesser General
// Public License as published by the Free Software Foundation.
//
// 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. 51 Franklin Street, Fifth Floor,
// Boston, MA  02110-1301  USA
//
//-----------------------------------------------------------------------el-

#ifndef UQ_1D_1D_FUNCTION_H
#define UQ_1D_1D_FUNCTION_H

#include <queso/ScalarSequence.h>
#include <queso/1DQuadrature.h>
#include <queso/Environment.h>
#include <queso/Defines.h>
#include <vector>
#include <math.h>
#include <fstream>

namespace QUESO {

//*****************************************************
// Base 1D->1D class
//*****************************************************

class
Base1D1DFunction {
public:

  Base1D1DFunction(double minDomainValue,
                          double maxDomainValue);

  virtual ~Base1D1DFunction();


  double minDomainValue() const;

  double maxDomainValue() const;

  virtual  double value         (double domainValue) const = 0;

  virtual  double deriv         (double domainValue) const = 0;


  virtual  double multiplyAndIntegrate(const Base1D1DFunction& func, unsigned int quadratureOrder, double* resultWithMultiplicationByTAsWell) const;
protected:
  double m_minDomainValue;
  double m_maxDomainValue;
};

//*****************************************************
// Generic 1D->1D class
//*****************************************************
class Generic1D1DFunction : public Base1D1DFunction {
public:

  Generic1D1DFunction(double minDomainValue,
                             double maxDomainValue,
                             double (*valueRoutinePtr)(double domainValue, const void* routinesDataPtr),
                             double (*derivRoutinePtr)(double domainValue, const void* routinesDataPtr),
                             const void* routinesDataPtr);
  ~Generic1D1DFunction();



  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  double (*m_valueRoutinePtr)(double domainValue, const void* routinesDataPtr);
  double (*m_derivRoutinePtr)(double domainValue, const void* routinesDataPtr);
  const void* m_routinesDataPtr;
};

//*****************************************************
// Constant 1D->1D class
//*****************************************************
class Constant1D1DFunction : public Base1D1DFunction {
public:

  Constant1D1DFunction(double minDomainValue,
                              double maxDomainValue,
                              double constantValue);
  ~Constant1D1DFunction();



  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  double m_constantValue;
};

//*****************************************************
// Linear 1D->1D class
//*****************************************************
class Linear1D1DFunction : public Base1D1DFunction {
public:


  Linear1D1DFunction(double minDomainValue,
                            double maxDomainValue,
                            double referenceDomainValue,
                            double referenceImageValue,
                            double rateValue);
  ~Linear1D1DFunction();



  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  double m_referenceDomainValue;

  double m_referenceImageValue;

  double m_rateValue;
};

//*****************************************************
// PiecewiseLinear 1D->1D class
//*****************************************************
class PiecewiseLinear1D1DFunction : public Base1D1DFunction {
public:

  PiecewiseLinear1D1DFunction(double                     minDomainValue,
                                     double                     maxDomainValue,
                                     const std::vector<double>& referenceDomainValues,
                                     double                     referenceImageValue0,
                                     const std::vector<double>& rateValues);
  ~PiecewiseLinear1D1DFunction();



  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  unsigned int        m_numRefValues;

  std::vector<double> m_referenceDomainValues;

  std::vector<double> m_referenceImageValues;

  std::vector<double> m_rateValues;
};

//*****************************************************
// Quadratic 1D->1D class
//*****************************************************
class Quadratic1D1DFunction : public Base1D1DFunction {
public:


  Quadratic1D1DFunction(double minDomainValue,
                               double maxDomainValue,
                               double a,
                               double b,
                               double c);
  ~Quadratic1D1DFunction();



  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  double m_a;

  double m_b;

  double m_c;
};

//*****************************************************
// Sampled 1D->1D class
//*****************************************************
class Sampled1D1DFunction : public Base1D1DFunction {
public:

  Sampled1D1DFunction();


  Sampled1D1DFunction(const std::vector<double>& domainValues,
                             const std::vector<double>& imageValues);

  virtual ~Sampled1D1DFunction();



  virtual double       value(double domainValue) const;


  double               deriv(double domainValue) const;

  const   std::vector<double>& domainValues() const;

  const   std::vector<double>& imageValues () const;

  bool    domainValueMatchesExactly(double domainValue) const;

  void    set(const std::vector<double>& domainValues,
              const std::vector<double>& imageValues);


  virtual void                 printForMatlab(const BaseEnvironment& env, std::ofstream& ofsvar, const std::string& prefixName) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  std::vector<double> m_domainValues;

  std::vector<double> m_imageValues;
};

//*****************************************************
// 'ScalarTimesFunc' 1D->1D class
//*****************************************************
class ScalarTimesFunc1D1DFunction : public Base1D1DFunction {
public:

  ScalarTimesFunc1D1DFunction(double scalar,
                                     const Base1D1DFunction& func);

  ~ScalarTimesFunc1D1DFunction();



  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  double m_scalar;
  const Base1D1DFunction& m_func;
};

//*****************************************************
// 'FuncTimesFunc' 1D->1D class
//*****************************************************
class FuncTimesFunc1D1DFunction : public Base1D1DFunction {
public:

  FuncTimesFunc1D1DFunction(const Base1D1DFunction& func1,
                                   const Base1D1DFunction& func2);

  ~FuncTimesFunc1D1DFunction();



  double value(double domainValue) const;


  double deriv(double domainValue) const;

protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  const Base1D1DFunction& m_func1;
  const Base1D1DFunction& m_func2;
};

//*****************************************************
// 'FuncPlusFunc' 1D->1D class
//*****************************************************
class FuncPlusFunc1D1DFunction : public Base1D1DFunction {
public:

  FuncPlusFunc1D1DFunction(const Base1D1DFunction& func1,
                                  const Base1D1DFunction& func2);

  ~FuncPlusFunc1D1DFunction();



  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  const Base1D1DFunction& m_func1;
  const Base1D1DFunction& m_func2;
};
//*****************************************************
// Lagrange Polynomial 1D->1D class
//*****************************************************
class LagrangePolynomial1D1DFunction : public Base1D1DFunction {
public:

  LagrangePolynomial1D1DFunction(const std::vector<double>& positionValues,
                                        const std::vector<double>* functionValues);

  ~LagrangePolynomial1D1DFunction();


  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  std::vector<double> m_positionValues;
  std::vector<double> m_functionValues;
};

//*****************************************************
// Lagrange Basis 1D->1D class
//*****************************************************
class LagrangeBasis1D1DFunction : public Base1D1DFunction {
public:

  LagrangeBasis1D1DFunction(const std::vector<double>& positionValues,
                                   unsigned int basisIndex);

  ~LagrangeBasis1D1DFunction();


  double value(double domainValue) const;


  double deriv(double domainValue) const;
protected:
  using Base1D1DFunction::m_minDomainValue;
  using Base1D1DFunction::m_maxDomainValue;

  std::vector<double> m_positionValues;
  unsigned int        m_basisIndex;
};

//----------------------------------------------------------------------

template <class T>
double SubF1F2Gaussian2dKdeIntegral(const ScalarSequence<T>& scalarSeq1,
    const ScalarSequence<T>& scalarSeq2, unsigned int initialPos,
    double scaleValue1, double scaleValue2, const Base1D1DFunction& func1,
    const Base1D1DFunction& func2, unsigned int quadratureOrder);

}  // End namespace QUESO

#endif // UQ_1D_1D_FUNCTION_H