Class for one-dimensional Lagrange polynomials. More...

#include <1D1DFunction.h>

Inheritance diagram for QUESO::LagrangePolynomial1D1DFunction:

Collaboration diagram for QUESO::LagrangePolynomial1D1DFunction:

Public Member Functions
Constructor/Destructor methods
	LagrangePolynomial1D1DFunction (const std::vector< double > &positionValues, const std::vector< double > *functionValues)
	Default constructor. More...

	~LagrangePolynomial1D1DFunction ()
	Destructor. More...

Mathematical methods
double	value (double domainValue) const
	Returns the value of the Lagrange polynomial at point `domainValue`. More...

double	deriv (double domainValue) const
	TODO: Returns the value of the derivative of the Lagrange polynomial 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
std::vector< double >	m_positionValues

std::vector< double >	m_functionValues

Protected Attributes inherited from QUESO::Base1D1DFunction
double	m_minDomainValue

double	m_maxDomainValue

Detailed Description

Class for one-dimensional Lagrange polynomials.

The Lagrange interpolating polynomial of a one-dimensional function $ f(x) = y $ is the polynomial $ P(x) $ of degree $\leq n-1$ that passes through the $ n $ points $ (x_1,y_1=f(x_1)), (x_2,y_2=f(x_2)), ..., (x_n,y_n=f(x_n))$ , and is given by:

$P(x)=\sum_{j=1}^n \prod_{k=1; k\not=j}^n \frac{x-x_k}{x_j-x_k}.$

Written explicitly,

$P(x)=\frac{(x-x_2)(x-x_3)...(x-x_n)}{(x_1-x_2)(x_1-x_3)...(x_1-x_n)}y_1+ \frac{(x-x_1)(x-x_3)...(x-x_n)}{(x_2-x_1)(x_2-x_3)...(x_2-x_n)}y_2+...+ \frac{(x-x_1)(x-x_2)...(x-x_(n-1))}{(x_n-x_1)(x_n-x_2)...(x_n-x_(n-1))}y_n.$

In this class, the array std::vector<double>& positionValues stores the points $ x_1, x_2, ... x_n $ and the array std::vector<double>* functionValues stores the points $ y_1, y_2, ... y_n $ of the Lagrange polynomial.

See Also: Archer, Branden and Weisstein, Eric W. "Lagrange Interpolating Polynomial." From MathWorld–A Wolfram Web Resource. http://mathworld.wolfram.com/LagrangeInterpolatingPolynomial.html.

Definition at line 558 of file 1D1DFunction.h.

Constructor & Destructor Documentation

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

Default constructor.

Definition at line 827 of file 1D1DFunction.C.

References m_functionValues, m_positionValues, UQ_FATAL_TEST_MACRO, and QUESO::UQ_UNAVAILABLE_RANK.

   :
   Base1D1DFunction(-INFINITY,INFINITY),
   m_positionValues(positionValues),
   m_functionValues(positionValues.size(),1.)
 {
   if (functionValues) {
     UQ_FATAL_TEST_MACRO(m_positionValues.size() != functionValues->size(),
                         UQ_UNAVAILABLE_RANK,
                         "LagrangePolynomial1D1DFunction::constructor()",
                         "invalid input");
     m_functionValues = *functionValues;
   }
 }

QUESO::LagrangePolynomial1D1DFunction::~LagrangePolynomial1D1DFunction ( )

Destructor.

Definition at line 844 of file 1D1DFunction.C.

845 {

846 }

Member Function Documentation

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

virtual

TODO: Returns the value of the derivative of the Lagrange polynomial at point domainValue.

Todo:: 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 884 of file 1D1DFunction.C.

References QUESO::Base1D1DFunction::m_maxDomainValue, QUESO::Base1D1DFunction::m_minDomainValue, UQ_FATAL_TEST_MACRO, QUESO::UQ_UNAVAILABLE_RANK, and value().

 {
   double value = 0.;
 
   if ((domainValue < m_minDomainValue) || (domainValue > m_maxDomainValue)) {
     std::cerr << "In LagrangePolynomial1D1DFunction::deriv()"
               << ": requested x ("            << domainValue
               << ") is out of the interval (" << m_minDomainValue
               << ", "                         << m_maxDomainValue
               << ")"
               << std::endl;
   }
 
   UQ_FATAL_TEST_MACRO(((domainValue < m_minDomainValue) || (domainValue > m_maxDomainValue)),
                       UQ_UNAVAILABLE_RANK,
                       "LagrangePolynomial1D1DFunction::deriv()",
                       "x out of range");
 
   UQ_FATAL_TEST_MACRO(true,
                       UQ_UNAVAILABLE_RANK,
                       "LagrangePolynomial1D1DFunction::deriv()",
                       "not implemented yet");
 
   return value;
 }

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

virtual

Returns the value of the Lagrange polynomial at point domainValue.

Implements QUESO::Base1D1DFunction.

Definition at line 849 of file 1D1DFunction.C.

References m_functionValues, and m_positionValues.

Referenced by deriv().

 {
   double value = 0.;
 
   for (unsigned int k = 0; k < m_positionValues.size(); ++k) {
     double scaleFactor = 1.;
     double posK = m_positionValues[k];
     for (unsigned int j = 0; j < m_positionValues.size(); ++j) {
       if (j != k) {
         double posJ = m_positionValues[j];
         scaleFactor *= (domainValue-posJ)/(posK-posJ);
       }
     }
 
     //if (m_env.subDisplayFile()) {
     //  *m_env.subDisplayFile() << "In sddTG<K_V,K_M>::lagrange()"
     //                          << ": k = " << k
     //                          << ", scaleFactor = " << scaleFactor
     //                          << std::endl;
     //}
 
     value += scaleFactor * m_functionValues[k];
 
     //if (m_env.subDisplayFile()) {
     //  *m_env.subDisplayFile() << "In sddTG<K_V,K_M>::lagrange()"
     //                          << ": k = " << k
     //                          << ", value = " << value
     //                          << std::endl;
     //}
   }
 
   return value;
 }

Member Data Documentation

std::vector<double> QUESO::LagrangePolynomial1D1DFunction::m_functionValues

protected

Definition at line 585 of file 1D1DFunction.h.

Referenced by LagrangePolynomial1D1DFunction(), and value().

std::vector<double> QUESO::LagrangePolynomial1D1DFunction::m_positionValues

protected

Definition at line 584 of file 1D1DFunction.h.

Referenced by LagrangePolynomial1D1DFunction(), and value().

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

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

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation