diff --git a/Gemfile.lock b/Gemfile.lock
index 739f47244..78481fc08 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -31,7 +31,7 @@ GEM
     base64 (0.3.0)
     benchmark (0.5.0)
     benchmark-ips (2.14.0)
-    bigdecimal (3.3.1)
+    bigdecimal (4.0.0)
     concurrent-ruby (1.3.5)
     connection_pool (2.5.5)
     csv (3.3.5)
@@ -56,9 +56,8 @@ GEM
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
     json (2.17.1)
-    json-schema (6.0.0)
+    json-schema (5.1.0)
       addressable (~> 2.8)
-      bigdecimal (~> 3.1)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     listen (3.9.0)
diff --git a/stdlib/bigdecimal-math/0/big_math.rbs b/stdlib/bigdecimal-math/0/big_math.rbs
index 3c61d8f18..1fd2a0fc9 100644
--- a/stdlib/bigdecimal-math/0/big_math.rbs
+++ b/stdlib/bigdecimal-math/0/big_math.rbs
@@ -35,6 +35,46 @@ module BigMath
   #
   def self?.PI: (Numeric prec) -> BigDecimal
 
+  # Computes the arccosine of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.acos(BigDecimal('0.5'), 32).to_s
+  #     #=> "0.10471975511965977461542144610932e1"
+  #
+  def self?.acos: (BigDecimal, Numeric) -> BigDecimal
+
+  # Computes the inverse hyperbolic cosine of `decimal` to the specified number of
+  # digits of precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.acosh(BigDecimal('2'), 32).to_s
+  #     #=> "0.1316957896924816708625046347308e1"
+  #
+  def self?.acosh: (BigDecimal, Numeric) -> BigDecimal
+
+  # Computes the arcsine of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.asin(BigDecimal('0.5'), 32).to_s
+  #     #=> "0.52359877559829887307710723054658e0"
+  #
+  def self?.asin: (BigDecimal, Numeric) -> BigDecimal
+
+  # Computes the inverse hyperbolic sine of `decimal` to the specified number of
+  # digits of precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.asinh(BigDecimal('1'), 32).to_s
+  #     #=> "0.88137358701954302523260932497979e0"
+  #
+  def self?.asinh: (BigDecimal, Numeric) -> BigDecimal
+
   # <!--
   #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
   #   - atan(decimal, numeric) -> BigDecimal
@@ -49,6 +89,32 @@ module BigMath
   #
   def self?.atan: (BigDecimal x, Numeric prec) -> BigDecimal
 
+  # Computes the arctangent of y and x to the specified number of digits of
+  # precision, `numeric`.
+  #
+  #     BigMath.atan2(BigDecimal('-1'), BigDecimal('1'), 32).to_s
+  #     #=> "-0.78539816339744830961566084581988e0"
+  #
+  def self?.atan2: (BigDecimal, BigDecimal, Numeric) -> BigDecimal
+
+  # Computes the inverse hyperbolic tangent of `decimal` to the specified number
+  # of digits of precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.atanh(BigDecimal('0.5'), 32).to_s
+  #     #=> "0.54930614433405484569762261846126e0"
+  #
+  def self?.atanh: (BigDecimal, Numeric) -> BigDecimal
+
+  # Computes the cube root of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  #     BigMath.cbrt(BigDecimal('2'), 32).to_s
+  #     #=> "0.12599210498948731647672106072782e1"
+  #
+  def self?.cbrt: (BigDecimal, Numeric) -> BigDecimal
+
   # <!--
   #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
   #   - cos(decimal, numeric) -> BigDecimal
@@ -63,10 +129,36 @@ module BigMath
   #
   def self?.cos: (BigDecimal x, Numeric prec) -> BigDecimal
 
-  # <!--
-  #   rdoc-file=ext/bigdecimal/bigdecimal.c
-  #   - BigMath.exp(decimal, numeric)    -> BigDecimal
-  # -->
+  # Computes the hyperbolic cosine of `decimal` to the specified number of digits
+  # of precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.cosh(BigDecimal('1'), 32).to_s
+  #     #=> "0.15430806348152437784779056207571e1"
+  #
+  def self?.cosh: (BigDecimal, Numeric) -> BigDecimal
+
+  # Computes the error function of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.erf(BigDecimal('1'), 32).to_s
+  #   #=> "0.84270079294971486934122063508261e0"
+  #
+  def self?.erf: (BigDecimal, Numeric) -> BigDecimal
+
+  # Computes the complementary error function of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.erfc(BigDecimal('10'), 32).to_s
+  #   #=> "0.20884875837625447570007862949578e-44"
+  #
+  def self?.erfc: (BigDecimal, Numeric) -> BigDecimal
+
   # Computes the value of e (the base of natural logarithms) raised to the power
   # of `decimal`, to the specified number of digits of precision.
   #
