# Module: Math

Defined in:
math.c

## Defined Under Namespace

Classes: DomainError

## Constant Summary collapse

PI =

Definition of the mathematical constant PI as a Float number.

`DBL2NUM(M_PI)`
E =

Definition of the mathematical constant E for Euler's number (e) as a Float number.

`DBL2NUM(exp(1.0))`

## Class Method Summary collapse

• Computes the arc cosine of `x`.

• Computes the inverse hyperbolic cosine of `x`.

• Computes the arc sine of `x`.

• Computes the inverse hyperbolic sine of `x`.

• Computes the arc tangent of `x`.

• Computes the arc tangent given `y` and `x`.

• Computes the inverse hyperbolic tangent of `x`.

• Returns the cube root of `x`.

• Computes the cosine of `x` (expressed in radians).

• Computes the hyperbolic cosine of `x` (expressed in radians).

• Calculates the error function of `x`.

• Calculates the complementary error function of x.

• Returns e**x.

• Returns a two-element array containing the normalized fraction (a Float) and exponent (an Integer) of `x`.

• Calculates the gamma function of x.

• Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with sides `x` and `y`.

• Returns the value of `fraction`*(2**`exponent`).

• Calculates the logarithmic gamma of `x` and the sign of gamma of `x`.

• Returns the logarithm of `x`.

• Returns the base 10 logarithm of `x`.

• Returns the base 2 logarithm of `x`.

• Computes the sine of `x` (expressed in radians).

• Computes the hyperbolic sine of `x` (expressed in radians).

• Returns the non-negative square root of `x`.

• Computes the tangent of `x` (expressed in radians).

• Computes the hyperbolic tangent of `x` (expressed in radians).

## Instance Method Summary collapse

• private

Computes the arc cosine of `x`.

• private

Computes the inverse hyperbolic cosine of `x`.

• private

Computes the arc sine of `x`.

• private

Computes the inverse hyperbolic sine of `x`.

• private

Computes the arc tangent of `x`.

• private

Computes the arc tangent given `y` and `x`.

• private

Computes the inverse hyperbolic tangent of `x`.

• private

Returns the cube root of `x`.

• private

Computes the cosine of `x` (expressed in radians).

• private

Computes the hyperbolic cosine of `x` (expressed in radians).

• private

Calculates the error function of `x`.

• private

Calculates the complementary error function of x.

• private

Returns e**x.

• private

Returns a two-element array containing the normalized fraction (a Float) and exponent (an Integer) of `x`.

• private

Calculates the gamma function of x.

• private

Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with sides `x` and `y`.

• private

Returns the value of `fraction`*(2**`exponent`).

• private

Calculates the logarithmic gamma of `x` and the sign of gamma of `x`.

• private

Returns the logarithm of `x`.

• private

Returns the base 10 logarithm of `x`.

• private

Returns the base 2 logarithm of `x`.

• private

Computes the sine of `x` (expressed in radians).

• private

Computes the hyperbolic sine of `x` (expressed in radians).

• private

Returns the non-negative square root of `x`.

• private

Computes the tangent of `x` (expressed in radians).

• private

Computes the hyperbolic tangent of `x` (expressed in radians).

## Class Method Details

### .acos(x) ⇒ Float

Computes the arc cosine of `x`. Returns 0..PI.

Domain: [-1, 1]

Codomain: [0, PI]

``````Math.acos(0) == Math::PI/2  #=> true
``````

Returns:

 ``` 181 182 183 184 185 186 187 188 189 190``` ```# File 'math.c', line 181 static VALUE math_acos(VALUE unused_obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < -1.0 || 1.0 < d) domain_error("acos"); return DBL2NUM(acos(d)); }```

### .acosh(x) ⇒ Float

Computes the inverse hyperbolic cosine of `x`.

Domain: [1, INFINITY)

Codomain: [0, INFINITY)

``````Math.acosh(1) #=> 0.0
``````

Returns:

 ``` 340 341 342 343 344 345 346 347 348 349``` ```# File 'math.c', line 340 static VALUE math_acosh(VALUE unused_obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < 1.0) domain_error("acosh"); return DBL2NUM(acosh(d)); }```

### .asin(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
``````

Returns:

 ``` 205 206 207 208 209 210 211 212 213 214``` ```# File 'math.c', line 205 static VALUE math_asin(VALUE unused_obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < -1.0 || 1.0 < d) domain_error("asin"); return DBL2NUM(asin(d)); }```

### .asinh(x) ⇒ Float

Computes the inverse hyperbolic sine of `x`.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.asinh(1) #=> 0.881373587019543
``````

Returns:

 ``` 365 366 367 368 369``` ```# File 'math.c', line 365 static VALUE math_asinh(VALUE unused_obj, VALUE x) { return DBL2NUM(asinh(Get_Double(x))); }```

### .atan(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
``````

Returns:

 ``` 229 230 231 232 233``` ```# File 'math.c', line 229 static VALUE math_atan(VALUE unused_obj, VALUE x) { return DBL2NUM(atan(Get_Double(x))); }```

