File: C:/Ruby27-x64/share/doc/ruby/html/Rational.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class Rational - 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-c-json_create">::json_create</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-3D-3E">#<=></a>
<li ><a href="#method-i-3D-3D">#==</a>
<li ><a href="#method-i-abs">#abs</a>
<li ><a href="#method-i-as_json">#as_json</a>
<li ><a href="#method-i-ceil">#ceil</a>
<li ><a href="#method-i-denominator">#denominator</a>
<li ><a href="#method-i-fdiv">#fdiv</a>
<li ><a href="#method-i-floor">#floor</a>
<li ><a href="#method-i-inspect">#inspect</a>
<li ><a href="#method-i-magnitude">#magnitude</a>
<li ><a href="#method-i-negative-3F">#negative?</a>
<li ><a href="#method-i-numerator">#numerator</a>
<li ><a href="#method-i-positive-3F">#positive?</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_json">#to_json</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>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-Rational">
<h1 id="class-Rational" class="class">
class Rational
</h1>
<section class="description">
<p>A rational number can be represented as a pair of integer numbers: a/b (b>0), where a is the numerator and b is the denominator. <a href="Integer.html"><code>Integer</code></a> a equals rational a/1 mathematically.</p>
<p>In Ruby, you can create rational objects with the Kernel#Rational, <a href="Rational.html#method-i-to_r"><code>to_r</code></a>, or rationalize methods or by suffixing <code>r</code> to a literal. The return values will be irreducible fractions.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> (1/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> (2/3)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">4</span>, <span class="ruby-value">-6</span>) <span class="ruby-comment">#=> (-2/3)</span>
<span class="ruby-value">3</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (3/1)</span>
<span class="ruby-value">2</span><span class="ruby-operator">/</span><span class="ruby-value">3r</span> <span class="ruby-comment">#=> (2/3)</span>
</pre>
<p>You can also create rational objects from floating-point numbers or strings.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">0.3</span>) <span class="ruby-comment">#=> (5404319552844595/18014398509481984)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'0.3'</span>) <span class="ruby-comment">#=> (3/10)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'2/3'</span>) <span class="ruby-comment">#=> (2/3)</span>
<span class="ruby-value">0.3</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (5404319552844595/18014398509481984)</span>
<span class="ruby-string">'0.3'</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (3/10)</span>
<span class="ruby-string">'2/3'</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (2/3)</span>
<span class="ruby-value">0.3</span>.<span class="ruby-identifier">rationalize</span> <span class="ruby-comment">#=> (3/10)</span>
</pre>
<p>A rational object is an exact number, which helps you to write programs without any rounding errors.</p>
<pre class="ruby"><span class="ruby-value">10</span>.<span class="ruby-identifier">times</span>.<span class="ruby-identifier">inject</span>(<span class="ruby-value">0</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">t</span><span class="ruby-operator">|</span> <span class="ruby-identifier">t</span> <span class="ruby-operator">+</span> <span class="ruby-value">0.1</span> } <span class="ruby-comment">#=> 0.9999999999999999</span>
<span class="ruby-value">10</span>.<span class="ruby-identifier">times</span>.<span class="ruby-identifier">inject</span>(<span class="ruby-value">0</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">t</span><span class="ruby-operator">|</span> <span class="ruby-identifier">t</span> <span class="ruby-operator">+</span> <span class="ruby-constant">Rational</span>(<span class="ruby-string">'0.1'</span>) } <span class="ruby-comment">#=> (1/1)</span>
</pre>
<p>However, when an expression includes an inexact component (numerical value or operation), it will produce an inexact result.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">10</span>) <span class="ruby-operator">/</span> <span class="ruby-value">3</span> <span class="ruby-comment">#=> (10/3)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">10</span>) <span class="ruby-operator">/</span> <span class="ruby-value">3.0</span> <span class="ruby-comment">#=> 3.3333333333333335</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-8</span>) <span class="ruby-operator">**</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>, <span class="ruby-value">3</span>)
<span class="ruby-comment">#=> (1.0000000000000002+1.7320508075688772i)</span>
</pre>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-json_create" class="method-detail ">
<div class="method-heading">
<span class="method-name">json_create</span><span
class="method-args">(object)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Deserializes <a href="JSON.html"><code>JSON</code></a> string by converting numerator value <code>n</code>, denominator value <code>d</code>, to a <a href="Rational.html"><code>Rational</code></a> object.</p>
<div class="method-source-code" id="json_create-source">
<pre><span class="ruby-comment"># File ext/json/lib/json/add/rational.rb, line 10</span>
<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">json_create</span>(<span class="ruby-identifier">object</span>)
<span class="ruby-constant">Rational</span>(<span class="ruby-identifier">object</span>[<span class="ruby-string">'n'</span>], <span class="ruby-identifier">object</span>[<span class="ruby-string">'d'</span>])
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
<section id="public-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Instance Methods</h3>
</header>
<div id="method-i-2A" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rat * numeric → numeric
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs multiplication.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-operator">*</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> (4/9)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">900</span>) <span class="ruby-operator">*</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> (900/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-2</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">*</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">-9</span>, <span class="ruby-value">2</span>) <span class="ruby-comment">#=> (1/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">9</span>, <span class="ruby-value">8</span>) <span class="ruby-operator">*</span> <span class="ruby-value">4</span> <span class="ruby-comment">#=> (9/2)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">20</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">*</span> <span class="ruby-value">9.8</span> <span class="ruby-comment">#=> 21.77777777777778</span>
</pre>
<div class="method-source-code" id="2A-source">
<pre>VALUE
rb_rational_mul(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
{
get_dat1(self);
return f_muldiv(self,
dat->num, dat->den,
other, ONE, '*');
}
}
else if (RB_FLOAT_TYPE_P(other)) {
return DBL2NUM(nurat_to_double(self) * RFLOAT_VALUE(other));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
{
get_dat2(self, other);
return f_muldiv(self,
adat->num, adat->den,
bdat->num, bdat->den, '*');
}
}
else {
return rb_num_coerce_bin(self, other, '*');
}
}</pre>
</div>
</div>
</div>
<div id="method-i-2A-2A" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rat ** numeric → numeric
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs exponentiation.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>) <span class="ruby-operator">**</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> (8/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">10</span>) <span class="ruby-operator">**</span> <span class="ruby-value">-2</span> <span class="ruby-comment">#=> (1/100)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">10</span>) <span class="ruby-operator">**</span> <span class="ruby-value">-2.0</span> <span class="ruby-comment">#=> 0.01</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-4</span>) <span class="ruby-operator">**</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>, <span class="ruby-value">2</span>) <span class="ruby-comment">#=> (0.0+2.0i)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>, <span class="ruby-value">2</span>) <span class="ruby-operator">**</span> <span class="ruby-value">0</span> <span class="ruby-comment">#=> (1/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>, <span class="ruby-value">2</span>) <span class="ruby-operator">**</span> <span class="ruby-value">0.0</span> <span class="ruby-comment">#=> 1.0</span>
</pre>
<div class="method-source-code" id="2A-2A-source">
<pre>VALUE
rb_rational_pow(VALUE self, VALUE other)
{
if (k_numeric_p(other) && k_exact_zero_p(other))
return f_rational_new_bang1(CLASS_OF(self), ONE);
if (k_rational_p(other)) {
get_dat1(other);
if (f_one_p(dat->den))
other = dat->num; /* c14n */
}
/* Deal with special cases of 0**n and 1**n */
if (k_numeric_p(other) && k_exact_p(other)) {
get_dat1(self);
if (f_one_p(dat->den)) {
if (f_one_p(dat->num)) {
return f_rational_new_bang1(CLASS_OF(self), ONE);
}
else if (f_minus_one_p(dat->num) && RB_INTEGER_TYPE_P(other)) {
return f_rational_new_bang1(CLASS_OF(self), INT2FIX(f_odd_p(other) ? -1 : 1));
}
else if (INT_ZERO_P(dat->num)) {
if (rb_num_negative_p(other)) {
rb_num_zerodiv();
}
else {
return f_rational_new_bang1(CLASS_OF(self), ZERO);
}
}
}
}
/* General case */
if (FIXNUM_P(other)) {
{
VALUE num, den;
get_dat1(self);
if (INT_POSITIVE_P(other)) {
num = rb_int_pow(dat->num, other);
den = rb_int_pow(dat->den, other);
}
else if (INT_NEGATIVE_P(other)) {
num = rb_int_pow(dat->den, rb_int_uminus(other));
den = rb_int_pow(dat->num, rb_int_uminus(other));
}
else {
num = ONE;
den = ONE;
}
if (RB_FLOAT_TYPE_P(num)) { /* infinity due to overflow */
if (RB_FLOAT_TYPE_P(den))
return DBL2NUM(nan(""));
return num;
}
if (RB_FLOAT_TYPE_P(den)) { /* infinity due to overflow */
num = ZERO;
den = ONE;
}
return f_rational_new2(CLASS_OF(self), num, den);
}
}
else if (RB_TYPE_P(other, T_BIGNUM)) {
rb_warn("in a**b, b may be too big");
return rb_float_pow(nurat_to_f(self), other);
}
else if (RB_FLOAT_TYPE_P(other) || RB_TYPE_P(other, T_RATIONAL)) {
return rb_float_pow(nurat_to_f(self), other);
}
else {
return rb_num_coerce_bin(self, other, rb_intern("**"));
}
}</pre>
</div>
</div>
</div>
<div id="method-i-2B" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rat + numeric → numeric
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs addition.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-operator">+</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> (4/3)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">900</span>) <span class="ruby-operator">+</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> (901/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-2</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">+</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">-9</span>, <span class="ruby-value">2</span>) <span class="ruby-comment">#=> (-85/18)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">9</span>, <span class="ruby-value">8</span>) <span class="ruby-operator">+</span> <span class="ruby-value">4</span> <span class="ruby-comment">#=> (41/8)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">20</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">+</span> <span class="ruby-value">9.8</span> <span class="ruby-comment">#=> 12.022222222222222</span>
</pre>
<div class="method-source-code" id="2B-source">
<pre>VALUE
rb_rational_plus(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
{
get_dat1(self);
return f_rational_new_no_reduce2(CLASS_OF(self),
rb_int_plus(dat->num, rb_int_mul(other, dat->den)),
dat->den);
}
}
else if (RB_FLOAT_TYPE_P(other)) {
return DBL2NUM(nurat_to_double(self) + RFLOAT_VALUE(other));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
{
get_dat2(self, other);
return f_addsub(self,
adat->num, adat->den,
bdat->num, bdat->den, '+');
}
}
else {
return rb_num_coerce_bin(self, other, '+');
}
}</pre>
</div>
</div>
</div>
<div id="method-i-2D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rat - numeric → numeric
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs subtraction.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-operator">-</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> (0/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">900</span>) <span class="ruby-operator">-</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> (899/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-2</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">-</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">-9</span>, <span class="ruby-value">2</span>) <span class="ruby-comment">#=> (77/18)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">9</span>, <span class="ruby-value">8</span>) <span class="ruby-operator">-</span> <span class="ruby-value">4</span> <span class="ruby-comment">#=> (-23/8)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">20</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">-</span> <span class="ruby-value">9.8</span> <span class="ruby-comment">#=> -7.577777777777778</span>
</pre>
<div class="method-source-code" id="2D-source">
<pre>VALUE
rb_rational_minus(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
{
get_dat1(self);
return f_rational_new_no_reduce2(CLASS_OF(self),
rb_int_minus(dat->num, rb_int_mul(other, dat->den)),
dat->den);
}
}
else if (RB_FLOAT_TYPE_P(other)) {
return DBL2NUM(nurat_to_double(self) - RFLOAT_VALUE(other));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
{
get_dat2(self, other);
return f_addsub(self,
adat->num, adat->den,
bdat->num, bdat->den, '-');
}
}
else {
return rb_num_coerce_bin(self, other, '-');
}
}</pre>
</div>
</div>
</div>
<div id="method-i-2D-40" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
-rat → rational
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Negates <code>rat</code>.</p>
<div class="method-source-code" id="2D-40-source">
<pre>VALUE
rb_rational_uminus(VALUE self)
{
const int unused = (assert(RB_TYPE_P(self, T_RATIONAL)), 0);
get_dat1(self);
(void)unused;
return f_rational_new2(CLASS_OF(self), rb_int_uminus(dat->num), dat->den);
}</pre>
</div>
</div>
</div>
<div id="method-i-2F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rat / numeric → numeric
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs division.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-operator">/</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> (1/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">900</span>) <span class="ruby-operator">/</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> (900/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-2</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">/</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">-9</span>, <span class="ruby-value">2</span>) <span class="ruby-comment">#=> (4/81)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">9</span>, <span class="ruby-value">8</span>) <span class="ruby-operator">/</span> <span class="ruby-value">4</span> <span class="ruby-comment">#=> (9/32)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">20</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">/</span> <span class="ruby-value">9.8</span> <span class="ruby-comment">#=> 0.22675736961451246</span>
</pre>
<div class="method-source-code" id="2F-source">
<pre>VALUE
rb_rational_div(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
if (f_zero_p(other))
rb_num_zerodiv();
{
get_dat1(self);
return f_muldiv(self,
dat->num, dat->den,
other, ONE, '/');
}
}
else if (RB_FLOAT_TYPE_P(other)) {
VALUE v = nurat_to_f(self);
return rb_flo_div_flo(v, other);
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
if (f_zero_p(other))
rb_num_zerodiv();
{
get_dat2(self, other);
if (f_one_p(self))
return f_rational_new_no_reduce2(CLASS_OF(self),
bdat->den, bdat->num);
return f_muldiv(self,
adat->num, adat->den,
bdat->num, bdat->den, '/');
}
}
else {
return rb_num_coerce_bin(self, other, '/');
}
}</pre>
</div>
</div>
</div>
<div id="method-i-3C-3D-3E" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rational <=> numeric → -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>rational</code> is less than, equal to, or greater than <code>numeric</code>.</p>
<p><code>nil</code> is returned if the two values are incomparable.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-operator"><=></span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> 0</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">5</span>) <span class="ruby-operator"><=></span> <span class="ruby-value">5</span> <span class="ruby-comment">#=> 0</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-operator"><=></span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> 1</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>, <span class="ruby-value">3</span>) <span class="ruby-operator"><=></span> <span class="ruby-value">1</span> <span class="ruby-comment">#=> -1</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>, <span class="ruby-value">3</span>) <span class="ruby-operator"><=></span> <span class="ruby-value">0.3</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>, <span class="ruby-value">3</span>) <span class="ruby-operator"><=></span> <span class="ruby-string">"0.3"</span> <span class="ruby-comment">#=> nil</span>
</pre>
<div class="method-source-code" id="3C-3D-3E-source">
<pre>VALUE
rb_rational_cmp(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
{
get_dat1(self);
if (dat->den == LONG2FIX(1))
return rb_int_cmp(dat->num, other); /* c14n */
other = f_rational_new_bang1(CLASS_OF(self), other);
goto other_is_rational;
}
}
else if (RB_FLOAT_TYPE_P(other)) {
return rb_dbl_cmp(nurat_to_double(self), RFLOAT_VALUE(other));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
other_is_rational:
{
VALUE num1, num2;
get_dat2(self, other);
if (FIXNUM_P(adat->num) && FIXNUM_P(adat->den) &&
FIXNUM_P(bdat->num) && FIXNUM_P(bdat->den)) {
num1 = f_imul(FIX2LONG(adat->num), FIX2LONG(bdat->den));
num2 = f_imul(FIX2LONG(bdat->num), FIX2LONG(adat->den));
}
else {
num1 = rb_int_mul(adat->num, bdat->den);
num2 = rb_int_mul(bdat->num, adat->den);
}
return rb_int_cmp(rb_int_minus(num1, num2), ZERO);
}
}
else {
return rb_num_coerce_cmp(self, other, rb_intern("<=>"));
}
}</pre>
</div>
</div>
</div>
<div id="method-i-3D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rat == object → 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>rat</code> equals <code>object</code> numerically.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-operator">==</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> true</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">5</span>) <span class="ruby-operator">==</span> <span class="ruby-value">5</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">0</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0.0</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'1/3'</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0.33</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'1/2'</span>) <span class="ruby-operator">==</span> <span class="ruby-string">'1/2'</span> <span class="ruby-comment">#=> false</span>
</pre>
<div class="method-source-code" id="3D-3D-source">
<pre>static VALUE
nurat_eqeq_p(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
get_dat1(self);
if (RB_INTEGER_TYPE_P(dat->num) && RB_INTEGER_TYPE_P(dat->den)) {
if (INT_ZERO_P(dat->num) && INT_ZERO_P(other))
return Qtrue;
if (!FIXNUM_P(dat->den))
return Qfalse;
if (FIX2LONG(dat->den) != 1)
return Qfalse;
return rb_int_equal(dat->num, other);
}
else {
const double d = nurat_to_double(self);
return f_boolcast(FIXNUM_ZERO_P(rb_dbl_cmp(d, NUM2DBL(other))));
}
}
else if (RB_FLOAT_TYPE_P(other)) {
const double d = nurat_to_double(self);
return f_boolcast(FIXNUM_ZERO_P(rb_dbl_cmp(d, RFLOAT_VALUE(other))));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
{
get_dat2(self, other);
if (INT_ZERO_P(adat->num) && INT_ZERO_P(bdat->num))
return Qtrue;
return f_boolcast(rb_int_equal(adat->num, bdat->num) &&
rb_int_equal(adat->den, bdat->den));
}
}
else {
return rb_equal(other, self);
}
}</pre>
</div>
</div>
</div>
<div id="method-i-abs" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
abs → rational
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the absolute value of <code>rat</code>.</p>
<pre class="ruby">(<span class="ruby-value">1</span><span class="ruby-operator">/</span><span class="ruby-value">2r</span>).<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> (1/2)</span>
(<span class="ruby-value">-1</span><span class="ruby-operator">/</span><span class="ruby-value">2r</span>).<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> (1/2)</span>
</pre>
<p><a href="Rational.html#method-i-magnitude"><code>Rational#magnitude</code></a> is an alias for <a href="Rational.html#method-i-abs"><code>Rational#abs</code></a>.</p>
<div class="method-source-code" id="abs-source">
<pre>VALUE
rb_rational_abs(VALUE self)
{
get_dat1(self);
if (INT_NEGATIVE_P(dat->num)) {
VALUE num = rb_int_abs(dat->num);
return nurat_s_canonicalize_internal_no_reduce(CLASS_OF(self), num, dat->den);
}
return self;
}</pre>
</div>
</div>
</div>
<div id="method-i-as_json" class="method-detail ">
<div class="method-heading">
<span class="method-name">as_json</span><span
class="method-args">(*)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a hash, that will be turned into a <a href="JSON.html"><code>JSON</code></a> object and represent this object.</p>
<div class="method-source-code" id="as_json-source">
<pre><span class="ruby-comment"># File ext/json/lib/json/add/rational.rb, line 16</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">as_json</span>(<span class="ruby-operator">*</span>)
{
<span class="ruby-constant">JSON</span>.<span class="ruby-identifier">create_id</span> <span class="ruby-operator">=></span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">name</span>,
<span class="ruby-string">'n'</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">numerator</span>,
<span class="ruby-string">'d'</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">denominator</span>,
}
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-ceil" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
ceil([ndigits]) → integer or rational
</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>rat</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 rational when <code>ndigits</code> is positive, otherwise returns an integer.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">3</span>).<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> 3</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>).<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-3</span>, <span class="ruby-value">2</span>).<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> -1</span>
<span class="ruby-comment"># decimal - 1 2 3 . 4 5 6</span>
<span class="ruby-comment"># ^ ^ ^ ^ ^ ^</span>
<span class="ruby-comment"># precision -3 -2 -1 0 +1 +2</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'-123.456'</span>).<span class="ruby-identifier">ceil</span>(<span class="ruby-value">+1</span>).<span class="ruby-identifier">to_f</span> <span class="ruby-comment">#=> -123.4</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'-123.456'</span>).<span class="ruby-identifier">ceil</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> -120</span>
</pre>
<div class="method-source-code" id="ceil-source">
<pre>static VALUE
nurat_ceil_n(int argc, VALUE *argv, VALUE self)
{
return f_round_common(argc, argv, self, nurat_ceil);
}</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).</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">7</span>).<span class="ruby-identifier">denominator</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">7</span>, <span class="ruby-value">1</span>).<span class="ruby-identifier">denominator</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">9</span>, <span class="ruby-value">-4</span>).<span class="ruby-identifier">denominator</span> <span class="ruby-comment">#=> 4</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-2</span>, <span class="ruby-value">-10</span>).<span class="ruby-identifier">denominator</span> <span class="ruby-comment">#=> 5</span>
</pre>
<div class="method-source-code" id="denominator-source">
<pre>static VALUE
nurat_denominator(VALUE self)
{
get_dat1(self);
return dat->den;
}</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>Performs division and returns the value as a <a href="Float.html"><code>Float</code></a>.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>).<span class="ruby-identifier">fdiv</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 0.6666666666666666</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>).<span class="ruby-identifier">fdiv</span>(<span class="ruby-value">0.5</span>) <span class="ruby-comment">#=> 1.3333333333333333</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>).<span class="ruby-identifier">fdiv</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> 0.6666666666666666</span>
</pre>
<div class="method-source-code" id="fdiv-source">
<pre>static VALUE
nurat_fdiv(VALUE self, VALUE other)
{
VALUE div;
if (f_zero_p(other))
return rb_rational_div(self, rb_float_new(0.0));
if (FIXNUM_P(other) && other == LONG2FIX(1))
return nurat_to_f(self);
div = rb_rational_div(self, other);
if (RB_TYPE_P(div, T_RATIONAL))
return nurat_to_f(div);
if (RB_FLOAT_TYPE_P(div))
return div;
return rb_funcall(div, idTo_f, 0);
}</pre>
</div>
</div>
</div>
<div id="method-i-floor" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
floor([ndigits]) → integer or rational
</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>rat</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 rational when <code>ndigits</code> is positive, otherwise returns an integer.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">3</span>).<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> 3</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>).<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> 0</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-3</span>, <span class="ruby-value">2</span>).<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> -2</span>
<span class="ruby-comment"># decimal - 1 2 3 . 4 5 6</span>
<span class="ruby-comment"># ^ ^ ^ ^ ^ ^</span>
<span class="ruby-comment"># precision -3 -2 -1 0 +1 +2</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'-123.456'</span>).<span class="ruby-identifier">floor</span>(<span class="ruby-value">+1</span>).<span class="ruby-identifier">to_f</span> <span class="ruby-comment">#=> -123.5</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'-123.456'</span>).<span class="ruby-identifier">floor</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> -130</span>
</pre>
<div class="method-source-code" id="floor-source">
<pre>static VALUE
nurat_floor_n(int argc, VALUE *argv, VALUE self)
{
return f_round_common(argc, argv, self, nurat_floor);
}</pre>
</div>
</div>
</div>
<div id="method-i-inspect" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
inspect → string
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the value as a string for inspection.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>).<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "(2/1)"</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-8</span>, <span class="ruby-value">6</span>).<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "(-4/3)"</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'1/2'</span>).<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "(1/2)"</span>
</pre>
<div class="method-source-code" id="inspect-source">
<pre>static VALUE
nurat_inspect(VALUE self)
{
VALUE s;
s = rb_usascii_str_new2("(");
rb_str_concat(s, f_format(self, f_inspect));
rb_str_cat2(s, ")");
return s;
}</pre>
</div>
</div>
</div>
<div id="method-i-magnitude" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
magnitude → rational
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the absolute value of <code>rat</code>.</p>
<pre class="ruby">(<span class="ruby-value">1</span><span class="ruby-operator">/</span><span class="ruby-value">2r</span>).<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> (1/2)</span>
(<span class="ruby-value">-1</span><span class="ruby-operator">/</span><span class="ruby-value">2r</span>).<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> (1/2)</span>
</pre>
<p><a href="Rational.html#method-i-magnitude"><code>Rational#magnitude</code></a> is an alias for <a href="Rational.html#method-i-abs"><code>Rational#abs</code></a>.</p>
<div class="method-source-code" id="magnitude-source">
<pre>VALUE
rb_rational_abs(VALUE self)
{
get_dat1(self);
if (INT_NEGATIVE_P(dat->num)) {
VALUE num = rb_int_abs(dat->num);
return nurat_s_canonicalize_internal_no_reduce(CLASS_OF(self), num, dat->den);
}
return self;
}</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>rat</code> is less than 0.</p>
<div class="method-source-code" id="negative-3F-source">
<pre>static VALUE
nurat_negative_p(VALUE self)
{
get_dat1(self);
return f_boolcast(INT_NEGATIVE_P(dat->num));
}</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.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">7</span>).<span class="ruby-identifier">numerator</span> <span class="ruby-comment">#=> 7</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">7</span>, <span class="ruby-value">1</span>).<span class="ruby-identifier">numerator</span> <span class="ruby-comment">#=> 7</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">9</span>, <span class="ruby-value">-4</span>).<span class="ruby-identifier">numerator</span> <span class="ruby-comment">#=> -9</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-2</span>, <span class="ruby-value">-10</span>).<span class="ruby-identifier">numerator</span> <span class="ruby-comment">#=> 1</span>
</pre>
<div class="method-source-code" id="numerator-source">
<pre>static VALUE
nurat_numerator(VALUE self)
{
get_dat1(self);
return dat->num;
}</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>rat</code> is greater than 0.</p>
<div class="method-source-code" id="positive-3F-source">
<pre>static VALUE
nurat_positive_p(VALUE self)
{
get_dat1(self);
return f_boolcast(INT_POSITIVE_P(dat->num));
}</pre>
</div>
</div>
</div>
<div id="method-i-quo" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
quo(numeric) → numeric
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs division.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-operator">/</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>) <span class="ruby-comment">#=> (1/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">900</span>) <span class="ruby-operator">/</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> (900/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-2</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">/</span> <span class="ruby-constant">Rational</span>(<span class="ruby-value">-9</span>, <span class="ruby-value">2</span>) <span class="ruby-comment">#=> (4/81)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">9</span>, <span class="ruby-value">8</span>) <span class="ruby-operator">/</span> <span class="ruby-value">4</span> <span class="ruby-comment">#=> (9/32)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">20</span>, <span class="ruby-value">9</span>) <span class="ruby-operator">/</span> <span class="ruby-value">9.8</span> <span class="ruby-comment">#=> 0.22675736961451246</span>
</pre>
<div class="method-source-code" id="quo-source">
<pre>VALUE
rb_rational_div(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
if (f_zero_p(other))
rb_num_zerodiv();
{
get_dat1(self);
return f_muldiv(self,
dat->num, dat->den,
other, ONE, '/');
}
}
else if (RB_FLOAT_TYPE_P(other)) {
VALUE v = nurat_to_f(self);
return rb_flo_div_flo(v, other);
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
if (f_zero_p(other))
rb_num_zerodiv();
{
get_dat2(self, other);
if (f_one_p(self))
return f_rational_new_no_reduce2(CLASS_OF(self),
bdat->den, bdat->num);
return f_muldiv(self,
adat->num, adat->den,
bdat->num, bdat->den, '/');
}
}
else {
return rb_num_coerce_bin(self, other, '/');
}
}</pre>
</div>
</div>
</div>
<div id="method-i-rationalize" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rationalize → self
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
rationalize(eps) → rational
</span>
</div>
<div class="method-description">
<p>Returns a simpler approximation of the value if the optional argument <code>eps</code> is given (rat-|eps| <= result <= rat+|eps|), self otherwise.</p>
<pre class="ruby"><span class="ruby-identifier">r</span> = <span class="ruby-constant">Rational</span>(<span class="ruby-value">5033165</span>, <span class="ruby-value">16777216</span>)
<span class="ruby-identifier">r</span>.<span class="ruby-identifier">rationalize</span> <span class="ruby-comment">#=> (5033165/16777216)</span>
<span class="ruby-identifier">r</span>.<span class="ruby-identifier">rationalize</span>(<span class="ruby-constant">Rational</span>(<span class="ruby-string">'0.01'</span>)) <span class="ruby-comment">#=> (3/10)</span>
<span class="ruby-identifier">r</span>.<span class="ruby-identifier">rationalize</span>(<span class="ruby-constant">Rational</span>(<span class="ruby-string">'0.1'</span>)) <span class="ruby-comment">#=> (1/3)</span>
</pre>
<div class="method-source-code" id="rationalize-source">
<pre>static VALUE
nurat_rationalize(int argc, VALUE *argv, VALUE self)
{
VALUE e, a, b, p, q;
if (rb_check_arity(argc, 0, 1) == 0)
return self;
if (nurat_negative_p(self))
return rb_rational_uminus(nurat_rationalize(argc, argv, rb_rational_uminus(self)));
e = f_abs(argv[0]);
a = f_sub(self, e);
b = f_add(self, e);
if (f_eqeq_p(a, b))
return self;
nurat_rationalize_internal(a, b, &p, &q);
return f_rational_new2(CLASS_OF(self), p, q);
}</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 rational
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>rat</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 rational when <code>ndigits</code> is positive, otherwise returns an integer.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">3</span>).<span class="ruby-identifier">round</span> <span class="ruby-comment">#=> 3</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>).<span class="ruby-identifier">round</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-3</span>, <span class="ruby-value">2</span>).<span class="ruby-identifier">round</span> <span class="ruby-comment">#=> -2</span>
<span class="ruby-comment"># decimal - 1 2 3 . 4 5 6</span>
<span class="ruby-comment"># ^ ^ ^ ^ ^ ^</span>
<span class="ruby-comment"># precision -3 -2 -1 0 +1 +2</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'-123.456'</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">+1</span>).<span class="ruby-identifier">to_f</span> <span class="ruby-comment">#=> -123.5</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'-123.456'</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> -120</span>
</pre>
<p>The optional <code>half</code> keyword argument is available similar to <a href="Float.html#method-i-round"><code>Float#round</code></a>.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">25</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:up</span>) <span class="ruby-comment">#=> (3/10)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">25</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:down</span>) <span class="ruby-comment">#=> (1/5)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">25</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:even</span>) <span class="ruby-comment">#=> (1/5)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">35</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:up</span>) <span class="ruby-comment">#=> (2/5)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">35</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:down</span>) <span class="ruby-comment">#=> (3/10)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">35</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:even</span>) <span class="ruby-comment">#=> (2/5)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-25</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:up</span>) <span class="ruby-comment">#=> (-3/10)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-25</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:down</span>) <span class="ruby-comment">#=> (-1/5)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-25</span>, <span class="ruby-value">100</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">1</span>, <span class="ruby-value">half:</span> <span class="ruby-value">:even</span>) <span class="ruby-comment">#=> (-1/5)</span>
</pre>
<div class="method-source-code" id="round-source">
<pre>static VALUE
nurat_round_n(int argc, VALUE *argv, VALUE self)
{
VALUE opt;
enum ruby_num_rounding_mode mode = (
argc = rb_scan_args(argc, argv, "*:", NULL, &opt),
rb_num_get_rounding_option(opt));
VALUE (*round_func)(VALUE) = ROUND_FUNC(mode, nurat_round);
return f_round_common(argc, argv, self, round_func);
}</pre>
</div>
</div>
</div>
<div id="method-i-to_d" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_d(precision) → bigdecimal
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the value as a <a href="BigDecimal.html"><code>BigDecimal</code></a>.</p>
<p>The required <code>precision</code> parameter is used to determine the number of significant digits for the result.</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-constant">Rational</span>(<span class="ruby-value">22</span>, <span class="ruby-value">7</span>).<span class="ruby-identifier">to_d</span>(<span class="ruby-value">3</span>) <span class="ruby-comment"># => 0.314e1</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 128</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">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 → float
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the value as a <a href="Float.html"><code>Float</code></a>.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>).<span class="ruby-identifier">to_f</span> <span class="ruby-comment">#=> 2.0</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">9</span>, <span class="ruby-value">4</span>).<span class="ruby-identifier">to_f</span> <span class="ruby-comment">#=> 2.25</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-3</span>, <span class="ruby-value">4</span>).<span class="ruby-identifier">to_f</span> <span class="ruby-comment">#=> -0.75</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">20</span>, <span class="ruby-value">3</span>).<span class="ruby-identifier">to_f</span> <span class="ruby-comment">#=> 6.666666666666667</span>
</pre>
<div class="method-source-code" id="to_f-source">
<pre>static VALUE
nurat_to_f(VALUE self)
{
return DBL2NUM(nurat_to_double(self));
}</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-description">
<p>Returns the truncated value as an integer.</p>
<p>Equivalent to <a href="Rational.html#method-i-truncate"><code>Rational#truncate</code></a>.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 0</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">3</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 3</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">300.6</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 300</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">98</span>, <span class="ruby-value">71</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-31</span>, <span class="ruby-value">2</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-comment">#=> -15</span>
</pre>
<div class="method-source-code" id="to_i-source">
<pre>static VALUE
nurat_truncate(VALUE self)
{
get_dat1(self);
if (INT_NEGATIVE_P(dat->num))
return rb_int_uminus(rb_int_idiv(rb_int_uminus(dat->num), dat->den));
return rb_int_idiv(dat->num, dat->den);
}</pre>
</div>
</div>
</div>
<div id="method-i-to_json" class="method-detail ">
<div class="method-heading">
<span class="method-name">to_json</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Stores class name (<a href="Rational.html"><code>Rational</code></a>) along with numerator value <code>n</code> and denominator value <code>d</code> as <a href="JSON.html"><code>JSON</code></a> string</p>
<div class="method-source-code" id="to_json-source">
<pre><span class="ruby-comment"># File ext/json/lib/json/add/rational.rb, line 25</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_json</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">as_json</span>.<span class="ruby-identifier">to_json</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-to_r" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_r → self
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns self.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>).<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (2/1)</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-8</span>, <span class="ruby-value">6</span>).<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (-4/3)</span>
</pre>
<div class="method-source-code" id="to_r-source">
<pre>static VALUE
nurat_to_r(VALUE self)
{
return self;
}</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 the value as a string.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>).<span class="ruby-identifier">to_s</span> <span class="ruby-comment">#=> "2/1"</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-8</span>, <span class="ruby-value">6</span>).<span class="ruby-identifier">to_s</span> <span class="ruby-comment">#=> "-4/3"</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'1/2'</span>).<span class="ruby-identifier">to_s</span> <span class="ruby-comment">#=> "1/2"</span>
</pre>
<div class="method-source-code" id="to_s-source">
<pre>static VALUE
nurat_to_s(VALUE self)
{
return f_format(self, f_to_s);
}</pre>
</div>
</div>
</div>
<div id="method-i-truncate" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
truncate([ndigits]) → integer or rational
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>rat</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 rational when <code>ndigits</code> is positive, otherwise returns an integer.</p>
<pre class="ruby"><span class="ruby-constant">Rational</span>(<span class="ruby-value">3</span>).<span class="ruby-identifier">truncate</span> <span class="ruby-comment">#=> 3</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">2</span>, <span class="ruby-value">3</span>).<span class="ruby-identifier">truncate</span> <span class="ruby-comment">#=> 0</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-value">-3</span>, <span class="ruby-value">2</span>).<span class="ruby-identifier">truncate</span> <span class="ruby-comment">#=> -1</span>
<span class="ruby-comment"># decimal - 1 2 3 . 4 5 6</span>
<span class="ruby-comment"># ^ ^ ^ ^ ^ ^</span>
<span class="ruby-comment"># precision -3 -2 -1 0 +1 +2</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'-123.456'</span>).<span class="ruby-identifier">truncate</span>(<span class="ruby-value">+1</span>).<span class="ruby-identifier">to_f</span> <span class="ruby-comment">#=> -123.4</span>
<span class="ruby-constant">Rational</span>(<span class="ruby-string">'-123.456'</span>).<span class="ruby-identifier">truncate</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> -120</span>
</pre>
<div class="method-source-code" id="truncate-source">
<pre>static VALUE
nurat_truncate_n(int argc, VALUE *argv, VALUE self)
{
return f_round_common(argc, argv, self, nurat_truncate);
}</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>