Initial data commit

Task/Pathological-floating-point-problems/C-sharp/pathological-floating-point-problems-2.cs

@@ -0,0 +1,118 @@
+static class Task1
+{
+    public static IEnumerable<float> SequenceSingle()
+    {
+        // n, n-1, and n-2
+        float vn, vn_1, vn_2;
+        vn_2 = 2;
+        vn_1 = -4;
+
+        while (true)
+        {
+            yield return vn_2;
+            vn = 111f - (1130f / vn_1) + (3000f / (vn_1 * vn_2));
+            vn_2 = vn_1;
+            vn_1 = vn;
+        }
+    }
+
+    public static IEnumerable<double> SequenceDouble()
+    {
+        // n, n-1, and n-2
+        double vn, vn_1, vn_2;
+        vn_2 = 2;
+        vn_1 = -4;
+
+        while (true)
+        {
+            yield return vn_2;
+            vn = 111 - (1130 / vn_1) + (3000 / (vn_1 * vn_2));
+            vn_2 = vn_1;
+            vn_1 = vn;
+        }
+    }
+
+    public static IEnumerable<decimal> SequenceDecimal()
+    {
+        // n, n-1, and n-2
+        decimal vn, vn_1, vn_2;
+        vn_2 = 2;
+        vn_1 = -4;
+
+        // Use constants to avoid calling the Decimal constructor in the loop.
+        const decimal i11 = 111;
+        const decimal i130 = 1130;
+        const decimal E000 = 3000;
+
+        while (true)
+        {
+            yield return vn_2;
+            vn = i11 - (i130 / vn_1) + (E000 / (vn_1 * vn_2));
+            vn_2 = vn_1;
+            vn_1 = vn;
+        }
+    }
+
+#if USE_BIGRATIONAL
+    public static IEnumerable<BigRational> SequenceRational()
+    {
+        // n, n-1, and n-2
+        BigRational vn, vn_1, vn_2;
+        vn_2 = 2;
+        vn_1 = -4;
+
+        // Same reasoning as for decimal.
+        BigRational i11 = 111;
+        BigRational i130 = 1130;
+        BigRational E000 = 3000;
+
+        while (true)
+        {
+            yield return vn_2;
+            vn = i11 - (i130 / vn_1) + (E000 / (vn_1 * vn_2));
+            vn_2 = vn_1;
+            vn_1 = vn;
+        }
+    }
+#else
+    public static IEnumerable<BigRational> SequenceRational()
+    {
+        while (true) yield return default;
+    }
+#endif
+
+    static void IncreaseMaxN(ref int[] arr)
+    {
+        int[] tmp = new int[arr.Length + 1];
+        arr.CopyTo(tmp, 0);
+        tmp[arr.Length] = 1000;
+        arr = tmp;
+    }
+
+    public static void WrongConvergence()
+    {
+        Console.WriteLine("Wrong Convergence Sequence:");
+
+        int[] displayedIndices = { 3, 4, 5, 6, 7, 8, 20, 30, 50, 100 };
+        IncreaseMaxN(ref displayedIndices);
+
+        var indicesSet = new HashSet<int>(displayedIndices);
+
+        Console.WriteLine(Headings);
+
+        int n = 1;
+        // Enumerate the implementations in parallel as tuples.
+        foreach (var x in SequenceSingle()
+            .Zip(SequenceDouble(), (sn, db) => (sn, db))
+            .Zip(SequenceDecimal(), (a, dm) => (a.sn, a.db, dm))
+            .Zip(SequenceRational(), (a, br) => (a.sn, a.db, a.dm, br)))
+        {
+            if (n > displayedIndices.Max()) break;
+
+            if (indicesSet.Contains(n))
+                Console.WriteLine(FormatOutput(n, x));
+
+            n++;
+        }
+    }
+}