QuantExt::detail Namespace Reference

Classes
struct	BachelierSpec
struct	Black76Spec
class	BlackStyleSwaptionEngineDeltaGamma
struct	CloseEnoughComparator
class	ImpliedBondSpreadHelper
	helper class for implied vanilla bond spread calculation More...
class	LogInterpolationImpl
class	NadarayaWatsonImpl
	Nadaraya Watson impl. More...
struct	NormalSABRSpecs
class	NormalSABRWrapper
class	NpvDeltaGammaCalculator
class	QuadraticInterpolationImpl
class	RegressionImpl
	Regression impl. More...
class	SimpleDeltaInterpolatedSmile

Functions
void	check (const Real p)
void	check (const Matrix &omega, const Array &delta)
void	check (const Matrix &omega, const Array &delta, const Matrix &gamma)
template<typename A >
Real	absMax (const A &a)
template<class Key >
Real &	getMapEntry (std::map< Key, Real > &map, const Key &key)
std::vector< Real >	rebucketDeltas (const std::vector< Time > &deltaTimes, const std::map< Date, Real > &deltaRaw, const Date &referenceDate, const DayCounter &dc, const bool linearInZero)
Matrix	rebucketGammas (const std::vector< Time > &gammaTimes, const std::map< Date, Real > &gammaDscRaw, std::map< std::pair< Date, Date >, Real > &gammaForward, std::map< std::pair< Date, Date >, Real > &gammaDscFwd, const bool forceFullMatrix, const Date &referenceDate, const DayCounter &dc, const bool linearInZero)
Real	transformVol (const Real v)
Real	untransformVol (const Real w)
QuantLib::ext::shared_ptr< SimpleDeltaInterpolatedSmile >	createSmile (const Real spot, const Real domDisc, const Real forDisc, const Real expiryTime, const std::vector< Real > &deltas, const std::vector< Real > &bfQuotes, const std::vector< Real > &rrQuotes, const Real atmVol, const DeltaVolQuote::DeltaType dt, const DeltaVolQuote::AtmType at, const Option::Type riskReversalInFavorOf, const bool butterflyIsBrokerStyle, const BlackVolatilitySurfaceBFRR::SmileInterpolation smileInterpolation)
template<class Curve >
QuantLib::Real	dontThrowFallback (const QuantLib::BootstrapError< Curve > &error, QuantLib::Real xMin, QuantLib::Real xMax, QuantLib::Size steps)

Variables
const QuantLib::Rate	avgInflation = 0.02
const QuantLib::Rate	maxInflation = 0.5
const QuantLib::Real	avgHazardRate = 0.01
const QuantLib::Real	maxHazardRate = 3.0

Function Documentation

check() [1/3]

void check

(

const Real

p

)

Definition at line 31 of file deltagammavar.cpp.

{ QL_REQUIRE(p >= 0.0 && p <= 1.0, "p (" << p << ") must be in [0,1] in VaR calculation"); }

Here is the caller graph for this function:

check() [2/3]

void check	(	const Matrix &	omega,
		const Array &	delta
	)

Definition at line 33 of file deltagammavar.cpp.

                                                    {
    QL_REQUIRE(omega.rows() == omega.columns(),
               "omega (" << omega.rows() << "x" << omega.columns() << ") must be square in VaR calculation");
    QL_REQUIRE(delta.size() == omega.rows(), "delta vector size (" << delta.size() << ") must match omega ("
                                                                   << omega.rows() << "x" << omega.columns() << ")");
}

check() [3/3]

void check	(	const Matrix &	omega,
		const Array &	delta,
		const Matrix &	gamma
	)

Definition at line 40 of file deltagammavar.cpp.

                                                                         {
    QL_REQUIRE(gamma.rows() == omega.rows() && gamma.columns() == omega.columns(),
               "gamma (" << gamma.rows() << "x" << gamma.columns() << ") must have same dimensions as omega ("
                         << omega.rows() << "x" << omega.columns() << ")");
}

absMax()

Real absMax

(

const A &

a

)

Definition at line 82 of file deltagammavar.hpp.

                                              {
    Real tmp = 0.0;
    BOOST_FOREACH (Real x, a) {
        if (std::abs(x) > tmp)
            tmp = std::abs(x);
    }
    return tmp;
}

Here is the caller graph for this function:

getMapEntry()

Real & getMapEntry	(	std::map< Key, Real > &	map,
		const Key &	key
	)

