Use native round (#240)

Author: ntkme

lib/sass/value/color.rb

@@ -318,32 +318,32 @@ def ==(other)
 
         if legacy?
           return false unless other.legacy?
-          return false unless FuzzyMath.equals_nilable(other.alpha_or_nil, alpha_or_nil)
+          return false unless FuzzyMath.equals(other.alpha_or_nil, alpha_or_nil)
 
           if _space == other._space
-            FuzzyMath.equals_nilable(other.channel0_or_nil, channel0_or_nil) &&
-              FuzzyMath.equals_nilable(other.channel1_or_nil, channel1_or_nil) &&
-              FuzzyMath.equals_nilable(other.channel2_or_nil, channel2_or_nil)
+            FuzzyMath.equals(other.channel0_or_nil, channel0_or_nil) &&
+              FuzzyMath.equals(other.channel1_or_nil, channel1_or_nil) &&
+              FuzzyMath.equals(other.channel2_or_nil, channel2_or_nil)
           else
             _to_space(Space::RGB) == other._to_space(Space::RGB)
           end
         else
           other._space == _space &&
-            FuzzyMath.equals_nilable(other.channel0_or_nil, channel0_or_nil) &&
-            FuzzyMath.equals_nilable(other.channel1_or_nil, channel1_or_nil) &&
-            FuzzyMath.equals_nilable(other.channel2_or_nil, channel2_or_nil) &&
-            FuzzyMath.equals_nilable(other.alpha_or_nil, alpha_or_nil)
+            FuzzyMath.equals(other.channel0_or_nil, channel0_or_nil) &&
+            FuzzyMath.equals(other.channel1_or_nil, channel1_or_nil) &&
+            FuzzyMath.equals(other.channel2_or_nil, channel2_or_nil) &&
+            FuzzyMath.equals(other.alpha_or_nil, alpha_or_nil)
         end
       end
 
       # @return [Integer]
       def hash
         @hash ||= [
-          _space,
-          channel0_or_nil&.finite? ? (channel0_or_nil * FuzzyMath::INVERSE_EPSILON).round : channel0_or_nil, # rubocop:disable Security/CompoundHash
-          channel1_or_nil&.finite? ? (channel1_or_nil * FuzzyMath::INVERSE_EPSILON).round : channel1_or_nil, # rubocop:disable Security/CompoundHash
-          channel2_or_nil&.finite? ? (channel2_or_nil * FuzzyMath::INVERSE_EPSILON).round : channel2_or_nil, # rubocop:disable Security/CompoundHash
-          alpha_or_nil&.finite? ? (alpha_or_nil * FuzzyMath::INVERSE_EPSILON).round : alpha_or_nil # rubocop:disable Security/CompoundHash
+          _space.name,
+          FuzzyMath._round(channel0_or_nil),
+          FuzzyMath._round(channel1_or_nil),
+          FuzzyMath._round(channel2_or_nil),
+          FuzzyMath._round(alpha_or_nil)
         ].hash
       end
 

lib/sass/value/color/gamut_map_method/clip.rb

@@ -29,7 +29,7 @@ def _clamp_channel(value, channel)
 
             case channel
             when LinearChannel
-              FuzzyMath.clamp_like_css(value, channel.min, channel.max)
+              FuzzyMath._clamp_like_css(value, channel.min, channel.max)
             else
               value
             end

lib/sass/value/color/space/a98_rgb.rb

@@ -17,11 +17,11 @@ def initialize
           end
 
           def to_linear(channel)
-            FuzzyMath.sign(channel) * (channel.abs**(563 / 256.0))
+            (channel <=> 0) * (channel.abs**(563 / 256.0))
           end
 
           def from_linear(channel)
-            FuzzyMath.sign(channel) * (channel.abs**(256 / 563.0))
+            (channel <=> 0) * (channel.abs**(256 / 563.0))
           end
 
           private

lib/sass/value/color/space/prophoto_rgb.rb

@@ -18,12 +18,12 @@ def initialize
 
           def to_linear(channel)
             abs = channel.abs
-            abs <= 16 / 512.0 ? channel / 16.0 : FuzzyMath.sign(channel) * (abs**1.8)
+            abs <= 16 / 512.0 ? channel / 16.0 : (channel <=> 0) * (abs**1.8)
           end
 
           def from_linear(channel)
             abs = channel.abs
-            abs >= 1 / 512.0 ? FuzzyMath.sign(channel) * (abs**(1 / 1.8)) : 16 * channel
+            abs >= 1 / 512.0 ? (channel <=> 0) * (abs**(1 / 1.8)) : 16 * channel
           end
 
           private

lib/sass/value/color/space/rec2020.rb

@@ -28,12 +28,12 @@ def initialize
 
           def to_linear(channel)
             abs = channel.abs
-            abs < BETA * 4.5 ? channel / 4.5 : FuzzyMath.sign(channel) * (((abs + ALPHA - 1) / ALPHA)**(1 / 0.45))
+            abs < BETA * 4.5 ? channel / 4.5 : (channel <=> 0) * (((abs + ALPHA - 1) / ALPHA)**(1 / 0.45))
           end
 
           def from_linear(channel)
             abs = channel.abs
-            abs > BETA ? FuzzyMath.sign(channel) * ((ALPHA * (abs**0.45)) - (ALPHA - 1)) : 4.5 * channel
+            abs > BETA ? (channel <=> 0) * ((ALPHA * (abs**0.45)) - (ALPHA - 1)) : 4.5 * channel
           end
 
           private

lib/sass/value/color/space/utils.rb

@@ -37,7 +37,7 @@ module Utils
           # @return [Numeric]
           def srgb_and_display_p3_to_linear(channel)
             abs = channel.abs
-            abs < 0.04045 ? channel / 12.92 : FuzzyMath.sign(channel) * (((abs + 0.055) / 1.055)**2.4)
+            abs < 0.04045 ? channel / 12.92 : (channel <=> 0) * (((abs + 0.055) / 1.055)**2.4)
           end
 
           # The algorithm for converting a single `srgb` or `display-p3` channel to
@@ -46,7 +46,7 @@ def srgb_and_display_p3_to_linear(channel)
           # @return [Numeric]
           def srgb_and_display_p3_from_linear(channel)
             abs = channel.abs
-            abs <= 0.0031308 ? channel * 12.92 : FuzzyMath.sign(channel) * ((1.055 * (abs**(1 / 2.4))) - 0.055)
+            abs <= 0.0031308 ? channel * 12.92 : (channel <=> 0) * ((1.055 * (abs**(1 / 2.4))) - 0.055)
           end
 
           # Converts a Lab or OKLab color to LCH or OKLCH, respectively.

lib/sass/value/fuzzy_math.rb

@@ -4,29 +4,12 @@ module Sass
   module Value
     # Sass's {FuzzyMath} module.
     module FuzzyMath
-      PRECISION = 10
-
-      EPSILON = 10**(-PRECISION - 1)
-
-      INVERSE_EPSILON = 10**(PRECISION + 1)
+      PRECISION = 11
 
       module_function
 
       def equals(number1, number2)
-        return true if number1 == number2
-
-        (number1 - number2).abs <= EPSILON &&
-          (number1 * INVERSE_EPSILON).round ==
-            (number2 * INVERSE_EPSILON).round
-      end
-
-      def equals_nilable(number1, number2)
-        return true if number1 == number2
-        return false if number1.nil? || number2.nil?
-
-        (number1 - number2).abs <= EPSILON &&
-          (number1 * INVERSE_EPSILON).round ==
-            (number2 * INVERSE_EPSILON).round
+        number1 == number2 || number1.round(PRECISION) == number2.round(PRECISION)
       end
 
       def less_than(number1, number2)
@@ -49,31 +32,13 @@ def integer?(number)
         return false unless number.finite?
         return true if number.integer?
 
-        equals((number - 0.5).abs % 1, 0.5)
+        number.round == number.round(PRECISION)
       end
 
       def to_i(number)
         integer?(number) ? number.round : nil
       end
 
-      def round(number)
-        if number.positive?
-          less_than(number % 1, 0.5) ? number.floor : number.ceil
-        else
-          less_than_or_equals(number % 1, 0.5) ? number.floor : number.ceil
-        end
-      end
-
-      def sign(number)
-        if number.positive?
-          1
-        elsif number.negative?
-          -1
-        else
-          0
-        end
-      end
-
       def between(number, min, max)
         return min if equals(number, min)
         return max if equals(number, max)
@@ -89,16 +54,12 @@ def assert_between(number, min, max, name)
         raise Sass::ScriptError.new("#{number} must be between #{min} and #{max}.", name)
       end
 
-      def clamp_like_css(number, lower_bound, upper_bound)
+      def _clamp_like_css(number, lower_bound, upper_bound)
         number.to_f.nan? ? lower_bound : number.clamp(lower_bound, upper_bound)
       end
 
-      def hash(number)
-        if number.finite?
-          (number * INVERSE_EPSILON).round.hash
-        else
-          number.hash
-        end
+      def _round(number)
+        number&.finite? ? number.round(PRECISION).to_f : number
       end
     end
 

lib/sass/value/number.rb

@@ -99,7 +99,7 @@ def ==(other)
 
       # @return [Integer]
       def hash
-        @hash ||= FuzzyMath.hash(canonical_units_value)
+        @hash ||= FuzzyMath._round(canonical_units_value).hash
       end
 
       # @return [::Boolean]

spec/spec_helper.rb

@@ -44,7 +44,7 @@
   supports_block_expectations
 end
 
-epsilon = Sass::Value.const_get(:FuzzyMath)::EPSILON
+precision = Sass::Value.const_get(:FuzzyMath)::PRECISION - 1
 
 RSpec::Matchers.matcher :fuzzy_eq do |expected|
   match do |actual|
@@ -56,7 +56,7 @@
       expect(actual.channel_missing?('alpha')).to eq(expected.channel_missing?('alpha'))
       expect(actual.alpha).to fuzzy_eq(expected.alpha)
     when Numeric
-      expect(actual).to be_within(epsilon).of(expected)
+      expect(actual).to be_within(((10**-precision) / 2)).of(expected.round(precision))
     else
       expect(actual).to eq(expected)
     end
@@ -67,7 +67,7 @@
   match do |actual|
     expect(actual).to match_array(expected.map do |obj|
       if obj.is_a?(Numeric)
-        a_value_within(epsilon).of(obj)
+        a_value_within((10**-precision) / 2).of(obj.round(precision))
       else
         obj
       end