long-decimal 0.01.01 → 0.01.02

data/README

@@ -2,7 +2,7 @@ Version
 -------
 
 This version ($Name: ALPHA_01_01 $) is functionally identical with the previous
-pre-alpha-0.22.  The runit tests have been extended and further tests
+alpha-0.01.00.  The runit tests have been extended and further tests
 have been added.  A lot of additional testing has been done using
 random numbers as parameters with testrandom.rb and values for which
 these random tests have failed have been added to the regular tests in
@@ -15,7 +15,7 @@ found directly with http://rubyforge.org/projects/long-decimal/ .  So
 you should feel encouraged to look if there is a newer version, when
 you install long-decimal.
 
-This version is a alpha-version.  Operations +, -, *, / and sqrt
+This version is an alpha-version.  Operations +, -, *, / and sqrt
 should be working properly and would justify calling this release at
 least beta.  Even log, exp and power should be fine.  log, log2, log10
 and exp have been tested for about a million random values and the
@@ -30,8 +30,8 @@ rounded up or down.  Because these functions are transcendental, at
 least exp and log will always have either one of these true, it will
 never be exactly ....5.  Speed could be improved as well.
 
-It would be a good idea to do some mathematical analysis on how many
-digits are needed internally to guarantee the correctness of the
+It would be a good idea to do some more mathematical analysis on how
+many digits are needed internally to guarantee the correctness of the
 digits that are provided.  But this will not be considered as a
 requirement for the alpha-version.
 
@@ -50,86 +50,27 @@ your machine.  It is about 15 minutes on my machine (1300 MHz).
 Whatever is gained by making the software run faster is used up again
 by adding more tests.  This is the result of the test:
 
-Finished in 1131.2352 seconds.
-128 tests, 45190 assertions, 0 failures, 0 errors
+Finished in 1160.808707 seconds.
 
-In addition random tests for exp, log, log2 and log10 can be run for a
-long time, using the script test/testrandom.rb.  This requires
-installation of the ruby-library crypt-isaac for its random numbers.
-If you actually want to run this and find an error with it, please
-report it with the lines of output revealing the bug on
-http://rubyforge.org/projects/long-decimal/ -> tracker
-
-Install
--------
-
-(REMARK: installation has only been successfully tested on Linux with
-ruby 1.8.4 and on Windows 2000 with ruby 1.8.2)
-
-1. Using ruby-gems (preferred)
-- open a shell window
-- become root, unless the current user has the right to install gems
-  (which is usually the case on windows)
-
-  su
-
-- uninstall old versions
-
-  gem uninstall long-decimal
-
-- install the newest version
-
-  gem install long-decimal
-
-- Usage from your ruby-programs:
-
-  require "rubygems"
-  require_gem "long-decimal"
-
-- documentation will be found in HTML-format in the directory
-  $RUBY_DIR/gems/$RUBY_VERSION/doc/long-decimal-$LONG_DECIMAL_VERSION/rdoc/index.html
-  where $RUBY_DIR is the directory containing your ruby-installation,
-                  usually /usr/lib/ruby or /usr/local/lib/ruby on
-                  Linux/Unix-systems.
-        $RUBY_VERSION is the major version of your Ruby, like 1.8
-        $LONG_DECIMAL_VERSION is the version of long-decimal that you
-                              have installed, like 0.00.20
-  on my machine that would be
-  /usr/local/lib/ruby/gems/1.8/doc/long-decimal-0.00.20/rdoc/index.html
-
-2. Installing from the sources (it is preferred to use the
-   gem-installation, but since long-decimal is open-source-software you
-   are off course granted the right to download the source and change
-   it and install your own version.
-
-- download the newest source-tar.gz-file from long-decimal project at rubyforge
-  which can be found by
-  http://rubyforge.org/projects/long-decimal/ -> Files
-  ( http://rubyforge.org/frs/?group_id=1334 )
-- open a shell window
-  cd to the directory where you have downloaded the gem-file
-  unpack the file using tar
-  tar xfzvv long-decimal-alpha-1_00.tar.gz
-  cd long-decimal
-- now you can use rake for several operations
-  - rake test
-      runs runit tests.  All tests should succeed.
-  - rake doc
-      creates the documentation
-  - rake gem creates the gem-file in a sub-directory pkg
-      recommended for installation, proceed as in 1
-  - cd pkg
-  - gem install --local long-decimal
+131 tests, 45612 assertions, 0 failures, 0 errors
 
+In addition random tests for exp, exp2, exp10, sqrt, log, log2 and
+log10 can be run for a long time, using the script test/testrandom.rb.
+Likewise tests for powers x to the yth with random x and y can be
+tested for a long time using test/testrandpower.rb
 
-3. The documentation can be created from the sources.  It is contained
-in the gem-file.  It is not provided as a separate file any more.
+These two require installation of the ruby-library crypt-isaac for its
+random numbers, which works well with Linux or Windows and Cygwin.  If
+you actually want to run this and find an error with it, please report
+it with the lines of output revealing the bug on
+http://rubyforge.org/projects/long-decimal/ -> tracker
 
 Install
 -------
 
 (REMARK: installation has only been successfully tested on Linux with
-ruby 1.8.4 and on Windows 2000 with ruby 1.8.2)
+ruby 1.8.4 and on Windows XP with Cygwin and ruby 1.8.4 and on Windows
+2000 with ruby 1.8.2)
 
 1. Using ruby-gems (preferred)
 - open a shell window
@@ -190,24 +131,6 @@ ruby 1.8.4 and on Windows 2000 with ruby 1.8.2)
 3. The documentation can be created from the sources.  It is contained
 in the gem-file.  It is not provided as a separate file any more.
 
