• 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.

E
PI

### Public Class Methods

acos(x) => float click to toggle source

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

```
static VALUE
math_acos(VALUE obj, VALUE x)
{
double d0, d;

Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = acos(d0);
domain_check(d0, d, "acos");
return DBL2NUM(d);
}
```
acosh(x) => float click to toggle source

Computes the inverse hyperbolic cosine of x.

```
static VALUE
math_acosh(VALUE obj, VALUE x)
{
double d0, d;

Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = acosh(d0);
domain_check(d0, d, "acosh");
return DBL2NUM(d);
}
```
asin(x) => float click to toggle source

Computes the arc sine of x. Returns -{PI/2} .. {PI/2}.

```
static VALUE
math_asin(VALUE obj, VALUE x)
{
double d0, d;

Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = asin(d0);
domain_check(d0, d, "asin");
return DBL2NUM(d);
}
```
asinh(x) => float click to toggle source

Computes the inverse hyperbolic sine of x.

```
static VALUE
math_asinh(VALUE obj, VALUE x)
{
Need_Float(x);
return DBL2NUM(asinh(RFLOAT_VALUE(x)));
}
```
atan(x) => float click to toggle source

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

```
static VALUE
math_atan(VALUE obj, VALUE x)
{
Need_Float(x);
return DBL2NUM(atan(RFLOAT_VALUE(x)));
}
```
atan2(y, x) => float click to toggle source

Computes the arc tangent given y and x. Returns -PI..PI.

```
static VALUE
math_atan2(VALUE obj, VALUE y, VALUE x)
{
Need_Float2(y, x);
return DBL2NUM(atan2(RFLOAT_VALUE(y), RFLOAT_VALUE(x)));
}
```
atanh(x) => float click to toggle source

Computes the inverse hyperbolic tangent of x.

```
static VALUE
math_atanh(VALUE obj, VALUE x)
{
double d0, d;

Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = atanh(d0);
domain_check(d0, d, "atanh");
infinity_check(x, d, "atanh");
return DBL2NUM(d);
}
```
cbrt(numeric) => float click to toggle source

Returns the cube root of numeric.

```-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)
{
Need_Float(x);
return DBL2NUM(cbrt(RFLOAT_VALUE(x)));
}
```
cos(x) => float click to toggle source

Computes the cosine of x (expressed in radians). Returns -1..1.

```
static VALUE
math_cos(VALUE obj, VALUE x)
{
Need_Float(x);
return DBL2NUM(cos(RFLOAT_VALUE(x)));
}
```
cosh(x) => float click to toggle source

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

```
static VALUE
math_cosh(VALUE obj, VALUE x)
{
Need_Float(x);

return DBL2NUM(cosh(RFLOAT_VALUE(x)));
}
```
erf(x) => float click to toggle source

Calculates the error function of x.

```
static VALUE
math_erf(VALUE obj, VALUE x)
{
Need_Float(x);
return DBL2NUM(erf(RFLOAT_VALUE(x)));
}
```
erfc(x) => float click to toggle source

Calculates the complementary error function of x.

```
static VALUE
math_erfc(VALUE obj, VALUE x)
{
Need_Float(x);
return DBL2NUM(erfc(RFLOAT_VALUE(x)));
}
```
exp(x) => float click to toggle source

Returns e**x.

```
static VALUE
math_exp(VALUE obj, VALUE x)
{
Need_Float(x);
return DBL2NUM(exp(RFLOAT_VALUE(x)));
}
```
frexp(numeric) => [ fraction, exponent ] click to toggle source

Returns a two-element array containing the normalized fraction (a `Float`) and exponent (a `Fixnum`) of numeric.

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

Need_Float(x);

