public void ChebyshevSpecialCases()
{
foreach (double x in bArguments)
{
Assert.IsTrue(OrthogonalPolynomials.ChebyshevT(0, x) == 1.0);
Assert.IsTrue(OrthogonalPolynomials.ChebyshevT(1, x) == x);
}
foreach (int n in orders)
{
if (n % 2 == 0)
{
if (n % 4 == 0)
{
Assert.IsTrue(OrthogonalPolynomials.ChebyshevT(n, 0.0) == 1.0);
}
else
{
Assert.IsTrue(OrthogonalPolynomials.ChebyshevT(n, 0.0) == -1.0);
}
}
else
{
Assert.IsTrue(OrthogonalPolynomials.ChebyshevT(n, 0.0) == 0.0);
}
Assert.IsTrue(OrthogonalPolynomials.ChebyshevT(n, 1.0) == 1.0);
}
}
public void AssociatedLegendreOrthonormalityL()
{
// don't let l and m get too big, or numerical integration will fail due to heavily oscilatory behavior
int[] ells = TestUtilities.GenerateIntegerValues(1, 10, 4);
for (int ki = 0; ki < ells.Length; ki++)
{
int k = ells[ki];
for (int li = 0; li <= ki; li++)
{
int l = ells[li];
foreach (int m in TestUtilities.GenerateUniformIntegerValues(0, Math.Min(k, l), 4))
{
Func <double, double> f = delegate(double x) {
return(OrthogonalPolynomials.LegendreP(k, m, x) * OrthogonalPolynomials.LegendreP(l, m, x));
};
double I = FunctionMath.Integrate(f, Interval.FromEndpoints(-1.0, 1.0));
Console.WriteLine("k={0} l={1} m={2} I={3}", k, l, m, I);
if (k == l)
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
I, 2.0 / (2 * k + 1) * Math.Exp(AdvancedIntegerMath.LogFactorial(l + m) - AdvancedIntegerMath.LogFactorial(l - m))
));
}
else
{
Assert.IsTrue(Math.Abs(I) < TestUtilities.TargetPrecision);
}
}
}
}
}
public void HermiteAddition()
{
foreach (int n in orders)
{
if (n > 100)
{
continue;
}
foreach (double x in aArguments)
{
foreach (double y in aArguments)
{
double value = OrthogonalPolynomials.HermiteH(n, x + y);
double[] terms = new double[n + 1]; double sum = 0.0;
for (int k = 0; k <= n; k++)
{
terms[k] = AdvancedIntegerMath.BinomialCoefficient(n, k) * OrthogonalPolynomials.HermiteH(k, x) * Math.Pow(2 * y, n - k);
sum += terms[k];
}
Console.WriteLine("n={0}, x={1}, y={2}, H(x+y)={3}, sum={4}", n, x, y, value, sum);
Assert.IsTrue(TestUtilities.IsSumNearlyEqual(terms, value));
}
}
}
}
public void HermiteSpecialCases()
{
foreach (double x in aArguments)
{
Assert.IsTrue(OrthogonalPolynomials.HermiteH(0, x) == 1.0);
Assert.IsTrue(OrthogonalPolynomials.HermiteH(1, x) == 2.0 * x);
}
foreach (int n in orders)
{
if (n > 100)
{
continue;
}
if (n % 2 == 0)
{
int m = n / 2;
int s = 1;
if (m % 2 != 0)
{
s = -s;
}
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.HermiteH(n, 0.0), s * AdvancedIntegerMath.Factorial(n) / AdvancedIntegerMath.Factorial(m)));
}
else
{
Assert.IsTrue(OrthogonalPolynomials.HermiteH(n, 0.0) == 0.0);
}
}
}
public void ChebyshevMultiplication()
{
foreach (int n in orders)
{
foreach (int m in orders)
{
if (n * m > 500)
{
continue; // we don't test very high order
}
foreach (double x in bArguments)
{
Console.WriteLine("n={0}, m={1}, x={2}", n, m, x);
double Tm = OrthogonalPolynomials.ChebyshevT(m, x);
Console.WriteLine("T_m(x)= {0}", Tm);
double Tn = OrthogonalPolynomials.ChebyshevT(n, Tm);
Console.WriteLine("T_n(T_m) = {0}", Tn);
double Tnm = OrthogonalPolynomials.ChebyshevT(n * m, x);
Console.WriteLine("T_nm(x) = {0}", Tnm);
double d = Math.Abs(Tn - Tnm) / Math.Abs(Tnm);
Console.WriteLine("relative d = {0}", d);
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ChebyshevT(n, OrthogonalPolynomials.ChebyshevT(m, x)), OrthogonalPolynomials.ChebyshevT(n * m, x)));
}
}
}
}
public void ChebyshevInequality()
{
foreach (int n in orders)
{
foreach (double x in bArguments)
{
Assert.IsTrue(Math.Abs(OrthogonalPolynomials.ChebyshevT(n, x)) <= 1.0);
}
}
}
public void LegendreInequality()
{
foreach (int n in orders)
{
foreach (double x in bArguments)
{
Assert.IsTrue(Math.Abs(OrthogonalPolynomials.LegendreP(n, x)) <= 1.0);
}
}
}
public void LegendreRecurrence()
{
foreach (int n in orders)
{
foreach (double x in bArguments)
{
Assert.IsTrue(TestUtilities.IsNearlyEqual((n + 1) * OrthogonalPolynomials.LegendreP(n + 1, x), (2 * n + 1) * x * OrthogonalPolynomials.LegendreP(n, x) - n * OrthogonalPolynomials.LegendreP(n - 1, x)));
}
}
}
public void LaguerreInequality()
{
foreach (int n in TestUtilities.GenerateRealValues(1.0, 1.0E2, 5))
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-2, 1.0E2, 5))
{
Assert.IsTrue(OrthogonalPolynomials.LaguerreL(n, x) <= Math.Exp(x / 2.0));
}
}
}
public void LegendreNegativeOrder()
{
foreach (int n in orders)
{
foreach (double x in bArguments)
{
Assert.IsTrue(OrthogonalPolynomials.LegendreP(-n, x) == OrthogonalPolynomials.LegendreP(n - 1, x));
}
}
}
public void ChebyshevRecurrence()
{
foreach (int n in orders)
{
foreach (double x in bArguments)
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ChebyshevT(n + 1, x), 2.0 * x * OrthogonalPolynomials.ChebyshevT(n, x) - OrthogonalPolynomials.ChebyshevT(n - 1, x)));
}
}
}
public void ChebyshevCosine()
{
// test T_n(cos t) = cos(n t)
foreach (int n in TestUtilities.GenerateIntegerValues(1, 100, 5))
{
foreach (double t in GenerateRandomAngles(-Math.PI, Math.PI, 5))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ChebyshevT(n, Math.Cos(t)), Math.Cos(n * t)));
}
}
}
public void LaguerreSpecialCases()
{
foreach (int n in TestUtilities.GenerateIntegerValues(1, 100, 5))
{
Assert.IsTrue(OrthogonalPolynomials.LaguerreL(n, 0.0) == 1.0);
}
foreach (double x in TestUtilities.GenerateRealValues(1.0E-4, 1.0E4, 5))
{
Assert.IsTrue(OrthogonalPolynomials.LaguerreL(0, x) == 1.0);
}
}
public void LegendreSpecialCases()
{
foreach (double x in bArguments)
{
Assert.IsTrue(OrthogonalPolynomials.LegendreP(0, x) == 1.0);
Assert.IsTrue(OrthogonalPolynomials.LegendreP(1, x) == x);
}
foreach (int n in orders)
{
Assert.IsTrue(OrthogonalPolynomials.LegendreP(n, 1.0) == 1.0);
}
}
public void AssociatedLegendreAgreement()
{
foreach (int l in TestUtilities.GenerateIntegerValues(1, 100, 5))
{
foreach (double x in TestUtilities.GenerateRealValues(0.01, 1.0, 5))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
OrthogonalPolynomials.LegendreP(l, 0, x), OrthogonalPolynomials.LegendreP(l, x)
));
}
}
}
public void AssociatedLegendreLowOrders()
{
foreach (double x in TestUtilities.GenerateRealValues(0.01, 1.0, 10))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.LegendreP(0, 0, x), 1.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.LegendreP(1, 0, x), x));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.LegendreP(1, 1, x), -Math.Sqrt(1.0 - x * x)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.LegendreP(2, 0, x), (3.0 * x * x - 1.0) / 2.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.LegendreP(2, 1, x), -3.0 * x * Math.Sqrt(1.0 - x * x)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.LegendreP(2, 2, x), 3.0 * (1.0 - x * x)));
}
}
public void LegendreTuronInequality()
{
foreach (int n in orders)
{
foreach (double x in bArguments)
{
Assert.IsTrue(
MoreMath.Pow(OrthogonalPolynomials.LegendreP(n, x), 2) >=
OrthogonalPolynomials.LegendreP(n - 1, x) * OrthogonalPolynomials.LegendreP(n + 1, x)
);
}
}
}
public void LaguerreRecurrence()
{
foreach (int n in TestUtilities.GenerateRealValues(1.0, 1.0E2, 5))
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-4, 1.0E4, 10))
{
double LP = OrthogonalPolynomials.LaguerreL(n + 1, x);
double L = OrthogonalPolynomials.LaguerreL(n, x);
double LM = OrthogonalPolynomials.LaguerreL(n - 1, x);
Assert.IsTrue(TestUtilities.IsSumNearlyEqual((n + 1) * LP, n * LM, (2 * n + 1 - x) * L));
}
}
}
public void HermiteRecurrence()
{
foreach (int n in TestUtilities.GenerateIntegerValues(1, 100, 10))
{
foreach (double x in TestUtilities.GenerateRealValues(1.0, 1000.0, 10))
{
Console.WriteLine("n={0} x={1}", n, x);
Assert.IsTrue(TestUtilities.IsSumNearlyEqual(
OrthogonalPolynomials.HermiteH(n + 1, x), 2.0 * n * OrthogonalPolynomials.HermiteH(n - 1, x),
2.0 * x * OrthogonalPolynomials.HermiteH(n, x)
));
}
}
}
public void HermiteNormalExpectation()
{
// Wikipedia article on Hermite polynomials
// X ~ N(\mu, 1) => E(He_n(X)) = \mu^n
NormalDistribution d = new NormalDistribution(2.0, 1.0);
foreach (int n in TestUtilities.GenerateIntegerValues(1, 32, 7))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
d.ExpectationValue(x => OrthogonalPolynomials.HermiteHe(n, x)),
MoreMath.Pow(d.Mean, n)
));
}
}
public void AssociatedLaguerreSpecialCases()
{
foreach (double a in TestUtilities.GenerateRealValues(0.01, 100.0, 5))
{
foreach (double x in TestUtilities.GenerateRealValues(0.01, 100.0, 5))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
OrthogonalPolynomials.LaguerreL(0, a, x), 1.0
));
Assert.IsTrue(TestUtilities.IsNearlyEqual(
OrthogonalPolynomials.LaguerreL(1, a, x), 1.0 + a - x
));
}
}
}
public void AssociatedLaguerreOrthonormality()
{
// don't let orders get too big, or (1) the Gamma function will overflow and (2) our integral will become highly oscilatory
foreach (int n in TestUtilities.GenerateIntegerValues(1, 10, 3))
{
foreach (int m in TestUtilities.GenerateIntegerValues(1, 10, 3))
{
foreach (double a in TestUtilities.GenerateRealValues(0.1, 10.0, 5))
{
//int n = 2;
//int m = 4;
//double a = 3.5;
Console.WriteLine("n={0} m={1} a={2}", n, m, a);
// evaluate the orthonormal integral
Func <double, double> f = delegate(double x) {
return(Math.Pow(x, a) * Math.Exp(-x) *
OrthogonalPolynomials.LaguerreL(m, a, x) *
OrthogonalPolynomials.LaguerreL(n, a, x)
);
};
Interval r = Interval.FromEndpoints(0.0, Double.PositiveInfinity);
// need to loosen default evaluation settings in order to get convergence in some of these cases
// seems to have most convergence problems for large a
IntegrationSettings e = new IntegrationSettings();
e.AbsolutePrecision = TestUtilities.TargetPrecision;
e.RelativePrecision = TestUtilities.TargetPrecision;
double I = FunctionMath.Integrate(f, r, e).Value;
Console.WriteLine(I);
// test for orthonormality
if (n == m)
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
I, AdvancedMath.Gamma(n + a + 1) / AdvancedIntegerMath.Factorial(n)
));
}
else
{
Assert.IsTrue(Math.Abs(I) < TestUtilities.TargetPrecision);
}
}
}
}
}
public void ZernikeSpecialCases()
{
foreach (double x in TestUtilities.GenerateUniformRealValues(0.0, 1.0, 4))
{
Console.WriteLine(x);
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(0, 0, x), 1.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(1, 1, x), x));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(2, 0, x), 2.0 * x * x - 1.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(2, 2, x), x * x));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(3, 1, x), 3.0 * x * x * x - 2.0 * x));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(3, 3, x), x * x * x));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(4, 0, x), 6.0 * x * x * x * x - 6.0 * x * x + 1.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(4, 2, x), 4.0 * x * x * x * x - 3.0 * x * x));
Assert.IsTrue(TestUtilities.IsNearlyEqual(OrthogonalPolynomials.ZernikeR(4, 4, x), x * x * x * x));
}
}
public void AssociatedLaguerreAlphaRecurrence()
{
foreach (int n in TestUtilities.GenerateIntegerValues(1, 100, 5))
{
foreach (double a in TestUtilities.GenerateRealValues(0.01, 100.0, 5))
{
foreach (double x in TestUtilities.GenerateRealValues(0.01, 100.0, 5))
{
Assert.IsTrue(TestUtilities.IsSumNearlyEqual(
OrthogonalPolynomials.LaguerreL(n, a - 1.0, x), OrthogonalPolynomials.LaguerreL(n - 1, a, x),
OrthogonalPolynomials.LaguerreL(n, a, x)
));
}
}
}
}
public void AssociatedLegendreRecurrenceL()
{
foreach (int l in TestUtilities.GenerateIntegerValues(1, 100, 4))
{
foreach (int m in TestUtilities.GenerateUniformIntegerValues(0, l - 1, 4))
{
foreach (double x in TestUtilities.GenerateRealValues(0.01, 1.0, 4))
{
Assert.IsTrue(TestUtilities.IsSumNearlyEqual(
(l - m + 1) * OrthogonalPolynomials.LegendreP(l + 1, m, x),
(l + m) * OrthogonalPolynomials.LegendreP(l - 1, m, x),
(2 * l + 1) * x * OrthogonalPolynomials.LegendreP(l, m, x)
));
}
}
}
}
public void SphericalHarmonicLegendre()
{
foreach (int ell in TestUtilities.GenerateIntegerValues(1, 100, 6))
{
foreach (double theta in GenerateRandomAngles(-Math.PI, Math.PI, 5))
{
// this loop shouldn't matter since the answer is phi-independent
foreach (double phi in GenerateRandomAngles(0.0, 2.0 * Math.PI, 3))
{
Complex Y = AdvancedMath.SphericalHarmonic(ell, 0, theta, phi);
double LP = Math.Sqrt((2 * ell + 1) / (4.0 * Math.PI)) * OrthogonalPolynomials.LegendreP(ell, Math.Cos(theta));
Console.WriteLine("l={0}, m=0, t={1}, p={2}, Y={3}, LP={4}", ell, theta, phi, Y, LP);
Assert.IsTrue(TestUtilities.IsNearlyEqual(Y, LP));
}
}
}
}
public void LegendreReflection()
{
foreach (int n in orders)
{
foreach (double x in bArguments)
{
if (n % 2 == 0)
{
Assert.IsTrue(OrthogonalPolynomials.LegendreP(n, -x) == OrthogonalPolynomials.LegendreP(n, x));
}
else
{
Assert.IsTrue(OrthogonalPolynomials.LegendreP(n, -x) == -OrthogonalPolynomials.LegendreP(n, x));
}
}
}
}
public void LaguerreOrthonormality()
{
// to avoid highly oscilatory integrals, don't use very high orders
int[] orders = TestUtilities.GenerateIntegerValues(1, 30, 3);
for (int i = 0; i < orders.Length; i++)
{
int n = orders[i];
for (int j = 0; j <= i; j++)
{
int m = orders[j];
Func <double, double> f = delegate(double x) {
return(Math.Exp(-x) * OrthogonalPolynomials.LaguerreL(n, x) * OrthogonalPolynomials.LaguerreL(m, x));
};
Interval r = Interval.FromEndpoints(0.0, Double.PositiveInfinity);
double I = FunctionMath.Integrate(f, r);
Console.WriteLine("{0} {1} {2}", n, m, I);
if (n == m)
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(I, 1.0));
}
else
{
Assert.IsTrue(Math.Abs(I) < TestUtilities.TargetPrecision);
}
}
}
/*
* foreach (int n in TestUtilities.GenerateIntegerValues(1, 100, 3)) {
* foreach (int m in TestUtilities.GenerateIntegerValues(1, 100, 3)) {
* Function<double, double> f = delegate(double x) {
* return (Math.Exp(-x) * OrthogonalPolynomials.LaguerreL(n, x) * OrthogonalPolynomials.LaguerreL(m, x));
* };
* Interval r = Interval.FromEndpoints(0.0, Double.PositiveInfinity);
* double I = FunctionMath.Integrate(f, r);
* Console.WriteLine("{0} {1} {2}", n, m, I);
* if (n == m) {
* Assert.IsTrue(TestUtilities.IsNearlyEqual(I, 1.0));
* } else {
* Assert.IsTrue(Math.Abs(I) < TestUtilities.TargetPrecision);
* }
* }
* }
*/
}
public void HypergeometricPolynomials()
{
foreach (int n in TestUtilities.GenerateUniformIntegerValues(0, 10, 4))
{
foreach (double x in TestUtilities.GenerateRealValues(1.0E-2, 1.0, 4))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedMath.Hypergeometric2F1(-n, n, 0.5, x),
OrthogonalPolynomials.ChebyshevT(n, 1.0 - 2.0 * x)
));
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedMath.Hypergeometric2F1(-n, n + 1, 1.0, x),
OrthogonalPolynomials.LegendreP(n, 1.0 - 2.0 * x)
));
}
}
}
public void AssociatedLegendreRecurrenceM()
{
foreach (int l in TestUtilities.GenerateIntegerValues(1, 100, 4))
{
foreach (int m in TestUtilities.GenerateUniformIntegerValues(0, l - 1, 4))
{
foreach (double x in TestUtilities.GenerateRealValues(0.1, 1.0, 4))
{
Console.WriteLine("l={0} m={1} x={2}", l, m, x);
Assert.IsTrue(TestUtilities.IsSumNearlyEqual(
OrthogonalPolynomials.LegendreP(l, m + 1, x),
(l + m) * (l - m + 1) * OrthogonalPolynomials.LegendreP(l, m - 1, x),
-2 * m * x / Math.Sqrt(1.0 - x * x) * OrthogonalPolynomials.LegendreP(l, m, x)
));
}
}
}
}
