Normalize YAML floating key equality

Canonicalize Decimal, Double, and Single values by decimal significand and exponent, making large equivalent values and signed zero obey YAML representation equality.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: MariusStorhaug

src/functions/private/Get-YamlNormalizedFloat.ps1

@@ -0,0 +1,95 @@
+function Get-YamlNormalizedFloat {
+    <#
+        .SYNOPSIS
+        Normalizes a finite CLR floating-point value to a decimal significand and exponent.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param (
+        [Parameter(Mandatory)]
+        [object] $Value
+    )
+
+    $culture = [System.Globalization.CultureInfo]::InvariantCulture
+    if ($Value -is [decimal]) {
+        if ($Value -eq 0) {
+            return '0e0'
+        }
+        $text = $Value.ToString('G29', $culture)
+    } elseif ($Value -is [single]) {
+        $number = [single] $Value
+        if ([single]::IsNaN($number)) {
+            return 'nan'
+        }
+        if ([single]::IsPositiveInfinity($number)) {
+            return '+inf'
+        }
+        if ([single]::IsNegativeInfinity($number)) {
+            return '-inf'
+        }
+        if ($number -eq 0) {
+            return '0e0'
+        }
+        $text = $number.ToString('R', $culture)
+    } elseif ($Value -is [double]) {
+        $number = [double] $Value
+        if ([double]::IsNaN($number)) {
+            return 'nan'
+        }
+        if ([double]::IsPositiveInfinity($number)) {
+            return '+inf'
+        }
+        if ([double]::IsNegativeInfinity($number)) {
+            return '-inf'
+        }
+        if ($number -eq 0) {
+            return '0e0'
+        }
+        $text = $number.ToString('R', $culture)
+    } else {
+        throw [System.ArgumentException]::new(
+            "Type '$($Value.GetType().FullName)' is not a supported floating-point type.",
+            'Value'
+        )
+    }
+
+    $match = [regex]::Match(
+        $text,
+        '^(?<sign>[-+]?)(?<integer>[0-9]+)(?:\.(?<fraction>[0-9]*))?(?:[eE](?<exponent>[-+]?[0-9]+))?$',
+        [System.Text.RegularExpressions.RegexOptions]::CultureInvariant
+    )
+    if (-not $match.Success) {
+        throw [System.InvalidOperationException]::new(
+            "The invariant floating-point text '$text' could not be normalized."
+        )
+    }
+
+    $fraction = $match.Groups['fraction'].Value
+    $digits = ($match.Groups['integer'].Value + $fraction).TrimStart('0')
+    if ($digits.Length -eq 0) {
+        return '0e0'
+    }
+
+    $exponent = 0 - $fraction.Length
+    if ($match.Groups['exponent'].Success) {
+        $exponent += [int]::Parse(
+            $match.Groups['exponent'].Value,
+            [System.Globalization.NumberStyles]::AllowLeadingSign,
+            $culture
+        )
+    }
+    while ($digits.Length -gt 1 -and $digits[$digits.Length - 1].Equals([char] '0')) {
+        $digits = $digits.Substring(0, $digits.Length - 1)
+        $exponent++
+    }
+
+    $sign = if ($match.Groups['sign'].Value.Equals(
+            '-',
+            [System.StringComparison]::Ordinal
+        )) {
+        '-'
+    } else {
+        ''
+    }
+    return '{0}{1}e{2}' -f $sign, $digits, $exponent
+}

src/functions/private/Get-YamlScalarFingerprint.ps1

@@ -33,32 +33,8 @@ function Get-YamlScalarFingerprint {
             [datetime]::SpecifyKind($Value, [System.DateTimeKind]::Utc)
         }
         $canonicalValue = 'timestamp:{0}' -f $utcValue.Ticks