-Test
-----
-
-Some runit tests have been included.  They give some indication of the
-correctness of this library and allow changes to be checked in order
-to make sure that what was running before would still work afterwards.
-Tests for a library as complex as long-decimal can never be
-exhaustive, but they give a good indication that methods are working
-correctly.  About 95% of the tests that will be eventually needed are
-already present.  As a policy a release is not created unless all
-tests succeed.  Running the tests can take a few minutes, depending on
-your machine.  It is about 15 minutes on my machine (1300 MHz).
-Whatever is gained by making the software run faster is used up again
-by adding more tests.  This is the result of the test:
-
-Finished in 1131.2352 seconds.
-128 tests, 45190 assertions, 0 failures, 0 errors
-
 Bugs
 ----
 

data/VERSION

@@ -1 +1 @@
-0.01.01
+0.01.02

data/doc/classes/Integer.html

@@ -0,0 +1,239 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html 
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Class: Integer</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <meta http-equiv="Content-Script-Type" content="text/javascript" />
+  <link rel="stylesheet" href=".././rdoc-style.css" type="text/css" media="screen" />
+  <script type="text/javascript">
+  // <![CDATA[
+
+  function popupCode( url ) {
+    window.open(url, "Code", "resizable=yes,scrollbars=yes,toolbar=no,status=no,height=150,width=400")
+  }
+
+  function toggleCode( id ) {
+    if ( document.getElementById )
+      elem = document.getElementById( id );
+    else if ( document.all )
+      elem = eval( "document.all." + id );
+    else
+      return false;
+
+    elemStyle = elem.style;
+    
+    if ( elemStyle.display != "block" ) {
+      elemStyle.display = "block"
+    } else {
+      elemStyle.display = "none"
+    }
+
+    return true;
+  }
+  
+  // Make codeblocks hidden by default
+  document.writeln( "<style type=\"text/css\">div.method-source-code { display: none }</style>" )
+  
+  // ]]>
+  </script>
+
+</head>
+<body>
+
+
+
+    <div id="classHeader">
+        <table class="header-table">
+        <tr class="top-aligned-row">
+          <td><strong>Class</strong></td>
+          <td class="class-name-in-header">Integer</td>
+        </tr>
+        <tr class="top-aligned-row">
+            <td><strong>In:</strong></td>
+            <td>
+                <a href="../files/lib/long-decimal_rb.html">
+                lib/long-decimal.rb
+                </a>
+        <br />
+            </td>
+        </tr>
+
+        <tr class="top-aligned-row">
+            <td><strong>Parent:</strong></td>
+            <td>
+                Object
+            </td>
+        </tr>
+        </table>
+    </div>
+  <!-- banner header -->
+
+  <div id="bodyContent">
+
+
+
+  <div id="contextContent">
+    <div id="diagram">
+      <map id="map" name="map">
+  <area shape="rect" coords="94,7,171,55"      href="Comparable.html" alt="Comparable" />
+  <area shape="rect" coords="158,206,235,254"      href="LongMath/CacheKey.html" alt="CacheKey" />
+  <area shape="rect" coords="231,103,356,151"      href="LongDecimalRoundingMode/RoundingModeClass.html" alt="RoundingModeClass" />
+  <area shape="rect" coords="58,103,207,151"      href="LongDecimalRoundingMode/ZeroRoundingModeClass.html" alt="ZeroRoundingModeClass" />
+  <area shape="rect" coords="355,206,470,254"      href="LongDecimalBase.html" alt="LongDecimalBase" />
+  <area shape="rect" coords="294,302,406,350"      href="LongDecimalQuot.html" alt="LongDecimalQuot" />
+  <area shape="rect" coords="195,7,267,55"      href="Integer.html" alt="Integer" />
+  <area shape="rect" coords="430,302,520,350"      href="LongDecimal.html" alt="LongDecimal" />
+  <area shape="rect" coords="407,103,479,151"      href="Numeric.html" alt="Numeric" />
+  <area shape="rect" coords="291,7,363,55"      href="Rational.html" alt="Rational" />
+  <area shape="rect" coords="147,172,272,264"      href="LongMath.html" alt="LongMath" />
+  <area shape="rect" coords="47,70,394,162"      href="LongDecimalRoundingMode.html" alt="LongDecimalRoundingMode" />
+</map>
+<img src="../dot/f_0.png" usemap="#map" border="0" alt="dot/f_0.png">
+    </div>
+
+    <div id="description">
+      <p>
+add one method to <a href="Integer.html">Integer</a>
+</p>
+
+    </div>
+
+
+   </div>
+
+    <div id="method-list">
+      <h3 class="section-bar">Methods</h3>
+
+      <div class="name-list">
+      <a href="#M000039">round_to_allowed_remainders</a>&nbsp;&nbsp;
+      <a href="#M000036">sgn</a>&nbsp;&nbsp;
+      <a href="#M000038">sign</a>&nbsp;&nbsp;
+      <a href="#M000037">signum</a>&nbsp;&nbsp;
+      </div>
+    </div>
+
+  </div>
+
+
+    <!-- if includes -->
+
+    <div id="section">
+
+
+
+
+
+      
+
+
+    <!-- if method_list -->
+    <div id="methods">
+      <h3 class="section-bar">Public Instance methods</h3>
+
+      <div id="method-M000039" class="method-detail">
+        <a name="M000039"></a>
+
+        <div class="method-heading">
+          <a href="Integer.src/M000039.html" target="Code" class="method-signature"
+            onclick="popupCode('Integer.src/M000039.html');return false;">
+          <span class="method-name">round_to_allowed_remainders</span><span class="method-args">(remainders, modulus, rounding_mode = LongDecimalRoundingMode::ROUND_UNNECESSARY, zero_rounding_mode = LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+create copy of self round in such a way that the result is congruent modulo
+modulus to one of the members of remainders
+</p>
+<p>
+param1: remainders array of allowed remainders param2: modulus modulus of
+the remainders param3: rounding_mode rounding mode to be applied when
+information is
+</p>
+<pre>
+                      lost.   defaults  to  ROUND_UNNECESSARY,  which
+                      means that  an exception is  thrown if rounding
+                      would actually loose any information.
+</pre>
+<p>
+param4: zero_rounding_mode if self is zero, but zero is not among
+</p>
+<pre>
+                           the available remainders, it has to be
+                           rounded to positive or negative value.
+                           If the rounding_mode does not allow to
+                           determine which of the two values to
+                           use, zero_rounding_mode has to be used
+                           to decide.
+</pre>
+        </div>
+      </div>
+
+      <div id="method-M000036" class="method-detail">
+        <a name="M000036"></a>
+
+        <div class="method-heading">
+          <a href="Integer.src/M000036.html" target="Code" class="method-signature"
+            onclick="popupCode('Integer.src/M000036.html');return false;">
+          <span class="method-name">sgn</span><span class="method-args">()</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+get the <a href="Integer.html#M000038">sign</a> of self -1 if self &lt; 0
+</p>
+<pre>
+ 0 if self is 0 (with any number of 0s after the decimal point)
+</pre>
+<p>
++1 if self &gt; 0
+</p>
+        </div>
+      </div>
+
+      <div id="method-M000038" class="method-detail">
+        <a name="M000038"></a>
+
+        <div class="method-heading">
+          <span class="method-name">sign</span><span class="method-args">()</span>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Alias for <a href="Integer.html#M000036">sgn</a>
+</p>
+        </div>
+      </div>
+
+      <div id="method-M000037" class="method-detail">
+        <a name="M000037"></a>
+
+        <div class="method-heading">
+          <span class="method-name">signum</span><span class="method-args">()</span>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Alias for <a href="Integer.html#M000036">sgn</a>
+</p>
+        </div>
+      </div>
+
+
+    </div>
+
+
+  </div>
+
+
+<div id="validator-badges">
+  <p><small><a href="http://validator.w3.org/check/referer">[Validate]</a></small></p>
+</div>
+
+</body>
+</html>

data/doc/classes/Integer.src/M000036.html

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html 
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html>
+<head>
+  <title>sgn (Integer)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre><span class="ruby-comment cmt"># File lib/long-decimal.rb, line 154</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sgn</span>
+    <span class="ruby-keyword kw">self</span> <span class="ruby-operator">&lt;=&gt;</span> <span class="ruby-value">0</span>
+  <span class="ruby-keyword kw">end</span></pre>
+</body>
+</html>

data/doc/classes/Integer.src/M000039.html

@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html 
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html>
+<head>
+  <title>round_to_allowed_remainders (Integer)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre><span class="ruby-comment cmt"># File lib/long-decimal.rb, line 179</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">round_to_allowed_remainders</span>(<span class="ruby-identifier">remainders</span>,
+                                  <span class="ruby-identifier">modulus</span>,
+                                  <span class="ruby-identifier">rounding_mode</span> = <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_UNNECESSARY</span>,
+                                  <span class="ruby-identifier">zero_rounding_mode</span> = <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZERO_ROUND_UNNECESSARY</span>)
+
+    <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-value str">&quot;remainders must be Array&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">remainders</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Array</span>
+    <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-value str">&quot;remainders must be non-empty Array&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">remainders</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
+    <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-node">&quot;modulus #{modulus.inspect} must be integer&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">modulus</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Integer</span>
+    <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-node">&quot;modulus #{modulus.inspect} must be &gt;= 2&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">modulus</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-value">2</span>
+    <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-node">&quot;rounding_mode #{rounding_mode.inspect} must be legal rounding rounding_mode&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">rounding_mode</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">RoundingModeClass</span>
+    <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-value str">&quot;ROUND_HALF_EVEN is not applicable here&quot;</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_EVEN</span>
+    <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-node">&quot;zero_rounding_mode #{zero_rounding_mode.inspect} must be legal zero_rounding zero_rounding_mode&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">zero_rounding_mode</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZeroRoundingModeClass</span>
+
+    <span class="ruby-identifier">r_self</span>     = <span class="ruby-keyword kw">self</span> <span class="ruby-operator">%</span> <span class="ruby-identifier">modulus</span>
+    <span class="ruby-identifier">r_self_00</span>  = <span class="ruby-identifier">r_self</span>
+    <span class="ruby-identifier">remainders</span> = <span class="ruby-identifier">remainders</span>.<span class="ruby-identifier">collect</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">r</span><span class="ruby-operator">|</span>
+      <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-value str">&quot;remainders must be numbers&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">r</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Integer</span>
+      <span class="ruby-identifier">r</span> <span class="ruby-operator">%</span> <span class="ruby-identifier">modulus</span>
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-identifier">remainders</span>.<span class="ruby-identifier">sort!</span>.<span class="ruby-identifier">uniq!</span>
+    <span class="ruby-identifier">r_first</span> = <span class="ruby-identifier">remainders</span>[<span class="ruby-value">0</span>]
+    <span class="ruby-identifier">r_last</span>  = <span class="ruby-identifier">remainders</span>[<span class="ruby-value">-1</span>]
+    <span class="ruby-identifier">r_first_again</span> = <span class="ruby-identifier">r_first</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">modulus</span>
+    <span class="ruby-identifier">remainders</span>.<span class="ruby-identifier">push</span> <span class="ruby-identifier">r_first_again</span>
+    <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">r_self</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">r_first</span>) <span class="ruby-keyword kw">then</span>
+      <span class="ruby-identifier">r_self</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">modulus</span>
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-comment cmt"># puts &quot;r_self=#{r_self_00}-&gt;#{r_self} r_first=#{r_first} r_last=#{r_last} r_first_again=#{r_first_again}&quot;</span>
+    <span class="ruby-identifier">r_lower</span> = <span class="ruby-value">-1</span>
+    <span class="ruby-identifier">r_upper</span> = <span class="ruby-value">-1</span>
+    <span class="ruby-identifier">remainders</span>.<span class="ruby-identifier">each_index</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
+      <span class="ruby-identifier">r</span> = <span class="ruby-identifier">remainders</span>[<span class="ruby-identifier">i</span>]
+      <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">r</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">r_self</span>) <span class="ruby-keyword kw">then</span>
+        <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">self</span>
+      <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">r</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">r_self</span>) <span class="ruby-keyword kw">then</span>
+        <span class="ruby-identifier">r_lower</span> = <span class="ruby-identifier">r</span>
+      <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">r</span> <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">r_self</span>) <span class="ruby-keyword kw">then</span>
+        <span class="ruby-identifier">r_upper</span>  = <span class="ruby-identifier">r</span>
+        <span class="ruby-keyword kw">break</span>
+      <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-identifier">lower</span> = <span class="ruby-keyword kw">self</span> <span class="ruby-operator">-</span> (<span class="ruby-identifier">r_self</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">r_lower</span>)
+    <span class="ruby-identifier">upper</span> = <span class="ruby-keyword kw">self</span> <span class="ruby-operator">+</span> (<span class="ruby-identifier">r_upper</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">r_self</span>)
+    <span class="ruby-comment cmt"># puts &quot;r_lower=#{r_lower} r_upper=#{r_upper} lower=#{lower} upper=#{upper} s=#{self}&quot;</span>
+
+    <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">lower</span> <span class="ruby-operator">&lt;</span> <span class="ruby-keyword kw">self</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-keyword kw">self</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">upper</span>)
+      <span class="ruby-identifier">raise</span> <span class="ruby-constant">Error</span>, <span class="ruby-node">&quot;self=#{self} not in (#{lower}, #{upper})&quot;</span>
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_UNNECESSARY</span>) <span class="ruby-keyword kw">then</span>
+      <span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-node">&quot;mode ROUND_UNNECESSARY not applicable, self=#{self.to_s} is in open interval (#{lower}, #{upper})&quot;</span>
+    <span class="ruby-keyword kw">end</span>
+
+<span class="ruby-comment cmt">#     if (rounding_mode == LongDecimalRoundingMode::ROUND_FLOOR) then</span>
+<span class="ruby-comment cmt">#       return lower</span>
+<span class="ruby-comment cmt">#     elsif (rounding_mode == LongDecimalRoundingMode::ROUND_CEILING) then</span>
+<span class="ruby-comment cmt">#       return upper</span>
+<span class="ruby-comment cmt">#     end</span>
+
+    <span class="ruby-identifier">sign_self</span> = <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">sign</span>
+    <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">sign_self</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>) <span class="ruby-keyword kw">then</span>
+      <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_UP</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_DOWN</span> \
+          <span class="ruby-operator">||</span> <span class="ruby-identifier">lower</span> <span class="ruby-operator">==</span> <span class="ruby-operator">-</span><span class="ruby-identifier">upper</span> <span class="ruby-operator">&amp;&amp;</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_UP</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_DOWN</span>))
+        <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">zero_rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZERO_ROUND_UNNECESSARY</span>) <span class="ruby-keyword kw">then</span>
+          <span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-node">&quot;self=#{self.to_s} is 0 in open interval (#{lower}, #{upper}) and cannot be resolved with ZERO_ROUND_UNNECESSARY&quot;</span>
+        <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">zero_rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZERO_ROUND_TO_CLOSEST_PREFER_PLUS</span> \
+               <span class="ruby-operator">||</span> <span class="ruby-identifier">zero_rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZERO_ROUND_TO_CLOSEST_PREFER_MINUS</span>) <span class="ruby-keyword kw">then</span>
+          <span class="ruby-identifier">diff</span> = <span class="ruby-identifier">lower</span>.<span class="ruby-identifier">abs</span> <span class="ruby-operator">&lt;=&gt;</span> <span class="ruby-identifier">upper</span>.<span class="ruby-identifier">abs</span>
+          <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">diff</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>) <span class="ruby-keyword kw">then</span>
+            <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">lower</span>
+          <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">diff</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>) <span class="ruby-keyword kw">then</span>
+            <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">upper</span>
+          <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">zero_rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZERO_ROUND_TO_CLOSEST_PREFER_PLUS</span>) <span class="ruby-keyword kw">then</span>
+            <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">upper</span>
+          <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">zero_rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZERO_ROUND_TO_CLOSEST_PREFER_MINUS</span>) <span class="ruby-keyword kw">then</span>
+            <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">lower</span>
+          <span class="ruby-keyword kw">else</span>
+            <span class="ruby-identifier">raise</span> <span class="ruby-constant">Error</span>, <span class="ruby-node">&quot;this case can never happen: zero_rounding_mode=#{zero_rounding_mode}&quot;</span>
+          <span class="ruby-keyword kw">end</span>
+        <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">zero_rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZERO_ROUND_TO_PLUS</span>) <span class="ruby-keyword kw">then</span>
+          <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">upper</span>
+        <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">zero_rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ZERO_ROUND_TO_MINUS</span>) <span class="ruby-keyword kw">then</span>
+          <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">lower</span>
+        <span class="ruby-keyword kw">else</span>
+          <span class="ruby-identifier">raise</span> <span class="ruby-constant">Error</span>, <span class="ruby-node">&quot;this case can never happen: zero_rounding_mode=#{zero_rounding_mode}&quot;</span>
+        <span class="ruby-keyword kw">end</span>
+      <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">end</span>
+
+    <span class="ruby-comment cmt"># now we can assume that sign_self (and self) is != 0, which allows to decide on the rounding_mode</span>
+
+    <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_UP</span>)
+      <span class="ruby-comment cmt"># ROUND_UP goes to the closest possible value away from zero</span>
+      <span class="ruby-identifier">rounding_mode</span> = (<span class="ruby-identifier">sign_self</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>) <span class="ruby-operator">?</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_FLOOR</span> <span class="ruby-operator">:</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_CEILING</span>
+    <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_DOWN</span>)
+      <span class="ruby-comment cmt"># ROUND_DOWN goes to the closest possible value towards zero or beyond zero</span>
+      <span class="ruby-identifier">rounding_mode</span> = (<span class="ruby-identifier">sign_self</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>) <span class="ruby-operator">?</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_CEILING</span> <span class="ruby-operator">:</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_FLOOR</span>
+    <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_UP</span>)
+      <span class="ruby-comment cmt"># ROUND_HALF_UP goes to the closest possible value preferring away from zero</span>
+      <span class="ruby-identifier">rounding_mode</span> = (<span class="ruby-identifier">sign_self</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>) <span class="ruby-operator">?</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_FLOOR</span> <span class="ruby-operator">:</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_CEILING</span>
+    <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_DOWN</span>)
+      <span class="ruby-comment cmt"># ROUND_HALF_DOWN goes to the closest possible value preferring towards zero or beyond zero</span>
+      <span class="ruby-identifier">rounding_mode</span> = (<span class="ruby-identifier">sign_self</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>) <span class="ruby-operator">?</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_CEILING</span> <span class="ruby-operator">:</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_FLOOR</span>
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_FLOOR</span> \
+        <span class="ruby-operator">||</span> <span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_CEILING</span>) <span class="ruby-keyword kw">then</span>
+      <span class="ruby-identifier">d_lower</span> = <span class="ruby-keyword kw">self</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">lower</span>
+      <span class="ruby-identifier">d_upper</span> = <span class="ruby-identifier">upper</span> <span class="ruby-operator">-</span> <span class="ruby-keyword kw">self</span>
+      <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">d_lower</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">d_upper</span>) <span class="ruby-keyword kw">then</span>
+        <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">lower</span>
+      <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">d_upper</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">d_lower</span>) <span class="ruby-keyword kw">then</span>
+        <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">upper</span>
+      <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_FLOOR</span>) <span class="ruby-keyword kw">then</span>
+        <span class="ruby-identifier">rounding_mode</span> = <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_FLOOR</span>
+      <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_HALF_CEILING</span>) <span class="ruby-keyword kw">then</span>
+        <span class="ruby-identifier">rounding_mode</span> = <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_CEILING</span>
+      <span class="ruby-keyword kw">else</span>
+        <span class="ruby-identifier">raise</span> <span class="ruby-constant">Error</span>, <span class="ruby-node">&quot;this case can never happen: rounding_mode=#{rounding_mode}&quot;</span>
+      <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">end</span>
+
+    <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_FLOOR</span>) <span class="ruby-keyword kw">then</span>
+      <span class="ruby-comment cmt"># puts &quot;floor/lower r_lower=#{r_lower} r_upper=#{r_upper} lower=#{lower} upper=#{upper} s=#{self}&quot;</span>
+      <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">lower</span>
+    <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">rounding_mode</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LongDecimalRoundingMode</span><span class="ruby-operator">::</span><span class="ruby-constant">ROUND_CEILING</span>) <span class="ruby-keyword kw">then</span>
+      <span class="ruby-comment cmt"># puts &quot;ceiling/upper r_lower=#{r_lower} r_upper=#{r_upper} lower=#{lower} upper=#{upper} s=#{self}&quot;</span>
+      <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">upper</span>
+    <span class="ruby-keyword kw">else</span>
+      <span class="ruby-identifier">raise</span> <span class="ruby-constant">Error</span>, <span class="ruby-node">&quot;this case can never happen: rounding_mode=#{rounding_mode}&quot;</span>
+    <span class="ruby-keyword kw">end</span>
+  <span class="ruby-keyword kw">end</span></pre>
+</body>
+</html>