QUESO::PiecewiseLinear1D1DFunction Class Reference

Class for piecewise-linear one-dimensional functions. More...

#include <1D1DFunction.h>

Inheritance diagram for QUESO::PiecewiseLinear1D1DFunction:

Public Member Functions
Constructor/Destructor methods
	PiecewiseLinear1D1DFunction (double minDomainValue, double maxDomainValue, const std::vector< double > &referenceDomainValues, double referenceImageValue0, const std::vector< double > &rateValues)
	Default constructor. More...
	~PiecewiseLinear1D1DFunction ()
	Destructor. More...
Mathematical methods
double	value (double domainValue) const
	Returns the value of the piecewise-linear function at point domainValue. More...
double	deriv (double domainValue) const
	Returns the value of the derivative of the piecewise-linear function at point domainValue. More...
Public Member Functions inherited from QUESO::Base1D1DFunction
	Base1D1DFunction (double minDomainValue, double maxDomainValue)
	Default constructor. More...
virtual	~Base1D1DFunction ()
	Destructor. More...
double	minDomainValue () const
	Returns the minimum value of the domain of the (one-dimensional) function. More...
double	maxDomainValue () const
	Returns the maximum value of the domain of the (one-dimensional) function. More...
virtual double	multiplyAndIntegrate (const Base1D1DFunction &func, unsigned int quadratureOrder, double *resultWithMultiplicationByTAsWell) const
	TODO: Multiplies this function with function, and integrates it numerically. See template specialization. More...

Protected Attributes
unsigned int	m_numRefValues
	Number of points which will be evaluated. More...
std::vector< double >	m_referenceDomainValues
	Reference values in the piecewise-linear function domain; \( x_1i \) in \( f_i(x) = y_{1i} + m_i (x - x_{1i})\), for each \( i \)=1 .. m_numRefValues. More...
std::vector< double >	m_referenceImageValues
	Reference values in the piecewise-linear function image; \( y_{1i} \) in \( f_i(x) = y_{1i} + m_i (x - x_{1i})\), for each \( i \)=1 .. m_numRefValues. More...
std::vector< double >	m_rateValues
	Rate value; \( m_i \) in \( f_i(x) = y_{1i} + m_i (x - x_{1i})\), for each \( i \)=1 .. m_numRefValues. More...
Protected Attributes inherited from QUESO::Base1D1DFunction
double	m_minDomainValue
double	m_maxDomainValue

Detailed Description

Class for piecewise-linear one-dimensional functions.

This class implements piecewise-linear one-dimensional functions.

Definition at line 237 of file 1D1DFunction.h.

Constructor & Destructor Documentation

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

Default constructor.

Definition at line 239 of file 1D1DFunction.C.

References m_numRefValues, m_rateValues, m_referenceDomainValues, m_referenceImageValues, QUESO::queso_require_equal_to_msg, and QUESO::queso_require_not_equal_to_msg.

  :
  Base1D1DFunction(minDomainValue,maxDomainValue),
  m_numRefValues         (referenceDomainValues.size()),
  m_referenceDomainValues(referenceDomainValues),
  m_rateValues           (rateValues)
{
  queso_require_not_equal_to_msg(m_numRefValues, 0, "num ref values = 0");

  queso_require_equal_to_msg(m_numRefValues, rateValues.size(), "num rate values is inconsistent");

  for (unsigned int i = 1; i < m_numRefValues; ++i) { // Yes, from '1'
    queso_require_greater_msg(m_referenceDomainValues[i], m_referenceDomainValues[i-1], "reference domain values are inconsistent");
  }

  m_referenceImageValues.clear();
  m_referenceImageValues.resize(m_numRefValues,0.);
  m_referenceImageValues[0] = referenceImageValue0;
  for (unsigned int i = 1; i < m_numRefValues; ++i) { // Yes, from '1'
    m_referenceImageValues[i] = m_referenceImageValues[i-1] + m_rateValues[i-1]*(m_referenceDomainValues[i] - m_referenceDomainValues[i-1]);
  }

  if (false) { // For debug only
    std::cout << "In PiecewiseLinear1D1DFunction::constructor():"
              << std::endl;
    for (unsigned int i = 0; i < m_numRefValues; ++i) {
      std::cout << "i = " << i
                << ", m_referenceDomainValues[i] = " << m_referenceDomainValues[i]
                << ", m_referenceImageValues[i] = "  << m_referenceImageValues[i]
                << ", m_rateValues[i] = "            << m_rateValues[i]
                << std::endl;
    }
  }
}

QUESO::PiecewiseLinear1D1DFunction::~PiecewiseLinear1D1DFunction

(

)

Destructor.

Definition at line 279 of file 1D1DFunction.C.

References m_rateValues, m_referenceDomainValues, and m_referenceImageValues.

{
  m_rateValues.clear();
  m_referenceImageValues.clear();
  m_referenceDomainValues.clear();
}

Member Function Documentation

double QUESO::PiecewiseLinear1D1DFunction::deriv ( double  domainValue ) const

virtual

Returns the value of the derivative of the piecewise-linear function at point domainValue.

This function checks if point domainValue belongs to the domain of this function, and in affirmative case, it returns the value of the derivative at such point.

Implements QUESO::Base1D1DFunction.

