File: C:/Ruby27-x64/share/doc/ruby/html/Integer.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class Integer - 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-each_prime">::each_prime</a>
<li ><a href="#method-c-from_prime_division">::from_prime_division</a>
<li ><a href="#method-c-sqrt">::sqrt</a>
<li ><a href="#method-i-25">#%</a>
<li ><a href="#method-i-26">#&</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-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-3E-3E">#>></a>
<li ><a href="#method-i-5B-5D">#[]</a>
<li ><a href="#method-i-5E">#^</a>
<li ><a href="#method-i-abs">#abs</a>
<li ><a href="#method-i-allbits-3F">#allbits?</a>
<li ><a href="#method-i-anybits-3F">#anybits?</a>
<li ><a href="#method-i-bit_length">#bit_length</a>
<li ><a href="#method-i-ceil">#ceil</a>
<li ><a href="#method-i-chr">#chr</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-digits">#digits</a>
<li ><a href="#method-i-div">#div</a>
<li ><a href="#method-i-divmod">#divmod</a>
<li ><a href="#method-i-downto">#downto</a>
<li ><a href="#method-i-even-3F">#even?</a>
<li ><a href="#method-i-fdiv">#fdiv</a>
<li ><a href="#method-i-floor">#floor</a>
<li ><a href="#method-i-gcd">#gcd</a>
<li ><a href="#method-i-gcdlcm">#gcdlcm</a>
<li ><a href="#method-i-inspect">#inspect</a>
<li ><a href="#method-i-integer-3F">#integer?</a>
<li ><a href="#method-i-lcm">#lcm</a>
<li ><a href="#method-i-magnitude">#magnitude</a>
<li ><a href="#method-i-modulo">#modulo</a>
<li ><a href="#method-i-next">#next</a>
<li ><a href="#method-i-nobits-3F">#nobits?</a>
<li ><a href="#method-i-numerator">#numerator</a>
<li ><a href="#method-i-odd-3F">#odd?</a>
<li ><a href="#method-i-ord">#ord</a>
<li ><a href="#method-i-pow">#pow</a>
<li ><a href="#method-i-pred">#pred</a>
<li ><a href="#method-i-prime-3F">#prime?</a>
<li ><a href="#method-i-prime_division">#prime_division</a>
<li ><a href="#method-i-rationalize">#rationalize</a>
<li ><a href="#method-i-remainder">#remainder</a>
<li ><a href="#method-i-round">#round</a>
<li ><a href="#method-i-size">#size</a>
<li ><a href="#method-i-succ">#succ</a>
<li ><a href="#method-i-times">#times</a>
<li ><a href="#method-i-to_bn">#to_bn</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-upto">#upto</a>
<li ><a href="#method-i-7C">#|</a>
<li ><a href="#method-i-~">#~</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-Integer">
<h1 id="class-Integer" class="class">
class Integer
</h1>
<section class="description">
<p>Holds <a href="Integer.html"><code>Integer</code></a> values. You cannot add a singleton method to an <a href="Integer.html"><code>Integer</code></a> object, any attempt to do so will raise a <a href="TypeError.html"><code>TypeError</code></a>.</p>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section class="constants-list">
<header>
<h3>Constants</h3>
</header>
<dl>
<dt id="GMP_VERSION">GMP_VERSION
<dd><p>The version of loaded GMP.</p>
</dl>
</section>
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-each_prime" class="method-detail ">
<div class="method-heading">
<span class="method-name">each_prime</span><span
class="method-args">(ubound) { |prime| ... }</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Iterates the given block over all prime numbers.</p>
<p>See <code>Prime</code>#each for more details.</p>
<div class="method-source-code" id="each_prime-source">
<pre><span class="ruby-comment"># File lib/prime.rb, line 49</span>
<span class="ruby-keyword">def</span> <span class="ruby-constant">Integer</span>.<span class="ruby-identifier ruby-title">each_prime</span>(<span class="ruby-identifier">ubound</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) <span class="ruby-comment"># :yields: prime</span>
<span class="ruby-constant">Prime</span>.<span class="ruby-identifier">each</span>(<span class="ruby-identifier">ubound</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-c-from_prime_division" class="method-detail ">
<div class="method-heading">
<span class="method-name">from_prime_division</span><span
class="method-args">(pd)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Re-composes a prime factorization and returns the product.</p>
<p>See <a href="Prime.html#method-i-int_from_prime_division"><code>Prime#int_from_prime_division</code></a> for more details.</p>
<div class="method-source-code" id="from_prime_division-source">
<pre><span class="ruby-comment"># File lib/prime.rb, line 22</span>
<span class="ruby-keyword">def</span> <span class="ruby-constant">Integer</span>.<span class="ruby-identifier ruby-title">from_prime_division</span>(<span class="ruby-identifier">pd</span>)
<span class="ruby-constant">Prime</span>.<span class="ruby-identifier">int_from_prime_division</span>(<span class="ruby-identifier">pd</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-c-sqrt" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
sqrt(n) → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the integer square root of the non-negative integer <code>n</code>, i.e. the largest non-negative integer less than or equal to the square root of <code>n</code>.</p>
<pre class="ruby"><span class="ruby-constant">Integer</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-value">0</span>) <span class="ruby-comment">#=> 0</span>
<span class="ruby-constant">Integer</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-value">1</span>) <span class="ruby-comment">#=> 1</span>
<span class="ruby-constant">Integer</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-value">24</span>) <span class="ruby-comment">#=> 4</span>
<span class="ruby-constant">Integer</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-value">25</span>) <span class="ruby-comment">#=> 5</span>
<span class="ruby-constant">Integer</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-value">10</span><span class="ruby-operator">**</span><span class="ruby-value">400</span>) <span class="ruby-comment">#=> 10**200</span>
</pre>
<p>Equivalent to <code>Math.sqrt(n).floor</code>, except that the result of the latter code may differ from the true value due to the limited precision of floating point arithmetic.</p>
<pre class="ruby"><span class="ruby-constant">Integer</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-value">10</span><span class="ruby-operator">**</span><span class="ruby-value">46</span>) <span class="ruby-comment">#=> 100000000000000000000000</span>
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-value">10</span><span class="ruby-operator">**</span><span class="ruby-value">46</span>).<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> 99999999999999991611392 (!)</span>
</pre>
<p>If <code>n</code> is not an <a href="Integer.html"><code>Integer</code></a>, it is converted to an <a href="Integer.html"><code>Integer</code></a> first. If <code>n</code> is negative, a <a href="Math/DomainError.html"><code>Math::DomainError</code></a> is raised.</p>
<div class="method-source-code" id="sqrt-source">
<pre>static VALUE
rb_int_s_isqrt(VALUE self, VALUE num)
{
unsigned long n, sq;
num = rb_to_int(num);
if (FIXNUM_P(num)) {
if (FIXNUM_NEGATIVE_P(num)) {
domain_error("isqrt");
}
n = FIX2ULONG(num);
sq = rb_ulong_isqrt(n);
return LONG2FIX(sq);
}
else {
size_t biglen;
if (RBIGNUM_NEGATIVE_P(num)) {
domain_error("isqrt");
}
biglen = BIGNUM_LEN(num);
if (biglen == 0) return INT2FIX(0);
#if SIZEOF_BDIGIT <= SIZEOF_LONG
/* short-circuit */
if (biglen == 1) {
n = BIGNUM_DIGITS(num)[0];
sq = rb_ulong_isqrt(n);
return ULONG2NUM(sq);
}
#endif
return rb_big_isqrt(num);
}
}</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-25" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int % other → real
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>int</code> modulo <code>other</code>.</p>
<p>See <a href="Numeric.html#method-i-divmod"><code>Numeric#divmod</code></a> for more information.</p>
<div class="method-source-code" id="25-source">
<pre>VALUE
rb_int_modulo(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_mod(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_modulo(x, y);
}
return num_modulo(x, y);
}</pre>
</div>
</div>
</div>
<div id="method-i-26" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int & other_int → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Bitwise AND.</p>
<div class="method-source-code" id="26-source">
<pre>VALUE
rb_int_and(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_and(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_and(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-2A" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int * numeric → numeric_result
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs multiplication: the class of the resulting object depends on the class of <code>numeric</code>.</p>
<div class="method-source-code" id="2A-source">
<pre>VALUE
rb_int_mul(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_mul(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_mul(x, y);
}
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">
int ** numeric → numeric_result
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Raises <code>int</code> to the power of <code>numeric</code>, which may be negative or fractional. The result may be an <a href="Integer.html"><code>Integer</code></a>, a <a href="Float.html"><code>Float</code></a>, a <a href="Rational.html"><code>Rational</code></a>, or a complex number.</p>
<pre class="ruby"><span class="ruby-value">2</span> <span class="ruby-operator">**</span> <span class="ruby-value">3</span> <span class="ruby-comment">#=> 8</span>
<span class="ruby-value">2</span> <span class="ruby-operator">**</span> <span class="ruby-value">-1</span> <span class="ruby-comment">#=> (1/2)</span>
<span class="ruby-value">2</span> <span class="ruby-operator">**</span> <span class="ruby-value">0.5</span> <span class="ruby-comment">#=> 1.4142135623730951</span>
(<span class="ruby-value">-1</span>) <span class="ruby-operator">**</span> <span class="ruby-value">0.5</span> <span class="ruby-comment">#=> (0.0+1.0i)</span>
<span class="ruby-value">123456789</span> <span class="ruby-operator">**</span> <span class="ruby-value">2</span> <span class="ruby-comment">#=> 15241578750190521</span>
<span class="ruby-value">123456789</span> <span class="ruby-operator">**</span> <span class="ruby-value">1.2</span> <span class="ruby-comment">#=> 5126464716.0993185</span>
<span class="ruby-value">123456789</span> <span class="ruby-operator">**</span> <span class="ruby-value">-2</span> <span class="ruby-comment">#=> (1/15241578750190521)</span>
</pre>
<div class="method-source-code" id="2A-2A-source">
<pre>VALUE
rb_int_pow(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_pow(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_pow(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-2B" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int + numeric → numeric_result
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs addition: the class of the resulting object depends on the class of <code>numeric</code>.</p>
<div class="method-source-code" id="2B-source">
<pre>VALUE
rb_int_plus(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_plus(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_plus(x, y);
}
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">
int - numeric → numeric_result
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs subtraction: the class of the resulting object depends on the class of <code>numeric</code>.</p>
<div class="method-source-code" id="2D-source">
<pre>VALUE
rb_int_minus(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_minus(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_minus(x, y);
}
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">
-int → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>int</code>, negated.</p>
<div class="method-source-code" id="2D-40-source">
<pre>VALUE
rb_int_uminus(VALUE num)
{
if (FIXNUM_P(num)) {
return fix_uminus(num);
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_uminus(num);
}
return num_funcall0(num, idUMinus);
}</pre>
</div>
</div>
</div>
<div id="method-i-2F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int / numeric → numeric_result
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs division: the class of the resulting object depends on the class of <code>numeric</code>.</p>
<div class="method-source-code" id="2F-source">
<pre>VALUE
rb_int_div(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_div(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_div(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3C" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int < 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 the value of <code>int</code> is less than that of <code>real</code>.</p>
<div class="method-source-code" id="3C-source">
<pre>static VALUE
int_lt(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_lt(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_lt(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3C-3C" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int << count → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>int</code> shifted left <code>count</code> positions, or right if <code>count</code> is negative.</p>
<div class="method-source-code" id="3C-3C-source">
<pre>VALUE
rb_int_lshift(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return rb_fix_lshift(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_lshift(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3C-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int <= 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 the value of <code>int</code> is less than or equal to that of <code>real</code>.</p>
<div class="method-source-code" id="3C-3D-source">
<pre>static VALUE
int_le(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_le(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_le(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3C-3D-3E" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int <=> numeric → -1, 0, +1, or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Comparison—Returns -1, 0, or +1 depending on whether <code>int</code> is less than, equal to, or greater than <code>numeric</code>.</p>
<p>This is the basis for the tests in the <a href="Comparable.html"><code>Comparable</code></a> module.</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>VALUE
rb_int_cmp(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_cmp(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_cmp(x, y);
}
else {
rb_raise(rb_eNotImpError, "need to define `<=>' in %s", rb_obj_classname(x));
}
}</pre>
</div>
</div>
</div>
<div id="method-i-3D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int == other → 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>int</code> equals <code>other</code> numerically. Contrast this with <a href="Numeric.html#method-i-eql-3F"><code>Integer#eql?</code></a>, which requires <code>other</code> to be an <a href="Integer.html"><code>Integer</code></a>.</p>
<pre class="ruby"><span class="ruby-value">1</span> <span class="ruby-operator">==</span> <span class="ruby-value">2</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-value">1</span> <span class="ruby-operator">==</span> <span class="ruby-value">1.0</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="3D-3D-source">
<pre>VALUE
rb_int_equal(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_equal(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_eq(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3D-3D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int == other → 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>int</code> equals <code>other</code> numerically. Contrast this with <a href="Numeric.html#method-i-eql-3F"><code>Integer#eql?</code></a>, which requires <code>other</code> to be an <a href="Integer.html"><code>Integer</code></a>.</p>
<pre class="ruby"><span class="ruby-value">1</span> <span class="ruby-operator">==</span> <span class="ruby-value">2</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-value">1</span> <span class="ruby-operator">==</span> <span class="ruby-value">1.0</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="3D-3D-3D-source">
<pre>VALUE
rb_int_equal(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_equal(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_eq(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3E" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int > 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 the value of <code>int</code> is greater than that of <code>real</code>.</p>
<div class="method-source-code" id="3E-source">
<pre>VALUE
rb_int_gt(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_gt(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_gt(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3E-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int >= 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 the value of <code>int</code> is greater than or equal to that of <code>real</code>.</p>
<div class="method-source-code" id="3E-3D-source">
<pre>VALUE
rb_int_ge(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_ge(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_ge(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3E-3E" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int >> count → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>int</code> shifted right <code>count</code> positions, or left if <code>count</code> is negative.</p>
<div class="method-source-code" id="3E-3E-source">
<pre>static VALUE
rb_int_rshift(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return rb_fix_rshift(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_rshift(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-5B-5D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int[n] → 0, 1
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
int[n, m] → num
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
int[range] → num
</span>
</div>
<div class="method-description">
<p>Bit Reference—Returns the <code>n</code>th bit in the binary representation of <code>int</code>, where <code>int[0]</code> is the least significant bit.</p>
<pre class="ruby"><span class="ruby-identifier">a</span> = <span class="ruby-value">0b11001100101010</span>
<span class="ruby-value">30</span>.<span class="ruby-identifier">downto</span>(<span class="ruby-value">0</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">n</span><span class="ruby-operator">|</span> <span class="ruby-identifier">print</span> <span class="ruby-identifier">a</span>[<span class="ruby-identifier">n</span>] }
<span class="ruby-comment">#=> 0000000000000000011001100101010</span>
<span class="ruby-identifier">a</span> = <span class="ruby-value">9</span><span class="ruby-operator">**</span><span class="ruby-value">15</span>
<span class="ruby-value">50</span>.<span class="ruby-identifier">downto</span>(<span class="ruby-value">0</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">n</span><span class="ruby-operator">|</span> <span class="ruby-identifier">print</span> <span class="ruby-identifier">a</span>[<span class="ruby-identifier">n</span>] }
<span class="ruby-comment">#=> 000101110110100000111000011110010100111100010111001</span>
</pre>
<p>In principle, <code>n[i]</code> is equivalent to <code>(n >> i) & 1</code>. Thus, any negative index always returns zero:</p>
<pre class="ruby"><span class="ruby-identifier">p</span> <span class="ruby-value">255</span>[<span class="ruby-value">-1</span>] <span class="ruby-comment">#=> 0</span>
</pre>
<p><a href="Range.html"><code>Range</code></a> operations <code>n[i, len]</code> and <code>n[i..j]</code> are naturally extended.</p>
<ul><li>
<p><code>n[i, len]</code> equals to <code>(n >> i) & ((1 << len) - 1)</code>.</p>
</li><li>
<p><code>n[i..j]</code> equals to <code>(n >> i) & ((1 << (j - i + 1)) - 1)</code>.</p>
</li><li>
<p><code>n[i...j]</code> equals to <code>(n >> i) & ((1 << (j - i)) - 1)</code>.</p>
</li><li>
<p><code>n[i..]</code> equals to <code>(n >> i)</code>.</p>
</li><li>
<p><code>n[..j]</code> is zero if <code>n & ((1 << (j + 1)) - 1)</code> is zero. Otherwise, raises an <a href="ArgumentError.html"><code>ArgumentError</code></a>.</p>
</li><li>
<p><code>n[...j]</code> is zero if <code>n & ((1 << j) - 1)</code> is zero. Otherwise, raises an <a href="ArgumentError.html"><code>ArgumentError</code></a>.</p>
</li></ul>
<p>Note that range operation may exhaust memory. For example, <code>-1[0, 1000000000000]</code> will raise <a href="NoMemoryError.html"><code>NoMemoryError</code></a>.</p>
<div class="method-source-code" id="5B-5D-source">
<pre>static VALUE
int_aref(int const argc, VALUE * const argv, VALUE const num)
{
rb_check_arity(argc, 1, 2);
if (argc == 2) {
return int_aref2(num, argv[0], argv[1]);
}
return int_aref1(num, argv[0]);
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-5E" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int ^ other_int → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Bitwise EXCLUSIVE OR.</p>
<div class="method-source-code" id="5E-source">
<pre>static VALUE
int_xor(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_xor(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_xor(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-abs" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
abs → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the absolute value of <code>int</code>.</p>
<pre class="ruby">(<span class="ruby-value">-12345</span>).<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 12345</span>
<span class="ruby-value">-12345</span>.<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 12345</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 12345</span>
</pre>
<p><a href="Integer.html#method-i-magnitude"><code>Integer#magnitude</code></a> is an alias for <a href="Integer.html#method-i-abs"><code>Integer#abs</code></a>.</p>
<div class="method-source-code" id="abs-source">
<pre>VALUE
rb_int_abs(VALUE num)
{
if (FIXNUM_P(num)) {
return fix_abs(num);
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_abs(num);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-allbits-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
allbits?(mask) → 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 all bits of <code>int & mask</code> are 1.</p>
<div class="method-source-code" id="allbits-3F-source">
<pre>static VALUE
int_allbits_p(VALUE num, VALUE mask)
{
mask = rb_to_int(mask);
return rb_int_equal(rb_int_and(num, mask), mask);
}</pre>
</div>
</div>
</div>
<div id="method-i-anybits-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
anybits?(mask) → 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 any bits of <code>int & mask</code> are 1.</p>
<div class="method-source-code" id="anybits-3F-source">
<pre>static VALUE
int_anybits_p(VALUE num, VALUE mask)
{
mask = rb_to_int(mask);
return num_zero_p(rb_int_and(num, mask)) ? Qfalse : Qtrue;
}</pre>
</div>
</div>
</div>
<div id="method-i-bit_length" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
bit_length → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the number of bits of the value of <code>int</code>.</p>
<p>“Number of bits” means the bit position of the highest bit which is different from the sign bit (where the least significant bit has bit position 1). If there is no such bit (zero or minus one), zero is returned.</p>
<p>I.e. this method returns <em>ceil(log2(int < 0 ? -int : int+1))</em>.</p>
<pre class="ruby">(<span class="ruby-value">-2</span><span class="ruby-operator">**</span><span class="ruby-value">1000</span><span class="ruby-value">-1</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 1001</span>
(<span class="ruby-value">-2</span><span class="ruby-operator">**</span><span class="ruby-value">1000</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 1000</span>
(<span class="ruby-value">-2</span><span class="ruby-operator">**</span><span class="ruby-value">1000</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 1000</span>
(<span class="ruby-value">-2</span><span class="ruby-operator">**</span><span class="ruby-value">12</span><span class="ruby-value">-1</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 13</span>
(<span class="ruby-value">-2</span><span class="ruby-operator">**</span><span class="ruby-value">12</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 12</span>
(<span class="ruby-value">-2</span><span class="ruby-operator">**</span><span class="ruby-value">12</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 12</span>
<span class="ruby-value">-0x101</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 9</span>
<span class="ruby-value">-0x100</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 8</span>
<span class="ruby-value">-0xff</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 8</span>
<span class="ruby-value">-2</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">-1</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 0</span>
<span class="ruby-value">0</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 0</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">0xff</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 8</span>
<span class="ruby-value">0x100</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 9</span>
(<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-value">12</span><span class="ruby-value">-1</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 12</span>
(<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-value">12</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 13</span>
(<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-value">12</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 13</span>
(<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-value">1000</span><span class="ruby-value">-1</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 1000</span>
(<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-value">1000</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 1001</span>
(<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-value">1000</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">bit_length</span> <span class="ruby-comment">#=> 1001</span>
</pre>
<p>This method can be used to detect overflow in <a href="Array.html#method-i-pack"><code>Array#pack</code></a> as follows:</p>
<pre class="ruby"><span class="ruby-keyword">if</span> <span class="ruby-identifier">n</span>.<span class="ruby-identifier">bit_length</span> <span class="ruby-operator"><</span> <span class="ruby-value">32</span>
[<span class="ruby-identifier">n</span>].<span class="ruby-identifier">pack</span>(<span class="ruby-string">"l"</span>) <span class="ruby-comment"># no overflow</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-string">"overflow"</span>
<span class="ruby-keyword">end</span>
</pre>
<div class="method-source-code" id="bit_length-source">
<pre>static VALUE
rb_int_bit_length(VALUE num)
{
if (FIXNUM_P(num)) {
return rb_fix_bit_length(num);
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_bit_length(num);
}
return Qnil;
}</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>int</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 <code>self</code> when <code>ndigits</code> is zero or positive.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">ceil</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">18</span>.<span class="ruby-identifier">ceil</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 20</span>
(<span class="ruby-value">-18</span>).<span class="ruby-identifier">ceil</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> -10</span>
</pre>
<div class="method-source-code" id="ceil-source">
<pre>static VALUE
int_ceil(int argc, VALUE* argv, VALUE num)
{
int ndigits;
if (!rb_check_arity(argc, 0, 1)) return num;
ndigits = NUM2INT(argv[0]);
if (ndigits >= 0) {
return num;
}
return rb_int_ceil(num, ndigits);
}</pre>
</div>
</div>
</div>
<div id="method-i-chr" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
chr([encoding]) → string
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a string containing the character represented by the <code>int</code>'s value according to <code>encoding</code>.</p>
<pre class="ruby"><span class="ruby-value">65</span>.<span class="ruby-identifier">chr</span> <span class="ruby-comment">#=> "A"</span>
<span class="ruby-value">230</span>.<span class="ruby-identifier">chr</span> <span class="ruby-comment">#=> "\xE6"</span>
<span class="ruby-value">255</span>.<span class="ruby-identifier">chr</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">UTF_8</span>) <span class="ruby-comment">#=> "\u00FF"</span>
</pre>
<div class="method-source-code" id="chr-source">
<pre>static VALUE
int_chr(int argc, VALUE *argv, VALUE num)
{
char c;
unsigned int i;
rb_encoding *enc;
if (rb_num_to_uint(num, &i) == 0) {
}
else if (FIXNUM_P(num)) {
rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(num));
}
else {
rb_raise(rb_eRangeError, "bignum out of char range");
}
switch (argc) {
case 0:
if (0xff < i) {
enc = rb_default_internal_encoding();
if (!enc) {
rb_raise(rb_eRangeError, "%d out of char range", i);
}
goto decode;
}
c = (char)i;
if (i < 0x80) {
return rb_usascii_str_new(&c, 1);
}
else {
return rb_str_new(&c, 1);
}
case 1:
break;
default:
rb_error_arity(argc, 0, 1);
}
enc = rb_to_encoding(argv[0]);
if (!enc) enc = rb_ascii8bit_encoding();
decode:
return rb_enc_uint_chr(i, enc);
}</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 a <code>numeric</code> and a <code>big</code> represented as Bignum objects.</p>
<p>This is achieved by converting <code>numeric</code> to a Bignum.</p>
<p>A <a href="TypeError.html"><code>TypeError</code></a> is raised if the <code>numeric</code> is not a Fixnum or Bignum type.</p>
<pre class="ruby">(<span class="ruby-value">0x3FFFFFFFFFFFFFFF</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">coerce</span>(<span class="ruby-value">42</span>) <span class="ruby-comment">#=> [42, 4611686018427387904]</span>
</pre>
<div class="method-source-code" id="coerce-source">
<pre>static VALUE
rb_int_coerce(VALUE x, VALUE y)
{
if (RB_INTEGER_TYPE_P(y)) {
return rb_assoc_new(y, x);
}
else {
x = rb_Float(x);
y = rb_Float(y);
return rb_assoc_new(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 25</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 → 1
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns 1.</p>
<div class="method-source-code" id="denominator-source">
<pre>static VALUE
integer_denominator(VALUE self)
{
return INT2FIX(1);
}</pre>
</div>
</div>
</div>
<div id="method-i-digits" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
digits → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
digits(base) → array
</span>
</div>
<div class="method-description">
<p>Returns the digits of <code>int</code>'s place-value representation with radix <code>base</code> (default: 10). The digits are returned as an array with the least significant digit as the first array element.</p>
<p><code>base</code> must be greater than or equal to 2.</p>
<pre class="ruby"><span class="ruby-value">12345</span>.<span class="ruby-identifier">digits</span> <span class="ruby-comment">#=> [5, 4, 3, 2, 1]</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">digits</span>(<span class="ruby-value">7</span>) <span class="ruby-comment">#=> [4, 6, 6, 0, 5]</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">digits</span>(<span class="ruby-value">100</span>) <span class="ruby-comment">#=> [45, 23, 1]</span>
<span class="ruby-value">-12345</span>.<span class="ruby-identifier">digits</span>(<span class="ruby-value">7</span>) <span class="ruby-comment">#=> Math::DomainError</span>
</pre>
<div class="method-source-code" id="digits-source">
<pre>static VALUE
rb_int_digits(int argc, VALUE *argv, VALUE num)
{
VALUE base_value;
long base;
if (rb_num_negative_p(num))
rb_raise(rb_eMathDomainError, "out of domain");
if (rb_check_arity(argc, 0, 1)) {
base_value = rb_to_int(argv[0]);
if (!RB_INTEGER_TYPE_P(base_value))
rb_raise(rb_eTypeError, "wrong argument type %s (expected Integer)",
rb_obj_classname(argv[0]));
if (RB_TYPE_P(base_value, T_BIGNUM))
return rb_int_digits_bigbase(num, base_value);
base = FIX2LONG(base_value);
if (base < 0)
rb_raise(rb_eArgError, "negative radix");
else if (base < 2)
rb_raise(rb_eArgError, "invalid radix %ld", base);
}
else
base = 10;
if (FIXNUM_P(num))
return rb_fix_digits(num, base);
else if (RB_TYPE_P(num, T_BIGNUM))
return rb_int_digits_bigbase(num, LONG2FIX(base));
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-div" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
div(numeric) → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs integer division: returns the integer result of dividing <code>int</code> by <code>numeric</code>.</p>
<div class="method-source-code" id="div-source">
<pre>VALUE
rb_int_idiv(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_idiv(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_idiv(x, y);
}
return num_div(x, y);
}</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>
<div class="method-source-code" id="divmod-source">
<pre>VALUE
rb_int_divmod(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_divmod(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_divmod(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-downto" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
downto(limit) {|i| block } → self
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
downto(limit) → an_enumerator
</span>
</div>
<div class="method-description">
<p>Iterates the given block, passing in decreasing values from <code>int</code> down to and including <code>limit</code>.</p>
<p>If no block is given, an <a href="Enumerator.html"><code>Enumerator</code></a> is returned instead.</p>
<pre class="ruby"><span class="ruby-value">5</span>.<span class="ruby-identifier">downto</span>(<span class="ruby-value">1</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">n</span><span class="ruby-operator">|</span> <span class="ruby-identifier">print</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">".. "</span> }
<span class="ruby-identifier">puts</span> <span class="ruby-string">"Liftoff!"</span>
<span class="ruby-comment">#=> "5.. 4.. 3.. 2.. 1.. Liftoff!"</span>
</pre>
<div class="method-source-code" id="downto-source">
<pre>static VALUE
int_downto(VALUE from, VALUE to)
{
RETURN_SIZED_ENUMERATOR(from, 1, &to, int_downto_size);
if (FIXNUM_P(from) && FIXNUM_P(to)) {
long i, end;
end = FIX2LONG(to);
for (i=FIX2LONG(from); i >= end; i--) {
rb_yield(LONG2FIX(i));
}
}
else {
VALUE i = from, c;
while (!(c = rb_funcall(i, '<', 1, to))) {
rb_yield(i);
i = rb_funcall(i, '-', 1, INT2FIX(1));
}
if (NIL_P(c)) rb_cmperr(i, to);
}
return from;
}</pre>
</div>
</div>
</div>
<div id="method-i-even-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
even? → 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>int</code> is an even number.</p>
<div class="method-source-code" id="even-3F-source">
<pre>static VALUE
int_even_p(VALUE num)
{
if (FIXNUM_P(num)) {
if ((num & 2) == 0) {
return Qtrue;
}
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_even_p(num);
}
else if (rb_funcall(num, '%', 1, INT2FIX(2)) == INT2FIX(0)) {
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 the floating point result of dividing <code>int</code> by <code>numeric</code>.</p>
<pre class="ruby"><span class="ruby-value">654321</span>.<span class="ruby-identifier">fdiv</span>(<span class="ruby-value">13731</span>) <span class="ruby-comment">#=> 47.652829364212366</span>
<span class="ruby-value">654321</span>.<span class="ruby-identifier">fdiv</span>(<span class="ruby-value">13731.24</span>) <span class="ruby-comment">#=> 47.65199646936475</span>
<span class="ruby-value">-654321</span>.<span class="ruby-identifier">fdiv</span>(<span class="ruby-value">13731</span>) <span class="ruby-comment">#=> -47.652829364212366</span>
</pre>
<div class="method-source-code" id="fdiv-source">
<pre>VALUE
rb_int_fdiv(VALUE x, VALUE y)
{
if (RB_INTEGER_TYPE_P(x)) {
return DBL2NUM(rb_int_fdiv_double(x, y));
}
return Qnil;
}</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>int</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 <code>self</code> when <code>ndigits</code> is zero or positive.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">floor</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">18</span>.<span class="ruby-identifier">floor</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 10</span>
(<span class="ruby-value">-18</span>).<span class="ruby-identifier">floor</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> -20</span>
</pre>
<div class="method-source-code" id="floor-source">
<pre>static VALUE
int_floor(int argc, VALUE* argv, VALUE num)
{
int ndigits;
if (!rb_check_arity(argc, 0, 1)) return num;
ndigits = NUM2INT(argv[0]);
if (ndigits >= 0) {
return num;
}
return rb_int_floor(num, ndigits);
}</pre>
</div>
</div>
</div>
<div id="method-i-gcd" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
gcd(other_int) → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the greatest common divisor of the two integers. The result is always positive. 0.gcd(x) and x.gcd(0) return x.abs.</p>
<pre class="ruby"><span class="ruby-value">36</span>.<span class="ruby-identifier">gcd</span>(<span class="ruby-value">60</span>) <span class="ruby-comment">#=> 12</span>
<span class="ruby-value">2</span>.<span class="ruby-identifier">gcd</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 2</span>
<span class="ruby-value">3</span>.<span class="ruby-identifier">gcd</span>(<span class="ruby-value">-7</span>) <span class="ruby-comment">#=> 1</span>
((<span class="ruby-value">1</span><span class="ruby-operator"><<</span><span class="ruby-value">31</span>)<span class="ruby-value">-1</span>).<span class="ruby-identifier">gcd</span>((<span class="ruby-value">1</span><span class="ruby-operator"><<</span><span class="ruby-value">61</span>)<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 1</span>
</pre>
<div class="method-source-code" id="gcd-source">
<pre>VALUE
rb_gcd(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return f_gcd(self, other);
}</pre>
</div>
</div>
</div>
<div id="method-i-gcdlcm" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
gcdlcm(other_int) → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns an array with the greatest common divisor and the least common multiple of the two integers, [gcd, lcm].</p>
<pre class="ruby"><span class="ruby-value">36</span>.<span class="ruby-identifier">gcdlcm</span>(<span class="ruby-value">60</span>) <span class="ruby-comment">#=> [12, 180]</span>
<span class="ruby-value">2</span>.<span class="ruby-identifier">gcdlcm</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> [2, 2]</span>
<span class="ruby-value">3</span>.<span class="ruby-identifier">gcdlcm</span>(<span class="ruby-value">-7</span>) <span class="ruby-comment">#=> [1, 21]</span>
((<span class="ruby-value">1</span><span class="ruby-operator"><<</span><span class="ruby-value">31</span>)<span class="ruby-value">-1</span>).<span class="ruby-identifier">gcdlcm</span>((<span class="ruby-value">1</span><span class="ruby-operator"><<</span><span class="ruby-value">61</span>)<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> [1, 4951760154835678088235319297]</span>
</pre>
<div class="method-source-code" id="gcdlcm-source">
<pre>VALUE
rb_gcdlcm(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return rb_assoc_new(f_gcd(self, other), f_lcm(self, other));
}</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">(*args)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="Integer.html#method-i-to_s">to_s</a>
</div>
</div>
<div id="method-i-integer-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
integer? → true
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Since <code>int</code> is already an <a href="Integer.html"><code>Integer</code></a>, this always returns <code>true</code>.</p>
<div class="method-source-code" id="integer-3F-source">
<pre>static VALUE
int_int_p(VALUE num)
{
return Qtrue;
}</pre>
</div>
</div>
</div>
<div id="method-i-lcm" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
lcm(other_int) → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the least common multiple of the two integers. The result is always positive. 0.lcm(x) and x.lcm(0) return zero.</p>
<pre class="ruby"><span class="ruby-value">36</span>.<span class="ruby-identifier">lcm</span>(<span class="ruby-value">60</span>) <span class="ruby-comment">#=> 180</span>
<span class="ruby-value">2</span>.<span class="ruby-identifier">lcm</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 2</span>
<span class="ruby-value">3</span>.<span class="ruby-identifier">lcm</span>(<span class="ruby-value">-7</span>) <span class="ruby-comment">#=> 21</span>
((<span class="ruby-value">1</span><span class="ruby-operator"><<</span><span class="ruby-value">31</span>)<span class="ruby-value">-1</span>).<span class="ruby-identifier">lcm</span>((<span class="ruby-value">1</span><span class="ruby-operator"><<</span><span class="ruby-value">61</span>)<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 4951760154835678088235319297</span>
</pre>
<div class="method-source-code" id="lcm-source">
<pre>VALUE
rb_lcm(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return f_lcm(self, other);
}</pre>
</div>
</div>
</div>
<div id="method-i-magnitude" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
magnitude → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the absolute value of <code>int</code>.</p>
<pre class="ruby">(<span class="ruby-value">-12345</span>).<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 12345</span>
<span class="ruby-value">-12345</span>.<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 12345</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">abs</span> <span class="ruby-comment">#=> 12345</span>
</pre>
<p><a href="Integer.html#method-i-magnitude"><code>Integer#magnitude</code></a> is an alias for <a href="Integer.html#method-i-abs"><code>Integer#abs</code></a>.</p>
<div class="method-source-code" id="magnitude-source">
<pre>VALUE
rb_int_abs(VALUE num)
{
if (FIXNUM_P(num)) {
return fix_abs(num);
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_abs(num);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-modulo" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
modulo(other) → real
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>int</code> modulo <code>other</code>.</p>
<p>See <a href="Numeric.html#method-i-divmod"><code>Numeric#divmod</code></a> for more information.</p>
<div class="method-source-code" id="modulo-source">
<pre>VALUE
rb_int_modulo(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_mod(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_modulo(x, y);
}
return num_modulo(x, y);
}</pre>
</div>
</div>
</div>
<div id="method-i-next" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
next → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the successor of <code>int</code>, i.e. the <a href="Integer.html"><code>Integer</code></a> equal to <code>int+1</code>.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">next</span> <span class="ruby-comment">#=> 2</span>
(<span class="ruby-value">-1</span>).<span class="ruby-identifier">next</span> <span class="ruby-comment">#=> 0</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">succ</span> <span class="ruby-comment">#=> 2</span>
(<span class="ruby-value">-1</span>).<span class="ruby-identifier">succ</span> <span class="ruby-comment">#=> 0</span>
</pre>
<div class="method-source-code" id="next-source">
<pre>VALUE
rb_int_succ(VALUE num)
{
if (FIXNUM_P(num)) {
long i = FIX2LONG(num) + 1;
return LONG2NUM(i);
}
if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_plus(num, INT2FIX(1));
}
return num_funcall1(num, '+', INT2FIX(1));
}</pre>
</div>
</div>
</div>
<div id="method-i-nobits-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
nobits?(mask) → 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 no bits of <code>int & mask</code> are 1.</p>
<div class="method-source-code" id="nobits-3F-source">
<pre>static VALUE
int_nobits_p(VALUE num, VALUE mask)
{
mask = rb_to_int(mask);
return num_zero_p(rb_int_and(num, mask));
}</pre>
</div>
</div>
</div>
<div id="method-i-numerator" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
numerator → self
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns self.</p>
<div class="method-source-code" id="numerator-source">
<pre>static VALUE
integer_numerator(VALUE self)
{
return self;
}</pre>
</div>
</div>
</div>
<div id="method-i-odd-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
odd? → 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>int</code> is an odd number.</p>
<div class="method-source-code" id="odd-3F-source">
<pre>VALUE
rb_int_odd_p(VALUE num)
{
if (FIXNUM_P(num)) {
if (num & 2) {
return Qtrue;
}
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_odd_p(num);
}
else if (rb_funcall(num, '%', 1, INT2FIX(2)) != INT2FIX(0)) {
return Qtrue;
}
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-ord" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
ord → self
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the <code>int</code> itself.</p>
<pre class="ruby"><span class="ruby-value">97</span>.<span class="ruby-identifier">ord</span> <span class="ruby-comment">#=> 97</span>
</pre>
<p>This method is intended for compatibility to character literals in Ruby 1.9.</p>
<p>For example, <code>?a.ord</code> returns 97 both in 1.8 and 1.9.</p>
<div class="method-source-code" id="ord-source">
<pre>static VALUE
int_ord(VALUE num)
{
return num;
}</pre>
</div>
</div>
</div>
<div id="method-i-pow" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
pow(numeric) → numeric
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
pow(integer, integer) → integer
</span>
</div>
<div class="method-description">
<p>Returns (modular) exponentiation as:</p>
<pre class="ruby"><span class="ruby-identifier">a</span>.<span class="ruby-identifier">pow</span>(<span class="ruby-identifier">b</span>) <span class="ruby-comment">#=> same as a**b</span>
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">pow</span>(<span class="ruby-identifier">b</span>, <span class="ruby-identifier">m</span>) <span class="ruby-comment">#=> same as (a**b) % m, but avoids huge temporary values</span>
</pre>
<div class="method-source-code" id="pow-source">
<pre>VALUE
rb_int_powm(int const argc, VALUE * const argv, VALUE const num)
{
rb_check_arity(argc, 1, 2);
if (argc == 1) {
return rb_int_pow(num, argv[0]);
}
else {
VALUE const a = num;
VALUE const b = argv[0];
VALUE m = argv[1];
int nega_flg = 0;
if ( ! RB_INTEGER_TYPE_P(b)) {
rb_raise(rb_eTypeError, "Integer#pow() 2nd argument not allowed unless a 1st argument is integer");
}
if (rb_int_negative_p(b)) {
rb_raise(rb_eRangeError, "Integer#pow() 1st argument cannot be negative when 2nd argument specified");
}
if (!RB_INTEGER_TYPE_P(m)) {
rb_raise(rb_eTypeError, "Integer#pow() 2nd argument not allowed unless all arguments are integers");
}
if (rb_int_negative_p(m)) {
m = rb_int_uminus(m);
nega_flg = 1;
}
if (FIXNUM_P(m)) {
long const half_val = (long)HALF_LONG_MSB;
long const mm = FIX2LONG(m);
if (!mm) rb_num_zerodiv();
if (mm <= half_val) {
return int_pow_tmp1(rb_int_modulo(a, m), b, mm, nega_flg);
}
else {
return int_pow_tmp2(rb_int_modulo(a, m), b, mm, nega_flg);
}
}
else {
if (rb_bigzero_p(m)) rb_num_zerodiv();
return int_pow_tmp3(rb_int_modulo(a, m), b, m, nega_flg);
}
}
UNREACHABLE_RETURN(Qnil);
}</pre>
</div>
</div>
</div>
<div id="method-i-pred" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
pred → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the predecessor of <code>int</code>, i.e. the <a href="Integer.html"><code>Integer</code></a> equal to <code>int-1</code>.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">pred</span> <span class="ruby-comment">#=> 0</span>
(<span class="ruby-value">-1</span>).<span class="ruby-identifier">pred</span> <span class="ruby-comment">#=> -2</span>
</pre>
<div class="method-source-code" id="pred-source">
<pre>static VALUE
rb_int_pred(VALUE num)
{
if (FIXNUM_P(num)) {
long i = FIX2LONG(num) - 1;
return LONG2NUM(i);
}
if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_minus(num, INT2FIX(1));
}
return num_funcall1(num, '-', INT2FIX(1));
}</pre>
</div>
</div>
</div>
<div id="method-i-prime-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">prime?</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns true if <code>self</code> is a prime number, else returns false.</p>
<div class="method-source-code" id="prime-3F-source">
<pre><span class="ruby-comment"># File lib/prime.rb, line 34</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">prime?</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">self</span> <span class="ruby-operator">>=</span> <span class="ruby-value">2</span> <span class="ruby-keyword">if</span> <span class="ruby-keyword">self</span> <span class="ruby-operator"><=</span> <span class="ruby-value">3</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">true</span> <span class="ruby-keyword">if</span> <span class="ruby-keyword">self</span> <span class="ruby-operator">==</span> <span class="ruby-value">5</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">false</span> <span class="ruby-keyword">unless</span> <span class="ruby-value">30</span>.<span class="ruby-identifier">gcd</span>(<span class="ruby-keyword">self</span>) <span class="ruby-operator">==</span> <span class="ruby-value">1</span>
(<span class="ruby-value">7</span><span class="ruby-operator">..</span><span class="ruby-constant">Integer</span>.<span class="ruby-identifier">sqrt</span>(<span class="ruby-keyword">self</span>)).<span class="ruby-identifier">step</span>(<span class="ruby-value">30</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">p</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">false</span> <span class="ruby-keyword">if</span>
<span class="ruby-keyword">self</span><span class="ruby-operator">%</span>(<span class="ruby-identifier">p</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-keyword">self</span><span class="ruby-operator">%</span>(<span class="ruby-identifier">p</span><span class="ruby-value">+4</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-keyword">self</span><span class="ruby-operator">%</span>(<span class="ruby-identifier">p</span><span class="ruby-value">+6</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-keyword">self</span><span class="ruby-operator">%</span>(<span class="ruby-identifier">p</span><span class="ruby-value">+10</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span>
<span class="ruby-keyword">self</span><span class="ruby-operator">%</span>(<span class="ruby-identifier">p</span><span class="ruby-value">+12</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-keyword">self</span><span class="ruby-operator">%</span>(<span class="ruby-identifier">p</span><span class="ruby-value">+16</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-keyword">self</span><span class="ruby-operator">%</span>(<span class="ruby-identifier">p</span><span class="ruby-value">+22</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-keyword">self</span><span class="ruby-operator">%</span>(<span class="ruby-identifier">p</span><span class="ruby-value">+24</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">true</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-prime_division" class="method-detail ">
<div class="method-heading">
<span class="method-name">prime_division</span><span
class="method-args">(generator = Prime::Generator23.new)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the factorization of <code>self</code>.</p>
<p>See <a href="Prime.html#method-i-prime_division"><code>Prime#prime_division</code></a> for more details.</p>
<div class="method-source-code" id="prime_division-source">
<pre><span class="ruby-comment"># File lib/prime.rb, line 29</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">prime_division</span>(<span class="ruby-identifier">generator</span> = <span class="ruby-constant">Prime</span><span class="ruby-operator">::</span><span class="ruby-constant">Generator23</span>.<span class="ruby-identifier">new</span>)
<span class="ruby-constant">Prime</span>.<span class="ruby-identifier">prime_division</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">generator</span>)
<span class="ruby-keyword">end</span></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 the value as a rational. The optional argument <code>eps</code> is always ignored.</p>
<div class="method-source-code" id="rationalize-source">
<pre>static VALUE
integer_rationalize(int argc, VALUE *argv, VALUE self)
{
rb_check_arity(argc, 0, 1);
return integer_to_r(self);
}</pre>
</div>
</div>
</div>
<div id="method-i-remainder" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
remainder(numeric) → real
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the remainder after dividing <code>int</code> by <code>numeric</code>.</p>
<p><code>x.remainder(y)</code> means <code>x-y*(x/y).truncate</code>.</p>
<pre class="ruby"><span class="ruby-value">5</span>.<span class="ruby-identifier">remainder</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> 2</span>
<span class="ruby-value">-5</span>.<span class="ruby-identifier">remainder</span>(<span class="ruby-value">3</span>) <span class="ruby-comment">#=> -2</span>
<span class="ruby-value">5</span>.<span class="ruby-identifier">remainder</span>(<span class="ruby-value">-3</span>) <span class="ruby-comment">#=> 2</span>
<span class="ruby-value">-5</span>.<span class="ruby-identifier">remainder</span>(<span class="ruby-value">-3</span>) <span class="ruby-comment">#=> -2</span>
<span class="ruby-value">5</span>.<span class="ruby-identifier">remainder</span>(<span class="ruby-value">1.5</span>) <span class="ruby-comment">#=> 0.5</span>
</pre>
<p>See <a href="Numeric.html#method-i-divmod"><code>Numeric#divmod</code></a>.</p>
<div class="method-source-code" id="remainder-source">
<pre>static VALUE
int_remainder(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return num_remainder(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_remainder(x, y);
}
return Qnil;
}</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>int</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 <code>self</code> when <code>ndigits</code> is zero or positive.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">round</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">15</span>.<span class="ruby-identifier">round</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 20</span>
(<span class="ruby-value">-15</span>).<span class="ruby-identifier">round</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> -20</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-value">25</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">#=> 30</span>
<span class="ruby-value">25</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">#=> 20</span>
<span class="ruby-value">25</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">#=> 20</span>
<span class="ruby-value">35</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">#=> 40</span>
<span class="ruby-value">35</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">#=> 30</span>
<span class="ruby-value">35</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">#=> 40</span>
(<span class="ruby-value">-25</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">#=> -30</span>
(<span class="ruby-value">-25</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">#=> -20</span>
(<span class="ruby-value">-25</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">#=> -20</span>
</pre>
<div class="method-source-code" id="round-source">
<pre>static VALUE
int_round(int argc, VALUE* argv, VALUE num)
{
int ndigits;
int mode;
VALUE nd, opt;
if (!rb_scan_args(argc, argv, "01:", &nd, &opt)) return num;
ndigits = NUM2INT(nd);
mode = rb_num_get_rounding_option(opt);
if (ndigits >= 0) {
return num;
}
return rb_int_round(num, ndigits, mode);
}</pre>
</div>
</div>
</div>
<div id="method-i-size" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
size → int
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the number of bytes in the machine representation of <code>int</code> (machine dependent).</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">size</span> <span class="ruby-comment">#=> 8</span>
<span class="ruby-value">-1</span>.<span class="ruby-identifier">size</span> <span class="ruby-comment">#=> 8</span>
<span class="ruby-value">2147483647</span>.<span class="ruby-identifier">size</span> <span class="ruby-comment">#=> 8</span>
(<span class="ruby-value">256</span><span class="ruby-operator">**</span><span class="ruby-value">10</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>).<span class="ruby-identifier">size</span> <span class="ruby-comment">#=> 10</span>
(<span class="ruby-value">256</span><span class="ruby-operator">**</span><span class="ruby-value">20</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>).<span class="ruby-identifier">size</span> <span class="ruby-comment">#=> 20</span>
(<span class="ruby-value">256</span><span class="ruby-operator">**</span><span class="ruby-value">40</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>).<span class="ruby-identifier">size</span> <span class="ruby-comment">#=> 40</span>
</pre>
<div class="method-source-code" id="size-source">
<pre>static VALUE
int_size(VALUE num)
{
if (FIXNUM_P(num)) {
return fix_size(num);
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_size_m(num);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-succ" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
succ → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the successor of <code>int</code>, i.e. the <a href="Integer.html"><code>Integer</code></a> equal to <code>int+1</code>.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">next</span> <span class="ruby-comment">#=> 2</span>
(<span class="ruby-value">-1</span>).<span class="ruby-identifier">next</span> <span class="ruby-comment">#=> 0</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">succ</span> <span class="ruby-comment">#=> 2</span>
(<span class="ruby-value">-1</span>).<span class="ruby-identifier">succ</span> <span class="ruby-comment">#=> 0</span>
</pre>
<div class="method-source-code" id="succ-source">
<pre>VALUE
rb_int_succ(VALUE num)
{
if (FIXNUM_P(num)) {
long i = FIX2LONG(num) + 1;
return LONG2NUM(i);
}
if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_plus(num, INT2FIX(1));
}
return num_funcall1(num, '+', INT2FIX(1));
}</pre>
</div>
</div>
</div>
<div id="method-i-times" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
times {|i| block } → self
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
times → an_enumerator
</span>
</div>
<div class="method-description">
<p>Iterates the given block <code>int</code> times, passing in values from zero to <code>int - 1</code>.</p>
<p>If no block is given, an <a href="Enumerator.html"><code>Enumerator</code></a> is returned instead.</p>
<pre class="ruby"><span class="ruby-value">5</span>.<span class="ruby-identifier">times</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span> <span class="ruby-identifier">print</span> <span class="ruby-identifier">i</span>, <span class="ruby-string">" "</span> } <span class="ruby-comment">#=> 0 1 2 3 4</span>
</pre>
<div class="method-source-code" id="times-source">
<pre>static VALUE
int_dotimes(VALUE num)
{
RETURN_SIZED_ENUMERATOR(num, 0, 0, int_dotimes_size);
if (FIXNUM_P(num)) {
long i, end;
end = FIX2LONG(num);
for (i=0; i<end; i++) {
rb_yield_1(LONG2FIX(i));
}
}
else {
VALUE i = INT2FIX(0);
for (;;) {
if (!RTEST(rb_funcall(i, '<', 1, num))) break;
rb_yield(i);
i = rb_funcall(i, '+', 1, INT2FIX(1));
}
}
return num;
}</pre>
</div>
</div>
</div>
<div id="method-i-to_bn" class="method-detail ">
<div class="method-heading">
<span class="method-name">to_bn</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Casts an <a href="Integer.html"><code>Integer</code></a> as an <a href="OpenSSL/BN.html"><code>OpenSSL::BN</code></a></p>
<p>See `man bn` for more info.</p>
<div class="method-source-code" id="to_bn-source">
<pre><span class="ruby-comment"># File ext/openssl/lib/openssl/bn.rb, line 37</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_bn</span>
<span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">BN</span><span class="ruby-operator">::</span><span class="ruby-identifier">new</span>(<span class="ruby-keyword">self</span>)
<span class="ruby-keyword">end</span></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-description">
<p>Returns the value of <code>int</code> as a <a href="BigDecimal.html"><code>BigDecimal</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">42</span>.<span class="ruby-identifier">to_d</span> <span class="ruby-comment"># => 0.42e2</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 23</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_d</span>
<span class="ruby-constant">BigDecimal</span>(<span class="ruby-keyword">self</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>Converts <code>int</code> to a <a href="Float.html"><code>Float</code></a>. If <code>int</code> doesn't fit in a <a href="Float.html"><code>Float</code></a>, the result is infinity.</p>
<div class="method-source-code" id="to_f-source">
<pre>static VALUE
int_to_f(VALUE num)
{
double val;
if (FIXNUM_P(num)) {
val = (double)FIX2LONG(num);
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
val = rb_big2dbl(num);
}
else {
rb_raise(rb_eNotImpError, "Unknown subclass for to_f: %s", rb_obj_classname(num));
}
return DBL2NUM(val);
}</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>Since <code>int</code> is already an <a href="Integer.html"><code>Integer</code></a>, returns <code>self</code>.</p>
<p><a href="Integer.html#method-i-to_int"><code>to_int</code></a> is an alias for <a href="Integer.html#method-i-to_i"><code>to_i</code></a>.</p>
<div class="method-source-code" id="to_i-source">
<pre>static VALUE
int_to_i(VALUE num)
{
return num;
}</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>Since <code>int</code> is already an <a href="Integer.html"><code>Integer</code></a>, returns <code>self</code>.</p>
<p><a href="Integer.html#method-i-to_int"><code>to_int</code></a> is an alias for <a href="Integer.html#method-i-to_i"><code>to_i</code></a>.</p>
<div class="method-source-code" id="to_int-source">
<pre>static VALUE
int_to_i(VALUE num)
{
return num;
}</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">1</span>.<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (1/1)</span>
(<span class="ruby-value">1</span><span class="ruby-operator"><<</span><span class="ruby-value">64</span>).<span class="ruby-identifier">to_r</span> <span class="ruby-comment">#=> (18446744073709551616/1)</span>
</pre>
<div class="method-source-code" id="to_r-source">
<pre>static VALUE
integer_to_r(VALUE self)
{
return rb_rational_new1(self);
}</pre>
</div>
</div>
</div>
<div id="method-i-to_s" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_s(base=10) → string
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a string containing the place-value representation of <code>int</code> with radix <code>base</code> (between 2 and 36).</p>
<pre class="ruby"><span class="ruby-value">12345</span>.<span class="ruby-identifier">to_s</span> <span class="ruby-comment">#=> "12345"</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">to_s</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> "11000000111001"</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">to_s</span>(<span class="ruby-value">8</span>) <span class="ruby-comment">#=> "30071"</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">to_s</span>(<span class="ruby-value">10</span>) <span class="ruby-comment">#=> "12345"</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">to_s</span>(<span class="ruby-value">16</span>) <span class="ruby-comment">#=> "3039"</span>
<span class="ruby-value">12345</span>.<span class="ruby-identifier">to_s</span>(<span class="ruby-value">36</span>) <span class="ruby-comment">#=> "9ix"</span>
<span class="ruby-value">78546939656932</span>.<span class="ruby-identifier">to_s</span>(<span class="ruby-value">36</span>) <span class="ruby-comment">#=> "rubyrules"</span>
</pre>
<div class="method-source-code" id="to_s-source">
<pre>static VALUE
int_to_s(int argc, VALUE *argv, VALUE x)
{
int base;
if (rb_check_arity(argc, 0, 1))
base = NUM2INT(argv[0]);
else
base = 10;
return rb_int2str(x, base);
}</pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="Integer.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>int</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 <code>self</code> when <code>ndigits</code> is zero or positive.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">truncate</span> <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">truncate</span>(<span class="ruby-value">2</span>) <span class="ruby-comment">#=> 1</span>
<span class="ruby-value">18</span>.<span class="ruby-identifier">truncate</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> 10</span>
(<span class="ruby-value">-18</span>).<span class="ruby-identifier">truncate</span>(<span class="ruby-value">-1</span>) <span class="ruby-comment">#=> -10</span>
</pre>
<div class="method-source-code" id="truncate-source">
<pre>static VALUE
int_truncate(int argc, VALUE* argv, VALUE num)
{
int ndigits;
if (!rb_check_arity(argc, 0, 1)) return num;
ndigits = NUM2INT(argv[0]);
if (ndigits >= 0) {
return num;
}
return rb_int_truncate(num, ndigits);
}</pre>
</div>
</div>
</div>
<div id="method-i-upto" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
upto(limit) {|i| block } → self
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
upto(limit) → an_enumerator
</span>
</div>
<div class="method-description">
<p>Iterates the given block, passing in integer values from <code>int</code> up to and including <code>limit</code>.</p>
<p>If no block is given, an <a href="Enumerator.html"><code>Enumerator</code></a> is returned instead.</p>
<pre class="ruby"><span class="ruby-value">5</span>.<span class="ruby-identifier">upto</span>(<span class="ruby-value">10</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span> <span class="ruby-identifier">print</span> <span class="ruby-identifier">i</span>, <span class="ruby-string">" "</span> } <span class="ruby-comment">#=> 5 6 7 8 9 10</span>
</pre>
<div class="method-source-code" id="upto-source">
<pre>static VALUE
int_upto(VALUE from, VALUE to)
{
RETURN_SIZED_ENUMERATOR(from, 1, &to, int_upto_size);
if (FIXNUM_P(from) && FIXNUM_P(to)) {
long i, end;
end = FIX2LONG(to);
for (i = FIX2LONG(from); i <= end; i++) {
rb_yield(LONG2FIX(i));
}
}
else {
VALUE i = from, c;
while (!(c = rb_funcall(i, '>', 1, to))) {
rb_yield(i);
i = rb_funcall(i, '+', 1, INT2FIX(1));
}
if (NIL_P(c)) rb_cmperr(i, to);
}
return from;
}</pre>
</div>
</div>
</div>
<div id="method-i-7C" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
int | other_int → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Bitwise OR.</p>
<div class="method-source-code" id="7C-source">
<pre>static VALUE
int_or(VALUE x, VALUE y)
{
if (FIXNUM_P(x)) {
return fix_or(x, y);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return rb_big_or(x, y);
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-~" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
~int → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>One's complement: returns a number where each bit is flipped.</p>
<p>Inverts the bits in an <a href="Integer.html"><code>Integer</code></a>. As integers are conceptually of infinite length, the result acts as if it had an infinite number of one bits to the left. In hex representations, this is displayed as two periods to the left of the digits.</p>
<pre class="ruby"><span class="ruby-identifier">sprintf</span>(<span class="ruby-string">"%X"</span>, <span class="ruby-operator">~</span><span class="ruby-value">0x1122334455</span>) <span class="ruby-comment">#=> "..FEEDDCCBBAA"</span>
</pre>
<div class="method-source-code" id="~-source">
<pre>static VALUE
int_comp(VALUE num)
{
if (FIXNUM_P(num)) {
return fix_comp(num);
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_comp(num);
}
return Qnil;
}</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>