Spaces:

Amogh-kal1
/

forge-arena

Sleeping

File size: 51,905 Bytes

db75f77

<!DOCTYPE HTML>
<html>
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="Author" content="MMclaughlin">
  <title>decimal.js-light API</title>
  <style>

html{font-size:100%}

body{background:#fff;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px;

  line-height:1.65em;min-height:100%;margin:0}

body,i{color:#000}

.nav{background:#fff;position:fixed;top:0;bottom:0;left:0;width:210px;overflow-y:auto;

  padding:15px 0 30px 15px}

div.container{width:600px;margin:50px 0 50px 240px}

p{margin:0 0 1em;width:600px}

pre,ul{margin:1em 0}

h1,h2,h3,h4,h5{margin:0;padding:1.5em 0 0}

h1,h2{padding:.75em 0}

h1{font:400 3em Consolas, monaco, monospace;color:#000;margin-bottom:1em}

h2{font-size:2.25em;color:#f00}

h3{font-size:1.75em;color:#69d2e7}

h4{font-size:1.75em;color:#f00;padding-bottom:.75em}

h5{font-size:1.2em;margin-bottom:.4em}

h6{font-size:1.1em;margin-bottom:0.8em;padding:0.5em 0}

dd dt{font-size:1.2em}

dt{padding-top:.5em}

dd{padding-top:.35em}

b{font-weight:700}

a,a:visited{color:#f00;text-decoration:none}

a:active,a:hover{outline:0;text-decoration:underline}

.nav a,.nav b,.nav a:visited{display:block;color:#f00;font-weight:700;margin-top:15px}

.nav b{color:#69d2e7;margin-top:20px;cursor:default;width:auto}

ul{list-style-type:none;padding:0 0 0 20px}

.nav ul{line-height:14px;padding-left:0;margin:5px 0 0}

.nav ul a,.nav ul a:visited,span{display:inline;color:#000;font-family:Verdana,Geneva,sans-serif;

  font-size:11px;font-weight:400;margin:0}

.inset{margin-left:20px;font-size:.9em}

.nav li{width:auto;margin:0 0 3px}

.alias{font-style:italic;margin-left:20px}

table{border-collapse:collapse;border-spacing:0;border:2px solid #a7dbd8;margin:1.75em 0;padding:0}

td,th{text-align:left;margin:0;padding:2px 5px;border:1px dotted #a7dbd8}

th{border-top:2px solid #a7dbd8;border-bottom:2px solid #a7dbd8;color:#f00}

code,pre{font-family:Consolas, monaco, monospace;font-weight:400}

pre{background:#f5f5f5;white-space:pre-wrap;word-wrap:break-word;border-left:5px solid #a7dbd8;

  padding:1px 0 1px 15px;margin:1.2em 0}

code,.nav-title{color:#f00}

.end{margin-bottom:25px}

.centre{text-align:center}

#modes,#configProps{color:#f00}

.spacer{line-height:0px}

#faq{margin:3em 0 0}

li span{float:right;margin-right:10px;color:#c0c0c0}

#js{font:inherit;color:#f00}

  </style>
</head>
<body>

  <div class="nav">

    <a class='nav-title' href="#">API</a>

    <b>CONSTRUCTOR</b>
    <ul><li><a href="#decimal">Decimal</a></li></ul>

    <a href="#methods">Methods</a>
    <ul>
      <li><a href="#Dclone" >clone</a></li>
      <li><a href="#Dconfig">config</a></li>
    </ul>

    <a href="#constructor-properties">Properties</a>
    <ul>
      <li><a href="#precision">precision</a></li>
      <li><a href="#rounding" >rounding</a></li>
      <li><a href="#toExpNeg" >toExpNeg</a></li>
      <li><a href="#toExpPos" >toExpPos</a></li>
      <li><a href="#ln10"     >LN10</a></li>
      <li class='spacer'>&nbsp;</li>
      <li><a href="#modes">ROUND_UP</a></li>
      <li><a href="#modes">ROUND_DOWN</a></li>
      <li><a href="#modes">ROUND_CEIL</a></li>
      <li><a href="#modes">ROUND_FLOOR</a></li>
      <li><a href="#modes">ROUND_HALF_UP</a></li>
      <li><a href="#modes">ROUND_HALF_DOWN</a></li>
      <li><a href="#modes">ROUND_HALF_EVEN</a></li>
      <li><a href="#modes">ROUND_HALF_CEIL</a></li>
      <li><a href="#modes">ROUND_HALF_FLOOR</a></li>
      <li><a href="#modes">EUCLID</a></li>
    </ul>

    <b> INSTANCE </b>

    <a href="#prototype-methods">Methods</a>
    <ul>
      <li><a href="#abs"          >absoluteValue           </a><span>abs</span>  </li>
      <li><a href="#cmp"          >comparedTo              </a><span>cmp</span>  </li>
      <li><a href="#dp"           >decimalPlaces           </a><span>dp</span>   </li>
      <li><a href="#div"          >dividedBy               </a><span>div</span>  </li>
      <li><a href="#idiv"         >dividedToIntegerBy      </a><span>idiv</span> </li>
      <li><a href="#eq"           >equals                  </a><span>eq</span>   </li>
      <li><a href="#exp"          >exponent                </a>                  </li>
      <li><a href="#gt"           >greaterThan             </a><span>gt</span>   </li>
      <li><a href="#gte"          >greaterThanOrEqualTo    </a><span>gte</span>  </li>
      <li><a href="#isint"        >isInteger               </a><span>isint</span></li>
      <li><a href="#isneg"        >isNegative              </a><span>isneg</span></li>
      <li><a href="#ispos"        >isPositive              </a><span>ispos</span></li>
      <li><a href="#isZero"       >isZero                  </a>                  </li>
      <li><a href="#lt"           >lessThan                </a><span>lt</span>   </li>
      <li><a href="#lte"          >lessThanOrEqualTo       </a><span>lte</span>  </li>
      <li><a href="#log"          >logarithm               </a><span>log</span>  </li>
      <li><a href="#sub"          >minus                   </a><span>sub</span>  </li>
      <li><a href="#mod"          >modulo                  </a><span>mod</span>  </li>
      <li><a href="#exp"          >naturalExponential      </a><span>exp</span>  </li>
      <li><a href="#ln"           >naturalLogarithm        </a><span>ln</span>   </li>
      <li><a href="#neg"          >negated                 </a><span>neg</span>  </li>
      <li><a href="#add"          >plus                    </a><span>add</span>  </li>
      <li><a href="#sd"           >precision               </a><span>sd</span>   </li>
      <li><a href="#sqrt"         >squareRoot              </a><span>sqrt</span> </li>
      <li><a href="#mul"          >times                   </a><span>mul</span>  </li>
      <li><a href="#todp"         >toDecimalPlaces         </a><span>todp</span> </li>
      <li><a href="#toExponential">toExponential           </a>                  </li>
      <li><a href="#toFixed"      >toFixed                 </a>                  </li>
      <li><a href="#toInteger"    >toInteger               </a><span>toint</span></li>
      <li><a href="#toJSON"       >toJSON                  </a>                  </li>
      <li><a href="#toNumber"     >toNumber                </a>                  </li>
      <li><a href="#pow"          >toPower                 </a><span>pow</span>  </li>
      <li><a href="#toPrecision"  >toPrecision             </a>                  </li>
      <li><a href="#tosd"         >toSignificantDigits     </a><span>tosd</span> </li>
      <li><a href="#toString"     >toString                </a>                  </li>
      <li><a href="#valueOf"      >valueOf                 </a><span>val</span>  </li>
    </ul>

    <a href="#instance-properties">Properties</a>
    <ul>
      <li><a href="#digits"  >d</a><span>digits</span></li>
      <li><a href="#exponent">e</a><span>exponent</span></li>
      <li><a href="#sign"    >s</a><span>sign</span></li>
    </ul>

    <a href="#Errors">Errors</a>
    <a class='end' href="#faq">FAQ</a>

  </div>

  <div class="container">

    <h1>decimal<span id='js'>.js</span>-light</h1>

    <p>
      The light version of <a href='https://github.com/MikeMcl/decimal.js/'>decimal.js</a>, an
      arbitrary-precision Decimal type for JavaScript.
    </p>
    <p><a href='https://github.com/MikeMcl/decimal.js-light'>Hosted on GitHub</a>.</p>

    <h2>API</h2>

    <p>
      See the <a href='https://github.com/MikeMcl/decimal.js'>README</a> on GitHub for a quick-start
      introduction.
    </p>
    <p>
      In all examples below, <code>var</code> and semicolons are not shown, and if a commented-out
      value is in quotes it means <code>toString</code> has been called on the preceding expression.
    </p><br />
    <p>
      When the library is loaded, it defines a single function object,
      <a href='#decimal'><code>Decimal</code></a>, the constructor of Decimal instances.
    </p>
    <p>
      <i>
        If necessary, multiple Decimal constructors can be created, each with their own independent
        configuration, e.g. precision and range, which applies to all Decimal instances created from
        it.
      </i>
    </p>
    <p>
      <i>
        A new Decimal constructor is created by calling the <code><a href='#Dclone'>clone</a></code>
        method of an already existing Decimal constructor.
      </i>
    </p>



    <h3 class='end'>CONSTRUCTOR</h3>

    <h5 id="decimal">
      Decimal<code class='inset'>Decimal(value) <i>&rArr; Decimal</i></code>
    </h5>
    <dl>
      <dt><code>value</code>: <i>number|string|Decimal</i></dt>
      <dd>
        Integer or float.
      </dd>
      <dd>
        The number of digits is not limited, except by JavaScript's maximum array size and, in
        practice, the processing time required.
      </dd>
      <dd>
        The maximum permissible exponent magnitude is approximately <code>9007199254740991</code>.
      </dd>
      <dd>
        String values may be in exponential (floating-point), as well as normal (fixed-point)
        notation.
      </dd>
      <dd>
        In exponential notation, <code>e</code> or <code>E</code> defines a power-of-ten exponent.
      </dd>
    </dl>
    <p>Returns a new Decimal object instance.</p>
    <p>Throws on an invalid <code>value</code>.</p>
    <pre>
x = new Decimal(9)                       // '9'
y = new Decimal(x)                       // '9'

new Decimal('5032485723458348569331745.33434346346912144534543')
new Decimal('4.321e+4')                  // '43210'
new Decimal('-735.0918e-430')            // '-7.350918e-428'
new Decimal('5.6700000')                 // '5.67'
new Decimal('.5')                        // '0.5'

new Decimal(0.046875)                    // '0.046875'
new Decimal('0.046875000000')            // '0.046875'

new Decimal(4.6875e-2)                   // '0.046875'
new Decimal('468.75e-4')                 // '0.046875'</pre>



    <h4 id="methods">Methods</h4>
    <p>The methods of a Decimal constructor.</p>



    <h5 id="Dclone">
      clone
      <code class='inset'>.clone([object]) <i>&rArr; Decimal constructor</i></code>
    </h5>
    <p><code>object</code>: <i>object</i></p>
    <p>
      Returns a new independent Decimal constructor with configuration settings as described by
      <code>object</code> (see <a href='#Dconfig'><code>config</code></a>), or with the same
      settings as <code>this</code> Decimal constructor if <code>object</code> is omitted.
    </p>
    <pre>Decimal.config({ precision: 5 })
D9 = Decimal.clone({ precision: 9 })

a = new Decimal(1)
b = new D9(1)

a.div(3)                           // 0.33333
b.div(3)                           // 0.333333333

// D9 = Decimal.clone({ precision: 9 }) is equivalent to:
D9 = Decimal.clone()
D9.config({ precision: 9 })</pre>
    <p>
      It is not inefficient in terms of memory usage to use multiple Decimal constructors as
      functions are shared between them.
    </p>



    <h5 id="Dconfig">
      config<code class='inset'>.set(object) <i>&rArr; Decimal constructor</i></code>
    </h5>
    <p><code>object</code>: <i>object</i></p>
    <p>
      Configures the 'global' settings for <code>this</code> particular Decimal constructor, i.e.
      the settings which apply to operations performed on the Decimal instances created by it.
    </p>
    <p>Returns <code>this</code> Decimal constructor.</p>
    <p>
      The configuration object, <code>object</code>, can contain some or all of the properties
      described in detail at <a href="#constructor-properties">Properties</a> and shown in the
      example below.
    </p>
    <p>
      The values of the configuration object properties are checked for validity and then stored as
      equivalently-named properties of <code>this</code> Decimal constructor.
    </p>
    <p>Throws on an invalid <code>object</code> or configuration property value.</p>
    <pre>
// Defaults
Decimal.config({
    precision: 20,
    rounding: 4,
    toExpNeg: -7,
    toExpPos: 21,
    LN10: new Decimal('2.30258509299404568401799145468436...')
})

Decimal.set({ rounding: Decimal.ROUND_CEIL })
</pre>
    <p>
      The properties of a Decimal constructor can also be set by direct assignment, but that will
      by-pass the validity checking that this method performs - which is not a problem if the user
      knows that the checks are unnecessary.
    </p>



    <h4 id="constructor-properties">Properties</h4>
    <p>The properties of a Decimal constructor.</p>



    <h6 id='configProps'>Configuration properties</h6>
    <p>
      The values of the configuration properties <a href='#precision'><code>precision</code></a>,
      <a href='#rounding'><code>rounding</code></a>, <a href='#toExpNeg'><code>toExpNeg</code></a>
      and <a href='#toExpPos'><code>toExpPos</code></a> are set using the
      <a href='#Dconfig'><code>config</code></a> method.
    </p>
    <p>
      As simple object properties they can be set directly without using
      <a href='#Dconfig'><code>config</code></a>, and it is fine to do so, but the values assigned
      will not then be checked for validity. For example:
    </p>
    <pre>Decimal.config({ precision: 0 })
// '[DecimalError] Invalid argument: precision: 0'

Decimal.precision = 0
// No error is thrown and the results of calculations are unreliable</pre>



    <h5 id="precision">precision</h5>
    <p>
      <i>number</i>: integer, <code>1</code> to <code>1e+9</code> inclusive<br />
      Default value: <code>20</code>
    </p>
    <p>The <i>maximum</i> number of significant digits of the result of an operation.</p>
    <p>
      All functions which return a Decimal will return the value to <code>precision</code>
      significant digits except <a href='#decimal'><code>Decimal</code></a>,
      <a href='#abs'><code>absoluteValue</code></a>,
      <a href='#neg'><code>negated</code></a>, <a href='#round'><code>toInteger</code></a>, and
      <a href='#todp'><code>toDecimalPlaces</code></a>.
    </p>
    <pre>Decimal.config({ precision: 5 })
Decimal.precision                  // 5</pre>



    <h5 id="rounding">rounding</h5>
    <p>
      <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive<br />
      Default value: <code>4</code> <a href="#modes">(<code>ROUND_HALF_UP</code>)</a>
    </p>
    <p>
      The default rounding mode used by <a href='#round'><code>toInteger</code></a>,
      <a href='#todp'><code>toDecimalPlaces</code></a>,
      <a href='#toExponential'><code>toExponential</code></a>,
      <a href='#toFixed'><code>toFixed</code></a>,
      <a href='#toPrecision'><code>toPrecision</code></a> and
      <a href='#tosd'><code>toSignificantDigits</code></a>.
    </p>
    <p>
      The <a href='#modes'>rounding modes</a> are available as enumerated properties of the
      constructor.
    </p>
    <pre>Decimal.config({ rounding: Decimal.ROUND_UP })
Decimal.config({ rounding: 0 })    // equivalent
Decimal.rounding                   // 0</pre>



    <h5 id="toExpNeg">toExpNeg</h5>
    <p>
      <i>number</i>: integer, <code>-9e15</code> to <code>0</code> inclusive<br />
      Default value: <code>-7</code>
    </p>
    <p>
      The negative exponent value at and below which <a href='#toString'><code>toString</code></a>
      returns exponential notation.
    </p>
    <pre>Decimal.config({ toExpNeg: -7 })
Decimal.toExpNeg                   // -7
new Decimal(0.00000123)            // '0.00000123'       e is -6
new Decimal(0.000000123)           // '1.23e-7'

// Always return exponential notation:
Decimal.config({ toExpNeg: 0 })</pre>
    <p>
      JavaScript numbers use exponential notation for negative exponents of <code>-7</code> and
      below.
    </p>
    <p>
      Regardless of the value of <code>toExpNeg</code>, the
      <a href='#toFixed'><code>toFixed</code></a> method will always return a value in normal
      notation and the <a href='#toExponential'><code>toExponential</code></a> method will always
      return a value in exponential form.
    </p>



    <h5 id="toExpPos">toExpPos</h5>
    <p>
      <i>number</i>: integer, <code>0</code> to <code>9e15</code> inclusive<br />
      Default value: <code>20</code>
    </p>
    <p>
      The positive exponent value at and above which <a href='#toString'><code>toString</code></a>
      returns exponential notation.
    </p>
    <pre>Decimal.config({ toExpPos: 2 })
Decimal.toExpPos                   // 2
new Decimal(12.3)                  // '12.3'        e is 1
new Decimal(123)                   // '1.23e+2'

// Always return exponential notation:
Decimal.config({ toExpPos: 0 })</pre>
    <p>
      JavaScript numbers use exponential notation for positive exponents of <code>20</code> and
      above.
    </p>
    <p>
      Regardless of the value of <code>toExpPos</code>, the
      <a href='#toFixed'><code>toFixed</code></a> method will always return a value in normal
      notation and the <a href='#toExponential'><code>toExponential</code></a> method will always
      return a value in exponential form.
    </p>



    <h5 id="ln10">LN10</h5>
    <p>
      <i>string|Decimal</i>: the natural logarithm of <code>10</code><br />
      The default value has <code>115</code> digits
    </p>
    <p>
      The maximum precision of the <a href='#exp'><code>naturalExponential</code></a>,
      <a href='#ln'><code>naturalLogarithm</code></a>, <a href='#log'><code>logarithm</code></a>,
      and <a href='#pow'><code>toPower</code></a> methods is determined by the precision of the
      value of <code>LN10</code>.
    </p>
    <p>
      The default value of <code>LN10</code> enables a maximum precision of about <code>100</code>
      digits. To increase this, assign a new value to <code>LN10</code> using a string or Decimal
      value with about 15 digits more than the maximum precision required.
    </p>
    <p>
      An error will be thrown if the <code>LN10</code> value does not have sufficient precision to
      enable an operation to be performed.
    </p>
    <pre>
Decimal.config({ LN10: '2.3025850929940456840179914546843642076011014886287729760333279009' })

Decimal.LN10.toFixed(5)             // ''2.30259'</pre>



    <h6 id="modes">Rounding modes</h6>
    <p>
      The library's enumerated rounding modes are stored as properties of the Decimal constructor.
      <br />They are not referenced internally by the library itself.
    </p>
    <p>Rounding modes 0 to 6 (inclusive) are the same as those of Java's BigDecimal class.</p>
    <table>
      <tr><th>Property</th><th>Value</th><th>Description</th></tr>
      <tr><td><b>ROUND_UP</b></td><td class='centre'>0</td><td>Rounds away from zero</td></tr>
      <tr><td><b>ROUND_DOWN</b></td><td class='centre'>1</td><td>Rounds towards zero</td></tr>
      <tr><td><b>ROUND_CEIL</b></td><td class='centre'>2</td><td>Rounds towards Infinity</td></tr>
      <tr><td><b>ROUND_FLOOR</b></td><td class='centre'>3</td><td>Rounds towards -Infinity</td></tr>
      <tr>
        <td><b>ROUND_HALF_UP</b></td><td class='centre'>4</td>
        <td>Rounds towards nearest neighbour.<br />If equidistant, rounds away from zero</td>
      </tr>
      <tr>
        <td><b>ROUND_HALF_DOWN</b></td><td class='centre'>5</td>
        <td>Rounds towards nearest neighbour.<br />If equidistant, rounds towards zero</td>
      </tr>
      <tr>
        <td><b>ROUND_HALF_EVEN</b></td><td class='centre'>6</td>
        <td>
          Rounds towards nearest neighbour.<br />If equidistant, rounds towards even neighbour
        </td>
      </tr>
      <tr>
        <td><b>ROUND_HALF_CEIL</b></td><td class='centre'>7</td>
        <td>Rounds towards nearest neighbour.<br />If equidistant, rounds towards Infinity</td>
      </tr>
      <tr>
        <td><b>ROUND_HALF_FLOOR</b></td><td class='centre'>8</td>
        <td>Rounds towards nearest neighbour.<br />If equidistant, rounds towards -Infinity</td>
      </tr>
    </table>
    <pre>Decimal.config({ rounding: Decimal.ROUND_CEIL })
Decimal.config({ rounding: 2 })    // equivalent
Decimal.rounding                   // 2</pre>




    <h3>INSTANCE</h3>

    <h4 id="prototype-methods">Methods</h4>
    <p>The methods inherited by a Decimal instance from its constructor's prototype object.</p>
    <p>A Decimal instance is immutable in the sense that it is not changed by its methods.</p>
    <p>Methods that return a Decimal can be chained:</p>
    <pre>x = new Decimal(2).times('999.999999999999999').dividedBy(4).toFixed(2)</pre>
    <p>Methods do not round their arguments before execution.</p>
    <p>
      Many method names have a shorter alias. (Internally, the library always uses the shorter
      method names.)
    </p>



    <h5 id="abs">absoluteValue<code class='inset'>.abs() <i>&rArr; Decimal</i></code></h5>
    <p>
      Returns a new Decimal whose value is the absolute value, i.e. the magnitude, of the value of
      this Decimal.
    </p>
    <p>
      The return value is not affected by the value of the
      <a href='#precision'><code>precision</code></a> setting.
    </p>
    <pre>
x = new Decimal(-0.8)
y = x.absoluteValue()         // '0.8'
z = y.abs()                   // '0.8'</pre>



    <h5 id="cmp">comparedTo<code class='inset'>.cmp(x) <i>&rArr; number</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <table>
      <tr><th>Returns</th><th>&nbsp;</th></tr>
      <tr>
        <td class='centre'><code>1</code></td>
        <td>if the value of this Decimal is greater than the value of <code>x</code></td>
      </tr>
      <tr>
        <td class='centre'><code>-1</code></td>
        <td>if the value of this Decimal is less than the value of <code>x</code></td>
      </tr>
      <tr>
        <td class='centre'><code>0</code></td>
        <td>if this Decimal and <code>x</code> have the same value</td>
      </tr>
    </table>
    <pre>
x = new Decimal(4)
y = new Decimal(5)
x.comparedTo(y)                // -1
x.comparedTo(x.plus(1))        // 0</pre>



    <h5 id="dp">decimalPlaces<code class='inset'>.dp() <i>&rArr; number</i></code></h5>
    <p>
      Returns the number of decimal places, i.e. the number of digits after the decimal point, of
      the value of this Decimal.
    </p>
    <pre>
x = new Decimal(1.234)
x.decimalPlaces()              // '3'
y = new Decimal(987.654321)
y.dp()                         // '6'</pre>



    <h5 id="div">dividedBy<code class='inset'>.div(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns a new Decimal whose value is the value of this Decimal divided by <code>x</code>,
      truncated to <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <pre>
x = new Decimal(355)
y = new Decimal(113)
x.dividedBy(y)             // '3.14159292035398230088'
x.div(5)                   // '71'</pre>



    <h5 id="idiv">
      dividedToIntegerBy<code class='inset'>.idiv(x) <i>&rArr; Decimal</i></code>
    </h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Return a new Decimal whose value is the integer part of dividing this Decimal by
      <code>x</code>, truncated to <code><a href='#precision'>precision</a></code> significant
      digits.
    </p>
    <pre>
x = new Decimal(5)
y = new Decimal(3)
x.dividedToIntegerBy(y)     // '1'
x.idiv(0.7)             // '7'</pre>



    <h5 id="eq">equals<code class='inset'>.eq(x) <i>&rArr; boolean</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns <code>true</code> if the value of this Decimal equals the value of <code>x</code>,
      otherwise returns <code>false</code>.
    </p>
    <p>Note: This method uses the <code>cmp</code> method internally.</p>
    <pre>
0 === 1e-324                     // true
x = new Decimal(0)
x.equals('1e-324')               // false</pre>



    <h5 id="exp">exponent<code class='inset'>.exponent() <i>&rArr; number</i></code></h5>
    <p>Returns the exponent value of this Decimal.</p>
    <pre>
x = new Decimal(1234.567)
x.exponent()                     // 3</pre>



    <h5 id="gt">greaterThan<code class='inset'>.gt(x) <i>&rArr; boolean</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns <code>true</code> if the value of this Decimal is greater than the value of
      <code>x</code>, otherwise returns <code>false</code>.
    </p>
    <p>Note: This method uses the <code>cmp</code> method internally.</p>
    <pre>
0.1 &gt; (0.3 - 0.2)                            // true
x = new Decimal(0.1)
x.greaterThan(Decimal(0.3).minus(0.2))       // false
new Decimal(0).gt(x)                         // false</pre>



    <h5 id="gte">
      greaterThanOrEqualTo<code class='inset'>.gte(x) <i>&rArr; boolean</i></code>
    </h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns <code>true</code> if the value of this Decimal is greater than or equal to the value
      of <code>x</code>, otherwise returns <code>false</code>.
    </p>
    <p>Note: This method uses the <code>cmp</code> method internally.</p>
    <pre>
(0.3 - 0.2) &gt;= 0.1                       // false
x = new Decimal(0.3).minus(0.2)
x.greaterThanOrEqualTo(0.1)              // true
new Decimal(1).gte(x)                    // true</pre>



    <h5 id="isint">isInteger<code class='inset'>.isint() <i>&rArr; boolean</i></code></h5>
    <p>
      Returns <code>true</code> if the value of this Decimal is a whole number, otherwise returns
      <code>false</code>.
    </p>
    <pre>
x = new Decimal(1)
x.isInteger()                            // true
y = new Decimal(123.456)
y.isint()                                // false</pre>



    <h5 id="isneg">isNegative<code class='inset'>.isneg() <i>&rArr; boolean</i></code></h5>
    <p>
      Returns <code>true</code> if the value of this Decimal is negative, otherwise returns
      <code>false</code>.
    </p>
    <pre>
x = new Decimal(0)
x.isNegative()                           // false
y = new Decimal(2)
y.isneg                                  // false</pre>
    <p>Note: <code>n &lt; 0</code> can be used if <code>n &lt;= -Number.MIN_VALUE</code>.</p>



     <h5 id="ispos">isPositive<code class='inset'>.ispos() <i>&rArr; boolean</i></code></h5>
    <p>
      Returns <code>true</code> if the value of this Decimal is positive, otherwise returns
      <code>false</code>.
    </p>
    <pre>
x = new Decimal(0)
x.isPositive()                           // false
y = new Decimal(-2)
y.ispos                                  // false</pre>
    <p>Note: <code>n &lt; 0</code> can be used if <code>n &lt;= -Number.MIN_VALUE</code>.</p>



    <h5 id="isZero">isZero<code class='inset'>.isZero() <i>&rArr; boolean</i></code></h5>
    <p>
      Returns <code>true</code> if the value of this Decimal is zero or minus zero, otherwise
      returns <code>false</code>.
    </p>
    <pre>
x = new Decimal(0)
x.isZero()                               // true</pre>
    <p>Note: <code>n == 0</code> can be used if <code>n &gt;= Number.MIN_VALUE</code>.</p>



    <h5 id="lt">lessThan<code class='inset'>.lt(x) <i>&rArr; boolean</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns <code>true</code> if the value of this Decimal is less than the value of
      <code>x</code>, otherwise returns <code>false</code>.
    </p>
    <p>Note: This method uses the <code>cmp</code> method internally.</p>
    <pre>
(0.3 - 0.2) &lt; 0.1                        // true
x = new Decimal(0.3).minus(0.2)
x.lessThan(0.1)                          // false
new Decimal(0).lt(x)                     // true</pre>



    <h5 id="lte">lessThanOrEqualTo<code class='inset'>.lte(x) <i>&rArr; boolean</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns <code>true</code> if the value of this Decimal is less than or equal to the value of
      <code>x</code>, otherwise returns <code>false</code>.
    </p>
    <p>Note: This method uses the <code>cmp</code> method internally.</p>
    <pre>
0.1 &lt;= (0.3 - 0.2)                              // false
x = new Decimal(0.1)
x.lessThanOrEqualTo(Decimal(0.3).minus(0.2))    // true
new Decimal(-1).lte(x)                          // true</pre>



    <h5 id="log">logarithm<code class='inset'>.log(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns a new Decimal whose value is the base <code>x</code> logarithm of the value of this
      Decimal, truncated to <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <p>
      If <code>x</code> is omitted, the base 10 logarithm of the value of this Decimal will be
      returned.
    </p>
    <pre>
x = new Decimal(1000)
x.logarithm()                            // '3'
y = new Decimal(256)
y.log(2)                                 // '8'</pre>
    <p>The maximum error will be <code>1</code> <i>ulp</i> (unit in the last place).</p>
    <p>Logarithms to base <code>2</code> or <code>10</code> will always be correct.</p>
    <p>The performance of this method degrades exponentially with increasing digits.</p>



    <h5 id="sub">minus<code class='inset'>.minus(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns a new Decimal whose value is the value of this Decimal minus <code>x</code>, truncated
      to <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <pre>
0.3 - 0.1                                // 0.19999999999999998
x = new Decimal(0.3)
x.minus(0.1)                             // '0.2'</pre>



    <h5 id="mod">modulo<code class='inset'>.mod(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns a new Decimal whose value is the value of this Decimal modulo <code>x</code>,
      truncated to <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <pre>
1 % 0.9                                  // 0.09999999999999998
x = new Decimal(1)
y = x.modulo(0.9)                            // '0.1'</pre>



    <h5 id="exp">naturalExponential<code class='inset'>.exp() <i>&rArr; Decimal</i></code></h5>
    <p>
      Returns a new Decimal whose value is the base <code>e</code> (Euler's number, the base of the
      natural logarithm) exponential of the value of this Decimal, truncated to
      <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <p>
      The <code><a href='#ln'>naturalLogarithm</a></code> function is the inverse of this function.
    </p>
    <pre>
x = new Decimal(1)
x.naturalExponential()                   // '2.7182818284590452354'
y = new Decimal(2)
y.exp()                                  // '7.3890560989306502272'</pre>
    <p>The maximum error will be <code>1</code> <i>ulp</i> (unit in the last place).</p>
    <p>The performance of this method degrades exponentially with increasing digits.</p>



    <h5 id="ln">naturalLogarithm<code class='inset'>.ln() <i>&rArr; Decimal</i></code></h5>
    <p>
      Returns a new Decimal whose value is the natural logarithm of the value of this Decimal,
      truncated to <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <p>
      The natural logarithm is the inverse of the <code><a href='#exp'>naturalExponential</a></code>
      function.
    </p>
    <pre>
x = new Decimal(10)
x.naturalLogarithm()                     // '2.3026'
y = new Decimal('1.23e+30')
y.ln()                                   // '69.28'</pre>
    <p>
      The mathematical result of the natural logarithm function is non-terminating, unless its
      argument is <code>1</code>.
    </p>
    <p>
      The time-taken by this method increases exponentially with increasing digits.
    </p>
    <p>
      See <a href='#ln10'>LN10</a> to configure the maximum precision available.
    </p>



    <h5 id="neg">negated<code class='inset'>.neg() <i>&rArr; Decimal</i></code></h5>
    <p>
      Returns a new Decimal whose value is the value of this Decimal negated, i.e. multiplied by
      <code>-1</code>.
    </p>
    <p>
      The return value is not affected by the value of the
      <a href='#precision'><code>precision</code></a> setting.
    </p>
    <pre>
x = new Decimal(1.8)
x.negated()                              // '-1.8'
y = new Decimal(-1.3)
y.neg()                                  // '1.3'</pre>



    <h5 id="add">plus<code class='inset'>.plus(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns a new Decimal whose value is the value of this Decimal plus <code>x</code>, truncated
      to <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <pre>
0.1 + 0.2                                // 0.30000000000000004
x = new Decimal(0.1)
y = x.plus(0.2)                          // '0.3'
new Decimal(0.7).plus(x).plus(y)         // '1.1'</pre>



    <h5 id="sd">precision<code class='inset'>.sd([include_zeros]) <i>&rArr; number</i></code></h5>
    <p>Returns the number of significant digits of the value of this Decimal.</p>
    <p>
      If <code>include_zeros</code> is <code>true</code> or <code>1</code> then any trailing zeros
      of the integer part of a number are counted as significant digits, otherwise they are not.
    </p>
    <pre>
x = new Decimal(1.234)
x.precision()                            // '4'
y = new Decimal(987000)
y.sd()                                   // '3'
y.sd(true)                               // '6'</pre>



    <h5 id="sqrt">squareRoot<code class='inset'>.sqrt() <i>&rArr; Decimal</i></code></h5>
    <p>
      Returns a new Decimal whose value is the square root of this Decimal, truncated to
      <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <p>
      This method is much faster than using the <a href='#pow'><code>toPower</code></a> method with
      an exponent of <code>0.5</code>.
    </p>
    <pre>
x = new Decimal(16)
x.squareRoot()                           // '4'
y = new Decimal(3)
y.sqrt()                                 // '1.73205080756887729353'
y.sqrt().eq( y.pow(0.5) )                // true</pre>



    <h5 id="mul">times<code class='inset'>.times(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>
      Returns a new Decimal whose value is the value of this Decimal times <code>x</code>,
      truncated to <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <pre>
0.6 * 3                                  // 1.7999999999999998
x = new Decimal(0.6)
y = x.times(3)                           // '1.8'
new Decimal('7e+500').times(y)           // '1.26e+501'</pre>



    <h5 id="todp">
      toDecimalPlaces<code class='inset'>.todp([dp [, rm]]) <i>&rArr; Decimal</i></code>
    </h5>
    <p>
      <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive.
    </p>
    <p>
      Returns a new Decimal whose value is the value of this Decimal rounded to a maximum of
      <code>dp</code> decimal places using rounding mode <code>rm</code>.
    </p>
    <p>
      If <code>dp</code> is omitted, the return value will have the same value as this Decimal.
    </p>
    <p>
      If <code>rm</code> is omitted, rounding mode <a href='#rounding'><code>rounding</code></a>
      is used.
    </p>
    <p>Throws on an invalid <code>dp</code> or <code>rm</code> value.</p>
    <pre>
x = new Decimal(12.24567)
x.toDecimalPlaces(0)                // '12'
x.toDecimalPlaces(1, 0)             // '12.3'

y = new Decimal(9876.54321)
y.todp(3)                           // '9876.543'
y.todp(1, 0)                        // '9876.6'
y.todp(1, Decimal.ROUND_DOWN)       // '9876.5'</pre>



    <h5 id="toExponential">
      toExponential<code class='inset'>.toExponential([dp [, rm]]) <i>&rArr; string</i></code>
    </h5>
    <p>
      <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    </p>
    <p>
      Returns a string representing the value of this Decimal in exponential notation rounded
      using rounding mode <code>rm</code> to <code>dp</code> decimal places, i.e with one digit
      before the decimal point and <code>dp</code> digits after it.
    </p>
    <p>
      If the value of this Decimal in exponential notation has fewer than <code>dp</code> fraction
      digits, the return value will be appended with zeros accordingly.
    </p>
    <p>
      If <code>dp</code> is omitted, the number of digits after the decimal point defaults to the
      minimum number of digits necessary to represent the value exactly.
    </p>
    <p>
      If <code>rm</code> is omitted, rounding mode <a href='#rounding'><code>rounding</code></a> is
      used.
    </p>
    <p>Throws on an invalid <code>dp</code> or <code>rm</code> value.</p>
    <pre>
x = 45.6
b = new Decimal(x)
x.toExponential()              // '4.56e+1'
y.toExponential()              // '4.56e+1'
x.toExponential(0)             // '5e+1'
y.toExponential(0)             // '5e+1'
x.toExponential(1)             // '4.6e+1'
y.toExponential(1)             // '4.6e+1'
y.toExponential(1, 1)          // '4.5e+1'  (ROUND_DOWN)
x.toExponential(3)             // '4.560e+1'
y.toExponential(3)             // '4.560e+1'</pre>



    <h5 id="toFixed">
      toFixed<code class='inset'>.toFixed([dp [, rm]]) <i>&rArr; string</i></code>
    </h5>
    <p>
      <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    </p>
    <p>
      Returns a string representing the value of this Decimal in normal (fixed-point) notation
      rounded to <code>dp</code> decimal places using rounding mode <code>rm</code>.
    </p>
    <p>
      If the value of this Decimal in normal notation has fewer than <code>dp</code> fraction
      digits, the return value will be appended with zeros accordingly.
    </p>
    <p>
      Unlike <code>Number.prototype.toFixed</code>, which returns exponential notation if a number
      is greater or equal to <code>10<sup>21</sup></code>, this method will always return normal
      notation.
    </p>
    <p>
      If <code>dp</code> is omitted, the return value will be unrounded and in normal notation. This
      is unlike <code>Number.prototype.toFixed</code>, which returns the value to zero decimal
      places, but is useful when because of the current
      <a href="#toExpNeg"><code>toExpNeg</code></a> or
      <a href="#toExpPos"><code>toExpNeg</code></a> values,
      <code><a href='#toString'>toString</a></code> returns exponential notation.
    </p>
    <p>
      If <code>rm</code> is omitted, rounding mode <a href='#rounding'><code>rounding</code></a> is
      used.
    </p>
    <p>Throws on an invalid <code>dp</code> or <code>rm</code> value.</p>
    <pre>
x = 3.456
b = new Decimal(x)
x.toFixed()              // '3'
y.toFixed()              // '3.456'
y.toFixed(0)             // '3'
x.toFixed(2)             // '3.46'
y.toFixed(2)             // '3.46'
y.toFixed(2, 1)          // '3.45'  (ROUND_DOWN)
x.toFixed(5)             // '3.45600'
y.toFixed(5)             // '3.45600'</pre>



    <h5 id="toInteger">toInteger<code class='inset'>.toint() <i>&rArr; Decimal</i></code></h5>
    <p>
      Returns a new Decimal whose value is the value of this Decimal rounded to a whole number using
      rounding mode <a href='#rounding'><code>rounding</code></a>.
    </p>
    <p>
      To emulate <code>Math.round</code>, set <a href='#rounding'><code>rounding</code></a> to
      <code>7</code>, i.e. <a href='#modes'><code>ROUND_HALF_CEIL</code></a>.
    </p>
    <pre>
Decimal.config({ rounding: 4 })
x = 1234.5
x.toInteger()                            // '1235'

Decimal.rounding = Decimal.ROUND_DOWN
x.toint()                                // '1234'
x                                        // '1234.5'</pre>



<h5 id="toJSON">toJSON<code class='inset'>.toJSON() <i>&rArr; string</i></code></h5>
    <p>As <a href='#toString'><code>toString</code></a>.</p>



    <h5 id="toNumber">toNumber<code class='inset'>.toNumber() <i>&rArr; number</i></code></h5>
    <p>Returns the value of this Decimal converted to a primitive number.</p>
    <p>
      Type coercion with, for example, JavaScript's unary plus operator will also work, except that
      a Decimal with the value minus zero will convert to positive zero.
    </p>
    <pre>
x = new Decimal(456.789)
x.toNumber()                   // 456.789
+x                             // 456.789

y = new Decimal('45987349857634085409857349856430985')
y.toNumber()                   // 4.598734985763409e+34</pre>



    <h5 id="pow">toPower<code class='inset'>.pow(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i>: integer or non-integer</p>
    <p>
      Returns a new Decimal whose value is the value of this Decimal raised to the power
      <code>x</code>, truncated to <a href='#precision'><code>precision</code></a> significant
      digits.
    </p>
    <p>
      The performance of this method degrades exponentially with increasing digits.<br />
      For non-integer exponents in particular, the performance of this method may not be adequate.
    </p>
    <p>The maximum error will be <code>1</code> <i>ulp</i> (unit in the last place). </p>
    <pre>
Math.pow(0.7, 2)               // 0.48999999999999994
x = new Decimal(0.7)
x.toPower(2)                   // '0.49'
new Decimal(3).pow(-2)         // '0.11111111111111111111'

new Decimal(1217652.23).pow('98765.489305603941')
// '4.8227010515242461181e+601039'</pre>




    <h5 id="toPrecision">
      toPrecision<code class='inset'>.toPrecision([sd [, rm]]) <i>&rArr; string</i></code>
    </h5>
    <p>
      <code>sd</code>: <i>number</i>: integer, <code>1</code> to <code>1e+9</code> inclusive<br />
      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    </p>
    <p>
      Returns a string representing the value of this Decimal rounded to <code>sd</code> significant
      digits using rounding mode <code>rm</code>.
    </p>
    <p>
      If <code>sd</code> is less than the number of digits necessary to represent the integer part
      of the value in normal (fixed-point) notation, then exponential notation is used.
    </p>
    <p>
      If <code>sd</code> is omitted, the return value is the same as
      <code><a href='#toString'>toString</a></code>.
    </p>
    <p>
      If <code>rm</code> is omitted, rounding mode <a href='#rounding'><code>rounding</code></a> is
      used.
    </p>
    <p>Throws on an invalid <code>sd</code> or <code>rm</code> value.</p>
    <pre>
x = 45.6
b = new Decimal(x)
x.toPrecision()                          // '45.6'
y.toPrecision()                          // '45.6'
x.toPrecision(1)                         // '5e+1'
y.toPrecision(1)                         // '5e+1'
y.toPrecision(2, 0)                      // '4.6e+1'  (ROUND_UP)
y.toPrecision(2, 1)                      // '4.5e+1'  (ROUND_DOWN)
x.toPrecision(5)                         // '45.600'
y.toPrecision(5)                         // '45.600'</pre>



    <h5 id="tosd">
      toSignificantDigits<code class='inset'>.tosd([sd [, rm]]) <i>&rArr; Decimal</i></code>
    </h5>
    <p>
      <code>sd</code>: <i>number</i>: integer, <code>1</code> to <code>1e+9</code> inclusive.<br />
      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive.
    </p>
    <p>
      Returns a new Decimal whose value is the value of this Decimal rounded to a maximum of
      <code>sd</code> significant digits using rounding mode <code>rm</code>.
    </p>
    <p>
      If <code>sd</code> is omitted, the return value will be rounded to
      <a href='#precision'><code>precision</code></a> significant digits.
    </p>
    <p>
      If <code>rm</code> is omitted, rounding mode <a href='#rounding'><code>rounding</code></a>
      will be used.
    </p>
    <p>Throws on an invalid <code>sd</code> or <code>rm</code> value.</p>
    <pre>
Decimal.config({ precision: 5, rounding: 4 })
x = new Decimal(9876.54321)

x.toSignificantDigits()                          // '9876.5'
x.toSignificantDigits(6)                         // '9876.54'
x.toSignificantDigits(6, Decimal.ROUND_UP)       // '9876.55'
x.tosd(2)                                        // '9900'
x.tosd(2, 1)                                     // '9800'
x                                                // '9876.54321'</pre>



    <h5 id="toString">toString<code class='inset'>.toString() <i>&rArr; string</i></code></h5>
    <p>Returns a string representing the value of this Decimal.</p>
    <p>
      If this Decimal has a positive exponent that is equal to or greater than
      <a href="#toExpPos"><code>toExpPos</code></a>, or a negative exponent equal to or less than
      <a href="#toExpPos"><code>toExpNeg</code></a>, then exponential notation will be returned.
    </p>
    <pre>
x = new Decimal(750000)
x.toString()                             // '750000'
Decimal.config({ toExpPos: 5 })
x.toString()                             // '7.5e+5'

Decimal.config({ precision: 4 });
y = new Decimal('1.23456789')
y.toString()                             // '1.23456789'</pre>



    <h5 id="valueOf">valueOf<code class='inset'>.val() <i>&rArr; string</i></code></h5>
    <p>As <a href='#toString'><code>toString</code></a>.</p>





    <h4 id="instance-properties">Properties</h4>
    <p>
      The value of a Decimal is stored in a normalised base <code>10000000</code> floating point
      format.
    </p>
    <p>
      A Decimal instance is an object with three properties:
    </p>
    <table>
      <tr>
        <th>Property</th>
        <th>Description</th>
        <th>Type</th>
        <th>Value</th>
      </tr>
      <tr>
        <td class='centre' id='digits'><b>d</b></td>
        <td>digits</td>
        <td><i>number</i><code style='color:#000'>[]</code></td>
        <td> Array of integers, each <code>0</code> - <code>1e7</code></td>
      </tr>
      <tr>
        <td class='centre' id='exponent'><b>e</b></td>
        <td>exponent*</td>
        <td><i>number</i></td>
        <td>Integer, <code>-1286742750677284</code> to <code>1286742750677284</code> inclusive</td>
      </tr>
      <tr>
        <td class='centre' id='sign'><b>s</b></td>
        <td>sign</td>
        <td><i>number</i></td>
        <td><code>-1</code>, <code>0</code>, or <code>1</code></td>
      </tr>
    </table>
     <p>
      *This is the exponent in base <code>10000000</code>. To get the base 10 exponent, use the
      <a href='#exp'><code>exponent</code></a> method.
    </p>
    <p>The properties are best considered to be read-only.</p>
    <p>
      As with JavaScript numbers, the original exponent and fractional trailing zeros of a number
      are not preserved.
    </p>
    <pre>
x = new Decimal(0.123)                   // '0.123'
x.toExponential()                        // '1.23e-1'
x.d                                      // [ 1230000 ]
x.e                                      // -1
x.s                                      // 1

y = new Number(-123.4567000e+2)          // '-12345.67'
y.toExponential()                        // '-1.234567e+4'
z = new Decimal('-123.4567000e+2')       // '-12345.67'
z.toExponential()                        // '-1.234567e+4'
z.d                                      // [ 12345, 6700000 ]
z.e                                      // 4
z.s                                      // -1</pre>



    <h4 id='Errors'>Errors</h4>
    <p>
      The errors that are thrown are generic <code>Error</code> objects whose <code>message</code>
      property begins with <code>"[DecimalError]"</code>.
    </p>
    <p>To determine if an exception is a Decimal Error:</p>
    <pre>
try {
    // ...
} catch (e) {
    if ( e instanceof Error && /DecimalError/.test(e.message) ) {
        // ...
    }
}</pre>



    <h2 id='faq'>FAQ</h2>
    <h6>Why are trailing fractional zeros removed from Decimals?</h6>
    <p>
      Some arbitrary-precision libraries retain trailing fractional zeros as they can indicate the
      precision of a value. This can be useful but the results of arithmetic operations can be
      misleading.
    </p>
    <pre>
x = new BigDecimal("1.0")
y = new BigDecimal("1.1000")
z = x.add(y)                      // 2.1000

x = new BigDecimal("1.20")
y = new BigDecimal("3.45000")
z = x.multiply(y)                 // 4.1400000</pre>
    <p>
      To specify the precision of a value is to specify that the value lies
      within a certain range.
    </p>
    <p>
      In the first example, <code>x</code> has a value of <code>1.0</code>. The trailing zero shows
      the precision of the value, implying that it is in the range <code>0.95</code> to
      <code>1.05</code>. Similarly, the precision indicated by the trailing zeros of <code>y</code>
      indicates that the value is in the range <code>1.09995</code> to <code>1.10005</code>.
    </p>
    <p>
      If we  add the two lowest values in the ranges we have, <code>0.95 + 1.09995 = 2.04995</code>,
      and if we add the two highest values we have, <code>1.05 + 1.10005 = 2.15005</code>, so the
      range of the result of the addition implied by the precision of its operands is
      <code>2.04995</code> to <code>2.15005</code>.
    </p>
    <p>
      The result given by BigDecimal of <code>2.1000</code> however, indicates that the value is in
      the range <code>2.09995</code> to <code>2.10005</code> and therefore the precision implied by
      its trailing zeros may be misleading.
    </p>
    <p>
      In the second example, the true range is <code>4.122744</code> to <code>4.157256</code> yet
      the BigDecimal answer of <code>4.1400000</code> indicates a range of <code>4.13999995</code>
      to  <code>4.14000005</code>. Again, the precision implied by the trailing zeros may be
      misleading.
    </p>
    <p>
      This library, like binary floating point and most calculators, does not retain trailing
      fractional zeros. Instead, the <code>toExponential</code>, <code>toFixed</code> and
      <code>toPrecision</code> methods enable trailing zeros to be added if and when required.<br />
    </p>
  </div>

</body>
</html>