# Module: Math

Defined in:
math.c

## Defined Under Namespace

Classes: DomainError

## Constant Summary

PI =

Definition of the mathematical constant PI as a Float number.

```DBL2NUM(atan(1.0)*4.0)
```
E =

Definition of the mathematical constant E (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 (a Fixnum) 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 (a Fixnum) 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:

 ``` 169 170 171 172 173 174 175 176 177 178``` ```# File 'math.c', line 169 static VALUE math_acos(VALUE 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:

 ``` 321 322 323 324 325 326 327 328 329 330``` ```# File 'math.c', line 321 static VALUE math_acosh(VALUE 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:

 ``` 193 194 195 196 197 198 199 200 201 202``` ```# File 'math.c', line 193 static VALUE math_asin(VALUE 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:

 ``` 346 347 348 349 350``` ```# File 'math.c', line 346 static VALUE math_asinh(VALUE 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:

 ``` 217 218 219 220 221``` ```# File 'math.c', line 217 static VALUE math_atan(VALUE 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:

 ``` 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89``` ```# File 'math.c', line 62 static VALUE math_atan2(VALUE 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:

 ``` 366 367 368 369 370 371 372 373 374 375 376 377 378``` ```# File 'math.c', line 366 static VALUE math_atanh(VALUE 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(-INFINITY); if (d == +1.0) return DBL2NUM(+INFINITY); 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:

 ``` 638 639 640 641 642``` ```# File 'math.c', line 638 static VALUE math_cbrt(VALUE obj, VALUE x) { return DBL2NUM(cbrt(Get_Double(x))); } ```

### .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:

 ``` 107 108 109 110 111``` ```# File 'math.c', line 107 static VALUE math_cos(VALUE 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:

 ``` 245 246 247 248 249``` ```# File 'math.c', line 245 static VALUE math_cosh(VALUE 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:

 ``` 711 712 713 714 715``` ```# File 'math.c', line 711 static VALUE math_erf(VALUE 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:

 ``` 731 732 733 734 735``` ```# File 'math.c', line 731 static VALUE math_erfc(VALUE 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:

 ``` 396 397 398 399 400``` ```# File 'math.c', line 396 static VALUE math_exp(VALUE 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 (a Fixnum) of x.

``````fraction, exponent = Math.frexp(1234)   #=> [0.6025390625, 11]
fraction * 2**exponent                  #=> 1234.0
``````

Returns:

 ``` 655 656 657 658 659 660 661 662 663``` ```# File 'math.c', line 655 static VALUE math_frexp(VALUE 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:

 ``` 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852``` ```# File 'math.c', line 809 static VALUE math_gamma(VALUE 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) && signbit(d)) domain_error("gamma"); 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:

 ``` 691 692 693 694 695``` ```# File 'math.c', line 691 static VALUE math_hypot(VALUE 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:

 ``` 675 676 677 678 679``` ```# File 'math.c', line 675 static VALUE math_ldexp(VALUE 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:

 ``` 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882``` ```# File 'math.c', line 868 static VALUE math_lgamma(VALUE 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(INFINITY), INT2FIX(1)); } 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
``````

 ``` 434 435 436 437 438 439 440 441 442 443 444 445 446``` ```# File 'math.c', line 434 static VALUE math_log(int argc, const VALUE *argv, VALUE obj) { VALUE x, base; double d; rb_scan_args(argc, argv, "11", &x, &base); d = math_log1(x); if (argc == 2) { d /= math_log1(base); } return DBL2NUM(d); } ```

### .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:

 ``` 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563``` ```# File 'math.c', line 541 static VALUE math_log10(VALUE obj, VALUE x) { double d; size_t numbits; if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) && DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) { numbits -= DBL_MANT_DIG; x = rb_big_rshift(x, SIZET2NUM(numbits)); } else { numbits = 0; } d = Get_Double(x); /* check for domain error */ if (d < 0.0) domain_error("log10"); /* check for pole error */ if (d == 0.0) return DBL2NUM(-INFINITY); 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:

 ``` 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523``` ```# File 'math.c', line 501 static VALUE math_log2(VALUE obj, VALUE x) { double d; size_t numbits; if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) && DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) { numbits -= DBL_MANT_DIG; x = rb_big_rshift(x, SIZET2NUM(numbits)); } else { numbits = 0; } d = Get_Double(x); /* check for domain error */ if (d < 0.0) domain_error("log2"); /* check for pole error */ if (d == 0.0) return DBL2NUM(-INFINITY); 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:

 ``` 128 129 130 131 132``` ```# File 'math.c', line 128 static VALUE math_sin(VALUE 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:

 ``` 273 274 275 276 277``` ```# File 'math.c', line 273 static VALUE math_sinh(VALUE 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]
``````

Returns:

 ``` 591 592 593 594 595 596 597 598 599 600 601``` ```# File 'math.c', line 591 static VALUE math_sqrt(VALUE obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < 0.0) domain_error("sqrt"); if (d == 0.0) return DBL2NUM(0.0); return DBL2NUM(sqrt(d)); } ```

### .tan(x) ⇒ Float

Computes the tangent of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

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

Returns:

 ``` 149 150 151 152 153``` ```# File 'math.c', line 149 static VALUE math_tan(VALUE 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:

 ``` 301 302 303 304 305``` ```# File 'math.c', line 301 static VALUE math_tanh(VALUE 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:

 ``` 169 170 171 172 173 174 175 176 177 178``` ```# File 'math.c', line 169 static VALUE math_acos(VALUE 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:

 ``` 321 322 323 324 325 326 327 328 329 330``` ```# File 'math.c', line 321 static VALUE math_acosh(VALUE 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:

 ``` 193 194 195 196 197 198 199 200 201 202``` ```# File 'math.c', line 193 static VALUE math_asin(VALUE 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:

 ``` 346 347 348 349 350``` ```# File 'math.c', line 346 static VALUE math_asinh(VALUE 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:

 ``` 217 218 219 220 221``` ```# File 'math.c', line 217 static VALUE math_atan(VALUE 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:

 ``` 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89``` ```# File 'math.c', line 62 static VALUE math_atan2(VALUE 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:

 ``` 366 367 368 369 370 371 372 373 374 375 376 377 378``` ```# File 'math.c', line 366 static VALUE math_atanh(VALUE 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(-INFINITY); if (d == +1.0) return DBL2NUM(+INFINITY); 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:

 ``` 638 639 640 641 642``` ```# File 'math.c', line 638 static VALUE math_cbrt(VALUE obj, VALUE x) { return DBL2NUM(cbrt(Get_Double(x))); } ```

### #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:

 ``` 107 108 109 110 111``` ```# File 'math.c', line 107 static VALUE math_cos(VALUE 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:

 ``` 245 246 247 248 249``` ```# File 'math.c', line 245 static VALUE math_cosh(VALUE 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:

 ``` 711 712 713 714 715``` ```# File 'math.c', line 711 static VALUE math_erf(VALUE 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:

 ``` 731 732 733 734 735``` ```# File 'math.c', line 731 static VALUE math_erfc(VALUE 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:

 ``` 396 397 398 399 400``` ```# File 'math.c', line 396 static VALUE math_exp(VALUE 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 (a Fixnum) of x.

``````fraction, exponent = Math.frexp(1234)   #=> [0.6025390625, 11]
fraction * 2**exponent                  #=> 1234.0
``````

Returns:

 ``` 655 656 657 658 659 660 661 662 663``` ```# File 'math.c', line 655 static VALUE math_frexp(VALUE 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:

 ``` 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852``` ```# File 'math.c', line 809 static VALUE math_gamma(VALUE 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) && signbit(d)) domain_error("gamma"); 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:

 ``` 691 692 693 694 695``` ```# File 'math.c', line 691 static VALUE math_hypot(VALUE 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:

 ``` 675 676 677 678 679``` ```# File 'math.c', line 675 static VALUE math_ldexp(VALUE 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:

 ``` 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882``` ```# File 'math.c', line 868 static VALUE math_lgamma(VALUE 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(INFINITY), INT2FIX(1)); } 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
``````

 ``` 434 435 436 437 438 439 440 441 442 443 444 445 446``` ```# File 'math.c', line 434 static VALUE math_log(int argc, const VALUE *argv, VALUE obj) { VALUE x, base; double d; rb_scan_args(argc, argv, "11", &x, &base); d = math_log1(x); if (argc == 2) { d /= math_log1(base); } return DBL2NUM(d); } ```

### #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:

 ``` 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563``` ```# File 'math.c', line 541 static VALUE math_log10(VALUE obj, VALUE x) { double d; size_t numbits; if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) && DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) { numbits -= DBL_MANT_DIG; x = rb_big_rshift(x, SIZET2NUM(numbits)); } else { numbits = 0; } d = Get_Double(x); /* check for domain error */ if (d < 0.0) domain_error("log10"); /* check for pole error */ if (d == 0.0) return DBL2NUM(-INFINITY); 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:

 ``` 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523``` ```# File 'math.c', line 501 static VALUE math_log2(VALUE obj, VALUE x) { double d; size_t numbits; if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) && DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) { numbits -= DBL_MANT_DIG; x = rb_big_rshift(x, SIZET2NUM(numbits)); } else { numbits = 0; } d = Get_Double(x); /* check for domain error */ if (d < 0.0) domain_error("log2"); /* check for pole error */ if (d == 0.0) return DBL2NUM(-INFINITY); 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:

 ``` 128 129 130 131 132``` ```# File 'math.c', line 128 static VALUE math_sin(VALUE 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:

 ``` 273 274 275 276 277``` ```# File 'math.c', line 273 static VALUE math_sinh(VALUE 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]
``````

Returns:

 ``` 591 592 593 594 595 596 597 598 599 600 601``` ```# File 'math.c', line 591 static VALUE math_sqrt(VALUE obj, VALUE x) { double d; d = Get_Double(x); /* check for domain error */ if (d < 0.0) domain_error("sqrt"); if (d == 0.0) return DBL2NUM(0.0); return DBL2NUM(sqrt(d)); } ```

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

Computes the tangent of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

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

Returns:

 ``` 149 150 151 152 153``` ```# File 'math.c', line 149 static VALUE math_tan(VALUE 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:

 ``` 301 302 303 304 305``` ```# File 'math.c', line 301 static VALUE math_tanh(VALUE obj, VALUE x) { return DBL2NUM(tanh(Get_Double(x))); } ```