Solver1D< Impl > Class Template Reference

Base class for 1-D solvers. More...

#include <ql/math/solver1d.hpp>

Inheritance diagram for Solver1D< Impl >:

Modifiers
Real	root_
Real	xMin_
Real	xMax_
Real	fxMin_
Real	fxMax_
Size	maxEvaluations_ = 100
Size	evaluationNumber_
template<class F>
Real	solve (const F &f, Real accuracy, Real guess, Real step) const
template<class F>
Real	solve (const F &f, Real accuracy, Real guess, Real xMin, Real xMax) const
void	setMaxEvaluations (Size evaluations)
void	setLowerBound (Real lowerBound)
	sets the lower bound for the function domain
void	setUpperBound (Real upperBound)
	sets the upper bound for the function domain

Additional Inherited Members
Protected Member Functions inherited from CuriouslyRecurringTemplate< Impl >
Impl &	impl ()
const Impl &	impl () const

Detailed Description

template<class Impl>
class QuantLib::Solver1D< Impl >

Base class for 1-D solvers.

The implementation of this class uses the so-called "Barton-Nackman trick", also known as "the curiously recurring template pattern". Concrete solvers will be declared as:

class Foo : public Solver1D<Foo> {
  public:
    ...
    template <class F>
    Real solveImpl(const F& f, Real accuracy) const {
        ...
    }
};

Before calling solveImpl, the base class will set its protected data members so that:

• xMin_ and xMax_ form a valid bracket;
• fxMin_ and fxMax_ contain the values of the function in xMin_ and xMax_;
• root_ is a valid initial guess. The implementation of solveImpl can safely assume all of the above.

Member Function Documentation

solve() [1/2]

template<class Impl>

template<class F>

Real solve	(	const F &	f,
		Real	accuracy,
		Real	guess,
		Real	step ) const

This method returns the zero of the function \( f \), determined with the given accuracy \( \epsilon \); depending on the particular solver, this might mean that the returned \( x \) is such that \( |f(x)| < \epsilon \), or that \( |x-\xi| < \epsilon \) where \( \xi \) is the real zero.

This method contains a bracketing routine to which an initial guess must be supplied as well as a step used to scan the range of the possible bracketing values.

solve() [2/2]

template<class Impl>

template<class F>

Real solve	(	const F &	f,
		Real	accuracy,
		Real	guess,
		Real	xMin,
		Real	xMax ) const

This method returns the zero of the function \( f \), determined with the given accuracy \( \epsilon \); depending on the particular solver, this might mean that the returned \( x \) is such that \( |f(x)| < \epsilon \), or that \( |x-\xi| < \epsilon \) where \( \xi \) is the real zero.

An initial guess must be supplied, as well as two values \( x_\mathrm{min} \) and \( x_\mathrm{max} \) which must bracket the zero (i.e., either \( f(x_\mathrm{min}) \leq 0 \leq f(x_\mathrm{max}) \), or \(f(x_\mathrm{max}) \leq 0 \leq f(x_\mathrm{min}) \) must be true).

setMaxEvaluations()

template<class T>

void setMaxEvaluations

(

Size

evaluations

)

This method sets the maximum number of function evaluations for the bracketing routine. An error is thrown if a bracket is not found after this number of evaluations.