@@ -76,10 +168,45 @@ module BigMath
   #
   def self?.exp: (BigDecimal, Numeric prec) -> BigDecimal
 
-  # <!--
-  #   rdoc-file=ext/bigdecimal/bigdecimal.c
-  #   - BigMath.log(decimal, numeric)    -> BigDecimal
-  # -->
+  # Decomposes +x+ into a normalized fraction and an integral power of ten.
+  #
+  #   BigMath.frexp(BigDecimal(123.456))
+  #   #=> [0.123456e0, 3]
+  #
+  def self?.frexp: (BigDecimal) -> [ BigDecimal, Integer ]
+
+  # Computes the gamma function of +decimal+ to the specified number of
+  # digits of precision, +numeric+.
+  #
+  #   BigMath.gamma(BigDecimal('0.5'), 32).to_s
+  #   #=> "0.17724538509055160272981674833411e1"
+  #
+  def self?.gamma: (BigDecimal, Numeric) -> BigDecimal
+
+  # Returns sqrt(x**2 + y**2) to the specified number of digits of precision,
+  # `numeric`.
+  #
+  #     BigMath.hypot(BigDecimal('1'), BigDecimal('2'), 32).to_s
+  #     #=> "0.22360679774997896964091736687313e1"
+  #
+  def self?.hypot: (BigDecimal, BigDecimal, Numeric) -> BigDecimal
+
+  # Inverse of +frexp+.
+  # Returns the value of fraction * 10**exponent.
+  #
+  #   BigMath.ldexp(BigDecimal("0.123456e0"), 3)
+  #   #=> 0.123456e3
+  #
+  def self?.ldexp: (BigDecimal, Integer) -> BigDecimal
+
+  # Computes the natural logarithm of the absolute value of the gamma function
+  # of +decimal+ to the specified number of digits of precision, +numeric+ and its sign.
+  #
+  #   BigMath.lgamma(BigDecimal('0.5'), 32)
+  #   #=> [0.57236494292470008707171367567653e0, 1]
+  #
+  def self?.lgamma: (BigDecimal, Numeric) -> [BigDecimal, Integer]
+
   # Computes the natural logarithm of `decimal` to the specified number of digits
   # of precision, `numeric`.
   #
@@ -91,6 +218,20 @@ module BigMath
   #
   def self?.log: (BigDecimal, Numeric prec) -> BigDecimal
 
+  # Computes the base 2 logarithm of `decimal` to the specified number of digits
+  # of precision, `numeric`.
+  #
+  # If `decimal` is zero or negative, raises Math::DomainError.
+  #
+  # If `decimal` is positive infinity, returns Infinity.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.log2(BigDecimal('3'), 32).to_s
+  #     #=> "0.15849625007211561814537389439478e1"
+  #
+  def self?.log2: (BigDecimal, Numeric) -> BigDecimal
+
   # <!--
   #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
   #   - sin(decimal, numeric) -> BigDecimal
@@ -105,6 +246,16 @@ module BigMath
   #
   def self?.sin: (BigDecimal x, Numeric prec) -> BigDecimal
 
+  # Computes the hyperbolic sine of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.sinh(BigDecimal('1'), 32).to_s
+  #     #=> "0.11752011936438014568823818505956e1"
+  #
+  def self?.sinh: (BigDecimal, Numeric) -> BigDecimal
+
   # <!--
   #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
   #   - sqrt(decimal, numeric) -> BigDecimal
@@ -116,4 +267,14 @@ module BigMath
   #     #=> "0.1414213562373095048801688724e1"
   #
   def self?.sqrt: (BigDecimal x, Numeric prec) -> BigDecimal
+
+  # Computes the hyperbolic tangent of `decimal` to the specified number of digits
+  # of precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.tanh(BigDecimal('1'), 32).to_s
+  #     #=> "0.76159415595576488811945828260479e0"
+  #
+  def self?.tanh: (BigDecimal, Numeric) -> BigDecimal
 end
diff --git a/stdlib/bigdecimal/0/big_decimal.rbs b/stdlib/bigdecimal/0/big_decimal.rbs
index 15abd15df..8792f0c68 100644
--- a/stdlib/bigdecimal/0/big_decimal.rbs
+++ b/stdlib/bigdecimal/0/big_decimal.rbs
@@ -609,7 +609,7 @@ class BigDecimal < Numeric
   # The quotient q is (a/b).floor, and the modulus is the amount that must be
   # added to q * b to get a.
   #