### .atan2(y, 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.

Domain: (-INFINITY, INFINITY)

Codomain: [-PI, PI]

``````Math.atan2(-0.0, -1.0) #=> -3.141592653589793
Math.atan2(-1.0, -1.0) #=> -2.356194490192345
Math.atan2(-1.0, 0.0)  #=> -1.5707963267948966
Math.atan2(-1.0, 1.0)  #=> -0.7853981633974483
Math.atan2(-0.0, 1.0)  #=> -0.0
Math.atan2(0.0, 1.0)   #=> 0.0
Math.atan2(1.0, 1.0)   #=> 0.7853981633974483
Math.atan2(1.0, 0.0)   #=> 1.5707963267948966
Math.atan2(1.0, -1.0)  #=> 2.356194490192345
Math.atan2(0.0, -1.0)  #=> 3.141592653589793
Math.atan2(INFINITY, INFINITY)   #=> 0.7853981633974483
Math.atan2(INFINITY, -INFINITY)  #=> 2.356194490192345
Math.atan2(-INFINITY, INFINITY)  #=> -0.7853981633974483
Math.atan2(-INFINITY, -INFINITY) #=> -2.356194490192345
``````

Returns:

 ``` 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101``` ```# File 'math.c', line 74 static VALUE math_atan2(VALUE unused_obj, VALUE y, VALUE x) { double dx, dy; dx = Get_Double(x); dy = Get_Double(y); if (dx == 0.0 && dy == 0.0) { if (!signbit(dx)) return DBL2NUM(dy); if (!signbit(dy)) return DBL2NUM(M_PI); return DBL2NUM(-M_PI); } #ifndef ATAN2_INF_C99 if (isinf(dx) && isinf(dy)) { /* optimization for FLONUM */ if (dx < 0.0) { const double dz = (3.0 * M_PI / 4.0); return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz); } else { const double dz = (M_PI / 4.0); return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz); } } #endif return DBL2NUM(atan2(dy, dx)); }```

### .atanh(x) ⇒ Float

Computes the inverse hyperbolic tangent of `x`.

Domain: (-1, 1)

Codomain: (-INFINITY, INFINITY)

``````Math.atanh(1) #=> Infinity
``````

Returns:

 ``` 385 386 387 388 389 390 391 392 393 394 395 396 397``` ```# File 'math.c', line 385 static VALUE math_atanh(VALUE unused_obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < -1.0 || +1.0 < d) domain_error("atanh"); /* check for pole error */ if (d == -1.0) return DBL2NUM(-HUGE_VAL); if (d == +1.0) return DBL2NUM(+HUGE_VAL); return DBL2NUM(atanh(d)); }```

### .cbrt(x) ⇒ Float

Returns the cube root of `x`.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````-9.upto(9) {|x|
p [x, Math.cbrt(x), Math.cbrt(x)**3]
}
#=> [-9, -2.0800838230519, -9.0]
#   [-8, -2.0, -8.0]
#   [-7, -1.91293118277239, -7.0]
#   [-6, -1.81712059283214, -6.0]
#   [-5, -1.7099759466767, -5.0]
#   [-4, -1.5874010519682, -4.0]
#   [-3, -1.44224957030741, -3.0]
#   [-2, -1.25992104989487, -2.0]
#   [-1, -1.0, -1.0]
#   [0, 0.0, 0.0]
#   [1, 1.0, 1.0]
#   [2, 1.25992104989487, 2.0]
#   [3, 1.44224957030741, 3.0]
#   [4, 1.5874010519682, 4.0]
#   [5, 1.7099759466767, 5.0]
#   [6, 1.81712059283214, 6.0]
#   [7, 1.91293118277239, 7.0]
#   [8, 2.0, 8.0]
#   [9, 2.0800838230519, 9.0]
``````

Returns:

 ``` 700 701 702 703 704 705 706 707 708 709 710 711``` ```# File 'math.c', line 700 static VALUE math_cbrt(VALUE unused_obj, VALUE x) { double f = Get_Double(x); double r = cbrt(f); #if defined __GLIBC__ if (isfinite(r)) { r = (2.0 * r + (f / r / r)) / 3.0; } #endif return DBL2NUM(r); }```

### .cos(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
``````

Returns:

 ``` 119 120 121 122 123``` ```# File 'math.c', line 119 static VALUE math_cos(VALUE unused_obj, VALUE x) { return DBL2NUM(cos(Get_Double(x))); }```

### .cosh(x) ⇒ Float

