Module Math
In: math.c
lib/mathn.rb

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.

Methods

acos   acosh   asin   asinh   atan   atan2   atanh   cbrt   cos   cosh   erf   erfc   exp   frexp   gamma   hypot   ldexp   lgamma   log   log10   log2   rsqrt   sin   sinh   sqrt   sqrt   tan   tanh  

Constants

PI = DOUBLE2NUM(M_PI)
PI = DOUBLE2NUM(atan(1.0)*4.0)
E = DOUBLE2NUM(M_E)
E = DOUBLE2NUM(exp(1.0))

Public Class methods

Math.acos(x) => float

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

Math.acosh(x) => float

Computes the inverse hyperbolic cosine of x.

Math.asin(x) => float

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

Math.asinh(x) => float

Computes the inverse hyperbolic sine of x.

Math.atan(x) => float

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

Math.atan2(y, x) => float

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

Math.atanh(x) => float

Computes the inverse hyperbolic tangent of x.

Math.cbrt(numeric) => float

Returns the cube root of numeric.

Math.cos(x) => float

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

Math.cosh(x) => float

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

Math.erf(x) => float

Calculates the error function of x.

Math.erfc(x) => float

Calculates the complementary error function of x.

Math.frexp(numeric) => [ fraction, exponent ]

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
Math.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 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]
Math.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
Math.ldexp(flt, int) → float

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

   fraction, exponent = Math.frexp(1234)
   Math.ldexp(fraction, exponent)   #=> 1234.0
Math.lgamma(x) => [float, -1 or 1]

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.log(numeric) => float
Math.log(num,base) => float

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

Math.log10(numeric) => float

Returns the base 10 logarithm of numeric.

Math.log2(numeric) => float

Returns the base 2 logarithm of numeric.

Math.sin(x) => float

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

Math.sinh(x) => float

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

Math.sqrt(numeric) => float

Returns the non-negative square root of numeric.

Math.tan(x) => float

Returns the tangent of x (expressed in radians).

Math.tanh() => float

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

Public Instance methods

[Validate]

ruby-doc.org is hosted and run by James Britt and Happy Camper Studios, a Ruby application development company in Phoenix, Arizona. Ruby-doc.org was created in 2002 to promote the Ruby language and to help other Ruby hackers.

Documentation content on ruby-doc.org is provided by remarkable members of the Ruby community.

For more information on the Ruby programming language, visit ruby-lang.org.

Want to help improve Ruby's API docs? See Ruby Documentation Guidelines.