public void EvalTestOneArray()
{
double[] b0Values = { 0.0, 1.0 };
double[][] bValues =
{
new double[] { },
new double[] { 2.0 },
new double[] {2.0, 2.0 },
new double[] {2.0, 2.0, 2.0 },
new double[] {2.0, 2.0, 2.0, 2.0 }
};
foreach (double b0 in b0Values)
{
for (int i = 0; i < b0Values.Length; i++)
{
double[] b = bValues[i];
TestFraction1 f = _Fractions1[i];
double result = ContinuedFraction.Eval(b0, 1.0, b);
double expected = f.EquivalentFunction(b0, b);
Assert2.AreNear(expected, result, 2);
}
}
}
public override object CalculateResult()
{
var e = new ContinuedFraction(2,
new Range(2, int.MaxValue, 2)
.SelectMany(n => new long[] { 1, n, 1 }));
return e
.GetBigFractions()
.Skip(99)
.Select(f => MathUtilities.ToDigits(f.Numerator))
.First()
.Sum();
}
/// <summary>
///
/// </summary>
public AdditiveRecurrence(int a, int b, int c, int d)
{
var x = (a + b * ContinuedFraction.Sqrt(c, 60)) / d;
var g = BigInteger.Pow(2, 64);
var y = Rational.Floor(Rational.Frac(x.Convergents().Last()) * g);
if (y == g)
{
y--;
}
value = 0;
increment = (ulong)y | 1UL;
}
///https://oeis.org/A001203
public void continued_fration_pi()
{
var seq = new[] { 3d, 7d, 15d, 1d, 292d, 1d, 1d };
// Define the argumetns for the Continued Fraction.
double fa(int n, double[] a) => a[n];
double fb(int n, double[] a) => 1;
var cf = new ContinuedFraction(fa, fb);
var pi = cf.Evaluate(seq.Length, seq);
Assert.Equal(pi, Math.PI, DecimalPrecision);
}
public void EvalTestInfinite()
{
double expected, actual;
expected = 1.0 / (Math.Sqrt(Math.E) - 1.0);
// actual = ContinuedFraction.Eval(1.0, Series1(),tolerance,100);
actual = ContinuedFraction.Eval(1.0, Series1());
Assert2.AreNear(expected, actual, 10);
expected = 1.0 / (Math.E - 1.0);
// actual = ContinuedFraction.Eval(0.0, Series2(),tolerance,100);
actual = ContinuedFraction.Eval(0.0, Series2());
Assert2.AreNear(expected, actual, 10);
}
public void EvalTestInfiniteF()
{
double expected, actual;
Series1Function f1 = new Series1Function();
expected = 1.0 / (Math.Sqrt(Math.E) - 1.0);
// actual = ContinuedFraction.Eval(1.0, Series1(),tolerance,100);
actual = ContinuedFraction.Eval(1.0, f1.Next);
Assert2.AreNear(expected, actual, 10);
Series2Function f2 = new Series2Function();
expected = 1.0 / (Math.E - 1.0);
// actual = ContinuedFraction.Eval(0.0, Series2(),tolerance,100);
actual = ContinuedFraction.Eval(0.0, f2.Next);
Assert2.AreNear(expected, actual, 10);
}
public void EvalTestTwoArray()
{
double[] b0Values = { 0.0, 1.0 };
Tuple <double[], double[]>[] abValues =
{
new Tuple <double[], double[]>(new double[] { },
new double[] { }),
new Tuple <double[], double[]>(new double[] { 1.0 },
new double[] { 2.0 }),
new Tuple <double[], double[]>(new double[] {1.0, 1.0 },
new double[] { 2.0, 2.0 }),
new Tuple <double[], double[]>(new double[] {1.0, 1.0, 1.0 },
new double[] { 2.0, 2.0, 2.0 }),
new Tuple <double[], double[]>(new double[] {1.0, 1.0, 1.0 },
new double[] { 2.0, 2.0, 2.0 }),
// infinite series would =1/(Sqrt(e)-1)
// Source:http://mathworld.wolfram.com/ContinuedFraction.html
new Tuple <double[], double[]>(new double[] {2.0, 4.0, 6.0, 8.0 },
new double[] { 3.0, 5.0, 7.0, 9.0 }),
// infinite series would =1/(e-1)
// Source: http://mathworld.wolfram.com/ContinuedFraction.html
new Tuple <double[], double[]>(new double[] {1.0, 2.0, 3.0, 4.0 },
new double[] { 1.0, 2.0, 3.0, 4.0 })
};
foreach (double b0 in b0Values)
{
foreach (var abValue in abValues)
{
double[] a = abValue.Item1;
double[] b = abValue.Item2;
Debug.Assert(a.Length == b.Length);
TestFraction2 f = _Fractions2[a.Length];
double result = ContinuedFraction.Eval(b0, a, b);
double expected = f.EquivalentFunction(b0, a, b);
Assert2.AreNear(expected, result, 2);
}
}
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// CONTINUED_FRACTION_TEST tests the CONTINUED_FRACTION library.
//
// Licensing:
//
// I don't care what you do with this code.
//
// Modified:
//
// 07 August 2017
//
// Author:
//
// John Burkardt
//
{
Console.WriteLine("");
Console.WriteLine("CONTINUED_FRACTION_TEST:");
Console.WriteLine(" CONTINUED_FRACTION is a library for dealing with");
Console.WriteLine(" expresssions representing a continued fraction.");
ContinuedFraction.i4cf_evaluate_test( );
ContinuedFraction.i4scf_evaluate_test( );
ContinuedFraction.i8cf_evaluate_test( );
ContinuedFraction.i8scf_evaluate_test( );
ContinuedFraction.r8_to_i4scf_test( );
ContinuedFraction.r8_to_i8scf_test( );
ContinuedFraction.r8cf_evaluate_test( );
ContinuedFraction.r8scf_evaluate_test( );
Console.WriteLine("");
Console.WriteLine("CONTINUED_FRACTION_TEST:");
Console.WriteLine(" Normal end of execution.");
}
public static void Main(string[] args)
{
IEnumerable <BigInteger> goldenRatioTerms
= new PeriodicContinuedFractionTerms(
new List <BigInteger>(),
new List <BigInteger>()
{
1
});
ContinuedFraction goldenRatioCF = new ContinuedFraction(goldenRatioTerms);
Console.WriteLine("Phi = " + goldenRatioCF.ToString());
Console.WriteLine("Convergents: ");
for (int i = 0; i < 15; i++)
{
Rational convergent = goldenRatioCF.GetConvergent(i);
Console.WriteLine(convergent + " = " + (double)convergent);
}
Console.WriteLine();
double log2_5 = Math.Log(5) / Math.Log(2);
IEnumerable <BigInteger> log2_5_terms = new DoubleContinuedFractionTerms(log2_5);
ContinuedFraction log2_5_CF = new ContinuedFraction(log2_5_terms);
Console.WriteLine("log_2(5) = " + log2_5_CF.ToString());
Console.WriteLine("Convergents: ");
for (int i = 0; i < 15; i++)
{
Rational convergent = log2_5_CF.GetConvergent(i);
Console.WriteLine(convergent + " = " + (double)convergent);
}
}
public void Generalized_TestInvalidArgs()
{
Assert.Throws <ArgumentException>(() => ContinuedFraction.Generalized(null, null));
Assert.Throws <ArgumentException>(() => ContinuedFraction.Generalized(null, new double[] { }));
Assert.Throws <ArgumentException>(() => ContinuedFraction.Generalized(new double[] { 1, 1 }, new double[] { }));
}
public void Generalized_Test(double[] a, double[] b, double expected)
{
Assert.That(ContinuedFraction.Generalized(a, b), Is.EqualTo(expected).Within(1.0e-14));
}
public void Evaluate_TestGoldenRatio()
{
Assert.That(ContinuedFraction.Evaluate(Enumerable.Repeat(1.0, 40).ToArray()),
Is.EqualTo(0.5 * (Math.Sqrt(5.0) + 1.0)).Within(1.0e-16));
}
public void Evaluate_TestInvalidArg()
{
Assert.Throws <ArgumentException>(() => ContinuedFraction.Evaluate(new double[] { }));
Assert.Throws <ArgumentException>(() => ContinuedFraction.Evaluate(null));
}
public void Evaluate_Test(double[] a, double expected)
{
Assert.That(ContinuedFraction.Evaluate(a), Is.EqualTo(expected).Within(1.0e-14));
}
