nodulator

<!DOCTYPE HTML> <html> <head> <meta charset="utf-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="Author" content="M Mclaughlin"> <title>bignumber.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:200px;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} h1{font:400 3em Verdana,sans-serif;color:#000;margin-bottom:1em} h2{font-size:2.25em;color:#ff2a00} h3{font-size:1.75em;color:#4dc71f} h4{font-size:1.75em;color:#ff2a00;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{padding-top:.35em} dt{padding-top:.5em} b{font-weight:700} dt b{font-size:1.3em} a,a:visited{color:#ff2a00;text-decoration:none} a:active,a:hover{outline:0;text-decoration:underline} .nav a,.nav b,.nav a:visited{display:block;color:#ff2a00;font-weight:700; margin-top:15px} .nav b{color:#4dc71f;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,ul.inset{margin-left:20px} .inset{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:#ff2a00} 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 #abef98; padding:1px 0 1px 15px;margin:1.2em 0} code,.nav-title{color:#ff2a00} .end{margin-bottom:25px} .centre{text-align:center} .error-table{font-size:13px;width:100%} #faq{margin:3em 0 0} li span{float:right;margin-right:10px;color:#c0c0c0} #js{font:inherit;color:#4dc71f} </style> </head> <body> <div class="nav"> <a class='nav-title' href="#">API</a> CONSTRUCTOR <ul> <li><a href="#bignumber">BigNumber</a></li> </ul> <a href="#methods">Methods</a> <ul> <li><a href="#another">another</a></li> <li><a href="#config" >config</a></li> <li> <ul class="inset"> <li><a href="#decimal-places">DECIMAL_PLACES</a></li> <li><a href="#rounding-mode" >ROUNDING_MODE</a></li> <li><a href="#exponential-at">EXPONENTIAL_AT</a></li> <li><a href="#range" >RANGE</a></li> <li><a href="#errors" >ERRORS</a></li> <li><a href="#crypto" >CRYPTO</a></li> <li><a href="#modulo-mode" >MODULO_MODE</a></li> <li><a href="#pow-precision" >POW_PRECISION</a></li> <li><a href="#format" >FORMAT</a></li> </ul> </li> <li><a href="#max" >max</a></li> <li><a href="#min" >min</a></li> <li><a href="#random" >random</a></li> </ul> <a href="#constructor-properties">Properties</a> <ul> <li><a href="#round-up" >ROUND_UP</a></li> <li><a href="#round-down" >ROUND_DOWN</a></li> <li><a href="#round-ceil" >ROUND_CEIL</a></li> <li><a href="#round-floor" >ROUND_FLOOR</a></li> <li><a href="#round-half-up" >ROUND_HALF_UP</a></li> <li><a href="#round-half-down" >ROUND_HALF_DOWN</a></li> <li><a href="#round-half-even" >ROUND_HALF_EVEN</a></li> <li><a href="#round-half-ceil" >ROUND_HALF_CEIL</a></li> <li><a href="#round-half-floor">ROUND_HALF_FLOOR</a></li> </ul> INSTANCE <a href="#prototype-methods">Methods</a> <ul> <li><a href="#abs" >absoluteValue </a>abs </li> <li><a href="#ceil" >ceil </a> </li> <li><a href="#cmp" >comparedTo </a>cmp </li> <li><a href="#dp" >decimalPlaces </a>dp </li> <li><a href="#div" >dividedBy </a>div </li> <li><a href="#divInt" >dividedToIntegerBy </a>divToInt</li> <li><a href="#eq" >equals </a>eq </li> <li><a href="#floor" >floor </a> </li> <li><a href="#gt" >greaterThan </a>gt </li> <li><a href="#gte" >greaterThanOrEqualTo</a>gte </li> <li><a href="#isF" >isFinite </a> </li> <li><a href="#isInt" >isInteger </a>isInt </li> <li><a href="#isNaN" >isNaN </a> </li> <li><a href="#isNeg" >isNegative </a>isNeg </li> <li><a href="#isZ" >isZero </a> </li> <li><a href="#lt" >lessThan </a>lt </li> <li><a href="#lte" >lessThanOrEqualTo </a>lte </li> <li><a href="#minus" >minus </a>sub </li> <li><a href="#mod" >modulo </a>mod </li> <li><a href="#neg" >negated </a>neg </li> <li><a href="#plus" >plus </a>add </li> <li><a href="#sd" >precision </a>sd </li> <li><a href="#round" >round </a> </li> <li><a href="#shift" >shift </a> </li> <li><a href="#sqrt" >squareRoot </a>sqrt </li> <li><a href="#times" >times </a>mul </li> <li><a href="#toD" >toDigits </a> </li> <li><a href="#toE" >toExponential </a> </li> <li><a href="#toFix" >toFixed </a> </li> <li><a href="#toFor" >toFormat </a> </li> <li><a href="#toFr" >toFraction </a> </li> <li><a href="#toJSON" >toJSON </a> </li> <li><a href="#toN" >toNumber </a> </li> <li><a href="#pow" >toPower </a>pow </li> <li><a href="#toP" >toPrecision </a> </li> <li><a href="#toS" >toString </a> </li> <li><a href="#trunc" >truncated </a>trunc </li> <li><a href="#valueOf">valueOf </a> </li> </ul> <a href="#instance-properties">Properties</a> <ul> <li><a href="#coefficient">c: coefficient</a></li> <li><a href="#exponent" >e: exponent</a></li> <li><a href="#sign" >s: sign</a></li> </ul> <a href="#zero-nan-infinity">Zero, NaN & Infinity</a> <a href="#Errors">Errors</a> <a class='end' href="#faq">FAQ</a> </div> <div class="container"> <h1>bignumber.js</h1> A JavaScript library for arbitrary-precision arithmetic. <a href="https://github.com/MikeMcl/bignumber.js">Hosted on GitHub</a>. <h2>API</h2> See the <a href='https://github.com/MikeMcl/bignumber.js'>README</a> on GitHub for a quick-start introduction. 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. <h3>CONSTRUCTOR</h3> <h5 id="bignumber"> BigNumber<code class='inset'>BigNumber(value [, base]) ⇒ BigNumber</code> </h5> <dl> <dt><code>value</code></dt> <dd> number|string|BigNumber: see <a href='#range'>RANGE</a> for range. </dd> <dd> A numeric value. </dd> <dd> Legitimate values include ±<code>0</code>, ±<code>Infinity</code> and <code>NaN</code>. </dd> <dd> Values of type number with more than <code>15</code> significant digits are considered invalid (if <a href='#errors'><code>ERRORS</code></a> is true) as calling <code><a href='#toS'>toString</a></code> or <code><a href='#valueOf'>valueOf</a></code> on such numbers may not result in the intended value. <pre>console.log( 823456789123456.3 ); // 823456789123456.2</pre> </dd> <dd> There is no limit to the number of digits of a value of type string (other than that of JavaScript's maximum array size). </dd> <dd> Decimal string values may be in exponential, as well as normal (fixed-point) notation. Non-decimal values must be in normal notation. </dd> <dd> String values in hexadecimal literal form, e.g. <code>'0xff'</code>, are valid, as are string values with the octal and binary prefixs <code>'0o'</code> and <code>'0b'</code>. String values in octal literal form without the prefix will be interpreted as decimals, e.g. <code>'011'</code> is interpreted as 11, not 9. </dd> <dd>Values in any base may have fraction digits.</dd> <dd> For bases from <code>10</code> to <code>36</code>, lower and/or upper case letters can be used to represent values from <code>10</code> to <code>35</code>. </dd> <dd> For bases above 36, <code>a-z</code> represents values from <code>10</code> to <code>35</code>, <code>A-Z</code> from <code>36</code> to <code>61</code>, and <code>$</code> and <code>_</code> represent <code>62</code> and <code>63</code> respectively (this can be changed by editing the <code>ALPHABET</code> variable near the top of the source file). </dd> </dl> <dl> <dt><code>base</code></dt> <dd> number: integer, <code>2</code> to <code>64</code> inclusive </dd> <dd>The base of <code>value</code>.</dd> <dd> If <code>base</code> is omitted, or is <code>null</code> or <code>undefined</code>, base <code>10</code> is assumed. </dd> </dl> Returns a new instance of a BigNumber object. If a base is specified, the value is rounded according to the current <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> configuration. See <a href='#Errors'>Errors</a> for the treatment of an invalid <code>value</code> or <code>base</code>. <pre> x = new BigNumber(9) // '9' y = new BigNumber(x) // '9' // 'new' is optional if ERRORS is false BigNumber(435.345) // '435.345' new BigNumber('5032485723458348569331745.33434346346912144534543') new BigNumber('4.321e+4') // '43210' new BigNumber('-735.0918e-430') // '-7.350918e-428' new BigNumber(Infinity) // 'Infinity' new BigNumber(NaN) // 'NaN' new BigNumber('.5') // '0.5' new BigNumber('+2') // '2' new BigNumber(-10110100.1, 2) // '-180.5' new BigNumber(-0b10110100.1) // '-180.5' new BigNumber('123412421.234324', 5) // '607236.557696' new BigNumber('ff.8', 16) // '255.5' new BigNumber('0xff.8') // '255.5'</pre> The following throws <code>'not a base 2 number'</code> if <a href='#errors'><code>ERRORS</code></a> is true, otherwise it returns a BigNumber with value <code>NaN</code>. <pre>new BigNumber(9, 2)</pre> The following throws <code>'number type has more than 15 significant digits'</code> if <a href='#errors'><code>errors</code></a> is true, otherwise it returns a BigNumber with value <code>96517860459076820</code>. <pre>new BigNumber(96517860459076817.4395)</pre> The following throws <code>'not a number'</code> if <a href='#errors'><code>ERRORS</code></a> is true, otherwise it returns a BigNumber with value <code>NaN</code>. <pre>new BigNumber('blurgh')</pre> A value is only rounded by the constructor if a base is specified. <pre>BigNumber.config({ DECIMAL_PLACES: 5 }) new BigNumber(1.23456789) // '1.23456789' new BigNumber(1.23456789, 10) // '1.23457'</pre> <h4 id="methods">Methods</h4> The static methods of a BigNumber constructor. <h5 id="another"> another<code class='inset'>.another([obj]) ⇒ BigNumber constructor</code> </h5> <code>obj</code>: object Returns a new independent BigNumber constructor with configuration as described by <code>obj</code> (see <a href='#config'><code>config</code></a>), or with the default configuration if <code>obj</code> is <code>null</code> or <code>undefined</code>. <pre>BigNumber.config({ DECIMAL_PLACES: 5 }) BN = BigNumber.another({ DECIMAL_PLACES: 9 }) x = new BigNumber(1) y = new BN(1) x.div(3) // 0.33333 y.div(3) // 0.333333333 // BN = BigNumber.another({ DECIMAL_PLACES: 9 }) is equivalent to: BN = BigNumber.another() BN.config({ DECIMAL_PLACES: 9 })</pre> <h5 id="config">config<code class='inset'>config([obj]) ⇒ object</code></h5> <code>obj</code>: object: an object that contains some or all of the following properties. Configures the 'global' settings for this particular BigNumber constructor. Note: the configuration can also be supplied as an argument list, see below. <dl class='inset'> <dt id="decimal-places"><code>DECIMAL_PLACES</code></dt> <dd> number: integer, <code>0</code> to <code>1e+9</code> inclusive Default value: <code>20</code> </dd> <dd> The maximum number of decimal places of the results of operations involving division, i.e. division, square root and base conversion operations, and power operations with negative exponents. </dd> <dd> <pre>BigNumber.config({ DECIMAL_PLACES: 5 }) BigNumber.config(5) // equivalent</pre> </dd> <dt id="rounding-mode"><code>ROUNDING_MODE</code></dt> <dd> number: integer, <code>0</code> to <code>8</code> inclusive Default value: <code>4</code> <a href="#h-up">(<code>ROUND_HALF_UP</code>)</a> </dd> <dd> The rounding mode used in the above operations and the default rounding mode of <a href='#round'><code>round</code></a>, <a href='#toE'><code>toExponential</code></a>, <a href='#toFix'><code>toFixed</code></a>, <a href='#toFor'><code>toFormat</code></a> and <a href='#toP'><code>toPrecision</code></a>. </dd> <dd>The modes are available as enumerated properties of the BigNumber constructor.</dd> <dd> <pre>BigNumber.config({ ROUNDING_MODE: 0 }) BigNumber.config(null, BigNumber.ROUND_UP) // equivalent</pre> </dd> <dt id="exponential-at"><code>EXPONENTIAL_AT</code></dt> <dd> number: integer, magnitude <code>0</code> to <code>1e+9</code> inclusive, or number[]: [ integer <code>-1e+9</code> to <code>0</code> inclusive, integer <code>0</code> to <code>1e+9</code> inclusive ] Default value: <code>[-7, 20]</code> </dd> <dd> The exponent value(s) at which <code>toString</code> returns exponential notation. </dd> <dd> If a single number is assigned, the value is the exponent magnitude. If an array of two numbers is assigned then the first number is the negative exponent value at and beneath which exponential notation is used, and the second number is the positive exponent value at and above which the same. </dd> <dd> For example, to emulate JavaScript numbers in terms of the exponent values at which they begin to use exponential notation, use <code>[-7, 20]</code>. </dd> <dd> <pre>BigNumber.config({ EXPONENTIAL_AT: 2 }) new BigNumber(12.3) // '12.3' e is only 1 new BigNumber(123) // '1.23e+2' new BigNumber(0.123) // '0.123' e is only -1 new BigNumber(0.0123) // '1.23e-2' BigNumber.config({ EXPONENTIAL_AT: [-7, 20] }) new BigNumber(123456789) // '123456789' e is only 8 new BigNumber(0.000000123) // '1.23e-7' // Almost never return exponential notation: BigNumber.config({ EXPONENTIAL_AT: 1e+9 }) // Always return exponential notation: BigNumber.config({ EXPONENTIAL_AT: 0 })</pre> </dd> <dd> Regardless of the value of <code>EXPONENTIAL_AT</code>, the <code>toFixed</code> method will always return a value in normal notation and the <code>toExponential</code> method will always return a value in exponential form. </dd> <dd> Calling <code>toString</code> with a base argument, e.g. <code>toString(10)</code>, will also always return normal notation. </dd> <dt id="range"><code>RANGE</code></dt> <dd> number: integer, magnitude <code>1</code> to <code>1e+9</code> inclusive, or number[]: [ integer <code>-1e+9</code> to <code>-1</code> inclusive, integer <code>1</code> to <code>1e+9</code> inclusive ] Default value: <code>[-1e+9, 1e+9]</code> </dd> <dd> The exponent value(s) beyond which overflow to <code>Infinity</code> and underflow to zero occurs. </dd> <dd> If a single number is assigned, it is the maximum exponent magnitude: values wth a positive exponent of greater magnitude become <code>Infinity</code> and those with a negative exponent of greater magnitude become zero. <dd> If an array of two numbers is assigned then the first number is the negative exponent limit and the second number is the positive exponent limit. </dd> <dd> For example, to emulate JavaScript numbers in terms of the exponent values at which they become zero and <code>Infinity</code>, use <code>[-324, 308]</code>. </dd> <dd> <pre>BigNumber.config({ RANGE: 500 }) BigNumber.config().RANGE // [ -500, 500 ] new BigNumber('9.999e499') // '9.999e+499' new BigNumber('1e500') // 'Infinity' new BigNumber('1e-499') // '1e-499' new BigNumber('1e-500') // '0' BigNumber.config({ RANGE: [-3, 4] }) new BigNumber(99999) // '99999' e is only 4 new BigNumber(100000) // 'Infinity' e is 5 new BigNumber(0.001) // '0.01' e is only -3 new BigNumber(0.0001) // '0' e is -4</pre> </dd> <dd> The largest possible magnitude of a finite BigNumber is <code>9.999...e+1000000000</code>. The smallest possible magnitude of a non-zero BigNumber is <code>1e-1000000000</code>. </dd> <dt id="errors"><code>ERRORS</code></dt> <dd> boolean|number: <code>true</code>, <code>false</code>, <code>0</code> or <code>1</code>. Default value: <code>true</code> </dd> <dd> The value that determines whether BigNumber Errors are thrown. If <code>ERRORS</code> is false, no errors will be thrown. </dd> <dd>See <a href='#Errors'>Errors</a>.</dd> <dd><pre>BigNumber.config({ ERRORS: false })</pre></dd> <dt id="crypto"><code>CRYPTO</code></dt> <dd> boolean|number: <code>true</code>, <code>false</code>, <code>0</code> or <code>1</code>. Default value: <code>false</code> </dd> <dd> The value that determines whether cryptographically-secure pseudo-random number generation is used. </dd> <dd> If <code>CRYPTO</code> is set to <code>true</code> then the <a href='#random'><code>random</code></a> method will generate random digits using <code>crypto.getRandomValues</code> in browsers that support it, or <code>crypto.randomBytes</code> if using a version of Node.js that supports it. </dd> <dd> If neither function is supported by the host environment then attempting to set <code>CRYPTO</code> to <code>true</code> will fail, and if <code>ERRORS</code> is <code>true</code> an exception will be thrown. </dd> <dd> If <code>CRYPTO</code> is <code>false</code> then the source of randomness used will be <code>Math.random</code> (which is assumed to generate at least <code>30</code> bits of randomness). </dd> <dd>See <a href='#random'><code>random</code></a>.</dd> <dd> <pre>BigNumber.config({ CRYPTO: true }) BigNumber.config().CRYPTO // true BigNumber.random() // 0.54340758610486147524</pre> </dd> <dt id="modulo-mode"><code>MODULO_MODE</code></dt> <dd> number: integer, <code>0</code> to <code>9</code> inclusive Default value: <code>1</code> (<a href="#round-down"><code>ROUND_DOWN</code></a>) </dd> <dd>The modulo mode used when calculating the modulus: <code>a mod n</code>.</dd> <dd> The quotient, <code>q = a / n</code>, is calculated according to the <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> that corresponds to the chosen <code>MODULO_MODE</code>. </dd> <dd>The remainder, <code>r</code>, is calculated as: <code>r = a - n * q</code>.</dd> <dd> The modes that are most commonly used for the modulus/remainder operation are shown in the following table. Although the other rounding modes can be used, they may not give useful results. </dd> <dd> <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, otherwise it is negative. </td> </tr> <tr> <td>ROUND_DOWN</td><td class='centre'>1</td> <td> The remainder has the same sign as the dividend. 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. This matches Python's <code>%</code> operator. </td> </tr> <tr> <td>ROUND_HALF_EVEN</td><td class='centre'>6</td> <td>The IEEE 754 remainder function.</td> </tr> <tr> <td>EUCLID</td><td class='centre'>9</td> <td> The remainder is always positive. Euclidian division: <code>q = sign(n) * floor(a / abs(n))</code> </td> </tr> </table> </dd> <dd> The rounding/modulo modes are available as enumerated properties of the BigNumber constructor. </dd> <dd>See <a href='#mod'><code>modulo</code></a>.</dd> <dd> <pre>BigNumber.config({ MODULO_MODE: BigNumber.EUCLID }) BigNumber.config({ MODULO_MODE: 9 }) // equivalent</pre> </dd> <dt id="pow-precision"><code>POW_PRECISION</code></dt> <dd> number: integer, <code>0</code> to <code>1e+9</code> inclusive. Default value: <code>100</code> </dd> <dd> The maximum number of significant digits of the result of the power operation. </dd> <dd>If set to <code>0</code>, the number of signifcant digits will not be limited.</dd> <dd>See <a href='#pow'><code>toPower</code></a>.</dd> <dd><pre>BigNumber.config({ POW_PRECISION: 100 })</pre></dd> <dt id="format"><code>FORMAT</code></dt> <dd>object</dd> <dd> The <code>FORMAT</code> object configures the format of the string returned by the <a href='#toFor'><code>toFormat</code></a> method. </dd> <dd> The example below shows the properties of the <code>FORMAT</code> object that are recognised, and their default values. </dd> <dd> Unlike the other configuration properties, the values of the properties of the <code>FORMAT</code> object will not be checked for validity. The existing <code>FORMAT</code> object will simply be replaced by the object that is passed in. Note that all the properties shown below do not have to be included. </dd> <dd>See <a href='#toFor'><code>toFormat</code></a> for examples of usage.</dd> <dd> <pre> BigNumber.config({ FORMAT: { // the decimal separator decimalSeparator: '.', // the grouping separator of the integer part groupSeparator: ',', // the primary grouping size of the integer part groupSize: 3, // the secondary grouping size of the integer part secondaryGroupSize: 0, // the grouping separator of the fraction part fractionGroupSeparator: ' ', // the grouping size of the fraction part fractionGroupSize: 0 } });</pre> </dd> </dl> Returns an object with the above properties and their current values. If the value to be assigned to any of the above properties is <code>null</code> or <code>undefined</code> it is ignored. See <a href='#Errors'>Errors</a> for the treatment of invalid values. <pre> BigNumber.config({ DECIMAL_PLACES: 40, ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL, EXPONENTIAL_AT: [-10, 20], RANGE: [-500, 500], ERRORS: true, CRYPTO: true, MODULO_MODE: BigNumber.ROUND_FLOOR, POW_PRECISION: 80, FORMAT: { groupSize: 3, groupSeparator: ' ', decimalSeparator: ',' } }); // Alternatively but equivalently (excluding FORMAT): BigNumber.config( 40, 7, [-10, 20], 500, 1, 1, 3, 80 ) obj = BigNumber.config(); obj.ERRORS // true obj.RANGE // [-500, 500]</pre> <h5 id="max"> max<code class='inset'>.max([arg1 [, arg2, ...]]) ⇒ BigNumber</code> </h5> <code>arg1</code>, <code>arg2</code>, ...: number|string|BigNumber See <code><a href="#bignumber">BigNumber</a></code> for further parameter details. Returns a BigNumber whose value is the maximum of <code>arg1</code>, <code>arg2</code>,... . The argument to this method can also be an array of values. The return value is always exact and unrounded. <pre>x = new BigNumber('3257869345.0378653') BigNumber.max(4e9, x, '123456789.9') // '4000000000' arr = [12, '13', new BigNumber(14)] BigNumber.max(arr) // '14'</pre> <h5 id="min"> min<code class='inset'>.min([arg1 [, arg2, ...]]) ⇒ BigNumber</code> </h5> <code>arg1</code>, <code>arg2</code>, ...: number|string|BigNumber See <code><a href="#bignumber">BigNumber</a></code> for further parameter details. Returns a BigNumber whose value is the minimum of <code>arg1</code>, <code>arg2</code>,... . The argument to this method can also be an array of values. The return value is always exact and unrounded. <pre>x = new BigNumber('3257869345.0378653') BigNumber.min(4e9, x, '123456789.9') // '123456789.9' arr = [2, new BigNumber(-14), '-15.9999', -12] BigNumber.min(arr) // '-15.9999'</pre> <h5 id="random"> random<code class='inset'>.random([dp]) ⇒ BigNumber</code> </h5> <code>dp</code>: number: integer, <code>0</code> to <code>1e+9</code> inclusive Returns a new BigNumber with a pseudo-random value equal to or greater than <code>0</code> and less than <code>1</code>. 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='#decimal-places'><code>DECIMAL_PLACES</code></a> setting. Depending on the value of this BigNumber constructor's <a href='#crypto'><code>CRYPTO</code></a> setting and the support for the <code>crypto</code> object in the host environment, the random digits of the return value are generated by either <code>Math.random</code> (fastest), <code>crypto.getRandomValues</code> (Web Cryptography API in recent browsers) or <code>crypto.randomBytes</code> (Node.js). If <a href='#crypto'><code>CRYPTO</code></a> is <code>true</code>, i.e. one of the <code>crypto</code> methods is to be used, the value of a returned BigNumber should be cryptographically-secure and statistically indistinguishable from a random value. <pre>BigNumber.config({ DECIMAL_PLACES: 10 }) BigNumber.random() // '0.4117936847' BigNumber.random(20) // '0.78193327636914089009'</pre> <h4 id="constructor-properties">Properties</h4> The library's enumerated rounding modes are stored as properties of the constructor. (They are not referenced internally by the library itself.) Rounding modes <code>0</code> to <code>6</code> (inclusive) are the same as those of Java's BigDecimal class. <table> <tr> <th>Property</th> <th>Value</th> <th>Description</th> </tr> <tr> <td id="round-up">ROUND_UP</td> <td class='centre'>0</td> <td>Rounds away from zero</td> </tr> <tr> <td id="round-down">ROUND_DOWN</td> <td class='centre'>1</td> <td>Rounds towards zero</td> </tr> <tr> <td id="round-ceil">ROUND_CEIL</td> <td class='centre'>2</td> <td>Rounds towards <code>Infinity</code></td> </tr> <tr> <td id="round-floor">ROUND_FLOOR</td> <td class='centre'>3</td> <td>Rounds towards <code>-Infinity</code></td> </tr> <tr> <td id="round-half-up">ROUND_HALF_UP</td> <td class='centre'>4</td> <td> Rounds towards nearest neighbour. If equidistant, rounds away from zero </td> </tr> <tr> <td id="round-half-down">ROUND_HALF_DOWN</td> <td class='centre'>5</td> <td> Rounds towards nearest neighbour. If equidistant, rounds towards zero </td> </tr> <tr> <td id="round-half-even">ROUND_HALF_EVEN</td> <td class='centre'>6</td> <td> Rounds towards nearest neighbour. If equidistant, rounds towards even neighbour </td> </tr> <tr> <td id="round-half-ceil">ROUND_HALF_CEIL</td> <td class='centre'>7</td> <td> Rounds towards nearest neighbour. If equidistant, rounds towards <code>Infinity</code> </td> </tr> <tr> <td id="round-half-floor">ROUND_HALF_FLOOR</td> <td class='centre'>8</td> <td> Rounds towards nearest neighbour. If equidistant, rounds towards <code>-Infinity</code> </td> </tr> </table> <pre> BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_CEIL }) BigNumber.config({ ROUNDING_MODE: 2 }) // equivalent</pre> <h3>INSTANCE</h3> <h4 id="prototype-methods">Methods</h4> The methods inherited by a BigNumber instance from its constructor's prototype object. A BigNumber is immutable in the sense that it is not changed by its methods. The treatment of ±<code>0</code>, ±<code>Infinity</code> and <code>NaN</code> is consistent with how JavaScript treats these values. Many method names have a shorter alias. (Internally, the library always uses the shorter method names.) <h5 id="abs">absoluteValue<code class='inset'>.abs() ⇒ BigNumber</code></h5> Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this BigNumber. The return value is always exact and unrounded. <pre> x = new BigNumber(-0.8) y = x.absoluteValue() // '0.8' z = y.abs() // '0.8'</pre> <h5 id="ceil">ceil<code class='inset'>.ceil() ⇒ BigNumber</code></h5> Returns a BigNumber whose value is the value of this BigNumber rounded to a whole number in the direction of positive <code>Infinity</code>. <pre> x = new BigNumber(1.3) x.ceil() // '2' y = new BigNumber(-1.8) y.ceil() // '-1'</pre> <h5 id="cmp">comparedTo<code class='inset'>.cmp(n [, base]) ⇒ number</code></h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. <table> <tr><th>Returns</th><th> </th></tr> <tr> <td class='centre'><code>1</code></td> <td>If the value of this BigNumber is greater than the value of <code>n</code></td> </tr> <tr> <td class='centre'><code>-1</code></td> <td>If the value of this BigNumber is less than the value of <code>n</code></td> </tr> <tr> <td class='centre'><code>0</code></td> <td>If this BigNumber and <code>n</code> have the same value</td> </tr> <tr> <td class='centre'><code>null</code></td> <td>If the value of either this BigNumber or <code>n</code> is <code>NaN</code></td> </tr> </table> <pre> x = new BigNumber(Infinity) y = new BigNumber(5) x.comparedTo(y) // 1 x.comparedTo(x.minus(1)) // 0 y.cmp(NaN) // null y.cmp('110', 2) // -1</pre> <h5 id="dp">decimalPlaces<code class='inset'>.dp() ⇒ number</code></h5> Return the number of decimal places of the value of this BigNumber, or <code>null</code> if the value of this BigNumber is ±<code>Infinity</code> or <code>NaN</code>. <pre> x = new BigNumber(123.45) x.decimalPlaces() // 2 y = new BigNumber('9.9e-101') y.dp() // 102</pre> <h5 id="div">dividedBy<code class='inset'>.div(n [, base]) ⇒ BigNumber</code> </h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns a BigNumber whose value is the value of this BigNumber divided by <code>n</code>, rounded according to the current <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> configuration. <pre> x = new BigNumber(355) y = new BigNumber(113) x.dividedBy(y) // '3.14159292035398230088' x.div(5) // '71' x.div(47, 16) // '5'</pre> <h5 id="divInt"> dividedToIntegerBy<code class='inset'>.divToInt(n [, base]) ⇒ BigNumber</code> </h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Return a BigNumber whose value is the integer part of dividing the value of this BigNumber by <code>n</code>. <pre> x = new BigNumber(5) y = new BigNumber(3) x.dividedToIntegerBy(y) // '1' x.divToInt(0.7) // '7' x.divToInt('0.f', 16) // '5'</pre> <h5 id="eq">equals<code class='inset'>.eq(n [, base]) ⇒ boolean</code></h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns <code>true</code> if the value of this BigNumber equals the value of <code>n</code>, otherwise returns <code>false</code>. As with JavaScript, <code>NaN</code> does not equal <code>NaN</code>. Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally. <pre> 0 === 1e-324 // true x = new BigNumber(0) x.equals('1e-324') // false BigNumber(-0).eq(x) // true ( -0 === 0 ) BigNumber(255).eq('ff', 16) // true y = new BigNumber(NaN) y.equals(NaN) // false</pre> <h5 id="floor">floor<code class='inset'>.floor() ⇒ BigNumber</code></h5> Returns a BigNumber whose value is the value of this BigNumber rounded to a whole number in the direction of negative <code>Infinity</code>. <pre> x = new BigNumber(1.8) x.floor() // '1' y = new BigNumber(-1.3) y.floor() // '-2'</pre> <h5 id="gt">greaterThan<code class='inset'>.gt(n [, base]) ⇒ boolean</code></h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns <code>true</code> if the value of this BigNumber is greater than the value of <code>n</code>, otherwise returns <code>false</code>. Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally. <pre> 0.1 > (0.3 - 0.2) // true x = new BigNumber(0.1) x.greaterThan(BigNumber(0.3).minus(0.2)) // false BigNumber(0).gt(x) // false BigNumber(11, 3).gt(11.1, 2) // true</pre> <h5 id="gte"> greaterThanOrEqualTo<code class='inset'>.gte(n [, base]) ⇒ boolean</code> </h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns <code>true</code> if the value of this BigNumber is greater than or equal to the value of <code>n</code>, otherwise returns <code>false</code>. Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally. <pre> (0.3 - 0.2) >= 0.1 // false x = new BigNumber(0.3).minus(0.2) x.greaterThanOrEqualTo(0.1) // true BigNumber(1).gte(x) // true BigNumber(10, 18).gte('i', 36) // true</pre> <h5 id="isF">isFinite<code class='inset'>.isFinite() ⇒ boolean</code></h5> Returns <code>true</code> if the value of this BigNumber is a finite number, otherwise returns <code>false</code>. The only possible non-finite values of a BigNumber are <code>NaN</code>, <code>Infinity</code> and <code>-Infinity</code>. <pre> x = new BigNumber(1) x.isFinite() // true y = new BigNumber(Infinity) y.isFinite() // false</pre> Note: The native method <code>isFinite()</code> can be used if <code>n <= Number.MAX_VALUE</code>. <h5 id="isInt">isInteger<code class='inset'>.isInt() ⇒ boolean</code></h5> Returns <code>true</code> if the value of this BigNumber is a whole number, otherwise returns <code>false</code>. <pre> x = new BigNumber(1) x.isInteger() // true y = new BigNumber(123.456) y.isInt() // false</pre> <h5 id="isNaN">isNaN<code class='inset'>.isNaN() ⇒ boolean</code></h5> Returns <code>true</code> if the value of this BigNumber is <code>NaN</code>, otherwise returns <code>false</code>. <pre> x = new BigNumber(NaN) x.isNaN() // true y = new BigNumber('Infinity') y.isNaN() // false</pre> Note: The native method <code>isNaN()</code> can also be used. <h5 id="isNeg">isNegative<code class='inset'>.isNeg() ⇒ boolean</code></h5> Returns <code>true</code> if the value of this BigNumber is negative, otherwise returns <code>false</code>. <pre> x = new BigNumber(-0) x.isNegative() // true y = new BigNumber(2) y.isNeg() // false</pre> Note: <code>n < 0</code> can be used if <code>n <= -Number.MIN_VALUE</code>. <h5 id="isZ">isZero<code class='inset'>.isZero() ⇒ boolean</code></h5> Returns <code>true</code> if the value of this BigNumber is zero or minus zero, otherwise returns <code>false</code>. <pre> x = new BigNumber(-0) x.isZero() && x.isNeg() // true y = new BigNumber(Infinity) y.isZero() // false</pre> Note: <code>n == 0</code> can be used if <code>n >= Number.MIN_VALUE</code>. <h5 id="lt">lessThan<code class='inset'>.lt(n [, base]) ⇒ boolean</code></h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns <code>true</code> if the value of this BigNumber is less than the value of <code>n</code>, otherwise returns <code>false</code>. Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally. <pre> (0.3 - 0.2) < 0.1 // true x = new BigNumber(0.3).minus(0.2) x.lessThan(0.1) // false BigNumber(0).lt(x) // true BigNumber(11.1, 2).lt(11, 3) // true</pre> <h5 id="lte"> lessThanOrEqualTo<code class='inset'>.lte(n [, base]) ⇒ boolean</code> </h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns <code>true</code> if the value of this BigNumber is less than or equal to the value of <code>n</code>, otherwise returns <code>false</code>. Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally. <pre> 0.1 <= (0.3 - 0.2) // false x = new BigNumber(0.1) x.lessThanOrEqualTo(BigNumber(0.3).minus(0.2)) // true BigNumber(-1).lte(x) // true BigNumber(10, 18).lte('i', 36) // true</pre> <h5 id="minus"> minus<code class='inset'>.minus(n [, base]) ⇒ BigNumber</code> </h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns a BigNumber whose value is the value of this BigNumber minus <code>n</code>. The return value is always exact and unrounded. <pre> 0.3 - 0.1 // 0.19999999999999998 x = new BigNumber(0.3) x.minus(0.1) // '0.2' x.minus(0.6, 20) // '0'</pre> <h5 id="mod">modulo<code class='inset'>.mod(n [, base]) ⇒ BigNumber</code></h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns a BigNumber whose value is the value of this BigNumber modulo <code>n</code>, i.e. the integer remainder of dividing this BigNumber by <code>n</code>. The value returned, and in particular its sign, is dependent on the value of the <a href='#modulo-mode'><code>MODULO_MODE</code></a> setting of this BigNumber constructor. If it is <code>1</code> (default value), the result will have the same sign as this BigNumber, and it will match that of Javascript's <code>%</code> operator (within the limits of double precision) and BigDecimal's <code>remainder</code> method. The return value is always exact and unrounded. See <a href='#modulo-mode'><code>MODULO_MODE</code></a> for a description of the other modulo modes. <pre> 1 % 0.9 // 0.09999999999999998 x = new BigNumber(1) x.modulo(0.9) // '0.1' y = new BigNumber(33) y.mod('a', 33) // '3'</pre> <h5 id="neg">negated<code class='inset'>.neg() ⇒ BigNumber</code></h5> Returns a BigNumber whose value is the value of this BigNumber negated, i.e. multiplied by <code>-1</code>. <pre> x = new BigNumber(1.8) x.negated() // '-1.8' y = new BigNumber(-1.3) y.neg() // '1.3'</pre> <h5 id="plus">plus<code class='inset'>.plus(n [, base]) ⇒ BigNumber</code></h5> <code>n</code>: number|string|BigNumber <code>base</code>: number See <a href="#bignumber">BigNumber</a> for further parameter details. Returns a BigNumber whose value is the value of this BigNumber plus <code>n</code>. The return value is always exact and unrounded. <pre> 0.1 + 0.2 // 0.30000000000000004 x = new BigNumber(0.1) y = x.plus(0.2) // '0.3' BigNumber(0.7).plus(x).plus(y) // '1' x.plus('0.1', 8) // '0.225'</pre> <h5 id="sd">precision<code class='inset'>.sd([z]) ⇒ number</code></h5> <code>z</code>: boolean|number: <code>true</code>, <code>false</code>, <code>0</code> or <code>1</code> Returns the number of significant digits of the value of this BigNumber. If <code>z</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. <pre> x = new BigNumber(1.234) x.precision() // 4 y = new BigNumber(987000) y.sd() // 3 y.sd(true) // 6</pre> <h5 id="round">round<code class='inset'>.round([dp [, rm]]) ⇒ BigNumber</code></h5> <code>dp</code>: number: integer, <code>0</code> to <