public static (MultiPrecision <N>[] cs, MultiPrecision <N>[] ds) Table(MultiPrecision <N> nu, int m)
{
BesselLimitCoef <Plus16 <N> > limitcoef = new(nu.Convert <Plus16 <N> >());
MultiPrecision <N>[] cs = new MultiPrecision <N> [m + 1], ds = new MultiPrecision <N> [m + 1];
for (int j = 0; j <= m; j++)
{
ds[j] = ShiftedLegendre.Table(m, m - j) / ((m - j + 1) * limitcoef.Value(m - j + 1)).Convert <N>();
MultiPrecision <Plus16 <N> > sum = 0;
for (int p = m - j; p <= m; p++)
{
sum += ShiftedLegendre.Table(m, p) * limitcoef.Value(p - m + j) / ((p + 1) * limitcoef.Value(p + 1));
}
cs[j] = sum.Convert <N>();
}
return(cs, ds);
}
public static MultiPrecision <N>[][] Table(int m)
{
MultiPrecision <N>[][] dss = new MultiPrecision <N> [m + 1][];
BigInteger[] fs = new BigInteger[m + 2];
BigInteger[][] ps = new BigInteger[m + 1][], qs = new BigInteger[m + 1][];
(fs[0], fs[1]) = (1, 1);
(ps[0], ps[1]) = (new BigInteger[1] {
1
}, new BigInteger[2] {
-1, 1
});
(qs[0], qs[1]) = (new BigInteger[1] {
1
}, new BigInteger[2] {
-(2 * m + 1) * (2 * m + 1), 1
});
for (int k = 2; k <= m; k++)
{
(ps[k], qs[k]) = (new BigInteger[k + 1], new BigInteger[k + 1]);
int sq2km1 = (2 * k - 1) * (2 * k - 1), sq2mkp3 = (2 * (m - k) + 3) * (2 * (m - k) + 3);
ps[k][0] = -sq2km1 * ps[k - 1][0];
ps[k][k] = 1;
qs[k][0] = -sq2mkp3 * qs[k - 1][0];
qs[k][k] = 1;
for (int l = 1; l < k; l++)
{
ps[k][l] = ps[k - 1][l - 1] - sq2km1 * ps[k - 1][l];
qs[k][l] = qs[k - 1][l - 1] - sq2mkp3 * qs[k - 1][l];
}
fs[k] = k * fs[k - 1];
}
fs[m + 1] = (m + 1) * fs[m];
for (int i = 0; i <= m; i++)
{
dss[i] = new MultiPrecision <N> [i + 1];
for (int j = 0; j <= i; j++)
{
MultiPrecision <Plus16 <N> > b = 0;
for (int l = 0; l <= j; l++)
{
for (int k = j - l; k <= i - l; k++)
{
b += (MultiPrecision <Plus16 <N> >)(ShiftedLegendre.Table(m, m - k) * ps[i - k][l] * qs[k][j - l] * fs[m - k]) / (fs[i - k] * fs[m + 1]);
}
}
dss[i][j] = MultiPrecision <Plus16 <N> > .Ldexp(b, 2 *j - 3 *i).Convert <N>();
}
}
return(dss);
}