Definition at line 27 of file discountingswapenginedeltagamma.cpp.

                                                                               {
    auto f = map.find(key);
    if (f == map.end()) {
        return map.insert(std::make_pair(key, 0.0)).first->second;
    } else {
        return f->second;
    }
}

Here is the caller graph for this function:

rebucketDeltas()

std::vector< Real > rebucketDeltas	(	const std::vector< Time > &	deltaTimes,
		const std::map< Date, Real > &	deltaRaw,
		const Date &	referenceDate,
		const DayCounter &	dc,
		const bool	linearInZero
	)

Definition at line 203 of file discountingswapenginedeltagamma.cpp.

                                                                                           {
    std::vector<Real> delta(deltaTimes.size(), 0.0);
    for (std::map<Date, Real>::const_iterator i = deltaRaw.begin(); i != deltaRaw.end(); ++i) {
        Real t = dc.yearFraction(referenceDate, i->first);
        Size b = std::upper_bound(deltaTimes.begin(), deltaTimes.end(), t) - deltaTimes.begin();
        if (b == 0) {
            delta[0] += i->second;
        } else if (b == deltaTimes.size()) {
            delta.back() += i->second;
        } else {
            Real tmp = (deltaTimes[b] - t) / (deltaTimes[b] - deltaTimes[b - 1]);
            if (linearInZero) {
                delta[b - 1] += i->second * tmp;
                delta[b] += i->second * (1.0 - tmp);
            } else {
                delta[b - 1] += i->second * tmp * deltaTimes[b - 1] / t;
                delta[b] += i->second * (1.0 - tmp) * deltaTimes[b] / t;
            }
        }
    }
    return delta;
}

Here is the caller graph for this function:

rebucketGammas()

Matrix rebucketGammas	(	const std::vector< Time > &	gammaTimes,
		const std::map< Date, Real > &	gammaDscRaw,
		std::map< std::pair< Date, Date >, Real > &	gammaForward,
		std::map< std::pair< Date, Date >, Real > &	gammaDscFwd,
		const bool	forceFullMatrix,
		const Date &	referenceDate,
		const DayCounter &	dc,
		const bool	linearInZero
	)

