Rate CreditDefaultSwap::impliedHazardRate(
Real targetNPV,
const Handle<YieldTermStructure>& discountCurve,
const DayCounter& dayCounter,
Real recoveryRate,
Real accuracy) const {
boost::shared_ptr<SimpleQuote> flatRate(new SimpleQuote(0.0));
Handle<DefaultProbabilityTermStructure> probability(
boost::shared_ptr<DefaultProbabilityTermStructure>(new
FlatHazardRate(0, WeekendsOnly(),
Handle<Quote>(flatRate), dayCounter)));
MidPointCdsEngine engine(probability, recoveryRate, discountCurve);
setupArguments(engine.getArguments());
const CreditDefaultSwap::results* results =
dynamic_cast<const CreditDefaultSwap::results*>(
engine.getResults());
ObjectiveFunction f(targetNPV, *flatRate, engine, results);
Rate guess = 0.001;
Rate step = guess*0.1;
return Brent().solve(f, accuracy, guess, step);
}
/**
@param hmass The mass enthalpy in J/kg
@param p The pressure in Pa
@returns T The temperature in K
*/
long double IncompressibleBackend::HmassP_flash(long double hmass, long double p){
class HmassP_residual : public FuncWrapper1D {
protected:
double p,x,h_in;
IncompressibleFluid* fluid;
protected:
HmassP_residual(){};
public:
HmassP_residual(IncompressibleFluid* fluid, const double &p, const double &x, const double &h_in){
this->p = p;
this->x = x;
this->h_in = h_in;
this->fluid = fluid;
}
virtual ~HmassP_residual(){};
double call(double target){
return fluid->h(target,p,x) - h_in; //fluid.u(target,p,x)+ p / fluid.rho(target,p,x) - h_in;
}
//double deriv(double target);
};
//double T_tmp = this->PUmass_flash(p, hmass); // guess value from u=h
HmassP_residual res = HmassP_residual(fluid, p, _fractions[0], hmass);
std::string errstring;
double macheps = DBL_EPSILON;
double tol = DBL_EPSILON*1e3;
int maxiter = 10;
double result = Brent(&res, fluid->getTmin(), fluid->getTmax(), macheps, tol, maxiter, errstring);
//if (this->do_debug()) std::cout << "Brent solver message: " << errstring << std::endl;
return result;
}
double GenotypeLikelihood::OptimizeFrequency()
{
a = 0.00001; fa = f(a);
b = 0.4; fb = f(b);
c = 0.99999; fc = f(c);
Brent(0.0001);
return min;
}
Real AnalyticPDFHestonEngine::Pv(Real x_t, Time t) const {
const Hestonp p = { model_->v0(),
model_->kappa(),
model_->theta(),
model_->sigma(),
model_->rho() };
Real xMax = (xMax_ != Null<Real>()) ? xMax_
: Brent().solve(boost::bind(&zero_pv, p, _1, x_t, t),
0.01, 1.0, 1.0);
return GaussLobattoIntegral(nIterations_, 0.1*eps_)
(boost::bind(&pv, p, _1, x_t, t), -xMax, xMax)/M_TWOPI;
}
Real RichardsonExtrapolation::operator()(Real t, Real s)
const {
QL_REQUIRE(t > 1 && s > 1, "scaling factors must be greater than 1");
QL_REQUIRE(t > s, "t must be greater than s");
const Real ft = f_(delta_h_/t);
const Real fs = f_(delta_h_/s);
const Real k = Brent().solve(RichardsonEqn(fdelta_h_, ft, fs, t, s),
1e-8, 0.05, 10);
const Real ts = std::pow(s, k);
return (ts*fs-fdelta_h_)/(ts-1.0);
}
void GaussianRandomDefaultModel::nextSequence(Real tmax) {
const std::vector<Real>& values = rsg_.nextSequence().value;
Real a = sqrt(copula_->correlation());
for (Size j = 0; j < pool_->size(); j++) {
const string name = pool_->names()[j];
const Handle<DefaultProbabilityTermStructure>&
dts = pool_->get(name).defaultProbability(defaultKeys_[j]);
Real y = a * values[0] + sqrt(1-a*a) * values[j+1];
Real p = CumulativeNormalDistribution()(y);
if (dts->defaultProbability(tmax) < p)
pool_->setTime(name, tmax+1);
else
pool_->setTime(name, Brent().solve(Root(dts,p),accuracy_,0,1));
}
}
void Efficiency(int k, int N, double conflevel,
double& mode, double& low, double& high)
{
//If there are no entries, then we know nothing, thus return the prior...
if (0==N) {
mode = .5; low = 0.0; high = 1.0;
return;
}
// Calculate the most probable value for the posterior cross section.
// This is easy, 'cause it is just k/N
double efficiency = (double)k/N;
double low_edge;
double high_edge;
if (k == 0) {
low_edge = 0.0;
high_edge = SearchUpper(low_edge, k, N, conflevel);
}
else if (k == N){
high_edge = 1.0;
low_edge = SearchLower(high_edge, k, N, conflevel);
}
else {
GLOBAL_k = k;
GLOBAL_N = N;
CONFLEVEL = conflevel;
Brent(0.0, 0.5, 1.0, 1.0e-9, &low_edge);
high_edge = low_edge + Interval(low_edge);
}
// return output
mode = efficiency;
low = low_edge;
high = high_edge;
}//Efficiency
Real InverseCumulativeBehrensFisher::operator()(const Probability q) const {
Probability effectiveq;
Real sign;
// since the distrib is symmetric solve only on the right side:
if(q==0.5) {
return 0.;
}else if(q < 0.5) {
sign = -1.;
effectiveq = 1.-q;
}else{
sign = 1.;
effectiveq = q;
}
Real xMin =
InverseCumulativeNormal::standard_value(effectiveq) * normSqr_;
// inversion will fail at the Brent's bounds-check if this is not enough
// (q is very close to 1.), in a bad combination fails around 1.-1.e-7
Real xMax = 1.e6;
return sign *
Brent().solve(boost::bind(std::bind2nd(std::minus<Real>(),
effectiveq), boost::bind(
&CumulativeBehrensFisher::operator(),
distrib_, _1)), accuracy_, (xMin+xMax)/2., xMin, xMax);
}
void ErrorRateEstimator::EstimateModel()
{
trace = false;
printf(" Assuming per %s error model\n", alleleError ? "allele" : "genotype");
a = 0.00001;
fa = f(a);
printf(" lnLikelihood at lower bound (%.3g) is %.3f\n", a, -fa);
c = 0.10;
fc = f(c);
printf(" lnLikelihood at upper bound (%.3g) is %.3f\n", c, -fc);
b = (c - a) * 0.4;
fb = f(b);
trace = !MerlinCore::quietOutput;
Brent(0.00001);
printf(" lnLikelihood at MLE (%.3g) is %.3f \n", min, -fmin);
}
void cdecl TERMWINDOWMEMBER Andy(const char *Format, const char *Codes, ...)
{
char *Vals[32], collect[512];
const char *Code;
int n, CodeCount, colCount;
va_list ap;
va_start(ap, Codes);
for (n = 0, CodeCount = strlen(Codes); n < CodeCount && n < 32; ++n)
{
Vals[n] = va_arg(ap, char *);
}
va_end(ap);
for (colCount = 0; *Format != '\0'; ++Format)
{
if (*Format != '%')
{
if (!Brent(&Format, &colCount, collect))
{
break;
}
continue;
}
if (*(++Format) == '\0')
{
break;
}
if (*Format == '%')
{
collect[colCount++] = *Format;
continue;
}
// not stuff
if (*Format == '[')
{
// Scan for close and include-location.
for (Code = Format; *Code != 0 && *Code != ']'; ++Code);
if (*Code == '\0')
{
break;
}
if ((n = strpos(*(Code + 1), Codes)) != 0)
{
if (Vals[n - 1][0] == '\0')
{
for (++Format; Format < Code; ++Format)
{
if (!Brent(&Format, &colCount, collect))
{
break;
}
}
if (*Format)
{
Format++;
}
}
else
{
Format = Code + 1;
}
}
continue;
}
if (*Format != '{')
{
if ((n = strpos(*Format, Codes)) != 0)
{
if (colCount)
{
collect[colCount] = 0;
mFormat(collect);
colCount = 0;
}
mFormat(Vals[n - 1]);
}
continue;
}
// Scan for close and include-location.
const char *Include = NULL;
for (Code = Format; *Code != 0 && *Code != '}'; ++Code)
{
if (*Code == '&')
{
Include = Code;
}
}
if (*Code == '\0')
{
break;
}
if (Include == NULL)
{
if ((n = strpos(*(Code + 1), Codes)) != 0)
{
if (Vals[n - 1][0] != '\0')
{
if (colCount)
{
collect[colCount] = 0;
mFormat(collect);
colCount = 0;
}
for (++Format; Format < Code; ++Format)
{
if (!Brent(&Format, &colCount, collect))
{
break;
}
}
if (*Format)
{
Format++;
}
}
else
{
Format = Code + 1;
}
}
}
else
{
if ((n = strpos(*(Code + 1), Codes)) != 0)
{
if (Vals[n - 1][0] != '\0')
{
if (colCount)
{
collect[colCount] = 0;
mFormat(collect);
colCount = 0;
}
for (++Format; Format < Include; ++Format)
{
if (!Brent(&Format, &colCount, collect))
{
break;
}
}
if (colCount)
{
collect[colCount] = 0;
mFormat(collect);
colCount = 0;
}
mFormat(Vals[n - 1]);
for (++Format; Format < Code; ++Format)
{
if (!Brent(&Format, &colCount, collect))
{
break;
}
}
if (*Format)
{
Format++;
}
}
else
{
Format = Code + 1;
}
}
}
}
if (colCount)
{
collect[colCount] = 0;
mFormat(collect);
}
}
void RandomLossLM<C, URNG>::nextSample(
const std::vector<Real>& values) const
{
const ext::shared_ptr<Pool>& pool = this->basket_->pool();
this->simsBuffer_.push_back(std::vector<defaultSimEvent> ());
// half the model is defaults, the other half are RRs...
for(Size iName=0; iName<copula_->size()/2; iName++) {
// ...but samples must be full
/* This is really a trick, we are passing a longer than
expected set of values in the sample but the last idiosyncratic
values corresponding to the RR are not used. They are used below
only if we are in default. This works due to the way the SpotLossLM
is split in two almost disjoint latent models and that theres no
check on the vector size in the LM base class.
*/
Real latentVarSample =
copula_->latentVarValue(values, iName);
Probability simDefaultProb =
copula_->cumulativeY(latentVarSample, iName);
// If the default simulated lies before the max date:
if (horizonDefaultPs_[iName] >= simDefaultProb) {
const Handle<DefaultProbabilityTermStructure>& dfts =
pool->get(pool->names()[iName]). // use 'live' names
defaultProbability(this->basket_->defaultKeys()[iName]);
// compute and store default time with respect to the
// curve ref date:
Size dateSTride =
static_cast<Size>(Brent().solve(// casted from Real:
detail::Root(dfts, simDefaultProb), accuracy_, 0., 1.));
/*
// value if one approximates to a flat HR;
// faster (>x2) but it introduces an error:..
// \todo: see how to include this 'polymorphically'. While
// not the case in pricing in risk metrics/real
// probabilities the curves are often flat
static_cast<Size>(ceil(maxHorizon_ *
std::log(1.-simDefaultProb)
/std::log(1.-data_.horizonDefaultPs_[iName])));
*/
// Determine the realized recovery rate:
/* For this; 'conditionalRecovery' needs to compute the pdef on
the realized def event date from the simulation. Yet, this might
have fallen between todays date and the default TS reference
date(usually a two day gap) To avoid requesting a negative time
probability the date is moved to the TS date
Unless the gap is ridiculous this has no practical effect for
the RR value*/
Date today = Settings::instance().evaluationDate();
Date eventDate = today+Period(static_cast<Integer>(dateSTride),
Days);
if(eventDate<dfts->referenceDate())
eventDate = dfts->referenceDate();
Real latentRRVarSample =
copula_->latentRRVarValue(values, iName);
Real recovery =
copula_->conditionalRecovery(latentRRVarSample,
iName, eventDate);
this->simsBuffer_.back().push_back(
defaultSimEvent(iName, dateSTride, recovery));
//emplace_back
}
/* Used to remove sims with no events. Uses less memory, faster
post-statistics. But only if all names in the portfolio have low
default probability, otherwise is more expensive and sim access has
to be modified. However low probability is also an indicator that
variance reduction is needed. */
//if(simsBuffer.back().empty()) {
// emptySims_++;// Size; intilzd to zero
// simsBuffer.pop_back();
//}
}
}