public void Generator_ForSequence3()
{
double[] expected = { 1, 2, 3, 3.5, 4.16666666666667, 4.69047619047619, 5.29238095238095, 5.81880106357264, 6.39184849183592, 6.91728310858544 };
var generator = new SequenceGenerator <int>(1, 2, (a, b) => a + b / a);
Assert.AreEqual(expected, generator.Generate(10));
}
public void Generator_ForSequence3Error()
{
double[] expected = { 1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587, 7.42763417076325, 8.31053343902137 };
var generator = new SequenceGenerator <double>(1, 2, (a, b) => a + b / a);
Assert.AreEqual(expected, generator.Generate(10));
}
public void Generator_ForSequence2Error()
{
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
var generator = new SequenceGenerator <int>(1, 2, (a, b) => 6 * a - 8 * b);
Assert.AreEqual(expected, generator.Generate(10));
}
public void Generator_ForSequence3()
{
double[] actual = SequenceGenerator.Generate <double>((double a, double b) => b + a / b, 10, 1, 2).ToArray();
double[] expected = { 1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587, 7.42763417076325, 8.31053343902137 };
CollectionAssert.AreEqual(actual, expected);
}
public void Generator_ForSequence1()
{
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
var generator = new SequenceGenerator <int>(1, 1, (a, b) => a + b);
Assert.AreEqual(expected, generator.Generate(10));
}
public void CreateWithValueLessThan1()
{
var start = BigInteger.Zero;
var generator = new SequenceGenerator();
Assert.Throws <InvalidValueException>(() => generator.Generate(start));
}
public void Generator_ForSequence1()
{
int[] actual = SequenceGenerator.Generate <int>((int a, int b) => a + b, 10, 1, 1).ToArray();
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
CollectionAssert.AreEqual(actual, expected);
}
public void Generator_ForSequence2()
{
int[] actual = SequenceGenerator.Generate <int>((int a, int b) => 6 * b - 8 * a, 10, 1, 2).ToArray();
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
CollectionAssert.AreEqual(actual, expected);
}
public void Generator_ForSequence2()
{
int[] expected = { 1, 2, -10, 92, -796, 6920, -60136, 522608, -4541680, 39469088 };
var generator = new SequenceGenerator <int>(1, 2, (a, b) => 6 * a - 8 * b);
Assert.AreEqual(expected, generator.Generate(10));
}
public void Generator_ForSequence1()
{
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
int[] actual = SequenceGenerator <int> .Generate((x, y) => x + y, 1, 1, 10).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Generator_ForSequence3()
{
double[] expected = { 1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587, 7.42763417076325, 8.31053343902137 };
var generator = new SequenceGenerator <double>(1, 2, (a, b) => a + b / a);
CollectionAssert.AreEqual(generator.Generate(10), expected, Comparer <double> .Create((a, b) => Math.Abs(a - b) <= 0.000000001 ? 0 : 1));
}
public void Generator_ForSequence2()
{
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
int[] actual = SequenceGenerator <int> .Generate((x, y) => 6 *y - 8 *x, 1, 2, 10).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Generator_ForSequence1()
{
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
Func <int, int, int> func = (x, y) => y + x;
CollectionAssert.AreEqual(expected, SequenceGenerator <int> .Generate(1, 1, 10, func).ToArray());
}
public void Generator_ForSequence2()
{
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
Func <int, int, int> func = (x, y) => 6 * y - 8 * x;
CollectionAssert.AreEqual(expected, SequenceGenerator <int> .Generate(1, 2, 10, func).ToArray());
}
public void Generator_ForSequence2()
{
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
var generator = new SequenceGenerator <int>(1, 2, (a, b) => 6 * a - 8 * b);
CollectionAssert.AreEqual(generator.Generate(10), expected);
}
public void Generator_ForSequence1()
{
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
var result = SequenceGenerator.Generate(expected.Length, 1, 1, (x, y) => x + y);
CollectionAssert.AreEqual(expected, result);
}
public void Generator_ForSequence2()
{
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
var result = SequenceGenerator.Generate(expected.Length, 1, 2, (x, y) => 6 * y - 8 * x);
CollectionAssert.AreEqual(expected, result);
}
public void Generator_ForSequence2()
{
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
IEnumerable <int> sequence = SequenceGenerator.Generate(expected[0], expected[1], expected.Length - 2, (a, b) => 6 * a - 8 * b);
int[] actual = sequence.ToArray();
Assert.AreEqual(expected, actual);
}
public void Create()
{
var start = new BigInteger(12);
var generator = new SequenceGenerator();
var statistics = generator.Generate(start).GetStatistics();
Assert.Equal(5, statistics.Even);
Assert.Equal(3, statistics.Odd);
Assert.Equal(12, statistics.Maximum);
}
public void Generator_ForSequence1()
{
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
IEnumerable <int> sequence = SequenceGenerator.Generate(expected[0], expected[1], expected.Length - 2, (a, b) => a + b);
int[] actual = sequence.ToArray();
Assert.AreEqual(expected, actual);
}
public void Generator_ForSequence1()
{
FunctionData <int> temp = new FunctionData <int>(1, 1, (x, y) => x + y);
int[] actual = SequenceGenerator <int> .Generate(temp).ToArray();
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
CollectionAssert.AreEqual(actual, expected);
}
public void Generator_ForSequence2()
{
FunctionData <int> temp = new FunctionData <int>(1, 2, (x, y) => 6 * y - 8 * x);
int[] actual = SequenceGenerator <int> .Generate(temp).ToArray();
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
CollectionAssert.AreEqual(actual, expected);
}
public void Generator_ForSequence3()
{
double[] expected = { 1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587, 7.42763417076325, 8.31053343902137 };
double[] actual = SequenceGenerator <double> .Generate((x, y) => y + x / y, 1, 2, 10).ToArray();
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 0.000001);
}
}
public void Create()
{
var start = new BigInteger(12);
var generator = new SequenceGenerator();
var sequence = generator.Generate(start);
// The original sequence I grabbed
// (from https://en.wikipedia.org/wiki/Collatz_conjecture)
// was this:
//Assert.Equal(new BigInteger[] { 12, 6, 3, 10, 5, 16, 8, 4, 2, 1 }, sequence);
Assert.Equal(new BigInteger[] { 12, 6, 3, 5, 8, 4, 2, 1 }, sequence);
}
public void Generator_ForSequence3()
{
double[] expected = { 1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587, 7.42763417076325, 8.31053343902137 };
IEnumerable <double> sequence = SequenceGenerator.Generate(expected[0], expected[1], expected.Length - 2, (a, b) => a + b / a);
double[] actual = sequence.ToArray();
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 0.001);
}
}
private static List <IEnumerable <Tuple <double, int> > > GenerateData(int pointCount)
{
const int count = 10;
var result = new List <IEnumerable <Tuple <double, int> > >(count);
var sg = new SequenceGenerator(10);
for (var i = 0; i < count; ++i)
{
result.Add(sg.Generate(pointCount).ToList());
}
return(result);
}
public void Generator_ForSequence3()
{
double[] expected = { 1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587, 7.42763417076325, 8.31053343902137 };
var result = SequenceGenerator.Generate(expected.Length, 1d, 2d, (x, y) => y + x / y).ToArray();
for (int i = 0; i < result.Length; ++i)
{
if (Math.Abs(result[i] - expected[i]) < 0.0000000000001)
{
Assert.False(false);
}
}
Assert.True(true);
}
public void Generator_ForSequence3()
{
FunctionData <double> temp = new FunctionData <double>(1, 2, (x, y) => y + x / y);
double[] actual = SequenceGenerator <double> .Generate(temp).ToArray();
double[] expected =
{
1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587,
7.42763417076325, 8.31053343902137
};
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(actual[i], expected[i], 0.000000000001);
}
}
public void Generator_ForSequence1()
{
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
int[] actual = SequenceGenerator.Generate(10, 1, 1, (a, b) => a + b).ToArray();
Assert.That(expected, Is.EquivalentTo(actual));
}
public void Generator_ForSequence3()
{
double[] expected = { 1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587, 7.42763417076325, 8.31053343902137 };
double[] actual = SequenceGenerator.Generate <double>(10, 1, 2, (a, b) => a + b / a).ToArray();
Assert.That(expected, Is.EqualTo(actual).Within(0.001));
}
