Fix three accuracy issues in System.Double article

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/csharp/comparison1.cs

@@ -7,7 +7,7 @@ public static void Main()
    {
       double value1 = .333333333333333;
       double value2 = 1.0/3;
-      Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
+      Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}");
    }
 }
 // The example displays the following output:

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/csharp/comparison3.cs

@@ -1,18 +1,19 @@
-// <Snippet11>
 using System;
 
 public class Example2
 {
     public static void Main()
     {
+        // <Snippet11>
         double value1 = .333333333333333;
         double value2 = 1.0 / 3;
         int precision = 7;
         value1 = Math.Round(value1, precision);
         value2 = Math.Round(value2, precision);
-        Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
+        Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}");
+
+        // The example displays the following output:
+        //        0.3333333 = 0.3333333: True
+        // </Snippet11>
     }
 }
-// The example displays the following output:
-//        0.3333333 = 0.3333333: True
-// </Snippet11>

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/csharp/comparison4.cs

@@ -10,8 +10,8 @@ public static void Main()
         for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1;
 
-        Console.WriteLine($"{one1:R} = {one2:R}: {one1.Equals(one2)}");
-        Console.WriteLine($"{one1:R} is approximately equal to {one2:R}: {IsApproximatelyEqual(one1, one2, .000000001)}");
+        Console.WriteLine($"{one1} = {one2}: {one1.Equals(one2)}");
+        Console.WriteLine($"{one1} is approximately equal to {one2}: {IsApproximatelyEqual(one1, one2, .000000001)}");
     }
 
     static bool IsApproximatelyEqual(double value1, double value2, double epsilon)
@@ -34,6 +34,7 @@ static bool IsApproximatelyEqual(double value1, double value2, double epsilon)
         return Math.Abs((value1 - value2) / divisor) <= epsilon;
     }
 }
+
 // The example displays the following output:
 //       1 = 0.99999999999999989: False
 //       1 is approximately equal to 0.99999999999999989: True

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/fsharp/Project.fsproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="comparison1.fs" />
+    <Compile Include="comparison3.fs" />
+    <Compile Include="comparison4.fs" />
+    <Compile Include="convert1.fs" />
+    <Compile Include="convert2.fs" />
+    <Compile Include="exceptional1.fs" />
+    <Compile Include="exceptional2.fs" />
+    <Compile Include="precision1.fs" />
+    <Compile Include="precisionlist1.fs" />
+    <Compile Include="precisionlist3.fs" />
+    <Compile Include="precisionlist4.fs" />
+    <Compile Include="representation1.fs" />
+    <Compile Include="representation2.fs" />
+    <Compile Include="source.fs" />
+  </ItemGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/fsharp/comparison1.fs

@@ -5,7 +5,8 @@ open System
 
 let value1 = 0.333333333333333
 let value2 = 1. / 3.
-printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
+printfn $"{value1} = {value2}: {value1.Equals value2}"
+
 // The example displays the following output:
 //        0.333333333333333 = 0.33333333333333331: False
-// </Snippet9>
+// </Snippet9>

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/fsharp/comparison3.fs

@@ -8,7 +8,8 @@ let v2 = 1. / 3.
 let precision = 7
 let value1 = Math.Round(v1, precision)
 let value2 = Math.Round(v2, precision)
-printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
+printfn $"{value1} = {value2}: {value1.Equals value2}"
+
 // The example displays the following output:
 //        0.3333333 = 0.3333333: True
-// </Snippet11>
+// </Snippet11>

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/fsharp/comparison4.fs

@@ -5,21 +5,21 @@ open System
 
 let isApproximatelyEqual (value1: double) (value2: double) (epsilon: double) =
     // If they are equal anyway, just return True.
-    if value1.Equals value2 then 
+    if value1.Equals value2 then
         true
     else
         // Handle NaN, Infinity.
-        if Double.IsInfinity value1 || Double.IsNaN value1 then 
+        if Double.IsInfinity value1 || Double.IsNaN value1 then
             value1.Equals value2
         elif Double.IsInfinity value2 || Double.IsNaN value2 then
             value1.Equals value2
         else
             // Handle zero to avoid division by zero
             let divisor = max value1 value2
-            let divisor = 
+            let divisor =
                 if divisor.Equals 0 then
                     min value1 value2
-                else 
+                else
                     divisor
             abs ((value1 - value2) / divisor) <= epsilon
 
@@ -28,10 +28,10 @@ let mutable one2 = 0.
 for _ = 1 to 10 do
     one2 <- one2 + 0.1
 
-printfn $"{one1:R} = {one2:R}: {one1.Equals one2}"
-printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000000001}"
+printfn $"{one1} = {one2}: {one1.Equals one2}"
+printfn $"{one1} is approximately equal to {one2}: {isApproximatelyEqual one1 one2 0.000000001}"
 
 // The example displays the following output:
 //       1 = 0.99999999999999989: False
 //       1 is approximately equal to 0.99999999999999989: True
-// </Snippet12>
+// </Snippet12>

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/vb/comparison1.vb

@@ -6,9 +6,10 @@ Module Example1
     Public Sub Main()
         Dim value1 As Double = 0.333333333333333
         Dim value2 As Double = 1 / 3
-        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
+        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
     End Sub
 End Module
+
 ' The example displays the following output:
 '       0.333333333333333 = 0.33333333333333331: False
 ' </Snippet9>

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/vb/comparison3.vb

@@ -9,9 +9,10 @@ Module Example3
         Dim precision As Integer = 7
         value1 = Math.Round(value1, precision)
         value2 = Math.Round(value2, precision)
-        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
+        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
     End Sub
 End Module
+
 ' The example displays the following output:
 '       0.3333333 = 0.3333333: True
 ' </Snippet11>

docs/fundamentals/runtime-libraries/snippets/System/Double/Overview/vb/comparison4.vb

@@ -9,8 +9,8 @@ Module Example4
         For ctr As Integer = 1 To 10
             one2 += 0.1
         Next
-        Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
-        Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}",
+        Console.WriteLine("{0} = {1}: {2}", one1, one2, one1.Equals(one2))
+        Console.WriteLine("{0} is approximately equal to {1}: {2}",
                         one1, one2,
                         IsApproximatelyEqual(one1, one2, 0.000000001))
     End Sub
@@ -36,6 +36,7 @@ Module Example4
         Return Math.Abs((value1 - value2) / divisor) <= epsilon
     End Function
 End Module
+
 ' The example displays the following output:
 '       1 = 0.99999999999999989: False
 '       1 is approximately equal to 0.99999999999999989: True