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)); }