d = frexp(RFLOAT_VALUE(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 possibly has error in calculation.

```def fact(n) (1..n).inject(1) {|r,i| r*i } end
0.upto(25) {|i| p [i, Math.gamma(i+1), fact(i)] }
#=>
[0, 1.0, 1]
[1, 1.0, 1]
[2, 2.0, 2]
[3, 6.0, 6]
[4, 24.0, 24]
[5, 120.0, 120]
[6, 720.0, 720]
[7, 5040.0, 5040]
[8, 40320.0, 40320]
[9, 362880.0, 362880]
[10, 3628800.0, 3628800]
[11, 39916800.0, 39916800]
[12, 479001599.999999, 479001600]
[13, 6227020800.00001, 6227020800]
[14, 87178291199.9998, 87178291200]
[15, 1307674368000.0, 1307674368000]
[16, 20922789888000.0, 20922789888000]
[17, 3.55687428096001e+14, 355687428096000]
[18, 6.40237370572799e+15, 6402373705728000]
[19, 1.21645100408832e+17, 121645100408832000]
[20, 2.43290200817664e+18, 2432902008176640000]
[21, 5.10909421717094e+19, 51090942171709440000]
[22, 1.12400072777761e+21, 1124000727777607680000]
[23, 2.58520167388851e+22, 25852016738884976640000]
[24, 6.20448401733239e+23, 620448401733239439360000]
[25, 1.5511210043331e+25, 15511210043330985984000000]
```
```
static VALUE
math_gamma(VALUE obj, VALUE x)
{
double d0, d;
Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = tgamma(d0);
domain_check(d0, d, "gamma");
return DBL2NUM(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)
{
Need_Float2(x, y);
return DBL2NUM(hypot(RFLOAT_VALUE(x), RFLOAT_VALUE(y)));
}
```
ldexp(flt, int) → float click to toggle source

Returns the value of flt*(2**int).

```fraction, exponent = Math.frexp(1234)
Math.ldexp(fraction, exponent)   #=> 1234.0
```
```
static VALUE
math_ldexp(VALUE obj, VALUE x, VALUE n)
{
Need_Float(x);
return DBL2NUM(ldexp(RFLOAT_VALUE(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.

```
static VALUE
math_lgamma(VALUE obj, VALUE x)
{
double d0, d;
int sign;
VALUE v;
Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = lgamma_r(d0, &sign);
domain_check(d0, d, "lgamma");
v = DBL2NUM(d);
return rb_assoc_new(v, INT2FIX(sign));
}
```
log(numeric) => float click to toggle source
log(num,base) => float

Returns the natural logarithm of numeric. If additional second argument is given, it will be the base of logarithm.

```
static VALUE
math_log(int argc, VALUE *argv)
{
VALUE x, base;
double d0, d;

rb_scan_args(argc, argv, "11", &x, &base);
Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = log(d0);
if (argc == 2) {
Need_Float(base);
d /= log(RFLOAT_VALUE(base));
}
domain_check(d0, d, "log");
infinity_check(x, d, "log");
return DBL2NUM(d);
}
```
log10(numeric) => float click to toggle source

Returns the base 10 logarithm of numeric.

```
static VALUE
math_log10(VALUE obj, VALUE x)
{
double d0, d;

Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = log10(d0);
domain_check(d0, d, "log10");
infinity_check(x, d, "log10");
return DBL2NUM(d);
}
```
log2(numeric) => float click to toggle source

Returns the base 2 logarithm of numeric.

```
static VALUE
math_log2(VALUE obj, VALUE x)
{
double d0, d;

Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = log2(d0);
domain_check(d0, d, "log2");
infinity_check(x, d, "log2");
return DBL2NUM(d);
}
```
sin(x) => float click to toggle source

Computes the sine of x (expressed in radians). Returns -1..1.

```
static VALUE
math_sin(VALUE obj, VALUE x)
{
Need_Float(x);

return DBL2NUM(sin(RFLOAT_VALUE(x)));
}
```
sinh(x) => float click to toggle source

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

```
static VALUE
math_sinh(VALUE obj, VALUE x)
{
Need_Float(x);
return DBL2NUM(sinh(RFLOAT_VALUE(x)));
}
```
sqrt(numeric) => float click to toggle source

Returns the non-negative square root of numeric.

```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 d0, d;

Need_Float(x);
errno = 0;
d0 = RFLOAT_VALUE(x);
d = sqrt(d0);
domain_check(d0, d, "sqrt");
return DBL2NUM(d);
}
```
tan(x) => float click to toggle source

Returns the tangent of x (expressed in radians).

```
static VALUE
math_tan(VALUE obj, VALUE x)
{
Need_Float(x);

return DBL2NUM(tan(RFLOAT_VALUE(x)));
}
```
tanh() => float click to toggle source

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

```
static VALUE
math_tanh(VALUE obj, VALUE x)
{
Need_Float(x);
return DBL2NUM(tanh(RFLOAT_VALUE(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.