Definition at line 227 of file discountingswapenginedeltagamma.cpp.

                                                                                        {
    int n = gammaTimes.size();
    // if we have two curves c1, c2, the matrix contains c1-c1, c1-c2, c2-c1, c2-c2 blocks
    Size n2 = !forceFullMatrix && gammaForward.empty() && gammaDscFwd.empty() ? n : 2 * n;
    Matrix gamma(n2, n2, 0.0);
    // pure dsc
    for (std::map<Date, Real>::const_iterator i = gammaDscRaw.begin(); i != gammaDscRaw.end(); ++i) {
        Real t = dc.yearFraction(referenceDate, i->first);
        int b = (int)(std::upper_bound(gammaTimes.begin(), gammaTimes.end(), t) - gammaTimes.begin());
        if (b == 0) {
            gamma[0][0] += i->second;
        } else if (b == n) {
            gamma[n - 1][n - 1] += i->second;
        } else {
            Real tmp = (gammaTimes[b] - t) / (gammaTimes[b] - gammaTimes[b - 1]);
            if (linearInZero) {
                gamma[b - 1][b - 1] += i->second * tmp * tmp;
                gamma[b - 1][b] += i->second * (1.0 - tmp) * tmp;
                gamma[b][b - 1] += i->second * tmp * (1.0 - tmp);
                gamma[b][b] += i->second * (1.0 - tmp) * (1.0 - tmp);
            } else {
                gamma[b - 1][b - 1] += i->second * tmp * tmp * gammaTimes[b - 1] * gammaTimes[b - 1] / (t * t);
                gamma[b - 1][b] += i->second * (1.0 - tmp) * tmp * gammaTimes[b] * gammaTimes[b - 1] / (t * t);
                gamma[b][b - 1] += i->second * tmp * (1.0 - tmp) * gammaTimes[b - 1] * gammaTimes[b] / (t * t);
                gamma[b][b] += i->second * (1.0 - tmp) * (1.0 - tmp) * gammaTimes[b] * gammaTimes[b] / (t * t);
            }
        }
    }
    // dsc-fwd
    if (!gammaDscFwd.empty()) {
        Matrix gammadf(n, n, 0.0);
        for (std::map<std::pair<Date, Date>, Real>::const_iterator i = gammaDscFwd.begin(); i != gammaDscFwd.end();
             ++i) {
            Real t1 = dc.yearFraction(referenceDate, i->first.first);
            Real t2 = dc.yearFraction(referenceDate, i->first.second);
            int b1 = (int)(std::upper_bound(gammaTimes.begin(), gammaTimes.end(), t1) - gammaTimes.begin());
            int b2 = (int)(std::upper_bound(gammaTimes.begin(), gammaTimes.end(), t2) - gammaTimes.begin());
            Real w1 = 0.0, w2 = 0.0;
            int i1 = 0, i2 = 0;
            if (b1 == 0) {
                w1 = 1.0;
                i1 = 0;
            } else if (b1 == n) {
                w1 = 0.0;
                i1 = n - 2;
            } else {
                w1 = (gammaTimes[b1] - t1) / (gammaTimes[b1] - gammaTimes[b1 - 1]);
                i1 = b1 - 1;
            }
            if (b2 == 0) {
                w2 = 1.0;
                i2 = 0;
            } else if (b2 == n) {
                w2 = 0.0;
                i2 = n - 2;
            } else {
                w2 = (gammaTimes[b2] - t2) / (gammaTimes[b2] - gammaTimes[b2 - 1]);
                i2 = b2 - 1;
            }
            if (i1 >= 0) {
                if (i2 < n - 1)
                    gammadf[i1][i2 + 1] += w1 * (1.0 - w2) * i->second *
                                           (linearInZero ? 1.0 : gammaTimes[b1 - 1] * gammaTimes[b2] / (t1 * t2));
                if (i2 >= 0) {
                    gammadf[i1][i2] += w1 * w2 * i->second *
                                       (linearInZero ? 1.0 : gammaTimes[b1 - 1] * gammaTimes[b2 - 1] / (t1 * t2));
                }
            }
            if (i2 >= 0 && i1 < n - 1) {
                gammadf[i1 + 1][i2] += (1.0 - w1) * w2 * i->second *
                                       (linearInZero ? 1.0 : gammaTimes[b1] * gammaTimes[b2 - 1] / (t1 * t2));
            }
            if (i1 < n - 1 && i2 < n - 1) {
                gammadf[i1 + 1][i2 + 1] += (1.0 - w1) * (1.0 - w2) * i->second *
                                           (linearInZero ? 1.0 : gammaTimes[b1] * gammaTimes[b2] / (t1 * t2));
            }
        }
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                gamma[i][n + j] = gamma[n + j][i] = gammadf[i][j];
            }
        }
    }
    // fwd-fwd
    for (std::map<std::pair<Date, Date>, Real>::const_iterator i = gammaForward.begin(); i != gammaForward.end(); ++i) {
        Real t1 = dc.yearFraction(referenceDate, i->first.first);
        Real t2 = dc.yearFraction(referenceDate, i->first.second);
        int b1 = (int)(std::upper_bound(gammaTimes.begin(), gammaTimes.end(), t1) - gammaTimes.begin());
        int b2 = (int)(std::upper_bound(gammaTimes.begin(), gammaTimes.end(), t2) - gammaTimes.begin());
        Real tmp = 0.5 * i->second;
        Real w1 = 0.0, w2 = 0.0;
        int i1 = 0, i2 = 0;
        if (b1 == 0) {
            w1 = 1.0;
            i1 = 0;
        } else if (b1 == n) {
            w1 = 0.0;
            i1 = n - 2;
        } else {
            w1 = (gammaTimes[b1] - t1) / (gammaTimes[b1] - gammaTimes[b1 - 1]);
            i1 = b1 - 1;
        }
        if (b2 == 0) {
            w2 = 1.0;
            i2 = 0;
        } else if (b2 == n) {
            w2 = 0.0;
            i2 = n - 2;
        } else {
            w2 = (gammaTimes[b2] - t2) / (gammaTimes[b2] - gammaTimes[b2 - 1]);
            i2 = b2 - 1;
        }
        if (i1 >= 0) {
            if (i2 < n - 1) {
                gamma[n + i1][n + i2 + 1] +=
                    w1 * (1.0 - w2) * tmp * (linearInZero ? 1.0 : gammaTimes[b1 - 1] * gammaTimes[b2] / (t1 * t2));
                gamma[n + i2 + 1][n + i1] +=
                    w1 * (1.0 - w2) * tmp * (linearInZero ? 1.0 : gammaTimes[b1 - 1] * gammaTimes[b2] / (t1 * t2));
            }
            if (i2 >= 0) {
                gamma[n + i1][n + i2] +=
                    w1 * w2 * tmp * (linearInZero ? 1.0 : gammaTimes[b1 - 1] * gammaTimes[b2 - 1] / (t1 * t2));
                gamma[n + i2][n + i1] +=
                    w1 * w2 * tmp * (linearInZero ? 1.0 : gammaTimes[b1 - 1] * gammaTimes[b2 - 1] / (t1 * t2));
            }
        }
        if (i2 >= 0 && i1 < n - 1) {
            gamma[n + i1 + 1][n + i2] +=
                (1.0 - w1) * w2 * tmp * (linearInZero ? 1.0 : gammaTimes[b1] * gammaTimes[b2 - 1] / (t1 * t2));
            gamma[n + i2][n + i1 + 1] +=
                (1.0 - w1) * w2 * tmp * (linearInZero ? 1.0 : gammaTimes[b1] * gammaTimes[b2 - 1] / (t1 * t2));
        }
        if (i1 < n - 1 && i2 < n - 1) {
            gamma[n + i1 + 1][n + i2 + 1] +=
                (1.0 - w1) * (1.0 - w2) * tmp * (linearInZero ? 1.0 : gammaTimes[b1] * gammaTimes[b2] / (t1 * t2));
            gamma[n + i2 + 1][n + i1 + 1] +=
                (1.0 - w1) * (1.0 - w2) * tmp * (linearInZero ? 1.0 : gammaTimes[b1] * gammaTimes[b2] / (t1 * t2));
        }
    }
 
    return gamma;
} // rebucketGammas

