/usr/include/ql/experimental/math/gaussiancopulapolicy.hpp is in libquantlib0-dev 1.7.1-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | /* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2014 Jose Aparicio
This file is part of QuantLib, a free-software/open-source library
for financial quantitative analysts and developers - http://quantlib.org/
QuantLib is free software: you can redistribute it and/or modify it
under the terms of the QuantLib license. You should have received a
copy of the license along with this program; if not, please email
<quantlib-dev@lists.sf.net>. The license is also available online at
<http://quantlib.org/license.shtml>.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
#ifndef quantlib_gaussian_copula_policy_hpp
#define quantlib_gaussian_copula_policy_hpp
#include <ql/utilities/disposable.hpp>
#include <ql/math/distributions/normaldistribution.hpp>
#include <boost/bind.hpp>
#include <vector>
#include <numeric>
#include <algorithm>
namespace QuantLib {
/*! Gaussian Latent Model's copula policy. Its simplicity is a result of
the convolution stability of the Gaussian distribution.
*/
/* This is the only case that would have allowed the policy to be static,
but other copulas will need parameters and initialization.*/
struct GaussianCopulaPolicy {
typedef int initTraits;
explicit GaussianCopulaPolicy(
const std::vector<std::vector<Real> >& factorWeights =
std::vector<std::vector<Real> >(),
const initTraits& dummy = int())
: numFactors_(factorWeights.size() + factorWeights[0].size())
{
/* check factors in LM are normalized. */
for(Size iLVar=0; iLVar<factorWeights.size(); iLVar++) {
Real factorsNorm =
std::inner_product(factorWeights[iLVar].begin(),
factorWeights[iLVar].end(),
factorWeights[iLVar].begin(), 0.);
QL_REQUIRE(factorsNorm < 1.,
"Non normal random factor combination.");
}
/* check factor matrix is squared .......... */
}
/*! Number of independent random factors.
This is the only methos that ould stop the class from being static, it
is needed for the MC generator construction.
*/
Size numFactors() const {
return numFactors_;
}
//! returns a copy of the initialization arguments
initTraits getInitTraits() const {
return initTraits();
}
/*! Cumulative probability of the indexed latent variable
@param iVariable The index of the latent variable requested.
*/
Probability cumulativeY(Real val, Size iVariable) const {
return cumulative_(val);
}
//! Cumulative probability of the idiosyncratic factors (all the same)
Probability cumulativeZ(Real z) const {
return cumulative_(z);
}
/*! Probability density of a given realization of values of the systemic
factors (remember they are independent). In the normal case, since
they all follow the same law it is just a trivial product of the same
density.
Intended to be used in numerical integration of an arbitrary function
depending on those values.
*/
Probability density(const std::vector<Real>& m) const {
return std::accumulate(m.begin(), m.end(), Real(1.),
boost::bind(std::multiplies<Real>(), _1,
boost::bind(density_, _2)));
}
/*! Returns the inverse of the cumulative distribution of the (modelled)
latent variable (as indexed by iVariable). The normal stability avoids
the convolution of the factors' distributions
*/
Real inverseCumulativeY(Probability p, Size iVariable) const {
return InverseCumulativeNormal::standard_value(p);
}
/*! Returns the inverse of the cumulative distribution of the
idiosyncratic factor (identically distributed for all latent variables)
*/
Real inverseCumulativeZ(Probability p) const {
return InverseCumulativeNormal::standard_value(p);
}
/*! Returns the inverse of the cumulative distribution of the
systemic factor iFactor.
*/
Real inverseCumulativeDensity(Probability p, Size iFactor) const {
return InverseCumulativeNormal::standard_value(p);
}
//!
//to use this (by default) version, the generator must be a uniform one.
Disposable<std::vector<Real> >
allFactorCumulInverter(const std::vector<Real>& probs) const {
std::vector<Real> result;
result.resize(probs.size());
std::transform(probs.begin(), probs.end(), result.begin(),
boost::bind(&InverseCumulativeNormal::standard_value, _1));
return result;
}
private:
mutable Size numFactors_;
// no op =
static const NormalDistribution density_;
static const CumulativeNormalDistribution cumulative_;
};
}
#endif
|