stdlib/builtin/math.rbs in rbs-0.11.0 vs stdlib/builtin/math.rbs in rbs-0.12.0
- old
+ new
@@ -11,51 +11,51 @@
#
# Codomain: [0, PI]
#
# Math.acos(0) == Math::PI/2 #=> true
#
- def self.acos: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.acos: (Numeric x) -> Float
# Computes the inverse hyperbolic cosine of `x`.
#
# Domain: [1, INFINITY)
#
# Codomain: [0, INFINITY)
#
# Math.acosh(1) #=> 0.0
#
- def self.acosh: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.acosh: (Numeric x) -> Float
# Computes the arc sine of `x`. Returns -PI/2..PI/2.
#
# Domain: [-1, -1]
#
# Codomain: [-PI/2, PI/2]
#
# Math.asin(1) == Math::PI/2 #=> true
#
- def self.asin: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.asin: (Numeric x) -> Float
# Computes the inverse hyperbolic sine of `x`.
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: (-INFINITY, INFINITY)
#
# Math.asinh(1) #=> 0.881373587019543
#
- def self.asinh: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.asinh: (Numeric x) -> Float
# Computes the arc tangent of `x`. Returns -PI/2..PI/2.
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: (-PI/2, PI/2)
#
# Math.atan(0) #=> 0.0
#
- def self.atan: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.atan: (Numeric x) -> Float
# Computes the arc tangent given `y` and `x`. Returns a Float in the range
# -PI..PI. Return value is a angle in radians between the positive x-axis of
# cartesian plane and the point given by the coordinates (`x`, `y`) on it.
#
@@ -76,21 +76,21 @@
# Math.atan2(INFINITY, INFINITY) #=> 0.7853981633974483
# Math.atan2(INFINITY, -INFINITY) #=> 2.356194490192345
# Math.atan2(-INFINITY, INFINITY) #=> -0.7853981633974483
# Math.atan2(-INFINITY, -INFINITY) #=> -2.356194490192345
#
- def self.atan2: (Integer | Float | Rational | BigDecimal y, Integer | Float | Rational | BigDecimal x) -> Float
+ def self.atan2: (Numeric y, Numeric x) -> Float
# Computes the inverse hyperbolic tangent of `x`.
#
# Domain: (-1, 1)
#
# Codomain: (-INFINITY, INFINITY)
#
# Math.atanh(1) #=> Infinity
#
- def self.atanh: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.atanh: (Numeric x) -> Float
# Returns the cube root of `x`.
#
# Domain: (-INFINITY, INFINITY)
#
@@ -117,52 +117,52 @@
# # [6, 1.81712059283214, 6.0]
# # [7, 1.91293118277239, 7.0]
# # [8, 2.0, 8.0]
# # [9, 2.0800838230519, 9.0]
#
- def self.cbrt: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.cbrt: (Numeric x) -> Float
# Computes the cosine of `x` (expressed in radians). Returns a Float in the
# range -1.0..1.0.
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: [-1, 1]
#
# Math.cos(Math::PI) #=> -1.0
#
- def self.cos: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.cos: (Numeric x) -> Float
# Computes the hyperbolic cosine of `x` (expressed in radians).
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: [1, INFINITY)
#
# Math.cosh(0) #=> 1.0
#
- def self.cosh: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.cosh: (Numeric x) -> Float
# Calculates the error function of `x`.
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: (-1, 1)
#
# Math.erf(0) #=> 0.0
#
- def self.erf: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.erf: (Numeric x) -> Float
# Calculates the complementary error function of x.
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: (0, 2)
#
# Math.erfc(0) #=> 1.0
#
- def self.erfc: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.erfc: (Numeric x) -> Float
# Returns e**x.
#
# Domain: (-INFINITY, INFINITY)
#
@@ -170,19 +170,19 @@
#
# Math.exp(0) #=> 1.0
# Math.exp(1) #=> 2.718281828459045
# Math.exp(1.5) #=> 4.4816890703380645
#
- def self.exp: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.exp: (Numeric x) -> Float
# Returns a two-element array containing the normalized fraction (a Float) and
# exponent (an Integer) of `x`.
#
# fraction, exponent = Math.frexp(1234) #=> [0.6025390625, 11]
# fraction * 2**exponent #=> 1234.0
#
- def self.frexp: (Integer | Float | Rational | BigDecimal x) -> [ Float, Integer ]
+ def self.frexp: (Numeric x) -> [ Float, Integer ]
# Calculates the gamma function of x.
#
# Note that gamma(n) is same as fact(n-1) for integer n > 0. However gamma(n)
# returns float and can be an approximation.
@@ -214,38 +214,38 @@
# # [23, 1.1240007277776077e+21, 1124000727777607680000]
# # [24, 2.5852016738885062e+22, 25852016738884976640000]
# # [25, 6.204484017332391e+23, 620448401733239439360000]
# # [26, 1.5511210043330954e+25, 15511210043330985984000000]
#
- def self.gamma: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.gamma: (Numeric x) -> Float
# Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with
# sides `x` and `y`.
#
# Math.hypot(3, 4) #=> 5.0
#
- def self.hypot: (Integer | Float | Rational | BigDecimal x, Integer | Float | Rational | BigDecimal y) -> Float
+ def self.hypot: (Numeric x, Numeric y) -> Float
# Returns the value of `fraction`*(2**`exponent`).
#
# fraction, exponent = Math.frexp(1234)
# Math.ldexp(fraction, exponent) #=> 1234.0
#
- def self.ldexp: (Integer | Float | Rational | BigDecimal fraction, Integer | Float | Rational | BigDecimal exponent) -> Float
+ def self.ldexp: (Numeric fraction, Numeric exponent) -> Float
# Calculates the logarithmic gamma of `x` and the sign of gamma of `x`.
#
# Math.lgamma(x) is same as
# [Math.log(Math.gamma(x).abs), Math.gamma(x) < 0 ? -1 : 1]
#
# but avoid overflow by Math.gamma(x) for large x.
#
# Math.lgamma(0) #=> [Infinity, 1]
#
- def self.lgamma: (Integer | Float | Rational | BigDecimal x) -> [ Float, Integer ]
+ def self.lgamma: (Numeric x) -> [ Float, Integer ]
- def self.log: (Integer | Float | Rational | BigDecimal x, ?Integer | Float | Rational | BigDecimal base) -> Float
+ def self.log: (Numeric x, ?Numeric base) -> Float
# Returns the base 10 logarithm of `x`.
#
# Domain: (0, INFINITY)
#
@@ -253,11 +253,11 @@
#
# Math.log10(1) #=> 0.0
# Math.log10(10) #=> 1.0
# Math.log10(10**100) #=> 100.0
#
- def self.log10: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.log10: (Numeric x) -> Float
# Returns the base 2 logarithm of `x`.
#
# Domain: (0, INFINITY)
#
@@ -266,32 +266,32 @@
# Math.log2(1) #=> 0.0
# Math.log2(2) #=> 1.0
# Math.log2(32768) #=> 15.0
# Math.log2(65536) #=> 16.0
#
- def self.log2: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.log2: (Numeric x) -> Float
# Computes the sine of `x` (expressed in radians). Returns a Float in the range
# -1.0..1.0.
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: [-1, 1]
#
# Math.sin(Math::PI/2) #=> 1.0
#
- def self.sin: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.sin: (Numeric x) -> Float
# Computes the hyperbolic sine of `x` (expressed in radians).
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: (-INFINITY, INFINITY)
#
# Math.sinh(0) #=> 0.0
#
- def self.sinh: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.sinh: (Numeric x) -> Float
# Returns the non-negative square root of `x`.
#
# Domain: [0, INFINITY)
#
@@ -317,30 +317,30 @@
#
# Math.sqrt(10**46).to_i #=> 99999999999999991611392 (!)
#
# See also BigDecimal#sqrt and Integer.sqrt.
#
- def self.sqrt: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.sqrt: (Numeric x) -> Float
# Computes the tangent of `x` (expressed in radians).
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: (-INFINITY, INFINITY)
#
# Math.tan(0) #=> 0.0
#
- def self.tan: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.tan: (Numeric x) -> Float
# Computes the hyperbolic tangent of `x` (expressed in radians).
#
# Domain: (-INFINITY, INFINITY)
#
# Codomain: (-1, 1)
#
# Math.tanh(0) #=> 0.0
#
- def self.tanh: (Integer | Float | Rational | BigDecimal x) -> Float
+ def self.tanh: (Numeric x) -> Float
end
# Definition of the mathematical constant E for Euler's number (e) as a Float
# number.
#