Computes the hyperbolic cosine of `x` (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: [1, INFINITY)

``````Math.cosh(0) #=> 1.0
``````

Returns:

 ``` 257 258 259 260 261``` ```# File 'math.c', line 257 static VALUE math_cosh(VALUE unused_obj, VALUE x) { return DBL2NUM(cosh(Get_Double(x))); }```

### .erf(x) ⇒ Float

Calculates the error function of `x`.

``````Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

Math.erf(0) #=> 0.0
``````

Returns:

 ``` 780 781 782 783 784``` ```# File 'math.c', line 780 static VALUE math_erf(VALUE unused_obj, VALUE x) { return DBL2NUM(erf(Get_Double(x))); }```

### .erfc(x) ⇒ Float

Calculates the complementary error function of x.

``````Domain: (-INFINITY, INFINITY)

Codomain: (0, 2)

Math.erfc(0) #=> 1.0
``````

Returns:

 ``` 800 801 802 803 804``` ```# File 'math.c', line 800 static VALUE math_erfc(VALUE unused_obj, VALUE x) { return DBL2NUM(erfc(Get_Double(x))); }```

### .exp(x) ⇒ Float

Returns e**x.

Domain: (-INFINITY, INFINITY)

Codomain: (0, INFINITY)

``````Math.exp(0)       #=> 1.0
Math.exp(1)       #=> 2.718281828459045
Math.exp(1.5)     #=> 4.4816890703380645
``````

Returns:

 ``` 415 416 417 418 419``` ```# File 'math.c', line 415 static VALUE math_exp(VALUE unused_obj, VALUE x) { return DBL2NUM(exp(Get_Double(x))); }```

### .frexp(x) ⇒ Array

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
``````

Returns:

 ``` 724 725 726 727 728 729 730 731 732``` ```# File 'math.c', line 724 static VALUE math_frexp(VALUE unused_obj, VALUE x) { double d; int exp; d = frexp(Get_Double(x), &exp); return rb_assoc_new(DBL2NUM(d), INT2NUM(exp)); }```

### .gamma(x) ⇒ Float

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.

def fact(n) (1..n).inject(1) {|r,i| r*i } end
1.upto(26) {|i| p [i, Math.gamma(i), fact(i-1)] }
#=> [1, 1.0, 1]
#   [2, 1.0, 1]
#   [3, 2.0, 2]
#   [4, 6.0, 6]
#   [5, 24.0, 24]
#   [6, 120.0, 120]
#   [7, 720.0, 720]
#   [8, 5040.0, 5040]
#   [9, 40320.0, 40320]
#   [10, 362880.0, 362880]
#   [11, 3628800.0, 3628800]
#   [12, 39916800.0, 39916800]
#   [13, 479001600.0, 479001600]
#   [14, 6227020800.0, 6227020800]
#   [15, 87178291200.0, 87178291200]
#   [16, 1307674368000.0, 1307674368000]
#   [17, 20922789888000.0, 20922789888000]
#   [18, 355687428096000.0, 355687428096000]
#   [19, 6.402373705728e+15, 6402373705728000]
#   [20, 1.21645100408832e+17, 121645100408832000]
#   [21, 2.43290200817664e+18, 2432902008176640000]
#   [22, 5.109094217170944e+19, 51090942171709440000]
#   [23, 1.1240007277776077e+21, 1124000727777607680000]
#   [24, 2.5852016738885062e+22, 25852016738884976640000]
#   [25, 6.204484017332391e+23, 620448401733239439360000]
#   [26, 1.5511210043330954e+25, 15511210043330985984000000]
``````

Returns:

 ``` 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895``` ```# File 'math.c', line 846 static VALUE math_gamma(VALUE unused_obj, VALUE x) { static const double fact_table[] = { /* fact(0) */ 1.0, /* fact(1) */ 1.0, /* fact(2) */ 2.0, /* fact(3) */ 6.0, /* fact(4) */ 24.0, /* fact(5) */ 120.0, /* fact(6) */ 720.0, /* fact(7) */ 5040.0, /* fact(8) */ 40320.0, /* fact(9) */ 362880.0, /* fact(10) */ 3628800.0, /* fact(11) */ 39916800.0, /* fact(12) */ 479001600.0, /* fact(13) */ 6227020800.0, /* fact(14) */ 87178291200.0, /* fact(15) */ 1307674368000.0, /* fact(16) */ 20922789888000.0, /* fact(17) */ 355687428096000.0, /* fact(18) */ 6402373705728000.0, /* fact(19) */ 121645100408832000.0, /* fact(20) */ 2432902008176640000.0, /* fact(21) */ 51090942171709440000.0, /* fact(22) */ 1124000727777607680000.0, /* fact(23)=25852016738884976640000 needs 56bit mantissa which is * impossible to represent exactly in IEEE 754 double which have * 53bit mantissa. */ }; enum {NFACT_TABLE = numberof(fact_table)}; double d; d = Get_Double(x); /* check for domain error */ if (isinf(d)) { if (signbit(d)) domain_error("gamma"); return DBL2NUM(HUGE_VAL); } if (d == 0.0) { return signbit(d) ? DBL2NUM(-HUGE_VAL) : DBL2NUM(HUGE_VAL); } if (d == floor(d)) { if (d < 0.0) domain_error("gamma"); if (1.0 <= d && d <= (double)NFACT_TABLE) { return DBL2NUM(fact_table[(int)d - 1]); } } return DBL2NUM(tgamma(d)); }```

### .hypot(x, y) ⇒ 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
``````

Returns:

 ``` 760 761 762 763 764``` ```# File 'math.c', line 760 static VALUE math_hypot(VALUE unused_obj, VALUE x, VALUE y) { return DBL2NUM(hypot(Get_Double(x), Get_Double(y))); }```

### .ldexp(fraction, exponent) ⇒ Float

Returns the value of `fraction`*(2**`exponent`).

``````fraction, exponent = Math.frexp(1234)
Math.ldexp(fraction, exponent)   #=> 1234.0
``````

Returns:

 ``` 744 745 746 747 748``` ```# File 'math.c', line 744 static VALUE math_ldexp(VALUE unused_obj, VALUE x, VALUE n) { return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n))); }```

### .lgamma(x) ⇒ Array, ...

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]
``````

