bigdecimal 3.3.0-java → 3.3.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b3e1def7d1cfc2c72b5aa0a460ef768973e6c704a1225663e8df144718ac23a
-  data.tar.gz: 41e414cf6a1348e4567ce0b06928abb2c757a3a4f5de05ebcb1d78ff54140afe
+  metadata.gz: 538c9295198cb9f2ca1a0e96735dc2d99f65d9217f224d581ca8030fd5d27630
+  data.tar.gz: d69f66f81b160cfe8aa9c613d59bdfec0a4a22655eb3c47fb431893c72e1c927
 SHA512:
-  metadata.gz: c5880f8f1e8ed360116110107cf448894118a6714ecc916b3be74c056dab9e258b82620db42ace5a4b0b5833445859403e401fd2ba3a6c7d5aecaea1068986da
-  data.tar.gz: 33d209590eaa3132f31495884df9a5f08eae7382d349df1977c03b69d6e48c3a3bab0dee6fc5c99ead0690e5dee4f74364976d99381290b7c71f0ab4e93d7f07
+  metadata.gz: f8900815e635a380751c0cd8567e8a2d494178eb982456fd3f86dcccc295b47b3d0220b2c6c12e46548782f05834f305407f421d53683931591bdd5d3daf22af
+  data.tar.gz: 826fa286abb8bdd09ad628e9545b765ae3f267756d8cc8b9a4c64f118fe4dda2ac61304bea1c10ad903a7457c0577fdbd39c6ddfc5a94b0346b438efcabb280a

data/lib/bigdecimal/math.rb

@@ -41,7 +41,7 @@ module BigMath
   #   #=> "0.14142135623730950488016887242097e1"
   #
   def sqrt(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :sqrt)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :sqrt)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sqrt)
     x.sqrt(prec)
   end
@@ -85,7 +85,7 @@ module BigMath
   #   #=> "0.70710807985947359435812921837984e0"
   #
   def sin(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :sin)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :sin)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sin)
     return BigDecimal::Internal.nan_computation_result if x.infinite? || x.nan?
     n    = prec + BigDecimal.double_fig
@@ -122,7 +122,7 @@ module BigMath
   #   #=> "-0.99999999999999999999999999999997e0"
   #
   def cos(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :cos)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :cos)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :cos)
     return BigDecimal::Internal.nan_computation_result if x.infinite? || x.nan?
     sign, x = _sin_periodic_reduction(x, prec + BigDecimal.double_fig, add_half_pi: true)
@@ -144,7 +144,7 @@ module BigMath
   #   #=> "0.99999999999999999999999830836025e0"
   #
   def tan(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :tan)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :tan)
     sin(x, prec + BigDecimal.double_fig).div(cos(x, prec + BigDecimal.double_fig), prec)
   end
 
@@ -160,7 +160,7 @@ module BigMath
   #   #=> "-0.78539816339744830961566084581988e0"
   #
   def atan(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :atan)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :atan)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :atan)
     return BigDecimal::Internal.nan_computation_result if x.nan?
     n = prec + BigDecimal.double_fig
@@ -198,7 +198,7 @@ module BigMath
   #   #=> "0.31415926535897932384626433832795e1"
   #
   def PI(prec)
-    BigDecimal::Internal.validate_prec(prec, :PI)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :PI)
     n      = prec + BigDecimal.double_fig
     zero   = BigDecimal("0")
     one    = BigDecimal("1")
@@ -243,7 +243,7 @@ module BigMath
   #   #=> "0.27182818284590452353602874713527e1"
   #
   def E(prec)
-    BigDecimal::Internal.validate_prec(prec, :E)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :E)
     BigMath.exp(1, prec)
   end
 end

data/lib/bigdecimal.rb

@@ -27,13 +27,24 @@ class BigDecimal
       raise ArgumentError, "#{x.inspect} can't be coerced into BigDecimal"
     end
 
-    def self.validate_prec(prec, method_name, accept_zero: false) # :nodoc:
-      raise ArgumentError, 'precision must be an Integer' unless Integer === prec
+    def self.coerce_validate_prec(prec, method_name, accept_zero: false) # :nodoc:
+      unless Integer === prec
+        original = prec
+        # Emulate Integer.try_convert for ruby < 3.1
+        if prec.respond_to?(:to_int)
+          prec = prec.to_int
+        else
+          raise TypeError, "no implicit conversion of #{original.class} into Integer"
+        end
+        raise TypeError, "can't convert #{original.class} to Integer" unless Integer === prec
+      end
+
       if accept_zero
         raise ArgumentError, "Negative precision for #{method_name}" if prec < 0
       else
         raise ArgumentError, "Zero or negative precision for #{method_name}" if prec <= 0
       end
+      prec
     end
 
     def self.infinity_computation_result # :nodoc:
@@ -83,10 +94,10 @@ class BigDecimal
   #
   # Also available as the operator **.
   #
-  def power(y, prec = nil)
-    Internal.validate_prec(prec, :power) if prec
+  def power(y, prec = 0)
+    prec = Internal.coerce_validate_prec(prec, :power, accept_zero: true)
     x = self
-    y = Internal.coerce_to_bigdecimal(y, prec || n_significant_digits, :power)
+    y = Internal.coerce_to_bigdecimal(y, prec.nonzero? || n_significant_digits, :power)
 
     return Internal.nan_computation_result if x.nan? || y.nan?
     return BigDecimal(1) if y.zero?
@@ -133,10 +144,10 @@ class BigDecimal
       return BigDecimal(1)
     end
 
-    prec ||= BigDecimal.limit.nonzero?
+    prec = BigDecimal.limit if prec.zero?
     frac_part = y.frac
 
-    if frac_part.zero? && !prec
+    if frac_part.zero? && prec.zero?
       # Infinite precision calculation for `x ** int` and `x.power(int)`
       int_part = y.fix.to_i
       int_part = -int_part if (neg = int_part < 0)
@@ -156,7 +167,7 @@ class BigDecimal
       return neg ? BigDecimal(1) / ans : ans
     end
 
-    prec ||= [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig
+    prec = [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig if prec.zero?
 
     if y < 0
       inv = x.power(-y, prec)
@@ -198,7 +209,7 @@ class BigDecimal
   # Result has at least prec significant digits.
   #
   def sqrt(prec)
-    Internal.validate_prec(prec, :sqrt, accept_zero: true)
+    prec = Internal.coerce_validate_prec(prec, :sqrt, accept_zero: true)
     return Internal.infinity_computation_result if infinite? == 1
 
     raise FloatDomainError, 'sqrt of negative value' if self < 0
@@ -238,7 +249,7 @@ module BigMath
   # If +decimal+ is NaN, returns NaN.
   #
   def self.log(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :log)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :log)
     raise Math::DomainError, 'Complex argument for BigMath.log' if Complex === x
 
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log)
@@ -315,7 +326,7 @@ module BigMath
   # If +decimal+ is NaN, returns NaN.
   #
   def self.exp(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :exp)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :exp)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :exp)
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return x.positive? ? BigDecimal::Internal.infinity_computation_result : BigDecimal(0) if x.infinite?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bigdecimal
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.3.1
 platform: java
 authors:
 - Kenta Murata
@@ -9,7 +9,7 @@ authors:
 - Shigeo Kobayashi
 bindir: bin
 cert_chain: []
-date: 2025-10-07 00:00:00.000000000 Z
+date: 2025-10-09 00:00:00.000000000 Z
 dependencies: []
 description: This library provides arbitrary-precision decimal floating-point number
   class.