public GaussianKernel(double average, double sigma) { nd_ = new NormalDistribution(average, sigma); cnd_ = new CumulativeNormalDistribution(average, sigma); // normFact is \sqrt{2*\pi}. normFact_ = Const.M_SQRT2 * Const.M_SQRTPI; }
/// <summary> /// Shortfall. /// </summary> /// <param name="target"></param> /// <param name="mean"></param> /// <param name="std"></param> /// <returns></returns> public static double Shortfall(double target, double mean, double std) { var gIntegral = new CumulativeNormalDistribution(mean, std); return(gIntegral.Value(target)); }
public void SmallSampleCheck() { CumulativeNormalDistribution cnd = new CumulativeNormalDistribution(); Assert.AreEqual(0.5, cnd.ValueOf(0.0), 1e-6); Assert.AreEqual(1.0, cnd.ValueOf(double.PositiveInfinity)); Assert.AreEqual(0.0, cnd.ValueOf(double.NegativeInfinity)); // values obtained with Maple 9.01 Assert.AreEqual(.6914624613, cnd.ValueOf(0.5), 1e-6); Assert.AreEqual(.3085375387, cnd.ValueOf(-0.5), 1e-6); Assert.AreEqual(.9331927987, cnd.ValueOf(1.5), 1e-6); Assert.AreEqual(.06680720127, cnd.ValueOf(-1.5), 1e-6); cnd = new CumulativeNormalDistribution(1.0, 2.0); Assert.AreEqual(0.0, cnd.ValueOf(1.0), 0.5); Assert.AreEqual(1.0, cnd.ValueOf(double.PositiveInfinity)); Assert.AreEqual(0.0, cnd.ValueOf(double.NegativeInfinity)); // values obtained with Maple 9.01 Assert.AreEqual(.4012936743, cnd.ValueOf(0.5), 1e-6); Assert.AreEqual(.2266273524, cnd.ValueOf(-0.5), 1e-6); Assert.AreEqual(.5987063257, cnd.ValueOf(1.5), 1e-6); Assert.AreEqual(.1056497737, cnd.ValueOf(-1.5), 1e-6); }
/// <summary> /// Average shortfall. /// </summary> /// <param name="target"></param> /// <param name="mean"></param> /// <param name="std"></param> /// <returns></returns> public static double AverageShortfall(double target, double mean, double std) { var gIntegral = new CumulativeNormalDistribution(mean, std); var g = new NormalDistribution(mean, std); return((target - mean) * gIntegral.Value(target) + std * std * g.Value(target)); }
public static double Greeks([ExcelArgument("Spot Price of Underlying")] double spot, [ExcelArgument("Strike Price")] double strike, [ExcelArgument("Risk-Free Rate")] double rfr, [ExcelArgument("Annualised Volatility")] double vol, [ExcelArgument("Time to Maturity")] double tenor, [ExcelArgument("Option Type")] string opt_type, [ExcelArgument("Option Type")] string greeks_type) { var d_1 = (Math.Log(spot / strike) + (rfr + Math.Pow(vol, 2) / 2) * (tenor)) / (vol * Math.Sqrt(tenor)); var d_2 = (d_1 - vol * Math.Sqrt(tenor)); var NormINV = new CumulativeNormalDistribution(0, 1); if (opt_type == "Put") { if (greeks_type == "Delta") { return(-Math.Pow(Math.E, -rfr * tenor) * NormINV.value(d_1)); } else if (greeks_type == "Gamma") { return((Math.Pow(Math.E, -rfr * tenor) * NormINV.value(d_1)) / spot * vol * Math.Sqrt(tenor)); } else { return(0); } } else if (opt_type == "Call") { if (greeks_type == "Delta") { return(Math.Pow(Math.E, -rfr * tenor) * NormINV.value(d_1)); } else if (greeks_type == "Gamma") { return((Math.Pow(Math.E, -rfr * tenor) * NormINV.value(d_1)) / spot * vol * Math.Sqrt(tenor)); } else { return(0); } } else { return(0); } }
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(); } } }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CumulativeNormalDistribution obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public void testOperatorConsistency() { //("Testing differential operators..."); NormalDistribution normal = new NormalDistribution(average, sigma); CumulativeNormalDistribution cum = new CumulativeNormalDistribution(average, sigma); double xMin = average - 4 * sigma, xMax = average + 4 * sigma; int N = 10001; double h = (xMax - xMin) / (N - 1); Vector x = new Vector(N), y = new Vector(N), yi = new Vector(N), yd = new Vector(N), temp = new Vector(N), diff = new Vector(N); for (int i = 0; i < N; i++) { x[i] = xMin + h * i; } for (int i = 0; i < x.Count; i++) { y[i] = normal.value(x[i]); } for (int i = 0; i < x.Count; i++) { yi[i] = cum.value(x[i]); } for (int i = 0; i < x.size(); i++) { yd[i] = normal.derivative(x[i]); } // define the differential operators DZero D = new DZero(N, h); DPlusDMinus D2 = new DPlusDMinus(N, h); // check that the derivative of cum is Gaussian temp = D.applyTo(yi); for (int i = 0; i < y.Count; i++) { diff[i] = y[i] - temp[i]; } double e = Utilities.norm(diff, diff.size(), h); if (e > 1.0e-6) { Assert.Fail("norm of 1st derivative of cum minus Gaussian: " + e + "\ntolerance exceeded"); } // check that the second derivative of cum is normal.derivative temp = D2.applyTo(yi); for (int i = 0; i < yd.Count; i++) { diff[i] = yd[i] - temp[i]; } e = Utilities.norm(diff, diff.size(), h); if (e > 1.0e-4) { Assert.Fail("norm of 2nd derivative of cum minus Gaussian derivative: " + e + "\ntolerance exceeded"); } }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CumulativeNormalDistribution obj) { return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; }