Returns ].

Returns:

 ``` 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929``` ```# File 'math.c', line 911 static VALUE math_lgamma(VALUE unused_obj, VALUE x) { double d; int sign=1; VALUE v; d = Get_Double(x); /* check for domain error */ if (isinf(d)) { if (signbit(d)) domain_error("lgamma"); return rb_assoc_new(DBL2NUM(HUGE_VAL), INT2FIX(1)); } if (d == 0.0) { VALUE vsign = signbit(d) ? INT2FIX(-1) : INT2FIX(+1); return rb_assoc_new(DBL2NUM(HUGE_VAL), vsign); } v = DBL2NUM(lgamma_r(d, &sign)); return rb_assoc_new(v, INT2FIX(sign)); }```

### .log(x) ⇒ Float .log(x, base) ⇒ Float

Returns the logarithm of `x`. If additional second argument is given, it will be the base of logarithm. Otherwise it is `e` (for the natural logarithm).

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.log(0)          #=> -Infinity
Math.log(1)          #=> 0.0
Math.log(Math::E)    #=> 1.0
Math.log(Math::E**3) #=> 3.0
Math.log(12, 3)      #=> 2.2618595071429146
``````

 ``` 461 462 463 464 465``` ```# File 'math.c', line 461 static VALUE math_log(int argc, const VALUE *argv, VALUE unused_obj) { return rb_math_log(argc, argv); }```

### .log10(x) ⇒ Float

Returns the base 10 logarithm of `x`.

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.log10(1)       #=> 0.0
Math.log10(10)      #=> 1.0
Math.log10(10**100) #=> 100.0
``````

Returns:

 ``` 571 572 573 574 575 576 577 578 579 580 581 582 583``` ```# File 'math.c', line 571 static VALUE math_log10(VALUE unused_obj, VALUE x) { size_t numbits; double d = get_double_rshift(x, &numbits); /* check for domain error */ if (d < 0.0) domain_error("log10"); /* check for pole error */ if (d == 0.0) return DBL2NUM(-HUGE_VAL); return DBL2NUM(log10(d) + numbits * log10(2)); /* log10(d * 2 ** numbits) */ }```

### .log2(x) ⇒ Float

Returns the base 2 logarithm of `x`.

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.log2(1)      #=> 0.0
Math.log2(2)      #=> 1.0
Math.log2(32768)  #=> 15.0
Math.log2(65536)  #=> 16.0
``````

Returns:

 ``` 541 542 543 544 545 546 547 548 549 550 551 552 553``` ```# File 'math.c', line 541 static VALUE math_log2(VALUE unused_obj, VALUE x) { size_t numbits; double d = get_double_rshift(x, &numbits); /* check for domain error */ if (d < 0.0) domain_error("log2"); /* check for pole error */ if (d == 0.0) return DBL2NUM(-HUGE_VAL); return DBL2NUM(log2(d) + numbits); /* log2(d * 2 ** numbits) */ }```

### .sin(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
``````

Returns:

 ``` 140 141 142 143 144``` ```# File 'math.c', line 140 static VALUE math_sin(VALUE unused_obj, VALUE x) { return DBL2NUM(sin(Get_Double(x))); }```

### .sinh(x) ⇒ Float

