• 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(obj, x)
VALUE obj, x;
{
double d;

Need_Float(x);
errno = 0;
d = acos(RFLOAT(x)->value);
domain_check(d, "acos");
return rb_float_new(d);
}
```
acosh(x) => float click to toggle source

Computes the inverse hyperbolic cosine of x.

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

Need_Float(x);
errno = 0;
d = acosh(RFLOAT(x)->value);
domain_check(d, "acosh");
return rb_float_new(d);
}
```
asin(x) => float click to toggle source

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

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

Need_Float(x);
errno = 0;
d = asin(RFLOAT(x)->value);
domain_check(d, "asin");
return rb_float_new(d);
}
```
asinh(x) => float click to toggle source

Computes the inverse hyperbolic sine of x.

```
static VALUE
math_asinh(obj, x)
VALUE obj, x;
{
Need_Float(x);
return rb_float_new(asinh(RFLOAT(x)->value));
}
```
atan(x) => float click to toggle source

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

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

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

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

Computes the inverse hyperbolic tangent of x.

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

Need_Float(x);
errno = 0;
d = atanh(RFLOAT(x)->value);
domain_check(d, "atanh");
return rb_float_new(d);
}
```
cos(x) => float click to toggle source

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

```
static VALUE
math_cos(obj, x)
VALUE obj, x;
{
Need_Float(x);
return rb_float_new(cos(RFLOAT(x)->value));
}
```
cosh(x) => float click to toggle source

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

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

return rb_float_new(cosh(RFLOAT(x)->value));
}
```
erf(x) => float click to toggle source

Calculates the error function of x.

```
static VALUE
math_erf(obj, x)
VALUE obj, x;
{
Need_Float(x);
return rb_float_new(erf(RFLOAT(x)->value));
}
```
erfc(x) => float click to toggle source

Calculates the complementary error function of x.

```
static VALUE
math_erfc(obj, x)
VALUE obj, x;
{
Need_Float(x);
return rb_float_new(erfc(RFLOAT(x)->value));
}
```
exp(x) => float click to toggle source

Returns e**x.

```
static VALUE
math_exp(obj, x)
VALUE obj, x;
{
Need_Float(x);
return rb_float_new(exp(RFLOAT(x)->value));
}
```
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(obj, x)
VALUE obj, x;
{
double d;
int exp;

Need_Float(x);

d = frexp(RFLOAT(x)->value, &exp);
return rb_assoc_new(rb_float_new(d), INT2NUM(exp));
}
```
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(obj, x, y)
VALUE obj, x, y;
{
Need_Float2(x, y);
return rb_float_new(hypot(RFLOAT(x)->value, RFLOAT(y)->value));
}
```
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(obj, x, n)
VALUE obj, x, n;
{
Need_Float(x);
return rb_float_new(ldexp(RFLOAT(x)->value, NUM2INT(n)));
}
```
log(numeric) => float click to toggle source

Returns the natural logarithm of numeric.

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

Need_Float(x);
errno = 0;
d = log(RFLOAT(x)->value);
domain_check(d, "log");
return rb_float_new(d);
}
```
log10(numeric) => float click to toggle source

Returns the base 10 logarithm of numeric.

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

Need_Float(x);
errno = 0;
d = log10(RFLOAT(x)->value);
domain_check(d, "log10");
return rb_float_new(d);
}
```
sin(x) => float click to toggle source

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

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

return rb_float_new(sin(RFLOAT(x)->value));
}
```
sinh(x) => float click to toggle source

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

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

Returns the non-negative square root of numeric.

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

Need_Float(x);
errno = 0;
d = sqrt(RFLOAT(x)->value);
domain_check(d, "sqrt");
return rb_float_new(d);
}
```
tan(x) => float click to toggle source

Returns the tangent of x (expressed in radians).

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

return rb_float_new(tan(RFLOAT(x)->value));
}
```
tanh() => float click to toggle source

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

```
static VALUE
math_tanh(obj, x)
VALUE obj, x;
{
Need_Float(x);
return rb_float_new(tanh(RFLOAT(x)->value));
}
```

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.