public void CallNaiveImplemXCheck()
{
var maturities = GridUtils.RegularGrid(0.1, 5.0, 100);
var vols = GridUtils.RegularGrid(0.01, 1.0, 10);
var volMoneynesses = GridUtils.RegularGrid(-3, 3, 100);
foreach (var mat in maturities)
{
foreach (var vol in vols)
{
var sigma = Math.Sqrt(mat) * vol;
foreach (var vm in volMoneynesses)
{
var strike = Math.Exp(vm * sigma);
var call = BlackScholesOption.Price(1.0, strike, vol, mat, 1);
//Naive implementation of black-scholes formulae
var d_plus = -(vm * sigma) / sigma + 0.5 * sigma;
var d_minus = d_plus - sigma;
var call_xcheck = NormalDistribution.Cumulative(d_plus) - strike * NormalDistribution.Cumulative(d_minus);
if (DoubleUtils.EqualZero(call))
{
Assert.IsTrue(DoubleUtils.EqualZero(call_xcheck));
}
else
{
var errRelative = (call - call_xcheck) / call_xcheck;
Assert.IsTrue(Math.Abs(errRelative) < 1.0e-11);
}
}
}
}
}
public void CallNaiveImplemXCheck()
{
var maturities = GridUtils.RegularGrid(0.1, 5.0, 100);
var vols = GridUtils.RegularGrid(0.001, 0.015, 10);
var volMoneynesses = GridUtils.RegularGrid(-3, 3, 100);
foreach (var mat in maturities)
{
foreach (var vol in vols)
{
var sigma = Math.Sqrt(mat) * vol;
foreach (var vm in volMoneynesses)
{
var strike = vm * sigma;
var call = BachelierOption.Price(0.0, strike, vol, mat, 1);
//Naive implementation of bachelier formulae
var d = strike / sigma;
var call_xcheck = -strike *NormalDistribution.Cumulative(-d) + sigma * NormalDistribution.Density(d);
if (DoubleUtils.EqualZero(call))
{
Assert.IsTrue(DoubleUtils.EqualZero(call_xcheck));
}
else
{
var errRelative = (call - call_xcheck) / call_xcheck;
Assert.IsTrue(Math.Abs(errRelative) < 1.0e-13);
}
}
}
}
}
public void SpecialValues()
{
Assert.AreEqual(NormalDistribution.Cumulative(0.0), 0.5);
Assert.AreEqual(NormalDistribution.Cumulative(double.PositiveInfinity), 1.0);
Assert.AreEqual(NormalDistribution.Cumulative(double.NegativeInfinity), 0.0);
Assert.AreEqual(NormalDistribution.Cumulative(double.MaxValue), 1.0);
Assert.AreEqual(NormalDistribution.Cumulative(double.MinValue), 0.0);
}
public void InverseHigherRegion()
{
var grid = GridUtils.RegularGrid(2.0, 6.0, 1000);
foreach (var x in grid)
{
var p = NormalDistribution.Cumulative(x);
var proxy_x = NormalDistribution.CumulativeInverse(p);
var err = Math.Abs((proxy_x - x) / x);
Assert.IsTrue(err < 1.0e-8);
}
}
public void InverseCentralRegion()
{
var grid = GridUtils.RegularGrid(-2.0, 2.0, 1000);
foreach (var x in grid)
{
var p = NormalDistribution.Cumulative(x);
var proxy_x = NormalDistribution.CumulativeInverse(p);
var errRelative = Math.Abs(proxy_x - x);
Assert.IsTrue(errRelative < 13 * DoubleUtils.MachineEpsilon);
}
}
public void CheckSymmetry()
{
var rand = new Random(1468);
for (int i = 0; i < 10000; i++)
{
var x = rand.NextDouble() * 30.0; // random in [0, 30]
var norm_x = NormalDistribution.Cumulative(x);
var norm_minusx = NormalDistribution.Cumulative(-x);
var err = Math.Abs((norm_x + norm_minusx) - 1.0);
Assert.IsTrue(DoubleUtils.EqualZero(err));
}
}
public void ProxyCrossCheck()
{
var rand = new Random(1515);
for (int i = 0; i < 10000; i++)
{
var x = rand.NextDouble() * 5.0; // random in [0, 5]
var norm_x = NormalDistribution.Cumulative(x);
var proxy_norm_x = CdfProxy(x);
var err = Math.Abs((proxy_norm_x - norm_x) / norm_x);
Assert.IsTrue(err < 1.4e-7);
}
}
public void FastVsPreciseInverse()
{
var bound = NormalDistribution.CumulativeInverse(1.0e-6);
var grid = GridUtils.RegularGrid(bound, -bound, 1000);
foreach (var x in grid)
{
var p = NormalDistribution.Cumulative(x);
var precise = NormalDistribution.CumulativeInverse(p);
var fast = NormalDistribution.FastCumulativeInverse(p);
var errRelative = Math.Abs(fast - precise);
Assert.IsTrue(errRelative < 3.0e-9);
}
}
