Repository: danm-de/Fractions
Pull request #104: Fixes the rounding issue with the general format (DecimalNotationFormatter)
Author: login: lipchev
Created: 2025-03-02T20:02:32Z | Merged: 2025-03-12T16:35:25Z

fixes #102

- optimizes the performance of the `Round`, `GetExponentPower`, `AppendDecimals` and `AppendSignificantDecimals`
- rounding mode fixed to `AwayFromZero` (used to be `ToEven` for `net8`)
- removes the negative zero (-0.0) output (as is the output for the `decimal` which has a nominal zero)
- completes the test coverage for the `DecimalNotationFormatter`
- adds benchmarks (with results) for the `Round` functions

Linked issue #102: DecimalNotationFormatter with "G2" returns "2.0"
Yeah, that's why 95% coverage isn't enough..

<!DOCTYPE html>
<HTML>
<body>
<!--StartFragment-->

  | Name | Value | Type
-- | -- | -- | --
  | DecimalNotationFormatter.Format("G2", 2.001234m, null) | "2.0" | string
  | 2.001234.ToString("G2") | "2" | string
  | DecimalNotationFormatter.Format("G2", 1m, null) | "1" | string


<!--EndFragment-->
</body>
</HTML>

The good news is that I caught this while trying to get to 100%, so the upcoming PR is going to come with a fix for this as well..
Linked issue comments: user: login: danm-de
created_at: 2025-03-02T19:12:12Z
body: I hope I have correctly understood the algorithm within the `DecimalNotationFormatter` class. What do you think about this bug fix? 

https://github.com/danm-de/Fractions/pull/103
author_association: COLLABORATOR
user: login: lipchev
created_at: 2025-03-02T20:03:16Z
body: I think the `AppendSignificantDecimals` function was fine, but there are other issues:
1. To fix the issue with the value not rounding to the correct precision was just a matter of adding the missing round here https://github.com/danm-de/Fractions/blob/e2d59d0f7e1663b6858877071b5a9309552c758f/src/Fractions/Formatter/DecimalNotationFormatter.cs#L757 This ensures that any rounding occurs before we start appending, this way the carry-over propagates all the way up to the first decimal. I was considering trying a complete re-write of the `Append` which, after encountering a round-up, carries it back to the previous decimal(s), however I decided to leave to for another time..
2. The other problem I've encountered was the rounding mode - I have a comment here https://github.com/danm-de/Fractions/blob/e2d59d0f7e1663b6858877071b5a9309552c758f/src/Fractions/Formatter/DecimalNotationFormatter.cs#L44 (and somewhere in the tests) that, while `netstandard ` is consistently rounding (both doubles and decimals) using `away from zero`, this is not the case with the `double` on `net8`: I originally thought that it's simply using the `round to even`, however it turns out it's not.. It's actually using _some variant_ of the `Ryu: Fast Float-to-String Conversion`, which is an implementation geared towards binary floating point numbers, and there is no way we're implementing this with the BigIntegers. 

In order to fix the tests (on net8) I switched to comparing against the `ToDecimal().ToString()` (instead of `ToDouble().ToString()`) which (except for `NaN` and `PositiveInfinity`) yields the same result in both frameworks. This also allowed me to remove things like the `-0.0` output..

See #104
author_association: COLLABORATOR

