Home Explore Help
Register Sign In
fatwolf
/
ERP
1
0
Fork 0
Files Issues 0 Pull Requests 0 Wiki
Tree: 543fb683b5
Branches Tags
ERP
/
test_two_list
/
API.html

API.html 85 KB
History Raw

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237 
  1. <!DOCTYPE HTML>
    2. 

  2. <html>
    3. 

  3. <head>
    4. 

  4. <meta charset="utf-8">
    5. 

  5. <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6. 

  6. <meta name="Author" content="M Mclaughlin">
    7. 

  7. <title>bignumber.js API</title>
    8. 

  8. <style>
    9. 

  9. html{font-size:100%}
    10. 

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

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

  12. body,i{color:#000}
    13. 

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

  14.   padding:15px 0 30px 15px}
    15. 

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

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

  17. pre,ul{margin:1em 0}
    18. 

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

  19. h1,h2{padding:.75em 0}
    20. 

  20. h1{font:400 3em Verdana,sans-serif;color:#000;margin-bottom:1em}
    21. 

  21. h2{font-size:2.25em;color:#ff2a00}
    22. 

  22. h3{font-size:1.75em;color:#4dc71f}
    23. 

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

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

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

  26. dd{padding-top:.35em}
    27. 

  27. dt{padding-top:.5em}
    28. 

  28. b{font-weight:700}
    29. 

  29. dt b{font-size:1.3em}
    30. 

  30. a,a:visited{color:#ff2a00;text-decoration:none}
    31. 

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

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

  33. .nav b{color:#4dc71f;margin-top:20px;cursor:default;width:auto}
    34. 

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

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

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

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

  38. .inset,ul.inset{margin-left:20px}
    39. 

  39. .inset{font-size:.9em}
    40. 

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

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

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

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

  44. th{border-top:2px solid #a7dbd8;border-bottom:2px solid #a7dbd8;color:#ff2a00}
    45. 

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

  46. pre{background:#f5f5f5;white-space:pre-wrap;word-wrap:break-word;border-left:5px solid #abef98;
    47. 

  47.   padding:1px 0 1px 15px;margin:1.2em 0}
    48. 

  48. code,.nav-title{color:#ff2a00}
    49. 

  49. .end{margin-bottom:25px}
    50. 

  50. .centre{text-align:center}
    51. 

  51. .error-table{font-size:13px;width:100%}
    52. 

  52. #faq{margin:3em 0 0}
    53. 

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

  54. #js{font:inherit;color:#4dc71f}
    55. 

  55. </style>
    56. 

  56. </head>
    57. 

  57. <body>
    58. 

  58. 

  59.   <div class="nav">
    60. 

  60. 

  61.     <b>v8.1.0</b>
    62. 

  62. 

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

  64. 

  65.     <b> CONSTRUCTOR </b>
    66. 

  66.     <ul>
    67. 

  67.       <li><a href="#bignumber">BigNumber</a></li>
    68. 

  68.     </ul>
    69. 

  69. 

  70.     <a href="#methods">Methods</a>
    71. 

  71.     <ul>
    72. 

  72.       <li><a href="#clone">clone</a></li>
    73. 

  73.       <li><a href="#config" >config</a><span>set</span></li>
    74. 

  74.       <li>
    75. 

  75.         <ul class="inset">
    76. 

  76.           <li><a href="#decimal-places">DECIMAL_PLACES</a></li>
    77. 

  77.           <li><a href="#rounding-mode" >ROUNDING_MODE</a></li>
    78. 

  78.           <li><a href="#exponential-at">EXPONENTIAL_AT</a></li>
    79. 

  79.           <li><a href="#range"         >RANGE</a></li>
    80. 

  80.           <li><a href="#crypto"        >CRYPTO</a></li>
    81. 

  81.           <li><a href="#modulo-mode"   >MODULO_MODE</a></li>
    82. 

  82.           <li><a href="#pow-precision" >POW_PRECISION</a></li>
    83. 

  83.           <li><a href="#format"        >FORMAT</a></li>
    84. 

  84.           <li><a href="#alphabet"      >ALPHABET</a></li>
    85. 

  85.         </ul>
    86. 

  86.       </li>
    87. 

  87.       <li><a href="#isBigNumber">isBigNumber</a></li>
    88. 

  88.       <li><a href="#max"        >maximum</a><span>max</span></li>
    89. 

  89.       <li><a href="#min"        >minimum</a><span>min</span></li>
    90. 

  90.       <li><a href="#random"     >random</a></li>
    91. 

  91.       <li><a href="#sum"        >sum</a></li>
    92. 

  92.     </ul>
    93. 

  93. 

  94.     <a href="#constructor-properties">Properties</a>
    95. 

  95.     <ul>
    96. 

  96.       <li><a href="#round-up"        >ROUND_UP</a></li>
    97. 

  97.       <li><a href="#round-down"      >ROUND_DOWN</a></li>
    98. 

  98.       <li><a href="#round-ceil"      >ROUND_CEIL</a></li>
    99. 

  99.       <li><a href="#round-floor"     >ROUND_FLOOR</a></li>
    100. 

  100.       <li><a href="#round-half-up"   >ROUND_HALF_UP</a></li>
    101. 

  101.       <li><a href="#round-half-down" >ROUND_HALF_DOWN</a></li>
    102. 

  102.       <li><a href="#round-half-even" >ROUND_HALF_EVEN</a></li>
    103. 

  103.       <li><a href="#round-half-ceil" >ROUND_HALF_CEIL</a></li>
    104. 

  104.       <li><a href="#round-half-floor">ROUND_HALF_FLOOR</a></li>
    105. 

  105.       <li><a href="#debug"           >DEBUG</a></li>
    106. 

  106.     </ul>
    107. 

  107. 

  108.     <b> INSTANCE </b>
    109. 

  109. 

  110.     <a href="#prototype-methods">Methods</a>
    111. 

  111.     <ul>
    112. 

  112.       <li><a href="#abs"    >absoluteValue         </a><span>abs</span>  </li>
    113. 

  113.       <li><a href="#cmp"    >comparedTo            </a>                  </li>
    114. 

  114.       <li><a href="#dp"     >decimalPlaces         </a><span>dp</span>   </li>
    115. 

  115.       <li><a href="#div"    >dividedBy             </a><span>div</span>  </li>
    116. 

  116.       <li><a href="#divInt" >dividedToIntegerBy    </a><span>idiv</span> </li>
    117. 

  117.       <li><a href="#pow"    >exponentiatedBy       </a><span>pow</span>  </li>
    118. 

  118.       <li><a href="#int"    >integerValue          </a>                  </li>
    119. 

  119.       <li><a href="#eq"     >isEqualTo             </a><span>eq</span>   </li>
    120. 

  120.       <li><a href="#isF"    >isFinite              </a>                  </li>
    121. 

  121.       <li><a href="#gt"     >isGreaterThan         </a><span>gt</span>   </li>
    122. 

  122.       <li><a href="#gte"    >isGreaterThanOrEqualTo</a><span>gte</span>  </li>
    123. 

  123.       <li><a href="#isInt"  >isInteger             </a>                  </li>
    124. 

  124.       <li><a href="#lt"     >isLessThan            </a><span>lt</span>   </li>
    125. 

  125.       <li><a href="#lte"    >isLessThanOrEqualTo   </a><span>lte</span>  </li>
    126. 

  126.       <li><a href="#isNaN"  >isNaN                 </a>                  </li>
    127. 

  127.       <li><a href="#isNeg"  >isNegative            </a>                  </li>
    128. 

  128.       <li><a href="#isPos"  >isPositive            </a>                  </li>
    129. 

  129.       <li><a href="#isZ"    >isZero                </a>                  </li>
    130. 

  130.       <li><a href="#minus"  >minus                 </a>                  </li>
    131. 

  131.       <li><a href="#mod"    >modulo                </a><span>mod</span>  </li>
    132. 

  132.       <li><a href="#times"  >multipliedBy          </a><span>times</span></li>
    133. 

  133.       <li><a href="#neg"    >negated               </a>                  </li>
    134. 

  134.       <li><a href="#plus"   >plus                  </a>                  </li>
    135. 

  135.       <li><a href="#sd"     >precision             </a><span>sd</span>   </li>
    136. 

  136.       <li><a href="#shift"  >shiftedBy             </a>                  </li>
    137. 

  137.       <li><a href="#sqrt"   >squareRoot            </a><span>sqrt</span> </li>
    138. 

  138.       <li><a href="#toE"    >toExponential         </a>                  </li>
    139. 

  139.       <li><a href="#toFix"  >toFixed               </a>                  </li>
    140. 

  140.       <li><a href="#toFor"  >toFormat              </a>                  </li>
    141. 

  141.       <li><a href="#toFr"   >toFraction            </a>                  </li>
    142. 

  142.       <li><a href="#toJSON" >toJSON                </a>                  </li>
    143. 

  143.       <li><a href="#toN"    >toNumber              </a>                  </li>
    144. 

  144.       <li><a href="#toP"    >toPrecision           </a>                  </li>
    145. 

  145.       <li><a href="#toS"    >toString              </a>                  </li>
    146. 

  146.       <li><a href="#valueOf">valueOf               </a>                  </li>
    147. 

  147.     </ul>
    148. 

  148. 

  149.     <a href="#instance-properties">Properties</a>
    150. 

  150.     <ul>
    151. 

  151.       <li><a href="#coefficient">c: coefficient</a></li>
    152. 

  152.       <li><a href="#exponent"   >e: exponent</a></li>
    153. 

  153.       <li><a href="#sign"       >s: sign</a></li>
    154. 

  154.     </ul>
    155. 

  155. 

  156.     <a href="#zero-nan-infinity">Zero, NaN &amp; Infinity</a>
    157. 

  157.     <a href="#Errors">Errors</a>
    158. 

  158.     <a href="#type-coercion">Type coercion</a>
    159. 

  159.     <a class='end' href="#faq">FAQ</a>
    160. 

  160. 

  161.   </div>
    162. 

  162. 

  163.   <div class="container">
    164. 

  164. 

  165.     <h1>bignumber<span id='js'>.js</span></h1>
    166. 

  166. 

  167.     <p>A JavaScript library for arbitrary-precision arithmetic.</p>
    168. 

  168.     <p><a href="https://github.com/MikeMcl/bignumber.js">Hosted on GitHub</a>. </p>
    169. 

  169. 

  170.     <h2>API</h2>
    171. 

  171. 

  172.     <p>
    173. 

  173.       See the <a href='https://github.com/MikeMcl/bignumber.js'>README</a> on GitHub for a
    174. 

  174.       quick-start introduction.
    175. 

  175.     </p>
    176. 

  176.     <p>
    177. 

  177.       In all examples below, <code>var</code> and semicolons are not shown, and if a commented-out
    178. 

  178.       value is in quotes it means <code>toString</code> has been called on the preceding expression.
    179. 

  179.     </p>
    180. 

  180. 

  181. 

  182.     <h3>CONSTRUCTOR</h3>
    183. 

  183. 

  184. 

  185.     <h5 id="bignumber">
    186. 

  186.       BigNumber<code class='inset'>BigNumber(n [, base]) <i>&rArr; BigNumber</i></code>
    187. 

  187.     </h5>
    188. 

  188.     <p>
    189. 

  189.       <code>n</code>: <i>number|string|BigNumber</i><br />
    190. 

  190.       <code>base</code>: <i>number</i>: integer, <code>2</code> to <code>36</code> inclusive. (See
    191. 

  191.       <a href='#alphabet'><code>ALPHABET</code></a> to extend this range).
    192. 

  192.     </p>
    193. 

  193.     <p>
    194. 

  194.       Returns a new instance of a BigNumber object with value <code>n</code>, where <code>n</code>
    195. 

  195.       is a numeric value in the specified <code>base</code>, or base <code>10</code> if
    196. 

  196.       <code>base</code> is omitted or is <code>null</code> or <code>undefined</code>.
    197. 

  197.     </p>
    198. 

  198.     <pre>
    199. 

  199. x = new BigNumber(123.4567)                // '123.4567'
    200. 

  200. // 'new' is optional
    201. 

  201. y = BigNumber(x)                           // '123.4567'</pre>
    202. 

  202.     <p>
    203. 

  203.       If <code>n</code> is a base <code>10</code> value it can be in normal (fixed-point) or
    204. 

  204.       exponential notation. Values in other bases must be in normal notation. Values in any base can
    205. 

  205.       have fraction digits, i.e. digits after the decimal point.
    206. 

  206.     </p>
    207. 

  207.     <pre>
    208. 

  208. new BigNumber(43210)                       // '43210'
    209. 

  209. new BigNumber('4.321e+4')                  // '43210'
    210. 

  210. new BigNumber('-735.0918e-430')            // '-7.350918e-428'
    211. 

  211. new BigNumber('123412421.234324', 5)       // '607236.557696'</pre>
    212. 

  212.     <p>
    213. 

  213.       Signed <code>0</code>, signed <code>Infinity</code> and <code>NaN</code> are supported.
    214. 

  214.     </p>
    215. 

  215.     <pre>
    216. 

  216. new BigNumber('-Infinity')                 // '-Infinity'
    217. 

  217. new BigNumber(NaN)                         // 'NaN'
    218. 

  218. new BigNumber(-0)                          // '0'
    219. 

  219. new BigNumber('.5')                        // '0.5'
    220. 

  220. new BigNumber('+2')                        // '2'</pre>
    221. 

  221.     <p>
    222. 

  222.       String values in hexadecimal literal form, e.g. <code>'0xff'</code>, are valid, as are
    223. 

  223.       string values with the octal and binary prefixs <code>'0o'</code> and <code>'0b'</code>.
    224. 

  224.       String values in octal literal form without the prefix will be interpreted as
    225. 

  225.       decimals, e.g. <code>'011'</code> is interpreted as 11, not 9.
    226. 

  226.     </p>
    227. 

  227.     <pre>
    228. 

  228. new BigNumber(-10110100.1, 2)              // '-180.5'
    229. 

  229. new BigNumber('-0b10110100.1')             // '-180.5'
    230. 

  230. new BigNumber('ff.8', 16)                  // '255.5'
    231. 

  231. new BigNumber('0xff.8')                    // '255.5'</pre>
    232. 

  232.     <p>
    233. 

  233.       If a base is specified, <code>n</code> is rounded according to the current
    234. 

  234.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
    235. 

  235.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings. <em>This includes base
    236. 

  236.       <code>10</code> so don't include a <code>base</code> parameter for decimal values unless
    237. 

  237.       this behaviour is wanted.</em>
    238. 

  238.     </p>
    239. 

  239.     <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
    240. 

  240. new BigNumber(1.23456789)                  // '1.23456789'
    241. 

  241. new BigNumber(1.23456789, 10)              // '1.23457'</pre>
    242. 

  242.     <p>An error is thrown if <code>base</code> is invalid. See <a href='#Errors'>Errors</a>.</p>
    243. 

  243.     <p>
    244. 

  244.       There is no limit to the number of digits of a value of type <em>string</em> (other than
    245. 

  245.       that of JavaScript's maximum array size). See <a href='#range'><code>RANGE</code></a> to set
    246. 

  246.       the maximum and minimum possible exponent value of a BigNumber.
    247. 

  247.     </p>
    248. 

  248.     <pre>
    249. 

  249. new BigNumber('5032485723458348569331745.33434346346912144534543')
    250. 

  250. new BigNumber('4.321e10000000')</pre>
    251. 

  251.     <p>BigNumber <code>NaN</code> is returned if <code>n</code> is invalid
    252. 

  252.     (unless <code>BigNumber.DEBUG</code> is <code>true</code>, see below).</p>
    253. 

  253.     <pre>
    254. 

  254. new BigNumber('.1*')                       // 'NaN'
    255. 

  255. new BigNumber('blurgh')                    // 'NaN'
    256. 

  256. new BigNumber(9, 2)                        // 'NaN'</pre>
    257. 

  257.     <p>
    258. 

  258.       To aid in debugging, if <code>BigNumber.DEBUG</code> is <code>true</code> then an error will
    259. 

  259.       be thrown on an invalid <code>n</code>. An error will also be thrown if <code>n</code> is of
    260. 

  260.       type <em>number</em> with more than <code>15</code> significant digits, as calling
    261. 

  261.       <code><a href='#toS'>toString</a></code> or <code><a href='#valueOf'>valueOf</a></code> on
    262. 

  262.       these numbers may not result in the intended value.
    263. 

  263.     </p>
    264. 

  264.       <pre>
    265. 

  265. console.log(823456789123456.3)            //  823456789123456.2
    266. 

  266. new BigNumber(823456789123456.3)          // '823456789123456.2'
    267. 

  267. BigNumber.DEBUG = true
    268. 

  268. // '[BigNumber Error] Number primitive has more than 15 significant digits'
    269. 

  269. new BigNumber(823456789123456.3)
    270. 

  270. // '[BigNumber Error] Not a base 2 number'
    271. 

  271. new BigNumber(9, 2)</pre>
    272. 

  272.     <p>
    273. 

  273.       A BigNumber can also be created from an object literal.
    274. 

  274.       Use <code><a href='#isBigNumber'>isBigNumber</a></code> to check that it is well-formed.
    275. 

  275.     </p>
    276. 

  276.     <pre>new BigNumber({ s: 1, e: 2, c: [ 777, 12300000000000 ], _isBigNumber: true })    // '777.123'</pre>
    277. 

  277. 

  278. 

  279. 

  280. 

  281.     <h4 id="methods">Methods</h4>
    282. 

  282.      <p>The static methods of a BigNumber constructor.</p>
    283. 

  283. 

  284. 

  285. 

  286. 

  287.     <h5 id="clone">clone
    288. 

  288.       <code class='inset'>.clone([object]) <i>&rArr; BigNumber constructor</i></code>
    289. 

  289.     </h5>
    290. 

  290.     <p><code>object</code>: <i>object</i></p>
    291. 

  291.     <p>
    292. 

  292.       Returns a new independent BigNumber constructor with configuration as described by
    293. 

  293.       <code>object</code> (see <a href='#config'><code>config</code></a>), or with the default
    294. 

  294.       configuration if <code>object</code> is <code>null</code> or <code>undefined</code>.
    295. 

  295.     </p>
    296. 

  296.     <p>
    297. 

  297.       Throws if <code>object</code> is not an object. See <a href='#Errors'>Errors</a>.
    298. 

  298.     </p>
    299. 

  299.     <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
    300. 

  300. BN = BigNumber.clone({ DECIMAL_PLACES: 9 })
    301. 

  301. 

  302. x = new BigNumber(1)
    303. 

  303. y = new BN(1)
    304. 

  304. 

  305. x.div(3)                        // 0.33333
    306. 

  306. y.div(3)                        // 0.333333333
    307. 

  307. 

  308. // BN = BigNumber.clone({ DECIMAL_PLACES: 9 }) is equivalent to:
    309. 

  309. BN = BigNumber.clone()
    310. 

  310. BN.config({ DECIMAL_PLACES: 9 })</pre>
    311. 

  311. 

  312. 

  313. 

  314.     <h5 id="config">config<code class='inset'>set([object]) <i>&rArr; object</i></code></h5>
    315. 

  315.     <p>
    316. 

  316.       <code>object</code>: <i>object</i>: an object that contains some or all of the following
    317. 

  317.       properties.
    318. 

  318.     </p>
    319. 

  319.     <p>Configures the settings for this particular BigNumber constructor.</p>
    320. 

  320. 

  321.     <dl class='inset'>
    322. 

  322.       <dt id="decimal-places"><code><b>DECIMAL_PLACES</b></code></dt>
    323. 

  323.       <dd>
    324. 

  324.         <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
    325. 

  325.         Default value: <code>20</code>
    326. 

  326.       </dd>
    327. 

  327.       <dd>
    328. 

  328.         The <u>maximum</u> number of decimal places of the results of operations involving
    329. 

  329.         division, i.e. division, square root and base conversion operations, and power
    330. 

  330.         operations with negative exponents.<br />
    331. 

  331.       </dd>
    332. 

  332.       <dd>
    333. 

  333.       <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
    334. 

  334. BigNumber.set({ DECIMAL_PLACES: 5 })    // equivalent</pre>
    335. 

  335.       </dd>
    336. 

  336. 

  337. 

  338. 

  339.       <dt id="rounding-mode"><code><b>ROUNDING_MODE</b></code></dt>
    340. 

  340.       <dd>
    341. 

  341.         <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive<br />
    342. 

  342.         Default value: <code>4</code> <a href="#round-half-up">(<code>ROUND_HALF_UP</code>)</a>
    343. 

  343.       </dd>
    344. 

  344.       <dd>
    345. 

  345.         The rounding mode used in the above operations and the default rounding mode of
    346. 

  346.         <a href='#dp'><code>decimalPlaces</code></a>,
    347. 

  347.         <a href='#sd'><code>precision</code></a>,
    348. 

  348.         <a href='#toE'><code>toExponential</code></a>,
    349. 

  349.         <a href='#toFix'><code>toFixed</code></a>,
    350. 

  350.         <a href='#toFor'><code>toFormat</code></a> and
    351. 

  351.         <a href='#toP'><code>toPrecision</code></a>.
    352. 

  352.       </dd>
    353. 

  353.       <dd>The modes are available as enumerated properties of the BigNumber constructor.</dd>
    354. 

  354.        <dd>
    355. 

  355.       <pre>BigNumber.config({ ROUNDING_MODE: 0 })
    356. 

  356. BigNumber.set({ ROUNDING_MODE: BigNumber.ROUND_UP })    // equivalent</pre>
    357. 

  357.         </dd>
    358. 

  358. 

  359. 

  360. 

  361.       <dt id="exponential-at"><code><b>EXPONENTIAL_AT</b></code></dt>
    362. 

  362.       <dd>
    363. 

  363.         <i>number</i>: integer, magnitude <code>0</code> to <code>1e+9</code> inclusive, or
    364. 

  364.         <br />
    365. 

  365.         <i>number</i>[]: [ integer <code>-1e+9</code> to <code>0</code> inclusive, integer
    366. 

  366.         <code>0</code> to <code>1e+9</code> inclusive ]<br />
    367. 

  367.         Default value: <code>[-7, 20]</code>
    368. 

  368.       </dd>
    369. 

  369.       <dd>
    370. 

  370.         The exponent value(s) at which <code>toString</code> returns exponential notation.
    371. 

  371.       </dd>
    372. 

  372.       <dd>
    373. 

  373.         If a single number is assigned, the value is the exponent magnitude.<br />
    374. 

  374.         If an array of two numbers is assigned then the first number is the negative exponent
    375. 

  375.         value at and beneath which exponential notation is used, and the second number is the
    376. 

  376.         positive exponent value at and above which the same.
    377. 

  377.       </dd>
    378. 

  378.       <dd>
    379. 

  379.         For example, to emulate JavaScript numbers in terms of the exponent values at which they
    380. 

  380.         begin to use exponential notation, use <code>[-7, 20]</code>.
    381. 

  381.       </dd>
    382. 

  382.       <dd>
    383. 

  383.       <pre>BigNumber.config({ EXPONENTIAL_AT: 2 })
    384. 

  384. new BigNumber(12.3)         // '12.3'        e is only 1
    385. 

  385. new BigNumber(123)          // '1.23e+2'
    386. 

  386. new BigNumber(0.123)        // '0.123'       e is only -1
    387. 

  387. new BigNumber(0.0123)       // '1.23e-2'
    388. 

  388. 

  389. BigNumber.config({ EXPONENTIAL_AT: [-7, 20] })
    390. 

  390. new BigNumber(123456789)    // '123456789'   e is only 8
    391. 

  391. new BigNumber(0.000000123)  // '1.23e-7'
    392. 

  392. 

  393. // Almost never return exponential notation:
    394. 

  394. BigNumber.config({ EXPONENTIAL_AT: 1e+9 })
    395. 

  395. 

  396. // Always return exponential notation:
    397. 

  397. BigNumber.config({ EXPONENTIAL_AT: 0 })</pre>
    398. 

  398.       </dd>
    399. 

  399.       <dd>
    400. 

  400.         Regardless of the value of <code>EXPONENTIAL_AT</code>, the <code>toFixed</code> method
    401. 

  401.         will always return a value in normal notation and the <code>toExponential</code> method
    402. 

  402.         will always return a value in exponential form.
    403. 

  403.       </dd>
    404. 

  404.       <dd>
    405. 

  405.         Calling <code>toString</code> with a base argument, e.g. <code>toString(10)</code>, will
    406. 

  406.         also always return normal notation.
    407. 

  407.       </dd>
    408. 

  408. 

  409. 

  410. 

  411.       <dt id="range"><code><b>RANGE</b></code></dt>
    412. 

  412.       <dd>
    413. 

  413.         <i>number</i>: integer, magnitude <code>1</code> to <code>1e+9</code> inclusive, or
    414. 

  414.         <br />
    415. 

  415.         <i>number</i>[]: [ integer <code>-1e+9</code> to <code>-1</code> inclusive, integer
    416. 

  416.         <code>1</code> to <code>1e+9</code> inclusive ]<br />
    417. 

  417.         Default value: <code>[-1e+9, 1e+9]</code>
    418. 

  418.       </dd>
    419. 

  419.       <dd>
    420. 

  420.         The exponent value(s) beyond which overflow to <code>Infinity</code> and underflow to
    421. 

  421.         zero occurs.
    422. 

  422.       </dd>
    423. 

  423.       <dd>
    424. 

  424.         If a single number is assigned, it is the maximum exponent magnitude: values wth a
    425. 

  425.         positive exponent of greater magnitude become <code>Infinity</code> and those with a
    426. 

  426.         negative exponent of greater magnitude become zero.
    427. 

  427.       <dd>
    428. 

  428.         If an array of two numbers is assigned then the first number is the negative exponent
    429. 

  429.         limit and the second number is the positive exponent limit.
    430. 

  430.       </dd>
    431. 

  431.       <dd>
    432. 

  432.         For example, to emulate JavaScript numbers in terms of the exponent values at which they
    433. 

  433.         become zero and <code>Infinity</code>, use <code>[-324, 308]</code>.
    434. 

  434.       </dd>
    435. 

  435.       <dd>
    436. 

  436.       <pre>BigNumber.config({ RANGE: 500 })
    437. 

  437. BigNumber.config().RANGE     // [ -500, 500 ]
    438. 

  438. new BigNumber('9.999e499')   // '9.999e+499'
    439. 

  439. new BigNumber('1e500')       // 'Infinity'
    440. 

  440. new BigNumber('1e-499')      // '1e-499'
    441. 

  441. new BigNumber('1e-500')      // '0'
    442. 

  442. 

  443. BigNumber.config({ RANGE: [-3, 4] })
    444. 

  444. new BigNumber(99999)         // '99999'      e is only 4
    445. 

  445. new BigNumber(100000)        // 'Infinity'   e is 5
    446. 

  446. new BigNumber(0.001)         // '0.01'       e is only -3
    447. 

  447. new BigNumber(0.0001)        // '0'          e is -4</pre>
    448. 

  448.       </dd>
    449. 

  449.       <dd>
    450. 

  450.         The largest possible magnitude of a finite BigNumber is
    451. 

  451.         <code>9.999...e+1000000000</code>.<br />
    452. 

  452.         The smallest possible magnitude of a non-zero BigNumber is <code>1e-1000000000</code>.
    453. 

  453.       </dd>
    454. 

  454. 

  455. 

  456. 

  457.       <dt id="crypto"><code><b>CRYPTO</b></code></dt>
    458. 

  458.       <dd>
    459. 

  459.         <i>boolean</i>: <code>true</code> or <code>false</code>.<br />
    460. 

  460.         Default value: <code>false</code>
    461. 

  461.       </dd>
    462. 

  462.       <dd>
    463. 

  463.         The value that determines whether cryptographically-secure pseudo-random number
    464. 

  464.         generation is used.
    465. 

  465.       </dd>
    466. 

  466.       <dd>
    467. 

  467.         If <code>CRYPTO</code> is set to <code>true</code> then the
    468. 

  468.         <a href='#random'><code>random</code></a> method will generate random digits using
    469. 

  469.         <code>crypto.getRandomValues</code> in browsers that support it, or
    470. 

  470.         <code>crypto.randomBytes</code> if using Node.js.
    471. 

  471.       </dd>
    472. 

  472.       <dd>
    473. 

  473.         If neither function is supported by the host environment then attempting to set
    474. 

  474.         <code>CRYPTO</code> to <code>true</code> will fail and an exception will be thrown.
    475. 

  475.       </dd>
    476. 

  476.       <dd>
    477. 

  477.         If <code>CRYPTO</code> is <code>false</code> then the source of randomness used will be
    478. 

  478.         <code>Math.random</code> (which is assumed to generate at least <code>30</code> bits of
    479. 

  479.         randomness).
    480. 

  480.       </dd>
    481. 

  481.       <dd>See <a href='#random'><code>random</code></a>.</dd>
    482. 

  482.       <dd>
    483. 

  483.       <pre>
    484. 

  484. // Node.js
    485. 

  485. global.crypto = require('crypto')
    486. 

  486. 

  487. BigNumber.config({ CRYPTO: true })
    488. 

  488. BigNumber.config().CRYPTO       // true
    489. 

  489. BigNumber.random()              // 0.54340758610486147524</pre>
    490. 

  490.       </dd>
    491. 

  491. 

  492. 

  493. 

  494.       <dt id="modulo-mode"><code><b>MODULO_MODE</b></code></dt>
    495. 

  495.       <dd>
    496. 

  496.         <i>number</i>: integer, <code>0</code> to <code>9</code> inclusive<br />
    497. 

  497.         Default value: <code>1</code> (<a href="#round-down"><code>ROUND_DOWN</code></a>)
    498. 

  498.       </dd>
    499. 

  499.       <dd>The modulo mode used when calculating the modulus: <code>a mod n</code>.</dd>
    500. 

  500.       <dd>
    501. 

  501.         The quotient, <code>q = a / n</code>, is calculated according to the
    502. 

  502.         <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> that corresponds to the chosen
    503. 

  503.         <code>MODULO_MODE</code>.
    504. 

  504.       </dd>
    505. 

  505.       <dd>The remainder, <code>r</code>, is calculated as: <code>r = a - n * q</code>.</dd>
    506. 

  506.       <dd>
    507. 

  507.         The modes that are most commonly used for the modulus/remainder operation are shown in
    508. 

  508.         the following table. Although the other rounding modes can be used, they may not give
    509. 

  509.         useful results.
    510. 

  510.       </dd>
    511. 

  511.       <dd>
    512. 

  512.         <table>
    513. 

  513.           <tr><th>Property</th><th>Value</th><th>Description</th></tr>
    514. 

  514.           <tr>
    515. 

  515.             <td><b>ROUND_UP</b></td><td class='centre'>0</td>
    516. 

  516.             <td>
    517. 

  517.               The remainder is positive if the dividend is negative, otherwise it is negative.
    518. 

  518.             </td>
    519. 

  519.           </tr>
    520. 

  520.           <tr>
    521. 

  521.             <td><b>ROUND_DOWN</b></td><td class='centre'>1</td>
    522. 

  522.             <td>
    523. 

  523.               The remainder has the same sign as the dividend.<br />
    524. 

  524.               This uses 'truncating division' and matches the behaviour of JavaScript's
    525. 

  525.               remainder operator <code>%</code>.
    526. 

  526.             </td>
    527. 

  527.           </tr>
    528. 

  528.           <tr>
    529. 

  529.             <td><b>ROUND_FLOOR</b></td><td class='centre'>3</td>
    530. 

  530.             <td>
    531. 

  531.               The remainder has the same sign as the divisor.<br />
    532. 

  532.               This matches Python's <code>%</code> operator.
    533. 

  533.             </td>
    534. 

  534.           </tr>
    535. 

  535.           <tr>
    536. 

  536.             <td><b>ROUND_HALF_EVEN</b></td><td class='centre'>6</td>
    537. 

  537.             <td>The <i>IEEE 754</i> remainder function.</td>
    538. 

  538.           </tr>
    539. 

  539.            <tr>
    540. 

  540.              <td><b>EUCLID</b></td><td class='centre'>9</td>
    541. 

  541.              <td>
    542. 

  542.                The remainder is always positive. Euclidian division: <br />
    543. 

  543.                <code>q = sign(n) * floor(a / abs(n))</code>
    544. 

  544.              </td>
    545. 

  545.            </tr>
    546. 

  546.         </table>
    547. 

  547.       </dd>
    548. 

  548.       <dd>
    549. 

  549.         The rounding/modulo modes are available as enumerated properties of the BigNumber
    550. 

  550.         constructor.
    551. 

  551.       </dd>
    552. 

  552.       <dd>See <a href='#mod'><code>modulo</code></a>.</dd>
    553. 

  553.       <dd>
    554. 

  554.         <pre>BigNumber.config({ MODULO_MODE: BigNumber.EUCLID })
    555. 

  555. BigNumber.config({ MODULO_MODE: 9 })          // equivalent</pre>
    556. 

  556.       </dd>
    557. 

  557. 

  558. 

  559. 

  560.       <dt id="pow-precision"><code><b>POW_PRECISION</b></code></dt>
    561. 

  561.       <dd>
    562. 

  562.         <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive.<br />
    563. 

  563.         Default value: <code>0</code>
    564. 

  564.       </dd>
    565. 

  565.       <dd>
    566. 

  566.         The <i>maximum</i> precision, i.e. number of significant digits, of the result of the power
    567. 

  567.         operation (unless a modulus is specified).
    568. 

  568.       </dd>
    569. 

  569.       <dd>If set to <code>0</code>, the number of significant digits will not be limited.</dd>
    570. 

  570.       <dd>See <a href='#pow'><code>exponentiatedBy</code></a>.</dd>
    571. 

  571.       <dd><pre>BigNumber.config({ POW_PRECISION: 100 })</pre></dd>
    572. 

  572. 

  573. 

  574. 

  575.       <dt id="format"><code><b>FORMAT</b></code></dt>
    576. 

  576.       <dd><i>object</i></dd>
    577. 

  577.       <dd>
    578. 

  578.         The <code>FORMAT</code> object configures the format of the string returned by the
    579. 

  579.         <a href='#toFor'><code>toFormat</code></a> method.
    580. 

  580.       </dd>
    581. 

  581.       <dd>
    582. 

  582.         The example below shows the properties of the <code>FORMAT</code> object that are
    583. 

  583.         recognised, and their default values.
    584. 

  584.       </dd>
    585. 

  585.       <dd>
    586. 

  586.          Unlike the other configuration properties, the values of the properties of the
    587. 

  587.          <code>FORMAT</code> object will not be checked for validity. The existing
    588. 

  588.          <code>FORMAT</code> object will simply be replaced by the object that is passed in.
    589. 

  589.          The object can include any number of the properties shown below.
    590. 

  590.       </dd>
    591. 

  591.       <dd>See <a href='#toFor'><code>toFormat</code></a> for examples of usage.</dd>
    592. 

  592.       <dd>
    593. 

  593.       <pre>
    594. 

  594. BigNumber.config({
    595. 

  595.   FORMAT: {
    596. 

  596.     // string to prepend
    597. 

  597.     prefix: '',
    598. 

  598.     // decimal separator
    599. 

  599.     decimalSeparator: '.',
    600. 

  600.     // grouping separator of the integer part
    601. 

  601.     groupSeparator: ',',
    602. 

  602.     // primary grouping size of the integer part
    603. 

  603.     groupSize: 3,
    604. 

  604.     // secondary grouping size of the integer part
    605. 

  605.     secondaryGroupSize: 0,
    606. 

  606.     // grouping separator of the fraction part
    607. 

  607.     fractionGroupSeparator: ' ',
    608. 

  608.     // grouping size of the fraction part
    609. 

  609.     fractionGroupSize: 0,
    610. 

  610.     // string to append
    611. 

  611.     suffix: ''
    612. 

  612.   }
    613. 

  613. });</pre>
    614. 

  614.       </dd>
    615. 

  615. 

  616. 

  617. 

  618.       <dt id="alphabet"><code><b>ALPHABET</b></code></dt>
    619. 

  619.       <dd>
    620. 

  620.         <i>string</i><br />
    621. 

  621.         Default value: <code>'0123456789abcdefghijklmnopqrstuvwxyz'</code>
    622. 

  622.       </dd>
    623. 

  623.       <dd>
    624. 

  624.         The alphabet used for base conversion. The length of the alphabet corresponds to the
    625. 

  625.         maximum value of the base argument that can be passed to the
    626. 

  626.         <a href='#bignumber'><code>BigNumber</code></a> constructor or
    627. 

  627.         <a href='#toS'><code>toString</code></a>.
    628. 

  628.       </dd>
    629. 

  629.       <dd>
    630. 

  630.         There is no maximum length for the alphabet, but it must be at least 2 characters long, and
    631. 

  631.         it must not contain whitespace or a repeated character, or the sign indicators
    632. 

  632.         <code>'+'</code> and <code>'-'</code>, or the decimal separator <code>'.'</code>.
    633. 

  633.       </dd>
    634. 

  634.       <dd>
    635. 

  635.         <pre>// duodecimal (base 12)
    636. 

  636. BigNumber.config({ ALPHABET: '0123456789TE' })
    637. 

  637. x = new BigNumber('T', 12)
    638. 

  638. x.toString()                // '10'
    639. 

  639. x.toString(12)              // 'T'</pre>
    640. 

  640.       </dd>
    641. 

  641. 

  642. 

  643. 

  644.     </dl>
    645. 

  645.     <br /><br />
    646. 

  646.     <p>Returns an object with the above properties and their current values.</p>
    647. 

  647.     <p>
    648. 

  648.       Throws if <code>object</code> is not an object, or if an invalid value is assigned to
    649. 

  649.       one or more of the above properties. See <a href='#Errors'>Errors</a>.
    650. 

  650.     </p>
    651. 

  651.     <pre>
    652. 

  652. BigNumber.config({
    653. 

  653.   DECIMAL_PLACES: 40,
    654. 

  654.   ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
    655. 

  655.   EXPONENTIAL_AT: [-10, 20],
    656. 

  656.   RANGE: [-500, 500],
    657. 

  657.   CRYPTO: true,
    658. 

  658.   MODULO_MODE: BigNumber.ROUND_FLOOR,
    659. 

  659.   POW_PRECISION: 80,
    660. 

  660.   FORMAT: {
    661. 

  661.     groupSize: 3,
    662. 

  662.     groupSeparator: ' ',
    663. 

  663.     decimalSeparator: ','
    664. 

  664.   },
    665. 

  665.   ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
    666. 

  666. });
    667. 

  667. 

  668. obj = BigNumber.config();
    669. 

  669. obj.DECIMAL_PLACES        // 40
    670. 

  670. obj.RANGE                 // [-500, 500]</pre>
    671. 

  671. 

  672. 

  673. 

  674.     <h5 id="isBigNumber">
    675. 

  675.       isBigNumber<code class='inset'>.isBigNumber(value) <i>&rArr; boolean</i></code>
    676. 

  676.     </h5>
    677. 

  677.     <p><code>value</code>: <i>any</i><br /></p>
    678. 

  678.     <p>
    679. 

  679.       Returns <code>true</code> if <code>value</code> is a BigNumber instance, otherwise returns
    680. 

  680.       <code>false</code>.
    681. 

  681.     </p>
    682. 

  682.     <pre>x = 42
    683. 

  683. y = new BigNumber(x)
    684. 

  684. 

  685. BigNumber.isBigNumber(x)             // false
    686. 

  686. y instanceof BigNumber               // true
    687. 

  687. BigNumber.isBigNumber(y)             // true
    688. 

  688. 

  689. BN = BigNumber.clone();
    690. 

  690. z = new BN(x)
    691. 

  691. z instanceof BigNumber               // false
    692. 

  692. BigNumber.isBigNumber(z)             // true</pre>
    693. 

  693.     <p>
    694. 

  694.       If <code>value</code> is a BigNumber instance and <code>BigNumber.DEBUG</code> is <code>true</code>,
    695. 

  695.       then this method will also check if <code>value</code> is well-formed, and throw if it is not.
    696. 

  696.       See <a href='#Errors'>Errors</a>.
    697. 

  697.     </p>
    698. 

  698.     <p>
    699. 

  699.       The check can be useful if creating a BigNumber from an object literal.
    700. 

  700.       See <a href='#bignumber'>BigNumber</a>.
    701. 

  701.     </p>
    702. 

  702.     <pre>
    703. 

  703. x = new BigNumber(10)
    704. 

  704. 

  705. // Change x.c to an illegitimate value.
    706. 

  706. x.c = NaN
    707. 

  707. 

  708. BigNumber.DEBUG = false
    709. 

  709. 

  710. // No error.
    711. 

  711. BigNumber.isBigNumber(x)    // true
    712. 

  712. 

  713. BigNumber.DEBUG = true
    714. 

  714. 

  715. // Error.
    716. 

  716. BigNumber.isBigNumber(x)    // '[BigNumber Error] Invalid BigNumber'</pre>
    717. 

  717. 

  718. 

  719. 

  720.     <h5 id="max">maximum<code class='inset'>.max(n...) <i>&rArr; BigNumber</i></code></h5>
    721. 

  721.     <p>
    722. 

  722.       <code>n</code>: <i>number|string|BigNumber</i><br />
    723. 

  723.       <i>See <code><a href="#bignumber">BigNumber</a></code> for further parameter details.</i>
    724. 

  724.     </p>
    725. 

  725.     <p>
    726. 

  726.       Returns a BigNumber whose value is the maximum of the arguments.
    727. 

  727.     </p>
    728. 

  728.     <p>The return value is always exact and unrounded.</p>
    729. 

  729.     <pre>x = new BigNumber('3257869345.0378653')
    730. 

  730. BigNumber.maximum(4e9, x, '123456789.9')      // '4000000000'
    731. 

  731. 

  732. arr = [12, '13', new BigNumber(14)]
    733. 

  733. BigNumber.max.apply(null, arr)                // '14'</pre>
    734. 

  734. 

  735. 

  736. 

  737.     <h5 id="min">minimum<code class='inset'>.min(n...) <i>&rArr; BigNumber</i></code></h5>
    738. 

  738.     <p>
    739. 

  739.       <code>n</code>: <i>number|string|BigNumber</i><br />
    740. 

  740.       <i>See <code><a href="#bignumber">BigNumber</a></code> for further parameter details.</i>
    741. 

  741.     </p>
    742. 

  742.     <p>
    743. 

  743.       Returns a BigNumber whose value is the minimum of the arguments.
    744. 

  744.     </p>
    745. 

  745.     <p>The return value is always exact and unrounded.</p>
    746. 

  746.     <pre>x = new BigNumber('3257869345.0378653')
    747. 

  747. BigNumber.minimum(4e9, x, '123456789.9')      // '123456789.9'
    748. 

  748. 

  749. arr = [2, new BigNumber(-14), '-15.9999', -12]
    750. 

  750. BigNumber.min.apply(null, arr)                // '-15.9999'</pre>
    751. 

  751. 

  752. 

  753. 

  754.     <h5 id="random">
    755. 

  755.       random<code class='inset'>.random([dp]) <i>&rArr; BigNumber</i></code>
    756. 

  756.     </h5>
    757. 

  757.     <p><code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive</p>
    758. 

  758.     <p>
    759. 

  759.       Returns a new BigNumber with a pseudo-random value equal to or greater than <code>0</code> and
    760. 

  760.       less than <code>1</code>.
    761. 

  761.     </p>
    762. 

  762.     <p>
    763. 

  763.       The return value will have <code>dp</code> decimal places (or less if trailing zeros are
    764. 

  764.       produced).<br />
    765. 

  765.       If <code>dp</code> is omitted then the number of decimal places will default to the current
    766. 

  766.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> setting.
    767. 

  767.     </p>
    768. 

  768.     <p>
    769. 

  769.       Depending on the value of this BigNumber constructor's
    770. 

  770.       <a href='#crypto'><code>CRYPTO</code></a> setting and the support for the
    771. 

  771.       <code>crypto</code> object in the host environment, the random digits of the return value are
    772. 

  772.       generated by either <code>Math.random</code> (fastest), <code>crypto.getRandomValues</code>
    773. 

  773.       (Web Cryptography API in recent browsers) or <code>crypto.randomBytes</code> (Node.js).
    774. 

  774.     </p>
    775. 

  775.     <p>
    776. 

  776.       To be able to set <a href='#crypto'><code>CRYPTO</code></a> to <code>true</code> when using
    777. 

  777.       Node.js, the <code>crypto</code> object must be available globally:
    778. 

  778.     </p>
    779. 

  779.     <pre>global.crypto = require('crypto')</pre>
    780. 

  780.     <p>
    781. 

  781.       If <a href='#crypto'><code>CRYPTO</code></a> is <code>true</code>, i.e. one of the
    782. 

  782.       <code>crypto</code> methods is to be used, the value of a returned BigNumber should be
    783. 

  783.       cryptographically-secure and statistically indistinguishable from a random value.
    784. 

  784.     </p>
    785. 

  785.     <p>
    786. 

  786.       Throws if <code>dp</code> is invalid. See <a href='#Errors'>Errors</a>.
    787. 

  787.     </p>
    788. 

  788.     <pre>BigNumber.config({ DECIMAL_PLACES: 10 })
    789. 

  789. BigNumber.random()              // '0.4117936847'
    790. 

  790. BigNumber.random(20)            // '0.78193327636914089009'</pre>
    791. 

  791. 

  792. 

  793. 

  794.     <h5 id="sum">sum<code class='inset'>.sum(n...) <i>&rArr; BigNumber</i></code></h5>
    795. 

  795.     <p>
    796. 

  796.       <code>n</code>: <i>number|string|BigNumber</i><br />
    797. 

  797.       <i>See <code><a href="#bignumber">BigNumber</a></code> for further parameter details.</i>
    798. 

  798.     </p>
    799. 

  799.     <p>Returns a BigNumber whose value is the sum of the arguments.</p>
    800. 

  800.     <p>The return value is always exact and unrounded.</p>
    801. 

  801.     <pre>x = new BigNumber('3257869345.0378653')
    802. 

  802. BigNumber.sum(4e9, x, '123456789.9')      // '7381326134.9378653'
    803. 

  803. 

  804. arr = [2, new BigNumber(14), '15.9999', 12]
    805. 

  805. BigNumber.sum.apply(null, arr)            // '43.9999'</pre>
    806. 

  806. 

  807. 

  808. 

  809.     <h4 id="constructor-properties">Properties</h4>
    810. 

  810.     <p>
    811. 

  811.       The library's enumerated rounding modes are stored as properties of the constructor.<br />
    812. 

  812.       (They are not referenced internally by the library itself.)
    813. 

  813.     </p>
    814. 

  814.     <p>
    815. 

  815.       Rounding modes <code>0</code> to <code>6</code> (inclusive) are the same as those of Java's
    816. 

  816.       BigDecimal class.
    817. 

  817.     </p>
    818. 

  818.     <table>
    819. 

  819.       <tr>
    820. 

  820.         <th>Property</th>
    821. 

  821.         <th>Value</th>
    822. 

  822.         <th>Description</th>
    823. 

  823.       </tr>
    824. 

  824.       <tr>
    825. 

  825.         <td id="round-up"><b>ROUND_UP</b></td>
    826. 

  826.         <td class='centre'>0</td>
    827. 

  827.         <td>Rounds away from zero</td>
    828. 

  828.       </tr>
    829. 

  829.       <tr>
    830. 

  830.         <td id="round-down"><b>ROUND_DOWN</b></td>
    831. 

  831.         <td class='centre'>1</td>
    832. 

  832.         <td>Rounds towards zero</td>
    833. 

  833.       </tr>
    834. 

  834.       <tr>
    835. 

  835.         <td id="round-ceil"><b>ROUND_CEIL</b></td>
    836. 

  836.         <td class='centre'>2</td>
    837. 

  837.         <td>Rounds towards <code>Infinity</code></td>
    838. 

  838.       </tr>
    839. 

  839.       <tr>
    840. 

  840.         <td id="round-floor"><b>ROUND_FLOOR</b></td>
    841. 

  841.         <td class='centre'>3</td>
    842. 

  842.         <td>Rounds towards <code>-Infinity</code></td>
    843. 

  843.       </tr>
    844. 

  844.       <tr>
    845. 

  845.         <td id="round-half-up"><b>ROUND_HALF_UP</b></td>
    846. 

  846.         <td class='centre'>4</td>
    847. 

  847.         <td>
    848. 

  848.           Rounds towards nearest neighbour.<br />
    849. 

  849.           If equidistant, rounds away from zero
    850. 

  850.         </td>
    851. 

  851.       </tr>
    852. 

  852.       <tr>
    853. 

  853.         <td id="round-half-down"><b>ROUND_HALF_DOWN</b></td>
    854. 

  854.         <td class='centre'>5</td>
    855. 

  855.         <td>
    856. 

  856.           Rounds towards nearest neighbour.<br />
    857. 

  857.           If equidistant, rounds towards zero
    858. 

  858.         </td>
    859. 

  859.       </tr>
    860. 

  860.       <tr>
    861. 

  861.         <td id="round-half-even"><b>ROUND_HALF_EVEN</b></td>
    862. 

  862.         <td class='centre'>6</td>
    863. 

  863.         <td>
    864. 

  864.           Rounds towards nearest neighbour.<br />
    865. 

  865.           If equidistant, rounds towards even neighbour
    866. 

  866.         </td>
    867. 

  867.       </tr>
    868. 

  868.       <tr>
    869. 

  869.         <td id="round-half-ceil"><b>ROUND_HALF_CEIL</b></td>
    870. 

  870.         <td class='centre'>7</td>
    871. 

  871.         <td>
    872. 

  872.           Rounds towards nearest neighbour.<br />
    873. 

  873.           If equidistant, rounds towards <code>Infinity</code>
    874. 

  874.         </td>
    875. 

  875.       </tr>
    876. 

  876.       <tr>
    877. 

  877.         <td id="round-half-floor"><b>ROUND_HALF_FLOOR</b></td>
    878. 

  878.         <td class='centre'>8</td>
    879. 

  879.         <td>
    880. 

  880.           Rounds towards nearest neighbour.<br />
    881. 

  881.           If equidistant, rounds towards <code>-Infinity</code>
    882. 

  882.         </td>
    883. 

  883.       </tr>
    884. 

  884.     </table>
    885. 

  885.     <pre>
    886. 

  886. BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_CEIL })
    887. 

  887. BigNumber.config({ ROUNDING_MODE: 2 })     // equivalent</pre>
    888. 

  888. 

  889.     <h5 id="debug">DEBUG</h5>
    890. 

  890.     <p><i>undefined|false|true</i></p>
    891. 

  891.     <p>
    892. 

  892.       If <code>BigNumber.DEBUG</code> is set <code>true</code> then an error will be thrown
    893. 

  893.       if this <a href='#bignumber'>BigNumber</a> constructor receives an invalid value, such as
    894. 

  894.       a value of type <em>number</em> with more than <code>15</code> significant digits.
    895. 

  895.       See <a href='#bignumber'>BigNumber</a>.
    896. 

  896.     </p>
    897. 

  897.     <p>
    898. 

  898.       An error will also be thrown if the <code><a href='#isBigNumber'>isBigNumber</a></code>
    899. 

  899.       method receives a BigNumber that is not well-formed.
    900. 

  900.       See <code><a href='#isBigNumber'>isBigNumber</a></code>.
    901. 

  901.     </p>
    902. 

  902.     <pre>BigNumber.DEBUG = true</pre>
    903. 

  903. 

  904. 

  905.     <h3>INSTANCE</h3>
    906. 

  906. 

  907. 

  908.     <h4 id="prototype-methods">Methods</h4>
    909. 

  909.     <p>The methods inherited by a BigNumber instance from its constructor's prototype object.</p>
    910. 

  910.     <p>A BigNumber is immutable in the sense that it is not changed by its methods. </p>
    911. 

  911.     <p>
    912. 

  912.       The treatment of &plusmn;<code>0</code>, &plusmn;<code>Infinity</code> and <code>NaN</code> is
    913. 

  913.       consistent with how JavaScript treats these values.
    914. 

  914.     </p>
    915. 

  915.     <p>Many method names have a shorter alias.</p>
    916. 

  916. 

  917. 

  918. 

  919.     <h5 id="abs">absoluteValue<code class='inset'>.abs() <i>&rArr; BigNumber</i></code></h5>
    920. 

  920.     <p>
    921. 

  921.       Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of
    922. 

  922.       this BigNumber.
    923. 

  923.     </p>
    924. 

  924.     <p>The return value is always exact and unrounded.</p>
    925. 

  925.     <pre>
    926. 

  926. x = new BigNumber(-0.8)
    927. 

  927. y = x.absoluteValue()           // '0.8'
    928. 

  928. z = y.abs()                     // '0.8'</pre>
    929. 

  929. 

  930. 

  931. 

  932.     <h5 id="cmp">
    933. 

  933.       comparedTo<code class='inset'>.comparedTo(n [, base]) <i>&rArr; number</i></code>
    934. 

  934.     </h5>
    935. 

  935.     <p>
    936. 

  936.       <code>n</code>: <i>number|string|BigNumber</i><br />
    937. 

  937.       <code>base</code>: <i>number</i><br />
    938. 

  938.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    939. 

  939.     </p>
    940. 

  940.     <table>
    941. 

  941.       <tr><th>Returns</th><th>&nbsp;</th></tr>
    942. 

  942.       <tr>
    943. 

  943.         <td class='centre'><code>1</code></td>
    944. 

  944.         <td>If the value of this BigNumber is greater than the value of <code>n</code></td>
    945. 

  945.       </tr>
    946. 

  946.       <tr>
    947. 

  947.         <td class='centre'><code>-1</code></td>
    948. 

  948.         <td>If the value of this BigNumber is less than the value of <code>n</code></td>
    949. 

  949.       </tr>
    950. 

  950.       <tr>
    951. 

  951.         <td class='centre'><code>0</code></td>
    952. 

  952.         <td>If this BigNumber and <code>n</code> have the same value</td>
    953. 

  953.       </tr>
    954. 

  954.        <tr>
    955. 

  955.         <td class='centre'><code>null</code></td>
    956. 

  956.         <td>If the value of either this BigNumber or <code>n</code> is <code>NaN</code></td>
    957. 

  957.       </tr>
    958. 

  958.     </table>
    959. 

  959.     <pre>
    960. 

  960. x = new BigNumber(Infinity)
    961. 

  961. y = new BigNumber(5)
    962. 

  962. x.comparedTo(y)                 // 1
    963. 

  963. x.comparedTo(x.minus(1))        // 0
    964. 

  964. y.comparedTo(NaN)               // null
    965. 

  965. y.comparedTo('110', 2)          // -1</pre>
    966. 

  966. 

  967. 

  968. 

  969.     <h5 id="dp">
    970. 

  970.       decimalPlaces<code class='inset'>.dp([dp [, rm]]) <i>&rArr; BigNumber|number</i></code>
    971. 

  971.     </h5>
    972. 

  972.     <p>
    973. 

  973.       <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
    974. 

  974.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    975. 

  975.     </p>
    976. 

  976.     <p>
    977. 

  977.       If <code>dp</code> is a number, returns a BigNumber whose value is the value of this BigNumber
    978. 

  978.       rounded by rounding mode <code>rm</code> to a maximum of <code>dp</code> decimal places.
    979. 

  979.     </p>
    980. 

  980.     <p>
    981. 

  981.       If <code>dp</code> is omitted, or is <code>null</code> or <code>undefined</code>, the return
    982. 

  982.       value is the number of decimal places of the value of this BigNumber, or <code>null</code> if
    983. 

  983.       the value of this BigNumber is &plusmn;<code>Infinity</code> or <code>NaN</code>.
    984. 

  984.     </p>
    985. 

  985.     <p>
    986. 

  986.       If <code>rm</code> is omitted, or is <code>null</code> or <code>undefined</code>,
    987. 

  987.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
    988. 

  988.     </p>
    989. 

  989.     <p>
    990. 

  990.       Throws if <code>dp</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
    991. 

  991.     </p>
    992. 

  992.     <pre>
    993. 

  993. x = new BigNumber(1234.56)
    994. 

  994. x.decimalPlaces(1)                     // '1234.6'
    995. 

  995. x.dp()                                 // 2
    996. 

  996. x.decimalPlaces(2)                     // '1234.56'
    997. 

  997. x.dp(10)                               // '1234.56'
    998. 

  998. x.decimalPlaces(0, 1)                  // '1234'
    999. 

  999. x.dp(0, 6)                             // '1235'
    1000. 

  1000. x.decimalPlaces(1, 1)                  // '1234.5'
    1001. 

  1001. x.dp(1, BigNumber.ROUND_HALF_EVEN)     // '1234.6'
    1002. 

  1002. x                                      // '1234.56'
    1003. 

  1003. y = new BigNumber('9.9e-101')
    1004. 

  1004. y.dp()                                 // 102</pre>
    1005. 

  1005. 

  1006. 

  1007. 

  1008.     <h5 id="div">dividedBy<code class='inset'>.div(n [, base]) <i>&rArr; BigNumber</i></code>
    1009. 

  1009.     </h5>
    1010. 

  1010.     <p>
    1011. 

  1011.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1012. 

  1012.       <code>base</code>: <i>number</i><br />
    1013. 

  1013.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1014. 

  1014.     </p>
    1015. 

  1015.     <p>
    1016. 

  1016.       Returns a BigNumber whose value is the value of this BigNumber divided by
    1017. 

  1017.       <code>n</code>, rounded according to the current
    1018. 

  1018.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
    1019. 

  1019.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
    1020. 

  1020.     </p>
    1021. 

  1021.     <pre>
    1022. 

  1022. x = new BigNumber(355)
    1023. 

  1023. y = new BigNumber(113)
    1024. 

  1024. x.dividedBy(y)                  // '3.14159292035398230088'
    1025. 

  1025. x.div(5)                        // '71'
    1026. 

  1026. x.div(47, 16)                   // '5'</pre>
    1027. 

  1027. 

  1028. 

  1029. 

  1030.     <h5 id="divInt">
    1031. 

  1031.       dividedToIntegerBy<code class='inset'>.idiv(n [, base]) &rArr;
    1032. 

  1032.       <i>BigNumber</i></code>
    1033. 

  1033.     </h5>
    1034. 

  1034.     <p>
    1035. 

  1035.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1036. 

  1036.       <code>base</code>: <i>number</i><br />
    1037. 

  1037.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1038. 

  1038.     </p>
    1039. 

  1039.     <p>
    1040. 

  1040.       Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by
    1041. 

  1041.       <code>n</code>.
    1042. 

  1042.     </p>
    1043. 

  1043.     <pre>
    1044. 

  1044. x = new BigNumber(5)
    1045. 

  1045. y = new BigNumber(3)
    1046. 

  1046. x.dividedToIntegerBy(y)         // '1'
    1047. 

  1047. x.idiv(0.7)                     // '7'
    1048. 

  1048. x.idiv('0.f', 16)               // '5'</pre>
    1049. 

  1049. 

  1050. 

  1051. 

  1052.     <h5 id="pow">
    1053. 

  1053.       exponentiatedBy<code class='inset'>.pow(n [, m]) <i>&rArr; BigNumber</i></code>
    1054. 

  1054.     </h5>
    1055. 

  1055.     <p>
    1056. 

  1056.       <code>n</code>: <i>number|string|BigNumber</i>: integer<br />
    1057. 

  1057.       <code>m</code>: <i>number|string|BigNumber</i>
    1058. 

  1058.     </p>
    1059. 

  1059.     <p>
    1060. 

  1060.       Returns a BigNumber whose value is the value of this BigNumber exponentiated by
    1061. 

  1061.       <code>n</code>, i.e. raised to the power <code>n</code>, and optionally modulo a modulus
    1062. 

  1062.       <code>m</code>.
    1063. 

  1063.     </p>
    1064. 

  1064.     <p>
    1065. 

  1065.       Throws if <code>n</code> is not an integer. See <a href='#Errors'>Errors</a>.
    1066. 

  1066.     </p>
    1067. 

  1067.     <p>
    1068. 

  1068.       If <code>n</code> is negative the result is rounded according to the current
    1069. 

  1069.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
    1070. 

  1070.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
    1071. 

  1071.     </p>
    1072. 

  1072.     <p>
    1073. 

  1073.       As the number of digits of the result of the power operation can grow so large so quickly,
    1074. 

  1074.       e.g. 123.456<sup>10000</sup> has over <code>50000</code> digits, the number of significant
    1075. 

  1075.       digits calculated is limited to the value of the
    1076. 

  1076.       <a href='#pow-precision'><code>POW_PRECISION</code></a> setting (unless a modulus
    1077. 

  1077.       <code>m</code> is specified).
    1078. 

  1078.     </p>
    1079. 

  1079.     <p>
    1080. 

  1080.       By default <a href='#pow-precision'><code>POW_PRECISION</code></a> is set to <code>0</code>.
    1081. 

  1081.       This means that an unlimited number of significant digits will be calculated, and that the
    1082. 

  1082.       method's performance will decrease dramatically for larger exponents.
    1083. 

  1083.     </p>
    1084. 

  1084.     <p>
    1085. 

  1085.       If <code>m</code> is specified and the value of <code>m</code>, <code>n</code> and this
    1086. 

  1086.       BigNumber are integers, and <code>n</code> is positive, then a fast modular exponentiation
    1087. 

  1087.       algorithm is used, otherwise the operation will be performed as
    1088. 

  1088.       <code>x.exponentiatedBy(n).modulo(m)</code> with a
    1089. 

  1089.       <a href='#pow-precision'><code>POW_PRECISION</code></a> of <code>0</code>.
    1090. 

  1090.     </p>
    1091. 

  1091.     <pre>
    1092. 

  1092. Math.pow(0.7, 2)                // 0.48999999999999994
    1093. 

  1093. x = new BigNumber(0.7)
    1094. 

  1094. x.exponentiatedBy(2)            // '0.49'
    1095. 

  1095. BigNumber(3).pow(-2)            // '0.11111111111111111111'</pre>
    1096. 

  1096. 

  1097. 

  1098. 

  1099.     <h5 id="int">
    1100. 

  1100.       integerValue<code class='inset'>.integerValue([rm]) <i>&rArr; BigNumber</i></code>
    1101. 

  1101.     </h5>
    1102. 

  1102.     <p>
    1103. 

  1103.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1104. 

  1104.     </p>
    1105. 

  1105.    <p>
    1106. 

  1106.       Returns a BigNumber whose value is the value of this BigNumber rounded to an integer using
    1107. 

  1107.       rounding mode <code>rm</code>.
    1108. 

  1108.     </p>
    1109. 

  1109.     <p>
    1110. 

  1110.       If <code>rm</code> is omitted, or is <code>null</code> or <code>undefined</code>,
    1111. 

  1111.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
    1112. 

  1112.     </p>
    1113. 

  1113.     <p>
    1114. 

  1114.       Throws if <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
    1115. 

  1115.     </p>
    1116. 

  1116.     <pre>
    1117. 

  1117. x = new BigNumber(123.456)
    1118. 

  1118. x.integerValue()                        // '123'
    1119. 

  1119. x.integerValue(BigNumber.ROUND_CEIL)    // '124'
    1120. 

  1120. y = new BigNumber(-12.7)
    1121. 

  1121. y.integerValue()                        // '-13'
    1122. 

  1122. y.integerValue(BigNumber.ROUND_DOWN)    // '-12'</pre>
    1123. 

  1123.     <p>
    1124. 

  1124.       The following is an example of how to add a prototype method that emulates JavaScript's
    1125. 

  1125.       <code>Math.round</code> function. <code>Math.ceil</code>, <code>Math.floor</code> and
    1126. 

  1126.       <code>Math.trunc</code> can be emulated in the same way with
    1127. 

  1127.       <code>BigNumber.ROUND_CEIL</code>, <code>BigNumber.ROUND_FLOOR</code> and
    1128. 

  1128.       <code> BigNumber.ROUND_DOWN</code> respectively.
    1129. 

  1129.     </p>
    1130. 

  1130.     <pre>
    1131. 

  1131. BigNumber.prototype.round = function (n) {
    1132. 

  1132.   return n.integerValue(BigNumber.ROUND_HALF_CEIL);
    1133. 

  1133. };
    1134. 

  1134. x.round()                               // '123'</pre>
    1135. 

  1135. 

  1136. 

  1137. 

  1138.     <h5 id="eq">isEqualTo<code class='inset'>.eq(n [, base]) <i>&rArr; boolean</i></code></h5>
    1139. 

  1139.     <p>
    1140. 

  1140.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1141. 

  1141.       <code>base</code>: <i>number</i><br />
    1142. 

  1142.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1143. 

  1143.     </p>
    1144. 

  1144.     <p>
    1145. 

  1145.       Returns <code>true</code> if the value of this BigNumber is equal to the value of
    1146. 

  1146.       <code>n</code>, otherwise returns <code>false</code>.<br />
    1147. 

  1147.       As with JavaScript, <code>NaN</code> does not equal <code>NaN</code>.
    1148. 

  1148.     </p>
    1149. 

  1149.     <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
    1150. 

  1150.     <pre>
    1151. 

  1151. 0 === 1e-324                    // true
    1152. 

  1152. x = new BigNumber(0)
    1153. 

  1153. x.isEqualTo('1e-324')           // false
    1154. 

  1154. BigNumber(-0).eq(x)             // true  ( -0 === 0 )
    1155. 

  1155. BigNumber(255).eq('ff', 16)     // true
    1156. 

  1156. 

  1157. y = new BigNumber(NaN)
    1158. 

  1158. y.isEqualTo(NaN)                // false</pre>
    1159. 

  1159. 

  1160. 

  1161. 

  1162.     <h5 id="isF">isFinite<code class='inset'>.isFinite() <i>&rArr; boolean</i></code></h5>
    1163. 

  1163.     <p>
    1164. 

  1164.       Returns <code>true</code> if the value of this BigNumber is a finite number, otherwise
    1165. 

  1165.       returns <code>false</code>.
    1166. 

  1166.     </p>
    1167. 

  1167.     <p>
    1168. 

  1168.       The only possible non-finite values of a BigNumber are <code>NaN</code>, <code>Infinity</code>
    1169. 

  1169.       and <code>-Infinity</code>.
    1170. 

  1170.     </p>
    1171. 

  1171.     <pre>
    1172. 

  1172. x = new BigNumber(1)
    1173. 

  1173. x.isFinite()                    // true
    1174. 

  1174. y = new BigNumber(Infinity)
    1175. 

  1175. y.isFinite()                    // false</pre>
    1176. 

  1176.     <p>
    1177. 

  1177.       Note: The native method <code>isFinite()</code> can be used if
    1178. 

  1178.       <code>n &lt;= Number.MAX_VALUE</code>.
    1179. 

  1179.     </p>
    1180. 

  1180. 

  1181. 

  1182. 

  1183.     <h5 id="gt">isGreaterThan<code class='inset'>.gt(n [, base]) <i>&rArr; boolean</i></code></h5>
    1184. 

  1184.     <p>
    1185. 

  1185.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1186. 

  1186.       <code>base</code>: <i>number</i><br />
    1187. 

  1187.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1188. 

  1188.     </p>
    1189. 

  1189.     <p>
    1190. 

  1190.       Returns <code>true</code> if the value of this BigNumber is greater than the value of
    1191. 

  1191.       <code>n</code>, otherwise returns <code>false</code>.
    1192. 

  1192.     </p>
    1193. 

  1193.     <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
    1194. 

  1194.     <pre>
    1195. 

  1195. 0.1 &gt; (0.3 - 0.2)                             // true
    1196. 

  1196. x = new BigNumber(0.1)
    1197. 

  1197. x.isGreaterThan(BigNumber(0.3).minus(0.2))    // false
    1198. 

  1198. BigNumber(0).gt(x)                            // false
    1199. 

  1199. BigNumber(11, 3).gt(11.1, 2)                  // true</pre>
    1200. 

  1200. 

  1201. 

  1202. 

  1203.     <h5 id="gte">
    1204. 

  1204.       isGreaterThanOrEqualTo<code class='inset'>.gte(n [, base]) <i>&rArr; boolean</i></code>
    1205. 

  1205.     </h5>
    1206. 

  1206.     <p>
    1207. 

  1207.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1208. 

  1208.       <code>base</code>: <i>number</i><br />
    1209. 

  1209.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1210. 

  1210.     </p>
    1211. 

  1211.     <p>
    1212. 

  1212.       Returns <code>true</code> if the value of this BigNumber is greater than or equal to the value
    1213. 

  1213.       of <code>n</code>, otherwise returns <code>false</code>.
    1214. 

  1214.     </p>
    1215. 

  1215.     <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
    1216. 

  1216.     <pre>
    1217. 

  1217. (0.3 - 0.2) &gt;= 0.1                     // false
    1218. 

  1218. x = new BigNumber(0.3).minus(0.2)
    1219. 

  1219. x.isGreaterThanOrEqualTo(0.1)          // true
    1220. 

  1220. BigNumber(1).gte(x)                    // true
    1221. 

  1221. BigNumber(10, 18).gte('i', 36)         // true</pre>
    1222. 

  1222. 

  1223. 

  1224. 

  1225.     <h5 id="isInt">isInteger<code class='inset'>.isInteger() <i>&rArr; boolean</i></code></h5>
    1226. 

  1226.     <p>
    1227. 

  1227.       Returns <code>true</code> if the value of this BigNumber is an integer, otherwise returns
    1228. 

  1228.       <code>false</code>.
    1229. 

  1229.     </p>
    1230. 

  1230.     <pre>
    1231. 

  1231. x = new BigNumber(1)
    1232. 

  1232. x.isInteger()                   // true
    1233. 

  1233. y = new BigNumber(123.456)
    1234. 

  1234. y.isInteger()                   // false</pre>
    1235. 

  1235. 

  1236. 

  1237. 

  1238.     <h5 id="lt">isLessThan<code class='inset'>.lt(n [, base]) <i>&rArr; boolean</i></code></h5>
    1239. 

  1239.     <p>
    1240. 

  1240.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1241. 

  1241.       <code>base</code>: <i>number</i><br />
    1242. 

  1242.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1243. 

  1243.     </p>
    1244. 

  1244.     <p>
    1245. 

  1245.       Returns <code>true</code> if the value of this BigNumber is less than the value of
    1246. 

  1246.       <code>n</code>, otherwise returns <code>false</code>.
    1247. 

  1247.     </p>
    1248. 

  1248.      <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
    1249. 

  1249.     <pre>
    1250. 

  1250. (0.3 - 0.2) &lt; 0.1                       // true
    1251. 

  1251. x = new BigNumber(0.3).minus(0.2)
    1252. 

  1252. x.isLessThan(0.1)                       // false
    1253. 

  1253. BigNumber(0).lt(x)                      // true
    1254. 

  1254. BigNumber(11.1, 2).lt(11, 3)            // true</pre>
    1255. 

  1255. 

  1256. 

  1257. 

  1258.     <h5 id="lte">
    1259. 

  1259.       isLessThanOrEqualTo<code class='inset'>.lte(n [, base]) <i>&rArr; boolean</i></code>
    1260. 

  1260.     </h5>
    1261. 

  1261.     <p>
    1262. 

  1262.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1263. 

  1263.       <code>base</code>: <i>number</i><br />
    1264. 

  1264.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1265. 

  1265.     </p>
    1266. 

  1266.     <p>
    1267. 

  1267.       Returns <code>true</code> if the value of this BigNumber is less than or equal to the value of
    1268. 

  1268.       <code>n</code>, otherwise returns <code>false</code>.
    1269. 

  1269.     </p>
    1270. 

  1270.     <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
    1271. 

  1271.     <pre>
    1272. 

  1272. 0.1 &lt;= (0.3 - 0.2)                                // false
    1273. 

  1273. x = new BigNumber(0.1)
    1274. 

  1274. x.isLessThanOrEqualTo(BigNumber(0.3).minus(0.2))  // true
    1275. 

  1275. BigNumber(-1).lte(x)                              // true
    1276. 

  1276. BigNumber(10, 18).lte('i', 36)                    // true</pre>
    1277. 

  1277. 

  1278. 

  1279. 

  1280.     <h5 id="isNaN">isNaN<code class='inset'>.isNaN() <i>&rArr; boolean</i></code></h5>
    1281. 

  1281.     <p>
    1282. 

  1282.       Returns <code>true</code> if the value of this BigNumber is <code>NaN</code>, otherwise
    1283. 

  1283.       returns <code>false</code>.
    1284. 

  1284.     </p>
    1285. 

  1285.     <pre>
    1286. 

  1286. x = new BigNumber(NaN)
    1287. 

  1287. x.isNaN()                       // true
    1288. 

  1288. y = new BigNumber('Infinity')
    1289. 

  1289. y.isNaN()                       // false</pre>
    1290. 

  1290.     <p>Note: The native method <code>isNaN()</code> can also be used.</p>
    1291. 

  1291. 

  1292. 

  1293. 

  1294.     <h5 id="isNeg">isNegative<code class='inset'>.isNegative() <i>&rArr; boolean</i></code></h5>
    1295. 

  1295.     <p>
    1296. 

  1296.       Returns <code>true</code> if the sign of this BigNumber is negative, otherwise returns
    1297. 

  1297.       <code>false</code>.
    1298. 

  1298.     </p>
    1299. 

  1299.     <pre>
    1300. 

  1300. x = new BigNumber(-0)
    1301. 

  1301. x.isNegative()                  // true
    1302. 

  1302. y = new BigNumber(2)
    1303. 

  1303. y.isNegative()                  // false</pre>
    1304. 

  1304.     <p>Note: <code>n &lt; 0</code> can be used if <code>n &lt;= -Number.MIN_VALUE</code>.</p>
    1305. 

  1305. 

  1306. 

  1307. 

  1308.     <h5 id="isPos">isPositive<code class='inset'>.isPositive() <i>&rArr; boolean</i></code></h5>
    1309. 

  1309.     <p>
    1310. 

  1310.       Returns <code>true</code> if the sign of this BigNumber is positive, otherwise returns
    1311. 

  1311.       <code>false</code>.
    1312. 

  1312.     </p>
    1313. 

  1313.     <pre>
    1314. 

  1314. x = new BigNumber(-0)
    1315. 

  1315. x.isPositive()                  // false
    1316. 

  1316. y = new BigNumber(2)
    1317. 

  1317. y.isPositive()                  // true</pre>
    1318. 

  1318. 

  1319. 

  1320. 

  1321.     <h5 id="isZ">isZero<code class='inset'>.isZero() <i>&rArr; boolean</i></code></h5>
    1322. 

  1322.     <p>
    1323. 

  1323.       Returns <code>true</code> if the value of this BigNumber is zero or minus zero, otherwise
    1324. 

  1324.       returns <code>false</code>.
    1325. 

  1325.     </p>
    1326. 

  1326.     <pre>
    1327. 

  1327. x = new BigNumber(-0)
    1328. 

  1328. x.isZero() && x.isNegative()         // true
    1329. 

  1329. y = new BigNumber(Infinity)
    1330. 

  1330. y.isZero()                      // false</pre>
    1331. 

  1331.     <p>Note: <code>n == 0</code> can be used if <code>n &gt;= Number.MIN_VALUE</code>.</p>
    1332. 

  1332. 

  1333. 

  1334. 

  1335.     <h5 id="minus">
    1336. 

  1336.       minus<code class='inset'>.minus(n [, base]) <i>&rArr; BigNumber</i></code>
    1337. 

  1337.     </h5>
    1338. 

  1338.     <p>
    1339. 

  1339.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1340. 

  1340.       <code>base</code>: <i>number</i><br />
    1341. 

  1341.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1342. 

  1342.     </p>
    1343. 

  1343.     <p>Returns a BigNumber whose value is the value of this BigNumber minus <code>n</code>.</p>
    1344. 

  1344.     <p>The return value is always exact and unrounded.</p>
    1345. 

  1345.     <pre>
    1346. 

  1346. 0.3 - 0.1                       // 0.19999999999999998
    1347. 

  1347. x = new BigNumber(0.3)
    1348. 

  1348. x.minus(0.1)                    // '0.2'
    1349. 

  1349. x.minus(0.6, 20)                // '0'</pre>
    1350. 

  1350. 

  1351. 

  1352. 

  1353.     <h5 id="mod">modulo<code class='inset'>.mod(n [, base]) <i>&rArr; BigNumber</i></code></h5>
    1354. 

  1354.     <p>
    1355. 

  1355.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1356. 

  1356.       <code>base</code>: <i>number</i><br />
    1357. 

  1357.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1358. 

  1358.     </p>
    1359. 

  1359.     <p>
    1360. 

  1360.       Returns a BigNumber whose value is the value of this BigNumber modulo <code>n</code>, i.e.
    1361. 

  1361.       the integer remainder of dividing this BigNumber by <code>n</code>.
    1362. 

  1362.     </p>
    1363. 

  1363.     <p>
    1364. 

  1364.       The value returned, and in particular its sign, is dependent on the value of the
    1365. 

  1365.       <a href='#modulo-mode'><code>MODULO_MODE</code></a> setting of this BigNumber constructor.
    1366. 

  1366.       If it is <code>1</code> (default value), the result will have the same sign as this BigNumber,
    1367. 

  1367.       and it will match that of Javascript's <code>%</code> operator (within the limits of double
    1368. 

  1368.       precision) and BigDecimal's <code>remainder</code> method.
    1369. 

  1369.     </p>
    1370. 

  1370.     <p>The return value is always exact and unrounded.</p>
    1371. 

  1371.     <p>
    1372. 

  1372.       See <a href='#modulo-mode'><code>MODULO_MODE</code></a> for a description of the other
    1373. 

  1373.       modulo modes.
    1374. 

  1374.     </p>
    1375. 

  1375.     <pre>
    1376. 

  1376. 1 % 0.9                         // 0.09999999999999998
    1377. 

  1377. x = new BigNumber(1)
    1378. 

  1378. x.modulo(0.9)                   // '0.1'
    1379. 

  1379. y = new BigNumber(33)
    1380. 

  1380. y.mod('a', 33)                  // '3'</pre>
    1381. 

  1381. 

  1382. 

  1383. 

  1384.     <h5 id="times">
    1385. 

  1385.       multipliedBy<code class='inset'>.times(n [, base]) <i>&rArr; BigNumber</i></code>
    1386. 

  1386.     </h5>
    1387. 

  1387.     <p>
    1388. 

  1388.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1389. 

  1389.       <code>base</code>: <i>number</i><br />
    1390. 

  1390.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1391. 

  1391.     </p>
    1392. 

  1392.     <p>
    1393. 

  1393.       Returns a BigNumber whose value is the value of this BigNumber multiplied by <code>n</code>.
    1394. 

  1394.     </p>
    1395. 

  1395.     <p>The return value is always exact and unrounded.</p>
    1396. 

  1396.     <pre>
    1397. 

  1397. 0.6 * 3                         // 1.7999999999999998
    1398. 

  1398. x = new BigNumber(0.6)
    1399. 

  1399. y = x.multipliedBy(3)           // '1.8'
    1400. 

  1400. BigNumber('7e+500').times(y)    // '1.26e+501'
    1401. 

  1401. x.multipliedBy('-a', 16)        // '-6'</pre>
    1402. 

  1402. 

  1403. 

  1404. 

  1405.     <h5 id="neg">negated<code class='inset'>.negated() <i>&rArr; BigNumber</i></code></h5>
    1406. 

  1406.     <p>
    1407. 

  1407.       Returns a BigNumber whose value is the value of this BigNumber negated, i.e. multiplied by
    1408. 

  1408.       <code>-1</code>.
    1409. 

  1409.     </p>
    1410. 

  1410.     <pre>
    1411. 

  1411. x = new BigNumber(1.8)
    1412. 

  1412. x.negated()                     // '-1.8'
    1413. 

  1413. y = new BigNumber(-1.3)
    1414. 

  1414. y.negated()                     // '1.3'</pre>
    1415. 

  1415. 

  1416. 

  1417. 

  1418.     <h5 id="plus">plus<code class='inset'>.plus(n [, base]) <i>&rArr; BigNumber</i></code></h5>
    1419. 

  1419.     <p>
    1420. 

  1420.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1421. 

  1421.       <code>base</code>: <i>number</i><br />
    1422. 

  1422.       <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
    1423. 

  1423.     </p>
    1424. 

  1424.     <p>Returns a BigNumber whose value is the value of this BigNumber plus <code>n</code>.</p>
    1425. 

  1425.     <p>The return value is always exact and unrounded.</p>
    1426. 

  1426.     <pre>
    1427. 

  1427. 0.1 + 0.2                       // 0.30000000000000004
    1428. 

  1428. x = new BigNumber(0.1)
    1429. 

  1429. y = x.plus(0.2)                 // '0.3'
    1430. 

  1430. BigNumber(0.7).plus(x).plus(y)  // '1'
    1431. 

  1431. x.plus('0.1', 8)                // '0.225'</pre>
    1432. 

  1432. 

  1433. 

  1434. 

  1435.     <h5 id="sd">
    1436. 

  1436.       precision<code class='inset'>.sd([d [, rm]]) <i>&rArr; BigNumber|number</i></code>
    1437. 

  1437.     </h5>
    1438. 

  1438.     <p>
    1439. 

  1439.       <code>d</code>: <i>number|boolean</i>: integer, <code>1</code> to <code>1e+9</code>
    1440. 

  1440.       inclusive, or <code>true</code> or <code>false</code><br />
    1441. 

  1441.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive.
    1442. 

  1442.     </p>
    1443. 

  1443.     <p>
    1444. 

  1444.       If <code>d</code> is a number, returns a BigNumber whose value is the value of this BigNumber
    1445. 

  1445.       rounded to a precision of <code>d</code> significant digits using rounding mode
    1446. 

  1446.       <code>rm</code>.
    1447. 

  1447.     </p>
    1448. 

  1448.     <p>
    1449. 

  1449.       If <code>d</code> is omitted or is <code>null</code> or <code>undefined</code>, the return
    1450. 

  1450.       value is the number of significant digits of the value of this BigNumber, or <code>null</code>
    1451. 

  1451.       if the value of this BigNumber is &plusmn;<code>Infinity</code> or <code>NaN</code>.</p>
    1452. 

  1452.     </p>
    1453. 

  1453.     <p>
    1454. 

  1454.       If <code>d</code> is <code>true</code> then any trailing zeros of the integer
    1455. 

  1455.       part of a number are counted as significant digits, otherwise they are not.
    1456. 

  1456.     </p>
    1457. 

  1457.     <p>
    1458. 

  1458.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1459. 

  1459.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> will be used.
    1460. 

  1460.     </p>
    1461. 

  1461.     <p>
    1462. 

  1462.       Throws if <code>d</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
    1463. 

  1463.     </p>
    1464. 

  1464.     <pre>
    1465. 

  1465. x = new BigNumber(9876.54321)
    1466. 

  1466. x.precision(6)                         // '9876.54'
    1467. 

  1467. x.sd()                                 // 9
    1468. 

  1468. x.precision(6, BigNumber.ROUND_UP)     // '9876.55'
    1469. 

  1469. x.sd(2)                                // '9900'
    1470. 

  1470. x.precision(2, 1)                      // '9800'
    1471. 

  1471. x                                      // '9876.54321'
    1472. 

  1472. y = new BigNumber(987000)
    1473. 

  1473. y.precision()                          // 3
    1474. 

  1474. y.sd(true)                             // 6</pre>
    1475. 

  1475. 

  1476. 

  1477. 

  1478. <h5 id="shift">shiftedBy<code class='inset'>.shiftedBy(n) <i>&rArr; BigNumber</i></code></h5>
    1479. 

  1479.     <p>
    1480. 

  1480.       <code>n</code>: <i>number</i>: integer,
    1481. 

  1481.       <code>-9007199254740991</code> to <code>9007199254740991</code> inclusive
    1482. 

  1482.     </p>
    1483. 

  1483.     <p>
    1484. 

  1484.       Returns a BigNumber whose value is the value of this BigNumber shifted by <code>n</code>
    1485. 

  1485.       places.
    1486. 

  1486.     <p>
    1487. 

  1487.       The shift is of the decimal point, i.e. of powers of ten, and is to the left if <code>n</code>
    1488. 

  1488.       is negative or to the right if <code>n</code> is positive.
    1489. 

  1489.     </p>
    1490. 

  1490.     <p>The return value is always exact and unrounded.</p>
    1491. 

  1491.     <p>
    1492. 

  1492.       Throws if <code>n</code> is invalid. See <a href='#Errors'>Errors</a>.
    1493. 

  1493.     </p>
    1494. 

  1494.     <pre>
    1495. 

  1495. x = new BigNumber(1.23)
    1496. 

  1496. x.shiftedBy(3)                      // '1230'
    1497. 

  1497. x.shiftedBy(-3)                     // '0.00123'</pre>
    1498. 

  1498. 

  1499. 

  1500. 

  1501.     <h5 id="sqrt">squareRoot<code class='inset'>.sqrt() <i>&rArr; BigNumber</i></code></h5>
    1502. 

  1502.     <p>
    1503. 

  1503.       Returns a BigNumber whose value is the square root of the value of this BigNumber,
    1504. 

  1504.       rounded according to the current
    1505. 

  1505.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
    1506. 

  1506.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
    1507. 

  1507.     </p>
    1508. 

  1508.     <p>
    1509. 

  1509.       The return value will be correctly rounded, i.e. rounded as if the result was first calculated
    1510. 

  1510.       to an infinite number of correct digits before rounding.
    1511. 

  1511.     </p>
    1512. 

  1512.     <pre>
    1513. 

  1513. x = new BigNumber(16)
    1514. 

  1514. x.squareRoot()                  // '4'
    1515. 

  1515. y = new BigNumber(3)
    1516. 

  1516. y.sqrt()                        // '1.73205080756887729353'</pre>
    1517. 

  1517. 

  1518. 

  1519. 

  1520.     <h5 id="toE">
    1521. 

  1521.       toExponential<code class='inset'>.toExponential([dp [, rm]]) <i>&rArr; string</i></code>
    1522. 

  1522.     </h5>
    1523. 

  1523.     <p>
    1524. 

  1524.       <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
    1525. 

  1525.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1526. 

  1526.     </p>
    1527. 

  1527.     <p>
    1528. 

  1528.       Returns a string representing the value of this BigNumber in exponential notation rounded
    1529. 

  1529.       using rounding mode <code>rm</code> to <code>dp</code> decimal places, i.e with one digit
    1530. 

  1530.       before the decimal point and <code>dp</code> digits after it.
    1531. 

  1531.     </p>
    1532. 

  1532.     <p>
    1533. 

  1533.       If the value of this BigNumber in exponential notation has fewer than <code>dp</code> fraction
    1534. 

  1534.       digits, the return value will be appended with zeros accordingly.
    1535. 

  1535.     </p>
    1536. 

  1536.     <p>
    1537. 

  1537.       If <code>dp</code> is omitted, or is <code>null</code> or <code>undefined</code>, the number
    1538. 

  1538.       of digits after the decimal point defaults to the minimum number of digits necessary to
    1539. 

  1539.       represent the value exactly.<br />
    1540. 

  1540.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1541. 

  1541.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
    1542. 

  1542.     </p>
    1543. 

  1543.     <p>
    1544. 

  1544.       Throws if <code>dp</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
    1545. 

  1545.     </p>
    1546. 

  1546.      <pre>
    1547. 

  1547. x = 45.6
    1548. 

  1548. y = new BigNumber(x)
    1549. 

  1549. x.toExponential()               // '4.56e+1'
    1550. 

  1550. y.toExponential()               // '4.56e+1'
    1551. 

  1551. x.toExponential(0)              // '5e+1'
    1552. 

  1552. y.toExponential(0)              // '5e+1'
    1553. 

  1553. x.toExponential(1)              // '4.6e+1'
    1554. 

  1554. y.toExponential(1)              // '4.6e+1'
    1555. 

  1555. y.toExponential(1, 1)           // '4.5e+1'  (ROUND_DOWN)
    1556. 

  1556. x.toExponential(3)              // '4.560e+1'
    1557. 

  1557. y.toExponential(3)              // '4.560e+1'</pre>
    1558. 

  1558. 

  1559. 

  1560. 

  1561.     <h5 id="toFix">
    1562. 

  1562.       toFixed<code class='inset'>.toFixed([dp [, rm]]) <i>&rArr; string</i></code>
    1563. 

  1563.     </h5>
    1564. 

  1564.     <p>
    1565. 

  1565.       <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
    1566. 

  1566.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1567. 

  1567.     </p>
    1568. 

  1568.     <p>
    1569. 

  1569.       Returns a string representing the value of this BigNumber in normal (fixed-point) notation
    1570. 

  1570.       rounded to <code>dp</code> decimal places using rounding mode <code>rm</code>.
    1571. 

  1571.     </p>
    1572. 

  1572.     <p>
    1573. 

  1573.       If the value of this BigNumber in normal notation has fewer than <code>dp</code> fraction
    1574. 

  1574.       digits, the return value will be appended with zeros accordingly.
    1575. 

  1575.     </p>
    1576. 

  1576.    <p>
    1577. 

  1577.       Unlike <code>Number.prototype.toFixed</code>, which returns exponential notation if a number
    1578. 

  1578.       is greater or equal to <code>10<sup>21</sup></code>, this method will always return normal
    1579. 

  1579.       notation.
    1580. 

  1580.     </p>
    1581. 

  1581.     <p>
    1582. 

  1582.       If <code>dp</code> is omitted or is <code>null</code> or <code>undefined</code>, the return
    1583. 

  1583.       value will be unrounded and in normal notation. This is also unlike
    1584. 

  1584.       <code>Number.prototype.toFixed</code>, which returns the value to zero decimal places.<br />
    1585. 

  1585.       It is useful when fixed-point notation is required and the current
    1586. 

  1586.       <a href="#exponential-at"><code>EXPONENTIAL_AT</code></a> setting causes
    1587. 

  1587.       <code><a href='#toS'>toString</a></code> to return exponential notation.<br />
    1588. 

  1588.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1589. 

  1589.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
    1590. 

  1590.     </p>
    1591. 

  1591.     <p>
    1592. 

  1592.       Throws if <code>dp</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
    1593. 

  1593.     </p>
    1594. 

  1594.     <pre>
    1595. 

  1595. x = 3.456
    1596. 

  1596. y = new BigNumber(x)
    1597. 

  1597. x.toFixed()                     // '3'
    1598. 

  1598. y.toFixed()                     // '3.456'
    1599. 

  1599. y.toFixed(0)                    // '3'
    1600. 

  1600. x.toFixed(2)                    // '3.46'
    1601. 

  1601. y.toFixed(2)                    // '3.46'
    1602. 

  1602. y.toFixed(2, 1)                 // '3.45'  (ROUND_DOWN)
    1603. 

  1603. x.toFixed(5)                    // '3.45600'
    1604. 

  1604. y.toFixed(5)                    // '3.45600'</pre>
    1605. 

  1605. 

  1606. 

  1607. 

  1608.     <h5 id="toFor">
    1609. 

  1609.       toFormat<code class='inset'>.toFormat([dp [, rm[, format]]]) <i>&rArr; string</i></code>
    1610. 

  1610.     </h5>
    1611. 

  1611.     <p>
    1612. 

  1612.       <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
    1613. 

  1613.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive<br />
    1614. 

  1614.       <code>format</code>: <i>object</i>: see <a href='#format'><code>FORMAT</code></a>
    1615. 

  1615.     </p>
    1616. 

  1616.     <p>
    1617. 

  1617.       <p>
    1618. 

  1618.       Returns a string representing the value of this BigNumber in normal (fixed-point) notation
    1619. 

  1619.       rounded to <code>dp</code> decimal places using rounding mode <code>rm</code>, and formatted
    1620. 

  1620.       according to the properties of the <code>format</code> object.
    1621. 

  1621.     </p>
    1622. 

  1622.     <p>
    1623. 

  1623.       See <a href='#format'><code>FORMAT</code></a> and the examples below for the properties of the
    1624. 

  1624.       <code>format</code> object, their types, and their usage. A formatting object may contain
    1625. 

  1625.       some or all of the recognised properties.
    1626. 

  1626.     </p>
    1627. 

  1627.     <p>
    1628. 

  1628.       If <code>dp</code> is omitted or is <code>null</code> or <code>undefined</code>, then the
    1629. 

  1629.       return value is not rounded to a fixed number of decimal places.<br />
    1630. 

  1630.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1631. 

  1631.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.<br />
    1632. 

  1632.       If <code>format</code> is omitted or is <code>null</code> or <code>undefined</code>, the
    1633. 

  1633.       <a href='#format'><code>FORMAT</code></a> object is used.
    1634. 

  1634.     </p>
    1635. 

  1635.     <p>
    1636. 

  1636.       Throws if <code>dp</code>, <code>rm</code> or <code>format</code> is invalid. See
    1637. 

  1637.       <a href='#Errors'>Errors</a>.
    1638. 

  1638.     </p>
    1639. 

  1639.     <pre>
    1640. 

  1640. fmt = {
    1641. 

  1641.   prefix = '',
    1642. 

  1642.   decimalSeparator: '.',
    1643. 

  1643.   groupSeparator: ',',
    1644. 

  1644.   groupSize: 3,
    1645. 

  1645.   secondaryGroupSize: 0,
    1646. 

  1646.   fractionGroupSeparator: ' ',
    1647. 

  1647.   fractionGroupSize: 0,
    1648. 

  1648.   suffix = ''
    1649. 

  1649. }
    1650. 

  1650. 

  1651. x = new BigNumber('123456789.123456789')
    1652. 

  1652. 

  1653. // Set the global formatting options
    1654. 

  1654. BigNumber.config({ FORMAT: fmt })
    1655. 

  1655. 

  1656. x.toFormat()                              // '123,456,789.123456789'
    1657. 

  1657. x.toFormat(3)                             // '123,456,789.123'
    1658. 

  1658. 

  1659. // If a reference to the object assigned to FORMAT has been retained,
    1660. 

  1660. // the format properties can be changed directly
    1661. 

  1661. fmt.groupSeparator = ' '
    1662. 

  1662. fmt.fractionGroupSize = 5
    1663. 

  1663. x.toFormat()                              // '123 456 789.12345 6789'
    1664. 

  1664. 

  1665. // Alternatively, pass the formatting options as an argument
    1666. 

  1666. fmt = {
    1667. 

  1667.   prefix: '=> ',
    1668. 

  1668.   decimalSeparator: ',',
    1669. 

  1669.   groupSeparator: '.',
    1670. 

  1670.   groupSize: 3,
    1671. 

  1671.   secondaryGroupSize: 2
    1672. 

  1672. }
    1673. 

  1673. 

  1674. x.toFormat()                              // '123 456 789.12345 6789'
    1675. 

  1675. x.toFormat(fmt)                           // '=> 12.34.56.789,123456789'
    1676. 

  1676. x.toFormat(2, fmt)                        // '=> 12.34.56.789,12'
    1677. 

  1677. x.toFormat(3, BigNumber.ROUND_UP, fmt)    // '=> 12.34.56.789,124'</pre>
    1678. 

  1678. 

  1679. 

  1680. 

  1681.     <h5 id="toFr">
    1682. 

  1682.       toFraction<code class='inset'>.toFraction([maximum_denominator])
    1683. 

  1683.       <i>&rArr; [BigNumber, BigNumber]</i></code>
    1684. 

  1684.     </h5>
    1685. 

  1685.     <p>
    1686. 

  1686.       <code>maximum_denominator</code>:
    1687. 

  1687.       <i>number|string|BigNumber</i>: integer &gt;= <code>1</code> and &lt;=
    1688. 

  1688.       <code>Infinity</code>
    1689. 

  1689.     </p>
    1690. 

  1690.     <p>
    1691. 

  1691.       Returns an array of two BigNumbers representing the value of this BigNumber as a simple
    1692. 

  1692.       fraction with an integer numerator and an integer denominator. The denominator will be a
    1693. 

  1693.       positive non-zero value less than or equal to <code>maximum_denominator</code>.
    1694. 

  1694.     </p>
    1695. 

  1695.     <p>
    1696. 

  1696.       If a <code>maximum_denominator</code> is not specified, or is <code>null</code> or
    1697. 

  1697.       <code>undefined</code>, the denominator will be the lowest value necessary to represent the
    1698. 

  1698.       number exactly.
    1699. 

  1699.     </p>
    1700. 

  1700.     <p>
    1701. 

  1701.       Throws if <code>maximum_denominator</code> is invalid. See <a href='#Errors'>Errors</a>.
    1702. 

  1702.     </p>
    1703. 

  1703.     <pre>
    1704. 

  1704. x = new BigNumber(1.75)
    1705. 

  1705. x.toFraction()                  // '7, 4'
    1706. 

  1706. 

  1707. pi = new BigNumber('3.14159265358')
    1708. 

  1708. pi.toFraction()                 // '157079632679,50000000000'
    1709. 

  1709. pi.toFraction(100000)           // '312689, 99532'
    1710. 

  1710. pi.toFraction(10000)            // '355, 113'
    1711. 

  1711. pi.toFraction(100)              // '311, 99'
    1712. 

  1712. pi.toFraction(10)               // '22, 7'
    1713. 

  1713. pi.toFraction(1)                // '3, 1'</pre>
    1714. 

  1714. 

  1715. 

  1716. 

  1717.     <h5 id="toJSON">toJSON<code class='inset'>.toJSON() <i>&rArr; string</i></code></h5>
    1718. 

  1718.     <p>As <a href='#valueOf'><code>valueOf</code></a>.</p>
    1719. 

  1719.     <pre>
    1720. 

  1720. x = new BigNumber('177.7e+457')
    1721. 

  1721. y = new BigNumber(235.4325)
    1722. 

  1722. z = new BigNumber('0.0098074')
    1723. 

  1723. 

  1724. // Serialize an array of three BigNumbers
    1725. 

  1725. str = JSON.stringify( [x, y, z] )
    1726. 

  1726. // "["1.777e+459","235.4325","0.0098074"]"
    1727. 

  1727. 

  1728. // Return an array of three BigNumbers
    1729. 

  1729. JSON.parse(str, function (key, val) {
    1730. 

  1730.     return key === '' ? val : new BigNumber(val)
    1731. 

  1731. })</pre>
    1732. 

  1732. 

  1733. 

  1734. 

  1735.     <h5 id="toN">toNumber<code class='inset'>.toNumber() <i>&rArr; number</i></code></h5>
    1736. 

  1736.     <p>Returns the value of this BigNumber as a JavaScript number primitive.</p>
    1737. 

  1737.     <p>
    1738. 

  1738.       This method is identical to using type coercion with the unary plus operator.
    1739. 

  1739.     </p>
    1740. 

  1740.     <pre>
    1741. 

  1741. x = new BigNumber(456.789)
    1742. 

  1742. x.toNumber()                    // 456.789
    1743. 

  1743. +x                              // 456.789
    1744. 

  1744. 

  1745. y = new BigNumber('45987349857634085409857349856430985')
    1746. 

  1746. y.toNumber()                    // 4.598734985763409e+34
    1747. 

  1747. 

  1748. z = new BigNumber(-0)
    1749. 

  1749. 1 / z.toNumber()                // -Infinity
    1750. 

  1750. 1 / +z                          // -Infinity</pre>
    1751. 

  1751. 

  1752. 

  1753. 

  1754.     <h5 id="toP">
    1755. 

  1755.       toPrecision<code class='inset'>.toPrecision([sd [, rm]]) <i>&rArr; string</i></code>
    1756. 

  1756.     </h5>
    1757. 

  1757.     <p>
    1758. 

  1758.       <code>sd</code>: <i>number</i>: integer, <code>1</code> to <code>1e+9</code> inclusive<br />
    1759. 

  1759.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1760. 

  1760.     </p>
    1761. 

  1761.     <p>
    1762. 

  1762.       Returns a string representing the value of this BigNumber rounded to <code>sd</code>
    1763. 

  1763.       significant digits using rounding mode <code>rm</code>.
    1764. 

  1764.     </p>
    1765. 

  1765.     <p>
    1766. 

  1766.       If <code>sd</code> is less than the number of digits necessary to represent the integer part
    1767. 

  1767.       of the value in normal (fixed-point) notation, then exponential notation is used.
    1768. 

  1768.     </p>
    1769. 

  1769.     <p>
    1770. 

  1770.       If <code>sd</code> is omitted, or is <code>null</code> or <code>undefined</code>, then the
    1771. 

  1771.       return value is the same as <code>n.toString()</code>.<br />
    1772. 

  1772.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1773. 

  1773.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
    1774. 

  1774.     </p>
    1775. 

  1775.     <p>
    1776. 

  1776.       Throws if <code>sd</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
    1777. 

  1777.     </p>
    1778. 

  1778.      <pre>
    1779. 

  1779. x = 45.6
    1780. 

  1780. y = new BigNumber(x)
    1781. 

  1781. x.toPrecision()                 // '45.6'
    1782. 

  1782. y.toPrecision()                 // '45.6'
    1783. 

  1783. x.toPrecision(1)                // '5e+1'
    1784. 

  1784. y.toPrecision(1)                // '5e+1'
    1785. 

  1785. y.toPrecision(2, 0)             // '4.6e+1'  (ROUND_UP)
    1786. 

  1786. y.toPrecision(2, 1)             // '4.5e+1'  (ROUND_DOWN)
    1787. 

  1787. x.toPrecision(5)                // '45.600'
    1788. 

  1788. y.toPrecision(5)                // '45.600'</pre>
    1789. 

  1789. 

  1790. 

  1791. 

  1792.     <h5 id="toS">toString<code class='inset'>.toString([base]) <i>&rArr; string</i></code></h5>
    1793. 

  1793.     <p>
    1794. 

  1794.       <code>base</code>: <i>number</i>: integer, <code>2</code> to <code>ALPHABET.length</code>
    1795. 

  1795.       inclusive (see <a href='#alphabet'><code>ALPHABET</code></a>).
    1796. 

  1796.     </p>
    1797. 

  1797.     <p>
    1798. 

  1798.       Returns a string representing the value of this BigNumber in the specified base, or base
    1799. 

  1799.       <code>10</code> if <code>base</code> is omitted or is <code>null</code> or
    1800. 

  1800.       <code>undefined</code>.
    1801. 

  1801.     </p>
    1802. 

  1802.     <p>
    1803. 

  1803.       For bases above <code>10</code>, and using the default base conversion alphabet
    1804. 

  1804.       (see <a href='#alphabet'><code>ALPHABET</code></a>), values from <code>10</code> to
    1805. 

  1805.       <code>35</code> are represented by <code>a-z</code>
    1806. 

  1806.       (as with <code>Number.prototype.toString</code>).
    1807. 

  1807.     </p>
    1808. 

  1808.     <p>
    1809. 

  1809.       If a base is specified the value is rounded according to the current
    1810. 

  1810.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a>
    1811. 

  1811.       and <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
    1812. 

  1812.     </p>
    1813. 

  1813.     <p>
    1814. 

  1814.       If a base is not specified, and this BigNumber has a positive
    1815. 

  1815.       exponent that is equal to or greater than the positive component of the
    1816. 

  1816.       current <a href="#exponential-at"><code>EXPONENTIAL_AT</code></a> setting,
    1817. 

  1817.       or a negative exponent equal to or less than the negative component of the
    1818. 

  1818.       setting, then exponential notation is returned.
    1819. 

  1819.     </p>
    1820. 

  1820.     <p>If <code>base</code> is <code>null</code> or <code>undefined</code> it is ignored.</p>
    1821. 

  1821.     <p>
    1822. 

  1822.       Throws if <code>base</code> is invalid. See <a href='#Errors'>Errors</a>.
    1823. 

  1823.     </p>
    1824. 

  1824.     <pre>
    1825. 

  1825. x = new BigNumber(750000)
    1826. 

  1826. x.toString()                    // '750000'
    1827. 

  1827. BigNumber.config({ EXPONENTIAL_AT: 5 })
    1828. 

  1828. x.toString()                    // '7.5e+5'
    1829. 

  1829. 

  1830. y = new BigNumber(362.875)
    1831. 

  1831. y.toString(2)                   // '101101010.111'
    1832. 

  1832. y.toString(9)                   // '442.77777777777777777778'
    1833. 

  1833. y.toString(32)                  // 'ba.s'
    1834. 

  1834. 

  1835. BigNumber.config({ DECIMAL_PLACES: 4 });
    1836. 

  1836. z = new BigNumber('1.23456789')
    1837. 

  1837. z.toString()                    // '1.23456789'
    1838. 

  1838. z.toString(10)                  // '1.2346'</pre>
    1839. 

  1839. 

  1840. 

  1841. 

  1842.     <h5 id="valueOf">valueOf<code class='inset'>.valueOf() <i>&rArr; string</i></code></h5>
    1843. 

  1843.     <p>
    1844. 

  1844.       As <a href='#toS'><code>toString</code></a>, but does not accept a base argument and includes
    1845. 

  1845.       the minus sign for negative zero.
    1846. 

  1846.     </p>
    1847. 

  1847.     <pre>
    1848. 

  1848. x = new BigNumber('-0')
    1849. 

  1849. x.toString()                    // '0'
    1850. 

  1850. x.valueOf()                     // '-0'
    1851. 

  1851. y = new BigNumber('1.777e+457')
    1852. 

  1852. y.valueOf()                     // '1.777e+457'</pre>
    1853. 

  1853. 

  1854. 

  1855. 

  1856.     <h4 id="instance-properties">Properties</h4>
    1857. 

  1857.     <p>The properties of a BigNumber instance:</p>
    1858. 

  1858.     <table>
    1859. 

  1859.       <tr>
    1860. 

  1860.         <th>Property</th>
    1861. 

  1861.         <th>Description</th>
    1862. 

  1862.         <th>Type</th>
    1863. 

  1863.         <th>Value</th>
    1864. 

  1864.       </tr>
    1865. 

  1865.       <tr>
    1866. 

  1866.         <td class='centre' id='coefficient'><b>c</b></td>
    1867. 

  1867.         <td>coefficient<sup>*</sup></td>
    1868. 

  1868.         <td><i>number</i><code>[]</code></td>
    1869. 

  1869.         <td> Array of base <code>1e14</code> numbers</td>
    1870. 

  1870.       </tr>
    1871. 

  1871.       <tr>
    1872. 

  1872.         <td class='centre' id='exponent'><b>e</b></td>
    1873. 

  1873.         <td>exponent</td>
    1874. 

  1874.         <td><i>number</i></td>
    1875. 

  1875.         <td>Integer, <code>-1000000000</code> to <code>1000000000</code> inclusive</td>
    1876. 

  1876.       </tr>
    1877. 

  1877.       <tr>
    1878. 

  1878.         <td class='centre' id='sign'><b>s</b></td>
    1879. 

  1879.         <td>sign</td>
    1880. 

  1880.         <td><i>number</i></td>
    1881. 

  1881.         <td><code>-1</code> or <code>1</code></td>
    1882. 

  1882.       </tr>
    1883. 

  1883.     </table>
    1884. 

  1884.     <p><sup>*</sup>significand</p>
    1885. 

  1885.     <p>
    1886. 

  1886.       The value of any of the <code>c</code>, <code>e</code> and <code>s</code> properties may also
    1887. 

  1887.       be <code>null</code>.
    1888. 

  1888.     </p>
    1889. 

  1889.     <p>
    1890. 

  1890.       The above properties are best considered to be read-only. In early versions of this library it
    1891. 

  1891.       was okay to change the exponent of a BigNumber by writing to its exponent property directly,
    1892. 

  1892.       but this is no longer reliable as the value of the first element of the coefficient array is
    1893. 

  1893.       now dependent on the exponent.
    1894. 

  1894.     </p>
    1895. 

  1895.     <p>
    1896. 

  1896.       Note that, as with JavaScript numbers, the original exponent and fractional trailing zeros are
    1897. 

  1897.       not necessarily preserved.
    1898. 

  1898.     </p>
    1899. 

  1899.     <pre>x = new BigNumber(0.123)              // '0.123'
    1900. 

  1900. x.toExponential()                     // '1.23e-1'
    1901. 

  1901. x.c                                   // '1,2,3'
    1902. 

  1902. x.e                                   // -1
    1903. 

  1903. x.s                                   // 1
    1904. 

  1904. 

  1905. y = new Number(-123.4567000e+2)       // '-12345.67'
    1906. 

  1906. y.toExponential()                     // '-1.234567e+4'
    1907. 

  1907. z = new BigNumber('-123.4567000e+2')  // '-12345.67'
    1908. 

  1908. z.toExponential()                     // '-1.234567e+4'
    1909. 

  1909. z.c                                   // '1,2,3,4,5,6,7'
    1910. 

  1910. z.e                                   // 4
    1911. 

  1911. z.s                                   // -1</pre>
    1912. 

  1912. 

  1913. 

  1914. 

  1915.     <h4 id="zero-nan-infinity">Zero, NaN and Infinity</h4>
    1916. 

  1916.     <p>
    1917. 

  1917.       The table below shows how &plusmn;<code>0</code>, <code>NaN</code> and
    1918. 

  1918.       &plusmn;<code>Infinity</code> are stored.
    1919. 

  1919.     </p>
    1920. 

  1920.     <table>
    1921. 

  1921.       <tr>
    1922. 

  1922.         <th> </th>
    1923. 

  1923.         <th class='centre'>c</th>
    1924. 

  1924.         <th class='centre'>e</th>
    1925. 

  1925.         <th class='centre'>s</th>
    1926. 

  1926.       </tr>
    1927. 

  1927.       <tr>
    1928. 

  1928.         <td>&plusmn;0</td>
    1929. 

  1929.         <td><code>[0]</code></td>
    1930. 

  1930.         <td><code>0</code></td>
    1931. 

  1931.         <td><code>&plusmn;1</code></td>
    1932. 

  1932.       </tr>
    1933. 

  1933.       <tr>
    1934. 

  1934.         <td>NaN</td>
    1935. 

  1935.         <td><code>null</code></td>
    1936. 

  1936.         <td><code>null</code></td>
    1937. 

  1937.         <td><code>null</code></td>
    1938. 

  1938.       </tr>
    1939. 

  1939.       <tr>
    1940. 

  1940.         <td>&plusmn;Infinity</td>
    1941. 

  1941.         <td><code>null</code></td>
    1942. 

  1942.         <td><code>null</code></td>
    1943. 

  1943.         <td><code>&plusmn;1</code></td>
    1944. 

  1944.       </tr>
    1945. 

  1945.     </table>
    1946. 

  1946.     <pre>
    1947. 

  1947. x = new Number(-0)              // 0
    1948. 

  1948. 1 / x == -Infinity              // true
    1949. 

  1949. 

  1950. y = new BigNumber(-0)           // '0'
    1951. 

  1951. y.c                             // '0' ( [0].toString() )
    1952. 

  1952. y.e                             // 0
    1953. 

  1953. y.s                             // -1</pre>
    1954. 

  1954. 

  1955. 

  1956. 

  1957.     <h4 id='Errors'>Errors</h4>
    1958. 

  1958.     <p>The table below shows the errors that are thrown.</p>
    1959. 

  1959.     <p>
    1960. 

  1960.       The errors are generic <code>Error</code> objects whose message begins
    1961. 

  1961.       <code>'[BigNumber Error]'</code>.
    1962. 

  1962.     </p>
    1963. 

  1963.     <table class='error-table'>
    1964. 

  1964.       <tr>
    1965. 

  1965.         <th>Method</th>
    1966. 

  1966.         <th>Throws</th>
    1967. 

  1967.       </tr>
    1968. 

  1968.       <tr>
    1969. 

  1969.         <td rowspan=6>
    1970. 

  1970.           <code>BigNumber</code><br />
    1971. 

  1971.           <code>comparedTo</code><br />
    1972. 

  1972.           <code>dividedBy</code><br />
    1973. 

  1973.           <code>dividedToIntegerBy</code><br />
    1974. 

  1974.           <code>isEqualTo</code><br />
    1975. 

  1975.           <code>isGreaterThan</code><br />
    1976. 

  1976.           <code>isGreaterThanOrEqualTo</code><br />
    1977. 

  1977.           <code>isLessThan</code><br />
    1978. 

  1978.           <code>isLessThanOrEqualTo</code><br />
    1979. 

  1979.           <code>minus</code><br />
    1980. 

  1980.           <code>modulo</code><br />
    1981. 

  1981.           <code>plus</code><br />
    1982. 

  1982.           <code>multipliedBy</code>
    1983. 

  1983.         </td>
    1984. 

  1984.         <td>Base not a primitive number</td>
    1985. 

  1985.       </tr>
    1986. 

  1986.       <tr>
    1987. 

  1987.         <td>Base not an integer</td>
    1988. 

  1988.       </tr>
    1989. 

  1989.       <tr>
    1990. 

  1990.         <td>Base out of range</td>
    1991. 

  1991.       </tr>
    1992. 

  1992.        <tr>
    1993. 

  1993.         <td>Number primitive has more than 15 significant digits<sup>*</sup></td>
    1994. 

  1994.       </tr>
    1995. 

  1995.       <tr>
    1996. 

  1996.         <td>Not a base... number<sup>*</sup></td>
    1997. 

  1997.       </tr>
    1998. 

  1998.       <tr>
    1999. 

  1999.         <td>Not a number<sup>*</sup></td>
    2000. 

  2000.       </tr>
    2001. 

  2001.       <tr>
    2002. 

  2002.         <td><code>clone</code></td>
    2003. 

  2003.         <td>Object expected</td>
    2004. 

  2004.       </tr>
    2005. 

  2005.       <tr>
    2006. 

  2006.         <td rowspan=24><code>config</code></td>
    2007. 

  2007.         <td>Object expected</td>
    2008. 

  2008.       </tr>
    2009. 

  2009.       <tr>
    2010. 

  2010.         <td><code>DECIMAL_PLACES</code> not a primitive number</td>
    2011. 

  2011.       </tr>
    2012. 

  2012.       <tr>
    2013. 

  2013.         <td><code>DECIMAL_PLACES</code> not an integer</td>
    2014. 

  2014.       </tr>
    2015. 

  2015.       <tr>
    2016. 

  2016.         <td><code>DECIMAL_PLACES</code> out of range</td>
    2017. 

  2017.       </tr>
    2018. 

  2018.       <tr>
    2019. 

  2019.         <td><code>ROUNDING_MODE</code> not a primitive number</td>
    2020. 

  2020.       </tr>
    2021. 

  2021.       <tr>
    2022. 

  2022.         <td><code>ROUNDING_MODE</code> not an integer</td>
    2023. 

  2023.       </tr>
    2024. 

  2024.       <tr>
    2025. 

  2025.         <td><code>ROUNDING_MODE</code> out of range</td>
    2026. 

  2026.       </tr>
    2027. 

  2027.       <tr>
    2028. 

  2028.         <td><code>EXPONENTIAL_AT</code> not a primitive number</td>
    2029. 

  2029.       </tr>
    2030. 

  2030.       <tr>
    2031. 

  2031.         <td><code>EXPONENTIAL_AT</code> not an integer</td>
    2032. 

  2032.       </tr>
    2033. 

  2033.       <tr>
    2034. 

  2034.         <td><code>EXPONENTIAL_AT</code> out of range</td>
    2035. 

  2035.       </tr>
    2036. 

  2036.       <tr>
    2037. 

  2037.         <td><code>RANGE</code> not a primitive number</td>
    2038. 

  2038.       </tr>
    2039. 

  2039.       <tr>
    2040. 

  2040.         <td><code>RANGE</code> not an integer</td>
    2041. 

  2041.       </tr>
    2042. 

  2042.       <tr>
    2043. 

  2043.         <td><code>RANGE</code> cannot be zero</td>
    2044. 

  2044.       </tr>
    2045. 

  2045.       <tr>
    2046. 

  2046.         <td><code>RANGE</code> cannot be zero</td>
    2047. 

  2047.       </tr>
    2048. 

  2048.       <tr>
    2049. 

  2049.         <td><code>CRYPTO</code> not true or false</td>
    2050. 

  2050.       </tr>
    2051. 

  2051.       <tr>
    2052. 

  2052.         <td><code>crypto</code> unavailable</td>
    2053. 

  2053.       </tr>
    2054. 

  2054.       <tr>
    2055. 

  2055.         <td><code>MODULO_MODE</code> not a primitive number</td>
    2056. 

  2056.       </tr>
    2057. 

  2057.       <tr>
    2058. 

  2058.         <td><code>MODULO_MODE</code> not an integer</td>
    2059. 

  2059.       </tr>
    2060. 

  2060.       <tr>
    2061. 

  2061.         <td><code>MODULO_MODE</code> out of range</td>
    2062. 

  2062.       </tr>
    2063. 

  2063.       <tr>
    2064. 

  2064.         <td><code>POW_PRECISION</code> not a primitive number</td>
    2065. 

  2065.       </tr>
    2066. 

  2066.       <tr>
    2067. 

  2067.         <td><code>POW_PRECISION</code> not an integer</td>
    2068. 

  2068.       </tr>
    2069. 

  2069.       <tr>
    2070. 

  2070.         <td><code>POW_PRECISION</code> out of range</td>
    2071. 

  2071.       </tr>
    2072. 

  2072.       <tr>
    2073. 

  2073.         <td><code>FORMAT</code> not an object</td>
    2074. 

  2074.       </tr>
    2075. 

  2075.       <tr>
    2076. 

  2076.         <td><code>ALPHABET</code> invalid</td>
    2077. 

  2077.       </tr>
    2078. 

  2078.       <tr>
    2079. 

  2079.         <td rowspan=3>
    2080. 

  2080.           <code>decimalPlaces</code><br />
    2081. 

  2081.           <code>precision</code><br />
    2082. 

  2082.           <code>random</code><br />
    2083. 

  2083.           <code>shiftedBy</code><br />
    2084. 

  2084.           <code>toExponential</code><br />
    2085. 

  2085.           <code>toFixed</code><br />
    2086. 

  2086.           <code>toFormat</code><br />
    2087. 

  2087.           <code>toPrecision</code>
    2088. 

  2088.         </td>
    2089. 

  2089.         <td>Argument not a primitive number</td>
    2090. 

  2090.       </tr>
    2091. 

  2091.       <tr>
    2092. 

  2092.         <td>Argument not an integer</td>
    2093. 

  2093.       </tr>
    2094. 

  2094.       <tr>
    2095. 

  2095.         <td>Argument out of range</td>
    2096. 

  2096.       </tr>
    2097. 

  2097.       <tr>
    2098. 

  2098.         <td>
    2099. 

  2099.           <code>decimalPlaces</code><br />
    2100. 

  2100.           <code>precision</code>
    2101. 

  2101.         </td>
    2102. 

  2102.         <td>Argument not true or false</td>
    2103. 

  2103.       </tr>
    2104. 

  2104.       <tr>
    2105. 

  2105.         <td><code>exponentiatedBy</code></td>
    2106. 

  2106.         <td>Argument not an integer</td>
    2107. 

  2107.       </tr>
    2108. 

  2108.       <tr>
    2109. 

  2109.         <td><code>isBigNumber</code></td>
    2110. 

  2110.         <td>Invalid BigNumber<sup>*</sup></td>
    2111. 

  2111.       </tr>
    2112. 

  2112.       <tr>
    2113. 

  2113.         <td>
    2114. 

  2114.           <code>minimum</code><br />
    2115. 

  2115.           <code>maximum</code>
    2116. 

  2116.         </td>
    2117. 

  2117.         <td>Not a number<sup>*</sup></td>
    2118. 

  2118.       </tr>
    2119. 

  2119.       <tr>
    2120. 

  2120.         <td>
    2121. 

  2121.           <code>random</code>
    2122. 

  2122.         </td>
    2123. 

  2123.         <td>crypto unavailable</td>
    2124. 

  2124.       </tr>
    2125. 

  2125.       <tr>
    2126. 

  2126.         <td>
    2127. 

  2127.           <code>toFormat</code>
    2128. 

  2128.         </td>
    2129. 

  2129.         <td>Argument not an object</td>
    2130. 

  2130.       </tr>
    2131. 

  2131.       <tr>
    2132. 

  2132.         <td rowspan=2><code>toFraction</code></td>
    2133. 

  2133.         <td>Argument not an integer</td>
    2134. 

  2134.       </tr>
    2135. 

  2135.       <tr>
    2136. 

  2136.         <td>Argument out of range</td>
    2137. 

  2137.       </tr>
    2138. 

  2138.       <tr>
    2139. 

  2139.         <td rowspan=3><code>toString</code></td>
    2140. 

  2140.         <td>Base not a primitive number</td>
    2141. 

  2141.       </tr>
    2142. 

  2142.       <tr>
    2143. 

  2143.         <td>Base not an integer</td>
    2144. 

  2144.       </tr>
    2145. 

  2145.       <tr>
    2146. 

  2146.         <td>Base out of range</td>
    2147. 

  2147.       </tr>
    2148. 

  2148.     </table>
    2149. 

  2149.     <p><sup>*</sup>Only thrown if <code>BigNumber.DEBUG</code> is <code>true</code>.</p>
    2150. 

  2150.     <p>To determine if an exception is a BigNumber Error:</p>
    2151. 

  2151.     <pre>
    2152. 

  2152. try {
    2153. 

  2153.   // ...
    2154. 

  2154. } catch (e) {
    2155. 

  2155.   if (e instanceof Error && e.message.indexOf('[BigNumber Error]') === 0) {
    2156. 

  2156.       // ...
    2157. 

  2157.   }
    2158. 

  2158. }</pre>
    2159. 

  2159. 

  2160. 

  2161. 

  2162.     <h4 id="type-coercion">Type coercion</h4>
    2163. 

  2163.     <p>
    2164. 

  2164.       To prevent the accidental use of a BigNumber in primitive number operations, or the
    2165. 

  2165.       accidental addition of a BigNumber to a string, the <code>valueOf</code> method can be safely
    2166. 

  2166.       overwritten as shown below.
    2167. 

  2167.     </p>
    2168. 

  2168.     <p>
    2169. 

  2169.       The <a href='#valueOf'><code>valueOf</code></a> method is the same as the
    2170. 

  2170.       <a href='#toJSON'><code>toJSON</code></a> method, and both are the same as the
    2171. 

  2171.       <a href='#toS'><code>toString</code></a> method except they do not take a <code>base</code>
    2172. 

  2172.       argument and they include the minus sign for negative zero.
    2173. 

  2173.     </p>
    2174. 

  2174.     <pre>
    2175. 

  2175. BigNumber.prototype.valueOf = function () {
    2176. 

  2176.   throw Error('valueOf called!')
    2177. 

  2177. }
    2178. 

  2178. 

  2179. x = new BigNumber(1)
    2180. 

  2180. x / 2                    // '[BigNumber Error] valueOf called!'
    2181. 

  2181. x + 'abc'                // '[BigNumber Error] valueOf called!'
    2182. 

  2182. </pre>
    2183. 

  2183. 

  2184. 

  2185. 

  2186.     <h4 id='faq'>FAQ</h4>
    2187. 

  2187. 

  2188.     <h6>Why are trailing fractional zeros removed from BigNumbers?</h6>
    2189. 

  2189.     <p>
    2190. 

  2190.       Some arbitrary-precision libraries retain trailing fractional zeros as they can indicate the
    2191. 

  2191.       precision of a value. This can be useful but the results of arithmetic operations can be
    2192. 

  2192.       misleading.
    2193. 

  2193.     </p>
    2194. 

  2194.     <pre>
    2195. 

  2195. x = new BigDecimal("1.0")
    2196. 

  2196. y = new BigDecimal("1.1000")
    2197. 

  2197. z = x.add(y)                      // 2.1000
    2198. 

  2198. 

  2199. x = new BigDecimal("1.20")
    2200. 

  2200. y = new BigDecimal("3.45000")
    2201. 

  2201. z = x.multiply(y)                 // 4.1400000</pre>
    2202. 

  2202.     <p>
    2203. 

  2203.       To specify the precision of a value is to specify that the value lies
    2204. 

  2204.       within a certain range.
    2205. 

  2205.     </p>
    2206. 

  2206.     <p>
    2207. 

  2207.       In the first example, <code>x</code> has a value of <code>1.0</code>. The trailing zero shows
    2208. 

  2208.       the precision of the value, implying that it is in the range <code>0.95</code> to
    2209. 

  2209.       <code>1.05</code>. Similarly, the precision indicated by the trailing zeros of <code>y</code>
    2210. 

  2210.       indicates that the value is in the range <code>1.09995</code> to <code>1.10005</code>.
    2211. 

  2211.     </p>
    2212. 

  2212.     <p>
    2213. 

  2213.       If we  add the two lowest values in the ranges we have, <code>0.95 + 1.09995 = 2.04995</code>,
    2214. 

  2214.       and if we add the two highest values we have, <code>1.05 + 1.10005 = 2.15005</code>, so the
    2215. 

  2215.       range of the result of the addition implied by the precision of its operands is
    2216. 

  2216.       <code>2.04995</code> to <code>2.15005</code>.
    2217. 

  2217.     </p>
    2218. 

  2218.     <p>
    2219. 

  2219.       The result given by BigDecimal of <code>2.1000</code> however, indicates that the value is in
    2220. 

  2220.       the range <code>2.09995</code> to <code>2.10005</code> and therefore the precision implied by
    2221. 

  2221.       its trailing zeros may be misleading.
    2222. 

  2222.     </p>
    2223. 

  2223.     <p>
    2224. 

  2224.       In the second example, the true range is <code>4.122744</code> to <code>4.157256</code> yet
    2225. 

  2225.       the BigDecimal answer of <code>4.1400000</code> indicates a range of <code>4.13999995</code>
    2226. 

  2226.       to  <code>4.14000005</code>. Again, the precision implied by the trailing zeros may be
    2227. 

  2227.       misleading.
    2228. 

  2228.     </p>
    2229. 

  2229.     <p>
    2230. 

  2230.       This library, like binary floating point and most calculators, does not retain trailing
    2231. 

  2231.       fractional zeros. Instead, the <code>toExponential</code>, <code>toFixed</code> and
    2232. 

  2232.       <code>toPrecision</code> methods enable trailing zeros to be added if and when required.<br />
    2233. 

  2233.     </p>
    2234. 

  2234.   </div>
    2235. 

  2235. 

  2236. </body>
    2237. 

  2237. </html>
    2238.