-  def divmod: (Numeric) -> [ BigDecimal, BigDecimal ]
+  def divmod: (Numeric) -> [ Integer, BigDecimal ]
 
   # <!--
   #   rdoc-file=ext/bigdecimal/bigdecimal.c
@@ -783,20 +783,6 @@ class BigDecimal < Numeric
   #
   def power: (Numeric n, int prec) -> BigDecimal
 
-  # <!--
-  #   rdoc-file=ext/bigdecimal/bigdecimal.c
-  #   - precs -> array
-  # -->
-  # Returns an Array of two Integer values that represent platform-dependent
-  # internal storage properties.
-  #
-  # This method is deprecated and will be removed in the future. Instead, use
-  # BigDecimal#n_significant_digits for obtaining the number of significant digits
-  # in scientific notation, and BigDecimal#precision for obtaining the number of
-  # digits in decimal notation.
-  #
-  def precs: () -> [ Integer, Integer ]
-
   # <!--
   #   rdoc-file=ext/bigdecimal/bigdecimal.c
   #   - quo(value)  -> bigdecimal
diff --git a/test/stdlib/BigDecimal_test.rb b/test/stdlib/BigDecimal_test.rb
index caa0a3bbc..9cb09516b 100644
--- a/test/stdlib/BigDecimal_test.rb
+++ b/test/stdlib/BigDecimal_test.rb
@@ -189,7 +189,7 @@ def test_div
   end
 
   def test_divmod
-    assert_send_type  "(::Numeric) -> [ ::BigDecimal, ::BigDecimal ]",
+    assert_send_type  "(::Numeric) -> [ ::Integer, ::BigDecimal ]",
                       BigDecimal("1.23"), :divmod, 2
   end
 
@@ -318,11 +318,6 @@ def test_power
                       BigDecimal("1.23"), :**, BigDecimal("1.23")
   end
 
-  def test_precs
-    assert_send_type  "() -> [ ::Integer, ::Integer ]",
-                      BigDecimal("1.23"), :precs
-  end
-
   def test_sign
     assert_send_type  "() -> ::Integer",
                       BigDecimal("1.23"), :sign
diff --git a/test/stdlib/BigMath_test.rb b/test/stdlib/BigMath_test.rb
index 9ad3493f8..32fc96bbf 100644
--- a/test/stdlib/BigMath_test.rb
+++ b/test/stdlib/BigMath_test.rb
@@ -17,35 +17,125 @@ def test_PI
                       BigMath, :PI, 10
   end
 
+  def test_acos
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :acos, BigDecimal('0.5'), 32
+  end
+
+  def test_acosh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :acosh, BigDecimal('2'), 32
+  end
+
+  def test_asin
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :asin, BigDecimal('0.5'), 32
+  end
+
+  def test_asinh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :asinh, BigDecimal('1'), 32
+  end
+
   def test_atan
     assert_send_type  "(::BigDecimal x, ::Numeric prec) -> ::BigDecimal",
                       BigMath, :atan, BigDecimal('1.23'), 10
   end
 
+  def test_atan2
+    assert_send_type "(::BigDecimal, ::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :atan2, BigDecimal('-1'), BigDecimal('1'), 32
+  end
+
+  def test_atanh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :atanh, BigDecimal('0.5'), 32
+  end
+
+  def test_cbrt
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :cbrt, BigDecimal('2'), 32
+  end
+
   def test_cos
     assert_send_type  "(::BigDecimal x, ::Numeric prec) -> ::BigDecimal",
                       BigMath, :cos, BigDecimal('1.23'), 10
   end
 
+  def test_cosh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :cosh, BigDecimal('1'), 32
+  end
+
+  def test_erf
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :erf, BigDecimal('1'), 32
+  end
+
+  def test_erfc
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :erfc, BigDecimal('10'), 32
+  end
+
   def test_exp
     assert_send_type  "(::BigDecimal, ::Numeric prec) -> ::BigDecimal",
                       BigMath, :exp, BigDecimal('1.23'), 10
   end
 
+  def test_frexp
+    assert_send_type "(::BigDecimal) -> [::BigDecimal, ::Integer]",
+                     BigMath, :frexp, BigDecimal(123.456)
+  end
+
+  def test_gamma
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :gamma, BigDecimal('0.5'), 32
+  end
+
+  def test_hypot
+    assert_send_type "(::BigDecimal, ::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :hypot, BigDecimal('1'), BigDecimal('2'), 32
+  end
+
+  def test_ldexp
+    assert_send_type "(::BigDecimal, ::Integer) -> ::BigDecimal",
+                     BigMath, :ldexp, BigDecimal("0.123456e0"), 3
+  end
+
+  def test_lgamma
+    assert_send_type "(::BigDecimal, ::Numeric) -> [::BigDecimal, ::Integer]",
+                     BigMath, :lgamma, BigDecimal('0.5'), 32
+  end
+
   def test_log
     assert_send_type  "(::BigDecimal, ::Numeric prec) -> ::BigDecimal",
                       BigMath, :log, BigDecimal('1.23'), 10
   end
 