Here is the caller graph for this function:

transformVol()

Real transformVol

(

const Real

v

)

Definition at line 32 of file blackvolsurfacebfrr.cpp.

{ return std::log(v); }

Here is the caller graph for this function:

untransformVol()

Real untransformVol

(

const Real

w

)

Definition at line 33 of file blackvolsurfacebfrr.cpp.

{ return std::exp(w); }

Here is the caller graph for this function:

createSmile()

QuantLib::ext::shared_ptr< SimpleDeltaInterpolatedSmile > createSmile	(	const Real	spot,
		const Real	domDisc,
		const Real	forDisc,
		const Real	expiryTime,
		const std::vector< Real > &	deltas,
		const std::vector< Real > &	bfQuotes,
		const std::vector< Real > &	rrQuotes,
		const Real	atmVol,
		const DeltaVolQuote::DeltaType	dt,
		const DeltaVolQuote::AtmType	at,
		const Option::Type	riskReversalInFavorOf,
		const bool	butterflyIsBrokerStyle,
		const BlackVolatilitySurfaceBFRR::SmileInterpolation	smileInterpolation
	)

Definition at line 209 of file blackvolsurfacebfrr.cpp.

                                                                                   {
 
    Real phirr = riskReversalInFavorOf == Option::Call ? 1.0 : -1.0;
    QuantLib::ext::shared_ptr<SimpleDeltaInterpolatedSmile> resultSmile;
 
    if (!butterflyIsBrokerStyle) {
 
        // butterfly is not broker style: we can directly compute the call/put vols ...
 
        std::vector<Real> vol_p, vol_c;
 
        for (Size i = 0; i < deltas.size(); ++i) {
            QL_REQUIRE(atmVol + bfQuotes[i] - 0.5 * std::abs(rrQuotes[i]) > 0.0,
                       "createSmile: atmVol ("
                           << atmVol << ") + bf (" << bfQuotes[i] << ") - rr (" << rrQuotes[i]
                           << ") must be positive when creating smile from smile bf quotes, tte=" << expiryTime);
            vol_p.push_back(atmVol + bfQuotes[i] - 0.5 * phirr * rrQuotes[i]);
            vol_c.push_back(atmVol + bfQuotes[i] + 0.5 * phirr * rrQuotes[i]);
        }
 
        // ... and set up the interpolated smile
 
        resultSmile = QuantLib::ext::make_shared<SimpleDeltaInterpolatedSmile>(
            spot, domDisc, forDisc, expiryTime, deltas, vol_p, vol_c, atmVol, dt, at, smileInterpolation);
 
    } else {
 
        Real forward = spot / domDisc * forDisc;
 
        /* handle broker style butterflys: first determine the strikes and the (non-discounted) premiums
           of the broker butterflies */
 
        std::vector<Real> kb_c, kb_p, vb;
 
        for (Size i = 0; i < deltas.size(); ++i) {
            Real stddevb = (atmVol + bfQuotes[i]) * std::sqrt(expiryTime);
            QL_REQUIRE(stddevb > 0.0,
                       "createSmile: atmVol ("
                           << atmVol << ") + bf (" << bfQuotes[i]
                           << ") must be positive when creating smile from broker bf quotes, tte=" << expiryTime);
            BlackDeltaCalculator cp(Option::Type::Put, dt, spot, domDisc, forDisc, stddevb);
            BlackDeltaCalculator cc(Option::Type::Call, dt, spot, domDisc, forDisc, stddevb);
            kb_p.push_back(cp.strikeFromDelta(-deltas[i]));
            kb_c.push_back(cc.strikeFromDelta(deltas[i]));
            vb.push_back(blackFormula(Option::Put, kb_p.back(), forward, stddevb) +
                         blackFormula(Option::Call, kb_c.back(), forward, stddevb));
        }
 
        /* set initial guess for smile butterfly vol := broker butterfly vol
           we optimise in z = log( bf - 0.5 * abs(rr) + atmVol ) */
 
        Array guess(deltas.size());
        for (Size i = 0; i < deltas.size(); ++i) {
            guess[i] = std::log(std::max(0.0001, bfQuotes[i] - 0.5 * std::abs(rrQuotes[i]) + atmVol));
        }
 
        /* define the target function to match up the butterfly market values and smile values */
 
        struct TargetFunction : public QuantLib::CostFunction {
            TargetFunction(Real atmVol, Real phirr, Real spot, Real domDisc, Real forDisc, Real forward,
                           Real expiryTime, DeltaVolQuote::DeltaType dt, DeltaVolQuote::AtmType at,
                           const std::vector<Real>& rrQuotes, const std::vector<Real>& deltas,
                           const std::vector<Real>& kb_p, const std::vector<Real>& kb_c, const std::vector<Real>& vb,
                           BlackVolatilitySurfaceBFRR::SmileInterpolation smileInterpolation)
                : atmVol(atmVol), phirr(phirr), spot(spot), domDisc(domDisc), forDisc(forDisc), forward(forward),
                  expiryTime(expiryTime), dt(dt), at(at), rrQuotes(rrQuotes), deltas(deltas), kb_p(kb_p), kb_c(kb_c),
                  vb(vb), smileInterpolation(smileInterpolation) {}
 
            Real atmVol, phirr, spot, domDisc, forDisc, forward, expiryTime;
            DeltaVolQuote::DeltaType dt;
            DeltaVolQuote::AtmType at;
            const std::vector<Real>&rrQuotes, deltas, kb_p, kb_c, vb;
            BlackVolatilitySurfaceBFRR::SmileInterpolation smileInterpolation;
 
            mutable Real bestValue = QL_MAX_REAL;
            mutable QuantLib::ext::shared_ptr<SimpleDeltaInterpolatedSmile> bestSmile;
 
            Array values(const Array& x) const override {
 
                constexpr Real large_error = 1E6;
 
                Array smileBfVol(x.size());
                for (Size i = 0; i < x.size(); ++i)
                    smileBfVol[i] = std::exp(x[i]) + 0.5 * std::abs(rrQuotes[i]) - atmVol;
 
                // compute the call/put vols ....
 
                std::vector<Real> vol_c, vol_p;
 
                for (Size i = 0; i < deltas.size(); ++i) {
                    vol_p.push_back(atmVol + smileBfVol[i] - 0.5 * phirr * rrQuotes[i]);
                    vol_c.push_back(atmVol + smileBfVol[i] + 0.5 * phirr * rrQuotes[i]);
                    QL_REQUIRE(vol_p.back() > 0.0, " createSmile: internal error: put vol = "
                                                       << vol_p.back() << " during broker bf fitting");
                    QL_REQUIRE(vol_c.back() > 0.0, " createSmile: internal error: call vol = "
                                                       << vol_c.back() << " during broker bf fitting");
                }
 
                // ... set up the interpolated smile ...
 
                QuantLib::ext::shared_ptr<SimpleDeltaInterpolatedSmile> tmpSmile;
                try {
                    tmpSmile = QuantLib::ext::make_shared<SimpleDeltaInterpolatedSmile>(
                        spot, domDisc, forDisc, expiryTime, deltas, vol_p, vol_c, atmVol, dt, at, smileInterpolation);
                } catch (...) {
                    // if we run into a problem we return max error and continue with the optimization
                    return Array(deltas.size(), large_error);
                }
 
                // ... and price the market butterfly on the constructed smile
 
                std::vector<Real> vs;
                for (Size i = 0; i < deltas.size(); ++i) {
                    Real pvol, cvol;
                    try {
                        pvol = tmpSmile->volatility(kb_p[i]);
                        cvol = tmpSmile->volatility(kb_c[i]);
                    } catch (...) {
                        // as above, if there is a problem, return max error
                        return Array(deltas.size(), large_error);
                    }
                    vs.push_back(blackFormula(Option::Put, kb_p[i], forward, pvol * std::sqrt(expiryTime)) +
                                 blackFormula(Option::Call, kb_c[i], forward, cvol * std::sqrt(expiryTime)));
                }
 
                // now set the target function to the relative difference of smile vs. market price
 
                Array result(deltas.size());
                for (Size i = 0; i < deltas.size(); ++i) {
                    result[i] = (vs[i] - vb[i]) / vb[i];
                    if (!std::isfinite(result[i]))
                        result[i] = large_error;
                }
 
                Real value = std::sqrt(std::accumulate(result.begin(), result.end(), 0.0,
                                                       [](Real acc, Real x) { return acc + x * x; })) /
                             result.size();
 
                if (value < bestValue) {
                    bestValue = value;
                    bestSmile = tmpSmile;
                }
 
                return result;
            }
        }; // TargetFunction declaration;
 
        TargetFunction targetFunction{atmVol, phirr,    spot,   domDisc, forDisc, forward, expiryTime,        dt,
                                      at,     rrQuotes, deltas, kb_p,    kb_c,    vb,      smileInterpolation};
        NoConstraint noConstraint;
        LevenbergMarquardt lm;
        EndCriteria endCriteria(100, 10, 1E-8, 1E-8, 1E-8);
        Problem problem(targetFunction, noConstraint, guess);
        lm.minimize(problem, endCriteria);
 
        QL_REQUIRE(targetFunction.bestValue < 0.01, "createSmile at expiry "
                                                        << expiryTime << " failed: target function value ("
                                                        << problem.functionValue() << ") not close to zero");
 
        resultSmile = targetFunction.bestSmile;
    }
 
    // sanity check of result smile before return it
 
    static const std::vector<Real> samplePoints = {0.01, 0.05, 0.1, 0.2, 0.5, 0.8, 0.9, 0.95, 0.99};
    for (auto const& simpleDelta : samplePoints) {
        Real vol = resultSmile->volatilityAtSimpleDelta(simpleDelta);
        QL_REQUIRE(vol > 0.0001 && vol < 5.0, "createSmile at expiry " << expiryTime << ": volatility at simple delta "
                                                                       << simpleDelta << " (" << vol
                                                                       << ") is not plausible.");
    }
 
    return resultSmile;
}

