File: C:/Ruby27-x64/share/doc/ruby/html/Math.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>module Math - RDoc Documentation</title>
<script type="text/javascript">
var rdoc_rel_prefix = "./";
var index_rel_prefix = "./";
</script>
<script src="./js/navigation.js" defer></script>
<script src="./js/search.js" defer></script>
<script src="./js/search_index.js" defer></script>
<script src="./js/searcher.js" defer></script>
<script src="./js/darkfish.js" defer></script>
<link href="./css/fonts.css" rel="stylesheet">
<link href="./css/rdoc.css" rel="stylesheet">
<body id="top" role="document" class="module">
<nav role="navigation">
<div id="project-navigation">
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
<h2>
<a href="./index.html" rel="home">Home</a>
</h2>
<div id="table-of-contents-navigation">
<a href="./table_of_contents.html#pages">Pages</a>
<a href="./table_of_contents.html#classes">Classes</a>
<a href="./table_of_contents.html#methods">Methods</a>
</div>
</div>
<div id="search-section" role="search" class="project-section initially-hidden">
<form action="#" method="get" accept-charset="utf-8">
<div id="search-field-wrapper">
<input id="search-field" role="combobox" aria-label="Search"
aria-autocomplete="list" aria-controls="search-results"
type="text" name="search" placeholder="Search" spellcheck="false"
title="Type to search, Up and Down to navigate, Enter to load">
</div>
<ul id="search-results" aria-label="Search Results"
aria-busy="false" aria-expanded="false"
aria-atomic="false" class="initially-hidden"></ul>
</form>
</div>
</div>
<div id="class-metadata">
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li ><a href="#method-c-acos">::acos</a>
<li ><a href="#method-c-acosh">::acosh</a>
<li ><a href="#method-c-asin">::asin</a>
<li ><a href="#method-c-asinh">::asinh</a>
<li ><a href="#method-c-atan">::atan</a>
<li ><a href="#method-c-atan2">::atan2</a>
<li ><a href="#method-c-atanh">::atanh</a>
<li ><a href="#method-c-cbrt">::cbrt</a>
<li ><a href="#method-c-cos">::cos</a>
<li ><a href="#method-c-cosh">::cosh</a>
<li ><a href="#method-c-erf">::erf</a>
<li ><a href="#method-c-erfc">::erfc</a>
<li ><a href="#method-c-exp">::exp</a>
<li ><a href="#method-c-frexp">::frexp</a>
<li ><a href="#method-c-gamma">::gamma</a>
<li ><a href="#method-c-hypot">::hypot</a>
<li ><a href="#method-c-ldexp">::ldexp</a>
<li ><a href="#method-c-lgamma">::lgamma</a>
<li ><a href="#method-c-log">::log</a>
<li ><a href="#method-c-log10">::log10</a>
<li ><a href="#method-c-log2">::log2</a>
<li ><a href="#method-c-sin">::sin</a>
<li ><a href="#method-c-sinh">::sinh</a>
<li ><a href="#method-c-sqrt">::sqrt</a>
<li ><a href="#method-c-tan">::tan</a>
<li ><a href="#method-c-tanh">::tanh</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="module-Math">
<h1 id="module-Math" class="module">
module Math
</h1>
<section class="description">
<p>The <a href="Math.html"><code>Math</code></a> module contains module functions for basic trigonometric and transcendental functions. See class <a href="Float.html"><code>Float</code></a> for a list of constants that define Ruby's floating point accuracy.</p>
<p>Domains and codomains are given only for real (not complex) numbers.</p>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section class="constants-list">
<header>
<h3>Constants</h3>
</header>
<dl>
<dt id="E">E
<dd><p>Definition of the mathematical constant <a href="Math.html#E"><code>E</code></a> for Euler's number (e) as a <a href="Float.html"><code>Float</code></a> number.</p>
<dt id="PI">PI
<dd><p>Definition of the mathematical constant <a href="Math.html#PI"><code>PI</code></a> as a <a href="Float.html"><code>Float</code></a> number.</p>
</dl>
</section>
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-acos" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
acos(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the arc cosine of <code>x</code>. Returns 0..PI.</p>
<p>Domain: [-1, 1]</p>
<p>Codomain: [0, PI]</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">acos</span>(<span class="ruby-value">0</span>) <span class="ruby-operator">==</span> <span class="ruby-constant">Math</span><span class="ruby-operator">::</span><span class="ruby-constant">PI</span><span class="ruby-operator">/</span><span class="ruby-value">2</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="acos-source">
<pre>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));
}</pre>
</div>
</div>
</div>
<div id="method-c-acosh" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
acosh(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the inverse hyperbolic cosine of <code>x</code>.</p>
<p>Domain: [1, INFINITY)</p>
<p>Codomain: [0, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">acosh</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 0.0</span>
</pre>
<div class="method-source-code" id="acosh-source">
<pre>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));
}</pre>
</div>
</div>
</div>
<div id="method-c-asin" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
asin(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the arc sine of <code>x</code>. Returns -PI/2..PI/2.</p>
<p>Domain: [-1, -1]</p>
<p>Codomain: [-PI/2, PI/2]</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">asin</span>(<span class="ruby-value">1</span>) <span class="ruby-operator">==</span> <span class="ruby-constant">Math</span><span class="ruby-operator">::</span><span class="ruby-constant">PI</span><span class="ruby-operator">/</span><span class="ruby-value">2</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="asin-source">
<pre>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));
}</pre>
</div>
</div>
</div>
<div id="method-c-asinh" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
asinh(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the inverse hyperbolic sine of <code>x</code>.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (-INFINITY, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">asinh</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 0.881373587019543</span>
</pre>
<div class="method-source-code" id="asinh-source">
<pre>static VALUE
math_asinh(VALUE unused_obj, VALUE x)
{
return DBL2NUM(asinh(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-atan" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
atan(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the arc tangent of <code>x</code>. Returns -PI/2..PI/2.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (-PI/2, PI/2)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 0.0</span>
</pre>
<div class="method-source-code" id="atan-source">
<pre>static VALUE
math_atan(VALUE unused_obj, VALUE x)
{
return DBL2NUM(atan(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-atan2" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
atan2(y, x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the arc tangent given <code>y</code> and <code>x</code>. Returns a <a href="Float.html"><code>Float</code></a> 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 (<code>x</code>, <code>y</code>) on it.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: [-PI, PI]</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">-0.0</span>, <span class="ruby-value">-1.0</span>) <span class="ruby-comment">#=> -3.141592653589793</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">-1.0</span>, <span class="ruby-value">-1.0</span>) <span class="ruby-comment">#=> -2.356194490192345</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">-1.0</span>, <span class="ruby-value">0.0</span>) <span class="ruby-comment">#=> -1.5707963267948966</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">-1.0</span>, <span class="ruby-value">1.0</span>) <span class="ruby-comment">#=> -0.7853981633974483</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">-0.0</span>, <span class="ruby-value">1.0</span>) <span class="ruby-comment">#=> -0.0</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">0.0</span>, <span class="ruby-value">1.0</span>) <span class="ruby-comment">#=> 0.0</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">1.0</span>, <span class="ruby-value">1.0</span>) <span class="ruby-comment">#=> 0.7853981633974483</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">1.0</span>, <span class="ruby-value">0.0</span>) <span class="ruby-comment">#=> 1.5707963267948966</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">1.0</span>, <span class="ruby-value">-1.0</span>) <span class="ruby-comment">#=> 2.356194490192345</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-value">0.0</span>, <span class="ruby-value">-1.0</span>) <span class="ruby-comment">#=> 3.141592653589793</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-constant">INFINITY</span>, <span class="ruby-constant">INFINITY</span>) <span class="ruby-comment">#=> 0.7853981633974483</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-constant">INFINITY</span>, <span class="ruby-operator">-</span><span class="ruby-constant">INFINITY</span>) <span class="ruby-comment">#=> 2.356194490192345</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-operator">-</span><span class="ruby-constant">INFINITY</span>, <span class="ruby-constant">INFINITY</span>) <span class="ruby-comment">#=> -0.7853981633974483</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">atan2</span>(<span class="ruby-operator">-</span><span class="ruby-constant">INFINITY</span>, <span class="ruby-operator">-</span><span class="ruby-constant">INFINITY</span>) <span class="ruby-comment">#=> -2.356194490192345</span>
</pre>
<div class="method-source-code" id="atan2-source">
<pre>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));
}</pre>
</div>
</div>
</div>
<div id="method-c-atanh" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
atanh(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the inverse hyperbolic tangent of <code>x</code>.</p>
<p>Domain: (-1, 1)</p>
<p>Codomain: (-INFINITY, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">atanh</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> Infinity</span>
</pre>
<div class="method-source-code" id="atanh-source">
<pre>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));
}</pre>
</div>
</div>
</div>
<div id="method-c-cbrt" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
cbrt(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the cube root of <code>x</code>.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (-INFINITY, INFINITY)</p>
<pre class="ruby"><span class="ruby-value">-9</span>.<span class="ruby-identifier">upto</span>(<span class="ruby-value">9</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">p</span> [<span class="ruby-identifier">x</span>, <span class="ruby-constant">Math</span>.<span class="ruby-identifier">cbrt</span>(<span class="ruby-identifier">x</span>), <span class="ruby-constant">Math</span>.<span class="ruby-identifier">cbrt</span>(<span class="ruby-identifier">x</span>)<span class="ruby-operator">**</span><span class="ruby-value">3</span>]
}
<span class="ruby-comment">#=> [-9, -2.0800838230519, -9.0]</span>
<span class="ruby-comment"># [-8, -2.0, -8.0]</span>
<span class="ruby-comment"># [-7, -1.91293118277239, -7.0]</span>
<span class="ruby-comment"># [-6, -1.81712059283214, -6.0]</span>
<span class="ruby-comment"># [-5, -1.7099759466767, -5.0]</span>
<span class="ruby-comment"># [-4, -1.5874010519682, -4.0]</span>
<span class="ruby-comment"># [-3, -1.44224957030741, -3.0]</span>
<span class="ruby-comment"># [-2, -1.25992104989487, -2.0]</span>
<span class="ruby-comment"># [-1, -1.0, -1.0]</span>
<span class="ruby-comment"># [0, 0.0, 0.0]</span>
<span class="ruby-comment"># [1, 1.0, 1.0]</span>
<span class="ruby-comment"># [2, 1.25992104989487, 2.0]</span>
<span class="ruby-comment"># [3, 1.44224957030741, 3.0]</span>
<span class="ruby-comment"># [4, 1.5874010519682, 4.0]</span>
<span class="ruby-comment"># [5, 1.7099759466767, 5.0]</span>
<span class="ruby-comment"># [6, 1.81712059283214, 6.0]</span>
<span class="ruby-comment"># [7, 1.91293118277239, 7.0]</span>
<span class="ruby-comment"># [8, 2.0, 8.0]</span>
<span class="ruby-comment"># [9, 2.0800838230519, 9.0]</span>
</pre>
<div class="method-source-code" id="cbrt-source">
<pre>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);
}</pre>
</div>
</div>
</div>
<div id="method-c-cos" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
cos(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the cosine of <code>x</code> (expressed in radians). Returns a <a href="Float.html"><code>Float</code></a> in the range -1.0..1.0.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: [-1, 1]</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">cos</span>(<span class="ruby-constant">Math</span><span class="ruby-operator">::</span><span class="ruby-constant">PI</span>) <span class="ruby-comment">#=> -1.0</span>
</pre>
<div class="method-source-code" id="cos-source">
<pre>static VALUE
math_cos(VALUE unused_obj, VALUE x)
{
return DBL2NUM(cos(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-cosh" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
cosh(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the hyperbolic cosine of <code>x</code> (expressed in radians).</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: [1, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">cosh</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 1.0</span>
</pre>
<div class="method-source-code" id="cosh-source">
<pre>static VALUE
math_cosh(VALUE unused_obj, VALUE x)
{
return DBL2NUM(cosh(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-erf" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
erf(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Calculates the error function of <code>x</code>.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (-1, 1)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">erf</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 0.0</span>
</pre>
<div class="method-source-code" id="erf-source">
<pre>static VALUE
math_erf(VALUE unused_obj, VALUE x)
{
return DBL2NUM(erf(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-erfc" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
erfc(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Calculates the complementary error function of x.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (0, 2)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">erfc</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 1.0</span>
</pre>
<div class="method-source-code" id="erfc-source">
<pre>static VALUE
math_erfc(VALUE unused_obj, VALUE x)
{
return DBL2NUM(erfc(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-exp" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
exp(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns e**x.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (0, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">exp</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 1.0</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">exp</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 2.718281828459045</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">exp</span>(<span class="ruby-value">1.5</span>) <span class="ruby-comment">#=> 4.4816890703380645</span>
</pre>
<div class="method-source-code" id="exp-source">
<pre>static VALUE
math_exp(VALUE unused_obj, VALUE x)
{
return DBL2NUM(exp(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-frexp" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
frexp(x) → [fraction, exponent]
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a two-element array containing the normalized fraction (a <a href="Float.html"><code>Float</code></a>) and exponent (an <a href="Integer.html"><code>Integer</code></a>) of <code>x</code>.</p>
<pre class="ruby"><span class="ruby-identifier">fraction</span>, <span class="ruby-identifier">exponent</span> = <span class="ruby-constant">Math</span>.<span class="ruby-identifier">frexp</span>(<span class="ruby-value">1234</span>) <span class="ruby-comment">#=> [0.6025390625, 11]</span>
<span class="ruby-identifier">fraction</span> <span class="ruby-operator">*</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">exponent</span> <span class="ruby-comment">#=> 1234.0</span>
</pre>
<div class="method-source-code" id="frexp-source">
<pre>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));
}</pre>
</div>
</div>
</div>
<div id="method-c-gamma" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
gamma(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Calculates the gamma function of x.</p>
<p>Note that gamma(n) is same as fact(n-1) for integer n > 0. However gamma(n) returns float and can be an approximation.</p>
<pre class="ruby"><span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">fact</span>(<span class="ruby-identifier">n</span>) (<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-identifier">n</span>).<span class="ruby-identifier">inject</span>(<span class="ruby-value">1</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">r</span>,<span class="ruby-identifier">i</span><span class="ruby-operator">|</span> <span class="ruby-identifier">r</span><span class="ruby-operator">*</span><span class="ruby-identifier">i</span> } <span class="ruby-keyword">end</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">upto</span>(<span class="ruby-value">26</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span> <span class="ruby-identifier">p</span> [<span class="ruby-identifier">i</span>, <span class="ruby-constant">Math</span>.<span class="ruby-identifier">gamma</span>(<span class="ruby-identifier">i</span>), <span class="ruby-identifier">fact</span>(<span class="ruby-identifier">i</span><span class="ruby-value">-1</span>)] }
<span class="ruby-comment">#=> [1, 1.0, 1]</span>
<span class="ruby-comment"># [2, 1.0, 1]</span>
<span class="ruby-comment"># [3, 2.0, 2]</span>
<span class="ruby-comment"># [4, 6.0, 6]</span>
<span class="ruby-comment"># [5, 24.0, 24]</span>
<span class="ruby-comment"># [6, 120.0, 120]</span>
<span class="ruby-comment"># [7, 720.0, 720]</span>
<span class="ruby-comment"># [8, 5040.0, 5040]</span>
<span class="ruby-comment"># [9, 40320.0, 40320]</span>
<span class="ruby-comment"># [10, 362880.0, 362880]</span>
<span class="ruby-comment"># [11, 3628800.0, 3628800]</span>
<span class="ruby-comment"># [12, 39916800.0, 39916800]</span>
<span class="ruby-comment"># [13, 479001600.0, 479001600]</span>
<span class="ruby-comment"># [14, 6227020800.0, 6227020800]</span>
<span class="ruby-comment"># [15, 87178291200.0, 87178291200]</span>
<span class="ruby-comment"># [16, 1307674368000.0, 1307674368000]</span>
<span class="ruby-comment"># [17, 20922789888000.0, 20922789888000]</span>
<span class="ruby-comment"># [18, 355687428096000.0, 355687428096000]</span>
<span class="ruby-comment"># [19, 6.402373705728e+15, 6402373705728000]</span>
<span class="ruby-comment"># [20, 1.21645100408832e+17, 121645100408832000]</span>
<span class="ruby-comment"># [21, 2.43290200817664e+18, 2432902008176640000]</span>
<span class="ruby-comment"># [22, 5.109094217170944e+19, 51090942171709440000]</span>
<span class="ruby-comment"># [23, 1.1240007277776077e+21, 1124000727777607680000]</span>
<span class="ruby-comment"># [24, 2.5852016738885062e+22, 25852016738884976640000]</span>
<span class="ruby-comment"># [25, 6.204484017332391e+23, 620448401733239439360000]</span>
<span class="ruby-comment"># [26, 1.5511210043330954e+25, 15511210043330985984000000]</span>
</pre>
<div class="method-source-code" id="gamma-source">
<pre>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));
}</pre>
</div>
</div>
</div>
<div id="method-c-hypot" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
hypot(x, y) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with sides <code>x</code> and <code>y</code>.</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">hypot</span>(<span class="ruby-value">3</span>, <span class="ruby-value">4</span>) <span class="ruby-comment">#=> 5.0</span>
</pre>
<div class="method-source-code" id="hypot-source">
<pre>static VALUE
math_hypot(VALUE unused_obj, VALUE x, VALUE y)
{
return DBL2NUM(hypot(Get_Double(x), Get_Double(y)));
}</pre>
</div>
</div>
</div>
<div id="method-c-ldexp" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
ldexp(fraction, exponent) → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the value of <code>fraction</code>*(2**<code>exponent</code>).</p>
<pre class="ruby"><span class="ruby-identifier">fraction</span>, <span class="ruby-identifier">exponent</span> = <span class="ruby-constant">Math</span>.<span class="ruby-identifier">frexp</span>(<span class="ruby-value">1234</span>)
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">ldexp</span>(<span class="ruby-identifier">fraction</span>, <span class="ruby-identifier">exponent</span>) <span class="ruby-comment">#=> 1234.0</span>
</pre>
<div class="method-source-code" id="ldexp-source">
<pre>static VALUE
math_ldexp(VALUE unused_obj, VALUE x, VALUE n)
{
return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n)));
}</pre>
</div>
</div>
</div>
<div id="method-c-lgamma" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
lgamma(x) → [float, -1 or 1]
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Calculates the logarithmic gamma of <code>x</code> and the sign of gamma of <code>x</code>.</p>
<p><a href="Math.html#method-c-lgamma"><code>Math.lgamma(x)</code></a> is same as</p>
<pre class="ruby">[<span class="ruby-constant">Math</span>.<span class="ruby-identifier">log</span>(<span class="ruby-constant">Math</span>.<span class="ruby-identifier">gamma</span>(<span class="ruby-identifier">x</span>).<span class="ruby-identifier">abs</span>), <span class="ruby-constant">Math</span>.<span class="ruby-identifier">gamma</span>(<span class="ruby-identifier">x</span>) <span class="ruby-operator"><</span> <span class="ruby-value">0</span> <span class="ruby-operator">?</span> <span class="ruby-value">-1</span> <span class="ruby-operator">:</span> <span class="ruby-value">1</span>]
</pre>
<p>but avoid overflow by <a href="Math.html#method-c-gamma"><code>Math.gamma(x)</code></a> for large x.</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">lgamma</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> [Infinity, 1]</span>
</pre>
<div class="method-source-code" id="lgamma-source">
<pre>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));
}</pre>
</div>
</div>
</div>
<div id="method-c-log" class="method-detail ">
<div class="method-heading">
<span class="method-name">log</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="log-source">
<pre>static VALUE math_log(int, const VALUE *, VALUE))</pre>
</div>
</div>
</div>
<div id="method-c-log10" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
log10(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the base 10 logarithm of <code>x</code>.</p>
<p>Domain: (0, INFINITY)</p>
<p>Codomain: (-INFINITY, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">log10</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 0.0</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">log10</span>(<span class="ruby-value">10</span>) <span class="ruby-comment">#=> 1.0</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">log10</span>(<span class="ruby-value">10</span><span class="ruby-operator">**</span><span class="ruby-value">100</span>) <span class="ruby-comment">#=> 100.0</span>
</pre>
<div class="method-source-code" id="log10-source">
<pre>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) */
}</pre>
</div>
</div>
</div>
<div id="method-c-log2" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
log2(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the base 2 logarithm of <code>x</code>.</p>
<p>Domain: (0, INFINITY)</p>
<p>Codomain: (-INFINITY, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">log2</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 0.0</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">log2</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1.0</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">log2</span>(<span class="ruby-value">32768</span>) <span class="ruby-comment">#=> 15.0</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">log2</span>(<span class="ruby-value">65536</span>) <span class="ruby-comment">#=> 16.0</span>
</pre>
<div class="method-source-code" id="log2-source">
<pre>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) */
}</pre>
</div>
</div>
</div>
<div id="method-c-sin" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
sin(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the sine of <code>x</code> (expressed in radians). Returns a <a href="Float.html"><code>Float</code></a> in the range -1.0..1.0.</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: [-1, 1]</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">sin</span>(<span class="ruby-constant">Math</span><span class="ruby-operator">::</span><span class="ruby-constant">PI</span><span class="ruby-operator">/</span><span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1.0</span>
</pre>
<div class="method-source-code" id="sin-source">
<pre>static VALUE
math_sin(VALUE unused_obj, VALUE x)
{
return DBL2NUM(sin(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-sinh" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
sinh(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the hyperbolic sine of <code>x</code> (expressed in radians).</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (-INFINITY, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">sinh</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 0.0</span>
</pre>
<div class="method-source-code" id="sinh-source">
<pre>static VALUE
math_sinh(VALUE unused_obj, VALUE x)
{
return DBL2NUM(sinh(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-sqrt" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
sqrt(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the non-negative square root of <code>x</code>.</p>
<p>Domain: [0, INFINITY)</p>
<p>Codomain:[0, INFINITY)</p>
<pre class="ruby"><span class="ruby-value">0</span>.<span class="ruby-identifier">upto</span>(<span class="ruby-value">10</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">p</span> [<span class="ruby-identifier">x</span>, <span class="ruby-constant">Math</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-identifier">x</span>), <span class="ruby-constant">Math</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-identifier">x</span>)<span class="ruby-operator">**</span><span class="ruby-value">2</span>]
}
<span class="ruby-comment">#=> [0, 0.0, 0.0]</span>
<span class="ruby-comment"># [1, 1.0, 1.0]</span>
<span class="ruby-comment"># [2, 1.4142135623731, 2.0]</span>
<span class="ruby-comment"># [3, 1.73205080756888, 3.0]</span>
<span class="ruby-comment"># [4, 2.0, 4.0]</span>
<span class="ruby-comment"># [5, 2.23606797749979, 5.0]</span>
<span class="ruby-comment"># [6, 2.44948974278318, 6.0]</span>
<span class="ruby-comment"># [7, 2.64575131106459, 7.0]</span>
<span class="ruby-comment"># [8, 2.82842712474619, 8.0]</span>
<span class="ruby-comment"># [9, 3.0, 9.0]</span>
<span class="ruby-comment"># [10, 3.16227766016838, 10.0]</span>
</pre>
<p>Note that the limited precision of floating point arithmetic might lead to surprising results:</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-value">10</span><span class="ruby-operator">**</span><span class="ruby-value">46</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 99999999999999991611392 (!)</span>
</pre>
<p>See also <a href="BigDecimal.html#method-i-sqrt"><code>BigDecimal#sqrt</code></a> and <a href="Integer.html#method-c-sqrt"><code>Integer.sqrt</code></a>.</p>
<div class="method-source-code" id="sqrt-source">
<pre>static VALUE
math_sqrt(VALUE unused_obj, VALUE x)
{
return rb_math_sqrt(x);
}</pre>
</div>
</div>
</div>
<div id="method-c-tan" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
tan(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the tangent of <code>x</code> (expressed in radians).</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (-INFINITY, INFINITY)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">tan</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 0.0</span>
</pre>
<div class="method-source-code" id="tan-source">
<pre>static VALUE
math_tan(VALUE unused_obj, VALUE x)
{
return DBL2NUM(tan(Get_Double(x)));
}</pre>
</div>
</div>
</div>
<div id="method-c-tanh" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
tanh(x) → Float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Computes the hyperbolic tangent of <code>x</code> (expressed in radians).</p>
<p>Domain: (-INFINITY, INFINITY)</p>
<p>Codomain: (-1, 1)</p>
<pre class="ruby"><span class="ruby-constant">Math</span>.<span class="ruby-identifier">tanh</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 0.0</span>
</pre>
<div class="method-source-code" id="tanh-source">
<pre>static VALUE
math_tanh(VALUE unused_obj, VALUE x)
{
return DBL2NUM(tanh(Get_Double(x)));
}</pre>
</div>
</div>
</div>
</section>
</section>
</main>
<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.2.1.1.
<p>Based on <a href="http://deveiate.org/projects/Darkfish-RDoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
</footer>