mirror of
https://github.com/MikeMcl/decimal.js.git
synced 2024-10-27 20:34:12 +00:00
2640 lines
131 KiB
HTML
2640 lines
131 KiB
HTML
<!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 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"><strong>Decimal</strong></a></li></ul>
|
|
|
|
<a href="#methods">Methods</a>
|
|
<ul>
|
|
<li><a href="#Dabs" >abs</a></li>
|
|
<li><a href="#Dacos" >acos</a></li>
|
|
<li><a href="#Dacosh" >acosh</a></li>
|
|
<li><a href="#Dadd" >add</a></li>
|
|
<li><a href="#Dasin" >asin</a></li>
|
|
<li><a href="#Dasinh" >asinh</a></li>
|
|
<li><a href="#Datan" >atan</a></li>
|
|
<li><a href="#Datanh" >atanh</a></li>
|
|
<li><a href="#Datan2" >atan2</a></li>
|
|
<li><a href="#Dcbrt" >cbrt</a></li>
|
|
<li><a href="#Dceil" >ceil</a></li>
|
|
<li><a href="#Dclone" ><strong>clone</strong></a></li>
|
|
<li><a href="#Dcos" >cos</a></li>
|
|
<li><a href="#Dcosh" >cosh</a></li>
|
|
<li><a href="#Ddiv" >div</a></li>
|
|
<li><a href="#Dexp" >exp</a></li>
|
|
<li><a href="#Dfloor" >floor</a></li>
|
|
<li><a href="#Dhypot" >hypot</a></li>
|
|
<li><a href="#Dln" >ln</a></li>
|
|
<li><a href="#Dlog" >log</a></li>
|
|
<li><a href="#Dlog2" >log2</a></li>
|
|
<li><a href="#Dlog10" >log10</a></li>
|
|
<li><a href="#Dmax" >max</a></li>
|
|
<li><a href="#Dmin" >min</a></li>
|
|
<li><a href="#Dmod" >mod</a></li>
|
|
<li><a href="#Dmul" >mul</a></li>
|
|
<li><a href="#DnoConflict"><strong>noConflict</strong></a></li>
|
|
<li><a href="#Dpow" >pow</a></li>
|
|
<li><a href="#Drandom" >random</a></li>
|
|
<li><a href="#Dround" >round</a></li>
|
|
<li><a href="#Dset" ><strong>set</strong></a></li>
|
|
<li><a href="#Dsign" >sign</a></li>
|
|
<li><a href="#Dsin" >sin</a></li>
|
|
<li><a href="#Dsinh" >sinh</a></li>
|
|
<li><a href="#Dsqrt" >sqrt</a></li>
|
|
<li><a href="#Dsub" >sub</a></li>
|
|
<li><a href="#Dtan" >tan</a></li>
|
|
<li><a href="#Dtanh" >tanh</a></li>
|
|
<li><a href="#Dtrunc" >trunc</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="#minE" >minE</a></li>
|
|
<li><a href="#maxE" >maxE</a></li>
|
|
<li><a href="#toExpNeg" >toExpNeg</a></li>
|
|
<li><a href="#toExpPos" >toExpPos</a></li>
|
|
<li><a href="#modulo" >modulo</a></li>
|
|
<li><a href="#crypto" >crypto</a></li>
|
|
<li class='spacer'> </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="#ceil" >ceil </a> </li>
|
|
<li><a href="#cmp" >comparedTo </a><span>cmp</span> </li>
|
|
<li><a href="#cos" >cosine </a><span>cos</span> </li>
|
|
<li><a href="#cbrt" >cubeRoot </a><span>cbrt</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="#divToInt" >dividedToIntegerBy </a><span>divToInt</span></li>
|
|
<li><a href="#eq" >equals </a><span>eq</span> </li>
|
|
<li><a href="#floor" >floor </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="#cosh" >hyperbolicCosine </a><span>cosh</span> </li>
|
|
<li><a href="#sinh" >hyperbolicSine </a><span>sinh</span> </li>
|
|
<li><a href="#tanh" >hyperbolicTangent </a><span>tanh</span> </li>
|
|
<li><a href="#acos" >inverseCosine </a><span>acos</span> </li>
|
|
<li><a href="#acosh" >inverseHyperbolicCosine </a><span>acosh</span> </li>
|
|
<li><a href="#asinh" >inverseHyperbolicSine </a><span>asinh</span> </li>
|
|
<li><a href="#atanh" >inverseHyperbolicTangent</a><span>atanh</span> </li>
|
|
<li><a href="#asin" >inverseSine </a><span>asin</span> </li>
|
|
<li><a href="#atan" >inverseTangent </a><span>atan</span> </li>
|
|
<li><a href="#isFinite" >isFinite </a> </li>
|
|
<li><a href="#isInt" >isInteger </a><span>isInt</span> </li>
|
|
<li><a href="#isNaN" >isNaN </a> </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="#round" >round </a> </li>
|
|
<li><a href="#sin" >sine </a><span>sin</span> </li>
|
|
<li><a href="#sqrt" >squareRoot </a><span>sqrt</span> </li>
|
|
<li><a href="#tan" >tangent </a><span>tan</span> </li>
|
|
<li><a href="#mul" >times </a><span>mul</span> </li>
|
|
<li><a href="#toBinary" >toBinary </a> </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="#toFraction" >toFraction </a> </li>
|
|
<li><a href="#toHex" >toHexadecimal </a><span>toHex</span> </li>
|
|
<li><a href="#toJSON" >toJSON </a> </li>
|
|
<li><a href="#toNearest" >toNearest </a> </li>
|
|
<li><a href="#toNumber" >toNumber </a> </li>
|
|
<li><a href="#toOctal" >toOctal </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="#trunc" >truncated </a><span>trunc</span> </li>
|
|
<li><a href="#valueOf" >valueOf </a> </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="#zero-nan-infinity">Zero, NaN & Infinity</a>
|
|
<a href="#Errors">Errors</a>
|
|
<a href="#Pi">Pi</a>
|
|
<a class='end' href="#faq">FAQ</a>
|
|
|
|
</div>
|
|
|
|
<div class="container">
|
|
|
|
<h1>decimal<span id='js'>.js</span></h1>
|
|
|
|
<p>An arbitrary-precision Decimal type for JavaScript.</p>
|
|
<p><a href='https://github.com/MikeMcl/decimal.js'>Hosted on GitHub</a>.</p>
|
|
<p>
|
|
<i>
|
|
The library is incorporated into this page, so it should be available in the console now.
|
|
</i>
|
|
</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>⇒ Decimal</i></code>
|
|
</h5>
|
|
<dl>
|
|
<dt><code>value</code>: <i>number|string|Decimal</i></dt>
|
|
<dd>
|
|
A legitimate <code>value</code> is an integer or float, including <code>±0</code>, or
|
|
is <code>±Infinity</code>, or <code>NaN</code>.
|
|
</dd>
|
|
<dd>
|
|
The number of digits of <code>value</code> is not limited, except by JavaScript's maximum
|
|
array size and, in practice, the processing time required.
|
|
</dd>
|
|
<dd>
|
|
The allowable range of <code>value</code> is defined in terms of a maximum exponent, see
|
|
<a href='#maxE'>maxE</a>, and a minimum exponent, see <a href='#minE'>minE</a>.
|
|
</dd>
|
|
<dd>
|
|
As well as in decimal, a string <code>value</code> may be expressed in binary, hexadecimal
|
|
or octal, if the appropriate prefix is included: <code>0x</code> or <code>0X</code> for
|
|
hexadecimal, <code>0b</code> or <code>0B</code> for binary, and <code>0o</code> or
|
|
<code>0O</code> for octal.
|
|
</dd>
|
|
<dd>
|
|
Both decimal and non-decimal string values may use 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
|
|
for decimal values, and <code>p</code> or <code>P</code> defines a power-of-two exponent for
|
|
non-decimal values, i.e. binary, hexadecimal or octal.
|
|
</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(Infinity) // 'Infinity'
|
|
new Decimal(NaN) // 'NaN'
|
|
new Decimal('.5') // '0.5'
|
|
new Decimal('-0b10110100.1') // '-180.5'
|
|
new Decimal('0xff.8') // '255.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'
|
|
|
|
new Decimal('0b0.000011') // '0.046875'
|
|
new Decimal('0o0.03') // '0.046875'
|
|
new Decimal('0x0.0c') // '0.046875'
|
|
|
|
new Decimal('0b1.1p-5') // '0.046875'
|
|
new Decimal('0o1.4p-5') // '0.046875'
|
|
new Decimal('0x1.8p-5') // '0.046875'</pre>
|
|
|
|
|
|
|
|
<h4 id="methods">Methods</h4>
|
|
<p>The methods of a Decimal constructor.</p>
|
|
|
|
|
|
|
|
<h5 id="Dabs">abs<code class='inset'>.abs(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#abs'>absoluteValue</a></code>.</p>
|
|
<pre>a = Decimal.abs(x)
|
|
b = new Decimal(x).abs()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dacos">acos<code class='inset'>.acos(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#acos'>inverseCosine</a></code>.</p>
|
|
<pre>a = Decimal.acos(x)
|
|
b = new Decimal(x).acos()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dacosh">acosh<code class='inset'>.acosh(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#acos'>inverseHyperbolicCosine</a></code>.</p>
|
|
<pre>a = Decimal.acosh(x)
|
|
b = new Decimal(x).acosh()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dadd">add<code class='inset'>.add(x, y) <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>y</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>See <code><a href='#add'>plus</a></code>.</p>
|
|
<pre>a = Decimal.add(x, y)
|
|
b = new Decimal(x).plus(y)
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dasin">asin<code class='inset'>.asin(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#asin'>inverseSine</a></code>.</p>
|
|
<pre>a = Decimal.asin(x)
|
|
b = new Decimal(x).asin()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dasinh">asinh<code class='inset'>.asinh(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#asin'>inverseHyperbolicSine</a></code>.</p>
|
|
<pre>a = Decimal.asinh(x)
|
|
b = new Decimal(x).asinh()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Datan">atan<code class='inset'>.atan(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#atan'>inverseTangent</a></code>.</p>
|
|
<pre>a = Decimal.atan(x)
|
|
b = new Decimal(x).atan()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Datanh">atanh<code class='inset'>.atanh(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#atan'>inverseHyperbolicTangent</a></code>.</p>
|
|
<pre>a = Decimal.atanh(x)
|
|
b = new Decimal(x).atanh()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Datan2">atan2<code class='inset'>.atan2(y, x) <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
<code>y</code>: <i>number|string|Decimal</i><br />
|
|
<code>x</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>
|
|
Returns a new Decimal whose value is the inverse tangent in radians of the quotient of
|
|
<code>y</code> and <code>x</code>, rounded to <a href='#precision'><code>precision</code></a>
|
|
significant digits using rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
The signs of <code>y</code> and <code>x</code> are used to determine the quadrant of the
|
|
result.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>-pi, pi</code>]
|
|
</p>
|
|
<p>
|
|
See <a href='#Pi'><code>Pi</code></a> and
|
|
<a href='https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2'><code>Math.atan2()</code>.</a>
|
|
</p>
|
|
<pre>r = Decimal.atan2(y, x)</pre>
|
|
|
|
|
|
|
|
<h5 id="Dcbrt">cbrt<code class='inset'>.cbrt(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#cbrt'>cubeRoot</a></code>.</p>
|
|
<pre>a = Decimal.cbrt(x)
|
|
b = new Decimal(x).cbrt()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dceil">ceil<code class='inset'>.ceil(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#ceil'>ceil</a></code>.</p>
|
|
<pre>a = Decimal.ceil(x)
|
|
b = new Decimal(x).ceil()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dclone">
|
|
clone
|
|
<code class='inset'>.clone([object]) <i>⇒ 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='#Dset'><code>set</code></a>), or with the same
|
|
settings as <code>this</code> Decimal constructor if <code>object</code> is omitted.
|
|
</p>
|
|
<pre>Decimal.set({ 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.set({ 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="Dcos">cos<code class='inset'>.cos(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#cos'>cosine</a></code>.</p>
|
|
<pre>a = Decimal.cos(x)
|
|
b = new Decimal(x).cos()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dcosh">cosh<code class='inset'>.cosh(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#cos'>hyperbolicCosine</a></code>.</p>
|
|
<pre>a = Decimal.cosh(x)
|
|
b = new Decimal(x).cosh()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Ddiv">div<code class='inset'>.div(x, y) <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>y</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>See <code><a href='#div'>dividedBy</a></code>.</p>
|
|
<pre>a = Decimal.div(x, y)
|
|
b = new Decimal(x).div(y)
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dexp">exp<code class='inset'>.exp(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#exp'>naturalExponential</a></code>.</p>
|
|
<pre>a = Decimal.exp(x)
|
|
b = new Decimal(x).exp()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dfloor">floor<code class='inset'>.floor(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#floor'>floor</a></code>.</p>
|
|
<pre>a = Decimal.floor(x)
|
|
b = new Decimal(x).floor()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dhypot">
|
|
hypot<code class='inset'>.hypot([x [, y, ...]]) <i>⇒ Decimal</i></code>
|
|
</h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>y</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>
|
|
Returns a new Decimal whose value is the square root of the sum of the squares of the
|
|
arguments, rounded to <a href='#precision'><code>precision</code></a> significant digits using
|
|
rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<pre>r = Decimal.hypot(x, y)</pre>
|
|
|
|
|
|
|
|
<h5 id="Dln">ln<code class='inset'>.ln(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#ln'>naturalLogarithm</a></code>.</p>
|
|
<pre>a = Decimal.ln(x)
|
|
b = new Decimal(x).ln()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dlog">log<code class='inset'>.log(x [, base]) <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>base</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>See <code><a href='#log'>logarithm</a></code>.</p>
|
|
<p>
|
|
The default base is <code>10</code>, which is not the same as JavaScript's
|
|
<code>Math.log()</code>, which returns the natural logarithm (base <code>e</code>).
|
|
</p>
|
|
<pre>a = Decimal.log(x, y)
|
|
b = new Decimal(x).log(y)
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dlog2">log2<code class='inset'>.log2(x) <i>⇒ 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>2</code> logarithm of <code>x</code>,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<pre>r = Decimal.log2(x)</pre>
|
|
|
|
|
|
|
|
<h5 id="Dlog10">log10<code class='inset'>.log10(x) <i>⇒ 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>10</code> logarithm of <code>x</code>,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<pre>r = Decimal.log10(x)</pre>
|
|
|
|
|
|
|
|
<h5 id="Dmax">
|
|
max<code class='inset'>.max([x [, y, ...]]) <i>⇒ Decimal</i></code>
|
|
</h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>y</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>Returns a new Decimal whose value is the maximum of the <code>arguments</code>.</p>
|
|
<pre>r = Decimal.max(x, y, z)</pre>
|
|
|
|
|
|
|
|
<h5 id="Dmin">
|
|
min<code class='inset'>.min([x [, y, ...]]) <i>⇒ Decimal</i></code>
|
|
</h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>y</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>Returns a new Decimal whose value is the minimum of the <code>arguments</code>.</p>
|
|
<pre>r = Decimal.min(x, y, z)</pre>
|
|
|
|
|
|
|
|
<h5 id="Dmod">mod<code class='inset'>.mod(x, y) <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>y</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>See <code><a href='#mod'>modulo</a></code>.</p>
|
|
<pre>a = Decimal.mod(x, y)
|
|
b = new Decimal(x).mod(y)
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dmul">mul<code class='inset'>.mul(x, y) <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>y</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>See <code><a href='#mul'>times</a></code>.</p>
|
|
<pre>a = Decimal.mul(x, y)
|
|
b = new Decimal(x).mul(y)
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="DnoConflict">
|
|
noConflict<code class='inset'>.noConflict() <i>⇒ Decimal constructor</i></code>
|
|
</h5>
|
|
<p><i>Browsers only.</i></p>
|
|
<p>
|
|
Reverts the <code>Decimal</code> variable to the value it had before this library was loaded
|
|
and returns a reference to the original Decimal constructor so it can be assigned to a
|
|
variable with a different name.
|
|
</p>
|
|
<pre>
|
|
<script> Decimal = 1 </script>
|
|
<script src='/path/to/decimal.js'></script>
|
|
<script>
|
|
a = new Decimal(2) // '2'
|
|
D = Decimal.noConflict()
|
|
Decimal // 1
|
|
b = new D(3) // '3'
|
|
</script></pre>
|
|
|
|
|
|
|
|
<h5 id="Dpow">pow<code class='inset'>.pow(base, exponent) <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
<code>base</code>: <i>number|string|Decimal</i><br />
|
|
<code>exponent</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>See <code><a href="#pow">toPower</a></code>.</p>
|
|
<pre>a = Decimal.pow(x, y)
|
|
b = new Decimal(x).pow(y)
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Drandom">
|
|
random<code class='inset'>.random([dp]) <i>⇒ Decimal</i></code>
|
|
</h5>
|
|
<p><code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive</p>
|
|
<p>
|
|
Returns a new Decimal with a pseudo-random value equal to or greater than <code>0</code> and
|
|
less than <code>1</code>.
|
|
</p>
|
|
<p>
|
|
The return value will have <code>dp</code> decimal places (or less if trailing zeros are
|
|
produced). If <code>dp</code> is omitted then the number of decimal places will
|
|
default to the current <a href='#precision'><code>precision</code></a> setting.
|
|
</p>
|
|
<p>
|
|
If the value of <code>this</code> Decimal constructor's
|
|
<a href='#crypto'><code>crypto</code></a> property is <code>true</code>, and the
|
|
<code>crypto</code> object is available in the host environment, the random digits of the
|
|
return value are generated by either <code>crypto.getRandomValues</code> (Web Cryptography API
|
|
in modern browsers) or <code>crypto.randomBytes</code> (Node.js), otherwise, if the the value
|
|
of the property is <code>false</code> the return value is generated by
|
|
<code>Math.random</code> (fastest).
|
|
</p>
|
|
<p>
|
|
If the value of <code>this</code> Decimal constructor's
|
|
<a href='#crypto'><code>crypto</code></a> property is set <code>true</code> and the
|
|
<code>crypto</code> object and associated method are not available, an exception will be
|
|
thrown.
|
|
</p>
|
|
<p>
|
|
If one of the <code>crypto</code> methods is used, the value of the returned Decimal should be
|
|
cryptographically-secure and statistically indistinguishable from a random value.
|
|
</p>
|
|
<pre>Decimal.set({ precision: 10 })
|
|
Decimal.random() // '0.4117936847'
|
|
Decimal.random(20) // '0.78193327636914089009'</pre>
|
|
|
|
|
|
|
|
<h5 id="Dround">round<code class='inset'>.round(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#round'>round</a></code>.</p>
|
|
<pre>a = Decimal.round(x)
|
|
b = new Decimal(x).round()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dset">set<code class='inset'>.set(object) <i>⇒ 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.set({
|
|
precision: 20,
|
|
rounding: 4,
|
|
toExpNeg: -7,
|
|
toExpPos: 21,
|
|
maxE: 9e15,
|
|
minE: -9e15,
|
|
modulo: 1,
|
|
crypto: false
|
|
})</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 - this is not a problem if the user
|
|
knows that the assingment is valid.
|
|
</p>
|
|
<pre>Decimal.precision = 40</pre>
|
|
|
|
|
|
|
|
<h5 id="Dsign">sign<code class='inset'>.sign(x) <i>⇒ number</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<table>
|
|
<tr><th>Returns</th><th> </th></tr>
|
|
<tr>
|
|
<td class='centre'><code>1</code></td>
|
|
<td>if the value of <code>x</code> is non-zero and its sign is positive</td>
|
|
</tr>
|
|
<tr>
|
|
<td class='centre'><code>-1</code></td>
|
|
<td>if the value of <code>x</code> is non-zero and its sign is negative</td>
|
|
</tr>
|
|
<tr>
|
|
<td class='centre'><code>0</code></td>
|
|
<td>if the value of <code>x</code> is positive zero</td>
|
|
</tr>
|
|
<tr>
|
|
<td class='centre'><code>-0</code></td>
|
|
<td>if the value of <code>x</code> is negative zero</td>
|
|
</tr>
|
|
<tr>
|
|
<td class='centre'><code>NaN</code></td>
|
|
<td>if the value of <code>x</code> is <code>NaN</code></td>
|
|
</tr>
|
|
</table>
|
|
<pre>r = Decimal.sign(x)</pre>
|
|
|
|
|
|
|
|
<h5 id="Dsin">sin<code class='inset'>.sin(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#sin'>sine</a></code>.</p>
|
|
<pre>a = Decimal.sin(x)
|
|
b = new Decimal(x).sin()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dsinh">sinh<code class='inset'>.sinh(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#sin'>hyperbolicSine</a></code>.</p>
|
|
<pre>a = Decimal.sinh(x)
|
|
b = new Decimal(x).sinh()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dsqrt">sqrt<code class='inset'>.sqrt(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <a href='#sqrt'>squareRoot</a>.</p>
|
|
<pre>a = Decimal.sqrt(x)
|
|
b = new Decimal(x).sqrt()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dsub">sub<code class='inset'>.sub(x, y) <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><br />
|
|
<code>y</code>: <i>number|string|Decimal</i>
|
|
</p>
|
|
<p>See <code><a href='#sub'>minus</a></code>.</p>
|
|
<pre>a = Decimal.sub(x, y)
|
|
b = new Decimal(x).sub(y)
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dtan">tan<code class='inset'>.tan(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#tan'>tangent</a></code>.</p>
|
|
<pre>a = Decimal.tan(x)
|
|
b = new Decimal(x).tan()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dtanh">tanh<code class='inset'>.tanh(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#tan'>hyperbolicTangent</a></code>.</p>
|
|
<pre>a = Decimal.tanh(x)
|
|
b = new Decimal(x).tanh()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
<h5 id="Dtrunc">trunc<code class='inset'>.trunc(x) <i>⇒ Decimal</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<p>See <code><a href='#trunc'>truncated</a></code>.</p>
|
|
<pre>a = Decimal.trunc(x)
|
|
b = new Decimal(x).trunc()
|
|
a.equals(b) // true</pre>
|
|
|
|
|
|
|
|
|
|
<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='#minE'><code>minE</code></a>,
|
|
<a href='#maxE'><code>maxE</code></a>, <a href='#toExpNeg'><code>toExpNeg</code></a>,
|
|
<a href='#toExpPos'><code>toExpPos</code></a>, <a href='#modulo'><code>modulo</code></a>, and
|
|
<a href='#crypto'><code>crypto</code></a> are set using the
|
|
<a href='#Dset'><code>set</code></a> method.
|
|
</p>
|
|
<p>
|
|
As simple object properties they can be set directly without using
|
|
<a href='#Dset'><code>set</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.set({ 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 round the return value to <code>precision</code>
|
|
significant digits except <a href='#decimal'><code>Decimal</code></a>,
|
|
<a href='#abs'><code>absoluteValue</code></a>,
|
|
<a href='#ceil'><code>ceil</code></a>, <a href='#floor'><code>floor</code></a>,
|
|
<a href='#neg'><code>negated</code></a>, <a href='#round'><code>round</code></a>,
|
|
<a href='#toDP'><code>toDecimalPlaces</code></a>,
|
|
<a href='#toNearest'><code>toNearest</code></a> and
|
|
<a href='#trunc'><code>truncated</code></a>.
|
|
</p>
|
|
<pre>Decimal.set({ 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 when rounding the result of an operation to
|
|
<code><a href='#precision'>precision</a></code> significant digits, and when rounding the
|
|
return value of the <a href='#round'><code>round</code></a>,
|
|
<a href='#toBinary'><code>toBinary</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='#toHexadecimal'><code>toHexadecimal</code></a>,
|
|
<a href='#toNearest'><code>toNearest</code></a>,
|
|
<a href='#toOctal'><code>toOctal</code></a>,
|
|
<a href='#toPrecision'><code>toPrecision</code></a> and
|
|
<a href='#toSD'><code>toSignificantDigits</code></a> methods.
|
|
</p>
|
|
<p>
|
|
The <a href='#modes'>rounding modes</a> are available as enumerated properties of the
|
|
constructor.
|
|
</p>
|
|
<pre>Decimal.set({ rounding: Decimal.ROUND_UP })
|
|
Decimal.set({ rounding: 0 }) // equivalent
|
|
Decimal.rounding // 0</pre>
|
|
|
|
|
|
|
|
<h5 id="minE">minE</h5>
|
|
<p>
|
|
<i>number</i>: integer, <code>-9e15</code> to <code>0</code> inclusive<br />
|
|
Default value: <code>-9e15</code>
|
|
</p>
|
|
<p>
|
|
The negative exponent limit, i.e. the exponent value below which underflow to zero occurs.
|
|
</p>
|
|
<p>
|
|
If the <code>Decimal</code> to be returned by a calculation would have an exponent lower than
|
|
<code>minE</code> then the value of that <code>Decimal</code> becomes zero.
|
|
<p>
|
|
JavaScript numbers underflow to zero for exponents below <code>-324</code>.
|
|
</p>
|
|
<pre>Decimal.set({ minE: -500 })
|
|
Decimal.minE // -500
|
|
new Decimal('1e-500') // '1e-500'
|
|
new Decimal('9.9e-501') // '0'
|
|
|
|
Decimal.set({ minE: -3 })
|
|
new Decimal(0.001) // '0.01' e is -3
|
|
new Decimal(0.0001) // '0' e is -4</pre>
|
|
<p>
|
|
The smallest possible magnitude of a non-zero Decimal is <code>1e-9000000000000000</code>
|
|
</p>
|
|
|
|
|
|
|
|
<h5 id="maxE">maxE</h5>
|
|
<p>
|
|
<i>number</i>: integer, <code>0</code> to <code>9e15</code> inclusive<br />
|
|
Default value: <code>9e15</code>
|
|
</p>
|
|
<p>
|
|
The positive exponent limit, i.e. the exponent value above which overflow to
|
|
<code>Infinity</code> occurs.
|
|
</p>
|
|
<p>
|
|
If the <code>Decimal</code> to be returned by a calculation would have an exponent higher than
|
|
<code>maxE</code> then the value of that <code>Decimal</code> becomes <code>Infinity</code>.
|
|
<p>
|
|
JavaScript numbers overflow to <code>Infinity</code> for exponents above <code>308</code>.
|
|
</p>
|
|
<pre>Decimal.set({ maxE: 500 })
|
|
Decimal.maxE // 500
|
|
new Decimal('9.999e500') // '9.999e+500'
|
|
new Decimal('1e501') // 'Infinity'
|
|
|
|
Decimal.set({ maxE: 4 })
|
|
new Decimal(99999) // '99999' e is 4
|
|
new Decimal(100000) // 'Infinity'</pre>
|
|
<p>
|
|
The largest possible magnitude of a finite Decimal is <code>9.999...e+9000000000000000</code>
|
|
</p>
|
|
|
|
|
|
|
|
<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.set({ 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.set({ 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.set({ 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.set({ 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="modulo">modulo</h5>
|
|
<p>
|
|
<i>number</i>: integer, <code>0</code> to <code>9</code> inclusive<br />
|
|
Default value: <code>1</code> (<code>ROUND_DOWN</code>)
|
|
</p>
|
|
<p>The modulo mode used when calculating the modulus: <code>a mod n</code>.</p>
|
|
<p>
|
|
The quotient, <code>q = a / n</code>, is calculated according to the
|
|
<a href='#rounding'><code>rounding</code></a> mode that corresponds to the chosen
|
|
<code>modulo</code> mode.
|
|
</p>
|
|
<p>The remainder, <code>r</code>, is calculated as: <code>r = a - n * q</code>.</p>
|
|
<p>
|
|
The modes that are most commonly used for the modulus/remainder operation are shown in the
|
|
following table. Although the other <a href='#rounding'><code>rounding</code></a> modes can
|
|
be used, they may not give useful results.
|
|
</p>
|
|
<table>
|
|
<tr><th>Property</th><th>Value</th><th>Description</th></tr>
|
|
<tr>
|
|
<td>ROUND_UP</td><td class='centre'>0</td>
|
|
<td>The remainder is positive if the dividend is negative, else is negative</td>
|
|
</tr>
|
|
<tr>
|
|
<td>ROUND_DOWN</td><td class='centre'>1</td>
|
|
<td>
|
|
The remainder has the same sign as the dividend.<br />
|
|
This uses truncating division and matches the behaviour of JavaScript's remainder
|
|
operator <code>%</code>.
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>ROUND_FLOOR</td><td class='centre'>3</td>
|
|
<td>
|
|
The remainder has the same sign as the divisor.<br />
|
|
(This matches Python's <code>%</code> operator)
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>ROUND_HALF_EVEN</td><td class='centre'>6</td>
|
|
<td>The <i>IEEE 754</i> remainder function</td>
|
|
</tr>
|
|
<tr>
|
|
<td>EUCLID</td><td class='centre'>9</td>
|
|
<td>
|
|
The remainder is always positive.<br />
|
|
Euclidian division: <code>q = sign(x) * floor(a / abs(x))</code>.
|
|
</td>
|
|
</tr>
|
|
</table>
|
|
<p>
|
|
The rounding/modulo modes are available as enumerated properties of the Decimal constructor.
|
|
</p>
|
|
<pre>Decimal.set({ modulo: Decimal.EUCLID })
|
|
Decimal.set({ modulo: 9 }) // equivalent
|
|
Decimal.modulo // 9</pre>
|
|
|
|
|
|
|
|
<h5 id="crypto">crypto</h5>
|
|
<p>
|
|
<i>boolean</i>: <code>true/false</code><br /> Default value: <code>false</code>
|
|
</p>
|
|
<p>
|
|
The value that determines whether cryptographically-secure pseudo-random number generation is
|
|
used.
|
|
</p>
|
|
<p>See <a href='#Drandom'><code>random</code></a>.</p>
|
|
<pre>Decimal.crypto // false
|
|
Decimal.set({ crypto: true })
|
|
Decimal.crypto // true</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>
|
|
<tr>
|
|
<td><b>EUCLID</b></td><td class='centre'>9</td>
|
|
<td>Not a rounding mode, see <a href='#modulo'>modulo</a></td>
|
|
</tr>
|
|
</table>
|
|
<pre>Decimal.set({ rounding: Decimal.ROUND_CEIL })
|
|
Decimal.set({ 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).ceil()</pre>
|
|
<p>Methods do not round their arguments before execution.</p>
|
|
<p>
|
|
The treatment of <code>±0</code>, <code>±Infinity</code> and <code>NaN</code>
|
|
is consistent with how JavaScript treats these values.
|
|
</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>⇒ 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="ceil">ceil<code class='inset'>.ceil() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the value of this Decimal rounded to a whole number in
|
|
the direction of positive <code>Infinity</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.3)
|
|
x.ceil() // '2'
|
|
y = new Decimal(-1.8)
|
|
y.ceil() // '-1'</pre>
|
|
|
|
|
|
|
|
<h5 id="cmp">comparedTo<code class='inset'>.cmp(x) <i>⇒ number</i></code></h5>
|
|
<p><code>x</code>: <i>number|string|Decimal</i></p>
|
|
<table>
|
|
<tr><th>Returns</th><th> </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>
|
|
<tr>
|
|
<td class='centre'><code>NaN</code></td>
|
|
<td>if the value of either this Decimal or <code>x</code> is <code>NaN</code> </td>
|
|
</tr>
|
|
</table>
|
|
<pre>
|
|
x = new Decimal(Infinity)
|
|
y = new Decimal(5)
|
|
x.comparedTo(y) // 1
|
|
x.comparedTo(x.minus(1)) // 0
|
|
y.cmp(NaN) // NaN</pre>
|
|
|
|
|
|
|
|
<h5 id="cos">cosine<code class='inset'>.cos() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the cosine of the value in radians of this Decimal,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>-1, 1</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(0.25)
|
|
x.cosine() // '0.96891242171064478414'
|
|
y = new Decimal(-0.25)
|
|
y.cos() // '0.96891242171064478414'</pre>
|
|
|
|
|
|
|
|
<h5 id="cbrt">cubeRoot<code class='inset'>.cbrt() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the cube root of this Decimal, rounded to
|
|
<a href='#precision'><code>precision</code></a> significant digits using rounding mode
|
|
<a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
The return value will be correctly rounded, i.e. rounded as if the result was first calculated
|
|
to an infinite number of correct digits before rounding.
|
|
</p>
|
|
<pre>
|
|
x = new Decimal(125)
|
|
x.cubeRoot() // '5'
|
|
y = new Decimal(3)
|
|
y.cbrt() // '1.4422495703074083823'</pre>
|
|
|
|
|
|
|
|
<h5 id="dp">decimalPlaces<code class='inset'>.dp() <i>⇒ 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>⇒ 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>,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<pre>
|
|
x = new Decimal(355)
|
|
y = new Decimal(113)
|
|
x.dividedBy(y) // '3.14159292035398230088'
|
|
x.div(5) // '71'</pre>
|
|
|
|
|
|
|
|
<h5 id="divToInt">
|
|
dividedToIntegerBy<code class='inset'>.divToInt(x) <i>⇒ 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>, rounded to <code><a href='#precision'>precision</a></code> significant digits
|
|
using rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<pre>
|
|
x = new Decimal(5)
|
|
y = new Decimal(3)
|
|
x.dividedToIntegerBy(y) // '1'
|
|
x.divToInt(0.7) // '7'</pre>
|
|
|
|
|
|
|
|
<h5 id="eq">equals<code class='inset'>.eq(x) <i>⇒ 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>.<br /> As with JavaScript, <code>NaN</code> does not
|
|
equal <code>NaN</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
|
|
new Decimal(-0).eq(x) // true ( -0 === 0 )
|
|
|
|
y = new Decimal(NaN)
|
|
y.equals(NaN) // false</pre>
|
|
|
|
|
|
|
|
<h5 id="floor">floor<code class='inset'>.floor() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the value of this Decimal rounded to a whole number in
|
|
the direction of negative <code>Infinity</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.floor() // '1'
|
|
y = new Decimal(-1.3)
|
|
y.floor() // '-2'</pre>
|
|
|
|
|
|
|
|
<h5 id="gt">greaterThan<code class='inset'>.gt(x) <i>⇒ 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 > (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>⇒ 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) >= 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="cosh">hyperbolicCosine<code class='inset'>.cosh() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the hyperbolic cosine of the value in radians of this
|
|
Decimal, rounded to <a href='#precision'><code>precision</code></a> significant digits using
|
|
rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>1, Infinity</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(1)
|
|
x.hyperbolicCosine() // '1.5430806348152437785'
|
|
y = new Decimal(0.5)
|
|
y.cosh() // '1.1276259652063807852'</pre>
|
|
|
|
|
|
|
|
<h5 id="sinh">hyperbolicSine<code class='inset'>.sinh() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the hyperbolic sine of the value in radians of this
|
|
Decimal, rounded to <a href='#precision'><code>precision</code></a> significant digits using
|
|
rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>-Infinity, Infinity</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(1)
|
|
x.hyperbolicSine() // '1.1752011936438014569'
|
|
y = new Decimal(0.5)
|
|
y.sinh() // '0.52109530549374736162'</pre>
|
|
|
|
|
|
|
|
<h5 id="tanh">hyperbolicTangent<code class='inset'>.tanh() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the hyperbolic tangent of the value in radians of this
|
|
Decimal, rounded to <a href='#precision'><code>precision</code></a> significant digits using
|
|
rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>-1, 1</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(1)
|
|
x.hyperbolicTangent() // '0.76159415595576488812'
|
|
y = new Decimal(0.5)
|
|
y.tanh() // '0.4621171572600097585'</pre>
|
|
|
|
|
|
|
|
<h5 id="acos">inverseCosine<code class='inset'>.acos() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the inverse cosine in radians of the value of this
|
|
Decimal, rounded to <a href='#precision'><code>precision</code></a> significant digits using
|
|
rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-1, 1</code>]<br />
|
|
Range: [<code>0, pi</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(0)
|
|
x.inverseCosine() // '1.5707963267948966192'
|
|
y = new Decimal(0.5)
|
|
y.acos() // '1.0471975511965977462'</pre>
|
|
|
|
|
|
|
|
<h5 id="acosh">
|
|
inverseHyperbolicCosine<code class='inset'>.acosh() <i>⇒ Decimal</i></code>
|
|
</h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the inverse hyperbolic cosine in radians of the value of
|
|
this Decimal, rounded to <a href='#precision'><code>precision</code></a> significant
|
|
digits using rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>1, Infinity</code>]<br />
|
|
Range: [<code>0, Infinity</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(5)
|
|
x.inverseHyperbolicCosine() // '2.2924316695611776878'
|
|
y = new Decimal(50)
|
|
y.acosh() // '4.6050701709847571595'</pre>
|
|
|
|
|
|
|
|
<h5 id="asinh">
|
|
inverseHyperbolicSine<code class='inset'>.asinh() <i>⇒ Decimal</i></code>
|
|
</h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the inverse hyperbolic sine in radians of the value of
|
|
this Decimal, rounded to <a href='#precision'><code>precision</code></a> significant digits
|
|
using rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>-Infinity, Infinity</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(5)
|
|
x.inverseHyperbolicSine() // '2.3124383412727526203'
|
|
y = new Decimal(50)
|
|
y.asinh() // '4.6052701709914238266'</pre>
|
|
|
|
|
|
|
|
<h5 id="atanh">
|
|
inverseHyperbolicTangent<code class='inset'>.atanh() <i>⇒ Decimal</i></code>
|
|
</h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the inverse hyperbolic tangent in radians of the value of
|
|
this Decimal, rounded to <a href='#precision'><code>precision</code></a> significant
|
|
digits using rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-1, 1</code>]<br />
|
|
Range: [<code>-Infinity, Infinity</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(0.5)
|
|
x.inverseHyperbolicTangent() // '0.5493061443340548457'
|
|
y = new Decimal(0.75)
|
|
y.atanh() // '0.97295507452765665255'</pre>
|
|
|
|
|
|
|
|
<h5 id="asin">inverseSine<code class='inset'>.asin() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the inverse sine in radians of the value of this Decimal,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-1, 1</code>]<br />
|
|
Range: [<code>-pi/2, pi/2</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(0.5)
|
|
x.inverseSine() // '0.52359877559829887308'
|
|
y = new Decimal(0.75)
|
|
y.asin() // '0.84806207898148100805'</pre>
|
|
|
|
|
|
|
|
<h5 id="atan">inverseTangent<code class='inset'>.atan() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the inverse tangent in radians of the value of this
|
|
Decimal, rounded to <a href='#precision'><code>precision</code></a> significant digits using
|
|
rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>-pi/2, pi/2</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(0.5)
|
|
x.inverseTangent() // '0.46364760900080611621'
|
|
y = new Decimal(0.75)
|
|
y.atan() // '0.6435011087932843868'</pre>
|
|
|
|
|
|
|
|
<h5 id="isFinite">isFinite<code class='inset'>.isFinite() <i>⇒ boolean</i></code></h5>
|
|
<p>
|
|
Returns <code>true</code> if the value of this Decimal is a finite number, otherwise returns
|
|
<code>false</code>.<br />
|
|
The only possible non-finite values of a Decimal are <code>NaN</code>, <code>Infinity</code>
|
|
and <code>-Infinity</code>.
|
|
</p>
|
|
<pre>
|
|
x = new Decimal(1)
|
|
x.isFinite() // true
|
|
y = new Decimal(Infinity)
|
|
y.isFinite() // false</pre>
|
|
<p>
|
|
Note: The native method <code>isFinite()</code> can be used if
|
|
<code>n <= Number.MAX_VALUE</code>.
|
|
</p>
|
|
|
|
|
|
|
|
<h5 id="isInt">isInteger<code class='inset'>.isInt() <i>⇒ 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="isNaN">isNaN<code class='inset'>.isNaN() <i>⇒ boolean</i></code></h5>
|
|
<p>
|
|
Returns <code>true</code> if the value of this Decimal is <code>NaN</code>, otherwise returns
|
|
<code>false</code>.
|
|
</p>
|
|
<pre>
|
|
x = new Decimal(NaN)
|
|
x.isNaN() // true
|
|
y = new Decimal('Infinity')
|
|
y.isNaN() // false</pre>
|
|
<p>Note: The native method <code>isNaN()</code> can also be used.</p>
|
|
|
|
|
|
|
|
<h5 id="isNeg">isNegative<code class='inset'>.isNeg() <i>⇒ 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() // true
|
|
y = new Decimal(2)
|
|
y.isNeg // false</pre>
|
|
<p>Note: <code>n < 0</code> can be used if <code>n <= -Number.MIN_VALUE</code>.</p>
|
|
|
|
|
|
|
|
<h5 id="isPos">isPositive<code class='inset'>.isPos() <i>⇒ 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() // true
|
|
y = new Decimal(-2)
|
|
y.isPos // false</pre>
|
|
<p>Note: <code>n < 0</code> can be used if <code>n <= -Number.MIN_VALUE</code>.</p>
|
|
|
|
|
|
|
|
<h5 id="isZero">isZero<code class='inset'>.isZero() <i>⇒ 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() && x.isNeg() // true
|
|
y = new Decimal(Infinity)
|
|
y.isZero() // false</pre>
|
|
<p>Note: <code>n == 0</code> can be used if <code>n >= Number.MIN_VALUE</code>.</p>
|
|
|
|
|
|
|
|
<h5 id="lt">lessThan<code class='inset'>.lt(x) <i>⇒ 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) < 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>⇒ 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 <= (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>⇒ 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, rounded to <a href='#precision'><code>precision</code></a> significant digits using
|
|
rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</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 return value will <i>almost always</i> be correctly rounded, i.e. rounded as if the result
|
|
was first calculated to an infinite number of correct digits before rounding. If a result is
|
|
incorrectly rounded 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 correctly rounded.</p>
|
|
<p>
|
|
See <a href='#pow'><code>toPower</code></a> for the circumstances in which this method may
|
|
return an incorrectly rounded result.
|
|
</p>
|
|
<p>The performance of this method degrades exponentially with increasing digits.</p>
|
|
|
|
|
|
|
|
<h5 id="sub">minus<code class='inset'>.minus(x) <i>⇒ 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>, rounded
|
|
to <a href='#precision'><code>precision</code></a> significant digits using rounding mode
|
|
<a href='#rounding'><code>rounding</code></a>.
|
|
</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>⇒ 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>,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
The value returned, and in particular its sign, is dependent on the value of the
|
|
<a href='#modulo'><code>modulo</code></a> property of this Decimal's constructor. If it is
|
|
<code>1</code> (default value), the result will have the same sign as this Decimal, and it
|
|
will match that of Javascript's <code>%</code> operator (within the limits of double
|
|
precision) and BigDecimal's <code>remainder</code> method.
|
|
</p>
|
|
<p>
|
|
See <a href='#modulo'><code>modulo</code></a> for a description of the other modulo modes.
|
|
</p>
|
|
<pre>
|
|
1 % 0.9 // 0.09999999999999998
|
|
x = new Decimal(1)
|
|
x.modulo(0.9) // '0.1'
|
|
|
|
y = new Decimal(8)
|
|
z = new Decimal(-3)
|
|
Decimal.modulo = 1
|
|
y.mod(z) // '2'
|
|
Decimal.modulo = 3
|
|
y.mod(z) // '-1'</pre>
|
|
|
|
|
|
|
|
<h5 id="exp">naturalExponential<code class='inset'>.exp() <i>⇒ 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, rounded to
|
|
<a href='#precision'><code>precision</code></a> significant digits using rounding mode
|
|
<a href='#rounding'><code>rounding</code></a>.
|
|
</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 return value will be correctly rounded, i.e. rounded as if the result was first calculated
|
|
to an infinite number of correct digits before rounding. (The mathematical result of the
|
|
exponential function is non-terminating, unless its argument is <code>0</code>).
|
|
</p>
|
|
<p>The performance of this method degrades exponentially with increasing digits.</p>
|
|
|
|
|
|
|
|
<h5 id="ln">naturalLogarithm<code class='inset'>.ln() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the natural logarithm of the value of this Decimal,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</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 return value will be correctly rounded, i.e. rounded as if the result was first calculated
|
|
to an infinite number of correct digits before rounding. (The mathematical result of the
|
|
natural logarithm function is non-terminating, unless its argument is <code>1</code>).
|
|
</p>
|
|
<p>
|
|
Internally, this method is dependent on a constant whose value is the natural logarithm of
|
|
<code>10</code>. This <code>LN10</code> variable in the source code currently has a precision
|
|
of <code>1025</code> digits, meaning that this method can accurately calculate up to
|
|
<code>1000</code> digits.
|
|
</p>
|
|
<p>
|
|
If more than <code>1000</code> digits is required then the precision of <code>LN10</code>
|
|
will need to be increased to <code>25</code> digits more than is required - though, as the
|
|
time-taken by this method increases exponentially with increasing digits, it is unlikely to be
|
|
viable to calculate over <code>1000</code> digits anyway.
|
|
</p>
|
|
|
|
|
|
|
|
<h5 id="neg">negated<code class='inset'>.neg() <i>⇒ 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>⇒ 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>, rounded to
|
|
<a href='#precision'><code>precision</code></a> significant digits using rounding mode
|
|
<a href='#rounding'><code>rounding</code></a>.
|
|
</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>⇒ 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="round">round<code class='inset'>.round() <i>⇒ 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.set({ rounding: 4 })
|
|
x = 1234.5
|
|
x.round() // '1235'
|
|
|
|
Decimal.rounding = Decimal.ROUND_DOWN
|
|
x.round() // '1234'
|
|
x // '1234.5'</pre>
|
|
|
|
|
|
|
|
<h5 id="sin">sine<code class='inset'>.sin() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the sine of the value in radians of this Decimal,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>-1, 1</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(0.5)
|
|
x.sine() // '0.47942553860420300027'
|
|
y = new Decimal(0.75)
|
|
y.sin() // '0.68163876002333416673'</pre>
|
|
|
|
|
|
|
|
<h5 id="sqrt">squareRoot<code class='inset'>.sqrt() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the square root of this Decimal, rounded to
|
|
<a href='#precision'><code>precision</code></a> significant digits using rounding mode
|
|
<a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
The return value will be correctly rounded, i.e. rounded as if the result was first calculated
|
|
to an infinite number of correct digits before rounding.
|
|
</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="tan">tangent<code class='inset'>.tan() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the tangent of the value in radians of this Decimal,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
Domain: [<code>-Infinity, Infinity</code>]<br />
|
|
Range: [<code>-Infinity, Infinity</code>]
|
|
</p>
|
|
<p>See <a href='#Pi'><code>Pi</code></a>.</p>
|
|
<pre>
|
|
x = new Decimal(0.5)
|
|
x.tangent() // '0.54630248984379051326'
|
|
y = new Decimal(0.75)
|
|
y.tan() // '0.93159645994407246117'</pre>
|
|
|
|
|
|
|
|
<h5 id="mul">times<code class='inset'>.times(x) <i>⇒ 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>,
|
|
rounded to <a href='#precision'><code>precision</code></a> significant digits using rounding
|
|
mode <a href='#rounding'><code>rounding</code></a>.
|
|
</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="toBinary">
|
|
toBinary<code class='inset'>.toBinary([sd [, rm]]) <i>⇒ string</i></code>
|
|
</h5>
|
|
<p>
|
|
<code>sd</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 binary, rounded to <code>sd</code>
|
|
significant digits using rounding mode <code>rm</code>.
|
|
</p>
|
|
<p>
|
|
If <code>sd</code> is defined, the return value will use binary exponential notation.
|
|
</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>
|
|
x = new Decimal(256)
|
|
x.toBinary() // '0b100000000'
|
|
x.toBinary(1) // '0b1p+8'</pre>
|
|
|
|
|
|
|
|
<h5 id="toDP">
|
|
toDecimalPlaces<code class='inset'>.toDP([dp [, rm]]) <i>⇒ 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 <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>⇒ 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>⇒ 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="toFraction">
|
|
toFraction
|
|
<code class='inset'>.toFraction([max_denominator]) <i>⇒ [Decimal, Decimal]</i></code>
|
|
</h5>
|
|
<p>
|
|
<code>max_denominator</code>: <i>number|string|Decimal</i>: <code>1</code> >= integer <
|
|
<code>Infinity</code>
|
|
</p>
|
|
<p>
|
|
Returns an array of two Decimals representing the value of this Decimal as a simple fraction
|
|
with an integer numerator and an integer denominator. The denominator will be a positive
|
|
non-zero value less than or equal to <code>max_denominator</code>.
|
|
</p>
|
|
<p>
|
|
If a maximum denominator is omitted, the denominator will be the lowest value necessary to
|
|
represent the number exactly.
|
|
</p>
|
|
<p>Throws on an invalid <code>max_denominator</code> value.</p>
|
|
<pre>
|
|
x = new Decimal(1.75)
|
|
x.toFraction() // '7, 4'
|
|
|
|
pi = new Decimal('3.14159265358')
|
|
pi.toFraction() // '157079632679,50000000000'
|
|
pi.toFraction(100000) // '312689, 99532'
|
|
pi.toFraction(10000) // '355, 113'
|
|
pi.toFraction(100) // '311, 99'
|
|
pi.toFraction(10) // '22, 7'
|
|
pi.toFraction(1) // '3, 1'</pre>
|
|
|
|
|
|
|
|
<h5 id="toHex">
|
|
toHexadecimal<code class='inset'>.toHex([sd [, rm]]) <i>⇒ string</i></code>
|
|
</h5>
|
|
<p>
|
|
<code>sd</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 hexadecimal, rounded to
|
|
<code>sd</code> significant digits using rounding mode <code>rm</code>.
|
|
</p>
|
|
<p>
|
|
If <code>sd</code> is defined, the return value will use binary exponential notation.
|
|
</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>
|
|
x = new Decimal(256)
|
|
x.toHexadecimal() // '0x100'
|
|
x.toHex(1) // '0x1p+8'</pre>
|
|
|
|
|
|
|
|
<h5 id="toJSON">toJSON<code class='inset'>.toJSON() <i>⇒ string</i></code></h5>
|
|
<p>As <a href='#valueOf'><code>valueOf</code></a>.</p>
|
|
|
|
|
|
|
|
<h5 id="toNearest">
|
|
toNearest<code class='inset'>.toNearest(n [, rm]) <i>⇒ Decimal</i></code>
|
|
</h5>
|
|
<p>
|
|
<code>x</code>: <i>number|string|Decimal</i><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 nearest multiple of <code>x</code> to the value of
|
|
this Decimal.
|
|
</p>
|
|
<p>
|
|
If the value of this Decimal is equidistant from two multiples of <code>x</code>, the rounding
|
|
mode <code>rm</code>, or <a href='#rounding'><code>rounding</code></a> if <code>rm</code> is
|
|
omitted, determines the direction of the nearest.
|
|
</p>
|
|
<p>
|
|
In this context, rounding mode <a href='#rounding'><code>ROUND_HALF_UP</code></a> is
|
|
interpreted the same as rounding mode <a href='#rounding'><code>ROUND_UP</code></a>, and so
|
|
on, i.e. the rounding is either up, down, to ceil, to floor or to even.
|
|
</p>
|
|
<p>
|
|
The return value will always have the same sign as this Decimal, unless either this Decimal
|
|
or <code>x</code> is <code>NaN</code>, in which case the return value will be also be
|
|
<code>NaN</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.39)
|
|
x.toNearest(0.25) // '1.5'
|
|
|
|
y = new Decimal(0.75) // equidistant from 0.5 and 1
|
|
y.toNearest(0.5, 0) // '1' (ROUND_UP)
|
|
y.toNearest(0.5, 1) // '0.5' (ROUND_DOWN)</pre>
|
|
|
|
|
|
|
|
<h5 id="toNumber">toNumber<code class='inset'>.toNumber() <i>⇒ 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
|
|
|
|
z = new Decimal(-0)
|
|
1 / +z // Infinity
|
|
1 / z.toNumber() // -Infinity</pre>
|
|
|
|
|
|
|
|
<h5 id="toOctal">
|
|
toOctal<code class='inset'>.toOctal([sd [, rm]]) <i>⇒ string</i></code>
|
|
</h5>
|
|
<p>
|
|
<code>sd</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 octal, rounded to <code>sd</code>
|
|
significant digits using rounding mode <code>rm</code>.
|
|
</p>
|
|
<p>
|
|
If <code>sd</code> is defined, the return value will use binary exponential notation.
|
|
</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>
|
|
x = new Decimal(256)
|
|
x.toOctal() // '0o400'
|
|
x.toOctal(1) // '0o1p+8'</pre>
|
|
|
|
|
|
|
|
<h5 id="pow">toPower<code class='inset'>.pow(x) <i>⇒ 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>, rounded to <a href='#precision'><code>precision</code></a> significant digits
|
|
using rounding mode <a href='#rounding'><code>rounding</code></a>.
|
|
</p>
|
|
<p>
|
|
The performance of this method degrades exponentially with increasing digits. For
|
|
non-integer exponents in particular, the performance of this method may not be adequate.
|
|
</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>
|
|
<p><i>Is the pow function guaranteed to be correctly rounded?</i></p>
|
|
<p>
|
|
The return value will <i>almost always</i> be correctly rounded, i.e. rounded as if the result
|
|
was first calculated to an infinite number of correct digits before rounding. If a result is
|
|
incorrectly rounded the maximum error will be <code>1</code> <i>ulp</i> (unit in the last
|
|
place).
|
|
</p>
|
|
<p>For non-integer and larger exponents this method uses the formula</p>
|
|
<blockquote><code>x<sup>y</sup> = exp(y*ln(x))</code></blockquote>
|
|
<p>
|
|
As the mathematical return values of the <a href='#exp'><code>exp</code></a> and
|
|
<a href='#ln'><code>ln</code></a> functions are both non-terminating (excluding arguments of
|
|
<code>0</code> or <code>1</code>), the values of the Decimals returned by the functions as
|
|
implemented by this library will necessarily be rounded approximations, which means that there
|
|
can be no guarantee of correct rounding when they are combined in the above formula.
|
|
</p>
|
|
<p>
|
|
The return value may, depending on the rounding mode, be incorrectly rounded only if the first
|
|
<code>15</code> rounding digits are <code>15</code> zeros (and there are non-zero digits
|
|
following at some point), or <code>15</code> nines, or a <code>5</code> or <code>4</code>
|
|
followed by <code>14</code> nines.
|
|
</p>
|
|
<p>
|
|
Therefore, assuming the first <code>15</code> rounding digits are each equally likely to be
|
|
any digit, <code>0-9</code>, the probability of an incorrectly rounded result is less than
|
|
<code>1</code> in <code>250,000,000,000,000</code>.
|
|
</p>
|
|
<p>
|
|
An example of incorrect rounding:
|
|
</p>
|
|
<pre>
|
|
Decimal.set({ precision: 20, rounding: 1 })
|
|
new Decimal(28).pow('6.166675020000903537297764507632802193308677149')
|
|
// 839756321.64088511</pre>
|
|
<p>As the exact mathematical result begins</p>
|
|
<pre>839756321.6408851099999999999999999999999999998969466049426031167...</pre>
|
|
<p>
|
|
and the rounding mode is set to <code><a href='#modes'>ROUND_DOWN</a></code>, the correct
|
|
return value should be
|
|
</p>
|
|
<pre>839756321.64088510999</pre>
|
|
|
|
|
|
|
|
<h5 id="toPrecision">
|
|
toPrecision<code class='inset'>.toPrecision([sd [, rm]]) <i>⇒ 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>⇒ 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 <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.set({ 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>⇒ 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.set({ toExpPos: 5 })
|
|
x.toString() // '7.5e+5'
|
|
|
|
Decimal.set({ precision: 4 })
|
|
y = new Decimal('1.23456789')
|
|
y.toString() // '1.23456789'</pre>
|
|
|
|
|
|
|
|
<h5 id="trunc">truncated<code class='inset'>.trunc() <i>⇒ Decimal</i></code></h5>
|
|
<p>
|
|
Returns a new Decimal whose value is the value of this Decimal truncated to a whole number.
|
|
</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(123.456)
|
|
x.truncated() // '123'
|
|
y = new Decimal(-12.3)
|
|
y.trunc() // '-12'</pre>
|
|
|
|
|
|
|
|
<h5 id="valueOf">valueOf<code class='inset'>.valueOf() <i>⇒ string</i></code></h5>
|
|
<p>As <a href='#toString'><code>toString</code></a>, but zero is signed.</p>
|
|
<pre>
|
|
x = new Decimal(-0)
|
|
x.valueOf() // '-0'</pre>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<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>, or <code>null</code></td>
|
|
</tr>
|
|
<tr>
|
|
<td class='centre' id='exponent'><b>e</b></td>
|
|
<td>exponent</td>
|
|
<td><i>number</i></td>
|
|
<td>Integer, <code>-9e15</code> to <code>9e15</code> inclusive, or <code>NaN</code></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>1</code>, or <code>NaN</code></td>
|
|
</tr>
|
|
</table>
|
|
<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="zero-nan-infinity">Zero, NaN and Infinity</h4>
|
|
<p>
|
|
The table below shows how <code>±0</code>, <code>NaN</code> and
|
|
<code>±Infinity</code> are stored.
|
|
</p>
|
|
<table>
|
|
<tr>
|
|
<th> </th>
|
|
<th>±0</th>
|
|
<th>NaN</th>
|
|
<th>±Infinity</th>
|
|
</tr>
|
|
<tr>
|
|
<td><b> d </b></td>
|
|
<td><code>[0]</code></td>
|
|
<td><code>null</code></td>
|
|
<td><code>null</code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><b> e </b></td>
|
|
<td><code>0</code></td>
|
|
<td><code>NaN</code></td>
|
|
<td><code>NaN</code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><b> s </b></td>
|
|
<td><code>±1</code></td>
|
|
<td><code>NaN</code></td>
|
|
<td><code>±1</code></td>
|
|
</tr>
|
|
</table>
|
|
<pre>
|
|
x = new Number(-0) // 0
|
|
1 / x == -Infinity // true
|
|
|
|
y = new Decimal(-0)
|
|
y.d // '0' ( [0].toString() )
|
|
y.e // 0
|
|
y.s // -1
|
|
y.toString() // '0'
|
|
y.valueOf() // '-0'</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>
|
|
|
|
|
|
|
|
<h4 id='Pi'>Pi</h4>
|
|
<p>
|
|
The maximum precision of the trigonometric methods is dependent on the internal value of the
|
|
constant pi, which is defined as the string <code>PI</code> near the top of the source file.
|
|
</p>
|
|
<p>
|
|
It has a precision of <code>1025</code> digits, meaning that the trigonometric methods
|
|
can accurately calculate up to at least <code>1000</code> digits.
|
|
</p>
|
|
<p>
|
|
If greater precision is required then the value of <code>PI</code> will need to be extended to
|
|
about <code>25</code> digits more than the precision required.
|
|
</p>
|
|
<p>The value can also be shortened to reduce the size of the source file.</p>
|
|
<p>To get the value of pi:</p>
|
|
<pre>
|
|
pi = Decimal.acos(-1)</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>
|
|
|
|
<script>
|
|
/* decimal.js v7.1.1 https://github.com/MikeMcl/decimal.js/LICENCE */
|
|
!function(n){"use strict";function e(n){var e,i,t,r=n.length-1,s="",o=n[0];if(r>0){for(s+=o,e=1;r>e;e++)t=n[e]+"",i=Rn-t.length,i&&(s+=d(i)),s+=t;o=n[e],t=o+"",i=Rn-t.length,i&&(s+=d(i))}else if(0===o)return"0";for(;o%10===0;)o/=10;return s+o}function i(n,e,i){if(n!==~~n||e>n||n>i)throw Error(En+n)}function t(n,e,i,t){var r,s,o,u;for(s=n[0];s>=10;s/=10)--e;return--e<0?(e+=Rn,r=0):(r=Math.ceil((e+1)/Rn),e%=Rn),s=On(10,Rn-e),u=n[r]%s|0,null==t?3>e?(0==e?u=u/100|0:1==e&&(u=u/10|0),o=4>i&&99999==u||i>3&&49999==u||5e4==u||0==u):o=(4>i&&u+1==s||i>3&&u+1==s/2)&&(n[r+1]/s/100|0)==On(10,e-2)-1||(u==s/2||0==u)&&0==(n[r+1]/s/100|0):4>e?(0==e?u=u/1e3|0:1==e?u=u/100|0:2==e&&(u=u/10|0),o=(t||4>i)&&9999==u||!t&&i>3&&4999==u):o=((t||4>i)&&u+1==s||!t&&i>3&&u+1==s/2)&&(n[r+1]/s/1e3|0)==On(10,e-3)-1,o}function r(n,e,i){for(var t,r,s=[0],o=0,u=n.length;u>o;){for(r=s.length;r--;)s[r]*=e;for(s[0]+=wn.indexOf(n.charAt(o++)),t=0;t<s.length;t++)s[t]>i-1&&(void 0===s[t+1]&&(s[t+1]=0),s[t+1]+=s[t]/i|0,s[t]%=i)}return s.reverse()}function s(n,e){var i,t,r=e.d.length;32>r?(i=Math.ceil(r/3),t=Math.pow(4,-i).toString()):(i=16,t="2.3283064365386962890625e-10"),n.precision+=i,e=E(n,1,e.times(t),new n(1));for(var s=i;s--;){var o=e.times(e);e=o.times(o).minus(o).times(8).plus(1)}return n.precision-=i,e}function o(n,e,i,t){var r,s,o,u,c,f,a,h,d,l=n.constructor;n:if(null!=e){if(h=n.d,!h)return n;for(r=1,u=h[0];u>=10;u/=10)r++;if(s=e-r,0>s)s+=Rn,o=e,a=h[d=0],c=a/On(10,r-o-1)%10|0;else if(d=Math.ceil((s+1)/Rn),u=h.length,d>=u){if(!t)break n;for(;u++<=d;)h.push(0);a=c=0,r=1,s%=Rn,o=s-Rn+1}else{for(a=u=h[d],r=1;u>=10;u/=10)r++;s%=Rn,o=s-Rn+r,c=0>o?0:a/On(10,r-o-1)%10|0}if(t=t||0>e||void 0!==h[d+1]||(0>o?a:a%On(10,r-o-1)),f=4>i?(c||t)&&(0==i||i==(n.s<0?3:2)):c>5||5==c&&(4==i||t||6==i&&(s>0?o>0?a/On(10,r-o):0:h[d-1])%10&1||i==(n.s<0?8:7)),1>e||!h[0])return h.length=0,f?(e-=n.e+1,h[0]=On(10,(Rn-e%Rn)%Rn),n.e=-e||0):h[0]=n.e=0,n;if(0==s?(h.length=d,u=1,d--):(h.length=d+1,u=On(10,Rn-s),h[d]=o>0?(a/On(10,r-o)%On(10,o)|0)*u:0),f)for(;;){if(0==d){for(s=1,o=h[0];o>=10;o/=10)s++;for(o=h[0]+=u,u=1;o>=10;o/=10)u++;s!=u&&(n.e++,h[0]==Pn&&(h[0]=1));break}if(h[d]+=u,h[d]!=Pn)break;h[d--]=0,u=1}for(s=h.length;0===h[--s];)h.pop()}return bn&&(n.e>l.maxE?(n.d=null,n.e=NaN):n.e<l.minE&&(n.e=0,n.d=[0])),n}function u(n,i,t){if(!n.isFinite())return v(n);var r,s=n.e,o=e(n.d),u=o.length;return i?(t&&(r=t-u)>0?o=o.charAt(0)+"."+o.slice(1)+d(r):u>1&&(o=o.charAt(0)+"."+o.slice(1)),o=o+(n.e<0?"e":"e+")+n.e):0>s?(o="0."+d(-s-1)+o,t&&(r=t-u)>0&&(o+=d(r))):s>=u?(o+=d(s+1-u),t&&(r=t-s-1)>0&&(o=o+"."+d(r))):((r=s+1)<u&&(o=o.slice(0,r)+"."+o.slice(r)),t&&(r=t-u)>0&&(s+1===u&&(o+="."),o+=d(r))),o}function c(n,e){var i=n[0];for(e*=Rn;i>=10;i/=10)e++;return e}function f(n,e,i){if(e>Un)throw bn=!0,i&&(n.precision=i),Error(Mn);return o(new n(mn),e,1,!0)}function a(n,e,i){if(e>_n)throw Error(Mn);return o(new n(vn),e,i,!0)}function h(n){var e=n.length-1,i=e*Rn+1;if(e=n[e]){for(;e%10==0;e/=10)i--;for(e=n[0];e>=10;e/=10)i++}return i}function d(n){for(var e="";n--;)e+="0";return e}function l(n,e,i,t){var r,s=new n(1),o=Math.ceil(t/Rn+4);for(bn=!1;;){if(i%2&&(s=s.times(e),q(s.d,o)&&(r=!0)),i=qn(i/2),0===i){i=s.d.length-1,r&&0===s.d[i]&&++s.d[i];break}e=e.times(e),q(e.d,o)}return bn=!0,s}function p(n){return 1&n.d[n.d.length-1]}function g(n,e,i){for(var t,r=new n(e[0]),s=0;++s<e.length;){if(t=new n(e[s]),!t.s){r=t;break}r[i](t)&&(r=t)}return r}function w(n,i){var r,s,u,c,f,a,h,d=0,l=0,p=0,g=n.constructor,w=g.rounding,m=g.precision;if(!n.d||!n.d[0]||n.e>17)return new g(n.d?n.d[0]?n.s<0?0:1/0:1:n.s?n.s<0?0:n:NaN);for(null==i?(bn=!1,h=m):h=i,a=new g(.03125);n.e>-2;)n=n.times(a),p+=5;for(s=Math.log(On(2,p))/Math.LN10*2+5|0,h+=s,r=c=f=new g(1),g.precision=h;;){if(c=o(c.times(n),h,1),r=r.times(++l),a=f.plus(Sn(c,r,h,1)),e(a.d).slice(0,h)===e(f.d).slice(0,h)){for(u=p;u--;)f=o(f.times(f),h,1);if(null!=i)return g.precision=m,f;if(!(3>d&&t(f.d,h-s,w,d)))return o(f,g.precision=m,w,bn=!0);g.precision=h+=10,r=c=a=new g(1),l=0,d++}f=a}}function m(n,i){var r,s,u,c,a,h,d,l,p,g,w,v=1,N=10,b=n,x=b.d,E=b.constructor,M=E.rounding,y=E.precision;if(b.s<0||!x||!x[0]||!b.e&&1==x[0]&&1==x.length)return new E(x&&!x[0]?-1/0:1!=b.s?NaN:x?0:b);if(null==i?(bn=!1,p=y):p=i,E.precision=p+=N,r=e(x),s=r.charAt(0),!(Math.abs(c=b.e)<15e14))return l=f(E,p+2,y).times(c+""),b=m(new E(s+"."+r.slice(1)),p-N).plus(l),E.precision=y,null==i?o(b,y,M,bn=!0):b;for(;7>s&&1!=s||1==s&&r.charAt(1)>3;)b=b.times(n),r=e(b.d),s=r.charAt(0),v++;for(c=b.e,s>1?(b=new E("0."+r),c++):b=new E(s+"."+r.slice(1)),g=b,d=a=b=Sn(b.minus(1),b.plus(1),p,1),w=o(b.times(b),p,1),u=3;;){if(a=o(a.times(w),p,1),l=d.plus(Sn(a,new E(u),p,1)),e(l.d).slice(0,p)===e(d.d).slice(0,p)){if(d=d.times(2),0!==c&&(d=d.plus(f(E,p+2,y).times(c+""))),d=Sn(d,new E(v),p,1),null!=i)return E.precision=y,d;if(!t(d.d,p-N,M,h))return o(d,E.precision=y,M,bn=!0);E.precision=p+=N,l=a=b=Sn(g.minus(1),g.plus(1),p,1),w=o(b.times(b),p,1),u=h=1}d=l,u+=2}}function v(n){return String(n.s*n.s/0)}function N(n,e){var i,t,r;for((i=e.indexOf("."))>-1&&(e=e.replace(".","")),(t=e.search(/e/i))>0?(0>i&&(i=t),i+=+e.slice(t+1),e=e.substring(0,t)):0>i&&(i=e.length),t=0;48===e.charCodeAt(t);t++);for(r=e.length;48===e.charCodeAt(r-1);--r);if(e=e.slice(t,r)){if(r-=t,n.e=i=i-t-1,n.d=[],t=(i+1)%Rn,0>i&&(t+=Rn),r>t){for(t&&n.d.push(+e.slice(0,t)),r-=Rn;r>t;)n.d.push(+e.slice(t,t+=Rn));e=e.slice(t),t=Rn-e.length}else t-=r;for(;t--;)e+="0";n.d.push(+e),bn&&(n.e>n.constructor.maxE?(n.d=null,n.e=NaN):n.e<n.constructor.minE&&(n.e=0,n.d=[0]))}else n.e=0,n.d=[0];return n}function b(n,e){var i,t,s,o,u,f,a,h,d;if("Infinity"===e||"NaN"===e)return+e||(n.s=NaN),n.e=NaN,n.d=null,n;if(An.test(e))i=16,e=e.toLowerCase();else if(Fn.test(e))i=2;else{if(!Dn.test(e))throw Error(En+e);i=8}for(o=e.search(/p/i),o>0?(a=+e.slice(o+1),e=e.substring(2,o)):e=e.slice(2),o=e.indexOf("."),u=o>=0,t=n.constructor,u&&(e=e.replace(".",""),f=e.length,o=f-o,s=l(t,new t(i),o,2*o)),h=r(e,i,Pn),d=h.length-1,o=d;0===h[o];--o)h.pop();return 0>o?new t(0*n.s):(n.e=c(h,d),n.d=h,bn=!1,u&&(n=Sn(n,s,4*f)),a&&(n=n.times(Math.abs(a)<54?Math.pow(2,a):Nn.pow(2,a))),bn=!0,n)}function x(n,e){var i,t=e.d.length;if(3>t)return E(n,2,e,e);i=1.4*Math.sqrt(t),i=i>16?16:0|i,e=e.times(Math.pow(5,-i)),e=E(n,2,e,e);for(var r,s=new n(5),o=new n(16),u=new n(20);i--;)r=e.times(e),e=e.times(s.plus(r.times(o.times(r).minus(u))));return e}function E(n,e,i,t,r){var s,o,u,c,f=1,a=n.precision,h=Math.ceil(a/Rn);for(bn=!1,c=i.times(i),u=new n(t);;){if(o=Sn(u.times(c),new n(e++*e++),a,1),u=r?t.plus(o):t.minus(o),t=Sn(o.times(c),new n(e++*e++),a,1),o=u.plus(t),void 0!==o.d[h]){for(s=h;o.d[s]===u.d[s]&&s--;);if(-1==s)break}s=u,u=t,t=o,o=s,f++}return bn=!0,o.d.length=h+1,o}function M(n,e){var i,t=e.s<0,r=a(n,n.precision,1),s=r.times(.5);if(e=e.abs(),e.lte(s))return ln=t?4:1,e;if(i=e.divToInt(r),i.isZero())ln=t?3:2;else{if(e=e.minus(i.times(r)),e.lte(s))return ln=p(i)?t?2:3:t?4:1,e;ln=p(i)?t?1:4:t?3:2}return e.minus(r).abs()}function y(n,e,t,s){var o,c,f,a,h,d,l,p,g,w=n.constructor,m=void 0!==t;if(m?(i(t,1,gn),void 0===s?s=w.rounding:i(s,0,8)):(t=w.precision,s=w.rounding),n.isFinite()){for(l=u(n),f=l.indexOf("."),m?(o=2,16==e?t=4*t-3:8==e&&(t=3*t-2)):o=e,f>=0&&(l=l.replace(".",""),g=new w(1),g.e=l.length-f,g.d=r(u(g),10,o),g.e=g.d.length),p=r(l,10,o),c=h=p.length;0==p[--h];)p.pop();if(p[0]){if(0>f?c--:(n=new w(n),n.d=p,n.e=c,n=Sn(n,g,t,s,0,o),p=n.d,c=n.e,d=hn),f=p[t],a=o/2,d=d||void 0!==p[t+1],d=4>s?(void 0!==f||d)&&(0===s||s===(n.s<0?3:2)):f>a||f===a&&(4===s||d||6===s&&1&p[t-1]||s===(n.s<0?8:7)),p.length=t,d)for(;++p[--t]>o-1;)p[t]=0,t||(++c,p.unshift(1));for(h=p.length;!p[h-1];--h);for(f=0,l="";h>f;f++)l+=wn.charAt(p[f]);if(m){if(h>1)if(16==e||8==e){for(f=16==e?4:3,--h;h%f;h++)l+="0";for(p=r(l,o,e),h=p.length;!p[h-1];--h);for(f=1,l="1.";h>f;f++)l+=wn.charAt(p[f])}else l=l.charAt(0)+"."+l.slice(1);l=l+(0>c?"p":"p+")+c}else if(0>c){for(;++c;)l="0"+l;l="0."+l}else if(++c>h)for(c-=h;c--;)l+="0";else h>c&&(l=l.slice(0,c)+"."+l.slice(c))}else l=m?"0p+0":"0";l=(16==e?"0x":2==e?"0b":8==e?"0o":"")+l}else l=v(n);return n.s<0?"-"+l:l}function q(n,e){return n.length>e?(n.length=e,!0):void 0}function O(n){return new this(n).abs()}function F(n){return new this(n).acos()}function A(n){return new this(n).acosh()}function D(n,e){return new this(n).plus(e)}function Z(n){return new this(n).asin()}function P(n){return new this(n).asinh()}function R(n){return new this(n).atan()}function L(n){return new this(n).atanh()}function U(n,e){n=new this(n),e=new this(e);var i,t=this.precision,r=this.rounding,s=t+4;return n.s&&e.s?n.d||e.d?!e.d||n.isZero()?(i=e.s<0?a(this,t,r):new this(0),i.s=n.s):!n.d||e.isZero()?(i=a(this,s,1).times(.5),i.s=n.s):e.s<0?(this.precision=s,this.rounding=1,i=this.atan(Sn(n,e,s,1)),e=a(this,s,1),this.precision=t,this.rounding=r,i=n.s<0?i.minus(e):i.plus(e)):i=this.atan(Sn(n,e,s,1)):(i=a(this,s,1).times(e.s>0?.25:.75),i.s=n.s):i=new this(NaN),i}function _(n){return new this(n).cbrt()}function k(n){return o(n=new this(n),n.e+1,2)}function S(n){if(!n||"object"!=typeof n)throw Error(xn+"Object expected");var e,i,t,r=["precision",1,gn,"rounding",0,8,"toExpNeg",-pn,0,"toExpPos",0,pn,"maxE",0,pn,"minE",-pn,0,"modulo",0,9];for(e=0;e<r.length;e+=3)if(void 0!==(t=n[i=r[e]])){if(!(qn(t)===t&&t>=r[e+1]&&t<=r[e+2]))throw Error(En+i+": "+t);this[i]=t}if(void 0!==(t=n[i="crypto"])){if(t!==!0&&t!==!1&&0!==t&&1!==t)throw Error(En+i+": "+t);if(t){if("undefined"==typeof crypto||!crypto||!crypto.getRandomValues&&!crypto.randomBytes)throw Error(yn);this[i]=!0}else this[i]=!1}return this}function T(n){return new this(n).cos()}function C(n){return new this(n).cosh()}function I(n){function e(n){var i,t,r,s=this;if(!(s instanceof e))return new e(n);if(s.constructor=e,n instanceof e)return s.s=n.s,s.e=n.e,void(s.d=(n=n.d)?n.slice():n);if(r=typeof n,"number"===r){if(0===n)return s.s=0>1/n?-1:1,s.e=0,void(s.d=[0]);if(0>n?(n=-n,s.s=-1):s.s=1,n===~~n&&1e7>n){for(i=0,t=n;t>=10;t/=10)i++;return s.e=i,void(s.d=[n])}return 0*n!==0?(n||(s.s=NaN),s.e=NaN,void(s.d=null)):N(s,n.toString())}if("string"!==r)throw Error(En+n);return 45===n.charCodeAt(0)?(n=n.slice(1),s.s=-1):s.s=1,Zn.test(n)?N(s,n):b(s,n)}var i,t,r;if(e.prototype=kn,e.ROUND_UP=0,e.ROUND_DOWN=1,e.ROUND_CEIL=2,e.ROUND_FLOOR=3,e.ROUND_HALF_UP=4,e.ROUND_HALF_DOWN=5,e.ROUND_HALF_EVEN=6,e.ROUND_HALF_CEIL=7,e.ROUND_HALF_FLOOR=8,e.EUCLID=9,e.config=e.set=S,e.clone=I,e.abs=O,e.acos=F,e.acosh=A,e.add=D,e.asin=Z,e.asinh=P,e.atan=R,e.atanh=L,e.atan2=U,e.cbrt=_,e.ceil=k,e.cos=T,e.cosh=C,e.div=H,e.exp=B,e.floor=V,e.hypot=$,e.ln=j,e.log=W,e.log10=z,e.log2=J,e.max=G,e.min=K,e.mod=Q,e.mul=X,e.pow=Y,e.random=nn,e.round=en,e.sign=tn,e.sin=rn,e.sinh=sn,e.sqrt=on,e.sub=un,e.tan=cn,e.tanh=fn,e.trunc=an,void 0===n&&(n={}),n)for(r=["precision","rounding","toExpNeg","toExpPos","maxE","minE","modulo","crypto"],i=0;i<r.length;)n.hasOwnProperty(t=r[i++])||(n[t]=this[t]);return e.config(n),e}function H(n,e){return new this(n).div(e)}function B(n){return new this(n).exp()}function V(n){return o(n=new this(n),n.e+1,3)}function $(){var n,e,i=new this(0);for(bn=!1,n=0;n<arguments.length;)if(e=new this(arguments[n++]),e.d)i.d&&(i=i.plus(e.times(e)));else{if(e.s)return bn=!0,new this(1/0);i=e}return bn=!0,i.sqrt()}function j(n){return new this(n).ln()}function W(n,e){return new this(n).log(e)}function J(n){return new this(n).log(2)}function z(n){return new this(n).log(10)}function G(){return g(this,arguments,"lt")}function K(){return g(this,arguments,"gt")}function Q(n,e){return new this(n).mod(e)}function X(n,e){return new this(n).mul(e)}function Y(n,e){return new this(n).pow(e)}function nn(n){var e,t,r,s,o=0,u=new this(1),c=[];if(void 0===n?n=this.precision:i(n,1,gn),r=Math.ceil(n/Rn),this.crypto)if(crypto.getRandomValues)for(e=crypto.getRandomValues(new Uint32Array(r));r>o;)s=e[o],s>=429e7?e[o]=crypto.getRandomValues(new Uint32Array(1))[0]:c[o++]=s%1e7;else{if(!crypto.randomBytes)throw Error(yn);for(e=crypto.randomBytes(r*=4);r>o;)s=e[o]+(e[o+1]<<8)+(e[o+2]<<16)+((127&e[o+3])<<24),s>=214e7?crypto.randomBytes(4).copy(e,o):(c.push(s%1e7),o+=4);o=r/4}else for(;r>o;)c[o++]=1e7*Math.random()|0;for(r=c[--o],n%=Rn,r&&n&&(s=On(10,Rn-n),c[o]=(r/s|0)*s);0===c[o];o--)c.pop();if(0>o)t=0,c=[0];else{for(t=-1;0===c[0];t-=Rn)c.shift();for(r=1,s=c[0];s>=10;s/=10)r++;Rn>r&&(t-=Rn-r)}return u.e=t,u.d=c,u}function en(n){return o(n=new this(n),n.e+1,this.rounding)}function tn(n){return n=new this(n),n.d?n.d[0]?n.s:0*n.s:n.s||NaN}function rn(n){return new this(n).sin()}function sn(n){return new this(n).sinh()}function on(n){return new this(n).sqrt()}function un(n,e){return new this(n).sub(e)}function cn(n){return new this(n).tan()}function fn(n){return new this(n).tanh()}function an(n){return o(n=new this(n),n.e+1,1)}var hn,dn,ln,pn=9e15,gn=1e9,wn="0123456789abcdef",mn="2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058",vn="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789",Nn={precision:20,rounding:4,modulo:1,toExpNeg:-7,toExpPos:21,minE:-pn,maxE:pn,crypto:!1},bn=!0,xn="[DecimalError] ",En=xn+"Invalid argument: ",Mn=xn+"Precision limit exceeded",yn=xn+"crypto unavailable",qn=Math.floor,On=Math.pow,Fn=/^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i,An=/^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i,Dn=/^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,Zn=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,Pn=1e7,Rn=7,Ln=9007199254740991,Un=mn.length-1,_n=vn.length-1,kn={};kn.absoluteValue=kn.abs=function(){var n=new this.constructor(this);return n.s<0&&(n.s=1),o(n)},kn.ceil=function(){return o(new this.constructor(this),this.e+1,2)},kn.comparedTo=kn.cmp=function(n){var e,i,t,r,s=this,o=s.d,u=(n=new s.constructor(n)).d,c=s.s,f=n.s;if(!o||!u)return c&&f?c!==f?c:o===u?0:!o^0>c?1:-1:NaN;if(!o[0]||!u[0])return o[0]?c:u[0]?-f:0;if(c!==f)return c;if(s.e!==n.e)return s.e>n.e^0>c?1:-1;for(t=o.length,r=u.length,e=0,i=r>t?t:r;i>e;++e)if(o[e]!==u[e])return o[e]>u[e]^0>c?1:-1;return t===r?0:t>r^0>c?1:-1},kn.cosine=kn.cos=function(){var n,e,i=this,t=i.constructor;return i.d?i.d[0]?(n=t.precision,e=t.rounding,t.precision=n+Math.max(i.e,i.sd())+Rn,t.rounding=1,i=s(t,M(t,i)),t.precision=n,t.rounding=e,o(2==ln||3==ln?i.neg():i,n,e,!0)):new t(1):new t(NaN)},kn.cubeRoot=kn.cbrt=function(){var n,i,t,r,s,u,c,f,a,h,d=this,l=d.constructor;if(!d.isFinite()||d.isZero())return new l(d);for(bn=!1,u=d.s*Math.pow(d.s*d,1/3),u&&Math.abs(u)!=1/0?r=new l(u.toString()):(t=e(d.d),n=d.e,(u=(n-t.length+1)%3)&&(t+=1==u||-2==u?"0":"00"),u=Math.pow(t,1/3),n=qn((n+1)/3)-(n%3==(0>n?-1:2)),u==1/0?t="5e"+n:(t=u.toExponential(),t=t.slice(0,t.indexOf("e")+1)+n),r=new l(t),r.s=d.s),c=(n=l.precision)+3;;)if(f=r,a=f.times(f).times(f),h=a.plus(d),r=Sn(h.plus(d).times(f),h.plus(a),c+2,1),e(f.d).slice(0,c)===(t=e(r.d)).slice(0,c)){if(t=t.slice(c-3,c+1),"9999"!=t&&(s||"4999"!=t)){(!+t||!+t.slice(1)&&"5"==t.charAt(0))&&(o(r,n+1,1),i=!r.times(r).times(r).eq(d));break}if(!s&&(o(f,n+1,0),f.times(f).times(f).eq(d))){r=f;break}c+=4,s=1}return bn=!0,o(r,n,l.rounding,i)},kn.decimalPlaces=kn.dp=function(){var n,e=this.d,i=NaN;if(e){if(n=e.length-1,i=(n-qn(this.e/Rn))*Rn,n=e[n])for(;n%10==0;n/=10)i--;0>i&&(i=0)}return i},kn.dividedBy=kn.div=function(n){return Sn(this,new this.constructor(n))},kn.dividedToIntegerBy=kn.divToInt=function(n){var e=this,i=e.constructor;return o(Sn(e,new i(n),0,1,1),i.precision,i.rounding)},kn.equals=kn.eq=function(n){return 0===this.cmp(n)},kn.floor=function(){return o(new this.constructor(this),this.e+1,3)},kn.greaterThan=kn.gt=function(n){return this.cmp(n)>0},kn.greaterThanOrEqualTo=kn.gte=function(n){var e=this.cmp(n);return 1==e||0===e},kn.hyperbolicCosine=kn.cosh=function(){var n,e,i,t,r,s=this,u=s.constructor,c=new u(1);if(!s.isFinite())return new u(s.s?1/0:NaN);if(s.isZero())return c;i=u.precision,t=u.rounding,u.precision=i+Math.max(s.e,s.sd())+4,u.rounding=1,r=s.d.length,32>r?(n=Math.ceil(r/3),e=Math.pow(4,-n).toString()):(n=16,e="2.3283064365386962890625e-10"),s=E(u,1,s.times(e),new u(1),!0);for(var f,a=n,h=new u(8);a--;)f=s.times(s),s=c.minus(f.times(h.minus(f.times(h))));return o(s,u.precision=i,u.rounding=t,!0)},kn.hyperbolicSine=kn.sinh=function(){var n,e,i,t,r=this,s=r.constructor;if(!r.isFinite()||r.isZero())return new s(r);if(e=s.precision,i=s.rounding,s.precision=e+Math.max(r.e,r.sd())+4,s.rounding=1,t=r.d.length,3>t)r=E(s,2,r,r,!0);else{n=1.4*Math.sqrt(t),n=n>16?16:0|n,r=r.times(Math.pow(5,-n)),r=E(s,2,r,r,!0);for(var u,c=new s(5),f=new s(16),a=new s(20);n--;)u=r.times(r),r=r.times(c.plus(u.times(f.times(u).plus(a))))}return s.precision=e,s.rounding=i,o(r,e,i,!0)},kn.hyperbolicTangent=kn.tanh=function(){var n,e,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(n=t.precision,e=t.rounding,t.precision=n+7,t.rounding=1,Sn(i.sinh(),i.cosh(),t.precision=n,t.rounding=e)):new t(i.s)},kn.inverseCosine=kn.acos=function(){var n,e=this,i=e.constructor,t=e.abs().cmp(1),r=i.precision,s=i.rounding;return-1!==t?0===t?e.isNeg()?a(i,r,s):new i(0):new i(NaN):e.isZero()?a(i,r+4,s).times(.5):(i.precision=r+6,i.rounding=1,e=e.asin(),n=a(i,r+4,s).times(.5),i.precision=r,i.rounding=s,n.minus(e))},kn.inverseHyperbolicCosine=kn.acosh=function(){var n,e,i=this,t=i.constructor;return i.lte(1)?new t(i.eq(1)?0:NaN):i.isFinite()?(n=t.precision,e=t.rounding,t.precision=n+Math.max(Math.abs(i.e),i.sd())+4,t.rounding=1,bn=!1,i=i.times(i).minus(1).sqrt().plus(i),bn=!0,t.precision=n,t.rounding=e,i.ln()):new t(i)},kn.inverseHyperbolicSine=kn.asinh=function(){var n,e,i=this,t=i.constructor;return!i.isFinite()||i.isZero()?new t(i):(n=t.precision,e=t.rounding,t.precision=n+2*Math.max(Math.abs(i.e),i.sd())+6,t.rounding=1,bn=!1,i=i.times(i).plus(1).sqrt().plus(i),bn=!0,t.precision=n,t.rounding=e,i.ln())},kn.inverseHyperbolicTangent=kn.atanh=function(){var n,e,i,t,r=this,s=r.constructor;return r.isFinite()?r.e>=0?new s(r.abs().eq(1)?r.s/0:r.isZero()?r:NaN):(n=s.precision,e=s.rounding,t=r.sd(),Math.max(t,n)<2*-r.e-1?o(new s(r),n,e,!0):(s.precision=i=t-r.e,r=Sn(r.plus(1),new s(1).minus(r),i+n,1),s.precision=n+4,s.rounding=1,r=r.ln(),s.precision=n,s.rounding=e,r.times(.5))):new s(NaN)},kn.inverseSine=kn.asin=function(){var n,e,i,t,r=this,s=r.constructor;return r.isZero()?new s(r):(e=r.abs().cmp(1),i=s.precision,t=s.rounding,-1!==e?0===e?(n=a(s,i+4,t).times(.5),n.s=r.s,n):new s(NaN):(s.precision=i+6,s.rounding=1,r=r.div(new s(1).minus(r.times(r)).sqrt().plus(1)).atan(),s.precision=i,s.rounding=t,r.times(2)))},kn.inverseTangent=kn.atan=function(){var n,e,i,t,r,s,u,c,f,h=this,d=h.constructor,l=d.precision,p=d.rounding;if(h.isFinite()){if(h.isZero())return new d(h);if(h.abs().eq(1)&&_n>=l+4)return u=a(d,l+4,p).times(.25),u.s=h.s,u}else{if(!h.s)return new d(NaN);if(_n>=l+4)return u=a(d,l+4,p).times(.5),u.s=h.s,u}for(d.precision=c=l+10,d.rounding=1,i=Math.min(28,c/Rn+2|0),n=i;n;--n)h=h.div(h.times(h).plus(1).sqrt().plus(1));for(bn=!1,e=Math.ceil(c/Rn),t=1,f=h.times(h),u=new d(h),r=h;-1!==n;)if(r=r.times(f),s=u.minus(r.div(t+=2)),r=r.times(f),u=s.plus(r.div(t+=2)),void 0!==u.d[e])for(n=e;u.d[n]===s.d[n]&&n--;);return i&&(u=u.times(2<<i-1)),bn=!0,o(u,d.precision=l,d.rounding=p,!0)},kn.isFinite=function(){return!!this.d},kn.isInteger=kn.isInt=function(){return!!this.d&&qn(this.e/Rn)>this.d.length-2},kn.isNaN=function(){return!this.s},kn.isNegative=kn.isNeg=function(){return this.s<0},kn.isPositive=kn.isPos=function(){return this.s>0},kn.isZero=function(){return!!this.d&&0===this.d[0]},kn.lessThan=kn.lt=function(n){return this.cmp(n)<0},kn.lessThanOrEqualTo=kn.lte=function(n){return this.cmp(n)<1},kn.logarithm=kn.log=function(n){var i,r,s,u,c,a,h,d,l=this,p=l.constructor,g=p.precision,w=p.rounding,v=5;if(null==n)n=new p(10),i=!0;else{if(n=new p(n),r=n.d,n.s<0||!r||!r[0]||n.eq(1))return new p(NaN);i=n.eq(10)}if(r=l.d,l.s<0||!r||!r[0]||l.eq(1))return new p(r&&!r[0]?-1/0:1!=l.s?NaN:r?0:1/0);if(i)if(r.length>1)c=!0;else{for(u=r[0];u%10===0;)u/=10;c=1!==u}if(bn=!1,h=g+v,a=m(l,h),s=i?f(p,h+10):m(n,h),d=Sn(a,s,h,1),t(d.d,u=g,w))do if(h+=10,a=m(l,h),s=i?f(p,h+10):m(n,h),d=Sn(a,s,h,1),!c){+e(d.d).slice(u+1,u+15)+1==1e14&&(d=o(d,g+1,0));break}while(t(d.d,u+=10,w));return bn=!0,o(d,g,w)},kn.minus=kn.sub=function(n){var e,i,t,r,s,u,f,a,h,d,l,p,g=this,w=g.constructor;if(n=new w(n),!g.d||!n.d)return g.s&&n.s?g.d?n.s=-n.s:n=new w(n.d||g.s!==n.s?g:NaN):n=new w(NaN),n;if(g.s!=n.s)return n.s=-n.s,g.plus(n);if(h=g.d,p=n.d,f=w.precision,a=w.rounding,!h[0]||!p[0]){if(p[0])n.s=-n.s;else{if(!h[0])return new w(3===a?-0:0);n=new w(g)}return bn?o(n,f,a):n}if(i=qn(n.e/Rn),d=qn(g.e/Rn),h=h.slice(),s=d-i){for(l=0>s,l?(e=h,s=-s,u=p.length):(e=p,i=d,u=h.length),t=Math.max(Math.ceil(f/Rn),u)+2,s>t&&(s=t,e.length=1),e.reverse(),t=s;t--;)e.push(0);e.reverse()}else{for(t=h.length,u=p.length,l=u>t,l&&(u=t),t=0;u>t;t++)if(h[t]!=p[t]){l=h[t]<p[t];break}s=0}for(l&&(e=h,h=p,p=e,n.s=-n.s),u=h.length,t=p.length-u;t>0;--t)h[u++]=0;for(t=p.length;t>s;){if(h[--t]<p[t]){for(r=t;r&&0===h[--r];)h[r]=Pn-1;--h[r],h[t]+=Pn}h[t]-=p[t]}for(;0===h[--u];)h.pop();for(;0===h[0];h.shift())--i;return h[0]?(n.d=h,n.e=c(h,i),bn?o(n,f,a):n):new w(3===a?-0:0)},kn.modulo=kn.mod=function(n){var e,i=this,t=i.constructor;return n=new t(n),!i.d||!n.s||n.d&&!n.d[0]?new t(NaN):!n.d||i.d&&!i.d[0]?o(new t(i),t.precision,t.rounding):(bn=!1,9==t.modulo?(e=Sn(i,n.abs(),0,3,1),e.s*=n.s):e=Sn(i,n,0,t.modulo,1),e=e.times(n),bn=!0,i.minus(e))},kn.naturalExponential=kn.exp=function(){return w(this)},kn.naturalLogarithm=kn.ln=function(){return m(this)},kn.negated=kn.neg=function(){var n=new this.constructor(this);return n.s=-n.s,o(n)},kn.plus=kn.add=function(n){var e,i,t,r,s,u,f,a,h,d,l=this,p=l.constructor;if(n=new p(n),!l.d||!n.d)return l.s&&n.s?l.d||(n=new p(n.d||l.s===n.s?l:NaN)):n=new p(NaN),n;if(l.s!=n.s)return n.s=-n.s,l.minus(n);if(h=l.d,d=n.d,f=p.precision,a=p.rounding,!h[0]||!d[0])return d[0]||(n=new p(l)),bn?o(n,f,a):n;if(s=qn(l.e/Rn),t=qn(n.e/Rn),h=h.slice(),r=s-t){for(0>r?(i=h,r=-r,u=d.length):(i=d,t=s,u=h.length),s=Math.ceil(f/Rn),u=s>u?s+1:u+1,r>u&&(r=u,i.length=1),i.reverse();r--;)i.push(0);i.reverse()}for(u=h.length,r=d.length,0>u-r&&(r=u,i=d,d=h,h=i),e=0;r;)e=(h[--r]=h[r]+d[r]+e)/Pn|0,h[r]%=Pn;for(e&&(h.unshift(e),++t),u=h.length;0==h[--u];)h.pop();return n.d=h,n.e=c(h,t),bn?o(n,f,a):n},kn.precision=kn.sd=function(n){var e,i=this;if(void 0!==n&&n!==!!n&&1!==n&&0!==n)throw Error(En+n);return i.d?(e=h(i.d),n&&i.e+1>e&&(e=i.e+1)):e=NaN,e},kn.round=function(){var n=this,e=n.constructor;return o(new e(n),n.e+1,e.rounding)},kn.sine=kn.sin=function(){var n,e,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(n=t.precision,e=t.rounding,t.precision=n+Math.max(i.e,i.sd())+Rn,t.rounding=1,i=x(t,M(t,i)),t.precision=n,t.rounding=e,o(ln>2?i.neg():i,n,e,!0)):new t(NaN)},kn.squareRoot=kn.sqrt=function(){var n,i,t,r,s,u,c=this,f=c.d,a=c.e,h=c.s,d=c.constructor;if(1!==h||!f||!f[0])return new d(!h||0>h&&(!f||f[0])?NaN:f?c:1/0);for(bn=!1,h=Math.sqrt(+c),0==h||h==1/0?(i=e(f),(i.length+a)%2==0&&(i+="0"),h=Math.sqrt(i),a=qn((a+1)/2)-(0>a||a%2),h==1/0?i="1e"+a:(i=h.toExponential(),i=i.slice(0,i.indexOf("e")+1)+a),r=new d(i)):r=new d(h.toString()),t=(a=d.precision)+3;;)if(u=r,r=u.plus(Sn(c,u,t+2,1)).times(.5),e(u.d).slice(0,t)===(i=e(r.d)).slice(0,t)){if(i=i.slice(t-3,t+1),"9999"!=i&&(s||"4999"!=i)){(!+i||!+i.slice(1)&&"5"==i.charAt(0))&&(o(r,a+1,1),n=!r.times(r).eq(c));break}if(!s&&(o(u,a+1,0),u.times(u).eq(c))){r=u;break}t+=4,s=1}return bn=!0,o(r,a,d.rounding,n)},kn.tangent=kn.tan=function(){var n,e,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(n=t.precision,e=t.rounding,t.precision=n+10,t.rounding=1,i=i.sin(),i.s=1,i=Sn(i,new t(1).minus(i.times(i)).sqrt(),n+10,0),t.precision=n,t.rounding=e,o(2==ln||4==ln?i.neg():i,n,e,!0)):new t(NaN)},kn.times=kn.mul=function(n){var e,i,t,r,s,u,f,a,h,d=this,l=d.constructor,p=d.d,g=(n=new l(n)).d;if(n.s*=d.s,!(p&&p[0]&&g&&g[0]))return new l(!n.s||p&&!p[0]&&!g||g&&!g[0]&&!p?NaN:p&&g?0*n.s:n.s/0);for(i=qn(d.e/Rn)+qn(n.e/Rn),a=p.length,h=g.length,h>a&&(s=p,p=g,g=s,u=a,a=h,h=u),s=[],u=a+h,t=u;t--;)s.push(0);for(t=h;--t>=0;){for(e=0,r=a+t;r>t;)f=s[r]+g[t]*p[r-t-1]+e,s[r--]=f%Pn|0,e=f/Pn|0;s[r]=(s[r]+e)%Pn|0}for(;!s[--u];)s.pop();return e?++i:s.shift(),n.d=s,n.e=c(s,i),bn?o(n,l.precision,l.rounding):n},kn.toBinary=function(n,e){return y(this,2,n,e)},kn.toDecimalPlaces=kn.toDP=function(n,e){var t=this,r=t.constructor;return t=new r(t),void 0===n?t:(i(n,0,gn),void 0===e?e=r.rounding:i(e,0,8),o(t,n+t.e+1,e))},kn.toExponential=function(n,e){var t,r=this,s=r.constructor;return void 0===n?t=u(r,!0):(i(n,0,gn),void 0===e?e=s.rounding:i(e,0,8),r=o(new s(r),n+1,e),t=u(r,!0,n+1)),r.isNeg()&&!r.isZero()?"-"+t:t},kn.toFixed=function(n,e){var t,r,s=this,c=s.constructor;return void 0===n?t=u(s):(i(n,0,gn),void 0===e?e=c.rounding:i(e,0,8),r=o(new c(s),n+s.e+1,e),t=u(r,!1,n+r.e+1)),s.isNeg()&&!s.isZero()?"-"+t:t},kn.toFraction=function(n){var i,t,r,s,o,u,c,f,a,d,l,p,g=this,w=g.d,m=g.constructor;if(!w)return new m(g);if(a=t=new m(1),r=f=new m(0),i=new m(r),o=i.e=h(w)-g.e-1,u=o%Rn,i.d[0]=On(10,0>u?Rn+u:u),null==n)n=o>0?i:a;else{if(c=new m(n),!c.isInt()||c.lt(a))throw Error(En+c);n=c.gt(i)?o>0?i:a:c}for(bn=!1,c=new m(e(w)),d=m.precision,m.precision=o=w.length*Rn*2;l=Sn(c,i,0,1,1),s=t.plus(l.times(r)),1!=s.cmp(n);)t=r,r=s,s=a,a=f.plus(l.times(s)),f=s,s=i,i=c.minus(l.times(s)),c=s;return s=Sn(n.minus(t),r,0,1,1),f=f.plus(s.times(a)),t=t.plus(s.times(r)),f.s=a.s=g.s,p=Sn(a,r,o,1).minus(g).abs().cmp(Sn(f,t,o,1).minus(g).abs())<1?[a,r]:[f,t],m.precision=d,bn=!0,p},kn.toHexadecimal=kn.toHex=function(n,e){return y(this,16,n,e)},kn.toNearest=function(n,e){var t=this,r=t.constructor;if(t=new r(t),null==n){if(!t.d)return t;n=new r(1),e=r.rounding}else{if(n=new r(n),void 0!==e&&i(e,0,8),!t.d)return n.s?t:n;if(!n.d)return n.s&&(n.s=t.s),n}return n.d[0]?(bn=!1,4>e&&(e=[4,5,7,8][e]),t=Sn(t,n,0,e,1).times(n),bn=!0,o(t)):(n.s=t.s,t=n),t},kn.toNumber=function(){return+this},kn.toOctal=function(n,e){return y(this,8,n,e)},kn.toPower=kn.pow=function(n){var i,r,s,u,c,f,a,h=this,d=h.constructor,p=+(n=new d(n));if(!(h.d&&n.d&&h.d[0]&&n.d[0]))return new d(On(+h,p));if(h=new d(h),h.eq(1))return h;if(s=d.precision,c=d.rounding,n.eq(1))return o(h,s,c);if(i=qn(n.e/Rn),r=n.d.length-1,a=i>=r,f=h.s,a){if((r=0>p?-p:p)<=Ln)return u=l(d,h,r,s),n.s<0?new d(1).div(u):o(u,s,c)}else if(0>f)return new d(NaN);return f=0>f&&1&n.d[Math.max(i,r)]?-1:1,r=On(+h,p),i=0!=r&&isFinite(r)?new d(r+"").e:qn(p*(Math.log("0."+e(h.d))/Math.LN10+h.e+1)),i>d.maxE+1||i<d.minE-1?new d(i>0?f/0:0):(bn=!1,d.rounding=h.s=1,r=Math.min(12,(i+"").length),u=w(n.times(m(h,s+r)),s),u=o(u,s+5,1),t(u.d,s,c)&&(i=s+10,u=o(w(n.times(m(h,i+r)),i),i+5,1),+e(u.d).slice(s+1,s+15)+1==1e14&&(u=o(u,s+1,0))),u.s=f,bn=!0,d.rounding=c,o(u,s,c))},kn.toPrecision=function(n,e){var t,r=this,s=r.constructor;return void 0===n?t=u(r,r.e<=s.toExpNeg||r.e>=s.toExpPos):(i(n,1,gn),void 0===e?e=s.rounding:i(e,0,8),r=o(new s(r),n,e),t=u(r,n<=r.e||r.e<=s.toExpNeg,n)),r.isNeg()&&!r.isZero()?"-"+t:t},kn.toSignificantDigits=kn.toSD=function(n,e){var t=this,r=t.constructor;return void 0===n?(n=r.precision,e=r.rounding):(i(n,1,gn),void 0===e?e=r.rounding:i(e,0,8)),o(new r(t),n,e)},kn.toString=function(){var n=this,e=n.constructor,i=u(n,n.e<=e.toExpNeg||n.e>=e.toExpPos);return n.isNeg()&&!n.isZero()?"-"+i:i},kn.truncated=kn.trunc=function(){return o(new this.constructor(this),this.e+1,1)},kn.valueOf=kn.toJSON=function(){var n=this,e=n.constructor,i=u(n,n.e<=e.toExpNeg||n.e>=e.toExpPos);return n.isNeg()?"-"+i:i};var Sn=function(){function n(n,e,i){var t,r=0,s=n.length;for(n=n.slice();s--;)t=n[s]*e+r,n[s]=t%i|0,r=t/i|0;return r&&n.unshift(r),n}function e(n,e,i,t){var r,s;if(i!=t)s=i>t?1:-1;else for(r=s=0;i>r;r++)if(n[r]!=e[r]){s=n[r]>e[r]?1:-1;break}return s}function i(n,e,i,t){for(var r=0;i--;)n[i]-=r,r=n[i]<e[i]?1:0,n[i]=r*t+n[i]-e[i];for(;!n[0]&&n.length>1;)n.shift()}return function(t,r,s,u,c,f){var a,h,d,l,p,g,w,m,v,N,b,x,E,M,y,q,O,F,A,D,Z=t.constructor,P=t.s==r.s?1:-1,R=t.d,L=r.d;if(!(R&&R[0]&&L&&L[0]))return new Z(t.s&&r.s&&(R?!L||R[0]!=L[0]:L)?R&&0==R[0]||!L?0*P:P/0:NaN);for(f?(p=1,h=t.e-r.e):(f=Pn,p=Rn,h=qn(t.e/p)-qn(r.e/p)),A=L.length,O=R.length,v=new Z(P),N=v.d=[],d=0;L[d]==(R[d]||0);d++);if(L[d]>(R[d]||0)&&h--,null==s?(M=s=Z.precision,u=Z.rounding):M=c?s+(t.e-r.e)+1:s,0>M)N.push(1),g=!0;else{if(M=M/p+2|0,d=0,1==A){for(l=0,L=L[0],M++;(O>d||l)&&M--;d++)y=l*f+(R[d]||0),N[d]=y/L|0,l=y%L|0;g=l||O>d}else{for(l=f/(L[0]+1)|0,l>1&&(L=n(L,l,f),R=n(R,l,f),A=L.length,O=R.length),q=A,b=R.slice(0,A),x=b.length;A>x;)b[x++]=0;D=L.slice(),D.unshift(0),F=L[0],L[1]>=f/2&&++F;do l=0,a=e(L,b,A,x),0>a?(E=b[0],A!=x&&(E=E*f+(b[1]||0)),l=E/F|0,l>1?(l>=f&&(l=f-1),w=n(L,l,f),m=w.length,x=b.length,a=e(w,b,m,x),1==a&&(l--,i(w,m>A?D:L,m,f))):(0==l&&(a=l=1),w=L.slice()),m=w.length,x>m&&w.unshift(0),i(b,w,x,f),-1==a&&(x=b.length,a=e(L,b,A,x),1>a&&(l++,i(b,x>A?D:L,x,f))),x=b.length):0===a&&(l++,b=[0]),N[d++]=l,a&&b[0]?b[x++]=R[q]||0:(b=[R[q]],x=1);while((q++<O||void 0!==b[0])&&M--);g=void 0!==b[0]}N[0]||N.shift()}if(1==p)v.e=h,hn=g;else{for(d=1,l=N[0];l>=10;l/=10)d++;v.e=d+h*p-1,o(v,c?s+v.e+1:s,u,g)}return v}}();Nn=I(Nn),mn=new Nn(mn),vn=new Nn(vn),"function"==typeof define&&define.amd?define(function(){return Nn}):"undefined"!=typeof module&&module.exports?module.exports=Nn["default"]=Nn.Decimal=Nn:(n||(n="undefined"!=typeof self&&self&&self.self==self?self:Function("return this")()),dn=n.Decimal,Nn.noConflict=function(){return n.Decimal=dn,Nn},n.Decimal=Nn)}(this);
|
|
</script>
|
|
|
|
</body>
|
|
</html>
|