public void ThreeUnknownsTest()
        {
            var geneRange = Enumerable.Range(-5, 11).ToArray();
            var geneSet   =
                (from n in geneRange from d in geneRange.Where(i => i != 0) select new Fraction(n, d))
                .Distinct().OrderBy(g => g).ToArray();

            IReadOnlyList <Fraction> FnGenesToInputs(IReadOnlyList <Fraction> genes) => genes;

            Fraction E1(IReadOnlyList <Fraction> genes) =>
            6 * genes[0] - 2 * genes[1] + 8 * genes[2] - 20;

            Fraction E2(IReadOnlyList <Fraction> genes) =>
            genes[1] + 8 * genes[0] * genes[2] + 1;

            Fraction E3(IReadOnlyList <Fraction> genes) =>
            2 * genes[2] * 6 / genes[0] + 3 * genes[1] / 2 - 6;

            var equations = new FnEquationDelegate[] { E1, E2, E3 };

            SolveUnknown(3, geneSet, equations, FnGenesToInputs);
            //Assert.AreEqual(new Fraction(0), best.Fitness.TotalDifference);
            //CollectionAssert.AreEqual(
            //    new[]
            //    {
            //        new Fraction(2, 3),
            //        new Fraction(-5),
            //        new Fraction(3, 4)
            //    }, best.Genes);
        }
        public void FourUnknownsTest()
        {
            var geneRange = Enumerable.Range(-13, 27).Where(i => i != 0).ToArray();
            var geneSet   =
                (from n in geneRange from d in geneRange.Where(i => i != 0) select new Fraction(n, d))
                .Distinct().OrderBy(g => g).ToArray();

            IReadOnlyList <Fraction> FnGenesToInputs(IReadOnlyList <Fraction> genes) => genes;

            Fraction E1(IReadOnlyList <Fraction> genes) =>
            new Fraction(1, 15) * genes[0] - 2 * genes[1] - 15 * genes[2] - new Fraction(4, 5) * genes[3] - 3;

            Fraction E2(IReadOnlyList <Fraction> genes) =>
            - new Fraction(5, 2) * genes[0] - new Fraction(9, 4) * genes[1] + 12 * genes[2] - genes[3] - 17;

            Fraction E3(IReadOnlyList <Fraction> genes) =>
            - 13 * genes[0] + new Fraction(3, 10) * genes[1] - 6 * genes[2] - new Fraction(2, 5) * genes[3] - 17;

            Fraction E4(IReadOnlyList <Fraction> genes) =>
            new Fraction(1, 2) * genes[0] + 2 * genes[1] + new Fraction(7, 4) * genes[2] +
            new Fraction(4, 3) * genes[3] + 9;

            var equations = new FnEquationDelegate[] { E1, E2, E3, E4 };

            SolveUnknown(4, geneSet, equations, FnGenesToInputs);
            //Assert.AreEqual(new Fraction(0), best.Fitness.TotalDifference);
            //CollectionAssert.AreEqual(
            //    new[]
            //    {
            //        new Fraction(-3, 2),
            //        new Fraction(-7, 2),
            //        new Fraction(1, 3),
            //        new Fraction(-11, 8)
            //    }, best.Genes);
        }
        public void TwoUnknownsTest()
        {
            var range   = Enumerable.Range(-5, 11).ToArray();
            var geneSet =
                (from n in range from d in range.Where(i => i != 0) select new Fraction(n, d))
                .Distinct().OrderBy(g => g).ToArray();

            IReadOnlyList <Fraction> FnGenesToInputs(IReadOnlyList <Fraction> genes) => genes;

            Fraction E1(IReadOnlyList <Fraction> genes) =>
            genes[0] + 2 * genes[1] - 4;

            Fraction E2(IReadOnlyList <Fraction> genes) =>
            4 * genes[0] + 4 * genes[1] - 12;

            var equations = new FnEquationDelegate[] { E1, E2 };

            SolveUnknown(2, geneSet, equations, FnGenesToInputs);
            //Assert.AreEqual(new Fraction(0), best.Fitness.TotalDifference);
            //CollectionAssert.AreEqual(
            //    new[]
            //    {
            //        new Fraction(2),
            //        new Fraction(1)
            //    }, best.Genes);
        }
        public void FitnessTest()
        {
            var child = new List <Fraction> {
                new Fraction(2), new Fraction(-1)
            };

            Fraction E1(IReadOnlyList <Fraction> genes) => genes[0] + 2 * genes[1] - 4;
            Fraction E2(IReadOnlyList <Fraction> genes) => 4 * genes[0] + 4 * genes[1] - 12;

            var equations = new FnEquationDelegate[] { E1, E2 };
            var fitness   = GetFitness(child, equations);

            Assert.AreEqual(new Fraction(12), fitness.TotalDifference);
        }