public void ComplexLogGammaRealLogGammaAgreement()
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-4, 1.0E4, 24))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.LogGamma(x), AdvancedMath.LogGamma(x)));
}
}
public void ComplexDiLogConjugation () {
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-1, 1.0E1, 8)) {
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.DiLog(z.Conjugate), AdvancedComplexMath.DiLog(z).Conjugate
));
}
}
public void ComplexReimannZetaPrimesTest()
{
// pick high enough values so that p^-x == 1 within double precision before we reach the end of our list of primes
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0, 100.0, 8))
{
Complex zz = z;
if (zz.Re < 0.0)
{
zz = -zz;
}
zz += 10.0;
Console.WriteLine(zz);
Complex f = 1.0;
for (int p = 2; p < 100; p++)
{
if (!AdvancedIntegerMath.IsPrime(p))
{
continue;
}
Complex t = Complex.One - ComplexMath.Pow(p, -zz);
if (t == Complex.One)
{
break;
}
f = f * t;
}
Assert.IsTrue(TestUtilities.IsNearlyEqual(1.0 / AdvancedComplexMath.RiemannZeta(zz), f));
}
}
public void ComplexGammaConjugation () {
// limited to 10^-2 to 10^2 to avoid overflow
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 10)) {
Console.WriteLine("z={0} G(z*)={1} G*(z)={2}", z, AdvancedComplexMath.Gamma(z.Conjugate), AdvancedComplexMath.Gamma(z).Conjugate);
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(z.Conjugate), AdvancedComplexMath.Gamma(z).Conjugate));
}
}
public void ComplexGammaDuplicationTest()
{
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 16))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(2.0 * z), ComplexMath.Pow(2.0, 2.0 * z - 0.5) * AdvancedComplexMath.Gamma(z) * AdvancedComplexMath.Gamma(z + 0.5) / Math.Sqrt(2.0 * Math.PI)));
}
}
public void ComplexGammaInequality()
{
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 10))
{
Console.WriteLine(z);
Assert.IsTrue(ComplexMath.Abs(AdvancedComplexMath.Gamma(z)) <= Math.Abs(AdvancedMath.Gamma(z.Re)));
}
}
public void ComplexRealRiemannZetaAgreement()
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-2, 1.0E2, 8))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.RiemannZeta(x), AdvancedMath.RiemannZeta(x)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.RiemannZeta(-x), AdvancedMath.RiemannZeta(-x)));
}
}
public void ComplexDiLogAgreement () {
// use negative arguments b/c positive real DiLog function complex for x > 1
foreach (double x in TestUtilities.GenerateRealValues(1.0E-2, 1.0E2, 10)) {
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedMath.DiLog(-x), AdvancedComplexMath.DiLog(-x)
));
}
}
public void ComplexGammaConjugation()
{
// limited to 10^-2 to 10^2 to avoid overflow
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 8))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(z.Conjugate), AdvancedComplexMath.Gamma(z).Conjugate));
}
}
public void ComplexPsiConjugation () {
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E3, 12)) {
Console.WriteLine(z);
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.Psi(z.Conjugate),
AdvancedComplexMath.Psi(z).Conjugate
));
}
}
public void ComplexFaddeevaDawson () {
foreach (double x in TestUtilities.GenerateRealValues(1.0E-4,1.0E4,10)) {
Complex w = AdvancedComplexMath.Faddeeva(x);
double F = AdvancedMath.Dawson(x);
Console.WriteLine("x={0} F={1} w={2}", x, F, w);
Assert.IsTrue(TestUtilities.IsNearlyEqual(w.Re, Math.Exp(-x * x)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(w.Im, (2.0/Math.Sqrt(Math.PI)) * AdvancedMath.Dawson(x)));
}
}
public void ComplexErfFresnel () {
// don't let x get too big or we run into problem of accruacy for arguments of large trig-like functions
foreach (double x in TestUtilities.GenerateRealValues(1.0E-1, 1.0E2, 16)) {
Complex z = Math.Sqrt(Math.PI) * (1.0 - ComplexMath.I) * x / 2.0;
Complex w = (1.0 + ComplexMath.I) * AdvancedComplexMath.Erf(z) / 2.0;
Assert.IsTrue(TestUtilities.IsNearlyEqual(w.Re, AdvancedMath.FresnelC(x)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(w.Im, AdvancedMath.FresnelS(x)));
}
}
public void ComplexPsiDuplication () {
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E3, 12)) {
Console.WriteLine(z);
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.Psi(2.0 * z),
AdvancedComplexMath.Psi(z) / 2.0 + AdvancedComplexMath.Psi(z + 0.5) / 2.0 + Math.Log(2.0)
));
}
}
public void ComplexGammaKnownLines () {
// to avoid problems with trig functions of large arguments, don't let x get too big
foreach (double x in TestUtilities.GenerateRealValues(1.0E-4, 1.0E2, 16)) {
Console.WriteLine(x);
double px = Math.PI * x;
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(new Complex(0.0, x)) * AdvancedComplexMath.Gamma(new Complex(0.0, -x)), Math.PI / x / Math.Sinh(px)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(new Complex(0.5, x)) * AdvancedComplexMath.Gamma(new Complex(0.5, -x)), Math.PI / Math.Cosh(px)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(new Complex(1.0, x)) * AdvancedComplexMath.Gamma(new Complex(1.0, -x)), px / Math.Sinh(px)));
}
}
public void ComplexEinE1Agreement()
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-3, 1.0E3, 8))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.Ein(x),
AdvancedMath.IntegralE(1, x) + AdvancedMath.EulerGamma + Math.Log(x)
));
}
}
public void ComplexGammaRecurrance () {
// fails when extended to more numbers due to a loss of last 4 digits of accuracy in an extreme case; look into it
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 10)) {
Complex G = AdvancedComplexMath.Gamma(z);
Complex Gz = G * z;
Complex GP = AdvancedComplexMath.Gamma(z + 1.0);
Console.WriteLine("z={0:g16} G(z)={1:g16} G(z)*z={2:g16} G(z+1)={3:g16}", z, G, Gz, GP);
Assert.IsTrue(TestUtilities.IsNearlyEqual(Gz,GP));
}
}
public void ComplexGammaRecurrance()
{
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 16))
{
Complex G = AdvancedComplexMath.Gamma(z);
Complex Gz = G * z;
Complex GP = AdvancedComplexMath.Gamma(z + 1.0);
Assert.IsTrue(TestUtilities.IsNearlyEqual(Gz, GP));
}
}
public void ComplexLogGammaComplexGammaAgreement()
{
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 16))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
ComplexMath.Exp(AdvancedComplexMath.LogGamma(z)),
AdvancedComplexMath.Gamma(z)
));
}
}
public void ComplexLogGammaConjugation () {
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-4, 1.0E4, 24)) {
if (z.Re <= 0.0) continue;
Console.WriteLine("z={0} lnG(z*)={1} lnG*(z)={2}", z, AdvancedComplexMath.LogGamma(z.Conjugate), AdvancedComplexMath.LogGamma(z).Conjugate);
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.LogGamma(z.Conjugate),
AdvancedComplexMath.LogGamma(z).Conjugate
));
}
}
public void ComplexLogGammaConjugation()
{
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-4, 1.0E4, 24))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.LogGamma(z.Conjugate),
AdvancedComplexMath.LogGamma(z).Conjugate
));
}
}
public void ComplexDiLogClausen()
{
foreach (double t in TestUtilities.GenerateUniformRealValues(0.0, 2.0 * Math.PI, 4))
{
Complex z = AdvancedComplexMath.DiLog(ComplexMath.Exp(ComplexMath.I * t));
Assert.IsTrue(TestUtilities.IsNearlyEqual(z.Re, Math.PI * Math.PI / 6.0 - t * (2.0 * Math.PI - t) / 4.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(z.Im, AdvancedMath.Clausen(t)));
}
}
public void ComplexGammaInequalities()
{
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 16))
{
Assert.IsTrue(ComplexMath.Abs(AdvancedComplexMath.Gamma(z)) <= Math.Abs(AdvancedMath.Gamma(z.Re)));
if (z.Re >= 0.5)
{
Assert.IsTrue(ComplexMath.Abs(AdvancedComplexMath.Gamma(z)) >= Math.Abs(AdvancedMath.Gamma(z.Re)) / Math.Sqrt(Math.Cosh(Math.PI * z.Im)));
}
}
}
public void ComplexLogGammaRecurrance()
{
// Don't try for z << 1, because z + 1 won't retain enough digits to satisfy
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E4, 24))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.LogGamma(z + 1.0),
AdvancedComplexMath.LogGamma(z) + ComplexMath.Log(z)
));
}
}
public void ComplexFaddeevaConjugation()
{
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-4, 1.0E4, 50))
{
if (z.Im * z.Im > Math.Log(Double.MaxValue / 10.0))
{
continue; // large imaginary values blow up
}
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Faddeeva(z.Conjugate), AdvancedComplexMath.Faddeeva(-z).Conjugate));
}
}
public void ComplexGammaRecurrance()
{
// G * z can loose digits from the cancelation of the two terms that contribute to its real and imaginary parts.
// This appears to be what happens when this fails. For now, just limit ourselves to few values that don't have this problem.
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-1, 1.0E1, 8))
{
Complex G = AdvancedComplexMath.Gamma(z);
Complex Gz = G * z;
Complex GP = AdvancedComplexMath.Gamma(z + 1.0);
Assert.IsTrue(TestUtilities.IsNearlyEqual(Gz, GP));
}
}
public void ComplexGammaKnownLines()
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-4, 1.0E2, 16))
{
Console.WriteLine(x);
double px = Math.PI * x;
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(new Complex(0.0, x)) * AdvancedComplexMath.Gamma(new Complex(0.0, -x)), Math.PI / x / Math.Sinh(px)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(new Complex(0.5, x)) * AdvancedComplexMath.Gamma(new Complex(0.5, -x)), Math.PI / Math.Cosh(px)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(new Complex(1.0, x)) * AdvancedComplexMath.Gamma(new Complex(1.0, -x)), px / Math.Sinh(px)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedComplexMath.Gamma(new Complex(0.25, x)) * AdvancedComplexMath.Gamma(new Complex(0.75, -x)), Math.Sqrt(2.0) * Math.PI / new Complex(Math.Cosh(px), Math.Sinh(px))));
}
}
public void ComplexErfSymmetries () {
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-1, 1.0E3, 16)) {
// for large imaginary parts, erf overflows, so don't try them
if (z.Im * z.Im > 500.0) continue;
//Console.WriteLine("{0} {1} {2} {3}", z, AdvancedComplexMath.Erf(z), AdvancedComplexMath.Erf(-z), AdvancedComplexMath.Erf(z.Conjugate));
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.Erf(-z), -AdvancedComplexMath.Erf(z)
));
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.Erf(z.Conjugate), AdvancedComplexMath.Erf(z).Conjugate
));
}
}
public void ComplexErfFaddevaAgreement () {
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-1, 1.0E2, 16)) {
Complex w = AdvancedComplexMath.Faddeeva(z);
Complex erf = AdvancedComplexMath.Erf(-ComplexMath.I * z);
Complex erfc = 1.0 - erf;
Complex f = ComplexMath.Exp(z * z);
Console.WriteLine("z={0} w={1} erf={2} erfc={3} f={4} w'={5} erf'={6}", z, w, erf, erfc, f, erfc / f, 1.0 - f * w);
if (Double.IsInfinity(f.Re) || Double.IsInfinity(f.Im) || f == 0.0) continue;
//Console.WriteLine("{0} {1}", TestUtilities.IsNearlyEqual(w, erfc / f), TestUtilities.IsNearlyEqual(erf, 1.0 - f * w));
Assert.IsTrue(TestUtilities.IsNearlyEqual(
erf, 1.0 - f * w
));
}
}
public void ComplexEinCinSiAgreement()
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-2, 1.0E2, 8))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.Ein(Complex.I * x).Im,
AdvancedMath.IntegralSi(x)
));
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.Ein(Complex.I * x).Re,
AdvancedMath.IntegralCin(x)
));
}
}
public void ComplexPsiRecurrence () {
foreach (Complex z in TestUtilities.GenerateComplexValues(1.0E-2, 1.0E2, 16)) {
//Complex z = new Complex(0.398612, 888.865);
//double t = Math.Exp(900.0);
//Console.WriteLine("{0} {1}", t, 1.0 / t);
Console.WriteLine("z={0}", z);
//Console.WriteLine("Psi(1-z)={0}", AdvancedComplexMath.Psi(1.0 - z));
//Console.WriteLine("Tan(pi z)={0}", ComplexMath.Tan(Math.PI * z));
//Console.WriteLine("{0} {1}", z, AdvancedComplexMath.Psi(z));
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedComplexMath.Psi(z + 1.0),
AdvancedComplexMath.Psi(z) + 1.0 / z
));
}
}
