• math.c

Quicksearch

Math

The Math module contains module functions for basic trigonometric and transcendental functions. See class Float for a list of constants that define Ruby's floating point accuracy.

Domains and codomains are given only for real (not complex) numbers.

Constants

E

Definition of the mathematical constant E (e) as a Float number.

PI

Definition of the mathematical constant PI as a Float number.

Public Class Methods

acos(x) → Float click to toggle source

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

Domain: [-1, 1]

Codomain: [0, PI]

```Math.acos(0) == Math::PI/2  #=> true
```
```
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 click to toggle source

Computes the inverse hyperbolic cosine of `x`.

Domain: [1, INFINITY)

Codomain: [0, INFINITY)

```Math.acosh(1) #=> 0.0
```
```
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 click to toggle source

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
```
```
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 click to toggle source

Computes the inverse hyperbolic sine of `x`.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

```Math.asinh(1) #=> 0.881373587019543
```
```
static VALUE
math_asinh(VALUE obj, VALUE x)
{
return DBL2NUM(asinh(Get_Double(x)));
}
```
atan(x) → Float click to toggle source

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

Domain: (-INFINITY, INFINITY)

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

```Math.atan(0) #=> 0.0
```
```
static VALUE
math_atan(VALUE obj, VALUE x)
{
return DBL2NUM(atan(Get_Double(x)));
}
```
atan2(y, x) → Float click to toggle source

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
```
```
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 click to toggle source

Computes the inverse hyperbolic tangent of `x`.

Domain: (-1, 1)

Codomain: (-INFINITY, INFINITY)

```Math.atanh(1) #=> Infinity
```
```
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 click to toggle source

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]
```
```
static VALUE
math_cbrt(VALUE obj, VALUE x)
{
return DBL2NUM(cbrt(Get_Double(x)));
}
```
cos(x) → Float click to toggle source

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
```
```
static VALUE
math_cos(VALUE obj, VALUE x)
{
return DBL2NUM(cos(Get_Double(x)));
}
```
cosh(x) → Float click to toggle source

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

Domain: (-INFINITY, INFINITY)

Codomain: [1, INFINITY)

```Math.cosh(0) #=> 1.0
```
```
static VALUE
math_cosh(VALUE obj, VALUE x)
{
return DBL2NUM(cosh(Get_Double(x)));
}
```
erf(x) → Float click to toggle source

Calculates the error function of `x`.

Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

```Math.erf(0) #=> 0.0
```
```
static VALUE
math_erf(VALUE obj, VALUE x)
{
return DBL2NUM(erf(Get_Double(x)));
}
```
erfc(x) → Float click to toggle source

Calculates the complementary error function of x.

Domain: (-INFINITY, INFINITY)

Codomain: (0, 2)

```Math.erfc(0) #=> 1.0
```
```
static VALUE
math_erfc(VALUE obj, VALUE x)
{
return DBL2NUM(erfc(Get_Double(x)));
}
```
exp(x) → Float click to toggle source

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
```
```
static VALUE
math_exp(VALUE obj, VALUE x)
{
return DBL2NUM(exp(Get_Double(x)));
}
```
frexp(x) → [fraction, exponent] click to toggle source

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
```
```
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 click to toggle source

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]
```
```
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 click to toggle source

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

```Math.hypot(3, 4)   #=> 5.0
```
```
static VALUE
math_hypot(VALUE obj, VALUE x, VALUE y)
{
return DBL2NUM(hypot(Get_Double(x), Get_Double(y)));
}
```
ldexp(fraction, exponent) → float click to toggle source

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

```fraction, exponent = Math.frexp(1234)
Math.ldexp(fraction, exponent)   #=> 1234.0
```
```
static VALUE
math_ldexp(VALUE obj, VALUE x, VALUE n)
{
return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n)));
}
```
lgamma(x) → [float, -1 or 1] click to toggle source

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

::lgamma is same as

```[Math.log(Math.gamma(x).abs), Math.gamma(x) < 0 ? -1 : 1]
```

but avoid overflow by ::gamma for large x.

```Math.lgamma(0) #=> [Infinity, 1]
```
```
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 click to toggle source
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
```
```
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 click to toggle source

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
```
```
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 click to toggle source

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
```
```
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 click to toggle source

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
```
```
static VALUE
math_sin(VALUE obj, VALUE x)
{
return DBL2NUM(sin(Get_Double(x)));
}
```
sinh(x) → Float click to toggle source

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

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

```Math.sinh(0) #=> 0.0
```
```
static VALUE
math_sinh(VALUE obj, VALUE x)
{
return DBL2NUM(sinh(Get_Double(x)));
}
```
sqrt(x) → Float click to toggle source

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]
```
```
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 click to toggle source

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

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

```Math.tan(0) #=> 0.0
```
```
static VALUE
math_tan(VALUE obj, VALUE x)
{
return DBL2NUM(tan(Get_Double(x)));
}
```
tanh(x) → Float click to toggle source

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

Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

```Math.tanh(0) #=> 0.0
```
```
static VALUE
math_tanh(VALUE obj, VALUE x)
{
return DBL2NUM(tanh(Get_Double(x)));
}
```

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.