public void ErrorFunctionComplementarity()
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-2, 1.0E2, 8))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedMath.Erf(x) + AdvancedMath.Erfc(x), 1.0));
}
}
public void ErfReflection()
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-2, 1.0E2, 4))
{
Assert.IsTrue(AdvancedMath.Erf(-x) == -AdvancedMath.Erf(x));
}
}
public void InverseErfTest()
{
foreach (double P in TestUtilities.GenerateRealValues(1.0E-8, 1.0, 16))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedMath.Erf(AdvancedMath.InverseErf(P)), P));
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedMath.Erfc(AdvancedMath.InverseErfc(P)), P));
}
}
public TruncatedNormalDistribution(double D)
{
if (D <= 0.0)
{
throw new ArgumentOutOfRangeException("D");
}
this.D = D;
this.ED = AdvancedMath.Erf(D / Global.SqrtTwo);
}
public void Bug5705()
{
// large arguments to Erf and Erfc would cause a NonconvergeException because of the way the continued fraction for GammaQ
// was evaluated; we added an explicit test before entering the evaluation loop to avoid this
Assert.IsTrue(AdvancedMath.Erf(Double.NegativeInfinity) == -1.0); Assert.IsTrue(AdvancedMath.Erfc(Double.NegativeInfinity) == 2.0);
Assert.IsTrue(AdvancedMath.Erf(Double.MinValue) == -1.0); Assert.IsTrue(AdvancedMath.Erfc(Double.MinValue) == 2.0);
Assert.IsTrue(AdvancedMath.Erf(Double.MaxValue) == 1.0); Assert.IsTrue(AdvancedMath.Erfc(Double.MaxValue) == 0.0);
Assert.IsTrue(AdvancedMath.Erf(Double.PositiveInfinity) == 1.0); Assert.IsTrue(AdvancedMath.Erfc(Double.PositiveInfinity) == 0.0);
// we should add tests of the behavior of all our advanced functions with large/infinite arguments
}
// standard normal left CDF, usually denoted by capital Phi
// this is used by several other distributions, so we expose it here
internal static double Phi(double z)
{
if (z < 0.0)
{
return(0.5 * AdvancedMath.Erfc(-z / Global.SqrtTwo));
}
else
{
return(0.5 * (1.0 + AdvancedMath.Erf(z / Global.SqrtTwo)));
}
}
private void FillNormalFunctionChart()
{
Dictionary <double, double> points = new Dictionary <double, double>();
Func <double, double, double, double> func = (x, u, q) =>
(1 + AdvancedMath.Erf((x - u) / Math.Sqrt(2 * Math.Pow(q, 2)))) / 2;
for (int i = -3; i <= 3; i++)
{
points.Add(i, func(i, 0, 1));
}
FillChart(points, normalFunc);
}
public void ErrorFunctionExtremeValues()
{
Assert.IsTrue(AdvancedMath.Erf(Double.MaxValue) == 1.0);
Assert.IsTrue(AdvancedMath.Erfc(Double.MaxValue) == 0.0);
Assert.IsTrue(AdvancedMath.Erf(Double.PositiveInfinity) == 1.0);
Assert.IsTrue(AdvancedMath.Erfc(Double.PositiveInfinity) == 0.0);
Assert.IsTrue(AdvancedMath.Erf(-Double.MaxValue) == -1.0);
Assert.IsTrue(AdvancedMath.Erf(Double.NegativeInfinity) == -1.0);
Assert.IsTrue(Double.IsNaN(AdvancedMath.Erf(Double.NaN)));
Assert.IsTrue(Double.IsNaN(AdvancedMath.Erfc(Double.NaN)));
}
public void DoubleDoubleErrorFunctionAgreement()
{
foreach (DoubleDouble x in DoubleDoubleTest.GetRandomDoubleDoubles(1.0E-2, 1.0E2, 8))
{
DoubleDouble xErf = AdvancedDoubleDoubleMath.Erf(x);
double xErfAsDouble = (double)xErf;
double xAsDouble = (double)x;
double xAsDoubleErf = AdvancedMath.Erf(xAsDouble);
Assert.IsTrue(TestUtilities.IsNearlyEqual(xErfAsDouble, xAsDoubleErf));
DoubleDouble xErfc = AdvancedDoubleDoubleMath.Erfc(x);
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(xErf + xErfc, DoubleDouble.One));
}
}
public void ExponentialBox()
{
// Mentioned in passing in http://crd-legacy.lbl.gov/~dhbailey/dhbpapers/BoxII.pdf
// This is easy because the integrand is seperable and smooth.
for (int d = 2; d <= 10; d++)
{
IntegrationResult result = MultiFunctionMath.Integrate((IReadOnlyList <double> r) => {
double s = 0.0;
foreach (double x in r)
{
s += x * x;
}
return(Math.Exp(-s));
}, UnitCube(d));
Assert.IsTrue(result.Estimate.ConfidenceInterval(0.95).ClosedContains(
MoreMath.Pow(Math.Sqrt(Math.PI) / 2.0 * AdvancedMath.Erf(1.0), d)
));
}
}
public static double FLogNorm(List <double> A, double x)
{
List <double> PA = new List <double>();
for (int i = 0; i < A.Count; i++)
{
PA.Add(Math.Pow(A[i], 2));
}
for (int i = 0; i < A.Count; i++)
{
if (A[i] < 0)
{
A[i] = Math.Abs(A[i]);
}
}
double mu = PointMark.Ave(A) /*2 * Math.Log(Moment.StartMoment(1,A.Count,A))-1/2*Math.Log(Moment.StartMoment(2, A.Count, A))*/;
double sigm = PointMark.Disp(A, PointMark.Ave(A)) /*Math.Sqrt(Math.Log(Moment.StartMoment(2, A.Count, A)) - 2* Math.Log(Moment.StartMoment(1, A.Count, A)))*/;
double FLN = (1.0 / 2) + (1.0 / 2) * (AdvancedMath.Erf((Math.Log(x) - mu) / (sigm)));
return(FLN);
}
private double CentralProbability(double x)
{
return(AdvancedMath.Erf(x / Global.SqrtTwo) / ED);
}
public void ErrorFunctionSpecialCases()
{
Assert.IsTrue(AdvancedMath.Erf(0.0) == 0.0);
Assert.IsTrue(AdvancedMath.Erfc(0.0) == 1.0);
}
