Code - yjryu/senior_care

<!DOCTYPE HTML> <html> <head> <meta charset="utf-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="Author" content="MMclaughlin"> <title>decimal.js-light API</title> <style> html{font-size:100%} body{background:#fff;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px; line-height:1.65em;min-height:100%;margin:0} body,i{color:#000} .nav{background:#fff;position:fixed;top:0;bottom:0;left:0;width:210px;overflow-y:auto; padding:15px 0 30px 15px} div.container{width:600px;margin:50px 0 50px 240px} p{margin:0 0 1em;width:600px} pre,ul{margin:1em 0} h1,h2,h3,h4,h5{margin:0;padding:1.5em 0 0} h1,h2{padding:.75em 0} h1{font:400 3em Consolas, monaco, monospace;color:#000;margin-bottom:1em} h2{font-size:2.25em;color:#f00} h3{font-size:1.75em;color:#69d2e7} h4{font-size:1.75em;color:#f00;padding-bottom:.75em} h5{font-size:1.2em;margin-bottom:.4em} h6{font-size:1.1em;margin-bottom:0.8em;padding:0.5em 0} dd dt{font-size:1.2em} dt{padding-top:.5em} dd{padding-top:.35em} b{font-weight:700} a,a:visited{color:#f00;text-decoration:none} a:active,a:hover{outline:0;text-decoration:underline} .nav a,.nav b,.nav a:visited{display:block;color:#f00;font-weight:700;margin-top:15px} .nav b{color:#69d2e7;margin-top:20px;cursor:default;width:auto} ul{list-style-type:none;padding:0 0 0 20px} .nav ul{line-height:14px;padding-left:0;margin:5px 0 0} .nav ul a,.nav ul a:visited,span{display:inline;color:#000;font-family:Verdana,Geneva,sans-serif; font-size:11px;font-weight:400;margin:0} .inset{margin-left:20px;font-size:.9em} .nav li{width:auto;margin:0 0 3px} .alias{font-style:italic;margin-left:20px} table{border-collapse:collapse;border-spacing:0;border:2px solid #a7dbd8;margin:1.75em 0;padding:0} td,th{text-align:left;margin:0;padding:2px 5px;border:1px dotted #a7dbd8} th{border-top:2px solid #a7dbd8;border-bottom:2px solid #a7dbd8;color:#f00} code,pre{font-family:Consolas, monaco, monospace;font-weight:400} pre{background:#f5f5f5;white-space:pre-wrap;word-wrap:break-word;border-left:5px solid #a7dbd8; padding:1px 0 1px 15px;margin:1.2em 0} code,.nav-title{color:#f00} .end{margin-bottom:25px} .centre{text-align:center} #modes,#configProps{color:#f00} .spacer{line-height:0px} #faq{margin:3em 0 0} li span{float:right;margin-right:10px;color:#c0c0c0} #js{font:inherit;color:#f00} </style> </head> <body> <div class="nav"> <a class='nav-title' href="#">API</a> <b>CONSTRUCTOR</b> <ul><li><a href="#decimal">Decimal</a></li></ul> <a href="#methods">Methods</a> <ul> <li><a href="#Dclone" >clone</a></li> <li><a href="#Dconfig">config</a></li> </ul> <a href="#constructor-properties">Properties</a> <ul> <li><a href="#precision">precision</a></li> <li><a href="#rounding" >rounding</a></li> <li><a href="#toExpNeg" >toExpNeg</a></li> <li><a href="#toExpPos" >toExpPos</a></li> <li><a href="#ln10" >LN10</a></li> <li class='spacer'> </li> <li><a href="#modes">ROUND_UP</a></li> <li><a href="#modes">ROUND_DOWN</a></li> <li><a href="#modes">ROUND_CEIL</a></li> <li><a href="#modes">ROUND_FLOOR</a></li> <li><a href="#modes">ROUND_HALF_UP</a></li> <li><a href="#modes">ROUND_HALF_DOWN</a></li> <li><a href="#modes">ROUND_HALF_EVEN</a></li> <li><a href="#modes">ROUND_HALF_CEIL</a></li> <li><a href="#modes">ROUND_HALF_FLOOR</a></li> <li><a href="#modes">EUCLID</a></li> </ul> <b> INSTANCE </b> <a href="#prototype-methods">Methods</a> <ul> <li><a href="#abs" >absoluteValue </a><span>abs</span> </li> <li><a href="#cmp" >comparedTo </a><span>cmp</span> </li> <li><a href="#dp" >decimalPlaces </a><span>dp</span> </li> <li><a href="#div" >dividedBy </a><span>div</span> </li> <li><a href="#idiv" >dividedToIntegerBy </a><span>idiv</span> </li> <li><a href="#eq" >equals </a><span>eq</span> </li> <li><a href="#exp" >exponent </a> </li> <li><a href="#gt" >greaterThan </a><span>gt</span> </li> <li><a href="#gte" >greaterThanOrEqualTo </a><span>gte</span> </li> <li><a href="#isint" >isInteger </a><span>isint</span></li> <li><a href="#isneg" >isNegative </a><span>isneg</span></li> <li><a href="#ispos" >isPositive </a><span>ispos</span></li> <li><a href="#isZero" >isZero </a> </li> <li><a href="#lt" >lessThan </a><span>lt</span> </li> <li><a href="#lte" >lessThanOrEqualTo </a><span>lte</span> </li> <li><a href="#log" >logarithm </a><span>log</span> </li> <li><a href="#sub" >minus </a><span>sub</span> </li> <li><a href="#mod" >modulo </a><span>mod</span> </li> <li><a href="#exp" >naturalExponential </a><span>exp</span> </li> <li><a href="#ln" >naturalLogarithm </a><span>ln</span> </li> <li><a href="#neg" >negated </a><span>neg</span> </li> <li><a href="#add" >plus </a><span>add</span> </li> <li><a href="#sd" >precision </a><span>sd</span> </li> <li><a href="#sqrt" >squareRoot </a><span>sqrt</span> </li> <li><a href="#mul" >times </a><span>mul</span> </li> <li><a href="#todp" >toDecimalPlaces </a><span>todp</span> </li> <li><a href="#toExponential">toExponential </a> </li> <li><a href="#toFixed" >toFixed </a> </li> <li><a href="#toInteger" >toInteger </a><span>toint</span></li> <li><a href="#toJSON" >toJSON </a> </li> <li><a href="#toNumber" >toNumber </a> </li> <li><a href="#pow" >toPower </a><span>pow</span> </li> <li><a href="#toPrecision" >toPrecision </a> </li> <li><a href="#tosd" >toSignificantDigits </a><span>tosd</span> </li> <li><a href="#toString" >toString </a> </li> <li><a href="#valueOf" >valueOf </a><span>val</span> </li> </ul> <a href="#instance-properties">Properties</a> <ul> <li><a href="#digits" >d</a><span>digits</span></li> <li><a href="#exponent">e</a><span>exponent</span></li> <li><a href="#sign" >s</a><span>sign</span></li> </ul> <a href="#Errors">Errors</a> <a class='end' href="#faq">FAQ</a> </div> <div class="container"> <h1>decimal<span id='js'>.js</span>-light</h1> <p> The light version of <a href='https://github.com/MikeMcl/decimal.js/'>decimal.js</a>, an arbitrary-precision Decimal type for JavaScript. </p> <p><a href='https://github.com/MikeMcl/decimal.js-light'>Hosted on GitHub</a>.</p> <h2>API</h2> <p> See the <a href='https://github.com/MikeMcl/decimal.js'>README</a> on GitHub for a quick-start introduction. </p> <p> In all examples below, <code>var</code> and semicolons are not shown, and if a commented-out value is in quotes it means <code>toString</code> has been called on the preceding expression. </p><br /> <p> When the library is loaded, it defines a single function object, <a href='#decimal'><code>Decimal</code></a>, the constructor of Decimal instances. </p> <p> <i> If necessary, multiple Decimal constructors can be created, each with their own independent configuration, e.g. precision and range, which applies to all Decimal instances created from it. </i> </p> <p> <i> A new Decimal constructor is created by calling the <code><a href='#Dclone'>clone</a></code> method of an already existing Decimal constructor. </i> </p> <h3 class='end'>CONSTRUCTOR</h3> <h5 id="decimal"> Decimal<code class='inset'>Decimal(value) <i>⇒ Decimal</i></code> </h5> <dl> <dt><code>value</code>: <i>number|string|Decimal</i></dt> <dd> Integer or float. </dd> <dd> The number of digits is not limited, except by JavaScript's maximum array size and, in practice, the processing time required. </dd> <dd> The maximum permissible exponent magnitude is approximately <code>9007199254740991</code>. </dd> <dd> String values may be in exponential (floating-point), as well as normal (fixed-point) notation. </dd> <dd> In exponential notation, <code>e</code> or <code>E</code> defines a power-of-ten exponent. </dd> </dl> <p>Returns a new Decimal object instance.</p> <p>Throws on an invalid <code>value</code>.</p> <pre> x = new Decimal(9) // '9' y = new Decimal(x) // '9' new Decimal('5032485723458348569331745.33434346346912144534543') new Decimal('4.321e+4') // '43210' new Decimal('-735.0918e-430') // '-7.350918e-428' new Decimal('5.6700000') // '5.67' new Decimal('.5') // '0.5' new Decimal(0.046875) // '0.046875' new Decimal('0.046875000000') // '0.046875' new Decimal(4.6875e-2) // '0.046875' new Decimal('468.75e-4') // '0.046875'</pre> <h4 id="methods">Methods</h4> <p>The methods of a Decimal constructor.</p> <h5 id="Dclone"> clone <code class='inset'>.clone([object]) <i>⇒ Decimal constructor</i></code> </h5> <p><code>object</code>: <i>object</i></p> <p> Returns a new independent Decimal constructor with configuration settings as described by <code>object</code> (see <a href='#Dconfig'><code>config</code></a>), or with the same settings as <code>this</code> Decimal constructor if <code>object</code> is omitted. </p> <pre>Decimal.config({ precision: 5 }) D9 = Decimal.clone({ precision: 9 }) a = new Decimal(1) b = new D9(1) a.div(3) // 0.33333 b.div(3) // 0.333333333 // D9 = Decimal.clone({ precision: 9 }) is equivalent to: D9 = Decimal.clone() D9.config({ precision: 9 })</pre> <p> It is not inefficient in terms of memory usage to use multiple Decimal constructors as functions are shared between them. </p> <h5 id="Dconfig"> config<code class='inset'>.set(object) <i>⇒ Decimal constructor</i></code> </h5> <p><code>object</code>: <i>object</i></p> <p> Configures the 'global' settings for <code>this</code> particular Decimal constructor, i.e. the settings which apply to operations performed on the Decimal instances created by it. </p> <p>Returns <code>this</code> Decimal constructor.</p> <p> The configuration object, <code>object</code>, can contain some or all of the properties described in detail at <a href="#constructor-properties">Properties</a> and shown in the example below. </p> <p> The values of the configuration object properties are checked for validity and then stored as equivalently-named properties of <code>this</code> Decimal constructor. </p> <p>Throws on an invalid <code>object</code> or configuration property value.</p> <pre> // Defaults Decimal.config({ precision: 20, rounding: 4, toExpNeg: -7, toExpPos: 21, LN10: new Decimal('2.30258509299404568401799145468436...') }) Decimal.set({ rounding: Decimal.ROUND_CEIL }) </pre> <p> The properties of a Decimal constructor can also be set by direct assignment, but that will by-pass the validity checking that this method performs - which is not a problem if the user knows that the checks are unnecessary. </p> <h4 id="constructor-properties">Properties</h4> <p>The properties of a Decimal constructor.</p> <h6 id='configProps'>Configuration properties</h6> <p> The values of the configuration properties <a href='#precision'><code>precision</code></a>, <a href='#rounding'><code>rounding</code></a>, <a href='#toExpNeg'><code>toExpNeg</code></a> and <a href='#toExpPos'><code>toExpPos</code></a> are set using the <a href='#Dconfig'><code>config</code></a> method. </p> <p> As simple object properties they can be set directly without using <a href='#Dconfig'><code>config</code></a>, and it is fine to do so, but the values assigned will not then be checked for validity. For example: </p> <pre>Decimal.config({ precision: 0 }) // '[DecimalError] Invalid argument: precision: 0' Decimal.precision = 0 // No error is thrown and the results of calculations are unreliable</pre> <h5 id="precision">precision</h5> <p> <i>number</i>: integer, <code>1</code> to <code>1e+9</code> inclusive<br /> Default value: <code>20</code> </p> <p>The <i>maximum</i> number of significant digits of the result of an operation.</p> <p> All functions which return a Decimal will return the value to <code>precision</code> significant digits except <a href='#decimal'><code>Decimal</code></a>, <a href='#abs'><code>absoluteValue</code></a>, <a href='#neg'><code>negated</code></a>, <a href='#round'><code>toInteger</code></a>, and <a href='#todp'><code>toDecimalPlaces</code></a>. </p> <pre>Decimal.config({ precision: 5 }) Decimal.precision // 5</pre> <h5 id="rounding">rounding</h5> <p> <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive<br /> Default value: <code>4</code> <a href="#modes">(<code>ROUND_HALF_UP</code>)</a> </p> <p> The default rounding mode used by <a href='#round'><code>toInteger</code></a>, <a href='#todp'><code>toDecimalPlaces</code></a>, <a href='#toExponential'><code>toExponential</code></a>, <a href='#toFixed'><code>toFixed</code></a>, <a href='#toPrecision'><code>toPrecision</code></a> and <a href='#tosd'><code>toSignificantDigits</code></a>. </p> <p> The <a href='#modes'>rounding modes</a> are available as enumerated properties of the constructor. </p> <pre>Decimal.config({ rounding: Decimal.ROUND_UP }) Decimal.config({ rounding: 0 }) // equivalent Decimal.rounding // 0</pre> <h5 id="toExpNeg">toExpNeg</h5> <p> <i>number</i>: integer, <code>-9e15</code> to <code>0</code> inclusive<br /> Default value: <code>-7</code> </p> <p> The negative exponent value at and below which <a href='#toString'><code>toString</code></a> returns exponential notation. </p> <pre>Decimal.config({ toExpNeg: -7 }) Decimal.toExpNeg // -7 new Decimal(0.00000123) // '0.00000123' e is -6 new Decimal(0.000000123) // '1.23e-7' // Always return exponential notation: Decimal.config({ toExpNeg: 0 })</pre> <p> JavaScript numbers use exponential notation for negative exponents of <code>-7</code> and below. </p> <p> Regardless of the value of <code>toExpNeg</code>, the <a href='#toFixed'><code>toFixed</code></a> method will always return a value in normal notation and the <a href='#toExponential'><code>toExponential</code></a> method will always return a value in exponential form. </p> <h5 id="toExpPos">toExpPos</h5> <p> <i>number</i>: integer, <code>0</code> to <code>9e15</code> inclusive<br /> Default value: <code>20</code> </p> <p> The positive exponent value at and above which <a href='#toString'><code>toString</code></a> returns exponential notation. </p> <pre>Decimal.config({ toExpPos: 2 }) Decimal.toExpPos // 2 new Decimal(12.3) // '12.3' e is 1 new Decimal(123) // '1.23e+2' // Always return exponential notation: Decimal.config({ toExpPos: 0 })</pre> <p> JavaScript numbers use exponential notation for positive exponents of <code>20</code> and above. </p> <p> Regardless of the value of <code>toExpPos</code>, the <a href='#toFixed'><code>toFixed</code></a> method will always return a value in normal notation and the <a href='#toExponential'><code>toExponential</code></a> method will always return a value in exponential form. </p> <h5 id="ln10">LN10</h5> <p> <i>string|Decimal</i>: the natural logarithm of <code>10</code><br /> The default value has <code>115</code> digits </p> <p> The maximum precision of the <a href='#exp'><code>naturalExponential</code></a>, <a href='#ln'><code>naturalLogarithm</code></a>, <a href='#log'><code>logarithm</code></a>, and <a href='#pow'><code>toPower</code></a> methods is determined by the precision of the value of <code>LN10</code>. </p> <p> The default value of <code>LN10</code> enables a maximum precision of about <code>100</code> digits. To increase this, assign a new value to <code>LN10</code> using a string or Decimal value with about 15 digits more than the maximum precision required. </p> <p> An error will be thrown if the <code>LN10</code> value does not have sufficient precision to enable an operation to be performed. </p> <pre> Decimal.config({ LN10: '2.3025850929940456840179914546843642076011014886287729760333279009' }) Decimal.LN10.toFixed(5) // ''2.30259'</pre> <h6 id="modes">Rounding modes</h6> <p> The library's enumerated rounding modes are stored as properties of the Decimal constructor. <br />They are not referenced internally by the library itself. </p> <p>Rounding modes 0 to 6 (inclusive) are the same as those of Java's BigDecimal class.</p> <table> <tr><th>Property</th><th>Value</th><th>Description</th></tr> <tr><td><b>ROUND_UP</b></td><td class='centre'>0</td><td>Rounds away from zero</td></tr> <tr><td><b>ROUND_DOWN</b></td><td class='centre'>1</td><td>Rounds towards zero</td></tr> <tr><td><b>ROUND_CEIL</b></td><td class='centre'>2</td><td>Rounds towards Infinity</td></tr> <tr><td><b>ROUND_FLOOR</b></td><td class='centre'>3</td><td>Rounds towards -Infinity</td></tr> <tr> <td><b>ROUND_HALF_UP</b></td><td class='centre'>4</td> <td>Rounds towards nearest neighbour.<br />If equidistant, rounds away from zero</td> </tr> <tr> <td><b>ROUND_HALF_DOWN</b></td><td class='centre'>5</td> <td>Rounds towards nearest neighbour.<br />If equidistant, rounds towards zero</td> </tr> <tr> <td><b>ROUND_HALF_EVEN</b></td><td class='centre'>6</td> <td> Rounds towards nearest neighbour.<br />If equidistant, rounds towards even neighbour </td> </tr> <tr> <td><b>ROUND_HALF_CEIL</b></td><td class='centre'>7</td> <td>Rounds towards nearest neighbour.<br />If equidistant, rounds towards Infinity</td> </tr> <tr> <td><b>ROUND_HALF_FLOOR</b></td><td class='centre'>8</td> <td>Rounds towards nearest neighbour.<br />If equidistant, rounds towards -Infinity</td> </tr> </table> <pre>Decimal.config({ rounding: Decimal.ROUND_CEIL }) Decimal.config({ rounding: 2 }) // equivalent Decimal.rounding // 2</pre> <h3>INSTANCE</h3> <h4 id="prototype-methods">Methods</h4> <p>The methods inherited by a Decimal instance from its constructor's prototype object.</p> <p>A Decimal instance is immutable in the sense that it is not changed by its methods.</p> <p>Methods that return a Decimal can be chained:</p> <pre>x = new Decimal(2).times('999.999999999999999').dividedBy(4).toFixed(2)</pre> <p>Methods do not round their arguments before execution.</p> <p> Many method names have a shorter alias. (Internally, the library always uses the shorter method names.) </p> <h5 id="abs">absoluteValue<code class='inset'>.abs() <i>⇒ Decimal</i></code></h5> <p> Returns a new Decimal whose value is the absolute value, i.e. the magnitude, of the value of this Decimal. </p> <p> The return value is not affected by the value of the <a href='#precision'><code>precision</code></a> setting. </p> <pre> x = new Decimal(-0.8) y = x.absoluteValue() // '0.8' z = y.abs() // '0.8'</pre> <h5 id="cmp">comparedTo<code class='inset'>.cmp(x) <i>⇒ 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> </table> <pre> x = new Decimal(4) y = new Decimal(5) x.comparedTo(y) // -1 x.comparedTo(x.plus(1)) // 0</pre> <h5 id="dp">decimalPlaces<code class='inset'>.dp() <i>⇒ 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>, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <pre> x = new Decimal(355) y = new Decimal(113) x.dividedBy(y) // '3.14159292035398230088' x.div(5) // '71'</pre> <h5 id="idiv"> dividedToIntegerBy<code class='inset'>.idiv(x) <i>⇒ Decimal</i></code> </h5> <p><code>x</code>: <i>number|string|Decimal</i></p> <p> Return a new Decimal whose value is the integer part of dividing this Decimal by <code>x</code>, truncated to <code><a href='#precision'>precision</a></code> significant digits. </p> <pre> x = new Decimal(5) y = new Decimal(3) x.dividedToIntegerBy(y) // '1' x.idiv(0.7) // '7'</pre> <h5 id="eq">equals<code class='inset'>.eq(x) <i>⇒ boolean</i></code></h5> <p><code>x</code>: <i>number|string|Decimal</i></p> <p> Returns <code>true</code> if the value of this Decimal equals the value of <code>x</code>, otherwise returns <code>false</code>. </p> <p>Note: This method uses the <code>cmp</code> method internally.</p> <pre> 0 === 1e-324 // true x = new Decimal(0) x.equals('1e-324') // false</pre> <h5 id="exp">exponent<code class='inset'>.exponent() <i>⇒ number</i></code></h5> <p>Returns the exponent value of this Decimal.</p> <pre> x = new Decimal(1234.567) x.exponent() // 3</pre> <h5 id="gt">greaterThan<code class='inset'>.gt(x) <i>⇒ 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="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="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() // false 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() // false 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() // true</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, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <p> If <code>x</code> is omitted, the base 10 logarithm of the value of this Decimal will be returned. </p> <pre> x = new Decimal(1000) x.logarithm() // '3' y = new Decimal(256) y.log(2) // '8'</pre> <p>The maximum error will be <code>1</code> <i>ulp</i> (unit in the last place).</p> <p>Logarithms to base <code>2</code> or <code>10</code> will always be correct.</p> <p>The performance of this method degrades exponentially with increasing digits.</p> <h5 id="sub">minus<code class='inset'>.minus(x) <i>⇒ Decimal</i></code></h5> <p><code>x</code>: <i>number|string|Decimal</i></p> <p> Returns a new Decimal whose value is the value of this Decimal minus <code>x</code>, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <pre> 0.3 - 0.1 // 0.19999999999999998 x = new Decimal(0.3) x.minus(0.1) // '0.2'</pre> <h5 id="mod">modulo<code class='inset'>.mod(x) <i>⇒ Decimal</i></code></h5> <p><code>x</code>: <i>number|string|Decimal</i></p> <p> Returns a new Decimal whose value is the value of this Decimal modulo <code>x</code>, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <pre> 1 % 0.9 // 0.09999999999999998 x = new Decimal(1) y = x.modulo(0.9) // '0.1'</pre> <h5 id="exp">naturalExponential<code class='inset'>.exp() <i>⇒ Decimal</i></code></h5> <p> Returns a new Decimal whose value is the base <code>e</code> (Euler's number, the base of the natural logarithm) exponential of the value of this Decimal, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <p> The <code><a href='#ln'>naturalLogarithm</a></code> function is the inverse of this function. </p> <pre> x = new Decimal(1) x.naturalExponential() // '2.7182818284590452354' y = new Decimal(2) y.exp() // '7.3890560989306502272'</pre> <p>The maximum error will be <code>1</code> <i>ulp</i> (unit in the last place).</p> <p>The performance of this method degrades exponentially with increasing digits.</p> <h5 id="ln">naturalLogarithm<code class='inset'>.ln() <i>⇒ Decimal</i></code></h5> <p> Returns a new Decimal whose value is the natural logarithm of the value of this Decimal, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <p> The natural logarithm is the inverse of the <code><a href='#exp'>naturalExponential</a></code> function. </p> <pre> x = new Decimal(10) x.naturalLogarithm() // '2.3026' y = new Decimal('1.23e+30') y.ln() // '69.28'</pre> <p> The mathematical result of the natural logarithm function is non-terminating, unless its argument is <code>1</code>. </p> <p> The time-taken by this method increases exponentially with increasing digits. </p> <p> See <a href='#ln10'>LN10</a> to configure the maximum precision available. </p> <h5 id="neg">negated<code class='inset'>.neg() <i>⇒ 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>, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <pre> 0.1 + 0.2 // 0.30000000000000004 x = new Decimal(0.1) y = x.plus(0.2) // '0.3' new Decimal(0.7).plus(x).plus(y) // '1.1'</pre> <h5 id="sd">precision<code class='inset'>.sd([include_zeros]) <i>⇒ number</i></code></h5> <p>Returns the number of significant digits of the value of this Decimal.</p> <p> If <code>include_zeros</code> is <code>true</code> or <code>1</code> then any trailing zeros of the integer part of a number are counted as significant digits, otherwise they are not. </p> <pre> x = new Decimal(1.234) x.precision() // '4' y = new Decimal(987000) y.sd() // '3' y.sd(true) // '6'</pre> <h5 id="sqrt">squareRoot<code class='inset'>.sqrt() <i>⇒ Decimal</i></code></h5> <p> Returns a new Decimal whose value is the square root of this Decimal, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <p> This method is much faster than using the <a href='#pow'><code>toPower</code></a> method with an exponent of <code>0.5</code>. </p> <pre> x = new Decimal(16) x.squareRoot() // '4' y = new Decimal(3) y.sqrt() // '1.73205080756887729353' y.sqrt().eq( y.pow(0.5) ) // true</pre> <h5 id="mul">times<code class='inset'>.times(x) <i>⇒ Decimal</i></code></h5> <p><code>x</code>: <i>number|string|Decimal</i></p> <p> Returns a new Decimal whose value is the value of this Decimal times <code>x</code>, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <pre> 0.6 * 3 // 1.7999999999999998 x = new Decimal(0.6) y = x.times(3) // '1.8' new Decimal('7e+500').times(y) // '1.26e+501'</pre> <h5 id="todp"> toDecimalPlaces<code class='inset'>.todp([dp [, rm]]) <i>⇒ Decimal</i></code> </h5> <p> <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br /> <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive. </p> <p> Returns a new Decimal whose value is the value of this Decimal rounded to a maximum of <code>dp</code> decimal places using rounding mode <code>rm</code>. </p> <p> If <code>dp</code> is omitted, the return value will have the same value as this Decimal. </p> <p> If <code>rm</code> is omitted, rounding mode <a href='#rounding'><code>rounding</code></a> is used. </p> <p>Throws on an invalid <code>dp</code> or <code>rm</code> value.</p> <pre> x = new Decimal(12.24567) x.toDecimalPlaces(0) // '12' x.toDecimalPlaces(1, 0) // '12.3' y = new Decimal(9876.54321) y.todp(3) // '9876.543' y.todp(1, 0) // '9876.6' y.todp(1, Decimal.ROUND_DOWN) // '9876.5'</pre> <h5 id="toExponential"> toExponential<code class='inset'>.toExponential([dp [, rm]]) <i>⇒ 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="toInteger">toInteger<code class='inset'>.toint() <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.config({ rounding: 4 }) x = 1234.5 x.toInteger() // '1235' Decimal.rounding = Decimal.ROUND_DOWN x.toint() // '1234' x // '1234.5'</pre> <h5 id="toJSON">toJSON<code class='inset'>.toJSON() <i>⇒ string</i></code></h5> <p>As <a href='#toString'><code>toString</code></a>.</p> <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</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>, truncated to <a href='#precision'><code>precision</code></a> significant digits. </p> <p> The performance of this method degrades exponentially with increasing digits.<br /> For non-integer exponents in particular, the performance of this method may not be adequate. </p> <p>The maximum error will be <code>1</code> <i>ulp</i> (unit in the last place). </p> <pre> Math.pow(0.7, 2) // 0.48999999999999994 x = new Decimal(0.7) x.toPower(2) // '0.49' new Decimal(3).pow(-2) // '0.11111111111111111111' new Decimal(1217652.23).pow('98765.489305603941') // '4.8227010515242461181e+601039'</pre> <h5 id="toPrecision"> toPrecision<code class='inset'>.toPrecision([sd [, rm]]) <i>⇒ 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 a maximum of <code>sd</code> significant digits using rounding mode <code>rm</code>. </p> <p> If <code>sd</code> is omitted, the return value will be rounded to <a href='#precision'><code>precision</code></a> significant digits. </p> <p> If <code>rm</code> is omitted, rounding mode <a href='#rounding'><code>rounding</code></a> will be used. </p> <p>Throws on an invalid <code>sd</code> or <code>rm</code> value.</p> <pre> Decimal.config({ precision: 5, rounding: 4 }) x = new Decimal(9876.54321) x.toSignificantDigits() // '9876.5' x.toSignificantDigits(6) // '9876.54' x.toSignificantDigits(6, Decimal.ROUND_UP) // '9876.55' x.tosd(2) // '9900' x.tosd(2, 1) // '9800' x // '9876.54321'</pre> <h5 id="toString">toString<code class='inset'>.toString() <i>⇒ string</i></code></h5> <p>Returns a string representing the value of this Decimal.</p> <p> If this Decimal has a positive exponent that is equal to or greater than <a href="#toExpPos"><code>toExpPos</code></a>, or a negative exponent equal to or less than <a href="#toExpPos"><code>toExpNeg</code></a>, then exponential notation will be returned. </p> <pre> x = new Decimal(750000) x.toString() // '750000' Decimal.config({ toExpPos: 5 }) x.toString() // '7.5e+5' Decimal.config({ precision: 4 }); y = new Decimal('1.23456789') y.toString() // '1.23456789'</pre> <h5 id="valueOf">valueOf<code class='inset'>.val() <i>⇒ string</i></code></h5> <p>As <a href='#toString'><code>toString</code></a>.</p> <h4 id="instance-properties">Properties</h4> <p> The value of a Decimal is stored in a normalised base <code>10000000</code> floating point format. </p> <p> A Decimal instance is an object with three properties: </p> <table> <tr> <th>Property</th> <th>Description</th> <th>Type</th> <th>Value</th> </tr> <tr> <td class='centre' id='digits'><b>d</b></td> <td>digits</td> <td><i>number</i><code style='color:#000'>[]</code></td> <td> Array of integers, each <code>0</code> - <code>1e7</code></td> </tr> <tr> <td class='centre' id='exponent'><b>e</b></td> <td>exponent*</td> <td><i>number</i></td> <td>Integer, <code>-1286742750677284</code> to <code>1286742750677284</code> inclusive</td> </tr> <tr> <td class='centre' id='sign'><b>s</b></td> <td>sign</td> <td><i>number</i></td> <td><code>-1</code>, <code>0</code>, or <code>1</code></td> </tr> </table> <p> *This is the exponent in base <code>10000000</code>. To get the base 10 exponent, use the <a href='#exp'><code>exponent</code></a> method. </p> <p>The properties are best considered to be read-only.</p> <p> As with JavaScript numbers, the original exponent and fractional trailing zeros of a number are not preserved. </p> <pre> x = new Decimal(0.123) // '0.123' x.toExponential() // '1.23e-1' x.d // [ 1230000 ] x.e // -1 x.s // 1 y = new Number(-123.4567000e+2) // '-12345.67' y.toExponential() // '-1.234567e+4' z = new Decimal('-123.4567000e+2') // '-12345.67' z.toExponential() // '-1.234567e+4' z.d // [ 12345, 6700000 ] z.e // 4 z.s // -1</pre> <h4 id='Errors'>Errors</h4> <p> The errors that are thrown are generic <code>Error</code> objects whose <code>message</code> property begins with <code>"[DecimalError]"</code>. </p> <p>To determine if an exception is a Decimal Error:</p> <pre> try { // ... } catch (e) { if ( e instanceof Error && /DecimalError/.test(e.message) ) { // ... } }</pre> <h2 id='faq'>FAQ</h2> <h6>Why are trailing fractional zeros removed from Decimals?</h6> <p> Some arbitrary-precision libraries retain trailing fractional zeros as they can indicate the precision of a value. This can be useful but the results of arithmetic operations can be misleading. </p> <pre> x = new BigDecimal("1.0") y = new BigDecimal("1.1000") z = x.add(y) // 2.1000 x = new BigDecimal("1.20") y = new BigDecimal("3.45000") z = x.multiply(y) // 4.1400000</pre> <p> To specify the precision of a value is to specify that the value lies within a certain range. </p> <p> In the first example, <code>x</code> has a value of <code>1.0</code>. The trailing zero shows the precision of the value, implying that it is in the range <code>0.95</code> to <code>1.05</code>. Similarly, the precision indicated by the trailing zeros of <code>y</code> indicates that the value is in the range <code>1.09995</code> to <code>1.10005</code>. </p> <p> If we add the two lowest values in the ranges we have, <code>0.95 + 1.09995 = 2.04995</code>, and if we add the two highest values we have, <code>1.05 + 1.10005 = 2.15005</code>, so the range of the result of the addition implied by the precision of its operands is <code>2.04995</code> to <code>2.15005</code>. </p> <p> The result given by BigDecimal of <code>2.1000</code> however, indicates that the value is in the range <code>2.09995</code> to <code>2.10005</code> and therefore the precision implied by its trailing zeros may be misleading. </p> <p> In the second example, the true range is <code>4.122744</code> to <code>4.157256</code> yet the BigDecimal answer of <code>4.1400000</code> indicates a range of <code>4.13999995</code> to <code>4.14000005</code>. Again, the precision implied by the trailing zeros may be misleading. </p> <p> This library, like binary floating point and most calculators, does not retain trailing fractional zeros. Instead, the <code>toExponential</code>, <code>toFixed</code> and <code>toPrecision</code> methods enable trailing zeros to be added if and when required.<br /> </p> </div> </body> </html>