public InvCumulativeSobolGaussianRsg(SobolRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) : this(NQuantLibcPINVOKE.new_InvCumulativeSobolGaussianRsg__SWIG_1(SobolRsg.getCPtr(uniformSequenceGenerator), InverseCumulativeNormal.getCPtr(inverseCumulative)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public void InitialisationTest(int dim, SobolDirection direction)
{
var sobol = new SobolRsg(dim, direction);
sobol.NextSequence();
Assert.IsTrue(true);
}
public MoroInvCumulativeSobolGaussianRsg(SobolRsg uniformSequenceGenerator) : this(NQuantLibcPINVOKE.new_MoroInvCumulativeSobolGaussianRsg(SobolRsg.getCPtr(uniformSequenceGenerator)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public void testSobolSkipping()
{
//("Testing Sobol sequence skipping...");
ulong seed = 42;
int[] dimensionality = { 1, 10, 100, 1000 };
ulong[] skip = { 0, 1, 42, 512, 100000 };
SobolRsg.DirectionIntegers[] integers =
{
SobolRsg.DirectionIntegers.Unit,
SobolRsg.DirectionIntegers.Jaeckel,
SobolRsg.DirectionIntegers.SobolLevitan,
SobolRsg.DirectionIntegers.SobolLevitanLemieux
};
for (int i = 0; i < integers.Length; i++)
{
for (int j = 0; j < dimensionality.Length; j++)
{
for (int k = 0; k < skip.Length; k++)
{
// extract n samples
SobolRsg rsg1 = new SobolRsg(dimensionality[j], seed, integers[i]);
for (int l = 0; l < (int)skip[k]; l++)
{
rsg1.nextInt32Sequence();
}
// skip n samples at once
SobolRsg rsg2 = new SobolRsg(dimensionality[j], seed, integers[i]);
rsg2.skipTo(skip[k]);
// compare next 100 samples
for (int m = 0; m < 100; m++)
{
List <ulong> s1 = rsg1.nextInt32Sequence();
List <ulong> s2 = rsg2.nextInt32Sequence();
for (int n = 0; n < s1.Count; n++)
{
if (s1[n] != s2[n])
{
QAssert.Fail("Mismatch after skipping:"
+ "\n size: " + dimensionality[j]
+ "\n integers: " + integers[i]
+ "\n skipped: " + skip[k]
+ "\n at index: " + n
+ "\n expected: " + s1[n]
+ "\n found: " + s2[n]);
}
}
}
}
}
}
}
public static object Sobol(string directionType, int dimension, int nbPaths,
int nbSkippedPaths, object startDimIndexDisplay)
{
return(FunctionRunnerUtils.Run("CubicSpline", () =>
{
SobolDirection direction;
if (!Enum.TryParse(directionType, true, out direction))
{
throw new Exception(string.Format("Unknow sobol direction type {0}", directionType));
}
var sobolGen = new SobolRsg(dimension, direction);
sobolGen.SkipTo((ulong)nbSkippedPaths);
int startIndex;
if (!NumberConverter.TryConvertInteger(startDimIndexDisplay, out startIndex))
{
startIndex = 0;
}
if (startIndex >= dimension)
{
throw new Exception(string.Format("invalid startDimIndexDisplay : {0}", startIndex));
}
var result = new double[nbPaths, dimension - startIndex];
for (int i = 0; i < nbPaths; i++)
{
var sample = sobolGen.NextSequence();
for (int j = 0; j < dimension - startIndex; j++)
{
result[i, j] = sample[startIndex + j];
}
}
return result;
}));
}
public void RiskStatisticsTest()
{
// ("Testing risk measures...");
IncrementalGaussianStatistics igs = new IncrementalGaussianStatistics();
RiskStatistics s = new RiskStatistics();
double[] averages = { -100.0, -1.0, 0.0, 1.0, 100.0 };
double[] sigmas = { 0.1, 1.0, 100.0 };
int i, j, k, N;
N = (int)Math.Pow(2, 16) - 1;
double dataMin, dataMax;
List <double> data = new InitializedList <double>(N), weights = new InitializedList <double>(N);
for (i = 0; i < averages.Length; i++)
{
for (j = 0; j < sigmas.Length; j++)
{
NormalDistribution normal = new NormalDistribution(averages[i], sigmas[j]);
CumulativeNormalDistribution cumulative = new CumulativeNormalDistribution(averages[i], sigmas[j]);
InverseCumulativeNormal inverseCum = new InverseCumulativeNormal(averages[i], sigmas[j]);
SobolRsg rng = new SobolRsg(1);
dataMin = double.MaxValue;
dataMax = double.MinValue;
for (k = 0; k < N; k++)
{
data[k] = inverseCum.value(rng.nextSequence().value[0]);
dataMin = Math.Min(dataMin, data[k]);
dataMax = Math.Max(dataMax, data[k]);
weights[k] = 1.0;
}
igs.addSequence(data, weights);
s.addSequence(data, weights);
// checks
double calculated, expected;
double tolerance;
if (igs.samples() != N)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong number of samples\n"
+ " calculated: " + igs.samples() + "\n"
+ " expected: " + N);
}
if (s.samples() != N)
{
QAssert.Fail("RiskStatistics: wrong number of samples\n"
+ " calculated: " + s.samples() + "\n"
+ " expected: " + N);
}
// weightSum()
tolerance = 1e-10;
expected = weights.Sum();
calculated = igs.weightSum();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong sum of weights\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.weightSum();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong sum of weights\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// min
tolerance = 1e-12;
expected = dataMin;
calculated = igs.min();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong minimum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.min();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong minimum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// max
expected = dataMax;
calculated = igs.max();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong maximum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.max();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong maximum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// mean
expected = averages[i];
tolerance = (expected == 0.0 ? 1.0e-13 :
Math.Abs(expected) * 1.0e-13);
calculated = igs.mean();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong mean value"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.mean();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong mean value"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// variance
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.variance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong variance"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.variance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong variance"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// standardDeviation
expected = sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.standardDeviation();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong standard deviation"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.standardDeviation();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong standard deviation"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// missing errorEstimate() test
// skewness
expected = 0.0;
tolerance = 1.0e-4;
calculated = igs.skewness();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong skewness"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.skewness();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong skewness"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// kurtosis
expected = 0.0;
tolerance = 1.0e-1;
calculated = igs.kurtosis();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong kurtosis"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.kurtosis();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong kurtosis"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// percentile
expected = averages[i];
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianPercentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianPercentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.percentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// potential upside
double upper_tail = averages[i] + 2.0 * sigmas[j],
lower_tail = averages[i] - 2.0 * sigmas[j];
double twoSigma = cumulative.value(upper_tail);
expected = Math.Max(upper_tail, 0.0);
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianPotentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianPotentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.potentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// just to check that GaussianStatistics<StatsHolder> does work
StatsHolder h = new StatsHolder(s.mean(), s.standardDeviation());
GenericGaussianStatistics <StatsHolder> test = new GenericGaussianStatistics <StatsHolder>(h);
expected = s.gaussianPotentialUpside(twoSigma);
calculated = test.gaussianPotentialUpside(twoSigma);
if (calculated != expected)
{
QAssert.Fail("GenericGaussianStatistics<StatsHolder> fails"
+ "\n calculated: " + calculated
+ "\n expected: " + expected);
}
// value-at-risk
expected = -Math.Min(lower_tail, 0.0);
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianValueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianValueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.valueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
if (averages[i] > 0.0 && sigmas[j] < averages[i])
{
// no data will miss the targets:
// skip the rest of this iteration
igs.reset();
s.reset();
continue;
}
// expected shortfall
expected = -Math.Min(averages[i]
- sigmas[j] * sigmas[j]
* normal.value(lower_tail) / (1.0 - twoSigma),
0.0);
tolerance = (expected == 0.0 ? 1.0e-4
: Math.Abs(expected) * 1.0e-2);
calculated = igs.gaussianExpectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianExpectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.expectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// shortfall
expected = 0.5;
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.shortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// average shortfall
expected = sigmas[j] / Math.Sqrt(2.0 * Const.M_PI) * 2.0;
tolerance = expected * 1.0e-3;
calculated = igs.gaussianAverageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianAverageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.averageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// regret
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.gaussianRegret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianRegret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong Gaussian regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.regret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// downsideVariance
expected = s.downsideVariance();
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = igs.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// downsideVariance
if (averages[i] == 0.0)
{
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-3;
calculated = igs.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = igs.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
}
igs.reset();
s.reset();
}
}
}
public void testSobol()
{
//("Testing Sobol sequences up to dimension "
// + PPMT_MAX_DIM + "...");
List <double> point;
double tolerance = 1.0e-15;
// testing max dimensionality
int dimensionality = (int)SobolRsg.PPMT_MAX_DIM;
ulong seed = 123456;
SobolRsg rsg = new SobolRsg(dimensionality, seed);
int points = 100, i;
for (i = 0; i < points; i++)
{
point = rsg.nextSequence().value;
if (point.Count != dimensionality)
{
Assert.Fail("Sobol sequence generator returns " +
" a sequence of wrong dimensionality: " + point.Count
+ " instead of " + dimensionality);
}
}
// testing homogeneity properties
dimensionality = 33;
seed = 123456;
rsg = new SobolRsg(dimensionality, seed);
SequenceStatistics stat = new SequenceStatistics(dimensionality);
List <double> mean;
int k = 0;
for (int j = 1; j < 5; j++) // five cycle
{
points = (int)(Utils.Pow(2.0, j) - 1); // base 2
for (; k < points; k++)
{
point = rsg.nextSequence().value;
stat.add(point);
}
mean = stat.mean();
for (i = 0; i < dimensionality; i++)
{
double error = Math.Abs(mean[i] - 0.5);
if (error > tolerance)
{
Assert.Fail(i + 1 + " dimension: "
// + QL_FIXED
+ "mean (" + mean[i]
+ ") at the end of the " + j + 1
+ " cycle in Sobol sequence is not " + 0.5
//+ QL_SCIENTIFIC
+ " (error = " + error + ")");
}
}
}
// testing first dimension (van der Corput sequence)
double[] vanderCorputSequenceModuloTwo =
{
// first cycle (zero excluded)
0.50000,
// second cycle
0.75000, 0.25000,
// third cycle
0.37500, 0.87500, 0.62500, 0.12500,
// fourth cycle
0.18750, 0.68750, 0.93750, 0.43750, 0.31250, 0.81250, 0.56250, 0.06250,
// fifth cycle
0.09375, 0.59375, 0.84375, 0.34375, 0.46875, 0.96875, 0.71875, 0.21875,
0.15625, 0.65625, 0.90625, 0.40625, 0.28125, 0.78125, 0.53125, 0.03125
};
dimensionality = 1;
rsg = new SobolRsg(dimensionality);
points = (int)(Utils.Pow(2.0, 5)) - 1; // five cycles
for (i = 0; i < points; i++)
{
point = rsg.nextSequence().value;
double error = Math.Abs(point[0] - vanderCorputSequenceModuloTwo[i]);
if (error > tolerance)
{
Assert.Fail(i + 1 + " draw ("
//+ QL_FIXED
+ point[0]
+ ") in 1-D Sobol sequence is not in the "
+ "van der Corput sequence modulo two: "
+ "it should have been "
+ vanderCorputSequenceModuloTwo[i]
//+ QL_SCIENTIFIC
+ " (error = " + error + ")");
}
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SobolRsg obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SobolRsg obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
protected double mcReferenceValue(CmsCoupon cpn1,
CmsCoupon cpn2,
double cap,
double floor,
Handle <SwaptionVolatilityStructure> vol,
double correlation)
{
List <double> acc = new List <double>();
int samples = 1000000;
Matrix Cov = new Matrix(2, 2);
Cov[0, 0] = vol.currentLink().blackVariance(cpn1.fixingDate(), cpn1.index().tenor(),
cpn1.indexFixing());
Cov[1, 1] = vol.currentLink().blackVariance(cpn2.fixingDate(), cpn2.index().tenor(),
cpn2.indexFixing());
Cov[0, 1] = Cov[1, 0] = Math.Sqrt(Cov[0, 0] * Cov[1, 1]) * correlation;
Matrix C = MatrixUtilitites.pseudoSqrt(Cov, MatrixUtilitites.SalvagingAlgorithm.None);
List <double> atmRate = new InitializedList <double>(2), adjRate = new InitializedList <double>(2),
volShift = new InitializedList <double>(2);
Vector avg = new Vector(2);
atmRate[0] = cpn1.indexFixing();
atmRate[1] = cpn2.indexFixing();
adjRate[0] = cpn1.adjustedFixing;
adjRate[1] = cpn2.adjustedFixing;
if (vol.currentLink().volatilityType() == VolatilityType.ShiftedLognormal)
{
volShift[0] = vol.currentLink().shift(cpn1.fixingDate(), cpn1.index().tenor());
volShift[1] = vol.currentLink().shift(cpn2.fixingDate(), cpn2.index().tenor());
avg[0] =
Math.Log((adjRate[0] + volShift[0]) / (atmRate[0] + volShift[0])) -
0.5 * Cov[0, 0];
avg[1] =
Math.Log((adjRate[1] + volShift[1]) / (atmRate[1] + volShift[1])) -
0.5 * Cov[1, 1];
}
else
{
avg[0] = adjRate[0];
avg[1] = adjRate[1];
}
InverseCumulativeNormal icn = new InverseCumulativeNormal();
SobolRsg sb_ = new SobolRsg(2, 42);
Vector w = new Vector(2), z = new Vector(2);
for (int i = 0; i < samples; ++i)
{
List <double> seq = sb_.nextSequence().value;
w[0] = icn.value(seq[0]);
w[1] = icn.value(seq[1]);
z = C * w + avg;
for (int j = 0; j < 2; ++j)
{
if (vol.currentLink().volatilityType() == VolatilityType.ShiftedLognormal)
{
z[j] =
(atmRate[j] + volShift[j]) * Math.Exp(z[j]) - volShift[j];
}
}
acc.Add(Math.Min(Math.Max(z[0] - z[1], floor), cap));
}
return(acc.Average());
} // mcReferenceValue
public GaussianSobolGenerator(SobolRsg sobol)
{
this.sobol = sobol;
dim = sobol.Dimension();
}