Definition at line 334 of file 1D1DFunction.C.

References QUESO::Base1D1DFunction::m_maxDomainValue, QUESO::Base1D1DFunction::m_minDomainValue, m_numRefValues, m_rateValues, and m_referenceDomainValues.

{
  if ((domainValue < m_minDomainValue) || (domainValue > m_maxDomainValue)) {
    std::cerr << "In PiecewiseLinear1D1DFunction::deriv()"
              << ": requested x ("            << domainValue
              << ") is out of the interval (" << m_minDomainValue
              << ", "                         << m_maxDomainValue
              << ")"
              << std::endl;
  }

  queso_require_msg(!((domainValue < m_minDomainValue) || (domainValue > m_maxDomainValue)), "x out of range");

  unsigned int i = 0;
  if (m_numRefValues == 1) {
    // Nothing else to do
  }
  else {
    bool referenceDomainValueFound = false;
    while (referenceDomainValueFound == false) {
      if (domainValue < m_referenceDomainValues[i+1]) {
        referenceDomainValueFound = true;
      }
      else {
        ++i;
        queso_require_less_equal_msg(i, m_numRefValues, "too big 'i'");
      }
    }
  }

  return m_rateValues[i];
}

double QUESO::PiecewiseLinear1D1DFunction::value ( double  domainValue ) const

virtual

Returns the value of the piecewise-linear function at point domainValue.

This function checks if point domainValue belongs to the domain of this function, and in affirmative case, it evaluates the function at such point.

Implements QUESO::Base1D1DFunction.

Definition at line 287 of file 1D1DFunction.C.

References QUESO::Base1D1DFunction::m_maxDomainValue, QUESO::Base1D1DFunction::m_minDomainValue, m_numRefValues, m_rateValues, m_referenceDomainValues, and m_referenceImageValues.

{
  if ((domainValue < m_minDomainValue) || (domainValue > m_maxDomainValue)) {
    std::cerr << "In PiecewiseLinear1D1DFunction::value()"
              << ": requested x ("            << domainValue
              << ") is out of the interval (" << m_minDomainValue
              << ", "                         << m_maxDomainValue
              << ")"
              << std::endl;
  }

  queso_require_msg(!((domainValue < m_minDomainValue) || (domainValue > m_maxDomainValue)), "x out of range");

  unsigned int i = 0;
  if (m_numRefValues == 1) {
    // Nothing else to do
  }
  else {
    bool referenceDomainValueFound = false;
    while (referenceDomainValueFound == false) {
      if (domainValue < m_referenceDomainValues[i+1]) {
        referenceDomainValueFound = true;
      }
      else {
        ++i;
        if (i == (m_numRefValues-1)) {
          referenceDomainValueFound = true;
        }
      }
    }
  }
  double imageValue = m_referenceImageValues[i] + m_rateValues[i]*(domainValue - m_referenceDomainValues[i]);
  if (false) { // For debug only
    std::cout << "In PiecewiseLinear1D1DFunction::value()"
              << ": domainValue = "                << domainValue
              << ", i = "                          << i
              << ", m_referenceDomainValues[i] = " << m_referenceDomainValues[i]
              << ", m_referenceImageValues[i] = "  << m_referenceImageValues[i]
              << ", m_rateValues[i] = "            << m_rateValues[i]
              << ", imageValue = "                 << imageValue
              << std::endl;
  }

  return imageValue;
}

Member Data Documentation

unsigned int QUESO::PiecewiseLinear1D1DFunction::m_numRefValues

protected

Number of points which will be evaluated.

Definition at line 268 of file 1D1DFunction.h.

Referenced by deriv(), PiecewiseLinear1D1DFunction(), and value().

std::vector<double> QUESO::PiecewiseLinear1D1DFunction::m_rateValues

protected

Rate value; \( m_i \) in \( f_i(x) = y_{1i} + m_i (x - x_{1i})\), for each \( i \)=1 .. m_numRefValues.

Definition at line 277 of file 1D1DFunction.h.

Referenced by deriv(), PiecewiseLinear1D1DFunction(), value(), and ~PiecewiseLinear1D1DFunction().

std::vector<double> QUESO::PiecewiseLinear1D1DFunction::m_referenceDomainValues

protected

Reference values in the piecewise-linear function domain; \( x_1i \) in \( f_i(x) = y_{1i} + m_i (x - x_{1i})\), for each \( i \)=1 .. m_numRefValues.

Definition at line 271 of file 1D1DFunction.h.

Referenced by deriv(), PiecewiseLinear1D1DFunction(), value(), and ~PiecewiseLinear1D1DFunction().

std::vector<double> QUESO::PiecewiseLinear1D1DFunction::m_referenceImageValues

protected

Reference values in the piecewise-linear function image; \( y_{1i} \) in \( f_i(x) = y_{1i} + m_i (x - x_{1i})\), for each \( i \)=1 .. m_numRefValues.

Definition at line 274 of file 1D1DFunction.h.

Referenced by PiecewiseLinear1D1DFunction(), value(), and ~PiecewiseLinear1D1DFunction().

---

The documentation for this class was generated from the following files:

• src/misc/inc/1D1DFunction.h
• src/misc/src/1D1DFunction.C