+  def test_log2
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :log2, BigDecimal('3'), 32
+  end
+
   def test_sin
     assert_send_type  "(::BigDecimal x, ::Numeric prec) -> ::BigDecimal",
                       BigMath, :sin, BigDecimal('1.23'), 10
   end
 
+  def test_sinh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :sinh, BigDecimal('1'), 32
+  end
+
   def test_sqrt
     assert_send_type  "(::BigDecimal x, ::Numeric prec) -> ::BigDecimal",
                       BigMath, :sqrt, BigDecimal('1.23'), 10
   end
+
+  def test_tanh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     BigMath, :tanh, BigDecimal('1'), 32
+  end
 end
 
 class BigMathTest < Test::Unit::TestCase
@@ -67,23 +157,122 @@ def test_PI
                       TestClass.new, :PI, 10
   end
 
+  def test_acos
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :acos, BigDecimal('0.5'), 32
+  end
+
+  def test_acosh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :acosh, BigDecimal('2'), 32
+  end
+
+  def test_asin
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :asin, BigDecimal('0.5'), 32
+  end
+
+  def test_asinh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :asinh, BigDecimal('1'), 32
+  end
+
   def test_atan
     assert_send_type  "(::BigDecimal x, ::Numeric prec) -> ::BigDecimal",
                       TestClass.new, :atan, BigDecimal('1.23'), 10
   end
 
+  def test_atan2
+    assert_send_type "(::BigDecimal, ::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :atan2, BigDecimal('-1'), BigDecimal('1'), 32
+  end
+
+  def test_atanh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :atanh, BigDecimal('0.5'), 32
+  end
+
+  def test_cbrt
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :cbrt, BigDecimal('2'), 32
+  end
+
   def test_cos
     assert_send_type  "(::BigDecimal x, ::Numeric prec) -> ::BigDecimal",
                       TestClass.new, :cos, BigDecimal('1.23'), 10
   end
 
+  def test_cosh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :cosh, BigDecimal('1'), 32
+  end
+
+  def test_erf
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :erf, BigDecimal('1'), 32
+  end
+
+  def test_erfc
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :erfc, BigDecimal('10'), 32
+  end
+
+  def test_exp
+    assert_send_type  "(::BigDecimal, ::Numeric prec) -> ::BigDecimal",
+                      TestClass.new, :exp, BigDecimal('1.23'), 10
+  end
+
+  def test_frexp
+    assert_send_type "(::BigDecimal) -> [::BigDecimal, ::Integer]",
+                     TestClass.new, :frexp, BigDecimal(123.456)
+  end
+
+  def test_gamma
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :gamma, BigDecimal('0.5'), 32
+  end
+
+  def test_hypot
+    assert_send_type "(::BigDecimal, ::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :hypot, BigDecimal('1'), BigDecimal('2'), 32
+  end
+
+  def test_ldexp
+    assert_send_type "(::BigDecimal, ::Integer) -> ::BigDecimal",
+                     TestClass.new, :ldexp, BigDecimal("0.123456e0"), 3
+  end
+
+  def test_lgamma
+    assert_send_type "(::BigDecimal, ::Numeric) -> [::BigDecimal, ::Integer]",
+                     TestClass.new, :lgamma, BigDecimal('0.5'), 32
+  end
+
+  def test_log
+    assert_send_type  "(::BigDecimal, ::Numeric prec) -> ::BigDecimal",
+                      TestClass.new, :log, BigDecimal('1.23'), 10
+  end
+
+  def test_log2
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :log2, BigDecimal('3'), 32
+  end
   def test_sin
     assert_send_type  "(::BigDecimal x, ::Numeric prec) -> ::BigDecimal",
                       TestClass.new, :sin, BigDecimal('1.23'), 10
   end
 
+  def test_sinh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :sinh, BigDecimal('1'), 32
+  end
+
   def test_sqrt
     assert_send_type  "(::BigDecimal x, ::Numeric prec) -> ::BigDecimal",
                       TestClass.new, :sqrt, BigDecimal('1.23'), 10
   end
+
+  def test_tanh
+    assert_send_type "(::BigDecimal, ::Numeric) -> ::BigDecimal",
+                     TestClass.new, :tanh, BigDecimal('1'), 32
+  end
 end