Here is the caller graph for this function:

dontThrowFallback()

QuantLib::Real dontThrowFallback	(	const QuantLib::BootstrapError< Curve > &	error,
		QuantLib::Real	xMin,
		QuantLib::Real	xMax,
		QuantLib::Size	steps
	)

If dontThrow is true in QuantExt::IterativeBootstrap and on a given pillar the bootstrap fails when searching for a helper root between xMin and xMax, we use this function to return the value that gives the minimum absolute helper error in the interval between xMin and xMax inclusive.

Definition at line 42 of file iterativebootstrap.hpp.

                                                     {
 
    QL_REQUIRE(xMin < xMax, "Expected xMin to be less than xMax");
 
    QuantLib::Real result = xMin;
    QuantLib::Real minError = QL_MAX_REAL;
    QuantLib::Real stepSize = (xMax - xMin) / steps;
 
    for (QuantLib::Size i = 0; i <= steps; ++i) {
        QuantLib::Real x = xMin + stepSize * static_cast<double>(i);
        QuantLib::Real absError = QL_MAX_REAL;
        try {
            absError = std::abs(error(x));
        } catch (...) {
        }
 
        if (absError < minError) {
            result = x;
            minError = absError;
        }
    }
 
    return result;
}

Here is the caller graph for this function:

Variable Documentation

avgInflation

const QuantLib::Rate avgInflation = 0.02

Definition at line 32 of file inflationtraits.hpp.

maxInflation

const QuantLib::Rate maxInflation = 0.5

Definition at line 33 of file inflationtraits.hpp.

avgHazardRate

const QuantLib::Real avgHazardRate = 0.01

Definition at line 34 of file probabilitytraits.hpp.

maxHazardRate

const QuantLib::Real maxHazardRate = 3.0

Definition at line 35 of file probabilitytraits.hpp.