File: C:/Ruby27-x64/share/doc/ruby/html/Float.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class Float - 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="class">
<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">
<div id="parent-class-section" class="nav-section">
<h3>Parent</h3>
<p class="link"><a href="Numeric.html">Numeric</a>
</div>
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li ><a href="#method-i-25">#%</a>
<li ><a href="#method-i-2A">#*</a>
<li ><a href="#method-i-2A-2A">#**</a>
<li ><a href="#method-i-2B">#+</a>
<li ><a href="#method-i-2D">#-</a>
<li ><a href="#method-i-2D-40">#-@</a>
<li ><a href="#method-i-2F">#/</a>
<li ><a href="#method-i-3C">#<</a>
<li ><a href="#method-i-3C-3D">#<=</a>
<li ><a href="#method-i-3C-3D-3E">#<=></a>
<li ><a href="#method-i-3D-3D">#==</a>
<li ><a href="#method-i-3D-3D-3D">#===</a>
<li ><a href="#method-i-3E">#></a>
<li ><a href="#method-i-3E-3D">#>=</a>
<li ><a href="#method-i-abs">#abs</a>
<li ><a href="#method-i-angle">#angle</a>
<li ><a href="#method-i-arg">#arg</a>
<li ><a href="#method-i-ceil">#ceil</a>
<li ><a href="#method-i-coerce">#coerce</a>
<li ><a href="#method-i-dclone">#dclone</a>
<li ><a href="#method-i-denominator">#denominator</a>
<li ><a href="#method-i-divmod">#divmod</a>
<li ><a href="#method-i-eql-3F">#eql?</a>
<li ><a href="#method-i-fdiv">#fdiv</a>
<li ><a href="#method-i-finite-3F">#finite?</a>
<li ><a href="#method-i-floor">#floor</a>
<li ><a href="#method-i-hash">#hash</a>
<li ><a href="#method-i-infinite-3F">#infinite?</a>
<li ><a href="#method-i-inspect">#inspect</a>
<li ><a href="#method-i-magnitude">#magnitude</a>
<li ><a href="#method-i-modulo">#modulo</a>
<li ><a href="#method-i-nan-3F">#nan?</a>
<li ><a href="#method-i-negative-3F">#negative?</a>
<li ><a href="#method-i-next_float">#next_float</a>
<li ><a href="#method-i-numerator">#numerator</a>
<li ><a href="#method-i-phase">#phase</a>
<li ><a href="#method-i-positive-3F">#positive?</a>
<li ><a href="#method-i-prev_float">#prev_float</a>
<li ><a href="#method-i-quo">#quo</a>
<li ><a href="#method-i-rationalize">#rationalize</a>
<li ><a href="#method-i-round">#round</a>
<li ><a href="#method-i-to_d">#to_d</a>
<li ><a href="#method-i-to_f">#to_f</a>
<li ><a href="#method-i-to_i">#to_i</a>
<li ><a href="#method-i-to_int">#to_int</a>
<li ><a href="#method-i-to_r">#to_r</a>
<li ><a href="#method-i-to_s">#to_s</a>
<li ><a href="#method-i-truncate">#truncate</a>
<li ><a href="#method-i-zero-3F">#zero?</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-Float">
<h1 id="class-Float" class="class">
class Float
</h1>
<section class="description">
<p><a href="Float.html"><code>Float</code></a> objects represent inexact real numbers using the native architecture's double-precision floating point representation.</p>
<p>Floating point has a different arithmetic and is an inexact number. So you should know its esoteric system. See following:</p>
<ul><li>
<p><a href="http://docs.sun.com/source/806-3568/ncg_goldberg.html">docs.sun.com/source/806-3568/ncg_goldberg.html</a></p>
</li><li>
<p><a href="https://github.com/rdp/ruby_tutorials_core/wiki/Ruby-Talk-FAQ#floats_imprecise">github.com/rdp/ruby_tutorials_core/wiki/Ruby-Talk-FAQ#floats_imprecise</a></p>
</li><li>
<p><a href="http://en.wikipedia.org/wiki/Floating_point#Accuracy_problems">en.wikipedia.org/wiki/Floating_point#Accuracy_problems</a></p>
</li></ul>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section class="constants-list">
<header>
<h3>Constants</h3>
</header>
<dl>
<dt id="DIG">DIG
<dd><p>The minimum number of significant decimal digits in a double-precision floating point.</p>
<p>Usually defaults to 15.</p>
<dt id="EPSILON">EPSILON
<dd><p>The difference between 1 and the smallest double-precision floating point number greater than 1.</p>
<p>Usually defaults to 2.2204460492503131e-16.</p>
<dt id="INFINITY">INFINITY
<dd><p>An expression representing positive infinity.</p>
<dt id="MANT_DIG">MANT_DIG
<dd><p>The number of base digits for the <code>double</code> data type.</p>
<p>Usually defaults to 53.</p>
<dt id="MAX">MAX
<dd><p>The largest possible integer in a double-precision floating point number.</p>
<p>Usually defaults to 1.7976931348623157e+308.</p>
<dt id="MAX_10_EXP">MAX_10_EXP
<dd><p>The largest positive exponent in a double-precision floating point where 10 raised to this power minus 1.</p>
<p>Usually defaults to 308.</p>
<dt id="MAX_EXP">MAX_EXP
<dd><p>The largest possible exponent value in a double-precision floating point.</p>
<p>Usually defaults to 1024.</p>
<dt id="MIN">MIN
<dd><p>The smallest positive normalized number in a double-precision floating point.</p>
<p>Usually defaults to 2.2250738585072014e-308.</p>
<p>If the platform supports denormalized numbers, there are numbers between zero and <a href="Float.html#MIN"><code>Float::MIN</code></a>. 0.0.next_float returns the smallest positive floating point number including denormalized numbers.</p>
<dt id="MIN_10_EXP">MIN_10_EXP
<dd><p>The smallest negative exponent in a double-precision floating point where 10 raised to this power minus 1.</p>
<p>Usually defaults to -307.</p>
<dt id="MIN_EXP">MIN_EXP
<dd><p>The smallest possible exponent value in a double-precision floating point.</p>
<p>Usually defaults to -1021.</p>
<dt id="NAN">NAN
<dd><p>An expression representing a value which is “not a number”.</p>
<dt id="RADIX">RADIX
<dd><p>The base of the floating point, or number of unique digits used to represent the number.</p>
<p>Usually defaults to 2 on most systems, which would represent a base-10 decimal.</p>
<dt id="ROUNDS">ROUNDS
<dd><p>Deprecated, do not use.</p>
<p>Represents the rounding mode for floating point addition at the start time.</p>
<p>Usually defaults to 1, rounding to the nearest number.</p>
<p>Other modes include:</p>
<dl class="rdoc-list note-list"><dt>-1
<dd>
<p>Indeterminable</p>
</dd><dt>0
<dd>
<p>Rounding towards zero</p>
</dd><dt>1
<dd>
<p>Rounding to the nearest number</p>
</dd><dt>2
<dd>
<p>Rounding towards positive infinity</p>
</dd><dt>3
<dd>
<p>Rounding towards negative infinity</p>
</dd></dl>
</dl>
</section>
<section id="public-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Instance Methods</h3>
</header>
<div id="method-i-25" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float % other → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the modulo after division of <code>float</code> by <code>other</code>.</p>
<pre class="ruby"><span class="ruby-value">6543.21</span>.<span class="ruby-identifier">modulo</span>(<span class="ruby-value">137</span>) <span class="ruby-comment">#=> 104.21000000000004</span>
<span class="ruby-value">6543.21</span>.<span class="ruby-identifier">modulo</span>(<span class="ruby-value">137.24</span>) <span class="ruby-comment">#=> 92.92999999999961</span>
</pre>
<div class="method-source-code" id="25-source">
<pre>static VALUE
flo_mod(VALUE x, VALUE y)
{
double fy;
if (RB_TYPE_P(y, T_FIXNUM)) {
fy = (double)FIX2LONG(y);
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
fy = rb_big2dbl(y);
}
else if (RB_TYPE_P(y, T_FLOAT)) {
fy = RFLOAT_VALUE(y);
}
else {
return rb_num_coerce_bin(x, y, '%');
}
return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(x), fy));
}</pre>
</div>
</div>
</div>
<div id="method-i-2A" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float * other → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a new <a href="Float.html"><code>Float</code></a> which is the product of <code>float</code> and <code>other</code>.</p>
<div class="method-source-code" id="2A-source">
<pre>VALUE
rb_float_mul(VALUE x, VALUE y)
{
if (RB_TYPE_P(y, T_FIXNUM)) {
return DBL2NUM(RFLOAT_VALUE(x) * (double)FIX2LONG(y));
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
return DBL2NUM(RFLOAT_VALUE(x) * rb_big2dbl(y));
}
else if (RB_TYPE_P(y, T_FLOAT)) {
return DBL2NUM(RFLOAT_VALUE(x) * RFLOAT_VALUE(y));
}
else {
return rb_num_coerce_bin(x, y, '*');
}
}</pre>
</div>
</div>
</div>
<div id="method-i-2A-2A" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float ** other → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Raises <code>float</code> to the power of <code>other</code>.</p>
<pre class="ruby"><span class="ruby-value">2.0</span><span class="ruby-operator">**</span><span class="ruby-value">3</span> <span class="ruby-comment">#=> 8.0</span>
</pre>
<div class="method-source-code" id="2A-2A-source">
<pre>VALUE
rb_float_pow(VALUE x, VALUE y)
{
double dx, dy;
if (RB_TYPE_P(y, T_FIXNUM)) {
dx = RFLOAT_VALUE(x);
dy = (double)FIX2LONG(y);
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
dx = RFLOAT_VALUE(x);
dy = rb_big2dbl(y);
}
else if (RB_TYPE_P(y, T_FLOAT)) {
dx = RFLOAT_VALUE(x);
dy = RFLOAT_VALUE(y);
if (dx < 0 && dy != round(dy))
return rb_dbl_complex_new_polar_pi(pow(-dx, dy), dy);
}
else {
return rb_num_coerce_bin(x, y, idPow);
}
return DBL2NUM(pow(dx, dy));
}</pre>
</div>
</div>
</div>
<div id="method-i-2B" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float + other → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a new <a href="Float.html"><code>Float</code></a> which is the sum of <code>float</code> and <code>other</code>.</p>
<div class="method-source-code" id="2B-source">
<pre>VALUE
rb_float_plus(VALUE x, VALUE y)
{
if (RB_TYPE_P(y, T_FIXNUM)) {
return DBL2NUM(RFLOAT_VALUE(x) + (double)FIX2LONG(y));
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
return DBL2NUM(RFLOAT_VALUE(x) + rb_big2dbl(y));
}
else if (RB_TYPE_P(y, T_FLOAT)) {
return DBL2NUM(RFLOAT_VALUE(x) + RFLOAT_VALUE(y));
}
else {
return rb_num_coerce_bin(x, y, '+');
}
}</pre>
</div>
</div>
</div>
<div id="method-i-2D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float - other → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a new <a href="Float.html"><code>Float</code></a> which is the difference of <code>float</code> and <code>other</code>.</p>
<div class="method-source-code" id="2D-source">
<pre>VALUE
rb_float_minus(VALUE x, VALUE y)
{
if (RB_TYPE_P(y, T_FIXNUM)) {
return DBL2NUM(RFLOAT_VALUE(x) - (double)FIX2LONG(y));
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
return DBL2NUM(RFLOAT_VALUE(x) - rb_big2dbl(y));
}
else if (RB_TYPE_P(y, T_FLOAT)) {
return DBL2NUM(RFLOAT_VALUE(x) - RFLOAT_VALUE(y));
}
else {
return rb_num_coerce_bin(x, y, '-');
}
}</pre>
</div>
</div>
</div>
<div id="method-i-2D-40" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
-float → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>float</code>, negated.</p>
<div class="method-source-code" id="2D-40-source">
<pre>VALUE
rb_float_uminus(VALUE flt)
{
return DBL2NUM(-RFLOAT_VALUE(flt));
}</pre>
</div>
</div>
</div>
<div id="method-i-2F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float / other → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a new <a href="Float.html"><code>Float</code></a> which is the result of dividing <code>float</code> by <code>other</code>.</p>
<div class="method-source-code" id="2F-source">
<pre>VALUE
rb_float_div(VALUE x, VALUE y)
{
double num = RFLOAT_VALUE(x);
double den;
double ret;
if (RB_TYPE_P(y, T_FIXNUM)) {
den = FIX2LONG(y);
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
den = rb_big2dbl(y);
}
else if (RB_TYPE_P(y, T_FLOAT)) {
den = RFLOAT_VALUE(y);
}
else {
return rb_num_coerce_bin(x, y, '/');
}
ret = double_div_double(num, den);
return DBL2NUM(ret);
}</pre>
</div>
</div>
</div>
<div id="method-i-3C" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float < real → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is less than <code>real</code>.</p>
<p>The result of <code>NaN < NaN</code> is undefined, so an implementation-dependent value is returned.</p>
<div class="method-source-code" id="3C-source">
<pre>static VALUE
flo_lt(VALUE x, VALUE y)
{
double a, b;
a = RFLOAT_VALUE(x);
if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
VALUE rel = rb_integer_float_cmp(y, x);
if (FIXNUM_P(rel))
return -FIX2LONG(rel) < 0 ? Qtrue : Qfalse;
return Qfalse;
}
else if (RB_TYPE_P(y, T_FLOAT)) {
b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(b)) return Qfalse;
#endif
}
else {
return rb_num_coerce_relop(x, y, '<');
}
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a < b)?Qtrue:Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-3C-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float <= real → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is less than or equal to <code>real</code>.</p>
<p>The result of <code>NaN <= NaN</code> is undefined, so an implementation-dependent value is returned.</p>
<div class="method-source-code" id="3C-3D-source">
<pre>static VALUE
flo_le(VALUE x, VALUE y)
{
double a, b;
a = RFLOAT_VALUE(x);
if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
VALUE rel = rb_integer_float_cmp(y, x);
if (FIXNUM_P(rel))
return -FIX2LONG(rel) <= 0 ? Qtrue : Qfalse;
return Qfalse;
}
else if (RB_TYPE_P(y, T_FLOAT)) {
b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(b)) return Qfalse;
#endif
}
else {
return rb_num_coerce_relop(x, y, idLE);
}
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a <= b)?Qtrue:Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-3C-3D-3E" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float <=> real → -1, 0, +1, or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns -1, 0, or +1 depending on whether <code>float</code> is less than, equal to, or greater than <code>real</code>. This is the basis for the tests in the <a href="Comparable.html"><code>Comparable</code></a> module.</p>
<p>The result of <code>NaN <=> NaN</code> is undefined, so an implementation-dependent value is returned.</p>
<p><code>nil</code> is returned if the two values are incomparable.</p>
<div class="method-source-code" id="3C-3D-3E-source">
<pre>static VALUE
flo_cmp(VALUE x, VALUE y)
{
double a, b;
VALUE i;
a = RFLOAT_VALUE(x);
if (isnan(a)) return Qnil;
if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
VALUE rel = rb_integer_float_cmp(y, x);
if (FIXNUM_P(rel))
return LONG2FIX(-FIX2LONG(rel));
return rel;
}
else if (RB_TYPE_P(y, T_FLOAT)) {
b = RFLOAT_VALUE(y);
}
else {
if (isinf(a) && (i = rb_check_funcall(y, rb_intern("infinite?"), 0, 0)) != Qundef) {
if (RTEST(i)) {
int j = rb_cmpint(i, x, y);
j = (a > 0.0) ? (j > 0 ? 0 : +1) : (j < 0 ? 0 : -1);
return INT2FIX(j);
}
if (a > 0.0) return INT2FIX(1);
return INT2FIX(-1);
}
return rb_num_coerce_cmp(x, y, id_cmp);
}
return rb_dbl_cmp(a, b);
}</pre>
</div>
</div>
</div>
<div id="method-i-3D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float == obj → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> only if <code>obj</code> has the same value as <code>float</code>. Contrast this with <a href="Float.html#method-i-eql-3F"><code>Float#eql?</code></a>, which requires <code>obj</code> to be a <a href="Float.html"><code>Float</code></a>.</p>
<pre class="ruby"><span class="ruby-value">1.0</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span> <span class="ruby-comment">#=> true</span>
</pre>
<p>The result of <code>NaN == NaN</code> is undefined, so an implementation-dependent value is returned.</p>
<div class="method-source-code" id="3D-3D-source">
<pre>MJIT_FUNC_EXPORTED VALUE
rb_float_equal(VALUE x, VALUE y)
{
volatile double a, b;
if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
return rb_integer_float_eq(y, x);
}
else if (RB_TYPE_P(y, T_FLOAT)) {
b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(b)) return Qfalse;
#endif
}
else {
return num_equal(x, y);
}
a = RFLOAT_VALUE(x);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a == b)?Qtrue:Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-3D-3D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float == obj → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> only if <code>obj</code> has the same value as <code>float</code>. Contrast this with <a href="Float.html#method-i-eql-3F"><code>Float#eql?</code></a>, which requires <code>obj</code> to be a <a href="Float.html"><code>Float</code></a>.</p>
<pre class="ruby"><span class="ruby-value">1.0</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span> <span class="ruby-comment">#=> true</span>
</pre>
<p>The result of <code>NaN == NaN</code> is undefined, so an implementation-dependent value is returned.</p>
<div class="method-source-code" id="3D-3D-3D-source">
<pre>MJIT_FUNC_EXPORTED VALUE
rb_float_equal(VALUE x, VALUE y)
{
volatile double a, b;
if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
return rb_integer_float_eq(y, x);
}
else if (RB_TYPE_P(y, T_FLOAT)) {
b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(b)) return Qfalse;
#endif
}
else {
return num_equal(x, y);
}
a = RFLOAT_VALUE(x);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a == b)?Qtrue:Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-3E" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float > real → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is greater than <code>real</code>.</p>
<p>The result of <code>NaN > NaN</code> is undefined, so an implementation-dependent value is returned.</p>
<div class="method-source-code" id="3E-source">
<pre>VALUE
rb_float_gt(VALUE x, VALUE y)
{
double a, b;
a = RFLOAT_VALUE(x);
if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
VALUE rel = rb_integer_float_cmp(y, x);
if (FIXNUM_P(rel))
return -FIX2LONG(rel) > 0 ? Qtrue : Qfalse;
return Qfalse;
}
else if (RB_TYPE_P(y, T_FLOAT)) {
b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(b)) return Qfalse;
#endif
}
else {
return rb_num_coerce_relop(x, y, '>');
}
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a > b)?Qtrue:Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-3E-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
float >= real → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is greater than or equal to <code>real</code>.</p>
<p>The result of <code>NaN >= NaN</code> is undefined, so an implementation-dependent value is returned.</p>
<div class="method-source-code" id="3E-3D-source">
<pre>static VALUE
flo_ge(VALUE x, VALUE y)
{
double a, b;
a = RFLOAT_VALUE(x);
if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
VALUE rel = rb_integer_float_cmp(y, x);
if (FIXNUM_P(rel))
return -FIX2LONG(rel) >= 0 ? Qtrue : Qfalse;
return Qfalse;
}
else if (RB_TYPE_P(y, T_FLOAT)) {
b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(b)) return Qfalse;
#endif
}
else {
return rb_num_coerce_relop(x, y, idGE);
}
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a >= b)?Qtrue:Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-abs" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
abs → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the absolute value of <code>float</code>.</p>
<pre class="ruby">(<span class="ruby-value">-34.56</span>).<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 34.56</span>
<span class="ruby-value">-34.56</span>.<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 34.56</span>
<span class="ruby-value">34.56</span>.<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 34.56</span>
</pre>
<p><a href="Float.html#method-i-magnitude"><code>Float#magnitude</code></a> is an alias for <a href="Float.html#method-i-abs"><code>Float#abs</code></a>.</p>
<div class="method-source-code" id="abs-source">
<pre>VALUE
rb_float_abs(VALUE flt)
{
double val = fabs(RFLOAT_VALUE(flt));
return DBL2NUM(val);
}</pre>
</div>
</div>
</div>
<div id="method-i-angle" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
angle → 0 or float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns 0 if the value is positive, pi otherwise.</p>
<div class="method-source-code" id="angle-source">
<pre>static VALUE
float_arg(VALUE self)
{
if (isnan(RFLOAT_VALUE(self)))
return self;
if (f_tpositive_p(self))
return INT2FIX(0);
return rb_const_get(rb_mMath, id_PI);
}</pre>
</div>
</div>
</div>
<div id="method-i-arg" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
arg → 0 or float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns 0 if the value is positive, pi otherwise.</p>
<div class="method-source-code" id="arg-source">
<pre>static VALUE
float_arg(VALUE self)
{
if (isnan(RFLOAT_VALUE(self)))
return self;
if (f_tpositive_p(self))
return INT2FIX(0);
return rb_const_get(rb_mMath, id_PI);
}</pre>
</div>
</div>
</div>
<div id="method-i-ceil" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
ceil([ndigits]) → integer or float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the smallest number greater than or equal to <code>float</code> with a precision of <code>ndigits</code> decimal digits (default: 0).</p>
<p>When the precision is negative, the returned value is an integer with at least <code>ndigits.abs</code> trailing zeros.</p>
<p>Returns a floating point number when <code>ndigits</code> is positive, otherwise returns an integer.</p>
<pre class="ruby"><span class="ruby-value">1.2</span>.<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> 2</span>
<span class="ruby-value">2.0</span>.<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> 2</span>
(<span class="ruby-value">-1.2</span>).<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> -1</span>
(<span class="ruby-value">-2.0</span>).<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> -2</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1.24</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> 1.235</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">4</span>) <span class="ruby-comment">#=> 1.2346</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">5</span>) <span class="ruby-comment">#=> 1.23457</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">-5</span>) <span class="ruby-comment">#=> 100000</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">-4</span>) <span class="ruby-comment">#=> 40000</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">-3</span>) <span class="ruby-comment">#=> 35000</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">-2</span>) <span class="ruby-comment">#=> 34600</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 34570</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 34568</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 34567.9</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 34567.89</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> 34567.89</span>
</pre>
<p>Note that the limited precision of floating point arithmetic might lead to surprising results:</p>
<pre class="ruby">(<span class="ruby-value">2.1</span> <span class="ruby-operator">/</span> <span class="ruby-value">0.7</span>).<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> 4 (!)</span>
</pre>
<div class="method-source-code" id="ceil-source">
<pre>static VALUE
flo_ceil(int argc, VALUE *argv, VALUE num)
{
int ndigits = 0;
if (rb_check_arity(argc, 0, 1)) {
ndigits = NUM2INT(argv[0]);
}
return rb_float_ceil(num, ndigits);
}</pre>
</div>
</div>
</div>
<div id="method-i-coerce" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
coerce(numeric) → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns an array with both <code>numeric</code> and <code>float</code> represented as <a href="Float.html"><code>Float</code></a> objects.</p>
<p>This is achieved by converting <code>numeric</code> to a <a href="Float.html"><code>Float</code></a>.</p>
<pre class="ruby"><span class="ruby-value">1.2</span>.<span class="ruby-identifier">coerce</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> [3.0, 1.2]</span>
<span class="ruby-value">2.5</span>.<span class="ruby-identifier">coerce</span>(<span class="ruby-value">1.1</span>) <span class="ruby-comment">#=> [1.1, 2.5]</span>
</pre>
<div class="method-source-code" id="coerce-source">
<pre>static VALUE
flo_coerce(VALUE x, VALUE y)
{
return rb_assoc_new(rb_Float(y), x);
}</pre>
</div>
</div>
</div>
<div id="method-i-dclone" class="method-detail ">
<div class="method-heading">
<span class="method-name">dclone</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>provides a unified <code>clone</code> operation, for <a href="REXML/XPathParser.html"><code>REXML::XPathParser</code></a> to use across multiple <a href="Object.html"><code>Object</code></a> types</p>
<div class="method-source-code" id="dclone-source">
<pre><span class="ruby-comment"># File lib/rexml/xpath_parser.rb, line 30</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">dclone</span> ; <span class="ruby-keyword">self</span> ; <span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-denominator" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
denominator → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the denominator (always positive). The result is machine dependent.</p>
<p>See also <a href="Float.html#method-i-numerator"><code>Float#numerator</code></a>.</p>
<div class="method-source-code" id="denominator-source">
<pre>VALUE
rb_float_denominator(VALUE self)
{
double d = RFLOAT_VALUE(self);
VALUE r;
if (isinf(d) || isnan(d))
return INT2FIX(1);
r = float_to_r(self);
if (canonicalization && k_integer_p(r)) {
return ONE;
}
return nurat_denominator(r);
}</pre>
</div>
</div>
</div>
<div id="method-i-divmod" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
divmod(numeric) → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>See <a href="Numeric.html#method-i-divmod"><code>Numeric#divmod</code></a>.</p>
<pre class="ruby"><span class="ruby-value">42.0</span>.<span class="ruby-identifier">divmod</span>(<span class="ruby-value">6</span>) <span class="ruby-comment">#=> [7, 0.0]</span>
<span class="ruby-value">42.0</span>.<span class="ruby-identifier">divmod</span>(<span class="ruby-value">5</span>) <span class="ruby-comment">#=> [8, 2.0]</span>
</pre>
<div class="method-source-code" id="divmod-source">
<pre>static VALUE
flo_divmod(VALUE x, VALUE y)
{
double fy, div, mod;
volatile VALUE a, b;
if (RB_TYPE_P(y, T_FIXNUM)) {
fy = (double)FIX2LONG(y);
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
fy = rb_big2dbl(y);
}
else if (RB_TYPE_P(y, T_FLOAT)) {
fy = RFLOAT_VALUE(y);
}
else {
return rb_num_coerce_bin(x, y, id_divmod);
}
flodivmod(RFLOAT_VALUE(x), fy, &div, &mod);
a = dbl2ival(div);
b = DBL2NUM(mod);
return rb_assoc_new(a, b);
}</pre>
</div>
</div>
</div>
<div id="method-i-eql-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
eql?(obj) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> only if <code>obj</code> is a <a href="Float.html"><code>Float</code></a> with the same value as <code>float</code>. Contrast this with Float#==, which performs type conversions.</p>
<pre class="ruby"><span class="ruby-value">1.0</span>.<span class="ruby-identifier">eql?</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> false</span>
</pre>
<p>The result of <code>NaN.eql?(NaN)</code> is undefined, so an implementation-dependent value is returned.</p>
<div class="method-source-code" id="eql-3F-source">
<pre>MJIT_FUNC_EXPORTED VALUE
rb_float_eql(VALUE x, VALUE y)
{
if (RB_TYPE_P(y, T_FLOAT)) {
double a = RFLOAT_VALUE(x);
double b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a) || isnan(b)) return Qfalse;
#endif
if (a == b)
return Qtrue;
}
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-fdiv" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
fdiv(numeric) → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>float / numeric</code>, same as Float#/.</p>
<div class="method-source-code" id="fdiv-source">
<pre>static VALUE
flo_quo(VALUE x, VALUE y)
{
return num_funcall1(x, '/', y);
}</pre>
</div>
</div>
</div>
<div id="method-i-finite-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
finite? → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is a valid IEEE floating point number, i.e. it is not infinite and <a href="Float.html#method-i-nan-3F"><code>Float#nan?</code></a> is <code>false</code>.</p>
<div class="method-source-code" id="finite-3F-source">
<pre>VALUE
rb_flo_is_finite_p(VALUE num)
{
double value = RFLOAT_VALUE(num);
#ifdef HAVE_ISFINITE
if (!isfinite(value))
return Qfalse;
#else
if (isinf(value) || isnan(value))
return Qfalse;
#endif
return Qtrue;
}</pre>
</div>
</div>
</div>
<div id="method-i-floor" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
floor([ndigits]) → integer or float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the largest number less than or equal to <code>float</code> with a precision of <code>ndigits</code> decimal digits (default: 0).</p>
<p>When the precision is negative, the returned value is an integer with at least <code>ndigits.abs</code> trailing zeros.</p>
<p>Returns a floating point number when <code>ndigits</code> is positive, otherwise returns an integer.</p>
<pre class="ruby"><span class="ruby-value">1.2</span>.<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">2.0</span>.<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> 2</span>
(<span class="ruby-value">-1.2</span>).<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> -2</span>
(<span class="ruby-value">-2.0</span>).<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> -2</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1.23</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> 1.234</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">4</span>) <span class="ruby-comment">#=> 1.2345</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">5</span>) <span class="ruby-comment">#=> 1.23456</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">-5</span>) <span class="ruby-comment">#=> 0</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">-4</span>) <span class="ruby-comment">#=> 30000</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">-3</span>) <span class="ruby-comment">#=> 34000</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">-2</span>) <span class="ruby-comment">#=> 34500</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 34560</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 34567</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 34567.8</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 34567.89</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> 34567.89</span>
</pre>
<p>Note that the limited precision of floating point arithmetic might lead to surprising results:</p>
<pre class="ruby">(<span class="ruby-value">0.3</span> <span class="ruby-operator">/</span> <span class="ruby-value">0.1</span>).<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> 2 (!)</span>
</pre>
<div class="method-source-code" id="floor-source">
<pre>static VALUE
flo_floor(int argc, VALUE *argv, VALUE num)
{
int ndigits = 0;
if (rb_check_arity(argc, 0, 1)) {
ndigits = NUM2INT(argv[0]);
}
return rb_float_floor(num, ndigits);
}</pre>
</div>
</div>
</div>
<div id="method-i-hash" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
hash → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a hash code for this float.</p>
<p>See also <a href="Object.html#method-i-hash"><code>Object#hash</code></a>.</p>
<div class="method-source-code" id="hash-source">
<pre>static VALUE
flo_hash(VALUE num)
{
return rb_dbl_hash(RFLOAT_VALUE(num));
}</pre>
</div>
</div>
</div>
<div id="method-i-infinite-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
infinite? → -1, 1, or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>nil</code>, -1, or 1 depending on whether the value is finite, <code>-Infinity</code>, or <code>+Infinity</code>.</p>
<pre class="ruby">(<span class="ruby-value">0.0</span>).<span class="ruby-identifier">infinite?</span> <span class="ruby-comment">#=> nil</span>
(<span class="ruby-value">-1.0</span><span class="ruby-operator">/</span><span class="ruby-value">0.0</span>).<span class="ruby-identifier">infinite?</span> <span class="ruby-comment">#=> -1</span>
(<span class="ruby-value">+1.0</span><span class="ruby-operator">/</span><span class="ruby-value">0.0</span>).<span class="ruby-identifier">infinite?</span> <span class="ruby-comment">#=> 1</span>
</pre>
<div class="method-source-code" id="infinite-3F-source">
<pre>VALUE
rb_flo_is_infinite_p(VALUE num)
{
double value = RFLOAT_VALUE(num);
if (isinf(value)) {
return INT2FIX( value < 0 ? -1 : 1 );
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-inspect" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">inspect</span><span
class="method-args">()</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="Float.html#method-i-to_s">to_s</a>
</div>
</div>
<div id="method-i-magnitude" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
magnitude → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the absolute value of <code>float</code>.</p>
<pre class="ruby">(<span class="ruby-value">-34.56</span>).<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 34.56</span>
<span class="ruby-value">-34.56</span>.<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 34.56</span>
<span class="ruby-value">34.56</span>.<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 34.56</span>
</pre>
<p><a href="Float.html#method-i-magnitude"><code>Float#magnitude</code></a> is an alias for <a href="Float.html#method-i-abs"><code>Float#abs</code></a>.</p>
<div class="method-source-code" id="magnitude-source">
<pre>VALUE
rb_float_abs(VALUE flt)
{
double val = fabs(RFLOAT_VALUE(flt));
return DBL2NUM(val);
}</pre>
</div>
</div>
</div>
<div id="method-i-modulo" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
modulo(other) → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the modulo after division of <code>float</code> by <code>other</code>.</p>
<pre class="ruby"><span class="ruby-value">6543.21</span>.<span class="ruby-identifier">modulo</span>(<span class="ruby-value">137</span>) <span class="ruby-comment">#=> 104.21000000000004</span>
<span class="ruby-value">6543.21</span>.<span class="ruby-identifier">modulo</span>(<span class="ruby-value">137.24</span>) <span class="ruby-comment">#=> 92.92999999999961</span>
</pre>
<div class="method-source-code" id="modulo-source">
<pre>static VALUE
flo_mod(VALUE x, VALUE y)
{
double fy;
if (RB_TYPE_P(y, T_FIXNUM)) {
fy = (double)FIX2LONG(y);
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
fy = rb_big2dbl(y);
}
else if (RB_TYPE_P(y, T_FLOAT)) {
fy = RFLOAT_VALUE(y);
}
else {
return rb_num_coerce_bin(x, y, '%');
}
return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(x), fy));
}</pre>
</div>
</div>
</div>
<div id="method-i-nan-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
nan? → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is an invalid IEEE floating point number.</p>
<pre class="ruby"><span class="ruby-identifier">a</span> = <span class="ruby-value">-1.0</span> <span class="ruby-comment">#=> -1.0</span>
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">nan?</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-identifier">a</span> = <span class="ruby-value">0.0</span><span class="ruby-operator">/</span><span class="ruby-value">0.0</span> <span class="ruby-comment">#=> NaN</span>
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">nan?</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="nan-3F-source">
<pre>static VALUE
flo_is_nan_p(VALUE num)
{
double value = RFLOAT_VALUE(num);
return isnan(value) ? Qtrue : Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-negative-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
negative? → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is less than 0.</p>
<div class="method-source-code" id="negative-3F-source">
<pre>static VALUE
flo_negative_p(VALUE num)
{
double f = RFLOAT_VALUE(num);
return f < 0.0 ? Qtrue : Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-next_float" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
next_float → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the next representable floating point number.</p>
<p>Float::MAX.next_float and Float::INFINITY.next_float is <a href="Float.html#INFINITY"><code>Float::INFINITY</code></a>.</p>
<p>Float::NAN.next_float is <a href="Float.html#NAN"><code>Float::NAN</code></a>.</p>
<p>For example:</p>
<pre class="ruby"><span class="ruby-value">0.01</span>.<span class="ruby-identifier">next_float</span> <span class="ruby-comment">#=> 0.010000000000000002</span>
<span class="ruby-value">1.0</span>.<span class="ruby-identifier">next_float</span> <span class="ruby-comment">#=> 1.0000000000000002</span>
<span class="ruby-value">100.0</span>.<span class="ruby-identifier">next_float</span> <span class="ruby-comment">#=> 100.00000000000001</span>
<span class="ruby-value">0.01</span>.<span class="ruby-identifier">next_float</span> <span class="ruby-operator">-</span> <span class="ruby-value">0.01</span> <span class="ruby-comment">#=> 1.734723475976807e-18</span>
<span class="ruby-value">1.0</span>.<span class="ruby-identifier">next_float</span> <span class="ruby-operator">-</span> <span class="ruby-value">1.0</span> <span class="ruby-comment">#=> 2.220446049250313e-16</span>
<span class="ruby-value">100.0</span>.<span class="ruby-identifier">next_float</span> <span class="ruby-operator">-</span> <span class="ruby-value">100.0</span> <span class="ruby-comment">#=> 1.4210854715202004e-14</span>
<span class="ruby-identifier">f</span> = <span class="ruby-value">0.01</span>; <span class="ruby-value">20</span>.<span class="ruby-identifier">times</span> { <span class="ruby-identifier">printf</span> <span class="ruby-string">"%-20a %s\n"</span>, <span class="ruby-identifier">f</span>, <span class="ruby-identifier">f</span>.<span class="ruby-identifier">to_s</span>; <span class="ruby-identifier">f</span> = <span class="ruby-identifier">f</span>.<span class="ruby-identifier">next_float</span> }
<span class="ruby-comment">#=> 0x1.47ae147ae147bp-7 0.01</span>
<span class="ruby-comment"># 0x1.47ae147ae147cp-7 0.010000000000000002</span>
<span class="ruby-comment"># 0x1.47ae147ae147dp-7 0.010000000000000004</span>
<span class="ruby-comment"># 0x1.47ae147ae147ep-7 0.010000000000000005</span>
<span class="ruby-comment"># 0x1.47ae147ae147fp-7 0.010000000000000007</span>
<span class="ruby-comment"># 0x1.47ae147ae148p-7 0.010000000000000009</span>
<span class="ruby-comment"># 0x1.47ae147ae1481p-7 0.01000000000000001</span>
<span class="ruby-comment"># 0x1.47ae147ae1482p-7 0.010000000000000012</span>
<span class="ruby-comment"># 0x1.47ae147ae1483p-7 0.010000000000000014</span>
<span class="ruby-comment"># 0x1.47ae147ae1484p-7 0.010000000000000016</span>
<span class="ruby-comment"># 0x1.47ae147ae1485p-7 0.010000000000000018</span>
<span class="ruby-comment"># 0x1.47ae147ae1486p-7 0.01000000000000002</span>
<span class="ruby-comment"># 0x1.47ae147ae1487p-7 0.010000000000000021</span>
<span class="ruby-comment"># 0x1.47ae147ae1488p-7 0.010000000000000023</span>
<span class="ruby-comment"># 0x1.47ae147ae1489p-7 0.010000000000000024</span>
<span class="ruby-comment"># 0x1.47ae147ae148ap-7 0.010000000000000026</span>
<span class="ruby-comment"># 0x1.47ae147ae148bp-7 0.010000000000000028</span>
<span class="ruby-comment"># 0x1.47ae147ae148cp-7 0.01000000000000003</span>
<span class="ruby-comment"># 0x1.47ae147ae148dp-7 0.010000000000000031</span>
<span class="ruby-comment"># 0x1.47ae147ae148ep-7 0.010000000000000033</span>
<span class="ruby-identifier">f</span> = <span class="ruby-value">0.0</span>
<span class="ruby-value">100</span>.<span class="ruby-identifier">times</span> { <span class="ruby-identifier">f</span> <span class="ruby-operator">+=</span> <span class="ruby-value">0.1</span> }
<span class="ruby-identifier">f</span> <span class="ruby-comment">#=> 9.99999999999998 # should be 10.0 in the ideal world.</span>
<span class="ruby-value">10</span><span class="ruby-operator">-</span><span class="ruby-identifier">f</span> <span class="ruby-comment">#=> 1.9539925233402755e-14 # the floating point error.</span>
<span class="ruby-value">10.0</span>.<span class="ruby-identifier">next_float</span><span class="ruby-value">-10</span> <span class="ruby-comment">#=> 1.7763568394002505e-15 # 1 ulp (unit in the last place).</span>
(<span class="ruby-value">10</span><span class="ruby-operator">-</span><span class="ruby-identifier">f</span>)<span class="ruby-operator">/</span>(<span class="ruby-value">10.0</span>.<span class="ruby-identifier">next_float</span><span class="ruby-value">-10</span>) <span class="ruby-comment">#=> 11.0 # the error is 11 ulp.</span>
(<span class="ruby-value">10</span><span class="ruby-operator">-</span><span class="ruby-identifier">f</span>)<span class="ruby-operator">/</span>(<span class="ruby-value">10</span><span class="ruby-operator">*</span><span class="ruby-constant">Float</span><span class="ruby-operator">::</span><span class="ruby-constant">EPSILON</span>) <span class="ruby-comment">#=> 8.8 # approximation of the above.</span>
<span class="ruby-string">"%a"</span> <span class="ruby-operator">%</span> <span class="ruby-value">10</span> <span class="ruby-comment">#=> "0x1.4p+3"</span>
<span class="ruby-string">"%a"</span> <span class="ruby-operator">%</span> <span class="ruby-identifier">f</span> <span class="ruby-comment">#=> "0x1.3fffffffffff5p+3" # the last hex digit is 5. 16 - 5 = 11 ulp.</span>
</pre>
<div class="method-source-code" id="next_float-source">
<pre>static VALUE
flo_next_float(VALUE vx)
{
double x, y;
x = NUM2DBL(vx);
y = nextafter(x, HUGE_VAL);
return DBL2NUM(y);
}</pre>
</div>
</div>
</div>
<div id="method-i-numerator" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
numerator → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the numerator. The result is machine dependent.</p>
<pre class="ruby"><span class="ruby-identifier">n</span> = <span class="ruby-value">0.3</span>.<span class="ruby-identifier">numerator</span> <span class="ruby-comment">#=> 5404319552844595</span>
<span class="ruby-identifier">d</span> = <span class="ruby-value">0.3</span>.<span class="ruby-identifier">denominator</span> <span class="ruby-comment">#=> 18014398509481984</span>
<span class="ruby-identifier">n</span>.<span class="ruby-identifier">fdiv</span>(<span class="ruby-identifier">d</span>) <span class="ruby-comment">#=> 0.3</span>
</pre>
<p>See also <a href="Float.html#method-i-denominator"><code>Float#denominator</code></a>.</p>
<div class="method-source-code" id="numerator-source">
<pre>VALUE
rb_float_numerator(VALUE self)
{
double d = RFLOAT_VALUE(self);
VALUE r;
if (isinf(d) || isnan(d))
return self;
r = float_to_r(self);
if (canonicalization && k_integer_p(r)) {
return r;
}
return nurat_numerator(r);
}</pre>
</div>
</div>
</div>
<div id="method-i-phase" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
phase → 0 or float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns 0 if the value is positive, pi otherwise.</p>
<div class="method-source-code" id="phase-source">
<pre>static VALUE
float_arg(VALUE self)
{
if (isnan(RFLOAT_VALUE(self)))
return self;
if (f_tpositive_p(self))
return INT2FIX(0);
return rb_const_get(rb_mMath, id_PI);
}</pre>
</div>
</div>
</div>
<div id="method-i-positive-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
positive? → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is greater than 0.</p>
<div class="method-source-code" id="positive-3F-source">
<pre>static VALUE
flo_positive_p(VALUE num)
{
double f = RFLOAT_VALUE(num);
return f > 0.0 ? Qtrue : Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-prev_float" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
prev_float → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the previous representable floating point number.</p>
<p>(-Float::MAX).prev_float and (-Float::INFINITY).prev_float is -Float::INFINITY.</p>
<p>Float::NAN.prev_float is <a href="Float.html#NAN"><code>Float::NAN</code></a>.</p>
<p>For example:</p>
<pre class="ruby"><span class="ruby-value">0.01</span>.<span class="ruby-identifier">prev_float</span> <span class="ruby-comment">#=> 0.009999999999999998</span>
<span class="ruby-value">1.0</span>.<span class="ruby-identifier">prev_float</span> <span class="ruby-comment">#=> 0.9999999999999999</span>
<span class="ruby-value">100.0</span>.<span class="ruby-identifier">prev_float</span> <span class="ruby-comment">#=> 99.99999999999999</span>
<span class="ruby-value">0.01</span> <span class="ruby-operator">-</span> <span class="ruby-value">0.01</span>.<span class="ruby-identifier">prev_float</span> <span class="ruby-comment">#=> 1.734723475976807e-18</span>
<span class="ruby-value">1.0</span> <span class="ruby-operator">-</span> <span class="ruby-value">1.0</span>.<span class="ruby-identifier">prev_float</span> <span class="ruby-comment">#=> 1.1102230246251565e-16</span>
<span class="ruby-value">100.0</span> <span class="ruby-operator">-</span> <span class="ruby-value">100.0</span>.<span class="ruby-identifier">prev_float</span> <span class="ruby-comment">#=> 1.4210854715202004e-14</span>
<span class="ruby-identifier">f</span> = <span class="ruby-value">0.01</span>; <span class="ruby-value">20</span>.<span class="ruby-identifier">times</span> { <span class="ruby-identifier">printf</span> <span class="ruby-string">"%-20a %s\n"</span>, <span class="ruby-identifier">f</span>, <span class="ruby-identifier">f</span>.<span class="ruby-identifier">to_s</span>; <span class="ruby-identifier">f</span> = <span class="ruby-identifier">f</span>.<span class="ruby-identifier">prev_float</span> }
<span class="ruby-comment">#=> 0x1.47ae147ae147bp-7 0.01</span>
<span class="ruby-comment"># 0x1.47ae147ae147ap-7 0.009999999999999998</span>
<span class="ruby-comment"># 0x1.47ae147ae1479p-7 0.009999999999999997</span>
<span class="ruby-comment"># 0x1.47ae147ae1478p-7 0.009999999999999995</span>
<span class="ruby-comment"># 0x1.47ae147ae1477p-7 0.009999999999999993</span>
<span class="ruby-comment"># 0x1.47ae147ae1476p-7 0.009999999999999992</span>
<span class="ruby-comment"># 0x1.47ae147ae1475p-7 0.00999999999999999</span>
<span class="ruby-comment"># 0x1.47ae147ae1474p-7 0.009999999999999988</span>
<span class="ruby-comment"># 0x1.47ae147ae1473p-7 0.009999999999999986</span>
<span class="ruby-comment"># 0x1.47ae147ae1472p-7 0.009999999999999985</span>
<span class="ruby-comment"># 0x1.47ae147ae1471p-7 0.009999999999999983</span>
<span class="ruby-comment"># 0x1.47ae147ae147p-7 0.009999999999999981</span>
<span class="ruby-comment"># 0x1.47ae147ae146fp-7 0.00999999999999998</span>
<span class="ruby-comment"># 0x1.47ae147ae146ep-7 0.009999999999999978</span>
<span class="ruby-comment"># 0x1.47ae147ae146dp-7 0.009999999999999976</span>
<span class="ruby-comment"># 0x1.47ae147ae146cp-7 0.009999999999999974</span>
<span class="ruby-comment"># 0x1.47ae147ae146bp-7 0.009999999999999972</span>
<span class="ruby-comment"># 0x1.47ae147ae146ap-7 0.00999999999999997</span>
<span class="ruby-comment"># 0x1.47ae147ae1469p-7 0.009999999999999969</span>
<span class="ruby-comment"># 0x1.47ae147ae1468p-7 0.009999999999999967</span>
</pre>
<div class="method-source-code" id="prev_float-source">
<pre>static VALUE
flo_prev_float(VALUE vx)
{
double x, y;
x = NUM2DBL(vx);
y = nextafter(x, -HUGE_VAL);
return DBL2NUM(y);
}</pre>
</div>
</div>
</div>
<div id="method-i-quo" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
quo(numeric) → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>float / numeric</code>, same as Float#/.</p>
<div class="method-source-code" id="quo-source">
<pre>static VALUE
flo_quo(VALUE x, VALUE y)
{
return num_funcall1(x, '/', y);
}</pre>
</div>
</div>
</div>
<div id="method-i-rationalize" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rationalize([eps]) → rational
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a simpler approximation of the value (flt-|eps| <= result <= flt+|eps|). If the optional argument <code>eps</code> is not given, it will be chosen automatically.</p>
<pre class="ruby"><span class="ruby-value">0.3</span>.<span class="ruby-identifier">rationalize</span> <span class="ruby-comment">#=> (3/10)</span>
<span class="ruby-value">1.333</span>.<span class="ruby-identifier">rationalize</span> <span class="ruby-comment">#=> (1333/1000)</span>
<span class="ruby-value">1.333</span>.<span class="ruby-identifier">rationalize</span>(<span class="ruby-value">0.01</span>) <span class="ruby-comment">#=> (4/3)</span>
</pre>
<p>See also <a href="Float.html#method-i-to_r"><code>Float#to_r</code></a>.</p>
<div class="method-source-code" id="rationalize-source">
<pre>static VALUE
float_rationalize(int argc, VALUE *argv, VALUE self)
{
double d = RFLOAT_VALUE(self);
if (d < 0.0)
return rb_rational_uminus(float_rationalize(argc, argv, DBL2NUM(-d)));
if (rb_check_arity(argc, 0, 1)) {
return rb_flt_rationalize_with_prec(self, argv[0]);
}
else {
return rb_flt_rationalize(self);
}
}</pre>
</div>
</div>
</div>
<div id="method-i-round" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
round([ndigits] [, half: mode]) → integer or float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>float</code> rounded to the nearest value with a precision of <code>ndigits</code> decimal digits (default: 0).</p>
<p>When the precision is negative, the returned value is an integer with at least <code>ndigits.abs</code> trailing zeros.</p>
<p>Returns a floating point number when <code>ndigits</code> is positive, otherwise returns an integer.</p>
<pre class="ruby"><span class="ruby-value">1.4</span>.<span class="ruby-identifier">round</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">1.5</span>.<span class="ruby-identifier">round</span> <span class="ruby-comment">#=> 2</span>
<span class="ruby-value">1.6</span>.<span class="ruby-identifier">round</span> <span class="ruby-comment">#=> 2</span>
(<span class="ruby-value">-1.5</span>).<span class="ruby-identifier">round</span> <span class="ruby-comment">#=> -2</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1.23</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> 1.235</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">4</span>) <span class="ruby-comment">#=> 1.2346</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">5</span>) <span class="ruby-comment">#=> 1.23457</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">-5</span>) <span class="ruby-comment">#=> 0</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">-4</span>) <span class="ruby-comment">#=> 30000</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">-3</span>) <span class="ruby-comment">#=> 35000</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">-2</span>) <span class="ruby-comment">#=> 34600</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 34570</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 34568</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 34567.9</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 34567.89</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> 34567.89</span>
</pre>
<p>If the optional <code>half</code> keyword argument is given, numbers that are half-way between two possible rounded values will be rounded according to the specified tie-breaking <code>mode</code>:</p>
<ul><li>
<p><code>:up</code> or <code>nil</code>: round half away from zero (default)</p>
</li><li>
<p><code>:down</code>: round half toward zero</p>
</li><li>
<p><code>:even</code>: round half toward the nearest even number</p>
<pre class="ruby"><span class="ruby-value">2.5</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:up</span>) <span class="ruby-comment">#=> 3</span>
<span class="ruby-value">2.5</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:down</span>) <span class="ruby-comment">#=> 2</span>
<span class="ruby-value">2.5</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:even</span>) <span class="ruby-comment">#=> 2</span>
<span class="ruby-value">3.5</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:up</span>) <span class="ruby-comment">#=> 4</span>
<span class="ruby-value">3.5</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:down</span>) <span class="ruby-comment">#=> 3</span>
<span class="ruby-value">3.5</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:even</span>) <span class="ruby-comment">#=> 4</span>
(<span class="ruby-value">-2.5</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:up</span>) <span class="ruby-comment">#=> -3</span>
(<span class="ruby-value">-2.5</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:down</span>) <span class="ruby-comment">#=> -2</span>
(<span class="ruby-value">-2.5</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">half:</span> <span class="ruby-value">:even</span>) <span class="ruby-comment">#=> -2</span>
</pre>
</li></ul>
<div class="method-source-code" id="round-source">
<pre>static VALUE
flo_round(int argc, VALUE *argv, VALUE num)
{
double number, f, x;
VALUE nd, opt;
int ndigits = 0;
enum ruby_num_rounding_mode mode;
if (rb_scan_args(argc, argv, "01:", &nd, &opt)) {
ndigits = NUM2INT(nd);
}
mode = rb_num_get_rounding_option(opt);
number = RFLOAT_VALUE(num);
if (number == 0.0) {
return ndigits > 0 ? DBL2NUM(number) : INT2FIX(0);
}
if (ndigits < 0) {
return rb_int_round(flo_to_i(num), ndigits, mode);
}
if (ndigits == 0) {
x = ROUND_CALL(mode, round, (number, 1.0));
return dbl2ival(x);
}
if (isfinite(number)) {
int binexp;
frexp(number, &binexp);
if (float_round_overflow(ndigits, binexp)) return num;
if (float_round_underflow(ndigits, binexp)) return DBL2NUM(0);
f = pow(10, ndigits);
x = ROUND_CALL(mode, round, (number, f));
return DBL2NUM(x / f);
}
return num;
}</pre>
</div>
</div>
</div>
<div id="method-i-to_d" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_d → bigdecimal
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
to_d(precision) → bigdecimal
</span>
</div>
<div class="method-description">
<p>Returns the value of <code>float</code> as a <a href="BigDecimal.html"><code>BigDecimal</code></a>. The <code>precision</code> parameter is used to determine the number of significant digits for the result (the default is <a href="Float.html#DIG"><code>Float::DIG</code></a>).</p>
<pre class="ruby"><span class="ruby-identifier">require</span> <span class="ruby-string">'bigdecimal'</span>
<span class="ruby-identifier">require</span> <span class="ruby-string">'bigdecimal/util'</span>
<span class="ruby-value">0.5</span>.<span class="ruby-identifier">to_d</span> <span class="ruby-comment"># => 0.5e0</span>
<span class="ruby-value">1.234</span>.<span class="ruby-identifier">to_d</span>(<span class="ruby-value">2</span>) <span class="ruby-comment"># => 0.12e1</span>
</pre>
<p>See also <a href="BasicObject.html#method-c-new"><code>BigDecimal::new</code></a>.</p>
<div class="method-source-code" id="to_d-source">
<pre><span class="ruby-comment"># File ext/bigdecimal/lib/bigdecimal/util.rb, line 46</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_d</span>(<span class="ruby-identifier">precision</span>=<span class="ruby-constant">Float</span><span class="ruby-operator">::</span><span class="ruby-constant">DIG</span>)
<span class="ruby-constant">BigDecimal</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">precision</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-to_f" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_f → self
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Since <code>float</code> is already a <a href="Float.html"><code>Float</code></a>, returns <code>self</code>.</p>
<div class="method-source-code" id="to_f-source">
<pre>static VALUE
flo_to_f(VALUE num)
{
return num;
}</pre>
</div>
</div>
</div>
<div id="method-i-to_i" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_i → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
to_int → integer
</span>
</div>
<div class="method-description">
<p>Returns the <code>float</code> truncated to an <a href="Integer.html"><code>Integer</code></a>.</p>
<pre class="ruby"><span class="ruby-value">1.2</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 1</span>
(<span class="ruby-value">-1.2</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> -1</span>
</pre>
<p>Note that the limited precision of floating point arithmetic might lead to surprising results:</p>
<pre class="ruby">(<span class="ruby-value">0.3</span> <span class="ruby-operator">/</span> <span class="ruby-value">0.1</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 2 (!)</span>
</pre>
<p><a href="Float.html#method-i-to_int"><code>to_int</code></a> is an alias for <a href="Float.html#method-i-to_i"><code>to_i</code></a>.</p>
<div class="method-source-code" id="to_i-source">
<pre>static VALUE
flo_to_i(VALUE num)
{
double f = RFLOAT_VALUE(num);
if (f > 0.0) f = floor(f);
if (f < 0.0) f = ceil(f);
return dbl2ival(f);
}</pre>
</div>
</div>
</div>
<div id="method-i-to_int" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_int → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the <code>float</code> truncated to an <a href="Integer.html"><code>Integer</code></a>.</p>
<pre class="ruby"><span class="ruby-value">1.2</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 1</span>
(<span class="ruby-value">-1.2</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> -1</span>
</pre>
<p>Note that the limited precision of floating point arithmetic might lead to surprising results:</p>
<pre class="ruby">(<span class="ruby-value">0.3</span> <span class="ruby-operator">/</span> <span class="ruby-value">0.1</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 2 (!)</span>
</pre>
<p><a href="Float.html#method-i-to_int"><code>to_int</code></a> is an alias for <a href="Float.html#method-i-to_i"><code>to_i</code></a>.</p>
<div class="method-source-code" id="to_int-source">
<pre>static VALUE
flo_to_i(VALUE num)
{
double f = RFLOAT_VALUE(num);
if (f > 0.0) f = floor(f);
if (f < 0.0) f = ceil(f);
return dbl2ival(f);
}</pre>
</div>
</div>
</div>
<div id="method-i-to_r" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_r → rational
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the value as a rational.</p>
<pre class="ruby"><span class="ruby-value">2.0</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (2/1)</span>
<span class="ruby-value">2.5</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (5/2)</span>
<span class="ruby-value">-0.75</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (-3/4)</span>
<span class="ruby-value">0.0</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (0/1)</span>
<span class="ruby-value">0.3</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (5404319552844595/18014398509481984)</span>
</pre>
<p>NOTE: 0.3.to_r isn't the same as “0.3”.to_r. The latter is equivalent to “3/10”.to_r, but the former isn't so.</p>
<pre class="ruby"><span class="ruby-value">0.3</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-operator">==</span> <span class="ruby-value">3</span><span class="ruby-operator">/</span><span class="ruby-value">10r</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-string">"0.3"</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-operator">==</span> <span class="ruby-value">3</span><span class="ruby-operator">/</span><span class="ruby-value">10r</span> <span class="ruby-comment">#=> true</span>
</pre>
<p>See also <a href="Float.html#method-i-rationalize"><code>Float#rationalize</code></a>.</p>
<div class="method-source-code" id="to_r-source">
<pre>static VALUE
float_to_r(VALUE self)
{
VALUE f;
int n;
float_decode_internal(self, &f, &n);
#if FLT_RADIX == 2
if (n == 0)
return rb_rational_new1(f);
if (n > 0)
return rb_rational_new1(rb_int_lshift(f, INT2FIX(n)));
n = -n;
return rb_rational_new2(f, rb_int_lshift(ONE, INT2FIX(n)));
#else
f = rb_int_mul(f, rb_int_pow(INT2FIX(FLT_RADIX), n));
if (RB_TYPE_P(f, T_RATIONAL))
return f;
return rb_rational_new1(f);
#endif
}</pre>
</div>
</div>
</div>
<div id="method-i-to_s" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_s → string
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a string containing a representation of <code>self</code>. As well as a fixed or exponential form of the <code>float</code>, the call may return <code>NaN</code>, <code>Infinity</code>, and <code>-Infinity</code>.</p>
<div class="method-source-code" id="to_s-source">
<pre>static VALUE
flo_to_s(VALUE flt)
{
enum {decimal_mant = DBL_MANT_DIG-DBL_DIG};
enum {float_dig = DBL_DIG+1};
char buf[float_dig + (decimal_mant + CHAR_BIT - 1) / CHAR_BIT + 10];
double value = RFLOAT_VALUE(flt);
VALUE s;
char *p, *e;
int sign, decpt, digs;
if (isinf(value)) {
static const char minf[] = "-Infinity";
const int pos = (value > 0); /* skip "-" */
return rb_usascii_str_new(minf+pos, strlen(minf)-pos);
}
else if (isnan(value))
return rb_usascii_str_new2("NaN");
p = ruby_dtoa(value, 0, 0, &decpt, &sign, &e);
s = sign ? rb_usascii_str_new_cstr("-") : rb_usascii_str_new(0, 0);
if ((digs = (int)(e - p)) >= (int)sizeof(buf)) digs = (int)sizeof(buf) - 1;
memcpy(buf, p, digs);
xfree(p);
if (decpt > 0) {
if (decpt < digs) {
memmove(buf + decpt + 1, buf + decpt, digs - decpt);
buf[decpt] = '.';
rb_str_cat(s, buf, digs + 1);
}
else if (decpt <= DBL_DIG) {
long len;
char *ptr;
rb_str_cat(s, buf, digs);
rb_str_resize(s, (len = RSTRING_LEN(s)) + decpt - digs + 2);
ptr = RSTRING_PTR(s) + len;
if (decpt > digs) {
memset(ptr, '0', decpt - digs);
ptr += decpt - digs;
}
memcpy(ptr, ".0", 2);
}
else {
goto exp;
}
}
else if (decpt > -4) {
long len;
char *ptr;
rb_str_cat(s, "0.", 2);
rb_str_resize(s, (len = RSTRING_LEN(s)) - decpt + digs);
ptr = RSTRING_PTR(s);
memset(ptr += len, '0', -decpt);
memcpy(ptr -= decpt, buf, digs);
}
else {
exp:
if (digs > 1) {
memmove(buf + 2, buf + 1, digs - 1);
}
else {
buf[2] = '0';
digs++;
}
buf[1] = '.';
rb_str_cat(s, buf, digs + 1);
rb_str_catf(s, "e%+03d", decpt - 1);
}
return s;
}</pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="Float.html#method-i-inspect">inspect</a>
</div>
</div>
<div id="method-i-truncate" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
truncate([ndigits]) → integer or float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>float</code> truncated (toward zero) to a precision of <code>ndigits</code> decimal digits (default: 0).</p>
<p>When the precision is negative, the returned value is an integer with at least <code>ndigits.abs</code> trailing zeros.</p>
<p>Returns a floating point number when <code>ndigits</code> is positive, otherwise returns an integer.</p>
<pre class="ruby"><span class="ruby-value">2.8</span>.<span class="ruby-identifier">truncate</span> <span class="ruby-comment">#=> 2</span>
(<span class="ruby-value">-2.8</span>).<span class="ruby-identifier">truncate</span> <span class="ruby-comment">#=> -2</span>
<span class="ruby-value">1.234567</span>.<span class="ruby-identifier">truncate</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1.23</span>
<span class="ruby-value">34567.89</span>.<span class="ruby-identifier">truncate</span>(<span class="ruby-value">-2</span>) <span class="ruby-comment">#=> 34500</span>
</pre>
<p>Note that the limited precision of floating point arithmetic might lead to surprising results:</p>
<pre class="ruby">(<span class="ruby-value">0.3</span> <span class="ruby-operator">/</span> <span class="ruby-value">0.1</span>).<span class="ruby-identifier">truncate</span> <span class="ruby-comment">#=> 2 (!)</span>
</pre>
<div class="method-source-code" id="truncate-source">
<pre>static VALUE
flo_truncate(int argc, VALUE *argv, VALUE num)
{
if (signbit(RFLOAT_VALUE(num)))
return flo_ceil(argc, argv, num);
else
return flo_floor(argc, argv, num);
}</pre>
</div>
</div>
</div>
<div id="method-i-zero-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
zero? → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <code>float</code> is 0.0.</p>
<div class="method-source-code" id="zero-3F-source">
<pre>static VALUE
flo_zero_p(VALUE num)
{
return flo_iszero(num) ? Qtrue : Qfalse;
}</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>