Computes the hyperbolic sine of `x` (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.sinh(0) #=> 0.0
``````

Returns:

 ``` 285 286 287 288 289``` ```# File 'math.c', line 285 static VALUE math_sinh(VALUE unused_obj, VALUE x) { return DBL2NUM(sinh(Get_Double(x))); }```

### .sqrt(x) ⇒ Float

Returns the non-negative square root of `x`.

Domain: [0, INFINITY)

Codomain:[0, INFINITY)

``````0.upto(10) {|x|
p [x, Math.sqrt(x), Math.sqrt(x)**2]
}
#=> [0, 0.0, 0.0]
#   [1, 1.0, 1.0]
#   [2, 1.4142135623731, 2.0]
#   [3, 1.73205080756888, 3.0]
#   [4, 2.0, 4.0]
#   [5, 2.23606797749979, 5.0]
#   [6, 2.44948974278318, 6.0]
#   [7, 2.64575131106459, 7.0]
#   [8, 2.82842712474619, 8.0]
#   [9, 3.0, 9.0]
#   [10, 3.16227766016838, 10.0]
``````

Note that the limited precision of floating point arithmetic might lead to surprising results:

``````Math.sqrt(10**46).to_i  #=> 99999999999999991611392 (!)
``````

Returns:

 ``` 620 621 622 623 624``` ```# File 'math.c', line 620 static VALUE math_sqrt(VALUE unused_obj, VALUE x) { return rb_math_sqrt(x); }```

### .tan(x) ⇒ Float

Computes the tangent of `x` (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.tan(0) #=> 0.0
``````

Returns:

 ``` 161 162 163 164 165``` ```# File 'math.c', line 161 static VALUE math_tan(VALUE unused_obj, VALUE x) { return DBL2NUM(tan(Get_Double(x))); }```

### .tanh(x) ⇒ Float

Computes the hyperbolic tangent of `x` (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

``````Math.tanh(0) #=> 0.0
``````

Returns:

 ``` 320 321 322 323 324``` ```# File 'math.c', line 320 static VALUE math_tanh(VALUE unused_obj, VALUE x) { return DBL2NUM(tanh(Get_Double(x))); }```

## Instance Method Details

### #acos(x) ⇒ Float(private)

Computes the arc cosine of `x`. Returns 0..PI.

Domain: [-1, 1]

Codomain: [0, PI]

``````Math.acos(0) == Math::PI/2  #=> true
``````

Returns:

 ``` 181 182 183 184 185 186 187 188 189 190``` ```# File 'math.c', line 181 static VALUE math_acos(VALUE unused_obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < -1.0 || 1.0 < d) domain_error("acos"); return DBL2NUM(acos(d)); }```

### #acosh(x) ⇒ Float(private)

Computes the inverse hyperbolic cosine of `x`.

Domain: [1, INFINITY)

Codomain: [0, INFINITY)

``````Math.acosh(1) #=> 0.0
``````

Returns:

 ``` 340 341 342 343 344 345 346 347 348 349``` ```# File 'math.c', line 340 static VALUE math_acosh(VALUE unused_obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < 1.0) domain_error("acosh"); return DBL2NUM(acosh(d)); }```

### #asin(x) ⇒ Float(private)

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
``````

Returns:

 ``` 205 206 207 208 209 210 211 212 213 214``` ```# File 'math.c', line 205 static VALUE math_asin(VALUE unused_obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < -1.0 || 1.0 < d) domain_error("asin"); return DBL2NUM(asin(d)); }```

### #asinh(x) ⇒ Float(private)

Computes the inverse hyperbolic sine of `x`.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.asinh(1) #=> 0.881373587019543
``````

Returns:

 ``` 365 366 367 368 369``` ```# File 'math.c', line 365 static VALUE math_asinh(VALUE unused_obj, VALUE x) { return DBL2NUM(asinh(Get_Double(x))); }```

### #atan(x) ⇒ Float(private)

Computes the arc tangent of `x`. Returns -PI/2..PI/2.

Domain: (-INFINITY, INFINITY)

Codomain: (-PI/2, PI/2)

``````Math.atan(0) #=> 0.0
``````

Returns:

 ``` 229 230 231 232 233``` ```# File 'math.c', line 229 static VALUE math_atan(VALUE unused_obj, VALUE x) { return DBL2NUM(atan(Get_Double(x))); }```

### #atan2(y, x) ⇒ Float(private)

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.

Domain: (-INFINITY, INFINITY)

Codomain: [-PI, PI]

``````Math.atan2(-0.0, -1.0) #=> -3.141592653589793
Math.atan2(-1.0, -1.0) #=> -2.356194490192345
Math.atan2(-1.0, 0.0)  #=> -1.5707963267948966
Math.atan2(-1.0, 1.0)  #=> -0.7853981633974483
Math.atan2(-0.0, 1.0)  #=> -0.0
Math.atan2(0.0, 1.0)   #=> 0.0
Math.atan2(1.0, 1.0)   #=> 0.7853981633974483
Math.atan2(1.0, 0.0)   #=> 1.5707963267948966
Math.atan2(1.0, -1.0)  #=> 2.356194490192345
Math.atan2(0.0, -1.0)  #=> 3.141592653589793
Math.atan2(INFINITY, INFINITY)   #=> 0.7853981633974483
Math.atan2(INFINITY, -INFINITY)  #=> 2.356194490192345
Math.atan2(-INFINITY, INFINITY)  #=> -0.7853981633974483
Math.atan2(-INFINITY, -INFINITY) #=> -2.356194490192345
``````

Returns:

 ``` 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101``` ```# File 'math.c', line 74 static VALUE math_atan2(VALUE unused_obj, VALUE y, VALUE x) { double dx, dy; dx = Get_Double(x); dy = Get_Double(y); if (dx == 0.0 && dy == 0.0) { if (!signbit(dx)) return DBL2NUM(dy); if (!signbit(dy)) return DBL2NUM(M_PI); return DBL2NUM(-M_PI); } #ifndef ATAN2_INF_C99 if (isinf(dx) && isinf(dy)) { /* optimization for FLONUM */ if (dx < 0.0) { const double dz = (3.0 * M_PI / 4.0); return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz); } else { const double dz = (M_PI / 4.0); return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz); } } #endif return DBL2NUM(atan2(dy, dx)); }```

### #atanh(x) ⇒ Float(private)

Computes the inverse hyperbolic tangent of `x`.

Domain: (-1, 1)

Codomain: (-INFINITY, INFINITY)

``````Math.atanh(1) #=> Infinity
``````

Returns:

 ``` 385 386 387 388 389 390 391 392 393 394 395 396 397``` ```# File 'math.c', line 385 static VALUE math_atanh(VALUE unused_obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < -1.0 || +1.0 < d) domain_error("atanh"); /* check for pole error */ if (d == -1.0) return DBL2NUM(-HUGE_VAL); if (d == +1.0) return DBL2NUM(+HUGE_VAL); return DBL2NUM(atanh(d)); }```

### #cbrt(x) ⇒ Float(private)

Returns the cube root of `x`.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````-9.upto(9) {|x|
p [x, Math.cbrt(x), Math.cbrt(x)**3]
}
#=> [-9, -2.0800838230519, -9.0]
#   [-8, -2.0, -8.0]
#   [-7, -1.91293118277239, -7.0]
#   [-6, -1.81712059283214, -6.0]
#   [-5, -1.7099759466767, -5.0]
#   [-4, -1.5874010519682, -4.0]
#   [-3, -1.44224957030741, -3.0]
#   [-2, -1.25992104989487, -2.0]
#   [-1, -1.0, -1.0]
#   [0, 0.0, 0.0]
#   [1, 1.0, 1.0]
#   [2, 1.25992104989487, 2.0]
#   [3, 1.44224957030741, 3.0]
#   [4, 1.5874010519682, 4.0]
#   [5, 1.7099759466767, 5.0]
#   [6, 1.81712059283214, 6.0]
#   [7, 1.91293118277239, 7.0]
#   [8, 2.0, 8.0]
#   [9, 2.0800838230519, 9.0]
``````

Returns:

 ``` 700 701 702 703 704 705 706 707 708 709 710 711``` ```# File 'math.c', line 700 static VALUE math_cbrt(VALUE unused_obj, VALUE x) { double f = Get_Double(x); double r = cbrt(f); #if defined __GLIBC__ if (isfinite(r)) { r = (2.0 * r + (f / r / r)) / 3.0; } #endif return DBL2NUM(r); }```

### #cos(x) ⇒ Float(private)

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
``````

Returns:

 ``` 119 120 121 122 123``` ```# File 'math.c', line 119 static VALUE math_cos(VALUE unused_obj, VALUE x) { return DBL2NUM(cos(Get_Double(x))); }```

### #cosh(x) ⇒ Float(private)

Computes the hyperbolic cosine of `x` (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: [1, INFINITY)

``````Math.cosh(0) #=> 1.0
``````

Returns:

 ``` 257 258 259 260 261``` ```# File 'math.c', line 257 static VALUE math_cosh(VALUE unused_obj, VALUE x) { return DBL2NUM(cosh(Get_Double(x))); }```

### #erf(x) ⇒ Float(private)

Calculates the error function of `x`.

``````Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

Math.erf(0) #=> 0.0
``````

Returns:

 ``` 780 781 782 783 784``` ```# File 'math.c', line 780 static VALUE math_erf(VALUE unused_obj, VALUE x) { return DBL2NUM(erf(Get_Double(x))); }```

### #erfc(x) ⇒ Float(private)

Calculates the complementary error function of x.

``````Domain: (-INFINITY, INFINITY)

Codomain: (0, 2)

Math.erfc(0) #=> 1.0
``````

Returns:

 ``` 800 801 802 803 804``` ```# File 'math.c', line 800 static VALUE math_erfc(VALUE unused_obj, VALUE x) { return DBL2NUM(erfc(Get_Double(x))); }```

### #exp(x) ⇒ Float(private)

Returns e**x.

Domain: (-INFINITY, INFINITY)

Codomain: (0, INFINITY)

``````Math.exp(0)       #=> 1.0
Math.exp(1)       #=> 2.718281828459045
Math.exp(1.5)     #=> 4.4816890703380645
``````

Returns:

 ``` 415 416 417 418 419``` ```# File 'math.c', line 415 static VALUE math_exp(VALUE unused_obj, VALUE x) { return DBL2NUM(exp(Get_Double(x))); }```

### #frexp(x) ⇒ Array(private)

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
``````

Returns:

 ``` 724 725 726 727 728 729 730 731 732``` ```# File 'math.c', line 724 static VALUE math_frexp(VALUE unused_obj, VALUE x) { double d; int exp; d = frexp(Get_Double(x), &exp); return rb_assoc_new(DBL2NUM(d), INT2NUM(exp)); }```

### #gamma(x) ⇒ Float(private)

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.

def fact(n) (1..n).inject(1) {|r,i| r*i } end
1.upto(26) {|i| p [i, Math.gamma(i), fact(i-1)] }
#=> [1, 1.0, 1]
#   [2, 1.0, 1]
#   [3, 2.0, 2]
#   [4, 6.0, 6]
#   [5, 24.0, 24]
#   [6, 120.0, 120]
#   [7, 720.0, 720]
#   [8, 5040.0, 5040]
#   [9, 40320.0, 40320]
#   [10, 362880.0, 362880]
#   [11, 3628800.0, 3628800]
#   [12, 39916800.0, 39916800]
#   [13, 479001600.0, 479001600]
#   [14, 6227020800.0, 6227020800]
#   [15, 87178291200.0, 87178291200]
#   [16, 1307674368000.0, 1307674368000]
#   [17, 20922789888000.0, 20922789888000]
#   [18, 355687428096000.0, 355687428096000]
#   [19, 6.402373705728e+15, 6402373705728000]
#   [20, 1.21645100408832e+17, 121645100408832000]
#   [21, 2.43290200817664e+18, 2432902008176640000]
#   [22, 5.109094217170944e+19, 51090942171709440000]
#   [23, 1.1240007277776077e+21, 1124000727777607680000]
#   [24, 2.5852016738885062e+22, 25852016738884976640000]
#   [25, 6.204484017332391e+23, 620448401733239439360000]
#   [26, 1.5511210043330954e+25, 15511210043330985984000000]
``````

Returns:

 ``` 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895``` ```# File 'math.c', line 846 static VALUE math_gamma(VALUE unused_obj, VALUE x) { static const double fact_table[] = { /* fact(0) */ 1.0, /* fact(1) */ 1.0, /* fact(2) */ 2.0, /* fact(3) */ 6.0, /* fact(4) */ 24.0, /* fact(5) */ 120.0, /* fact(6) */ 720.0, /* fact(7) */ 5040.0, /* fact(8) */ 40320.0, /* fact(9) */ 362880.0, /* fact(10) */ 3628800.0, /* fact(11) */ 39916800.0, /* fact(12) */ 479001600.0, /* fact(13) */ 6227020800.0, /* fact(14) */ 87178291200.0, /* fact(15) */ 1307674368000.0, /* fact(16) */ 20922789888000.0, /* fact(17) */ 355687428096000.0, /* fact(18) */ 6402373705728000.0, /* fact(19) */ 121645100408832000.0, /* fact(20) */ 2432902008176640000.0, /* fact(21) */ 51090942171709440000.0, /* fact(22) */ 1124000727777607680000.0, /* fact(23)=25852016738884976640000 needs 56bit mantissa which is * impossible to represent exactly in IEEE 754 double which have * 53bit mantissa. */ }; enum {NFACT_TABLE = numberof(fact_table)}; double d; d = Get_Double(x); /* check for domain error */ if (isinf(d)) { if (signbit(d)) domain_error("gamma"); return DBL2NUM(HUGE_VAL); } if (d == 0.0) { return signbit(d) ? DBL2NUM(-HUGE_VAL) : DBL2NUM(HUGE_VAL); } if (d == floor(d)) { if (d < 0.0) domain_error("gamma"); if (1.0 <= d && d <= (double)NFACT_TABLE) { return DBL2NUM(fact_table[(int)d - 1]); } } return DBL2NUM(tgamma(d)); }```

### #hypot(x, y) ⇒ Float(private)

Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with sides `x` and `y`.

``````Math.hypot(3, 4)   #=> 5.0
``````

Returns:

 ``` 760 761 762 763 764``` ```# File 'math.c', line 760 static VALUE math_hypot(VALUE unused_obj, VALUE x, VALUE y) { return DBL2NUM(hypot(Get_Double(x), Get_Double(y))); }```

### #ldexp(fraction, exponent) ⇒ Float(private)

Returns the value of `fraction`*(2**`exponent`).

``````fraction, exponent = Math.frexp(1234)
Math.ldexp(fraction, exponent)   #=> 1234.0
``````

Returns:

 ``` 744 745 746 747 748``` ```# File 'math.c', line 744 static VALUE math_ldexp(VALUE unused_obj, VALUE x, VALUE n) { return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n))); }```

### #lgamma(x) ⇒ Array, ... (private)

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]
``````

Returns ].

Returns:

 ``` 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929``` ```# File 'math.c', line 911 static VALUE math_lgamma(VALUE unused_obj, VALUE x) { double d; int sign=1; VALUE v; d = Get_Double(x); /* check for domain error */ if (isinf(d)) { if (signbit(d)) domain_error("lgamma"); return rb_assoc_new(DBL2NUM(HUGE_VAL), INT2FIX(1)); } if (d == 0.0) { VALUE vsign = signbit(d) ? INT2FIX(-1) : INT2FIX(+1); return rb_assoc_new(DBL2NUM(HUGE_VAL), vsign); } v = DBL2NUM(lgamma_r(d, &sign)); return rb_assoc_new(v, INT2FIX(sign)); }```

### #log(x) ⇒ Float (private)#log(x, base) ⇒ Float (private)

Returns the logarithm of `x`. If additional second argument is given, it will be the base of logarithm. Otherwise it is `e` (for the natural logarithm).

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.log(0)          #=> -Infinity
Math.log(1)          #=> 0.0
Math.log(Math::E)    #=> 1.0
Math.log(Math::E**3) #=> 3.0
Math.log(12, 3)      #=> 2.2618595071429146
``````

 ``` 461 462 463 464 465``` ```# File 'math.c', line 461 static VALUE math_log(int argc, const VALUE *argv, VALUE unused_obj) { return rb_math_log(argc, argv); }```

### #log10(x) ⇒ Float(private)

Returns the base 10 logarithm of `x`.

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.log10(1)       #=> 0.0
Math.log10(10)      #=> 1.0
Math.log10(10**100) #=> 100.0
``````

Returns:

 ``` 571 572 573 574 575 576 577 578 579 580 581 582 583``` ```# File 'math.c', line 571 static VALUE math_log10(VALUE unused_obj, VALUE x) { size_t numbits; double d = get_double_rshift(x, &numbits); /* check for domain error */ if (d < 0.0) domain_error("log10"); /* check for pole error */ if (d == 0.0) return DBL2NUM(-HUGE_VAL); return DBL2NUM(log10(d) + numbits * log10(2)); /* log10(d * 2 ** numbits) */ }```

### #log2(x) ⇒ Float(private)

Returns the base 2 logarithm of `x`.

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.log2(1)      #=> 0.0
Math.log2(2)      #=> 1.0
Math.log2(32768)  #=> 15.0
Math.log2(65536)  #=> 16.0
``````

Returns:

 ``` 541 542 543 544 545 546 547 548 549 550 551 552 553``` ```# File 'math.c', line 541 static VALUE math_log2(VALUE unused_obj, VALUE x) { size_t numbits; double d = get_double_rshift(x, &numbits); /* check for domain error */ if (d < 0.0) domain_error("log2"); /* check for pole error */ if (d == 0.0) return DBL2NUM(-HUGE_VAL); return DBL2NUM(log2(d) + numbits); /* log2(d * 2 ** numbits) */ }```

### #sin(x) ⇒ Float(private)

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
``````

Returns:

 ``` 140 141 142 143 144``` ```# File 'math.c', line 140 static VALUE math_sin(VALUE unused_obj, VALUE x) { return DBL2NUM(sin(Get_Double(x))); }```

### #sinh(x) ⇒ Float(private)

Computes the hyperbolic sine of `x` (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.sinh(0) #=> 0.0
``````

Returns:

 ``` 285 286 287 288 289``` ```# File 'math.c', line 285 static VALUE math_sinh(VALUE unused_obj, VALUE x) { return DBL2NUM(sinh(Get_Double(x))); }```

### #sqrt(x) ⇒ Float(private)

Returns the non-negative square root of `x`.

Domain: [0, INFINITY)

Codomain:[0, INFINITY)

``````0.upto(10) {|x|
p [x, Math.sqrt(x), Math.sqrt(x)**2]
}
#=> [0, 0.0, 0.0]
#   [1, 1.0, 1.0]
#   [2, 1.4142135623731, 2.0]
#   [3, 1.73205080756888, 3.0]
#   [4, 2.0, 4.0]
#   [5, 2.23606797749979, 5.0]
#   [6, 2.44948974278318, 6.0]
#   [7, 2.64575131106459, 7.0]
#   [8, 2.82842712474619, 8.0]
#   [9, 3.0, 9.0]
#   [10, 3.16227766016838, 10.0]
``````

Note that the limited precision of floating point arithmetic might lead to surprising results:

``````Math.sqrt(10**46).to_i  #=> 99999999999999991611392 (!)
``````

Returns:

 ``` 620 621 622 623 624``` ```# File 'math.c', line 620 static VALUE math_sqrt(VALUE unused_obj, VALUE x) { return rb_math_sqrt(x); }```

### #tan(x) ⇒ Float(private)

Computes the tangent of `x` (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

``````Math.tan(0) #=> 0.0
``````

Returns:

 ``` 161 162 163 164 165``` ```# File 'math.c', line 161 static VALUE math_tan(VALUE unused_obj, VALUE x) { return DBL2NUM(tan(Get_Double(x))); }```

### #tanh(x) ⇒ Float(private)

Computes the hyperbolic tangent of `x` (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

``````Math.tanh(0) #=> 0.0
``````

Returns:

 ``` 320 321 322 323 324``` ```# File 'math.c', line 320 static VALUE math_tanh(VALUE unused_obj, VALUE x) { return DBL2NUM(tanh(Get_Double(x))); }```