Diff:
diff --git a/Fractions.sln b/Fractions.sln
index 0e2aec8..90e3b8c 100644
--- a/Fractions.sln
+++ b/Fractions.sln
@@ -46,6 +46,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Results", "Results", "{FCF0
 		benchmarks\results\Fractions.Benchmarks.NonNormalizedComparisonBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.NonNormalizedComparisonBenchmarks-report-github.md
 		benchmarks\results\Fractions.Benchmarks.NonNormalizedMathBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.NonNormalizedMathBenchmarks-report-github.md
 		benchmarks\results\Fractions.Benchmarks.PowerMathBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.PowerMathBenchmarks-report-github.md
+		benchmarks\results\Fractions.Benchmarks.RoundingBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.RoundingBenchmarks-report-github.md
+		benchmarks\results\Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md
 		benchmarks\results\Fractions.Benchmarks.SqrtBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.SqrtBenchmarks-report-github.md
 		benchmarks\results\Fractions.Benchmarks.ToStringBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.ToStringBenchmarks-report-github.md
 	EndProjectSection
diff --git a/benchmarks/Fractions.Benchmarks/DecimalNotationFormatterBenchmarks.cs b/benchmarks/Fractions.Benchmarks/DecimalNotationFormatterBenchmarks.cs
index 31d6d02..9c21934 100644
--- a/benchmarks/Fractions.Benchmarks/DecimalNotationFormatterBenchmarks.cs
+++ b/benchmarks/Fractions.Benchmarks/DecimalNotationFormatterBenchmarks.cs
@@ -17,7 +17,8 @@ public class DecimalNotationFormatterBenchmarks {
         // extreme integers
         123456789, -123456789,             
         // normal decimals
-        new Fraction(-2.5m), new Fraction(1.345m),
+        new Fraction(2.5m), new Fraction(-2.5m),
+        new Fraction(1.345m),
         new Fraction(1234567, 1000),
         new Fraction(-1234567, 1000),
         // extreme decimals
@@ -28,19 +29,11 @@ public class DecimalNotationFormatterBenchmarks {
         new Fraction(-Math.PI),
         // non-terminating fractions
         new Fraction(8, 3),
-        new Fraction(-8, 3),
         new Fraction(400, 3),
-        new Fraction(-400, 3),
         new Fraction(2, 3),
         new Fraction(-2, 3),
     ];
     
-    [Benchmark(Baseline = true)]
-    [ArgumentsSource(nameof(TestValues))]
-    public string ToDouble_ToString(Fraction fraction) {
-        return fraction.ToDouble().ToString(StringFormat, CultureInfo.InvariantCulture);
-    }
-    
     [Benchmark]
     [ArgumentsSource(nameof(TestValues))]
     public string DecimalNotationFormatter_Format(Fraction fraction) {
diff --git a/benchmarks/Fractions.Benchmarks/RoundingBenchmarks.cs b/benchmarks/Fractions.Benchmarks/RoundingBenchmarks.cs
new file mode 100644
index 0000000..dc60180
--- /dev/null
+++ b/benchmarks/Fractions.Benchmarks/RoundingBenchmarks.cs
@@ -0,0 +1,73 @@
+﻿using BenchmarkDotNet.Attributes;
+
+namespace Fractions.Benchmarks;
+
+[MemoryDiagnoser]
+[ShortRunJob]
+public class RoundingBenchmarks {
+
+    [Params(1, 2, 4, 8, 16)]
+    public int NbDecimals { get; set; }
+    
+    [Params(MidpointRounding.AwayFromZero)]
+    public MidpointRounding RoundingMode { get; set; }
+    
+    public static IEnumerable<Fraction> TestValues => [    
+        // normal decimals
+        Fraction.FromDecimal(2.5m, false),
+        Fraction.FromDecimal(1.345m, false),
+        Fraction.FromDecimal(123.456m, false),
+        // small decimals
+        new Fraction(1, 123456789, false),
+        new Fraction(-1, 123456789, false),
+        // high precision fractions
+        Fraction.FromDoubleRounded(Math.PI, 16, false),
+        Fraction.FromDoubleRounded(-Math.PI, 16, false),
+        // non-terminating fractions
+        new Fraction(8, 3, false),
+        new Fraction(400, 3, false),
+        new Fraction(2, 3, false),
+        new Fraction(-2, 3, false),
+    ];
+    
+    [Benchmark]
+    [ArgumentsSource(nameof(TestValues))]
+    public Fraction Round(Fraction fraction) {
+        return Fraction.Round(fraction, NbDecimals, RoundingMode);
+    }
+}
+
+[MemoryDiagnoser]
+[ShortRunJob]
+public class RoundingWithoutReductionBenchmarks {
+
+    [Params(1, 2, 4, 8, 16)]
+    public int NbDecimals { get; set; }
+    
+    [Params(MidpointRounding.AwayFromZero)]
+    public MidpointRounding RoundingMode { get; set; }
+    
+    public static IEnumerable<Fraction> TestValues => [    
+        // normal decimals
+        Fraction.FromDecimal(2.5m, false),
+        Fraction.FromDecimal(1.345m, false),
+        Fraction.FromDecimal(123.456m, false),
+        // small decimals
+        new Fraction(1, 123456789, false),
+        new Fraction(-1, 123456789, false),
+        // high precision fractions
+        Fraction.FromDoubleRounded(Math.PI, 16, false),
+        Fraction.FromDoubleRounded(-Math.PI, 16, false),
+        // non-terminating fractions
+        new Fraction(8, 3, false),
+        new Fraction(400, 3, false),
+        new Fraction(2, 3, false),
+        new Fraction(-2, 3, false),
+    ];
+    
+    [Benchmark]
+    [ArgumentsSource(nameof(TestValues))]
+    public Fraction Round(Fraction fraction) {
+        return Fraction.Round(fraction, NbDecimals, RoundingMode, false);
+    }
+}
diff --git a/benchmarks/Readme.md b/benchmarks/Readme.md
index 6479850..2f5c276 100644
--- a/benchmarks/Readme.md
+++ b/benchmarks/Readme.md
@@ -79,6 +79,13 @@ These benchmarks evaluate the performance of power operations within the `Fracti
 
 For a detailed report on the performance of these operations, [view the results here](./results/Fractions.Benchmarks.PowerMathBenchmarks-report-github.md) and [here](./results/Fractions.Benchmarks.SqrtBenchmarks-report-github.md).
 
+### Rounding
+These benchmarks evaluate the performance of rounding a `Fraction` to a given number of decimal places. The operations being benchmarked are:
+- `Round(Fraction fraction, int decimals, MidpointRounding mode)`: Rounds a `Fraction` to the given number of decimal places, returning a normalized Fraction.
+- `Round(Fraction fraction, int decimals, MidpointRounding mode, bool normalize)`: Rounding a `Fraction` to the given number of decimal places, without reducing its terms.
+
+For a detailed report on the performance of these operations, [view the results here](./results/Fractions.Benchmarks.RoundingBenchmarks-report-github.md) and [here](./results/Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md).
+
 ### Conversions
 These benchmarks evaluate the performance of converting `Fraction` objects to number types. The operations being benchmarked are:
 - `ConvertToDouble(Fraction fraction)`: Converts a `Fraction` object to a double value.
diff --git a/benchmarks/results/Fractions.Benchmarks.DecimalNotationFormatterBenchmarks-report-github.md b/benchmarks/results/Fractions.Benchmarks.DecimalNotationFormatterBenchmarks-report-github.md
index 94b55ea..6f7b1cb 100644
--- a/benchmarks/results/Fractions.Benchmarks.DecimalNotationFormatterBenchmarks-report-github.md
+++ b/benchmarks/results/Fractions.Benchmarks.DecimalNotationFormatterBenchmarks-report-github.md
@@ -1,465 +1,150 @@
 ```
 
-BenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5131/22H2/2022Update)
+BenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5487/22H2/2022Update)
 AMD Ryzen 9 7900X, 1 CPU, 24 logical and 12 physical cores
-.NET SDK 9.0.100
-  [Host]   : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
-  ShortRun : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
+.NET SDK 9.0.200
+  [Host]   : .NET 9.0.2 (9.0.225.6610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
+  ShortRun : .NET 9.0.2 (9.0.225.6610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
 
 Job=ShortRun  IterationCount=3  LaunchCount=1  
 WarmupCount=3  
 
 ```
-| Method                          | StringFormat | fraction             | Mean        | Error      | StdDev    | Ratio | RatioSD | Gen0   | Allocated | Alloc Ratio |
-|-------------------------------- |------------- |--------------------- |------------:|-----------:|----------:|------:|--------:|-------:|----------:|------------:|
-| **ToDouble_ToString**               | **?**            | **-123456789**           |    **65.39 ns** |   **2.972 ns** |  **0.163 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -123456789           |   171.78 ns | 181.132 ns |  9.928 ns |  2.63 |    0.13 | 0.0138 |     232 B |        4.83 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **-1234567/1000**        |    **68.23 ns** |   **8.334 ns** |  **0.457 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -1234567/1000        |   223.98 ns |   5.438 ns |  0.298 ns |  3.28 |    0.02 | 0.0129 |     216 B |        5.40 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **-400/3**               |    **84.09 ns** |   **4.046 ns** |  **0.222 ns** |  **1.00** |    **0.00** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -400/3               |   466.11 ns |  26.537 ns |  1.455 ns |  5.54 |    0.02 | 0.0124 |     208 B |        3.25 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **-42**                  |    **54.09 ns** |   **1.880 ns** |  **0.103 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -42                  |   107.77 ns |   2.790 ns |  0.153 ns |  1.99 |    0.00 | 0.0105 |     176 B |        5.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **-8842(...)10656 [32]** |    **84.38 ns** |   **6.383 ns** |  **0.350 ns** |  **1.00** |    **0.01** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -8842(...)10656 [32] |   906.13 ns |  57.119 ns |  3.131 ns | 10.74 |    0.05 | 0.0763 |    1288 B |       20.12 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **-8/3**                 |    **82.11 ns** |   **1.840 ns** |  **0.101 ns** |  **1.00** |    **0.00** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -8/3                 |   484.30 ns |  68.427 ns |  3.751 ns |  5.90 |    0.04 | 0.0114 |     200 B |        3.12 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **-5/2**                 |    **56.46 ns** |   **1.275 ns** |  **0.070 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -5/2                 |   134.30 ns |  11.735 ns |  0.643 ns |  2.38 |    0.01 | 0.0100 |     168 B |        5.25 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **-2/3**                 |    **78.30 ns** |   **6.571 ns** |  **0.360 ns** |  **1.00** |    **0.01** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -2/3                 | 1,036.56 ns | 116.209 ns |  6.370 ns | 13.24 |    0.09 | 0.0801 |    1352 B |       21.12 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **-1/123456789**         |    **87.11 ns** |   **0.462 ns** |  **0.025 ns** |  **1.00** |    **0.00** | **0.0043** |      **72 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | -1/123456789         | 1,112.11 ns | 346.733 ns | 19.006 ns | 12.77 |    0.19 | 0.0839 |    1416 B |       19.67 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **1/123456789**          |    **85.58 ns** |   **2.517 ns** |  **0.138 ns** |  **1.00** |    **0.00** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 1/123456789          | 1,095.08 ns | 116.845 ns |  6.405 ns | 12.80 |    0.07 | 0.0839 |    1408 B |       22.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **2/3**                  |    **77.46 ns** |   **3.972 ns** |  **0.218 ns** |  **1.00** |    **0.00** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 2/3                  | 1,021.94 ns | 117.169 ns |  6.422 ns | 13.19 |    0.08 | 0.0801 |    1352 B |       21.12 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **269/200**              |    **59.85 ns** |   **4.938 ns** |  **0.271 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 269/200              |   168.96 ns |  39.204 ns |  2.149 ns |  2.82 |    0.03 | 0.0100 |     168 B |        5.25 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **8/3**                  |    **81.88 ns** |   **3.196 ns** |  **0.175 ns** |  **1.00** |    **0.00** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 8/3                  |   568.28 ns |  12.331 ns |  0.676 ns |  6.94 |    0.01 | 0.0114 |     192 B |        3.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **88427(...)10656 [31]** |    **82.79 ns** |   **3.527 ns** |  **0.193 ns** |  **1.00** |    **0.00** | **0.0033** |      **56 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 88427(...)10656 [31] |   875.44 ns | 112.181 ns |  6.149 ns | 10.57 |    0.07 | 0.0763 |    1280 B |       22.86 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **42**                   |    **53.65 ns** |   **4.950 ns** |  **0.271 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 42                   |   101.78 ns | 178.255 ns |  9.771 ns |  1.90 |    0.16 | 0.0105 |     176 B |        5.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **400/3**                |    **84.35 ns** |   **3.441 ns** |  **0.189 ns** |  **1.00** |    **0.00** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 400/3                |   454.93 ns |   5.780 ns |  0.317 ns |  5.39 |    0.01 | 0.0119 |     200 B |        3.12 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **1234567/1000**         |    **67.30 ns** |   **5.532 ns** |  **0.303 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 1234567/1000         |   213.26 ns |   3.097 ns |  0.170 ns |  3.17 |    0.01 | 0.0129 |     216 B |        5.40 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **?**            | **123456789**            |    **63.93 ns** |   **1.604 ns** |  **0.088 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | ?            | 123456789            |   153.53 ns |   7.396 ns |  0.405 ns |  2.40 |    0.01 | 0.0134 |     224 B |        5.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-123456789**           |   **108.59 ns** |   **0.198 ns** |  **0.011 ns** |  **1.00** |    **0.00** | **0.0033** |      **56 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -123456789           |    54.34 ns |   2.252 ns |  0.123 ns |  0.50 |    0.00 | 0.0033 |      56 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-1234567/1000**        |    **88.62 ns** |   **6.036 ns** |  **0.331 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -1234567/1000        |   405.97 ns |  44.676 ns |  2.449 ns |  4.58 |    0.03 | 0.0563 |     944 B |       19.67 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-400/3**               |    **90.23 ns** |   **1.871 ns** |  **0.103 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -400/3               |   392.15 ns | 137.488 ns |  7.536 ns |  4.35 |    0.07 | 0.0558 |     936 B |       23.40 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-42**                  |    **56.13 ns** |   **2.114 ns** |  **0.116 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -42                  |    42.62 ns |   3.880 ns |  0.213 ns |  0.76 |    0.00 | 0.0024 |      40 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-8842(...)10656 [32]** |    **67.71 ns** |   **3.750 ns** |  **0.206 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -8842(...)10656 [32] |   434.25 ns |  32.791 ns |  1.797 ns |  6.41 |    0.03 | 0.0486 |     816 B |       20.40 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-8/3**                 |    **66.63 ns** |   **2.576 ns** |  **0.141 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -8/3                 |   375.76 ns |  16.071 ns |  0.881 ns |  5.64 |    0.02 | 0.0429 |     720 B |       18.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-5/2**                 |    **55.37 ns** |   **0.926 ns** |  **0.051 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -5/2                 |   352.10 ns |  36.671 ns |  2.010 ns |  6.36 |    0.03 | 0.0429 |     720 B |       18.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-2/3**                 |    **63.10 ns** |   **5.134 ns** |  **0.281 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -2/3                 |   380.67 ns |  41.567 ns |  2.278 ns |  6.03 |    0.04 | 0.0429 |     720 B |       18.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **-1/123456789**         |    **59.90 ns** |   **1.549 ns** |  **0.085 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | -1/123456789         |   289.56 ns |  17.869 ns |  0.979 ns |  4.83 |    0.02 | 0.0453 |     760 B |       19.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **1/123456789**          |    **57.89 ns** |   **1.439 ns** |  **0.079 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 1/123456789          |   246.43 ns |  35.886 ns |  1.967 ns |  4.26 |    0.03 | 0.0396 |     664 B |       20.75 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **2/3**                  |    **57.46 ns** |   **7.381 ns** |  **0.405 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 2/3                  |   340.91 ns | 168.314 ns |  9.226 ns |  5.93 |    0.14 | 0.0372 |     624 B |       19.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **269/200**              |    **61.44 ns** |   **3.837 ns** |  **0.210 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 269/200              |   354.33 ns |   7.259 ns |  0.398 ns |  5.77 |    0.02 | 0.0372 |     624 B |       19.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **8/3**                  |    **60.92 ns** |   **9.125 ns** |  **0.500 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 8/3                  |   343.86 ns |  26.240 ns |  1.438 ns |  5.64 |    0.04 | 0.0372 |     624 B |       19.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **88427(...)10656 [31]** |    **66.09 ns** |   **2.614 ns** |  **0.143 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 88427(...)10656 [31] |   403.88 ns |  21.972 ns |  1.204 ns |  6.11 |    0.02 | 0.0429 |     720 B |       22.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **42**                   |    **55.84 ns** |   **0.939 ns** |  **0.051 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 42                   |    43.07 ns |   1.840 ns |  0.101 ns |  0.77 |    0.00 | 0.0024 |      40 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **400/3**                |    **77.85 ns** |   **2.688 ns** |  **0.147 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 400/3                |   340.70 ns |  26.053 ns |  1.428 ns |  4.38 |    0.02 | 0.0443 |     744 B |       18.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **1234567/1000**         |    **87.90 ns** |  **12.249 ns** |  **0.671 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 1234567/1000         |   372.75 ns |  51.787 ns |  2.839 ns |  4.24 |    0.04 | 0.0496 |     832 B |       20.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **C2**           | **123456789**            |   **106.49 ns** |   **2.899 ns** |  **0.159 ns** |  **1.00** |    **0.00** | **0.0033** |      **56 B** |        **1.00** |
-| DecimalNotationFormatter_Format | C2           | 123456789            |    54.89 ns |   1.387 ns |  0.076 ns |  0.52 |    0.00 | 0.0033 |      56 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-123456789**           |    **51.68 ns** |   **1.743 ns** |  **0.096 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -123456789           |    53.59 ns |   4.927 ns |  0.270 ns |  1.04 |    0.00 | 0.0029 |      48 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-1234567/1000**        |    **52.06 ns** |   **1.785 ns** |  **0.098 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -1234567/1000        |   358.06 ns |  26.337 ns |  1.444 ns |  6.88 |    0.03 | 0.0186 |     312 B |        6.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-400/3**               |    **51.95 ns** |   **0.785 ns** |  **0.043 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -400/3               |   348.03 ns |  68.103 ns |  3.733 ns |  6.70 |    0.06 | 0.0167 |     280 B |        5.83 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-42**                  |    **52.30 ns** |   **1.096 ns** |  **0.060 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -42                  |    46.69 ns |   0.887 ns |  0.049 ns |  0.89 |    0.00 | 0.0029 |      48 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-8842(...)10656 [32]** |    **56.57 ns** |   **1.122 ns** |  **0.062 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -8842(...)10656 [32] |   377.70 ns |  79.628 ns |  4.365 ns |  6.68 |    0.07 | 0.0262 |     440 B |        9.17 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-8/3**                 |    **53.53 ns** |   **1.708 ns** |  **0.094 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -8/3                 |   295.31 ns |  13.948 ns |  0.765 ns |  5.52 |    0.01 | 0.0167 |     280 B |        5.83 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-5/2**                 |    **53.08 ns** |   **0.527 ns** |  **0.029 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -5/2                 |   278.51 ns |   7.122 ns |  0.390 ns |  5.25 |    0.01 | 0.0167 |     280 B |        5.83 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-2/3**                 |    **52.04 ns** |   **0.705 ns** |  **0.039 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -2/3                 |   309.51 ns |   9.741 ns |  0.534 ns |  5.95 |    0.01 | 0.0167 |     280 B |        5.83 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **-1/123456789**         |    **52.49 ns** |   **3.947 ns** |  **0.216 ns** |  **1.00** |    **0.01** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | -1/123456789         |   319.44 ns |   8.606 ns |  0.472 ns |  6.09 |    0.02 | 0.0186 |     312 B |        6.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **1/123456789**          |    **51.75 ns** |   **2.162 ns** |  **0.119 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 1/123456789          |   311.97 ns |  28.600 ns |  1.568 ns |  6.03 |    0.03 | 0.0181 |     304 B |        7.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **2/3**                  |    **50.87 ns** |   **3.214 ns** |  **0.176 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 2/3                  |   294.06 ns |  51.702 ns |  2.834 ns |  5.78 |    0.05 | 0.0162 |     272 B |        6.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **269/200**              |    **51.25 ns** |   **1.044 ns** |  **0.057 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 269/200              |   299.75 ns |  46.393 ns |  2.543 ns |  5.85 |    0.04 | 0.0162 |     272 B |        6.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **8/3**                  |    **52.03 ns** |   **0.725 ns** |  **0.040 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 8/3                  |   276.92 ns |  21.942 ns |  1.203 ns |  5.32 |    0.02 | 0.0162 |     272 B |        6.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **88427(...)10656 [31]** |    **55.73 ns** |   **2.445 ns** |  **0.134 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 88427(...)10656 [31] |   361.67 ns |   5.004 ns |  0.274 ns |  6.49 |    0.01 | 0.0257 |     432 B |       10.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **42**                   |    **50.33 ns** |   **1.206 ns** |  **0.066 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 42                   |    46.47 ns |   1.659 ns |  0.091 ns |  0.92 |    0.00 | 0.0024 |      40 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **400/3**                |    **51.57 ns** |   **2.023 ns** |  **0.111 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 400/3                |   331.10 ns | 124.799 ns |  6.841 ns |  6.42 |    0.12 | 0.0162 |     272 B |        6.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **1234567/1000**         |    **51.40 ns** |   **0.187 ns** |  **0.010 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 1234567/1000         |   363.20 ns |   5.220 ns |  0.286 ns |  7.07 |    0.00 | 0.0181 |     304 B |        7.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **E2**           | **123456789**            |    **52.92 ns** |  **27.481 ns** |  **1.506 ns** |  **1.00** |    **0.03** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | E2           | 123456789            |    58.66 ns |   5.006 ns |  0.274 ns |  1.11 |    0.03 | 0.0024 |      40 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-123456789**           |   **104.62 ns** |   **5.523 ns** |  **0.303 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -123456789           |    49.90 ns |   0.369 ns |  0.020 ns |  0.48 |    0.00 | 0.0029 |      48 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-1234567/1000**        |    **82.96 ns** |   **1.558 ns** |  **0.085 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -1234567/1000        |   236.55 ns |  45.491 ns |  2.494 ns |  2.85 |    0.03 | 0.0105 |     176 B |        4.40 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-400/3**               |    **78.14 ns** |  **23.668 ns** |  **1.297 ns** |  **1.00** |    **0.02** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -400/3               |   225.00 ns | 133.817 ns |  7.335 ns |  2.88 |    0.09 | 0.0105 |     176 B |        4.40 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-42**                  |    **52.25 ns** |   **5.968 ns** |  **0.327 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -42                  |    38.32 ns |   3.913 ns |  0.214 ns |  0.73 |    0.01 | 0.0024 |      40 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-8842(...)10656 [32]** |    **63.09 ns** |   **3.836 ns** |  **0.210 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -8842(...)10656 [32] |   269.05 ns |  22.675 ns |  1.243 ns |  4.26 |    0.02 | 0.0153 |     256 B |        8.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-8/3**                 |    **58.27 ns** |   **3.164 ns** |  **0.173 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -8/3                 |   235.07 ns |  45.612 ns |  2.500 ns |  4.03 |    0.04 | 0.0095 |     160 B |        5.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-5/2**                 |    **51.84 ns** |   **2.591 ns** |  **0.142 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -5/2                 |   230.43 ns |  38.328 ns |  2.101 ns |  4.44 |    0.04 | 0.0095 |     160 B |        5.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-2/3**                 |    **54.82 ns** |   **3.534 ns** |  **0.194 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -2/3                 |   221.97 ns | 115.374 ns |  6.324 ns |  4.05 |    0.10 | 0.0095 |     160 B |        5.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **-1/123456789**         |    **56.30 ns** |  **13.373 ns** |  **0.733 ns** |  **1.00** |    **0.02** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | -1/123456789         |   135.55 ns |  53.532 ns |  2.934 ns |  2.41 |    0.05 | 0.0100 |     168 B |        5.25 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **1/123456789**          |    **56.22 ns** |   **7.198 ns** |  **0.395 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 1/123456789          |   125.29 ns |  38.193 ns |  2.093 ns |  2.23 |    0.03 | 0.0100 |     168 B |        5.25 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **2/3**                  |    **55.27 ns** |   **1.123 ns** |  **0.062 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 2/3                  |   226.14 ns |  35.806 ns |  1.963 ns |  4.09 |    0.03 | 0.0095 |     160 B |        5.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **269/200**              |    **58.17 ns** |   **2.307 ns** |  **0.126 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 269/200              |   256.30 ns | 169.249 ns |  9.277 ns |  4.41 |    0.14 | 0.0095 |     160 B |        5.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **8/3**                  |    **59.52 ns** |  **53.374 ns** |  **2.926 ns** |  **1.00** |    **0.06** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 8/3                  |   214.58 ns |  15.332 ns |  0.840 ns |  3.61 |    0.15 | 0.0095 |     160 B |        5.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **88427(...)10656 [31]** |    **63.67 ns** |   **5.942 ns** |  **0.326 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 88427(...)10656 [31] |   262.72 ns |  46.141 ns |  2.529 ns |  4.13 |    0.04 | 0.0153 |     256 B |        8.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **42**                   |    **53.33 ns** |   **9.633 ns** |  **0.528 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 42                   |    39.07 ns |  20.667 ns |  1.133 ns |  0.73 |    0.02 | 0.0019 |      32 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **400/3**                |    **76.80 ns** |  **45.127 ns** |  **2.474 ns** |  **1.00** |    **0.04** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 400/3                |   230.60 ns | 117.717 ns |  6.452 ns |  3.00 |    0.11 | 0.0105 |     176 B |        4.40 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **1234567/1000**         |    **85.03 ns** |  **21.160 ns** |  **1.160 ns** |  **1.00** |    **0.02** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 1234567/1000         |   226.59 ns |  27.644 ns |  1.515 ns |  2.67 |    0.03 | 0.0105 |     176 B |        4.40 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **F2**           | **123456789**            |   **102.89 ns** |   **1.376 ns** |  **0.075 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | F2           | 123456789            |    48.52 ns |   9.538 ns |  0.523 ns |  0.47 |    0.00 | 0.0029 |      48 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-123456789**           |    **48.20 ns** |   **5.801 ns** |  **0.318 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -123456789           |   318.32 ns | 150.967 ns |  8.275 ns |  6.61 |    0.15 | 0.0181 |     304 B |        7.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-1234567/1000**        |    **48.76 ns** |   **3.924 ns** |  **0.215 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -1234567/1000        |   307.12 ns |  25.700 ns |  1.409 ns |  6.30 |    0.03 | 0.0181 |     304 B |        7.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-400/3**               |    **48.27 ns** |   **1.061 ns** |  **0.058 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -400/3               |   284.25 ns |  33.902 ns |  1.858 ns |  5.89 |    0.03 | 0.0162 |     272 B |        6.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-42**                  |    **41.23 ns** |   **4.685 ns** |  **0.257 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -42                  |    84.63 ns |   5.744 ns |  0.315 ns |  2.05 |    0.01 | 0.0072 |     120 B |        3.75 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-8842(...)10656 [32]** |    **49.36 ns** |  **15.567 ns** |  **0.853 ns** |  **1.00** |    **0.02** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -8842(...)10656 [32] |   238.16 ns |   5.891 ns |  0.323 ns |  4.83 |    0.07 | 0.0200 |     336 B |       10.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-8/3**                 |    **44.17 ns** |  **13.260 ns** |  **0.727 ns** |  **1.00** |    **0.02** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -8/3                 |   150.15 ns |   5.514 ns |  0.302 ns |  3.40 |    0.05 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-5/2**                 |    **43.26 ns** |  **18.233 ns** |  **0.999 ns** |  **1.00** |    **0.03** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -5/2                 |   143.93 ns |   5.002 ns |  0.274 ns |  3.33 |    0.07 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-2/3**                 |    **44.38 ns** |   **8.729 ns** |  **0.478 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -2/3                 |   257.85 ns |   1.832 ns |  0.100 ns |  5.81 |    0.05 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **-1/123456789**         |    **51.00 ns** |  **20.315 ns** |  **1.114 ns** |  **1.00** |    **0.03** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | -1/123456789         |   294.21 ns | 187.533 ns | 10.279 ns |  5.77 |    0.21 | 0.0181 |     304 B |        7.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **1/123456789**          |    **48.24 ns** |   **5.428 ns** |  **0.298 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 1/123456789          |   289.61 ns | 140.422 ns |  7.697 ns |  6.00 |    0.14 | 0.0181 |     304 B |        7.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **2/3**                  |    **43.46 ns** |   **5.293 ns** |  **0.290 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 2/3                  |   230.77 ns |  10.444 ns |  0.572 ns |  5.31 |    0.03 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **269/200**              |    **40.34 ns** |   **1.503 ns** |  **0.082 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 269/200              |   138.40 ns | 120.303 ns |  6.594 ns |  3.43 |    0.14 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **8/3**                  |    **42.37 ns** |   **3.533 ns** |  **0.194 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 8/3                  |   135.25 ns |   1.137 ns |  0.062 ns |  3.19 |    0.01 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **88427(...)10656 [31]** |    **45.46 ns** |   **3.045 ns** |  **0.167 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 88427(...)10656 [31] |   223.40 ns |  11.205 ns |  0.614 ns |  4.91 |    0.02 | 0.0200 |     336 B |       10.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **42**                   |    **39.37 ns** |   **1.176 ns** |  **0.064 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 42                   |    96.71 ns |   8.155 ns |  0.447 ns |  2.46 |    0.01 | 0.0072 |     120 B |        3.75 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **400/3**                |    **48.26 ns** |   **7.823 ns** |  **0.429 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 400/3                |   287.82 ns | 124.246 ns |  6.810 ns |  5.96 |    0.13 | 0.0162 |     272 B |        6.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **1234567/1000**         |    **49.69 ns** |  **54.381 ns** |  **2.981 ns** |  **1.00** |    **0.07** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 1234567/1000         |   314.34 ns | 569.507 ns | 31.217 ns |  6.34 |    0.63 | 0.0181 |     304 B |        7.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **G2**           | **123456789**            |    **48.32 ns** |  **32.349 ns** |  **1.773 ns** |  **1.00** |    **0.04** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | G2           | 123456789            |   308.77 ns |  19.261 ns |  1.056 ns |  6.40 |    0.20 | 0.0181 |     304 B |        7.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-123456789**           |   **109.22 ns** |  **69.898 ns** |  **3.831 ns** |  **1.00** |    **0.04** | **0.0033** |      **56 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -123456789           |    52.52 ns |  23.364 ns |  1.281 ns |  0.48 |    0.02 | 0.0033 |      56 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-1234567/1000**        |    **89.38 ns** |  **22.925 ns** |  **1.257 ns** |  **1.00** |    **0.02** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -1234567/1000        |   302.73 ns | 526.497 ns | 28.859 ns |  3.39 |    0.28 | 0.0210 |     352 B |        8.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-400/3**               |    **79.64 ns** |  **67.766 ns** |  **3.714 ns** |  **1.00** |    **0.06** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -400/3               |   249.21 ns |  66.582 ns |  3.650 ns |  3.13 |    0.13 | 0.0210 |     352 B |        8.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-42**                  |    **54.35 ns** |   **0.490 ns** |  **0.027 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -42                  |    40.75 ns |   3.389 ns |  0.186 ns |  0.75 |    0.00 | 0.0024 |      40 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-8842(...)10656 [32]** |    **68.14 ns** |  **72.234 ns** |  **3.959 ns** |  **1.00** |    **0.07** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -8842(...)10656 [32] |   291.99 ns | 193.589 ns | 10.611 ns |  4.29 |    0.25 | 0.0143 |     240 B |        7.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-8/3**                 |    **60.88 ns** |   **5.873 ns** |  **0.322 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -8/3                 |   238.22 ns |  23.657 ns |  1.297 ns |  3.91 |    0.03 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-5/2**                 |    **53.72 ns** |   **8.555 ns** |  **0.469 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -5/2                 |   207.33 ns |  17.091 ns |  0.937 ns |  3.86 |    0.03 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-2/3**                 |    **57.04 ns** |   **3.146 ns** |  **0.172 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -2/3                 |   229.21 ns |   6.186 ns |  0.339 ns |  4.02 |    0.01 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **-1/123456789**         |    **57.68 ns** |   **1.921 ns** |  **0.105 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | -1/123456789         |   146.68 ns |  16.500 ns |  0.904 ns |  2.54 |    0.01 | 0.0091 |     152 B |        4.75 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **1/123456789**          |    **56.85 ns** |   **9.068 ns** |  **0.497 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 1/123456789          |   120.79 ns |   0.904 ns |  0.050 ns |  2.12 |    0.02 | 0.0091 |     152 B |        4.75 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **2/3**                  |    **55.57 ns** |   **2.370 ns** |  **0.130 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 2/3                  |   206.10 ns |   8.277 ns |  0.454 ns |  3.71 |    0.01 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **269/200**              |    **59.06 ns** |   **3.609 ns** |  **0.198 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 269/200              |   230.51 ns |   9.276 ns |  0.508 ns |  3.90 |    0.01 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **8/3**                  |    **60.52 ns** |  **31.925 ns** |  **1.750 ns** |  **1.00** |    **0.04** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 8/3                  |   218.22 ns |  17.771 ns |  0.974 ns |  3.61 |    0.09 | 0.0086 |     144 B |        4.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **88427(...)10656 [31]** |    **64.12 ns** |  **12.359 ns** |  **0.677 ns** |  **1.00** |    **0.01** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 88427(...)10656 [31] |   254.80 ns |  13.559 ns |  0.743 ns |  3.97 |    0.04 | 0.0143 |     240 B |        7.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **42**                   |    **53.68 ns** |   **1.998 ns** |  **0.109 ns** |  **1.00** |    **0.00** | **0.0019** |      **32 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 42                   |    39.09 ns |   2.349 ns |  0.129 ns |  0.73 |    0.00 | 0.0019 |      32 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **400/3**                |    **75.71 ns** |   **0.379 ns** |  **0.021 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 400/3                |   233.00 ns |  57.735 ns |  3.165 ns |  3.08 |    0.04 | 0.0148 |     248 B |        6.20 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **1234567/1000**         |    **86.05 ns** |   **2.855 ns** |  **0.157 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 1234567/1000         |   234.72 ns |  11.624 ns |  0.637 ns |  2.73 |    0.01 | 0.0148 |     248 B |        6.20 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **N2**           | **123456789**            |   **104.72 ns** |   **3.140 ns** |  **0.172 ns** |  **1.00** |    **0.00** | **0.0033** |      **56 B** |        **1.00** |
-| DecimalNotationFormatter_Format | N2           | 123456789            |    51.74 ns |   1.698 ns |  0.093 ns |  0.49 |    0.00 | 0.0033 |      56 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-123456789**           |   **111.75 ns** |   **3.829 ns** |  **0.210 ns** |  **1.00** |    **0.00** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -123456789           |    60.80 ns |   4.907 ns |  0.269 ns |  0.54 |    0.00 | 0.0038 |      64 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-1234567/1000**        |   **101.57 ns** |   **6.693 ns** |  **0.367 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -1234567/1000        |   441.89 ns |  33.592 ns |  1.841 ns |  4.35 |    0.02 | 0.0505 |     848 B |       17.67 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-400/3**               |    **97.63 ns** |   **3.138 ns** |  **0.172 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -400/3               |   420.24 ns | 160.294 ns |  8.786 ns |  4.30 |    0.08 | 0.0505 |     848 B |       17.67 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-42**                  |    **62.43 ns** |  **18.397 ns** |  **1.008 ns** |  **1.00** |    **0.02** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -42                  |    50.17 ns |   3.063 ns |  0.168 ns |  0.80 |    0.01 | 0.0029 |      48 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-8842(...)10656 [32]** |    **82.97 ns** |   **6.490 ns** |  **0.356 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -8842(...)10656 [32] |   603.52 ns |  35.634 ns |  1.953 ns |  7.27 |    0.03 | 0.0610 |    1024 B |       25.60 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-8/3**                 |    **78.40 ns** |   **0.403 ns** |  **0.022 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -8/3                 |   413.72 ns |  10.033 ns |  0.550 ns |  5.28 |    0.01 | 0.0496 |     832 B |       20.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-5/2**                 |    **58.85 ns** |   **1.925 ns** |  **0.106 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -5/2                 |   291.46 ns |  38.546 ns |  2.113 ns |  4.95 |    0.03 | 0.0520 |     872 B |       21.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-2/3**                 |    **75.78 ns** |   **2.872 ns** |  **0.157 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -2/3                 |   395.42 ns |  25.653 ns |  1.406 ns |  5.22 |    0.02 | 0.0434 |     728 B |       18.20 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **-1/123456789**         |    **61.54 ns** |   **9.515 ns** |  **0.522 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | -1/123456789         |   311.35 ns |  29.015 ns |  1.590 ns |  5.06 |    0.04 | 0.0453 |     760 B |       19.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **1/123456789**          |    **60.36 ns** |   **1.984 ns** |  **0.109 ns** |  **1.00** |    **0.00** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 1/123456789          |   300.79 ns | 161.292 ns |  8.841 ns |  4.98 |    0.13 | 0.0401 |     672 B |       16.80 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **2/3**                  |    **71.78 ns** |  **26.213 ns** |  **1.437 ns** |  **1.00** |    **0.02** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 2/3                  |   395.29 ns |   7.090 ns |  0.389 ns |  5.51 |    0.10 | 0.0434 |     728 B |       18.20 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **269/200**              |    **77.26 ns** |   **6.277 ns** |  **0.344 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 269/200              |   374.48 ns |  35.806 ns |  1.963 ns |  4.85 |    0.03 | 0.0434 |     728 B |       18.20 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **8/3**                  |    **76.77 ns** |   **6.523 ns** |  **0.358 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 8/3                  |   389.75 ns | 171.400 ns |  9.395 ns |  5.08 |    0.11 | 0.0434 |     728 B |       18.20 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **88427(...)10656 [31]** |    **81.55 ns** |   **6.844 ns** |  **0.375 ns** |  **1.00** |    **0.01** | **0.0024** |      **40 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 88427(...)10656 [31] |   579.22 ns | 220.360 ns | 12.079 ns |  7.10 |    0.13 | 0.0544 |     920 B |       23.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **42**                   |    **60.23 ns** |   **5.806 ns** |  **0.318 ns** |  **1.00** |    **0.01** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 42                   |    48.22 ns |   1.109 ns |  0.061 ns |  0.80 |    0.00 | 0.0029 |      48 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **400/3**                |    **96.00 ns** |  **11.206 ns** |  **0.614 ns** |  **1.00** |    **0.01** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 400/3                |   376.96 ns |  43.212 ns |  2.369 ns |  3.93 |    0.03 | 0.0443 |     744 B |       15.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **1234567/1000**         |   **100.07 ns** |   **4.568 ns** |  **0.250 ns** |  **1.00** |    **0.00** | **0.0029** |      **48 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 1234567/1000         |   413.82 ns | 203.674 ns | 11.164 ns |  4.14 |    0.10 | 0.0443 |     744 B |       15.50 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **P2**           | **123456789**            |   **110.10 ns** |   **3.820 ns** |  **0.209 ns** |  **1.00** |    **0.00** | **0.0038** |      **64 B** |        **1.00** |
-| DecimalNotationFormatter_Format | P2           | 123456789            |    62.75 ns |   4.244 ns |  0.233 ns |  0.57 |    0.00 | 0.0038 |      64 B |        1.00 |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-123456789**           |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -123456789           |   378.34 ns |  28.068 ns |  1.538 ns |     ? |       ? | 0.0200 |     336 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-1234567/1000**        |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -1234567/1000        |   310.18 ns |   6.705 ns |  0.368 ns |     ? |       ? | 0.0167 |     280 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-400/3**               |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -400/3               |   283.56 ns |   5.355 ns |  0.294 ns |     ? |       ? | 0.0148 |     248 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-42**                  |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -42                  |   116.35 ns |   9.520 ns |  0.522 ns |     ? |       ? | 0.0091 |     152 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-8842(...)10656 [32]** |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -8842(...)10656 [32] |   343.84 ns |   6.990 ns |  0.383 ns |     ? |       ? | 0.0181 |     304 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-8/3**                 |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -8/3                 |   249.01 ns |   5.094 ns |  0.279 ns |     ? |       ? | 0.0086 |     144 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-5/2**                 |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -5/2                 |   229.55 ns |   1.686 ns |  0.092 ns |     ? |       ? | 0.0086 |     144 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-2/3**                 |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -2/3                 |   252.76 ns |  19.229 ns |  1.054 ns |     ? |       ? | 0.0086 |     144 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **-1/123456789**         |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | -1/123456789         |   322.09 ns |  35.473 ns |  1.944 ns |     ? |       ? | 0.0181 |     304 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **1/123456789**          |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 1/123456789          |   344.16 ns |  27.127 ns |  1.487 ns |     ? |       ? | 0.0181 |     304 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **2/3**                  |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 2/3                  |   253.44 ns |  15.629 ns |  0.857 ns |     ? |       ? | 0.0086 |     144 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **269/200**              |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 269/200              |   255.61 ns |  40.979 ns |  2.246 ns |     ? |       ? | 0.0086 |     144 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **8/3**                  |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 8/3                  |   258.32 ns |  92.301 ns |  5.059 ns |     ? |       ? | 0.0086 |     144 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **88427(...)10656 [31]** |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 88427(...)10656 [31] |   321.68 ns |  25.219 ns |  1.382 ns |     ? |       ? | 0.0181 |     304 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **42**                   |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 42                   |   104.34 ns |   8.415 ns |  0.461 ns |     ? |       ? | 0.0091 |     152 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **400/3**                |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 400/3                |   271.53 ns |  15.539 ns |  0.852 ns |     ? |       ? | 0.0148 |     248 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **1234567/1000**         |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 1234567/1000         |   297.98 ns |   2.204 ns |  0.121 ns |     ? |       ? | 0.0167 |     280 B |           ? |
-|                                 |              |                      |             |            |           |       |         |        |           |             |
-| **ToDouble_ToString**               | **S2**           | **123456789**            |          **NA** |         **NA** |        **NA** |     **?** |       **?** |     **NA** |        **NA** |           **?** |
-| DecimalNotationFormatter_Format | S2           | 123456789            |   393.95 ns | 508.227 ns | 27.858 ns |     ? |       ? | 0.0200 |     336 B |           ? |
-
-Benchmarks with issues:
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-123456789]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-1234567/1000]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-400/3]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-42]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-8842(...)10656 [32]]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-8/3]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-5/2]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-2/3]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=-1/123456789]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=1/123456789]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=2/3]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=269/200]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=8/3]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=88427(...)10656 [31]]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=42]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=400/3]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=1234567/1000]
-  DecimalNotationFormatterBenchmarks.ToDouble_ToString: ShortRun(IterationCount=3, LaunchCount=1, WarmupCount=3) [StringFormat=S2, fraction=123456789]
+| Method                          | StringFormat | fraction             | Mean      | Error      | StdDev    | Gen0   | Allocated |
+|-------------------------------- |------------- |--------------------- |----------:|-----------:|----------:|-------:|----------:|
+| **DecimalNotationFormatter_Format** | **?**            | **-123456789**           | **119.00 ns** | **127.811 ns** |  **7.006 ns** | **0.0119** |     **200 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **-1234567/1000**        | **273.31 ns** | **324.682 ns** | **17.797 ns** | **0.0224** |     **376 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **-42**                  |  **84.34 ns** |   **6.705 ns** |  **0.368 ns** | **0.0105** |     **176 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **-8842(...)10656 [32]** | **487.80 ns** |  **46.351 ns** |  **2.541 ns** | **0.0334** |     **568 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **-5/2**                 | **179.01 ns** |  **10.977 ns** |  **0.602 ns** | **0.0176** |     **296 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **-2/3**                 | **461.74 ns** | **108.858 ns** |  **5.967 ns** | **0.0310** |     **520 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **-1/123456789**         | **411.99 ns** |  **55.784 ns** |  **3.058 ns** | **0.0296** |     **496 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **1/123456789**          | **412.03 ns** |  **30.462 ns** |  **1.670 ns** | **0.0291** |     **488 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **2/3**                  | **463.44 ns** | **165.532 ns** |  **9.073 ns** | **0.0310** |     **520 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **269/200**              | **236.67 ns** |  **17.209 ns** |  **0.943 ns** | **0.0215** |     **360 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **5/2**                  | **170.42 ns** |  **32.123 ns** |  **1.761 ns** | **0.0176** |     **296 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **8/3**                  | **424.04 ns** |  **30.769 ns** |  **1.687 ns** | **0.0286** |     **480 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **88427(...)10656 [31]** | **474.55 ns** |   **8.638 ns** |  **0.473 ns** | **0.0334** |     **560 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **42**                   |  **75.83 ns** |   **6.443 ns** |  **0.353 ns** | **0.0105** |     **176 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **400/3**                | **382.37 ns** |  **45.464 ns** |  **2.492 ns** | **0.0253** |     **424 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **1234567/1000**         | **244.26 ns** | **113.868 ns** |  **6.241 ns** | **0.0224** |     **376 B** |
+| **DecimalNotationFormatter_Format** | **?**            | **123456789**            |  **88.14 ns** |  **21.849 ns** |  **1.198 ns** | **0.0114** |     **192 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **-123456789**           |  **54.72 ns** |   **1.288 ns** |  **0.071 ns** | **0.0033** |      **56 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **-1234567/1000**        | **313.56 ns** |  **83.621 ns** |  **4.584 ns** | **0.0563** |     **944 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **-42**                  |  **43.00 ns** |   **1.010 ns** |  **0.055 ns** | **0.0024** |      **40 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **-8842(...)10656 [32]** | **323.47 ns** |  **26.861 ns** |  **1.472 ns** | **0.0486** |     **816 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **-5/2**                 | **284.14 ns** |  **42.383 ns** |  **2.323 ns** | **0.0429** |     **720 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **-2/3**                 | **281.76 ns** |  **16.437 ns** |  **0.901 ns** | **0.0429** |     **720 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **-1/123456789**         | **200.56 ns** |  **17.025 ns** |  **0.933 ns** | **0.0358** |     **600 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **1/123456789**          | **187.84 ns** |  **36.961 ns** |  **2.026 ns** | **0.0358** |     **600 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **2/3**                  | **256.15 ns** |  **95.207 ns** |  **5.219 ns** | **0.0372** |     **624 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **269/200**              | **254.39 ns** |   **7.090 ns** |  **0.389 ns** | **0.0372** |     **624 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **5/2**                  | **267.02 ns** |  **90.310 ns** |  **4.950 ns** | **0.0372** |     **624 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **8/3**                  | **249.87 ns** |  **47.239 ns** |  **2.589 ns** | **0.0372** |     **624 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **88427(...)10656 [31]** | **285.54 ns** |  **76.893 ns** |  **4.215 ns** | **0.0429** |     **720 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **42**                   |  **42.50 ns** |   **3.065 ns** |  **0.168 ns** | **0.0024** |      **40 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **400/3**                | **264.48 ns** |  **20.514 ns** |  **1.124 ns** | **0.0443** |     **744 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **1234567/1000**         | **287.51 ns** | **123.000 ns** |  **6.742 ns** | **0.0496** |     **832 B** |
+| **DecimalNotationFormatter_Format** | **C2**           | **123456789**            |  **54.84 ns** |   **0.941 ns** |  **0.052 ns** | **0.0033** |      **56 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **-123456789**           |  **54.38 ns** |   **4.038 ns** |  **0.221 ns** | **0.0029** |      **48 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **-1234567/1000**        | **219.94 ns** |  **22.102 ns** |  **1.211 ns** | **0.0167** |     **280 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **-42**                  |  **49.76 ns** |   **1.986 ns** |  **0.109 ns** | **0.0029** |      **48 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **-8842(...)10656 [32]** | **225.05 ns** |  **31.339 ns** |  **1.718 ns** | **0.0243** |     **408 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **-5/2**                 | **169.36 ns** |  **20.196 ns** |  **1.107 ns** | **0.0167** |     **280 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **-2/3**                 | **198.26 ns** |   **7.770 ns** |  **0.426 ns** | **0.0167** |     **280 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **-1/123456789**         | **222.06 ns** |  **15.082 ns** |  **0.827 ns** | **0.0205** |     **344 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **1/123456789**          | **215.10 ns** |  **41.886 ns** |  **2.296 ns** | **0.0200** |     **336 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **2/3**                  | **209.32 ns** |  **85.405 ns** |  **4.681 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **269/200**              | **185.97 ns** |  **19.779 ns** |  **1.084 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **5/2**                  | **170.66 ns** |   **6.147 ns** |  **0.337 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **8/3**                  | **172.02 ns** |  **25.187 ns** |  **1.381 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **88427(...)10656 [31]** | **233.46 ns** |   **8.989 ns** |  **0.493 ns** | **0.0238** |     **400 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **42**                   |  **49.66 ns** |   **4.114 ns** |  **0.226 ns** | **0.0024** |      **40 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **400/3**                | **224.17 ns** |  **19.679 ns** |  **1.079 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **1234567/1000**         | **232.77 ns** |  **44.926 ns** |  **2.463 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **E2**           | **123456789**            |  **57.15 ns** |   **5.416 ns** |  **0.297 ns** | **0.0024** |      **40 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **-123456789**           |  **48.80 ns** |   **4.385 ns** |  **0.240 ns** | **0.0029** |      **48 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **-1234567/1000**        | **162.94 ns** |  **18.023 ns** |  **0.988 ns** | **0.0105** |     **176 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **-42**                  |  **38.44 ns** |   **1.810 ns** |  **0.099 ns** | **0.0024** |      **40 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **-8842(...)10656 [32]** | **176.47 ns** |  **27.889 ns** |  **1.529 ns** | **0.0153** |     **256 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **-5/2**                 | **138.63 ns** |   **6.813 ns** |  **0.373 ns** | **0.0095** |     **160 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **-2/3**                 | **142.36 ns** |   **3.841 ns** |  **0.211 ns** | **0.0095** |     **160 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **-1/123456789**         |  **89.67 ns** |  **11.494 ns** |  **0.630 ns** | **0.0100** |     **168 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **1/123456789**          |  **88.59 ns** |  **22.389 ns** |  **1.227 ns** | **0.0100** |     **168 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **2/3**                  | **151.57 ns** |  **37.644 ns** |  **2.063 ns** | **0.0095** |     **160 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **269/200**              | **135.22 ns** |  **12.349 ns** |  **0.677 ns** | **0.0095** |     **160 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **5/2**                  | **120.68 ns** |  **10.839 ns** |  **0.594 ns** | **0.0095** |     **160 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **8/3**                  | **134.99 ns** |  **25.658 ns** |  **1.406 ns** | **0.0095** |     **160 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **88427(...)10656 [31]** | **168.01 ns** |  **19.464 ns** |  **1.067 ns** | **0.0153** |     **256 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **42**                   |  **37.47 ns** |   **1.714 ns** |  **0.094 ns** | **0.0019** |      **32 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **400/3**                | **137.96 ns** |   **3.202 ns** |  **0.175 ns** | **0.0105** |     **176 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **1234567/1000**         | **144.66 ns** |  **20.125 ns** |  **1.103 ns** | **0.0105** |     **176 B** |
+| **DecimalNotationFormatter_Format** | **F2**           | **123456789**            |  **48.06 ns** |   **2.679 ns** |  **0.147 ns** | **0.0029** |      **48 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **-123456789**           | **162.19 ns** |   **6.694 ns** |  **0.367 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **-1234567/1000**        | **177.41 ns** |  **10.699 ns** |  **0.586 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **-42**                  |  **55.97 ns** |   **0.665 ns** |  **0.036 ns** | **0.0072** |     **120 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **-8842(...)10656 [32]** | **196.17 ns** | **233.152 ns** | **12.780 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **-5/2**                 | **138.92 ns** |  **41.567 ns** |  **2.278 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **-2/3**                 | **144.13 ns** |  **18.728 ns** |  **1.027 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **-1/123456789**         | **212.49 ns** |  **54.198 ns** |  **2.971 ns** | **0.0200** |     **336 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **1/123456789**          | **199.55 ns** |   **7.354 ns** |  **0.403 ns** | **0.0200** |     **336 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **2/3**                  | **145.22 ns** |   **4.605 ns** |  **0.252 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **269/200**              | **127.90 ns** |   **8.792 ns** |  **0.482 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **5/2**                  | **130.50 ns** |   **9.359 ns** |  **0.513 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **8/3**                  | **128.60 ns** |  **13.217 ns** |  **0.724 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **88427(...)10656 [31]** | **176.57 ns** |   **2.938 ns** |  **0.161 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **42**                   |  **49.63 ns** |   **1.725 ns** |  **0.095 ns** | **0.0072** |     **120 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **400/3**                | **154.13 ns** |  **10.637 ns** |  **0.583 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **1234567/1000**         | **153.21 ns** |  **14.671 ns** |  **0.804 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **G2**           | **123456789**            | **152.96 ns** |   **2.340 ns** |  **0.128 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **-123456789**           |  **49.77 ns** |   **0.404 ns** |  **0.022 ns** | **0.0033** |      **56 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **-1234567/1000**        | **187.96 ns** |  **24.466 ns** |  **1.341 ns** | **0.0210** |     **352 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **-42**                  |  **39.37 ns** |  **11.257 ns** |  **0.617 ns** | **0.0024** |      **40 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **-8842(...)10656 [32]** | **181.17 ns** |  **48.979 ns** |  **2.685 ns** | **0.0143** |     **240 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **-5/2**                 | **141.43 ns** |  **94.998 ns** |  **5.207 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **-2/3**                 | **154.57 ns** |   **7.761 ns** |  **0.425 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **-1/123456789**         |  **89.67 ns** |   **3.456 ns** |  **0.189 ns** | **0.0072** |     **120 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **1/123456789**          |  **81.20 ns** |   **3.065 ns** |  **0.168 ns** | **0.0072** |     **120 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **2/3**                  | **124.16 ns** |   **7.411 ns** |  **0.406 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **269/200**              | **124.89 ns** |  **10.539 ns** |  **0.578 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **5/2**                  | **117.11 ns** |  **17.815 ns** |  **0.977 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **8/3**                  | **122.44 ns** |   **5.115 ns** |  **0.280 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **88427(...)10656 [31]** | **157.68 ns** |  **15.557 ns** |  **0.853 ns** | **0.0143** |     **240 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **42**                   |  **36.67 ns** |   **2.432 ns** |  **0.133 ns** | **0.0019** |      **32 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **400/3**                | **148.28 ns** | **109.215 ns** |  **5.986 ns** | **0.0148** |     **248 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **1234567/1000**         | **146.16 ns** |  **16.200 ns** |  **0.888 ns** | **0.0148** |     **248 B** |
+| **DecimalNotationFormatter_Format** | **N2**           | **123456789**            |  **50.11 ns** |   **4.595 ns** |  **0.252 ns** | **0.0033** |      **56 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **-123456789**           |  **60.17 ns** |   **8.704 ns** |  **0.477 ns** | **0.0038** |      **64 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **-1234567/1000**        | **345.22 ns** |  **27.491 ns** |  **1.507 ns** | **0.0505** |     **848 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **-42**                  |  **48.97 ns** |   **1.355 ns** |  **0.074 ns** | **0.0029** |      **48 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **-8842(...)10656 [32]** | **483.66 ns** |  **29.861 ns** |  **1.637 ns** | **0.0610** |    **1024 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **-5/2**                 | **281.11 ns** |  **11.803 ns** |  **0.647 ns** | **0.0520** |     **872 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **-2/3**                 | **323.51 ns** |  **49.659 ns** |  **2.722 ns** | **0.0434** |     **728 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **-1/123456789**         | **260.45 ns** |  **35.125 ns** |  **1.925 ns** | **0.0362** |     **608 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **1/123456789**          | **227.34 ns** |  **26.913 ns** |  **1.475 ns** | **0.0362** |     **608 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **2/3**                  | **298.95 ns** | **142.649 ns** |  **7.819 ns** | **0.0434** |     **728 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **269/200**              | **306.94 ns** |  **90.501 ns** |  **4.961 ns** | **0.0434** |     **728 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **5/2**                  | **241.98 ns** |  **40.872 ns** |  **2.240 ns** | **0.0458** |     **768 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **8/3**                  | **303.62 ns** |  **45.807 ns** |  **2.511 ns** | **0.0434** |     **728 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **88427(...)10656 [31]** | **468.43 ns** | **129.322 ns** |  **7.089 ns** | **0.0548** |     **920 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **42**                   |  **49.56 ns** |   **2.053 ns** |  **0.113 ns** | **0.0029** |      **48 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **400/3**                | **305.50 ns** |  **53.570 ns** |  **2.936 ns** | **0.0443** |     **744 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **1234567/1000**         | **320.55 ns** |  **79.589 ns** |  **4.363 ns** | **0.0443** |     **744 B** |
+| **DecimalNotationFormatter_Format** | **P2**           | **123456789**            |  **63.92 ns** |  **34.930 ns** |  **1.915 ns** | **0.0038** |      **64 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **-123456789**           | **194.60 ns** |  **25.902 ns** |  **1.420 ns** | **0.0200** |     **336 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **-1234567/1000**        | **168.42 ns** |  **10.610 ns** |  **0.582 ns** | **0.0148** |     **248 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **-42**                  |  **87.40 ns** |   **1.224 ns** |  **0.067 ns** | **0.0091** |     **152 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **-8842(...)10656 [32]** | **202.71 ns** |   **9.259 ns** |  **0.508 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **-5/2**                 | **135.55 ns** |   **5.702 ns** |  **0.313 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **-2/3**                 | **144.67 ns** |   **0.464 ns** |  **0.025 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **-1/123456789**         | **177.25 ns** |   **4.392 ns** |  **0.241 ns** | **0.0200** |     **336 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **1/123456789**          | **176.29 ns** |  **18.434 ns** |  **1.010 ns** | **0.0200** |     **336 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **2/3**                  | **132.90 ns** |  **17.180 ns** |  **0.942 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **269/200**              | **140.13 ns** |   **9.010 ns** |  **0.494 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **5/2**                  | **128.59 ns** |  **66.129 ns** |  **3.625 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **8/3**                  | **141.20 ns** |  **10.003 ns** |  **0.548 ns** | **0.0086** |     **144 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **88427(...)10656 [31]** | **186.49 ns** |  **16.341 ns** |  **0.896 ns** | **0.0162** |     **272 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **42**                   |  **79.01 ns** |  **10.461 ns** |  **0.573 ns** | **0.0091** |     **152 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **400/3**                | **157.02 ns** |   **6.778 ns** |  **0.372 ns** | **0.0148** |     **248 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **1234567/1000**         | **161.18 ns** |   **7.257 ns** |  **0.398 ns** | **0.0148** |     **248 B** |
+| **DecimalNotationFormatter_Format** | **S2**           | **123456789**            | **185.58 ns** |   **0.395 ns** |  **0.022 ns** | **0.0200** |     **336 B** |
diff --git a/benchmarks/results/Fractions.Benchmarks.RoundingBenchmarks-report-github.md b/benchmarks/results/Fractions.Benchmarks.RoundingBenchmarks-report-github.md
new file mode 100644
index 0000000..0f0bf49
--- /dev/null
+++ b/benchmarks/results/Fractions.Benchmarks.RoundingBenchmarks-report-github.md
@@ -0,0 +1,69 @@
+```
+
+BenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5487/22H2/2022Update)
+AMD Ryzen 9 7900X, 1 CPU, 24 logical and 12 physical cores
+.NET SDK 9.0.200
+  [Host]   : .NET 9.0.2 (9.0.225.6610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
+  ShortRun : .NET 9.0.2 (9.0.225.6610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
+
+Job=ShortRun  IterationCount=3  LaunchCount=1  
+WarmupCount=3  
+
+```
+| Method | NbDecimals | RoundingMode | fraction             | Mean      | Error     | StdDev   | Gen0   | Allocated |
+|------- |----------- |------------- |--------------------- |----------:|----------:|---------:|-------:|----------:|
+| **Round**  | **1**          | **AwayFromZero** | **-3141(...)00000 [34]** |  **75.24 ns** |  **6.109 ns** | **0.335 ns** | **0.0057** |      **96 B** |
+| **Round**  | **1**          | **AwayFromZero** | **-2/3**                 |  **42.02 ns** |  **2.468 ns** | **0.135 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **-1/123456789**         |  **58.08 ns** |  **4.514 ns** | **0.247 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **1/123456789**          |  **57.70 ns** |  **2.797 ns** | **0.153 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **2/3**                  |  **41.99 ns** |  **1.683 ns** | **0.092 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **1345/1000**            |  **39.83 ns** |  **3.653 ns** | **0.200 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **25/10**                |  **59.66 ns** |  **1.542 ns** | **0.085 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **8/3**                  |  **42.19 ns** |  **1.395 ns** | **0.076 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **31415(...)00000 [33]** |  **73.65 ns** |  **3.391 ns** | **0.186 ns** | **0.0057** |      **96 B** |
+| **Round**  | **1**          | **AwayFromZero** | **123456/1000**          |  **59.73 ns** |  **2.452 ns** | **0.134 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **400/3**                |  **40.42 ns** |  **1.999 ns** | **0.110 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **-3141(...)00000 [34]** |  **95.52 ns** |  **5.625 ns** | **0.308 ns** | **0.0057** |      **96 B** |
+| **Round**  | **2**          | **AwayFromZero** | **-2/3**                 |  **42.09 ns** |  **4.989 ns** | **0.273 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **-1/123456789**         |  **58.34 ns** |  **4.919 ns** | **0.270 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **1/123456789**          |  **57.95 ns** |  **2.247 ns** | **0.123 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **2/3**                  |  **42.51 ns** |  **3.214 ns** | **0.176 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **1345/1000**            |  **63.37 ns** |  **4.163 ns** | **0.228 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **25/10**                |  **59.64 ns** |  **7.417 ns** | **0.407 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **8/3**                  |  **42.27 ns** |  **4.736 ns** | **0.260 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **31415(...)00000 [33]** |  **98.79 ns** | **17.075 ns** | **0.936 ns** | **0.0057** |      **96 B** |
+| **Round**  | **2**          | **AwayFromZero** | **123456/1000**          |  **65.65 ns** |  **4.164 ns** | **0.228 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **400/3**                |  **40.64 ns** |  **2.597 ns** | **0.142 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **-3141(...)00000 [34]** | **107.99 ns** |  **9.557 ns** | **0.524 ns** | **0.0067** |     **112 B** |
+| **Round**  | **4**          | **AwayFromZero** | **-2/3**                 |  **49.74 ns** |  **2.635 ns** | **0.144 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **-1/123456789**         |  **57.47 ns** |  **0.897 ns** | **0.049 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **1/123456789**          |  **57.85 ns** | **13.501 ns** | **0.740 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **2/3**                  |  **42.57 ns** |  **2.297 ns** | **0.126 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **1345/1000**            |  **67.38 ns** |  **0.793 ns** | **0.043 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **25/10**                |  **82.14 ns** | **42.509 ns** | **2.330 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **8/3**                  |  **48.37 ns** | **98.101 ns** | **5.377 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **31415(...)00000 [33]** | **106.23 ns** |  **1.621 ns** | **0.089 ns** | **0.0067** |     **112 B** |
+| **Round**  | **4**          | **AwayFromZero** | **123456/1000**          |  **66.47 ns** |  **9.501 ns** | **0.521 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **400/3**                |  **40.86 ns** |  **2.433 ns** | **0.133 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **-3141(...)00000 [34]** | **122.37 ns** | **13.268 ns** | **0.727 ns** | **0.0067** |     **112 B** |
+| **Round**  | **8**          | **AwayFromZero** | **-2/3**                 |  **44.74 ns** | **35.482 ns** | **1.945 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **-1/123456789**         |  **34.41 ns** |  **0.538 ns** | **0.029 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **1/123456789**          |  **34.05 ns** |  **1.911 ns** | **0.105 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **2/3**                  |  **43.10 ns** | **19.023 ns** | **1.043 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **1345/1000**            |  **83.47 ns** | **13.746 ns** | **0.753 ns** | **0.0038** |      **64 B** |
+| **Round**  | **8**          | **AwayFromZero** | **25/10**                |  **73.91 ns** |  **6.459 ns** | **0.354 ns** | **0.0038** |      **64 B** |
+| **Round**  | **8**          | **AwayFromZero** | **8/3**                  |  **44.29 ns** | **41.014 ns** | **2.248 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **31415(...)00000 [33]** | **122.52 ns** |  **6.102 ns** | **0.334 ns** | **0.0067** |     **112 B** |
+| **Round**  | **8**          | **AwayFromZero** | **123456/1000**          |  **92.64 ns** |  **3.447 ns** | **0.189 ns** | **0.0057** |      **96 B** |
+| **Round**  | **8**          | **AwayFromZero** | **400/3**                |  **64.05 ns** | **57.209 ns** | **3.136 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **-3141(...)00000 [34]** | **190.94 ns** | **17.937 ns** | **0.983 ns** | **0.0124** |     **208 B** |
+| **Round**  | **16**         | **AwayFromZero** | **-2/3**                 |  **76.75 ns** |  **5.246 ns** | **0.288 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **-1/123456789**         |  **97.80 ns** |  **7.877 ns** | **0.432 ns** | **0.0038** |      **64 B** |
+| **Round**  | **16**         | **AwayFromZero** | **1/123456789**          |  **97.78 ns** | **16.962 ns** | **0.930 ns** | **0.0038** |      **64 B** |
+| **Round**  | **16**         | **AwayFromZero** | **2/3**                  |  **76.56 ns** |  **8.354 ns** | **0.458 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **1345/1000**            | **133.99 ns** | **12.006 ns** | **0.658 ns** | **0.0076** |     **128 B** |
+| **Round**  | **16**         | **AwayFromZero** | **25/10**                | **127.24 ns** | **26.632 ns** | **1.460 ns** | **0.0076** |     **128 B** |
+| **Round**  | **16**         | **AwayFromZero** | **8/3**                  |  **80.54 ns** |  **7.705 ns** | **0.422 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **31415(...)00000 [33]** | **191.62 ns** | **21.489 ns** | **1.178 ns** | **0.0124** |     **208 B** |
+| **Round**  | **16**         | **AwayFromZero** | **123456/1000**          | **142.70 ns** | **59.162 ns** | **3.243 ns** | **0.0086** |     **144 B** |
+| **Round**  | **16**         | **AwayFromZero** | **400/3**                |  **77.79 ns** |  **6.424 ns** | **0.352 ns** | **0.0057** |      **96 B** |
diff --git a/benchmarks/results/Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md b/benchmarks/results/Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md
new file mode 100644
index 0000000..ea812c9
--- /dev/null
+++ b/benchmarks/results/Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md
@@ -0,0 +1,69 @@
+```
+
+BenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5487/22H2/2022Update)
+AMD Ryzen 9 7900X, 1 CPU, 24 logical and 12 physical cores
+.NET SDK 9.0.200
+  [Host]   : .NET 9.0.2 (9.0.225.6610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
+  ShortRun : .NET 9.0.2 (9.0.225.6610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
+
+Job=ShortRun  IterationCount=3  LaunchCount=1  
+WarmupCount=3  
+
+```
+| Method | NbDecimals | RoundingMode | fraction             | Mean     | Error     | StdDev   | Gen0   | Allocated |
+|------- |----------- |------------- |--------------------- |---------:|----------:|---------:|-------:|----------:|
+| **Round**  | **1**          | **AwayFromZero** | **-3141(...)00000 [34]** | **71.15 ns** | **11.010 ns** | **0.603 ns** | **0.0057** |      **96 B** |
+| **Round**  | **1**          | **AwayFromZero** | **-2/3**                 | **41.57 ns** |  **4.539 ns** | **0.249 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **-1/123456789**         | **41.55 ns** |  **0.981 ns** | **0.054 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **1/123456789**          | **40.80 ns** |  **3.231 ns** | **0.177 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **2/3**                  | **41.72 ns** |  **5.233 ns** | **0.287 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **1345/1000**            | **40.52 ns** |  **4.508 ns** | **0.247 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **25/10**                | **41.26 ns** |  **0.747 ns** | **0.041 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **8/3**                  | **40.76 ns** |  **0.498 ns** | **0.027 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **31415(...)00000 [33]** | **70.59 ns** |  **2.892 ns** | **0.159 ns** | **0.0057** |      **96 B** |
+| **Round**  | **1**          | **AwayFromZero** | **123456/1000**          | **40.84 ns** |  **3.865 ns** | **0.212 ns** |      **-** |         **-** |
+| **Round**  | **1**          | **AwayFromZero** | **400/3**                | **40.82 ns** |  **3.155 ns** | **0.173 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **-3141(...)00000 [34]** | **71.94 ns** |  **7.072 ns** | **0.388 ns** | **0.0057** |      **96 B** |
+| **Round**  | **2**          | **AwayFromZero** | **-2/3**                 | **42.28 ns** | **41.160 ns** | **2.256 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **-1/123456789**         | **40.97 ns** |  **0.313 ns** | **0.017 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **1/123456789**          | **42.94 ns** | **32.055 ns** | **1.757 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **2/3**                  | **40.37 ns** |  **1.200 ns** | **0.066 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **1345/1000**            | **40.67 ns** |  **5.331 ns** | **0.292 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **25/10**                | **42.03 ns** |  **1.065 ns** | **0.058 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **8/3**                  | **40.52 ns** |  **0.722 ns** | **0.040 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **31415(...)00000 [33]** | **71.91 ns** | **10.728 ns** | **0.588 ns** | **0.0057** |      **96 B** |
+| **Round**  | **2**          | **AwayFromZero** | **123456/1000**          | **40.35 ns** |  **1.721 ns** | **0.094 ns** |      **-** |         **-** |
+| **Round**  | **2**          | **AwayFromZero** | **400/3**                | **41.54 ns** |  **1.346 ns** | **0.074 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **-3141(...)00000 [34]** | **78.25 ns** |  **3.635 ns** | **0.199 ns** | **0.0067** |     **112 B** |
+| **Round**  | **4**          | **AwayFromZero** | **-2/3**                 | **41.89 ns** | **10.495 ns** | **0.575 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **-1/123456789**         | **40.27 ns** |  **0.860 ns** | **0.047 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **1/123456789**          | **40.54 ns** |  **0.726 ns** | **0.040 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **2/3**                  | **40.63 ns** |  **1.402 ns** | **0.077 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **1345/1000**            | **41.75 ns** |  **2.361 ns** | **0.129 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **25/10**                | **40.78 ns** |  **4.786 ns** | **0.262 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **8/3**                  | **40.80 ns** |  **0.969 ns** | **0.053 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **31415(...)00000 [33]** | **77.75 ns** |  **0.740 ns** | **0.041 ns** | **0.0067** |     **112 B** |
+| **Round**  | **4**          | **AwayFromZero** | **123456/1000**          | **40.52 ns** |  **2.863 ns** | **0.157 ns** |      **-** |         **-** |
+| **Round**  | **4**          | **AwayFromZero** | **400/3**                | **40.90 ns** |  **2.688 ns** | **0.147 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **-3141(...)00000 [34]** | **77.86 ns** |  **6.278 ns** | **0.344 ns** | **0.0067** |     **112 B** |
+| **Round**  | **8**          | **AwayFromZero** | **-2/3**                 | **40.54 ns** |  **2.061 ns** | **0.113 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **-1/123456789**         | **41.30 ns** |  **3.232 ns** | **0.177 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **1/123456789**          | **40.48 ns** |  **1.990 ns** | **0.109 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **2/3**                  | **41.27 ns** |  **1.805 ns** | **0.099 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **1345/1000**            | **55.54 ns** | **24.204 ns** | **1.327 ns** | **0.0038** |      **64 B** |
+| **Round**  | **8**          | **AwayFromZero** | **25/10**                | **54.21 ns** | **19.417 ns** | **1.064 ns** | **0.0038** |      **64 B** |
+| **Round**  | **8**          | **AwayFromZero** | **8/3**                  | **43.44 ns** | **18.697 ns** | **1.025 ns** |      **-** |         **-** |
+| **Round**  | **8**          | **AwayFromZero** | **31415(...)00000 [33]** | **80.80 ns** | **22.103 ns** | **1.212 ns** | **0.0067** |     **112 B** |
+| **Round**  | **8**          | **AwayFromZero** | **123456/1000**          | **57.95 ns** | **12.970 ns** | **0.711 ns** | **0.0057** |      **96 B** |
+| **Round**  | **8**          | **AwayFromZero** | **400/3**                | **56.85 ns** |  **8.850 ns** | **0.485 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **-3141(...)00000 [34]** | **90.37 ns** |  **3.607 ns** | **0.198 ns** | **0.0086** |     **144 B** |
+| **Round**  | **16**         | **AwayFromZero** | **-2/3**                 | **59.53 ns** |  **4.040 ns** | **0.221 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **-1/123456789**         | **57.48 ns** |  **2.950 ns** | **0.162 ns** | **0.0038** |      **64 B** |
+| **Round**  | **16**         | **AwayFromZero** | **1/123456789**          | **58.01 ns** | **11.249 ns** | **0.617 ns** | **0.0038** |      **64 B** |
+| **Round**  | **16**         | **AwayFromZero** | **2/3**                  | **62.01 ns** | **14.580 ns** | **0.799 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **1345/1000**            | **61.01 ns** |  **4.839 ns** | **0.265 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **25/10**                | **60.41 ns** | **27.000 ns** | **1.480 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **8/3**                  | **60.04 ns** | **13.371 ns** | **0.733 ns** | **0.0057** |      **96 B** |
+| **Round**  | **16**         | **AwayFromZero** | **31415(...)00000 [33]** | **91.79 ns** | **21.709 ns** | **1.190 ns** | **0.0086** |     **144 B** |
+| **Round**  | **16**         | **AwayFromZero** | **123456/1000**          | **65.42 ns** |  **2.655 ns** | **0.146 ns** | **0.0067** |     **112 B** |
+| **Round**  | **16**         | **AwayFromZero** | **400/3**                | **59.94 ns** |  **1.949 ns** | **0.107 ns** | **0.0057** |      **96 B** |
diff --git a/src/Fractions/Formatter/DecimalNotationFormatter.cs b/src/Fractions/Formatter/DecimalNotationFormatter.cs
index 025051f..2b126b6 100644
--- a/src/Fractions/Formatter/DecimalNotationFormatter.cs
+++ b/src/Fractions/Formatter/DecimalNotationFormatter.cs
@@ -33,20 +33,14 @@ public class DecimalNotationFormatter : ICustomFormatter {
     ///     <list type="bullet">
     ///         <item>
     ///             On .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least
-    ///             significant digit (that is, using <see cref="MidpointRounding.AwayFromZero" />).
+    ///             significant digit (that is, using <see cref="MidpointRounding.AwayFromZero" />) for both the double and decimal rounding.
     ///         </item>
     ///         <item>
-    ///             On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is,
-    ///             using  <see cref="MidpointRounding.ToEven" />).
+    ///             On .NET Core 2.1 and later, the EEE‑754 floating‑point (e.g. double) numbers appear to be formatted using some variant of the Ry¯u: Fast Float-to-String Conversion.
     ///         </item>
-    ///     </list>
+    ///     </list>   
     /// </summary>
-    private const MidpointRounding DefaultMidpointRoundingMode =
-#if NETCOREAPP2_1_OR_GREATER
-        MidpointRounding.ToEven;
-#else
-        MidpointRounding.AwayFromZero;
-#endif
+    private const MidpointRounding DefaultMidpointRoundingMode =  MidpointRounding.AwayFromZero;
 
     /// <summary>
     ///     The default precision used for the general format specifier (G)
@@ -74,8 +68,6 @@ public class DecimalNotationFormatter : ICustomFormatter {
     /// </remarks>
     public static DecimalNotationFormatter Instance { get; } = new();
 
-    private static readonly BigInteger Ten = new(10);
-
     /// <summary>
     /// <inheritdoc cref="Format(string?,Fraction,System.IFormatProvider?)" path="/summary"/>
     /// </summary>
@@ -267,8 +259,8 @@ private static bool TryGetPrecisionDigits(string format, int defaultPrecision, o
     /// </remarks>
     private static string FormatWithFixedPointFormat(Fraction fraction, string format,
         NumberFormatInfo formatProvider) {
-        if (fraction.Numerator == BigInteger.Zero) {
-            return 0d.ToString(format, formatProvider);
+        if (fraction.Numerator.IsZero) {
+            return 0.ToString(format, formatProvider);
         }
 
         if (fraction.Denominator.IsOne) {
@@ -281,28 +273,8 @@ private static string FormatWithFixedPointFormat(Fraction fraction, string forma
         }
 
         var sb = new StringBuilder(12 + maxNbDecimalsAfterRadix);
-
-#if NETCOREAPP2_1_OR_GREATER
-        if (fraction.IsNegative) {
-            sb.Append(formatProvider.NegativeSign);
-            fraction = fraction.Abs();
-        }
-
         if (maxNbDecimalsAfterRadix == 0) {
-            return sb.Append(Round(fraction.Numerator, fraction.Denominator).ToString(format, formatProvider)).ToString();
-        }
-
-        var roundedFraction = Round(fraction, maxNbDecimalsAfterRadix);
-        if (roundedFraction.Numerator.IsZero || roundedFraction.Denominator.IsOne) {
-            return sb.Append(roundedFraction.Numerator.ToString(format, formatProvider)!).ToString();
-        }
-
-        return AppendDecimals(sb, roundedFraction, formatProvider, maxNbDecimalsAfterRadix).ToString();
-#else
-        // On .NET Framework and .NET Core up to .NET Core 2.0 the string format does not append the '-' sign when a value is rounded to 0.
-        if (maxNbDecimalsAfterRadix == 0) {
-            return sb.Append(Round(fraction.Numerator, fraction.Denominator).ToString(format, formatProvider)!)
-                .ToString();
+            return sb.Append(Round(fraction.Numerator, fraction.Denominator).ToString(format, formatProvider)!).ToString();
         }
 
         var roundedFraction = Round(fraction, maxNbDecimalsAfterRadix);
@@ -311,12 +283,11 @@ private static string FormatWithFixedPointFormat(Fraction fraction, string forma
             roundedFraction = roundedFraction.Abs();
         }
 
-        if (roundedFraction.Numerator.IsZero || roundedFraction.Denominator.IsOne) {
-            return sb.Append(roundedFraction.Numerator.ToString(format, formatProvider)!).ToString();
+        if (roundedFraction.Numerator.IsZero) {
+            return sb.Append(0.ToString(format, formatProvider)).ToString();
         }
 
         return AppendDecimals(sb, roundedFraction, formatProvider, maxNbDecimalsAfterRadix).ToString();
-#endif
     }
 
     /// <summary>
@@ -330,8 +301,8 @@ private static string FormatWithFixedPointFormat(Fraction fraction, string forma
     ///     current <see cref="NumberFormatInfo.NumberDecimalDigits" /> property supplies the numeric precision.
     /// </remarks>
     private static string FormatWithStandardNumericFormat(Fraction fraction, string format, NumberFormatInfo formatProvider) {
-        if (fraction.Numerator == BigInteger.Zero) {
-            return 0d.ToString(format, formatProvider);
+        if (fraction.Numerator.IsZero) {
+            return 0.ToString(format, formatProvider);
         }
 
         if (fraction.Denominator.IsOne) {
@@ -352,24 +323,18 @@ private static string FormatWithStandardNumericFormat(Fraction fraction, string
 
         if (maxNbDecimals == 0) {
             var roundedValue = Round(fraction.Numerator, fraction.Denominator);
-#if NETSTANDARD
             if (roundedValue.IsZero) {
-                return 0d.ToString(format, formatProvider);
+                return 0.ToString(format, formatProvider);
             }
-#endif
+            
             sb.Append(roundedValue.ToString(format, formatProvider)!);
         } else {
             var roundedFraction = Round(fraction, maxNbDecimals);
-            if (roundedFraction.Numerator.IsZero || roundedFraction.Denominator.IsOne) {
-#if NETSTANDARD
-                if (roundedFraction.Numerator.IsZero) {
-                    return 0d.ToString(format, formatProvider);
-                }
-#endif
-                sb.Append(roundedFraction.Numerator.ToString(format, formatProvider)!);
-            } else {
-                AppendDecimals(sb, roundedFraction, formatProvider, maxNbDecimals, "N0");
+            if (roundedFraction.Numerator.IsZero) {
+                return 0.ToString(format, formatProvider);
             }
+
+            AppendDecimals(sb, roundedFraction, formatProvider, maxNbDecimals, "N0");
         }
 
         return isPositive
@@ -386,9 +351,8 @@ static string withNegativeSign(StringBuilder sb, string negativeSignSymbol, int
                     sb.Insert(0, negativeSignSymbol + ' ').ToString(),
                 3 => // n-
                     sb.Append(negativeSignSymbol).ToString(),
-                4 => // n -
+                _ => // n -
                     sb.Append(' ').Append(negativeSignSymbol).ToString(),
-                _ => throw new ArgumentOutOfRangeException(nameof(pattern))
             };
         }
     }
@@ -428,11 +392,10 @@ private static string FormatWithPercentFormat(Fraction fraction, string format,
 
         if (maxNbDecimals == 0) {
             var roundedValue = Round(100 * fraction.Numerator, fraction.Denominator);
-#if NETSTANDARD
             if (roundedValue.IsZero) {
                 return 0.ToString(format, formatProvider);
             }
-#endif
+            
             var percentFormatString = 'N' + maxNbDecimals.ToString();
             if (fraction.IsPositive) {
                 sb.Append(roundedValue.ToString(percentFormatString, percentFormatInfo));
@@ -440,8 +403,7 @@ private static string FormatWithPercentFormat(Fraction fraction, string format,
             }
 
             sb.Append((-roundedValue).ToString(percentFormatString, percentFormatInfo));
-            return withNegativeSign(sb, formatProvider.PercentSymbol, formatProvider.NegativeSign,
-                formatProvider.PercentNegativePattern);
+            return withNegativeSign(sb, formatProvider.PercentSymbol, formatProvider.NegativeSign, formatProvider.PercentNegativePattern);
         }
 
         var isPositive = fraction.IsPositive;
@@ -454,11 +416,10 @@ private static string FormatWithPercentFormat(Fraction fraction, string format,
 
         var roundedFraction = Round(fraction, maxNbDecimals);
         if (roundedFraction.Numerator.IsZero || roundedFraction.Denominator.IsOne) {
-#if NETSTANDARD
             if (roundedFraction.Numerator.IsZero) {
                 return 0.ToString(format, formatProvider);
             }
-#endif
+            
             var percentFormatString = 'N' + maxNbDecimals.ToString();
             sb.Append(roundedFraction.Numerator.ToString(percentFormatString, percentFormatInfo)!);
         } else {
@@ -478,9 +439,8 @@ static string withPositiveSign(StringBuilder sb, string percentSymbol, int patte
                     sb.Append(percentSymbol).ToString(),
                 2 => // %n
                     sb.Insert(0, percentSymbol).ToString(),
-                3 => // % n
+                _ => // % n
                     sb.Insert(0, percentSymbol + ' ').ToString(),
-                _ => throw new ArgumentOutOfRangeException(nameof(pattern))
             };
         }
 
@@ -508,9 +468,8 @@ static string withNegativeSign(StringBuilder sb, string percentSymbol, string ne
                     sb.Insert(0, percentSymbol + ' ').Append(negativeSignSymbol).ToString(),
                 10 => // % -n
                     sb.Insert(0, percentSymbol + ' ').Insert(2, negativeSignSymbol).ToString(),
-                11 => // n- %
+                _ => // n- %
                     sb.Append(negativeSignSymbol).Append(' ').Append(percentSymbol).ToString(),
-                _ => throw new ArgumentOutOfRangeException(nameof(pattern))
             };
         }
     }
@@ -527,7 +486,7 @@ static string withNegativeSign(StringBuilder sb, string percentSymbol, string ne
     ///     greater, the last digit in the result string is rounded away from zero.
     /// </remarks>
     private static string FormatWithCurrencyFormat(Fraction fraction, string format, NumberFormatInfo formatProvider) {
-        if (fraction.Numerator == BigInteger.Zero) {
+        if (fraction.Numerator.IsZero) {
             return 0.ToString(format, formatProvider);
         }
 
@@ -552,11 +511,10 @@ private static string FormatWithCurrencyFormat(Fraction fraction, string format,
 
         if (maxNbDecimals == 0) {
             var roundedValue = Round(fraction.Numerator, fraction.Denominator);
-#if NETSTANDARD
             if (roundedValue.IsZero) {
                 return 0.ToString(format, formatProvider);
             }
-#endif
+            
             var currencyFormatString = 'N' + maxNbDecimals.ToString();
             if (fraction.IsPositive) {
                 sb.Append(roundedValue.ToString(currencyFormatString, currencyFormatInfo));
@@ -575,18 +533,13 @@ private static string FormatWithCurrencyFormat(Fraction fraction, string format,
         }
 
         var roundedFraction = Round(fraction, maxNbDecimals);
-        if (roundedFraction.Numerator.IsZero || roundedFraction.Denominator.IsOne) {
-#if NETSTANDARD
-            if (roundedFraction.Numerator.IsZero) {
-                return 0.ToString(format, formatProvider);
-            }
-#endif
-            var currencyFormatString = 'N' + maxNbDecimals.ToString();
-            sb.Append(roundedFraction.Numerator.ToString(currencyFormatString, currencyFormatInfo)!);
-        } else {
-            AppendDecimals(sb, roundedFraction, currencyFormatInfo, maxNbDecimals, "N0");
+        
+        if (roundedFraction.Numerator.IsZero) {
+            return 0.ToString(format, formatProvider);
         }
 
+        AppendDecimals(sb, roundedFraction, currencyFormatInfo, maxNbDecimals, "N0");
+
         return isPositive
             ? withPositiveSign(sb, formatProvider.CurrencySymbol, formatProvider.CurrencyPositivePattern)
             : withNegativeSign(sb, formatProvider.CurrencySymbol, formatProvider.NegativeSign,
@@ -600,9 +553,8 @@ static string withPositiveSign(StringBuilder sb, string currencySymbol, int patt
                     sb.Append(currencySymbol).ToString(),
                 2 => // $ n
                     sb.Insert(0, currencySymbol + ' ').ToString(),
-                3 => // n $
+                _ => // n $
                     sb.Append(' ').Append(currencySymbol).ToString(),
-                _ => throw new ArgumentOutOfRangeException(nameof(pattern))
             };
         }
 
@@ -639,11 +591,15 @@ static string withNegativeSign(StringBuilder sb, string currencySymbol, string n
                     sb.Append(negativeSignSymbol).Append(' ').Append(currencySymbol).ToString(),
                 14 => // ($ n)
                     sb.Insert(0, '(').Insert(1, currencySymbol + ' ').Append(')').ToString(),
+#if NETSTANDARD
+                _ => // (n $)
+                    sb.Insert(0, '(').Append(' ').Append(currencySymbol).Append(')').ToString(),
+#else
                 15 => // (n $)
                     sb.Insert(0, '(').Append(' ').Append(currencySymbol).Append(')').ToString(),
-                16 => // $- n
+                _ => // $- n
                     sb.Insert(0, currencySymbol + negativeSignSymbol + ' ').ToString(),
-                _ => throw new ArgumentOutOfRangeException(nameof(pattern))
+#endif
             };
         }
     }
@@ -662,8 +618,8 @@ static string withNegativeSign(StringBuilder sb, string currencySymbol, string n
     ///     this minimum, if required.
     /// </remarks>
     private static string FormatWithScientificFormat(Fraction fraction, string format, NumberFormatInfo formatProvider) {
-        if (fraction.Numerator == BigInteger.Zero) {
-            return 0d.ToString(format, formatProvider);
+        if (fraction.Numerator.IsZero) {
+            return 0.ToString(format, formatProvider);
         }
 
         if (fraction.Denominator.IsOne) {
@@ -682,7 +638,7 @@ private static string FormatWithScientificFormat(Fraction fraction, string forma
             fraction = fraction.Abs();
         }
 
-        var exponent = GetExponentPower(fraction, out var exponentTerm);
+        var exponent = GetExponentPower(fraction.Numerator, fraction.Denominator, out var exponentTerm);
         var mantissa = exponent switch {
             0 => Round(fraction, maxNbDecimals),
             > 0 => Round(fraction / exponentTerm, maxNbDecimals),
@@ -716,8 +672,8 @@ static string withAppendedExponent(StringBuilder sb, int exponent, NumberFormatI
     ///     is omitted or zero, the type of the number determines the default precision.
     /// </remarks>
     private static string FormatGeneral(Fraction fraction, string format, NumberFormatInfo formatProvider) {
-        if (fraction.Numerator == BigInteger.Zero) {
-            return 0d.ToString(format, formatProvider);
+        if (fraction.Numerator.IsZero) {
+            return 0.ToString(format, formatProvider);
         }
 
         if (!TryGetPrecisionDigits(format, DefaultGeneralFormatPrecision, out var maxNbDecimals)) {
@@ -736,7 +692,7 @@ private static string FormatGeneral(Fraction fraction, string format, NumberForm
             fraction = fraction.Abs();
         }
 
-        var exponent = GetExponentPower(fraction, out var exponentTerm);
+        var exponent = GetExponentPower(fraction.Numerator, fraction.Denominator, out var exponentTerm);
 
         if (exponent == maxNbDecimals - 1) {
             // integral result: both 123400 (1.234e5) and 123400.01 (1.234001e+005) result in "123400" with the "G6" format
@@ -745,28 +701,29 @@ private static string FormatGeneral(Fraction fraction, string format, NumberForm
 
         if (exponent > maxNbDecimals - 1) {
             // we are required to shorten down a number of the form 123400 (1.234E+05)
-            var mantissa = Round(fraction / exponentTerm, maxNbDecimals - 1);
-            AppendSignificantDecimals(sb, mantissa, formatProvider, maxNbDecimals - 1);
+            if (maxNbDecimals == 1) {
+                sb.Append(Round(fraction.Numerator, fraction.Denominator * exponentTerm));
+            } else {
+                var mantissa = Round(new Fraction(fraction.Numerator, fraction.Denominator * exponentTerm, false), maxNbDecimals - 1);
+                AppendSignificantDecimals(sb, mantissa, formatProvider, maxNbDecimals - 1);
+            }
+            
             return AppendExponentWithSignificantDigits(sb, exponent, formatProvider, format[0] is 'g' ? 'e' : 'E')
                 .ToString();
         }
 
-        switch (exponent) {
-            case >= 0:
-                // the required number of significant digits is less than the specified limit: e.g. 123.45 with the "G20"
-                return AppendSignificantDecimals(sb, fraction, formatProvider, maxNbDecimals - exponent - 1).ToString();
-            case <= -5:
-                // the largest value would have the form: 1.23e-5 (0.000123)
-                var mantissa = Round(fraction * exponentTerm, maxNbDecimals - 1);
-                AppendSignificantDecimals(sb, mantissa, formatProvider, maxNbDecimals - 1);
-                return AppendExponentWithSignificantDigits(sb, exponent, formatProvider, format[0] is 'g' ? 'e' : 'E')
-                    .ToString();
-            default:
-                // the smallest value would have the form: 1.23e-4 (0.00123)
-                var roundedDecimal = Round(fraction, maxNbDecimals - exponent - 1);
-                return AppendSignificantDecimals(sb, roundedDecimal, formatProvider, maxNbDecimals - exponent - 1)
-                    .ToString();
+        if (exponent <= -5) {
+            // the largest value would have the form: 1.23e-5 (0.000123)
+            var mantissa = Round(fraction * exponentTerm, maxNbDecimals - 1);
+            AppendSignificantDecimals(sb, mantissa, formatProvider, maxNbDecimals - 1);
+            return AppendExponentWithSignificantDigits(sb, exponent, formatProvider, format[0] is 'g' ? 'e' : 'E')
+                .ToString();
         }
+        
+        // the smallest value would have the form: 1.23e-4 (0.00123)
+        var roundedDecimal = Round(fraction, maxNbDecimals - exponent - 1);
+        return AppendSignificantDecimals(sb, roundedDecimal, formatProvider, maxNbDecimals - exponent - 1)
+            .ToString();
     }
 
     /// <summary>
@@ -800,8 +757,8 @@ private static string FormatGeneral(Fraction fraction, string format, NumberForm
     /// </remarks>
     private static string FormatWithSignificantDigitsAfterRadix(Fraction fraction, string format,
         NumberFormatInfo formatProvider) {
-        if (fraction.Numerator == BigInteger.Zero) {
-            return 0d.ToString(formatProvider);
+        if (fraction.Numerator.IsZero) {
+            return 0.ToString(formatProvider);
         }
 
         const string quotientFormat = "N0";
@@ -818,18 +775,20 @@ private static string FormatWithSignificantDigitsAfterRadix(Fraction fraction, s
             fraction = fraction.Abs();
         }
 
-        var exponent = GetExponentPower(fraction, out var exponentTerm);
+        var exponent = GetExponentPower(fraction.Numerator, fraction.Denominator, out var exponentTerm);
         Fraction mantissa;
         switch (exponent) {
             case > 5:
                 // the smallest value would have the form: 1.23e6 (1230000)
-                mantissa = Round(fraction / exponentTerm, maxDigitsAfterRadix);
+                // mantissa = Round(fraction / exponentTerm, maxDigitsAfterRadix);
+                mantissa = Round(new Fraction(fraction.Numerator, fraction.Denominator * exponentTerm, false), maxDigitsAfterRadix);
                 AppendSignificantDecimals(sb, mantissa, formatProvider, maxDigitsAfterRadix, quotientFormat);
                 return AppendExponentWithSignificantDigits(sb, exponent, formatProvider, format[0] is 's' ? 'e' : 'E')
                     .ToString();
             case <= -4:
                 // the largest value would have the form: 1.23e-4 (0.000123)
-                mantissa = Round(fraction * exponentTerm, maxDigitsAfterRadix);
+                // mantissa = Round(fraction * exponentTerm, maxDigitsAfterRadix);
+                mantissa = Round(new Fraction(fraction.Numerator * exponentTerm, fraction.Denominator, false), maxDigitsAfterRadix);
                 AppendSignificantDecimals(sb, mantissa, formatProvider, maxDigitsAfterRadix, quotientFormat);
                 return AppendExponentWithSignificantDigits(sb, exponent, formatProvider, format[0] is 's' ? 'e' : 'E')
                     .ToString();
@@ -848,11 +807,40 @@ private static string FormatWithSignificantDigitsAfterRadix(Fraction fraction, s
         }
     }
 
+    private static BigInteger PreviousPowerOfTen(BigInteger powerOfTen, int exponent) {
+        return exponent <= Fraction.PowersOfTen.Length ? Fraction.PowersOfTen[exponent - 1] : powerOfTen / Fraction.TEN;
+    }
 
-    private static StringBuilder AppendDecimals(StringBuilder sb, Fraction fraction, NumberFormatInfo formatProvider,
-        int nbDecimals, string quotientFormat = "F0",
-        MidpointRounding roundingMode = DefaultMidpointRoundingMode) {
-        var quotient = BigInteger.DivRem(fraction.Numerator, fraction.Denominator, out var remainder);
+    private static BigInteger NextPowerOfTen(BigInteger powerOfTen, int exponent) {
+        return exponent + 1 < Fraction.PowersOfTen.Length ? Fraction.PowersOfTen[exponent + 1] : powerOfTen * Fraction.TEN;
+    }
+
+    /// <summary>
+    ///     Appends the decimal representation of a fraction to the specified <see cref="StringBuilder" />.
+    /// </summary>
+    /// <param name="sb">The <see cref="StringBuilder" /> to which the decimal representation will be appended.</param>
+    /// <param name="decimalFraction">The <see cref="Fraction" /> to be represented in decimal form.</param>
+    /// <param name="formatProvider">The <see cref="NumberFormatInfo" /> that provides culture-specific formatting information.</param>
+    /// <param name="nbDecimals">The maximum number of decimal places to include in the representation.</param>
+    /// <param name="quotientFormat">
+    ///     An optional format string for formatting the quotient part of the fraction.
+    ///     Defaults to <c>"F0"</c>.
+    /// </param>
+    /// <returns>The <see cref="StringBuilder" /> with the appended decimal representation.</returns>
+    /// <remarks>
+    ///     This method calculates the decimal representation of the given fraction by dividing the numerator
+    ///     by the denominator and appending the result to the <paramref name="sb" />, padding with "0" to ensure the specified
+    ///     number of decimal places is respected.
+    ///     <para>
+    ///         The <paramref name="decimalFraction" /> must represent a value with a denominator that is a power of 10,
+    ///         equal to the specified <paramref name="nbDecimals" />.
+    ///     </para>
+    /// </remarks>
+    private static StringBuilder AppendDecimals(StringBuilder sb, Fraction decimalFraction, NumberFormatInfo formatProvider,
+        int nbDecimals, string quotientFormat = "F0") {
+        var numerator = decimalFraction.Numerator;
+        var denominator = decimalFraction.Denominator;
+        var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
 
         sb.Append(quotient.ToString(quotientFormat, formatProvider)).Append(formatProvider.NumberDecimalSeparator);
 
@@ -860,24 +848,49 @@ private static StringBuilder AppendDecimals(StringBuilder sb, Fraction fraction,
 
         var decimalsAdded = 0;
         while (!remainder.IsZero && decimalsAdded++ < nbDecimals - 1) {
-            quotient = BigInteger.DivRem(remainder * Ten, fraction.Denominator, out remainder);
-            sb.Append(quotient.ToString(formatProvider));
+            denominator = PreviousPowerOfTen(denominator, nbDecimals - decimalsAdded + 1);
+            var digit = (int)BigInteger.DivRem(remainder, denominator, out remainder);
+            sb.Append(digit.ToString(formatProvider));
         }
 
         if (remainder.IsZero) {
             sb.Append('0', nbDecimals - decimalsAdded);
         } else {
-            quotient = Round(remainder * Ten, fraction.Denominator, roundingMode);
-            sb.Append(quotient.ToString(formatProvider));
+            sb.Append(remainder.ToString(formatProvider));
         }
 
         return sb;
     }
 
-    private static StringBuilder AppendSignificantDecimals(StringBuilder sb, Fraction mantissa,
-        NumberFormatInfo formatProvider, int maxNbDecimals,
-        string quotientFormat = "F0") {
-        var quotient = BigInteger.DivRem(mantissa.Numerator, mantissa.Denominator, out var remainder);
+    /// <summary>
+    ///     Appends the significant decimal digits of a fractional number to the specified <see cref="StringBuilder" />.
+    /// </summary>
+    /// <param name="sb">The <see cref="StringBuilder" /> to which the significant decimal digits will be appended.</param>
+    /// <param name="decimalFraction">
+    ///     The fractional number whose significant decimal digits are to be appended.
+    ///     The denominator of this fraction must be a power of 10, corresponding to the <paramref name="maxNbDecimals" />.
+    /// </param>
+    /// <param name="formatProvider">The <see cref="NumberFormatInfo" /> that provides culture-specific formatting information.</param>
+    /// <param name="maxNbDecimals">The maximum number of decimal digits to append.</param>
+    /// <param name="quotientFormat">
+    ///     An optional format string that specifies the format of the quotient. Defaults to "F0".
+    /// </param>
+    /// <returns>
+    ///     The <see cref="StringBuilder" /> instance with the appended significant decimal digits.
+    /// </returns>
+    /// <remarks>
+    ///     This method calculates and appends the significant decimal digits of the given fractional number.
+    ///     It ensures that the number of appended decimal digits does not exceed the specified maximum.
+    ///     <para>
+    ///         The <paramref name="decimalFraction" /> must represent a value with a denominator that is a power of 10,
+    ///         equal to the specified <paramref name="maxNbDecimals" />.
+    ///     </para>
+    /// </remarks>
+    private static StringBuilder AppendSignificantDecimals(StringBuilder sb, Fraction decimalFraction, NumberFormatInfo formatProvider,
+        int maxNbDecimals, string quotientFormat = "F0") {
+        var numerator = decimalFraction.Numerator;
+        var denominator = decimalFraction.Denominator;
+        var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
 
         sb.Append(quotient.ToString(quotientFormat, formatProvider));
 
@@ -887,17 +900,14 @@ private static StringBuilder AppendSignificantDecimals(StringBuilder sb, Fractio
 
         sb.Append(formatProvider.NumberDecimalSeparator);
 
-        var nbDecimals = 0;
-        while (nbDecimals++ < maxNbDecimals - 1) {
-            quotient = BigInteger.DivRem(remainder * Ten, mantissa.Denominator, out remainder);
-            sb.Append(quotient.ToString(formatProvider));
-            if (remainder == BigInteger.Zero) {
-                return sb;
-            }
-        }
+        var decimalsRemaining = maxNbDecimals;
+        do {
+            denominator = PreviousPowerOfTen(denominator, decimalsRemaining);
+            var digit = (int)BigInteger.DivRem(remainder, denominator, out remainder);
+            sb.Append(digit.ToString(formatProvider));
+            decimalsRemaining--;
+        } while (!remainder.IsZero && decimalsRemaining > 0);
 
-        quotient = Round(remainder * Ten, mantissa.Denominator);
-        sb.Append(quotient.ToString(formatProvider));
         return sb;
     }
 
@@ -953,69 +963,92 @@ private static BigInteger Round(BigInteger numerator, BigInteger denominator,
 
     #endregion
 
+    private static readonly double Log10Of2 = Math.Log10(2);
+
     /// <summary>
-    ///     Calculates the exponent power for the given fraction.
+    ///     Calculates the exponent power for the given fraction terms.
     /// </summary>
-    /// <param name="fraction">The fraction for which to calculate the exponent power. The fraction must be positive.</param>
+    /// <param name="numerator">The numerator of the fraction.</param>
+    /// <param name="denominator">The denominator of the fraction.</param>
     /// <param name="powerOfTen">
     ///     Output parameter that returns the power of ten that corresponds to the calculated exponent
     ///     power.
     /// </param>
     /// <returns>The exponent power for the given fraction.</returns>
-    private static int GetExponentPower(Fraction fraction, out BigInteger powerOfTen) {
-        var numerator = fraction.Numerator;
-        var denominator = fraction.Denominator;
+    /// <remarks>It is expected that both terms have the same sign (i.e. the Fraction is positive)</remarks>
+    private static int GetExponentPower(BigInteger numerator, BigInteger denominator, out BigInteger powerOfTen) {
         if (denominator.Sign == -1) {
             // normalize the signs of the terms
             numerator = -numerator;
             denominator = -denominator;
         }
 
-        if (numerator > denominator) {
-            var nbDigits = CountDigits(numerator / denominator, out powerOfTen);
-            if (numerator * powerOfTen < Ten * denominator) {
-                return nbDigits;
-            }
-
-            powerOfTen /= Ten;
-            return nbDigits - 1;
-        } else {
-            var nbDigits = CountDigits(denominator / numerator, out powerOfTen);
-            if (numerator * powerOfTen < Ten * denominator) {
-                return -nbDigits;
+        // Preconditions: numerator > 0, denominator > 0.
+#if NET
+        var numLen = numerator.GetBitLength();
+        var denLen = denominator.GetBitLength();
+#else
+        var numLen = getBitLength(numerator);
+        var denLen = getBitLength(denominator);
+#endif
+        // If the two numbers have equal bit-length, then their ratio is in [1,2) if numerator >= denominator,
+        // or in (0,1) if numerator < denominator. In these cases the scientific exponent is fixed.
+        if (numLen == denLen) {
+            if (numerator >= denominator) {
+                powerOfTen = BigInteger.One; // 10^0
+                return 0;
             }
 
-            powerOfTen /= Ten;
-            return -nbDigits + 1;
+            // When numerator < denominator, ratio < 1, and normalization requires multiplying by 10 once.
+            powerOfTen = Fraction.TEN; // 10^1, leading to an exponent of -1.
+            return -1;
         }
-    }
 
+        if (numLen > denLen) {
+            // Case: number >= 1, so the scientific exponent is positive.
+            // The adjusted candidate uses (diffBits - 1) because an L-bit number is at least 2^(L-1).
+            var diffBits = numLen - denLen;
+            var exponent = (int)Math.Floor((diffBits - 1) * Log10Of2) + 1;
+            powerOfTen = Fraction.PowerOfTen(exponent);
 
-#if NET5_0_OR_GREATER
-    private static readonly double Log10Of2 = Math.Log10(2);
-    private static int CountDigits(BigInteger value, out BigInteger powerOfTen) {
-        var numBits = value.GetBitLength();
-        var base10Digits = (int)(numBits * Log10Of2);
-        powerOfTen = BigInteger.Pow(Ten, base10Digits);
+            // Adjustment: if our candidate powerOfTen is too high,
+            // then the quotient doesn't reach that many digits.
+            if (numerator >= denominator * powerOfTen) {
+                return exponent;
+            }
 
-        if (value < powerOfTen) {
-            return base10Digits;
-        }
+            powerOfTen = PreviousPowerOfTen(powerOfTen, exponent);
+            return exponent - 1;
+        } else {
+            // Case: number < 1, so the scientific exponent is negative.
+            // We need the smallest k such that numerator * 10^k >= denominator.
+            var diffBits = denLen - numLen;
+            var exponent = (int)Math.Ceiling(diffBits * Log10Of2) - 1;
+            powerOfTen = Fraction.PowerOfTen(exponent);
+
+            // First, check if one fewer factor of Ten would suffice.
+            if (numerator * powerOfTen >= denominator) {
+                return -exponent;
+            }
 
-        powerOfTen *= Ten;
-        return base10Digits + 1;
-    }
-#else
-    private static int CountDigits(BigInteger value, out BigInteger powerOfTen) {
-        var base10Digits = (int)Math.Ceiling(BigInteger.Log10(value));
-        powerOfTen = BigInteger.Pow(Ten, base10Digits);
+            // Select the next guess as 10^exponent
+            powerOfTen = NextPowerOfTen(powerOfTen, exponent++);
+            
+            // Then, check if our candidate is too low.
+            if (numerator * powerOfTen < denominator) {
+                powerOfTen = NextPowerOfTen(powerOfTen, exponent++);
+            }
 
-        if (value < powerOfTen) {
-            return base10Digits;
+            // For numbers < 1, the scientific exponent is -k.
+            return -exponent;
         }
 
-        powerOfTen *= Ten;
-        return base10Digits + 1;
-    }
+#if NETSTANDARD
+        static long getBitLength(BigInteger value) {
+            // Using BigInteger.Log(value, 2) avoids creating a byte array.
+            // Note: For value > 0 this returns a double that we floor and add 1.
+            return (long)Math.Floor(BigInteger.Log(value, 2)) + 1;
+        }
 #endif
+    }
 }
diff --git a/src/Fractions/Fraction.Math.cs b/src/Fractions/Fraction.Math.cs
index 95b4ce5..5c68257 100644
--- a/src/Fractions/Fraction.Math.cs
+++ b/src/Fractions/Fraction.Math.cs
@@ -555,6 +555,8 @@ public static Fraction Pow(Fraction @base, int exponent) {
             denominator: BigInteger.Pow(fraction.Denominator, exponent));
     }
 
+    internal static BigInteger PowerOfTen(int exponent) => exponent < PowersOfTen.Length ? PowersOfTen[exponent] : BigInteger.Pow(TEN, exponent);
+
     /// <summary>
     /// Returns a fraction with the numerator and denominator exchanged.
     /// </summary>
diff --git a/src/Fractions/Fraction.Round.cs b/src/Fractions/Fraction.Round.cs
index 30a0dfb..85e6cfa 100644
--- a/src/Fractions/Fraction.Round.cs
+++ b/src/Fractions/Fraction.Round.cs
@@ -55,7 +55,7 @@ public static Fraction Round(Fraction fraction, int decimals, MidpointRounding m
                 return fraction.Reduce();
             }
 
-            var factor = BigInteger.Pow(TEN, decimals);
+            var factor = PowerOfTen(decimals);
             var roundedNumerator = RoundToBigInteger(numerator * factor, denominator, mode);
             return ReduceSigned(roundedNumerator, factor);
         } else {
@@ -68,8 +68,8 @@ public static Fraction Round(Fraction fraction, int decimals, MidpointRounding m
             if (denominator.IsOne || denominator.IsZero) {
                 return fraction;
             }
-
-            var factor = BigInteger.Pow(TEN, decimals);
+            
+            var factor = PowerOfTen(decimals);
             var roundedNumerator = RoundToBigInteger(numerator * factor, denominator, mode);
             return new Fraction(true, roundedNumerator, factor);
         }
@@ -120,9 +120,10 @@ private static BigInteger RoundToBigInteger(BigInteger numerator, BigInteger den
         };
 
         static BigInteger roundAwayFromZero(BigInteger numerator, BigInteger denominator) {
+            var halfDenominator = denominator >> 1;
             return numerator.Sign == denominator.Sign
-                ? BigInteger.Divide(numerator + (denominator / 2), denominator)
-                : BigInteger.Divide(numerator - (denominator / 2), denominator);
+                ? BigInteger.Divide(numerator + halfDenominator, denominator)
+                : BigInteger.Divide(numerator - halfDenominator, denominator);
         }
 
         static BigInteger roundToEven(BigInteger numerator, BigInteger denominator) {
@@ -134,29 +135,29 @@ static BigInteger roundToEven(BigInteger numerator, BigInteger denominator) {
             if (denominator.Sign == 1) {
                 if (numerator.Sign == 1) {
                     // Both values are positive
-                    var midpoint = 2 * remainder;
+                    var midpoint = remainder << 1;
                     if (midpoint > denominator || (midpoint == denominator && !quotient.IsEven)) {
-                        return quotient + 1;
+                        return quotient + BigInteger.One;
                     }
                 } else {
                     // For negative values
-                    var midpoint = -2 * remainder;
+                    var midpoint = -remainder << 1;
                     if (midpoint > denominator || (midpoint == denominator && !quotient.IsEven)) {
-                        return quotient - 1;
+                        return quotient - BigInteger.One;
                     }
                 }
             } else {
                 if (numerator.Sign == -1) {
                     // Both values are positive
-                    var midpoint = 2 * remainder;
+                    var midpoint = remainder << 1;
                     if (midpoint < denominator || (midpoint == denominator && !quotient.IsEven)) {
-                        return quotient + 1;
+                        return quotient + BigInteger.One;
                     }
                 } else {
                     // For negative values
-                    var midpoint = -2 * remainder;
+                    var midpoint = -remainder << 1;
                     if (midpoint < denominator || (midpoint == denominator && !quotient.IsEven)) {
-                        return quotient - 1;
+                        return quotient - BigInteger.One;
                     }
                 }
             }
@@ -166,12 +167,12 @@ static BigInteger roundToEven(BigInteger numerator, BigInteger denominator) {
 #if NET
         static BigInteger roundToPositiveInfinity(BigInteger numerator, BigInteger denominator) {
             var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
-            return remainder.Sign == denominator.Sign ? quotient + 1 : quotient;
+            return remainder.Sign == denominator.Sign ? quotient + BigInteger.One : quotient;
         }
 
         static BigInteger roundToNegativeInfinity(BigInteger numerator, BigInteger denominator) {
             var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
-            return remainder.Sign == -denominator.Sign ? quotient - 1 : quotient;
+            return remainder.Sign == -denominator.Sign ? quotient - BigInteger.One : quotient;
         }
 #endif
     }
diff --git a/src/Fractions/Fraction.cs b/src/Fractions/Fraction.cs
index 153e577..16c7ea0 100644
--- a/src/Fractions/Fraction.cs
+++ b/src/Fractions/Fraction.cs
@@ -16,7 +16,30 @@ namespace Fractions;
 [DebuggerTypeProxy(typeof(FractionDebugView))]
 public readonly partial struct Fraction : IEquatable<Fraction>, IComparable, IComparable<Fraction>, IFormattable {
 #pragma warning disable IDE1006
-    private static readonly BigInteger TEN = new(10);
+    internal static readonly BigInteger TEN = new(10);
+
+    internal static readonly BigInteger[] PowersOfTen = [
+        BigInteger.One, // 10^0 = 1
+        new(10), // 10^1 = 10
+        new(100), // 10^2 = 100
+        new(1000), // 10^3 = 1,000
+        new(10000), // 10^4 = 10,000
+        new(100000), // 10^5 = 100,000
+        new(1000000), // 10^6 = 1,000,000
+        new(10000000), // 10^7 = 10,000,000
+        new(100000000), // 10^8 = 100,000,000
+        new(1000000000), // 10^9 = 1,000,000,000
+        new(10000000000), // 10^10 = 10,000,000,000
+        new(100000000000), // 10^11 = 100,000,000,000
+        new(1000000000000), // 10^12 = 1,000,000,000,000
+        new(10000000000000), // 10^13 = 10,000,000,000,000
+        new(100000000000000), // 10^14 = 100,000,000,000,000
+        new(1000000000000000), // 10^15 = 1,000,000,000,000,000
+        new(10000000000000000), // 10^16 = 10,000,000,000,000,000
+        new(100000000000000000), // 10^17 = 100,000,000,000,000,000
+        new(1000000000000000000) // 10^18 = 1,000,000,000,000,000,000
+    ];
+
 #pragma warning restore IDE1006
 
     private readonly BigInteger? _denominator;
diff --git a/tests/Fractions.Tests/StringFormatters/DecimalNotationFormatter_Format.cs b/tests/Fractions.Tests/StringFormatters/DecimalNotationFormatter_Format.cs
index 52addb0..9565ef6 100644
--- a/tests/Fractions.Tests/StringFormatters/DecimalNotationFormatter_Format.cs
+++ b/tests/Fractions.Tests/StringFormatters/DecimalNotationFormatter_Format.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Numerics;
 using FluentAssertions;
 using Fractions.Formatter;
 using NUnit.Framework;
@@ -10,7 +11,7 @@
 namespace Fractions.Tests.StringFormatters;
 
 public abstract class DecimalNotationFormatterSpecs : Spec {
-    protected static readonly ICustomFormatter DecimalFormatter = DecimalNotationFormatter.Instance;
+    protected static readonly DecimalNotationFormatter DecimalFormatter = DecimalNotationFormatter.Instance;
 
     protected static readonly CultureInfo AmericanCulture = CultureInfo.GetCultureInfo("en-US");
     protected static readonly CultureInfo NorwegianCulture = CultureInfo.GetCultureInfo("nb-NO");
@@ -25,7 +26,8 @@ public abstract class DecimalNotationFormatterSpecs : Spec {
 
     protected static readonly Fraction[] TerminatingFractions = [
         0, 1, -1, 10, -10, 100, -100, 1000, -1000, 10000, -10000, 100000, -100000,
-        0.1m, -0.1m, 0.2m, -0.2m, 0.5m, -0.5m, 1.2m, -1.2m, 1.5m, -1.5m, 2.5m, -2.5m,
+        0.1m, -0.1m, 0.2m, -0.2m, 0.5m, -0.5m, 1.2m, -1.2m, 1.5m, -1.5m, 1.95m, -1.95m, 2.5m, -2.5m,
+        2.001234m, 2.1001234m,
         0.000015545665434654m, -0.000015545665434654m,
         0.00015545665434654m, -0.00015545665434654m,
         0.0015545665434654m, -0.0015545665434654m,
@@ -37,7 +39,10 @@ public abstract class DecimalNotationFormatterSpecs : Spec {
         1554.5665434654m, -1554.5665434654m,
         15545.665434654m, -15545.665434654m,
         155456.65434654m, -155456.65434654m,
-        1554566.5434654m, -1554566.5434654m
+        1554566.5434654m, -1554566.5434654m,
+        new Fraction(-10, -20, false), new Fraction(10, -20, false),
+        // 128 in binary is 10000000, so its bit length is 8. 1400 is between 2^10 (1024) and 2^11 (2048), so its bit length is 11.
+        new Fraction(128, 1400, false), new Fraction(-128, 1400, false)
     ];
 
     protected static readonly Fraction[] NonTerminatingFractions = [
@@ -50,7 +55,6 @@ public abstract class DecimalNotationFormatterSpecs : Spec {
         new Fraction(4, 3), new Fraction(-4, 3),
         new Fraction(5, 3), new Fraction(-5, 3),
         new Fraction(7, 3), new Fraction(-7, 3),
-        new Fraction(-10, -20, false), new Fraction(10, -20, false)
     ];
 
     /// <summary>
@@ -69,90 +73,22 @@ public abstract class DecimalNotationFormatterSpecs : Spec {
 [TestFixture]
 public class When_formatting_a_fraction_using_the_general_format : DecimalNotationFormatterSpecs {
     private static readonly string[] GeneralFormats =
-        ["G", "G0", "G1", "G2", "G3", "G4", "G5", "G6", "g", "g0", "g1", "g2", "g3", "g4", "g5", "g6"];
+        ["G1", "G2", "G3", "G4", "G5", "G6", "g1", "g6"];
 
-    public static IEnumerable<TestCaseData> FormatWithTerminatingFractionCases =>
+    public static IEnumerable<TestCaseData> FormatWithFiniteFractionCases =>
         from stringFormat in GeneralFormats
-        from valueToTest in TerminatingFractions
-        from cultureToTest in FormatProviders
-        select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
-
-    [Test]
-    [TestCaseSource(nameof(FormatWithTerminatingFractionCases))]
-    public string The_general_format_should_match_double_ToString_if_the_fraction_is_terminating(Fraction valueToTest,
-        string stringFormat, IFormatProvider formatProvider) {
-        return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
-    }
-
-    public static IEnumerable<TestCaseData> FormatWithNonTerminatingFractionAndSpecificPrecisionCases =>
-        from stringFormat in GeneralFormats.Except(["G", "g", "G0", "g0"])
-        from valueToTest in NonTerminatingFractions
+        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions)
         from cultureToTest in FormatProviders
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     [Test]
-    [TestCaseSource(nameof(FormatWithNonTerminatingFractionAndSpecificPrecisionCases))]
-    public string The_general_format_should_match_double_ToString_when_the_precision_is_specified(Fraction valueToTest,
+    [TestCaseSource(nameof(FormatWithFiniteFractionCases))]
+    public string The_general_format_should_match_decimal_ToString_if_the_fraction_is_finite(Fraction valueToTest,
         string stringFormat, IFormatProvider formatProvider) {
         return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
     }
-
-#if NET
-    public static IEnumerable<TestCaseData> FormatWithNonTerminatingFractionAndDefaultPrecisionCases =>
-        from stringFormat in new[] { "G", "g", "G0", "g0" }
-        from valueToTest in NonTerminatingFractions
-        from cultureToTest in FormatProviders
-        select new TestCaseData(valueToTest, stringFormat, cultureToTest);
-
-    [Test]
-    [TestCaseSource(nameof(FormatWithNonTerminatingFractionAndDefaultPrecisionCases))]
-    public void The_general_format_should_match_double_ToString_when_the_precision_is_not_specified(
-        Fraction valueToTest, string stringFormat, IFormatProvider formatProvider) {
-        // Arrange
-        var doubleToString = valueToTest.ToDouble().ToString(stringFormat, formatProvider);
-
-        // Act
-        var fractionToString = DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
-
-        // Assert:
-        // while the fraction is correctly rounded to MidpointRounding.ToEven,
-        // there is apparently some optimization done to the double.ToString("g") that give weird results on the last decimal (cannot find any reference)
-        // (7.0/3).ToString(CultureInfo.InvariantCulture) returns "2,3333333333333335"
-        // DecimalFormatter.Format(null, new Fraction(7,3), CultureInfo.InvariantCulture) returns "2.333333333333333"
-        fractionToString[..^2].Should().Be(doubleToString[..(fractionToString.Length - 2)]);
-    }
-
-#else
-    public static IEnumerable<TestCaseData> FormatWithNonTerminatingFractionAndDefaultPrecisionCases =>
-        from stringFormat in new[] { "G", "g", "G0", "g0" }
-        from valueToTest in NonTerminatingFractions
-        from cultureToTest in FormatProviders
-        select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
-
-    [Test]
-    [TestCaseSource(nameof(FormatWithNonTerminatingFractionAndDefaultPrecisionCases))]
-    public string The_general_format_should_match_double_ToString_when_the_precision_is_not_specified(Fraction valueToTest, string stringFormat, IFormatProvider formatProvider) {
-        return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
-    }
-#endif
-
-    public static IEnumerable<TestCaseData> FormatWithSpecialFractionCases =>
-        from stringFormat in GeneralFormats
-        from valueToTest in SpecialFractions
-        from cultureToTest in FormatProviders
-        select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
-
-    [Test]
-    [TestCaseSource(nameof(FormatWithSpecialFractionCases))]
-    public string The_general_format_should_match_double_ToString_if_the_fraction_is_NaN_or_Infinity(
-        Fraction valueToTest, string stringFormat, IFormatProvider formatProvider) {
-        return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
-    }
-
+    
     public static IEnumerable<TestCaseData> GeneralFormatSupportHighPrecisionCases {
         get {
             var formatProvider = CultureInfo.InvariantCulture;
@@ -182,25 +118,28 @@ public string The_general_format_support_high_precision(Fraction valueToTest, st
 
 #if NET
     [Test]
-    public void The_default_precision_specifier_is_16_digits_after_the_decimal_point() {
+    public void The_default_precision_specifier_is_16_digits_after_the_decimal_point(
+        [Values(null, "G", "G0", "g", "g0")] string format) {
         // Arrange
         var fraction = new Fraction(0.123456789987654321m);
         // Act
-        var result = DecimalFormatter.Format("g", fraction, null);
+        var result = DecimalFormatter.Format(format, fraction, null);
         // Assert
-        result.Should().Be(DecimalFormatter.Format("g16", fraction, null));
+        result.Should().Be(DecimalFormatter.Format("G16", fraction, null));
     }
 #else
     [Test]
-    public void The_default_precision_specifier_is_15_digits_after_the_decimal_point() {
+    public void The_default_precision_specifier_is_15_digits_after_the_decimal_point(
+        [Values(null, "G", "G0", "g", "g0")] string format) {
         // Arrange
         var fraction = new Fraction(0.123456789987654321m);
         // Act
-        var result = DecimalFormatter.Format("g", fraction, null);
+        var result = DecimalFormatter.Format(format, fraction, null);
         // Assert
-        result.Should().Be(DecimalFormatter.Format("g15", fraction, null));
+        result.Should().Be(DecimalFormatter.Format("G15", fraction, null));
     }
 #endif
+
 }
 
 /// <summary>
@@ -216,14 +155,14 @@ public class When_formatting_a_fraction_using_the_fixed_point_format : DecimalNo
 
     public static IEnumerable<TestCaseData> FixedPointFormatsToTest =>
         from stringFormat in FixedPointFormats
-        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions).Concat(SpecialFractions)
+        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions)
         from cultureToTest in FormatProviders
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     [Test]
     [TestCaseSource(nameof(FixedPointFormatsToTest))]
-    public string The_fixed_point_format_should_match_double_ToString(Fraction valueToTest, string stringFormat,
+    public string The_fixed_point_format_should_match_decimal_ToString(Fraction valueToTest, string stringFormat,
         IFormatProvider formatProvider) {
         return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
     }
@@ -270,27 +209,45 @@ public class When_formatting_a_fraction_with_the_numeric_format : DecimalNotatio
         4 // n -
     ];
 
+    [Test]
+    public void NumberFormat_with_invalid_NumberNegativePattern_ThrowsArgumentOutOfRangeException()
+    {
+        var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+        var numberFormat = formatProvider.NumberFormat;
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.NumberNegativePattern = -1);
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.NumberNegativePattern = 5);
+    }
+
+    [Test]
+    public void NumberFormat_with_invalid_NumberDecimalDigits_ThrowsArgumentOutOfRangeException()
+    {
+        var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+        var numberFormat = formatProvider.NumberFormat;
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.NumberDecimalDigits = -1);
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.NumberDecimalDigits = 100);
+    }
+
     public static IEnumerable<TestCaseData> NumberFormatsToTest =>
         from stringFormat in NumberFormats
-        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions).Concat(SpecialFractions)
+        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions)
         from cultureToTest in FormatProviders
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     public static IEnumerable<TestCaseData> NumberNegativePatternsToTest =>
         from stringFormat in NumberFormats
-        from valueToTest in new Fraction[] { 0, -0.1m, -1, -1.23456789m }.Concat(SpecialFractions)
+        from valueToTest in new Fraction[] { 0, -0.1m, -1, -1.23456789m }
         from cultureToTest in NumberNegativePatterns.Select(pattern => {
             var culture = (CultureInfo)AmericanCulture.Clone();
             culture.NumberFormat.NumberNegativePattern = pattern;
             return culture;
         })
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     [Test]
     [TestCaseSource(nameof(NumberFormatsToTest))]
-    public string The_number_format_should_match_double_ToString(Fraction valueToTest, string stringFormat,
+    public string The_number_format_should_match_decimal_ToString(Fraction valueToTest, string stringFormat,
         IFormatProvider formatProvider) {
         return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
     }
@@ -338,18 +295,18 @@ public string The_standard_number_format_supports_high_precision(Fraction valueT
 [TestFixture]
 public class When_formatting_a_fraction_with_the_exponential_format : DecimalNotationFormatterSpecs {
     private static readonly string[] ScientificFormats =
-        ["E", "E0", "E1", "E2", "E3", "E4", "E5", "E6", "e", "e0", "e1", "e2", "e3", "e4", "e5", "e6"];
+        ["E", "E0", "E1", "E2", "E3", "E4", "E5", "E6", "e1", "e6"];
 
     public static IEnumerable<TestCaseData> ScientificFormatsToTest =>
         from stringFormat in ScientificFormats
-        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions).Concat(SpecialFractions)
+        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions)
         from cultureToTest in FormatProviders
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     [Test]
     [TestCaseSource(nameof(ScientificFormatsToTest))]
-    public string The_scientific_format_should_match_double_ToString(Fraction valueToTest, string stringFormat,
+    public string The_scientific_format_should_match_decimal_ToString(Fraction valueToTest, string stringFormat,
         IFormatProvider formatProvider) {
         return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
     }
@@ -434,12 +391,32 @@ public class When_formatting_a_fraction_with_the_currency_format : DecimalNotati
 #endif
     ];
 
+    [Test]
+    public void CurrencyPositivePattern_WithInvalidValue_ThrowsArgumentOutOfRangeException() {
+        var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+        var numberFormat = formatProvider.NumberFormat;
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyPositivePattern = -1);
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyPositivePattern = 4);
+    }
+
+    [Test]
+    public void CurrencyNegativePattern_WithInvalidValue_ThrowsArgumentOutOfRangeException() {
+        var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+        var numberFormat = formatProvider.NumberFormat;
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyNegativePattern = -1);
+#if NET
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyNegativePattern = 17);
+#else
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyNegativePattern = 16);
+#endif
+    }
+
     public static IEnumerable<TestCaseData> CurrencyFormatsToTest =>
         from stringFormat in CurrencyFormats
-        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions).Concat(SpecialFractions)
+        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions)
         from cultureToTest in FormatProviders
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     public static IEnumerable<TestCaseData> CurrencyPositivePatternsToTest =>
         from stringFormat in CurrencyFormats
@@ -450,7 +427,7 @@ from cultureToTest in CurrencyPositivePatterns.Select(pattern => {
             return culture;
         })
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     public static IEnumerable<TestCaseData> CurrencyNegativePatternsToTest =>
         from stringFormat in CurrencyFormats
@@ -461,11 +438,11 @@ from cultureToTest in CurrencyNegativePatterns.Select(pattern => {
             return culture;
         })
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     [Test]
     [TestCaseSource(nameof(CurrencyFormatsToTest))]
-    public string The_currency_format_should_match_double_ToString(Fraction valueToTest, string stringFormat,
+    public string The_currency_format_should_match_decimal_ToString(Fraction valueToTest, string stringFormat,
         IFormatProvider formatProvider) {
         return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
     }
@@ -518,14 +495,14 @@ public class When_formatting_a_fraction_with_the_percent_format : DecimalNotatio
 
     public static IEnumerable<TestCaseData> PercentFormatsToTest =>
         from stringFormat in PercentFormats
-        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions).Concat(SpecialFractions)
+        from valueToTest in TerminatingFractions.Concat(NonTerminatingFractions)
         from cultureToTest in FormatProviders
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     [Test]
     [TestCaseSource(nameof(PercentFormatsToTest))]
-    public string The_percentage_format_should_match_double_ToString(Fraction valueToTest, string stringFormat,
+    public string The_percentage_format_should_match_decimal_ToString(Fraction valueToTest, string stringFormat,
         IFormatProvider formatProvider) {
         return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
     }
@@ -537,6 +514,15 @@ public string The_percentage_format_should_match_double_ToString(Fraction valueT
         03 // % n
     ];
 
+    [Test]
+    public void PercentPositivePattern_with_invalid_value_ThrowsArgumentOutOfRangeException()
+    {
+        var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+        var numberFormat = formatProvider.NumberFormat;
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.PercentPositivePattern = -1);
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.PercentPositivePattern = 4);
+    }
+
     public static IEnumerable<TestCaseData> PercentPositivePatternsToTest =>
         from stringFormat in PercentFormats
         from valueToTest in new Fraction[] { 0, 0.1m, 1, 1.2345789m }
@@ -546,7 +532,7 @@ from cultureToTest in PercentPositivePatterns.Select(pattern => {
             return culture;
         })
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     [Test]
     [TestCaseSource(nameof(PercentPositivePatternsToTest))]
@@ -571,6 +557,15 @@ public string The_percent_format_should_respect_the_percent_positive_patterns(Fr
         11 // % n-
     ];
 
+    [Test]
+    public void PercentNegativePattern_with_invalid_value_ThrowsArgumentOutOfRangeException()
+    {
+        var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+        var numberFormat = formatProvider.NumberFormat;
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.PercentNegativePattern = -1);
+        Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.PercentNegativePattern = 12);
+    }
+
     public static IEnumerable<TestCaseData> PercentNegativePatternsToTest =>
         from stringFormat in PercentFormats
         from valueToTest in new Fraction[] { 0, -0.1m, -1, -1.23456789m }
@@ -580,7 +575,7 @@ from cultureToTest in PercentNegativePatterns.Select(pattern => {
             return culture;
         })
         select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
+            .Returns(valueToTest.ToDecimal().ToString(stringFormat, cultureToTest));
 
     [Test]
     [TestCaseSource(nameof(PercentNegativePatternsToTest))]
@@ -627,11 +622,11 @@ public static IEnumerable<TestCaseData> NormalValueCases {
             foreach (var format in new[] { "S2", "s2" }) {
                 // no exponent: no difference
                 // from -1000000 to -1
-                yield return new TestCaseData(new Fraction(-999999.99), format, culture).Returns("-999,999.99");
+                yield return new TestCaseData(new Fraction(-999999.99m), format, culture).Returns("-999,999.99");
                 yield return new TestCaseData(new Fraction(-111000), format, culture).Returns("-111,000");
                 yield return new TestCaseData(new Fraction(-11000), format, culture).Returns("-11,000");
                 yield return new TestCaseData(new Fraction(-1000), format, culture).Returns("-1,000");
-                yield return new TestCaseData(new Fraction(-999.99), format, culture).Returns("-999.99");
+                yield return new TestCaseData(new Fraction(-999.99m), format, culture).Returns("-999.99");
                 yield return new TestCaseData(new Fraction(-1.1m), format, culture).Returns("-1.1");
                 yield return new TestCaseData(Fraction.MinusOne, format, culture).Returns("-1");
 
@@ -647,19 +642,21 @@ public static IEnumerable<TestCaseData> NormalValueCases {
                 yield return new TestCaseData(new Fraction(0.1), format, culture).Returns("0.1");
 
                 // from 1 to 1000000
+                yield return new TestCaseData(Fraction.One, format, culture).Returns("1");
                 yield return new TestCaseData(new Fraction(1.1m), format, culture).Returns("1.1");
-                yield return new TestCaseData(new Fraction(999.99), format, culture).Returns("999.99");
+                yield return new TestCaseData(new Fraction(999.99m), format, culture).Returns("999.99");
                 yield return new TestCaseData(new Fraction(1000), format, culture).Returns("1,000");
                 yield return new TestCaseData(new Fraction(11000), format, culture).Returns("11,000");
                 yield return new TestCaseData(new Fraction(111000), format, culture).Returns("111,000");
-                yield return new TestCaseData(new Fraction(999999.99), format, culture).Returns("999,999.99");
+                yield return new TestCaseData(new Fraction(999999.99m), format, culture).Returns("999,999.99");
+                yield return new TestCaseData(Fraction.FromDecimal(999999.99m, false), format, culture).Returns("999,999.99");
             }
 
             // the provided culture is respected
             foreach (var format in new[] { "S2", "s2" }) {
                 // no exponent: no difference
-                yield return new TestCaseData(new Fraction(999999.99), format, RussianCulture).Returns("999 999,99");
-                yield return new TestCaseData(new Fraction(-999999.99), format, RussianCulture).Returns("-999 999,99");
+                yield return new TestCaseData(new Fraction(999999.99m), format, RussianCulture).Returns("999 999,99");
+                yield return new TestCaseData(new Fraction(-999999.99m), format, RussianCulture).Returns("-999 999,99");
             }
         }
     }
@@ -749,20 +746,26 @@ public string Large_negative_values_are_formatted_in_scientific_notation(Fractio
         return DecimalFormatter.Format(stringFormat, fraction, formatProvider);
     }
 
-    public static IEnumerable<TestCaseData> FormatWithSpecialFractionCases =>
-        from stringFormat in new[] { "S", "S1", "S2", "S3", "S4", "s", "s1", "s2", "s3", "s4" }
-        from valueToTest in SpecialFractions
-        from cultureToTest in FormatProviders
-        select new TestCaseData(valueToTest, stringFormat, cultureToTest)
-            .Returns(valueToTest.ToDouble().ToString(stringFormat, cultureToTest));
-
     [Test]
-    [TestCaseSource(nameof(FormatWithSpecialFractionCases))]
-    public string The_general_format_should_match_double_ToString_if_the_fraction_is_NaN_or_Infinity(
-        Fraction valueToTest, string stringFormat, IFormatProvider formatProvider) {
-        return DecimalFormatter.Format(stringFormat, valueToTest, formatProvider);
+    public void Very_large_positive_values_are_formatted_in_scientific_notation()
+    {
+        var value = new Fraction(1234 * BigInteger.Pow(10, 1000));
+
+        var actualValue = DecimalFormatter.Format("s", value, CultureInfo.InvariantCulture);
+                
+        actualValue.Should().Be("1.23e+1003");
     }
 
+    [Test]
+    public void Very_small_positive_values_are_formatted_in_scientific_notation()
+    {
+        var value = new Fraction(1234, BigInteger.Pow(10, 1004), false);
+        
+        var actualValue = DecimalFormatter.Format("s", value, CultureInfo.InvariantCulture);
+
+        actualValue.Should().Be("1.23e-1001");
+    }
+    
     public static IEnumerable<TestCaseData> RoundingErrorsWithSignificantDigitsAfterRadixFormattingCases {
         get {
             var culture = CultureInfo.InvariantCulture;
@@ -878,6 +881,12 @@ public static IEnumerable<TestCaseData> TestCases {
             yield return new TestCaseData("#0.0#;(#0.0#)", Fraction.Zero, culture).Returns("0.0");
             yield return new TestCaseData("Test: 0.00", new Fraction(12.345), culture).Returns("Test: 12.35");
             yield return new TestCaseData("Pest: 0.00", new Fraction(12.345), culture).Returns("Pest: 12.35");
+            yield return new TestCaseData("Fest: 0.00", new Fraction(12.345), culture).Returns("Fest: 12.35");
+            yield return new TestCaseData("Number: 0.00", oneHalf, culture).Returns("Number: 0.50");
+            yield return new TestCaseData("Some: 0.00", oneHalf, culture).Returns("Some: 0.50");
+            yield return new TestCaseData("Cans: 0.00", oneHalf, culture).Returns("Cans: 0.50");
+            yield return new TestCaseData("Eons: 0.00", oneHalf, culture).Returns("Eons: 0.50");
+            yield return new TestCaseData("Guess: 0.00", oneHalf, culture).Returns("Guess: 0.50");
             yield return new TestCaseData("Guess: 0.00", Fraction.PositiveInfinity, culture).Returns(culture.NumberFormat.PositiveInfinitySymbol);
             yield return new TestCaseData("Guess: 0.00", Fraction.NegativeInfinity, culture).Returns(culture.NumberFormat.NegativeInfinitySymbol);
             yield return new TestCaseData("Guess: 0.00", Fraction.NaN, culture).Returns(culture.NumberFormat.NaNSymbol);
@@ -921,6 +930,22 @@ public void The_result_should_be_formatted_using_the_current_culture() {
     }
 }
 
+[TestFixture]
+public class When_formatting_NaN_or_Infinity : DecimalNotationFormatterSpecs {
+    public static IEnumerable<TestCaseData> FormatWithSpecialFractionCases =>
+        from valueToTest in SpecialFractions
+        from cultureToTest in FormatProviders
+        select new TestCaseData(valueToTest, cultureToTest)
+            .Returns(valueToTest.ToDouble().ToString(cultureToTest));
+
+    [Test]
+    [TestCaseSource(nameof(FormatWithSpecialFractionCases))]
+    public string The_result_should_be_the_corresponding_symbol(
+        Fraction valueToTest, IFormatProvider formatProvider) {
+        return DecimalFormatter.Format(null, valueToTest, formatProvider);
+    }
+}
+
 [TestFixture]
 public class When_attempting_to_format_null : DecimalNotationFormatterSpecs {
     [Test]


Reviews:
user: login: lipchev
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-07T12:39:20Z
user: login: lipchev
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-07T12:41:12Z
user: login: danm-de
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-12T16:34:39Z
user: login: lipchev
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-12T16:41:08Z
user: login: danm-de
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-12T17:16:27Z
user: login: lipchev
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-12T17:29:10Z

Review comments:
diff_hunk: @@ -46,6 +46,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Results", "Results", "{FCF0
 		benchmarks\results\Fractions.Benchmarks.NonNormalizedComparisonBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.NonNormalizedComparisonBenchmarks-report-github.md
 		benchmarks\results\Fractions.Benchmarks.NonNormalizedMathBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.NonNormalizedMathBenchmarks-report-github.md
 		benchmarks\results\Fractions.Benchmarks.PowerMathBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.PowerMathBenchmarks-report-github.md
+		benchmarks\results\Fractions.Benchmarks.RoundingBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.RoundingBenchmarks-report-github.md
+		benchmarks\results\Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md
path: Fractions.sln
user: login: lipchev
body: I've added two versions of these, as running them together would have been really slow with the output being very long (I didn't even bother with using multiple rounding modes). I only have the `before-and-after` for the `reducing` variant:

![image](https://github.com/user-attachments/assets/42704310-3cc1-4600-abed-7f53d489c771)

![image](https://github.com/user-attachments/assets/d92ff172-1f1f-4717-9b6e-dbc7a26588ee)

And for reference, here are the absolute values for the new version:

![image](https://github.com/user-attachments/assets/6bd6e31d-afe2-4279-84a5-6aaced144b65)

And here are the absolute values for the `non-reducing` overload:

![image](https://github.com/user-attachments/assets/4e6b4b92-6780-473a-9dfb-8427776c42a2)

In the next episode, we'll look at what happens when we double the precision 😄 
created_at: 2025-03-07T12:39:20Z
author_association: COLLABORATOR
diff_hunk: @@ -46,6 +46,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Results", "Results", "{FCF0
 		benchmarks\results\Fractions.Benchmarks.NonNormalizedComparisonBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.NonNormalizedComparisonBenchmarks-report-github.md
 		benchmarks\results\Fractions.Benchmarks.NonNormalizedMathBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.NonNormalizedMathBenchmarks-report-github.md
 		benchmarks\results\Fractions.Benchmarks.PowerMathBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.PowerMathBenchmarks-report-github.md
+		benchmarks\results\Fractions.Benchmarks.RoundingBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.RoundingBenchmarks-report-github.md
+		benchmarks\results\Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md = benchmarks\results\Fractions.Benchmarks.RoundingWithoutReductionBenchmarks-report-github.md
path: Fractions.sln
user: login: lipchev
body: By the way, I think it would probably make sense to change the default rounding mode (for the `Fraction.Round(decimals)`) to `AwayFromZero`.
created_at: 2025-03-07T12:41:12Z
author_association: COLLABORATOR
diff_hunk: @@ -33,20 +33,14 @@ public class DecimalNotationFormatter : ICustomFormatter {
     ///     <list type="bullet">
     ///         <item>
     ///             On .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least
-    ///             significant digit (that is, using <see cref="MidpointRounding.AwayFromZero" />).
+    ///             significant digit (that is, using <see cref="MidpointRounding.AwayFromZero" />) for both the double and decimal rounding.
     ///         </item>
     ///         <item>
-    ///             On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is,
-    ///             using  <see cref="MidpointRounding.ToEven" />).
+    ///             On .NET Core 2.1 and later, the EEE‑754 floating‑point (e.g. double) numbers appear to be formatted using some variant of the Ry¯u: Fast Float-to-String Conversion.
     ///         </item>
-    ///     </list>
+    ///     </list>   
     /// </summary>
-    private const MidpointRounding DefaultMidpointRoundingMode =
-#if NETCOREAPP2_1_OR_GREATER
-        MidpointRounding.ToEven;
-#else
-        MidpointRounding.AwayFromZero;
-#endif
+    private const MidpointRounding DefaultMidpointRoundingMode =  MidpointRounding.AwayFromZero;
path: src/Fractions/Formatter/DecimalNotationFormatter.cs
user: login: danm-de
body: I think (or hope) that only a _fraction_ of users will notice a difference. I would risk releasing these changes here without a major version change. 


created_at: 2025-03-12T14:08:45Z
author_association: COLLABORATOR
diff_hunk: @@ -478,9 +439,8 @@ static string withPositiveSign(StringBuilder sb, string percentSymbol, int patte
                     sb.Append(percentSymbol).ToString(),
                 2 => // %n
                     sb.Insert(0, percentSymbol).ToString(),
-                3 => // % n
+                _ => // % n
path: src/Fractions/Formatter/DecimalNotationFormatter.cs
user: login: danm-de
body: Even if it is not possible to fill the property `NumberFormatInfo.PercentPositivePattern` with an invalid value - I would still keep the old check, because it exactly validates the specification.

![image](https://github.com/user-attachments/assets/9db17677-fc64-49b9-8d84-94569b9afdb5)

```suggestion
                3 => // % n
                    sb.Insert(0, percentSymbol + ' ').ToString(),
                _ => throw new ArgumentOutOfRangeException(nameof(pattern))
```
created_at: 2025-03-12T14:21:14Z
author_association: COLLABORATOR
diff_hunk: @@ -508,9 +468,8 @@ static string withNegativeSign(StringBuilder sb, string percentSymbol, string ne
                     sb.Insert(0, percentSymbol + ' ').Append(negativeSignSymbol).ToString(),
                 10 => // % -n
                     sb.Insert(0, percentSymbol + ' ').Insert(2, negativeSignSymbol).ToString(),
-                11 => // n- %
+                _ => // n- %
path: src/Fractions/Formatter/DecimalNotationFormatter.cs
user: login: danm-de
body: Again - even if it is not possible to fill the property `NumberFormatInfo.PercentNegativePattern` with an invalid value - I would still keep the old check, because it exactly validates the specification.
```suggestion
                11 => // n- %
                    sb.Append(negativeSignSymbol).Append(' ').Append(percentSymbol).ToString(),
                _ => throw new ArgumentOutOfRangeException(nameof(pattern))
```

![image](https://github.com/user-attachments/assets/0be9d378-9184-4cfa-8725-93c23d06fbca)
created_at: 2025-03-12T14:25:43Z
author_association: COLLABORATOR
diff_hunk: @@ -478,9 +439,8 @@ static string withPositiveSign(StringBuilder sb, string percentSymbol, int patte
                     sb.Append(percentSymbol).ToString(),
                 2 => // %n
                     sb.Insert(0, percentSymbol).ToString(),
-                3 => // % n
+                _ => // % n
path: src/Fractions/Formatter/DecimalNotationFormatter.cs
user: login: lipchev
body: The problem is that it makes it impossible to cover by any tests, and the class being at 98% coverage because of it, was really bugging me.
I intentionally added tests for the CultureInfo so that in case anything changes in the framework, we get notified by a test failure, instead of a runtime exception..
created_at: 2025-03-12T16:41:08Z
author_association: COLLABORATOR
diff_hunk: @@ -478,9 +439,8 @@ static string withPositiveSign(StringBuilder sb, string percentSymbol, int patte
                     sb.Append(percentSymbol).ToString(),
                 2 => // %n
                     sb.Insert(0, percentSymbol).ToString(),
-                3 => // % n
+                _ => // % n
path: src/Fractions/Formatter/DecimalNotationFormatter.cs
user: login: danm-de
body: Unfortunately, 100% code coverage through unit tests doesn't mean 100% bug-free. If this bothers you so much, we can add the `[ExcludeFromCodeCoverage]` attribute to the affected methods.


created_at: 2025-03-12T17:16:27Z
author_association: COLLABORATOR
diff_hunk: @@ -478,9 +439,8 @@ static string withPositiveSign(StringBuilder sb, string percentSymbol, int patte
                     sb.Append(percentSymbol).ToString(),
                 2 => // %n
                     sb.Insert(0, percentSymbol).ToString(),
-                3 => // % n
+                _ => // % n
path: src/Fractions/Formatter/DecimalNotationFormatter.cs
user: login: lipchev
body: Nah, unless you know a way to mark the specific branch as "unreachable" better keep it at 98%- I spend too much time covering those other 50 branches 😓 
created_at: 2025-03-12T17:29:10Z
author_association: COLLABORATOR

PR comments:
user: login: lipchev
created_at: 2025-03-02T20:14:13Z
body: I actually started writing the test coverage, which lead me to some `unreachable` branches, which lead me to optimizing the `GetExponentPower`, but before I was done- I encountered the rounding issue, so I didn't quite finish the optimization- it's clearly possible to reduce one of the operations in the `numerator < denominator` branch, but I'll deal with it later..

I'm still waiting for the benchmarks to complete- but I saw the highlights earlier, all values, except the ones with the general format (the branch that was missing the rounding), should be slightly faster.. 
author_association: COLLABORATOR
user: login: lipchev
created_at: 2025-03-02T20:20:17Z
body: Ah damn it I forgot the failing value- 2.001234m, I had it in the test of my other project...
author_association: COLLABORATOR
user: login: lipchev
created_at: 2025-03-02T20:33:32Z
body: The benchmarks are out here are the absolute differences in nanoseconds (guess which cases were missing the rounding):
![image](https://github.com/user-attachments/assets/ba1292b5-2031-48d8-863e-4c47eb90be66)

Yeah, the `Round(value, 16)` does not come cheap: we get a hit on both the allocation of the `BigInteger.Pow(..)` and then again by the multiplication.. I really wish there was a way to avoid that round..

Here are the % differences:
![image](https://github.com/user-attachments/assets/873423ef-6ea2-4bdc-b930-ddb8ea513435)

And here is the allocation difference (damn that `Round`..)

![image](https://github.com/user-attachments/assets/6892cb6c-d340-4423-a1e1-2f4c2a5326cb)

author_association: COLLABORATOR
user: login: lipchev
created_at: 2025-03-04T09:37:48Z
body: For reference, here are also the absolute times with "G", "G2" and "F2" (the rest are fairly similar):

![image](https://github.com/user-attachments/assets/c7beaaa5-ed18-413b-9ba9-5d8a67b2e320)

Note: I haven't updated the names since the release of `v8`, but these correspond to the `latest` version.

One can imagine that using "F16" would perform similarly to "G".. I think it might be worth short-circuiting the whole thing, when the terms are smaller than the double precision, by converting to `double` (we can return the bit lengths from the `GetExponent` function).
author_association: COLLABORATOR
user: login: lipchev
created_at: 2025-03-05T16:16:21Z
body: Ok, don't mind the previous results - I've made some major improvements in https://github.com/danm-de/Fractions/pull/104/commits/ac0c0606b5149e6e78f76dc8d5397dc161e22f8e . I need to run now, but I'll post the results when I get back..

PS: Note that I've only updated the BigInteger.Pow(Ten, exponent) in the `Round` and the `DecimalNotationFormatter` - but there are even more cases to be optimized like `FromDoubleRounded` or `FromDecimal`.. I also ran a benchmark- the array initialization costs us less than a single call to BigInteger.Pow(Ten, 16) 😄 
author_association: COLLABORATOR
user: login: danm-de
created_at: 2025-03-05T16:27:30Z
body: Thank you for your efforts. However, I won't have some time for code reviews until Sunday at the earliest.
author_association: COLLABORATOR
user: login: lipchev
created_at: 2025-03-06T05:56:06Z
body: Here are the results for the absolute differences between `this` and `master` (with the missing `Round`):
![image](https://github.com/user-attachments/assets/b864be2c-2abf-49d6-93cd-b258459a5f7c)

![image](https://github.com/user-attachments/assets/dd81bfb8-9252-4630-a9db-a899439dbdc5)

![image](https://github.com/user-attachments/assets/af2948b1-3a71-436a-bb0e-8aa408177432)


author_association: COLLABORATOR
user: login: danm-de
created_at: 2025-03-09T20:26:21Z
body: > Thank you for your efforts. However, I won't have some time for code reviews until Sunday at the earliest.

Ha, I must have underestimated the time needed for assembly. At the moment I'm only online via tablet :-(

![image](https://github.com/user-attachments/assets/c25fab6f-5333-4000-adf4-57c74e36152d)

author_association: COLLABORATOR