public static Rational Harmonic(BigInteger n, int m)
{
Rational sum = 0;
for (BigInteger k = 1; k <= n; k++)
{
sum += Rational.Inv(Rational.Pow(k, m));
}
return(sum);
}
/// <summary>
/// Generates the series (1+az)^r.
/// </summary>
public static Series Binomial(Rational a, Rational r)
{
int degree = InfinityDegree;
if (r.IsInteger && r.Top >= 0 && r.Top <= int.MaxValue)
{
degree = (int)r.Top;
}
if (a == Rational.One)
{
return(new Series((n, s) => Discrete.Binomial(r, n), order: 0, degree: degree));
}
else
{
return(new Series((n, s) => Rational.Pow(a, n) * Discrete.Binomial(r, n), order: 0, degree: degree));
}
}
public Polynomial <Rational, RationalField> ToPolynomial(int degree, Polynomial <Rational, RationalField> x)
{
int low = this.Order;
int high = degree;
if (x.Terms.Length == 1)
{
var terms = new List <Term <Rational> >();
var leadingTerm = x.Terms[0];
for (int i = low; i <= high; i++)
{
var term = new Term <Rational>(x.Degree * i, this[i] * Rational.Pow(leadingTerm.Coeff, i));
Polynomial <Rational, RationalField> .Add(terms, term);
}
return(new Polynomial <Rational, RationalField>(terms));
}
else
{
Polynomial <Rational, RationalField> result = Polynomial <Rational, RationalField> .Zero;
int i;
for (i = high; i >= low; i--)
{
result *= x;
result += this[i];
}
for (; i >= 0; i--)
{
result *= x;
}
return(result);
}
}
/// <summary>
/// Generates the series f(az^k).
/// </summary>
/// <param name="a">A rational.</param>
/// <param name="k">A positive integer.</param>
/// <returns>The series f(az^k).</returns>
public Series ComposeZPow(Rational a, int k)
{
if (a == Rational.Zero)
{
return(Zero);
}
Func <int, Series, Rational> compute = (n, s) =>
{
if (n % k == 0)
{
return(this[n / k] * Rational.Pow(a, n / k));
}
else
{
return(Rational.Zero);
}
};
if (k == 1)
{
compute = (n, s) => this[n] * Rational.Pow(a, n);
if (a == Rational.One)
{
return(this);
}
else if (a == Rational.MinusOne)
{
compute = (n, s) => Discrete.AlternateSign(this[n], n);
}
}
else
{
if (a == Rational.One)
{
compute = (n, s) =>
{
if (n % k == 0)
{
return(this[n / k]);
}
else
{
return(Rational.Zero);
}
};
}
else if (a == Rational.MinusOne)
{
compute = (n, s) =>
{
if (n % k == 0)
{
return(Discrete.AlternateSign(this[n / k], n / k));
}
else
{
return(Rational.Zero);
}
};
}
}
return(new Series(compute, order: ExtendedMultiply(this.Order, k), degree: ExtendedMultiply(this.Degree, k)));
}
