module 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
Public Class Methods
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 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));
}
Computes the inverse hyperbolic cosine of x.
Domain: [1, INFINITY)
Codomain: [0, INFINITY)
Math.acosh(1) #=> 0.0
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));
}
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 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));
}
Computes the inverse hyperbolic sine of x.
Domain: (-INFINITY, INFINITY)
Codomain: (-INFINITY, INFINITY)
Math.asinh(1) #=> 0.881373587019543
static VALUE
math_asinh(VALUE unused_obj, VALUE x)
{
return DBL2NUM(asinh(Get_Double(x)));
}
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 unused_obj, VALUE x)
{
return DBL2NUM(atan(Get_Double(x)));
}
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 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));
}
Computes the inverse hyperbolic tangent of x.
Domain: (-1, 1)
Codomain: (-INFINITY, INFINITY)
Math.atanh(1) #=> Infinity
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));
}
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 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);
}
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 unused_obj, VALUE x)
{
return DBL2NUM(cos(Get_Double(x)));
}
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 unused_obj, VALUE x)
{
return DBL2NUM(cosh(Get_Double(x)));
}
Calculates the error function of x.
Domain: (-INFINITY, INFINITY)
Codomain: (-1, 1)
Math.erf(0) #=> 0.0
static VALUE
math_erf(VALUE unused_obj, VALUE x)
{
return DBL2NUM(erf(Get_Double(x)));
}
Calculates the complementary error function of x.
Domain: (-INFINITY, INFINITY)
Codomain: (0, 2)
Math.erfc(0) #=> 1.0
static VALUE
math_erfc(VALUE unused_obj, VALUE x)
{
return DBL2NUM(erfc(Get_Double(x)));
}
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 unused_obj, VALUE x)
{
return DBL2NUM(exp(Get_Double(x)));
}
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
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));
}
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 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));
}
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 unused_obj, VALUE x, VALUE y)
{
return DBL2NUM(hypot(Get_Double(x), Get_Double(y)));
}
Returns the value of fraction*(2**exponent).
fraction, exponent = Math.frexp(1234) Math.ldexp(fraction, exponent) #=> 1234.0
static VALUE
math_ldexp(VALUE unused_obj, VALUE x, VALUE n)
{
return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n)));
}
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]
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));
}
static VALUE math_log(int, const VALUE *, VALUE))
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 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) */
}
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 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) */
}
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 unused_obj, VALUE x)
{
return DBL2NUM(sin(Get_Double(x)));
}
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 unused_obj, VALUE x)
{
return DBL2NUM(sinh(Get_Double(x)));
}
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 (!)
See also BigDecimal#sqrt and Integer.sqrt.
static VALUE
math_sqrt(VALUE unused_obj, VALUE x)
{
return rb_math_sqrt(x);
}
Computes the tangent of x (expressed in radians).
Domain: (-INFINITY, INFINITY)
Codomain: (-INFINITY, INFINITY)
Math.tan(0) #=> 0.0
static VALUE
math_tan(VALUE unused_obj, VALUE x)
{
return DBL2NUM(tan(Get_Double(x)));
}
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 unused_obj, VALUE x)
{
return DBL2NUM(tanh(Get_Double(x)));
}