-    } elseif ($Value -is [decimal]) {
-        if ($Value -eq 0 -and
-            ([decimal]::GetBits($Value)[3] -band [int]::MinValue) -ne 0) {
-            $canonicalValue = 'float:-0'
-        } else {
-            $canonicalValue = 'float:{0}' -f $Value.ToString(
-                'G29',
-                [cultureinfo]::InvariantCulture
-            )
-        }
-    } elseif ($Value -is [double]) {
-        if ([double]::IsNaN($Value)) {
-            $canonicalValue = 'float:nan'
-        } elseif ([double]::IsPositiveInfinity($Value)) {
-            $canonicalValue = 'float:+inf'
-        } elseif ([double]::IsNegativeInfinity($Value)) {
-            $canonicalValue = 'float:-inf'
-        } elseif ($Value -eq 0) {
-            $negative = [System.BitConverter]::DoubleToInt64Bits([double] $Value) -lt 0
-            $canonicalValue = if ($negative) { 'float:-0' } else { 'float:0' }
-        } else {
-            $canonicalValue = 'float:{0}' -f $Value.ToString(
-                'R',
-                [cultureinfo]::InvariantCulture
-            )
-        }
+    } elseif ($Value -is [decimal] -or $Value -is [double] -or $Value -is [single]) {
+        $canonicalValue = 'float:{0}' -f (Get-YamlNormalizedFloat -Value $Value)
     } else {
         $canonicalValue = 'int:{0}' -f $Value.ToString([cultureinfo]::InvariantCulture)
     }

tests/ConvertFrom-Yaml.Tests.ps1

@@ -376,6 +376,28 @@ date: !!timestamp 2001-12-14
                 Should -Throw
         }
 
+        It 'normalizes cross-type finite floats for key equality' {
+            $yaml = @'
+100000000000000000000.0: decimal
+1e20: double
+'@
+
+            ($yaml | Test-Yaml) | Should -BeFalse
+            { $yaml | ConvertFrom-Yaml -AsHashtable } |
+                Should -Throw -ExpectedMessage '*duplicate mapping key*'
+        }
+
+        It 'treats signed zero keys as the same YAML representation value' {
+            $yaml = @'
+0.0: positive
+-0.0: negative
+'@
+
+            ($yaml | Test-Yaml) | Should -BeFalse
+            { $yaml | ConvertFrom-Yaml -AsHashtable } |
+                Should -Throw -ExpectedMessage '*duplicate mapping key*'
+        }
+
         It 'rejects equivalent offset timestamps as duplicate keys' {
             $yaml = @'
 ? !!timestamp 2001-12-15T02:59:43.1Z

tests/ConvertTo-Yaml.Tests.ps1

@@ -181,6 +181,33 @@ Describe 'ConvertTo-Yaml' {
                 Should -Throw -ExpectedMessage '*normalize to the same YAML value*'
         }
 
+        It 'normalizes finite float key fingerprints across CLR types' {
+            $equal = [System.Collections.Specialized.OrderedDictionary]::new()
+            $equal.Add(
+                [decimal]::Parse(
+                    '100000000000000000000.0',
+                    [cultureinfo]::InvariantCulture
+                ),
+                'decimal'
+            )
+            $equal.Add([double] 1e20, 'double')
+
+            { $equal | ConvertTo-Yaml } |
+                Should -Throw -ExpectedMessage '*normalize to the same YAML value*'
+
+            $different = [System.Collections.Specialized.OrderedDictionary]::new()
+            $different.Add(
+                [decimal]::Parse(
+                    '100000000000000000001',
+                    [cultureinfo]::InvariantCulture
+                ),
+                'decimal'
+            )
+            $different.Add([double] 1e20, 'double')
+
+            { $different | ConvertTo-Yaml } | Should -Not -Throw
+        }
+
         It 'compares unordered complex keys with ordinal case-sensitive sorting' {
             $firstKey = [System.Collections.Specialized.OrderedDictionary]::new()
             $firstKey.Add('a', 1)