Inicio Explorar Axuda
Rexistro Iniciar sesión
shuochen
/
apacsys-vaporrecoverymonitor
1
0
Fork 0
Ficheiros Incidencias 0 Pull Requests 0 Wiki
Rama: master
Ramas Etiquetas
apacsys-vaporre...
/
server
/
node_modules
/
bignumber.js
/
doc
/
API.html

API.html 78 KB
Permalink Histórico Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118 
  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.     <a class='nav-title' href="#">API</a>
    62. 

  62. 

  63.     <b> CONSTRUCTOR </b>
    64. 

  64.     <ul>
    65. 

  65.       <li><a href="#bignumber">BigNumber</a></li>
    66. 

  66.     </ul>
    67. 

  67. 

  68.     <a href="#methods">Methods</a>
    69. 

  69.     <ul>
    70. 

  70.       <li><a href="#clone">clone</a></li>
    71. 

  71.       <li><a href="#config" >config</a><span>set</span></li>
    72. 

  72.       <li>
    73. 

  73.         <ul class="inset">
    74. 

  74.           <li><a href="#decimal-places">DECIMAL_PLACES</a></li>
    75. 

  75.           <li><a href="#rounding-mode" >ROUNDING_MODE</a></li>
    76. 

  76.           <li><a href="#exponential-at">EXPONENTIAL_AT</a></li>
    77. 

  77.           <li><a href="#range"         >RANGE</a></li>
    78. 

  78.           <li><a href="#crypto"        >CRYPTO</a></li>
    79. 

  79.           <li><a href="#modulo-mode"   >MODULO_MODE</a></li>
    80. 

  80.           <li><a href="#pow-precision" >POW_PRECISION</a></li>
    81. 

  81.           <li><a href="#format"        >FORMAT</a></li>
    82. 

  82.           <li><a href="#alphabet"      >ALPHABET</a></li>
    83. 

  83.         </ul>
    84. 

  84.       </li>
    85. 

  85.       <li><a href="#isBigNumber">isBigNumber</a></li>
    86. 

  86.       <li><a href="#max"        >maximum</a><span>max</span></li>
    87. 

  87.       <li><a href="#min"        >minimum</a><span>min</span></li>
    88. 

  88.       <li><a href="#random"     >random</a></li>
    89. 

  89.     </ul>
    90. 

  90. 

  91.     <a href="#constructor-properties">Properties</a>
    92. 

  92.     <ul>
    93. 

  93.       <li><a href="#round-up"        >ROUND_UP</a></li>
    94. 

  94.       <li><a href="#round-down"      >ROUND_DOWN</a></li>
    95. 

  95.       <li><a href="#round-ceil"      >ROUND_CEIL</a></li>
    96. 

  96.       <li><a href="#round-floor"     >ROUND_FLOOR</a></li>
    97. 

  97.       <li><a href="#round-half-up"   >ROUND_HALF_UP</a></li>
    98. 

  98.       <li><a href="#round-half-down" >ROUND_HALF_DOWN</a></li>
    99. 

  99.       <li><a href="#round-half-even" >ROUND_HALF_EVEN</a></li>
    100. 

  100.       <li><a href="#round-half-ceil" >ROUND_HALF_CEIL</a></li>
    101. 

  101.       <li><a href="#round-half-floor">ROUND_HALF_FLOOR</a></li>
    102. 

  102.     </ul>
    103. 

  103. 

  104.     <b> INSTANCE </b>
    105. 

  105. 

  106.     <a href="#prototype-methods">Methods</a>
    107. 

  107.     <ul>
    108. 

  108.       <li><a href="#abs"    >absoluteValue         </a><span>abs</span>  </li>
    109. 

  109.       <li><a href="#cmp"    >comparedTo            </a>                  </li>
    110. 

  110.       <li><a href="#dp"     >decimalPlaces         </a><span>dp</span>   </li>
    111. 

  111.       <li><a href="#div"    >dividedBy             </a><span>div</span>  </li>
    112. 

  112.       <li><a href="#divInt" >dividedToIntegerBy    </a><span>idiv</span> </li>
    113. 

  113.       <li><a href="#pow"    >exponentiatedBy       </a><span>pow</span>  </li>
    114. 

  114.       <li><a href="#int"    >integerValue          </a>                  </li>
    115. 

  115.       <li><a href="#eq"     >isEqualTo             </a><span>eq</span>   </li>
    116. 

  116.       <li><a href="#isF"    >isFinite              </a>                  </li>
    117. 

  117.       <li><a href="#gt"     >isGreaterThan         </a><span>gt</span>   </li>
    118. 

  118.       <li><a href="#gte"    >isGreaterThanOrEqualTo</a><span>gte</span>  </li>
    119. 

  119.       <li><a href="#isInt"  >isInteger             </a>                  </li>
    120. 

  120.       <li><a href="#lt"     >isLessThan            </a><span>lt</span>   </li>
    121. 

  121.       <li><a href="#lte"    >isLessThanOrEqualTo   </a><span>lte</span>  </li>
    122. 

  122.       <li><a href="#isNaN"  >isNaN                 </a>                  </li>
    123. 

  123.       <li><a href="#isNeg"  >isNegative            </a>                  </li>
    124. 

  124.       <li><a href="#isPos"  >isPositive            </a>                  </li>
    125. 

  125.       <li><a href="#isZ"    >isZero                </a>                  </li>
    126. 

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

  127.       <li><a href="#mod"    >modulo                </a><span>mod</span>  </li>
    128. 

  128.       <li><a href="#times"  >multipliedBy          </a><span>times</span></li>
    129. 

  129.       <li><a href="#neg"    >negated               </a>                  </li>
    130. 

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

  131.       <li><a href="#sd"     >precision             </a><span>sd</span>   </li>
    132. 

  132.       <li><a href="#shift"  >shiftedBy             </a>                  </li>
    133. 

  133.       <li><a href="#sqrt"   >squareRoot            </a><span>sqrt</span> </li>
    134. 

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

  135.       <li><a href="#toFix"  >toFixed               </a>                  </li>
    136. 

  136.       <li><a href="#toFor"  >toFormat              </a>                  </li>
    137. 

  137.       <li><a href="#toFr"   >toFraction            </a>                  </li>
    138. 

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

  139.       <li><a href="#toN"    >toNumber              </a>                  </li>
    140. 

  140.       <li><a href="#toP"    >toPrecision           </a>                  </li>
    141. 

  141.       <li><a href="#toS"    >toString              </a>                  </li>
    142. 

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

  143.     </ul>
    144. 

  144. 

  145.     <a href="#instance-properties">Properties</a>
    146. 

  146.     <ul>
    147. 

  147.       <li><a href="#coefficient">c: coefficient</a></li>
    148. 

  148.       <li><a href="#exponent"   >e: exponent</a></li>
    149. 

  149.       <li><a href="#sign"       >s: sign</a></li>
    150. 

  150.     </ul>
    151. 

  151. 

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

  153.     <a href="#Errors">Errors</a>
    154. 

  154.     <a class='end' href="#faq">FAQ</a>
    155. 

  155. 

  156.   </div>
    157. 

  157. 

  158.   <div class="container">
    159. 

  159. 

  160.     <h1>bignumber<span id='js'>.js</span></h1>
    161. 

  161. 

  162.     <p>A JavaScript library for arbitrary-precision arithmetic.</p>
    163. 

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

  164. 

  165.     <h2>API</h2>
    166. 

  166. 

  167.     <p>
    168. 

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

  169.       quick-start introduction.
    170. 

  170.     </p>
    171. 

  171.     <p>
    172. 

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

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

  174.     </p>
    175. 

  175. 

  176. 

  177.     <h3>CONSTRUCTOR</h3>
    178. 

  178. 

  179. 

  180.     <h5 id="bignumber">
    181. 

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

  182.     </h5>
    183. 

  183.     <p>
    184. 

  184.       <code>n</code>: <i>number|string|BigNumber</i><br />
    185. 

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

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

  187.     </p>
    188. 

  188.     <p>
    189. 

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

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

  191.       <code>base</code> is omitted or is <code>null</code> or <code>undefined</code>.
    192. 

  192.     </p>
    193. 

  193.     <pre>
    194. 

  194. x = new BigNumber(123.4567)                // '123.4567'
    195. 

  195. // 'new' is optional
    196. 

  196. y = BigNumber(x)                           // '123.4567'</pre>
    197. 

  197.     <p>
    198. 

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

  199.       exponential notation. Values in other bases must be in normal notation. Values in any base can
    200. 

  200.       have fraction digits, i.e. digits after the decimal point.
    201. 

  201.     </p>
    202. 

  202.     <pre>
    203. 

  203. new BigNumber(43210)                       // '43210'
    204. 

  204. new BigNumber('4.321e+4')                  // '43210'
    205. 

  205. new BigNumber('-735.0918e-430')            // '-7.350918e-428'
    206. 

  206. new BigNumber('123412421.234324', 5)       // '607236.557696'</pre>
    207. 

  207.     <p>
    208. 

  208.       Signed <code>0</code>, signed <code>Infinity</code> and <code>NaN</code> are supported.
    209. 

  209.     </p>
    210. 

  210.     <pre>
    211. 

  211. new BigNumber('-Infinity')                 // '-Infinity'
    212. 

  212. new BigNumber(NaN)                         // 'NaN'
    213. 

  213. new BigNumber(-0)                          // '0'
    214. 

  214. new BigNumber('.5')                        // '0.5'
    215. 

  215. new BigNumber('+2')                        // '2'</pre>
    216. 

  216.     <p>
    217. 

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

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

  219.       String values in octal literal form without the prefix will be interpreted as
    220. 

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

  221.     </p>
    222. 

  222.     <pre>
    223. 

  223. new BigNumber(-10110100.1, 2)              // '-180.5'
    224. 

  224. new BigNumber('-0b10110100.1')             // '-180.5'
    225. 

  225. new BigNumber('ff.8', 16)                  // '255.5'
    226. 

  226. new BigNumber('0xff.8')                    // '255.5'</pre>
    227. 

  227.     <p>
    228. 

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

  229.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
    230. 

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

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

  232.       this behaviour is wanted.</em>
    233. 

  233.     </p>
    234. 

  234.     <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
    235. 

  235. new BigNumber(1.23456789)                  // '1.23456789'
    236. 

  236. new BigNumber(1.23456789, 10)              // '1.23457'</pre>
    237. 

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

  238.     <p>
    239. 

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

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

  241.       the maximum and minimum possible exponent value of a BigNumber.
    242. 

  242.     </p>
    243. 

  243.     <pre>
    244. 

  244. new BigNumber('5032485723458348569331745.33434346346912144534543')
    245. 

  245. new BigNumber('4.321e10000000')</pre>
    246. 

  246.     <p>BigNumber <code>NaN</code> is returned if <code>n</code> is invalid
    247. 

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

  248.     <pre>
    249. 

  249. new BigNumber('.1*')                       // 'NaN'
    250. 

  250. new BigNumber('blurgh')                    // 'NaN'
    251. 

  251. new BigNumber(9, 2)                        // 'NaN'</pre>
    252. 

  252.     <p>
    253. 

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

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

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

  256.       <code><a href='#toS'>toString</a></code> or <code><a href='#valueOf'>valueOf</a></code> on
    257. 

  257.       these numbers may not result in the intended value.
    258. 

  258.     </p>
    259. 

  259.       <pre>
    260. 

  260. console.log(823456789123456.3)            //  823456789123456.2
    261. 

  261. new BigNumber(823456789123456.3)          // '823456789123456.2'
    262. 

  262. BigNumber.DEBUG = true
    263. 

  263. // '[BigNumber Error] Number primitive has more than 15 significant digits'
    264. 

  264. new BigNumber(823456789123456.3)
    265. 

  265. // '[BigNumber Error] Not a base 2 number'
    266. 

  266. new BigNumber(9, 2)</pre>
    267. 

  267. 

  268. 

  269. 

  270. 

  271.     <h4 id="methods">Methods</h4>
    272. 

  272.      <p>The static methods of a BigNumber constructor.</p>
    273. 

  273. 

  274. 

  275. 

  276. 

  277.     <h5 id="clone">clone
    278. 

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

  279.     </h5>
    280. 

  280.     <p><code>object</code>: <i>object</i></p>
    281. 

  281.     <p>
    282. 

  282.       Returns a new independent BigNumber constructor with configuration as described by
    283. 

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

  284.       configuration if <code>object</code> is <code>null</code> or <code>undefined</code>.
    285. 

  285.     </p>
    286. 

  286.     <p>
    287. 

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

  288.     </p>
    289. 

  289.     <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
    290. 

  290. BN = BigNumber.clone({ DECIMAL_PLACES: 9 })
    291. 

  291. 

  292. x = new BigNumber(1)
    293. 

  293. y = new BN(1)
    294. 

  294. 

  295. x.div(3)                        // 0.33333
    296. 

  296. y.div(3)                        // 0.333333333
    297. 

  297. 

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

  299. BN = BigNumber.clone()
    300. 

  300. BN.config({ DECIMAL_PLACES: 9 })</pre>
    301. 

  301. 

  302. 

  303. 

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

  305.     <p>
    306. 

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

  307.       properties.
    308. 

  308.     </p>
    309. 

  309.     <p>Configures the settings for this particular BigNumber constructor.</p>
    310. 

  310. 

  311.     <dl class='inset'>
    312. 

  312.       <dt id="decimal-places"><code><b>DECIMAL_PLACES</b></code></dt>
    313. 

  313.       <dd>
    314. 

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

  315.         Default value: <code>20</code>
    316. 

  316.       </dd>
    317. 

  317.       <dd>
    318. 

  318.         The <u>maximum</u> number of decimal places of the results of operations involving
    319. 

  319.         division, i.e. division, square root and base conversion operations, and power
    320. 

  320.         operations with negative exponents.<br />
    321. 

  321.       </dd>
    322. 

  322.       <dd>
    323. 

  323.       <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
    324. 

  324. BigNumber.set({ DECIMAL_PLACES: 5 })    // equivalent</pre>
    325. 

  325.       </dd>
    326. 

  326. 

  327. 

  328. 

  329.       <dt id="rounding-mode"><code><b>ROUNDING_MODE</b></code></dt>
    330. 

  330.       <dd>
    331. 

  331.         <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive<br />
    332. 

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

  333.       </dd>
    334. 

  334.       <dd>
    335. 

  335.         The rounding mode used in the above operations and the default rounding mode of
    336. 

  336.         <a href='#dp'><code>decimalPlaces</code></a>,
    337. 

  337.         <a href='#sd'><code>precision</code></a>,
    338. 

  338.         <a href='#toE'><code>toExponential</code></a>,
    339. 

  339.         <a href='#toFix'><code>toFixed</code></a>,
    340. 

  340.         <a href='#toFor'><code>toFormat</code></a> and
    341. 

  341.         <a href='#toP'><code>toPrecision</code></a>.
    342. 

  342.       </dd>
    343. 

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

  344.        <dd>
    345. 

  345.       <pre>BigNumber.config({ ROUNDING_MODE: 0 })
    346. 

  346. BigNumber.set({ ROUNDING_MODE: BigNumber.ROUND_UP })    // equivalent</pre>
    347. 

  347.         </dd>
    348. 

  348. 

  349. 

  350. 

  351.       <dt id="exponential-at"><code><b>EXPONENTIAL_AT</b></code></dt>
    352. 

  352.       <dd>
    353. 

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

  354.         <br />
    355. 

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

  356.         <code>0</code> to <code>1e+9</code> inclusive ]<br />
    357. 

  357.         Default value: <code>[-7, 20]</code>
    358. 

  358.       </dd>
    359. 

  359.       <dd>
    360. 

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

  361.       </dd>
    362. 

  362.       <dd>
    363. 

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

  364.         If an array of two numbers is assigned then the first number is the negative exponent
    365. 

  365.         value at and beneath which exponential notation is used, and the second number is the
    366. 

  366.         positive exponent value at and above which the same.
    367. 

  367.       </dd>
    368. 

  368.       <dd>
    369. 

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

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

  371.       </dd>
    372. 

  372.       <dd>
    373. 

  373.       <pre>BigNumber.config({ EXPONENTIAL_AT: 2 })
    374. 

  374. new BigNumber(12.3)         // '12.3'        e is only 1
    375. 

  375. new BigNumber(123)          // '1.23e+2'
    376. 

  376. new BigNumber(0.123)        // '0.123'       e is only -1
    377. 

  377. new BigNumber(0.0123)       // '1.23e-2'
    378. 

  378. 

  379. BigNumber.config({ EXPONENTIAL_AT: [-7, 20] })
    380. 

  380. new BigNumber(123456789)    // '123456789'   e is only 8
    381. 

  381. new BigNumber(0.000000123)  // '1.23e-7'
    382. 

  382. 

  383. // Almost never return exponential notation:
    384. 

  384. BigNumber.config({ EXPONENTIAL_AT: 1e+9 })
    385. 

  385. 

  386. // Always return exponential notation:
    387. 

  387. BigNumber.config({ EXPONENTIAL_AT: 0 })</pre>
    388. 

  388.       </dd>
    389. 

  389.       <dd>
    390. 

  390.         Regardless of the value of <code>EXPONENTIAL_AT</code>, the <code>toFixed</code> method
    391. 

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

  392.         will always return a value in exponential form.
    393. 

  393.       </dd>
    394. 

  394.       <dd>
    395. 

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

  396.         also always return normal notation.
    397. 

  397.       </dd>
    398. 

  398. 

  399. 

  400. 

  401.       <dt id="range"><code><b>RANGE</b></code></dt>
    402. 

  402.       <dd>
    403. 

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

  404.         <br />
    405. 

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

  406.         <code>1</code> to <code>1e+9</code> inclusive ]<br />
    407. 

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

  408.       </dd>
    409. 

  409.       <dd>
    410. 

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

  411.         zero occurs.
    412. 

  412.       </dd>
    413. 

  413.       <dd>
    414. 

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

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

  416.         negative exponent of greater magnitude become zero.
    417. 

  417.       <dd>
    418. 

  418.         If an array of two numbers is assigned then the first number is the negative exponent
    419. 

  419.         limit and the second number is the positive exponent limit.
    420. 

  420.       </dd>
    421. 

  421.       <dd>
    422. 

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

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

  424.       </dd>
    425. 

  425.       <dd>
    426. 

  426.       <pre>BigNumber.config({ RANGE: 500 })
    427. 

  427. BigNumber.config().RANGE     // [ -500, 500 ]
    428. 

  428. new BigNumber('9.999e499')   // '9.999e+499'
    429. 

  429. new BigNumber('1e500')       // 'Infinity'
    430. 

  430. new BigNumber('1e-499')      // '1e-499'
    431. 

  431. new BigNumber('1e-500')      // '0'
    432. 

  432. 

  433. BigNumber.config({ RANGE: [-3, 4] })
    434. 

  434. new BigNumber(99999)         // '99999'      e is only 4
    435. 

  435. new BigNumber(100000)        // 'Infinity'   e is 5
    436. 

  436. new BigNumber(0.001)         // '0.01'       e is only -3
    437. 

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

  438.       </dd>
    439. 

  439.       <dd>
    440. 

  440.         The largest possible magnitude of a finite BigNumber is
    441. 

  441.         <code>9.999...e+1000000000</code>.<br />
    442. 

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

  443.       </dd>
    444. 

  444. 

  445. 

  446. 

  447.       <dt id="crypto"><code><b>CRYPTO</b></code></dt>
    448. 

  448.       <dd>
    449. 

  449.         <i>boolean</i>: <code>true</code> or <code>false</code>.<br />
    450. 

  450.         Default value: <code>false</code>
    451. 

  451.       </dd>
    452. 

  452.       <dd>
    453. 

  453.         The value that determines whether cryptographically-secure pseudo-random number
    454. 

  454.         generation is used.
    455. 

  455.       </dd>
    456. 

  456.       <dd>
    457. 

  457.         If <code>CRYPTO</code> is set to <code>true</code> then the
    458. 

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

  459.         <code>crypto.getRandomValues</code> in browsers that support it, or
    460. 

  460.         <code>crypto.randomBytes</code> if using a version of Node.js that supports it.
    461. 

  461.       </dd>
    462. 

  462.       <dd>
    463. 

  463.         If neither function is supported by the host environment then attempting to set
    464. 

  464.         <code>CRYPTO</code> to <code>true</code> will fail and an exception will be thrown.
    465. 

  465.       </dd>
    466. 

  466.       <dd>
    467. 

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

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

  469.         randomness).
    470. 

  470.       </dd>
    471. 

  471.       <dd>See <a href='#random'><code>random</code></a>.</dd>
    472. 

  472.       <dd>
    473. 

  473.       <pre>BigNumber.config({ CRYPTO: true })
    474. 

  474. BigNumber.config().CRYPTO       // true
    475. 

  475. BigNumber.random()              // 0.54340758610486147524</pre>
    476. 

  476.       </dd>
    477. 

  477. 

  478. 

  479. 

  480.       <dt id="modulo-mode"><code><b>MODULO_MODE</b></code></dt>
    481. 

  481.       <dd>
    482. 

  482.         <i>number</i>: integer, <code>0</code> to <code>9</code> inclusive<br />
    483. 

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

  484.       </dd>
    485. 

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

  486.       <dd>
    487. 

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

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

  489.         <code>MODULO_MODE</code>.
    490. 

  490.       </dd>
    491. 

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

  492.       <dd>
    493. 

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

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

  495.         useful results.
    496. 

  496.       </dd>
    497. 

  497.       <dd>
    498. 

  498.         <table>
    499. 

  499.           <tr><th>Property</th><th>Value</th><th>Description</th></tr>
    500. 

  500.           <tr>
    501. 

  501.             <td><b>ROUND_UP</b></td><td class='centre'>0</td>
    502. 

  502.             <td>
    503. 

  503.               The remainder is positive if the dividend is negative, otherwise it is negative.
    504. 

  504.             </td>
    505. 

  505.           </tr>
    506. 

  506.           <tr>
    507. 

  507.             <td><b>ROUND_DOWN</b></td><td class='centre'>1</td>
    508. 

  508.             <td>
    509. 

  509.               The remainder has the same sign as the dividend.<br />
    510. 

  510.               This uses 'truncating division' and matches the behaviour of JavaScript's
    511. 

  511.               remainder operator <code>%</code>.
    512. 

  512.             </td>
    513. 

  513.           </tr>
    514. 

  514.           <tr>
    515. 

  515.             <td><b>ROUND_FLOOR</b></td><td class='centre'>3</td>
    516. 

  516.             <td>
    517. 

  517.               The remainder has the same sign as the divisor.<br />
    518. 

  518.               This matches Python's <code>%</code> operator.
    519. 

  519.             </td>
    520. 

  520.           </tr>
    521. 

  521.           <tr>
    522. 

  522.             <td><b>ROUND_HALF_EVEN</b></td><td class='centre'>6</td>
    523. 

  523.             <td>The <i>IEEE 754</i> remainder function.</td>
    524. 

  524.           </tr>
    525. 

  525.            <tr>
    526. 

  526.              <td><b>EUCLID</b></td><td class='centre'>9</td>
    527. 

  527.              <td>
    528. 

  528.                The remainder is always positive. Euclidian division: <br />
    529. 

  529.                <code>q = sign(n) * floor(a / abs(n))</code>
    530. 

  530.              </td>
    531. 

  531.            </tr>
    532. 

  532.         </table>
    533. 

  533.       </dd>
    534. 

  534.       <dd>
    535. 

  535.         The rounding/modulo modes are available as enumerated properties of the BigNumber
    536. 

  536.         constructor.
    537. 

  537.       </dd>
    538. 

  538.       <dd>See <a href='#mod'><code>modulo</code></a>.</dd>
    539. 

  539.       <dd>
    540. 

  540.         <pre>BigNumber.config({ MODULO_MODE: BigNumber.EUCLID })
    541. 

  541. BigNumber.config({ MODULO_MODE: 9 })          // equivalent</pre>
    542. 

  542.       </dd>
    543. 

  543. 

  544. 

  545. 

  546.       <dt id="pow-precision"><code><b>POW_PRECISION</b></code></dt>
    547. 

  547.       <dd>
    548. 

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

  549.         Default value: <code>0</code>
    550. 

  550.       </dd>
    551. 

  551.       <dd>
    552. 

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

  553.         operation (unless a modulus is specified).
    554. 

  554.       </dd>
    555. 

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

  556.       <dd>See <a href='#pow'><code>exponentiatedBy</code></a>.</dd>
    557. 

  557.       <dd><pre>BigNumber.config({ POW_PRECISION: 100 })</pre></dd>
    558. 

  558. 

  559. 

  560. 

  561.       <dt id="format"><code><b>FORMAT</b></code></dt>
    562. 

  562.       <dd><i>object</i></dd>
    563. 

  563.       <dd>
    564. 

  564.         The <code>FORMAT</code> object configures the format of the string returned by the
    565. 

  565.         <a href='#toFor'><code>toFormat</code></a> method.
    566. 

  566.       </dd>
    567. 

  567.       <dd>
    568. 

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

  569.         recognised, and their default values.
    570. 

  570.       </dd>
    571. 

  571.       <dd>
    572. 

  572.          Unlike the other configuration properties, the values of the properties of the
    573. 

  573.          <code>FORMAT</code> object will not be checked for validity. The existing
    574. 

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

  575.          The object can include any number of the properties shown below.
    576. 

  576.       </dd>
    577. 

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

  578.       <dd>
    579. 

  579.       <pre>
    580. 

  580. BigNumber.config({
    581. 

  581.     FORMAT: {
    582. 

  582.         // the decimal separator
    583. 

  583.         decimalSeparator: '.',
    584. 

  584.         // the grouping separator of the integer part
    585. 

  585.         groupSeparator: ',',
    586. 

  586.         // the primary grouping size of the integer part
    587. 

  587.         groupSize: 3,
    588. 

  588.         // the secondary grouping size of the integer part
    589. 

  589.         secondaryGroupSize: 0,
    590. 

  590.         // the grouping separator of the fraction part
    591. 

  591.         fractionGroupSeparator: ' ',
    592. 

  592.         // the grouping size of the fraction part
    593. 

  593.         fractionGroupSize: 0
    594. 

  594.     }
    595. 

  595. });</pre>
    596. 

  596.       </dd>
    597. 

  597. 

  598. 

  599. 

  600.       <dt id="alphabet"><code><b>ALPHABET</b></code></dt>
    601. 

  601.       <dd>
    602. 

  602.         <i>string</i><br />
    603. 

  603.         Default value: <code>'0123456789abcdefghijklmnopqrstuvwxyz'</code>
    604. 

  604.       </dd>
    605. 

  605.       <dd>
    606. 

  606.         The alphabet used for base conversion. The length of the alphabet corresponds to the
    607. 

  607.         maximum value of the base argument that can be passed to the
    608. 

  608.         <a href='#bignumber'><code>BigNumber</code></a> constructor or
    609. 

  609.         <a href='#toS'><code>toString</code></a>.
    610. 

  610.       </dd>
    611. 

  611.       <dd>
    612. 

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

  613.         it must not contain a repeated character, or <code>'.'</code>, as that is used as the
    614. 

  614.         decimal separator for all values whatever their base.
    615. 

  615.       </dd>
    616. 

  616.       <dd>
    617. 

  617.         <pre>// duodecimal (base 12)
    618. 

  618. BigNumber.config({ ALPHABET: '0123456789TE' })
    619. 

  619. x = new BigNumber('T', 12)
    620. 

  620. x.toString()                // '10'
    621. 

  621. x.toString(12)              // 'T'</pre>
    622. 

  622.       </dd>
    623. 

  623. 

  624. 

  625. 

  626.     </dl>
    627. 

  627.     <br /><br />
    628. 

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

  629.     <p>
    630. 

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

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

  632.     </p>
    633. 

  633.     <pre>
    634. 

  634. BigNumber.config({
    635. 

  635.     DECIMAL_PLACES: 40,
    636. 

  636.     ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
    637. 

  637.     EXPONENTIAL_AT: [-10, 20],
    638. 

  638.     RANGE: [-500, 500],
    639. 

  639.     CRYPTO: true,
    640. 

  640.     MODULO_MODE: BigNumber.ROUND_FLOOR,
    641. 

  641.     POW_PRECISION: 80,
    642. 

  642.     FORMAT: {
    643. 

  643.         groupSize: 3,
    644. 

  644.         groupSeparator: ' ',
    645. 

  645.         decimalSeparator: ','
    646. 

  646.     },
    647. 

  647.     ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
    648. 

  648. });
    649. 

  649. 

  650. obj = BigNumber.config();
    651. 

  651. obj.DECIMAL_PLACES        // 40
    652. 

  652. obj.RANGE                 // [-500, 500]</pre>
    653. 

  653. 

  654. 

  655. 

  656.     <h5 id="isBigNumber">
    657. 

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

  658.     </h5>
    659. 

  659.     <p><code>value</code>: <i>any</i><br /></p>
    660. 

  660.     <p>
    661. 

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

  662.       <code>false</code>.
    663. 

  663.     </p>
    664. 

  664.       <pre>x = 42
    665. 

  665. y = new BigNumber(x)
    666. 

  666. 

  667. BigNumber.isBigNumber(x)             // false
    668. 

  668. y instanceof BigNumber               // true
    669. 

  669. BigNumber.isBigNumber(y)             // true
    670. 

  670. 

  671. BN = BigNumber.clone();
    672. 

  672. z = new BN(x)
    673. 

  673. z instanceof BigNumber               // false
    674. 

  674. BigNumber.isBigNumber(z)             // true</pre>
    675. 

  675. 

  676. 

  677. 

  678.     <h5 id="max">
    679. 

  679.       maximum<code class='inset'>.max([arg1 [, arg2, ...]]) <i>&rArr; BigNumber</i></code>
    680. 

  680.     </h5>
    681. 

  681.     <p>
    682. 

  682.       <code>arg1</code>, <code>arg2</code>, ...: <i>number|string|BigNumber</i><br />
    683. 

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

  684.     </p>
    685. 

  685.     <p>
    686. 

  686.       Returns a BigNumber whose value is the maximum of <code>arg1</code>,
    687. 

  687.       <code>arg2</code>,... .
    688. 

  688.     </p>
    689. 

  689.     <p>The argument to this method can also be an array of values.</p>
    690. 

  690.     <p>The return value is always exact and unrounded.</p>
    691. 

  691.     <pre>x = new BigNumber('3257869345.0378653')
    692. 

  692. BigNumber.maximum(4e9, x, '123456789.9')      // '4000000000'
    693. 

  693. 

  694. arr = [12, '13', new BigNumber(14)]
    695. 

  695. BigNumber.max(arr)                            // '14'</pre>
    696. 

  696. 

  697. 

  698. 

  699.     <h5 id="min">
    700. 

  700.       minimum<code class='inset'>.min([arg1 [, arg2, ...]]) <i>&rArr; BigNumber</i></code>
    701. 

  701.     </h5>
    702. 

  702.     <p>
    703. 

  703.       <code>arg1</code>, <code>arg2</code>, ...: <i>number|string|BigNumber</i><br />
    704. 

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

  705.     </p>
    706. 

  706.     <p>
    707. 

  707.       Returns a BigNumber whose value is the minimum of <code>arg1</code>,
    708. 

  708.       <code>arg2</code>,... .
    709. 

  709.     </p>
    710. 

  710.     <p>The argument to this method can also be an array of values.</p>
    711. 

  711.     <p>The return value is always exact and unrounded.</p>
    712. 

  712.     <pre>x = new BigNumber('3257869345.0378653')
    713. 

  713. BigNumber.minimum(4e9, x, '123456789.9')      // '123456789.9'
    714. 

  714. 

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

  716. BigNumber.min(arr)                            // '-15.9999'</pre>
    717. 

  717. 

  718. 

  719. 

  720.     <h5 id="random">
    721. 

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

  722.     </h5>
    723. 

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

  724.     <p>
    725. 

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

  726.       less than <code>1</code>.
    727. 

  727.     </p>
    728. 

  728.     <p>
    729. 

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

  730.       produced).<br />
    731. 

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

  732.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> setting.
    733. 

  733.     </p>
    734. 

  734.     <p>
    735. 

  735.       Depending on the value of this BigNumber constructor's
    736. 

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

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

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

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

  740.     </p>
    741. 

  741.     <p>
    742. 

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

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

  744.       cryptographically-secure and statistically indistinguishable from a random value.
    745. 

  745.     </p>
    746. 

  746.     <p>
    747. 

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

  748.     </p>
    749. 

  749.     <pre>BigNumber.config({ DECIMAL_PLACES: 10 })
    750. 

  750. BigNumber.random()              // '0.4117936847'
    751. 

  751. BigNumber.random(20)            // '0.78193327636914089009'</pre>
    752. 

  752. 

  753. 

  754. 

  755.     <h4 id="constructor-properties">Properties</h4>
    756. 

  756.     <p>
    757. 

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

  758.       (They are not referenced internally by the library itself.)
    759. 

  759.     </p>
    760. 

  760.     <p>
    761. 

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

  762.       BigDecimal class.
    763. 

  763.     </p>
    764. 

  764.     <table>
    765. 

  765.       <tr>
    766. 

  766.         <th>Property</th>
    767. 

  767.         <th>Value</th>
    768. 

  768.         <th>Description</th>
    769. 

  769.       </tr>
    770. 

  770.       <tr>
    771. 

  771.         <td id="round-up"><b>ROUND_UP</b></td>
    772. 

  772.         <td class='centre'>0</td>
    773. 

  773.         <td>Rounds away from zero</td>
    774. 

  774.       </tr>
    775. 

  775.       <tr>
    776. 

  776.         <td id="round-down"><b>ROUND_DOWN</b></td>
    777. 

  777.         <td class='centre'>1</td>
    778. 

  778.         <td>Rounds towards zero</td>
    779. 

  779.       </tr>
    780. 

  780.       <tr>
    781. 

  781.         <td id="round-ceil"><b>ROUND_CEIL</b></td>
    782. 

  782.         <td class='centre'>2</td>
    783. 

  783.         <td>Rounds towards <code>Infinity</code></td>
    784. 

  784.       </tr>
    785. 

  785.       <tr>
    786. 

  786.         <td id="round-floor"><b>ROUND_FLOOR</b></td>
    787. 

  787.         <td class='centre'>3</td>
    788. 

  788.         <td>Rounds towards <code>-Infinity</code></td>
    789. 

  789.       </tr>
    790. 

  790.       <tr>
    791. 

  791.         <td id="round-half-up"><b>ROUND_HALF_UP</b></td>
    792. 

  792.         <td class='centre'>4</td>
    793. 

  793.         <td>
    794. 

  794.           Rounds towards nearest neighbour.<br />
    795. 

  795.           If equidistant, rounds away from zero
    796. 

  796.         </td>
    797. 

  797.       </tr>
    798. 

  798.       <tr>
    799. 

  799.         <td id="round-half-down"><b>ROUND_HALF_DOWN</b></td>
    800. 

  800.         <td class='centre'>5</td>
    801. 

  801.         <td>
    802. 

  802.           Rounds towards nearest neighbour.<br />
    803. 

  803.           If equidistant, rounds towards zero
    804. 

  804.         </td>
    805. 

  805.       </tr>
    806. 

  806.       <tr>
    807. 

  807.         <td id="round-half-even"><b>ROUND_HALF_EVEN</b></td>
    808. 

  808.         <td class='centre'>6</td>
    809. 

  809.         <td>
    810. 

  810.           Rounds towards nearest neighbour.<br />
    811. 

  811.           If equidistant, rounds towards even neighbour
    812. 

  812.         </td>
    813. 

  813.       </tr>
    814. 

  814.       <tr>
    815. 

  815.         <td id="round-half-ceil"><b>ROUND_HALF_CEIL</b></td>
    816. 

  816.         <td class='centre'>7</td>
    817. 

  817.         <td>
    818. 

  818.           Rounds towards nearest neighbour.<br />
    819. 

  819.           If equidistant, rounds towards <code>Infinity</code>
    820. 

  820.         </td>
    821. 

  821.       </tr>
    822. 

  822.       <tr>
    823. 

  823.         <td id="round-half-floor"><b>ROUND_HALF_FLOOR</b></td>
    824. 

  824.         <td class='centre'>8</td>
    825. 

  825.         <td>
    826. 

  826.           Rounds towards nearest neighbour.<br />
    827. 

  827.           If equidistant, rounds towards <code>-Infinity</code>
    828. 

  828.         </td>
    829. 

  829.       </tr>
    830. 

  830.     </table>
    831. 

  831.     <pre>
    832. 

  832. BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_CEIL })
    833. 

  833. BigNumber.config({ ROUNDING_MODE: 2 })     // equivalent</pre>
    834. 

  834. 

  835. 

  836.     <h3>INSTANCE</h3>
    837. 

  837. 

  838.     <h4 id="prototype-methods">Methods</h4>
    839. 

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

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

  841.     <p>
    842. 

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

  843.       consistent with how JavaScript treats these values.
    844. 

  844.     </p>
    845. 

  845.     <p>Many method names have a shorter alias.</p>
    846. 

  846. 

  847. 

  848. 

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

  850.     <p>
    851. 

  851.       Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of
    852. 

  852.       this BigNumber.
    853. 

  853.     </p>
    854. 

  854.     <p>The return value is always exact and unrounded.</p>
    855. 

  855.     <pre>
    856. 

  856. x = new BigNumber(-0.8)
    857. 

  857. y = x.absoluteValue()           // '0.8'
    858. 

  858. z = y.abs()                     // '0.8'</pre>
    859. 

  859. 

  860. 

  861. 

  862.     <h5 id="cmp">
    863. 

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

  864.     </h5>
    865. 

  865.     <p>
    866. 

  866.       <code>n</code>: <i>number|string|BigNumber</i><br />
    867. 

  867.       <code>base</code>: <i>number</i><br />
    868. 

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

  869.     </p>
    870. 

  870.     <table>
    871. 

  871.       <tr><th>Returns</th><th>&nbsp;</th></tr>
    872. 

  872.       <tr>
    873. 

  873.         <td class='centre'><code>1</code></td>
    874. 

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

  875.       </tr>
    876. 

  876.       <tr>
    877. 

  877.         <td class='centre'><code>-1</code></td>
    878. 

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

  879.       </tr>
    880. 

  880.       <tr>
    881. 

  881.         <td class='centre'><code>0</code></td>
    882. 

  882.         <td>If this BigNumber and <code>n</code> have the same value</td>
    883. 

  883.       </tr>
    884. 

  884.        <tr>
    885. 

  885.         <td class='centre'><code>null</code></td>
    886. 

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

  887.       </tr>
    888. 

  888.     </table>
    889. 

  889.     <pre>
    890. 

  890. x = new BigNumber(Infinity)
    891. 

  891. y = new BigNumber(5)
    892. 

  892. x.comparedTo(y)                 // 1
    893. 

  893. x.comparedTo(x.minus(1))        // 0
    894. 

  894. y.comparedTo(NaN)               // null
    895. 

  895. y.comparedTo('110', 2)          // -1</pre>
    896. 

  896. 

  897. 

  898. 

  899.     <h5 id="dp">
    900. 

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

  901.     </h5>
    902. 

  902.     <p>
    903. 

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

  904.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    905. 

  905.     </p>
    906. 

  906.     <p>
    907. 

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

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

  909.     </p>
    910. 

  910.     <p>
    911. 

  911.       If <code>dp</code> is omitted, or is <code>null</code> or <code>undefined</code>, the return
    912. 

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

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

  914.     </p>
    915. 

  915.     <p>
    916. 

  916.       If <code>rm</code> is omitted, or is <code>null</code> or <code>undefined</code>,
    917. 

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

  918.     </p>
    919. 

  919.     <p>
    920. 

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

  921.     </p>
    922. 

  922.     <pre>
    923. 

  923. x = new BigNumber(1234.56)
    924. 

  924. x.decimalPlaces(1)                     // '1234.6'
    925. 

  925. x.dp()                                 // 2
    926. 

  926. x.decimalPlaces(2)                     // '1234.56'
    927. 

  927. x.dp(10)                               // '1234.56'
    928. 

  928. x.decimalPlaces(0, 1)                  // '1234'
    929. 

  929. x.dp(0, 6)                             // '1235'
    930. 

  930. x.decimalPlaces(1, 1)                  // '1234.5'
    931. 

  931. x.dp(1, BigNumber.ROUND_HALF_EVEN)     // '1234.6'
    932. 

  932. x                                      // '1234.56'
    933. 

  933. y = new BigNumber('9.9e-101')
    934. 

  934. y.dp()                                 // 102</pre>
    935. 

  935. 

  936. 

  937. 

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

  939.     </h5>
    940. 

  940.     <p>
    941. 

  941.       <code>n</code>: <i>number|string|BigNumber</i><br />
    942. 

  942.       <code>base</code>: <i>number</i><br />
    943. 

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

  944.     </p>
    945. 

  945.     <p>
    946. 

  946.       Returns a BigNumber whose value is the value of this BigNumber divided by
    947. 

  947.       <code>n</code>, rounded according to the current
    948. 

  948.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
    949. 

  949.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
    950. 

  950.     </p>
    951. 

  951.     <pre>
    952. 

  952. x = new BigNumber(355)
    953. 

  953. y = new BigNumber(113)
    954. 

  954. x.dividedBy(y)                  // '3.14159292035398230088'
    955. 

  955. x.div(5)                        // '71'
    956. 

  956. x.div(47, 16)                   // '5'</pre>
    957. 

  957. 

  958. 

  959. 

  960.     <h5 id="divInt">
    961. 

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

  962.       <i>BigNumber</i></code>
    963. 

  963.     </h5>
    964. 

  964.     <p>
    965. 

  965.       <code>n</code>: <i>number|string|BigNumber</i><br />
    966. 

  966.       <code>base</code>: <i>number</i><br />
    967. 

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

  968.     </p>
    969. 

  969.     <p>
    970. 

  970.       Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by
    971. 

  971.       <code>n</code>.
    972. 

  972.     </p>
    973. 

  973.     <pre>
    974. 

  974. x = new BigNumber(5)
    975. 

  975. y = new BigNumber(3)
    976. 

  976. x.dividedToIntegerBy(y)         // '1'
    977. 

  977. x.idiv(0.7)                     // '7'
    978. 

  978. x.idiv('0.f', 16)               // '5'</pre>
    979. 

  979. 

  980. 

  981. 

  982.     <h5 id="pow">
    983. 

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

  984.     </h5>
    985. 

  985.     <p>
    986. 

  986.       <code>n</code>: <i>number|string|BigNumber</i>: integer<br />
    987. 

  987.       <code>m</code>: <i>number|string|BigNumber</i>
    988. 

  988.     </p>
    989. 

  989.     <p>
    990. 

  990.       Returns a BigNumber whose value is the value of this BigNumber exponentiated by
    991. 

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

  992.       <code>m</code>.
    993. 

  993.     </p>
    994. 

  994.     <p>
    995. 

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

  996.     </p>
    997. 

  997.     <p>
    998. 

  998.       If <code>n</code> is negative the result is rounded according to the current
    999. 

  999.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
    1000. 

  1000.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
    1001. 

  1001.     </p>
    1002. 

  1002.     <p>
    1003. 

  1003.       As the number of digits of the result of the power operation can grow so large so quickly,
    1004. 

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

  1005.       digits calculated is limited to the value of the
    1006. 

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

  1007.       <code>m</code> is specified).
    1008. 

  1008.     </p>
    1009. 

  1009.     <p>
    1010. 

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

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

  1012.       method's performance will decrease dramatically for larger exponents.
    1013. 

  1013.     </p>
    1014. 

  1014.     <p>
    1015. 

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

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

  1017.       algorithm is used, otherwise the operation will be performed as
    1018. 

  1018.       <code>x.exponentiatedBy(n).modulo(m)</code> with a
    1019. 

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

  1020.     </p>
    1021. 

  1021.     <pre>
    1022. 

  1022. Math.pow(0.7, 2)                // 0.48999999999999994
    1023. 

  1023. x = new BigNumber(0.7)
    1024. 

  1024. x.exponentiatedBy(2)            // '0.49'
    1025. 

  1025. BigNumber(3).pow(-2)            // '0.11111111111111111111'</pre>
    1026. 

  1026. 

  1027. 

  1028. 

  1029.     <h5 id="int">
    1030. 

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

  1031.     </h5>
    1032. 

  1032.     <p>
    1033. 

  1033.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1034. 

  1034.     </p>
    1035. 

  1035.    <p>
    1036. 

  1036.       Returns a BigNumber whose value is the value of this BigNumber rounded to an integer using
    1037. 

  1037.       rounding mode <code>rm</code>.
    1038. 

  1038.     </p>
    1039. 

  1039.     <p>
    1040. 

  1040.       If <code>rm</code> is omitted, or is <code>null</code> or <code>undefined</code>,
    1041. 

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

  1042.     </p>
    1043. 

  1043.     <p>
    1044. 

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

  1045.     </p>
    1046. 

  1046.     <pre>
    1047. 

  1047. x = new BigNumber(123.456)
    1048. 

  1048. x.integerValue()                        // '123'
    1049. 

  1049. x.integerValue(BigNumber.ROUND_CEIL)    // '124'
    1050. 

  1050. y = new BigNumber(-12.7)
    1051. 

  1051. y.integerValue()                        // '-13'
    1052. 

  1052. y.integerValue(BigNumber.ROUND_DOWN)    // '-12'</pre>
    1053. 

  1053.     <p>
    1054. 

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

  1055.       <code>Math.round</code> function. <code>Math.ceil</code>, <code>Math.floor</code> and
    1056. 

  1056.       <code>Math.trunc</code> can be emulated in the same way with
    1057. 

  1057.       <code>BigNumber.ROUND_CEIL</code>, <code>BigNumber.ROUND_FLOOR</code> and
    1058. 

  1058.       <code> BigNumber.ROUND_DOWN</code> respectively.
    1059. 

  1059.     </p>
    1060. 

  1060.     <pre>
    1061. 

  1061. BigNumber.prototype.round = function (n) {
    1062. 

  1062.   return n.integerValue(BigNumber.ROUND_HALF_CEIL);
    1063. 

  1063. };
    1064. 

  1064. x.round()                               // '123'</pre>
    1065. 

  1065. 

  1066. 

  1067. 

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

  1069.     <p>
    1070. 

  1070.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1071. 

  1071.       <code>base</code>: <i>number</i><br />
    1072. 

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

  1073.     </p>
    1074. 

  1074.     <p>
    1075. 

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

  1076.       <code>n</code>, otherwise returns <code>false</code>.<br />
    1077. 

  1077.       As with JavaScript, <code>NaN</code> does not equal <code>NaN</code>.
    1078. 

  1078.     </p>
    1079. 

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

  1080.     <pre>
    1081. 

  1081. 0 === 1e-324                    // true
    1082. 

  1082. x = new BigNumber(0)
    1083. 

  1083. x.isEqualTo('1e-324')           // false
    1084. 

  1084. BigNumber(-0).eq(x)             // true  ( -0 === 0 )
    1085. 

  1085. BigNumber(255).eq('ff', 16)     // true
    1086. 

  1086. 

  1087. y = new BigNumber(NaN)
    1088. 

  1088. y.isEqualTo(NaN)                // false</pre>
    1089. 

  1089. 

  1090. 

  1091. 

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

  1093.     <p>
    1094. 

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

  1095.       returns <code>false</code>.
    1096. 

  1096.     </p>
    1097. 

  1097.     <p>
    1098. 

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

  1099.       and <code>-Infinity</code>.
    1100. 

  1100.     </p>
    1101. 

  1101.     <pre>
    1102. 

  1102. x = new BigNumber(1)
    1103. 

  1103. x.isFinite()                    // true
    1104. 

  1104. y = new BigNumber(Infinity)
    1105. 

  1105. y.isFinite()                    // false</pre>
    1106. 

  1106.     <p>
    1107. 

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

  1108.       <code>n &lt;= Number.MAX_VALUE</code>.
    1109. 

  1109.     </p>
    1110. 

  1110. 

  1111. 

  1112. 

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

  1114.     <p>
    1115. 

  1115.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1116. 

  1116.       <code>base</code>: <i>number</i><br />
    1117. 

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

  1118.     </p>
    1119. 

  1119.     <p>
    1120. 

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

  1121.       <code>n</code>, otherwise returns <code>false</code>.
    1122. 

  1122.     </p>
    1123. 

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

  1124.     <pre>
    1125. 

  1125. 0.1 &gt; (0.3 - 0.2)                             // true
    1126. 

  1126. x = new BigNumber(0.1)
    1127. 

  1127. x.isGreaterThan(BigNumber(0.3).minus(0.2))    // false
    1128. 

  1128. BigNumber(0).gt(x)                            // false
    1129. 

  1129. BigNumber(11, 3).gt(11.1, 2)                  // true</pre>
    1130. 

  1130. 

  1131. 

  1132. 

  1133.     <h5 id="gte">
    1134. 

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

  1135.     </h5>
    1136. 

  1136.     <p>
    1137. 

  1137.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1138. 

  1138.       <code>base</code>: <i>number</i><br />
    1139. 

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

  1140.     </p>
    1141. 

  1141.     <p>
    1142. 

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

  1143.       of <code>n</code>, otherwise returns <code>false</code>.
    1144. 

  1144.     </p>
    1145. 

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

  1146.     <pre>
    1147. 

  1147. (0.3 - 0.2) &gt;= 0.1                     // false
    1148. 

  1148. x = new BigNumber(0.3).minus(0.2)
    1149. 

  1149. x.isGreaterThanOrEqualTo(0.1)          // true
    1150. 

  1150. BigNumber(1).gte(x)                    // true
    1151. 

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

  1152. 

  1153. 

  1154. 

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

  1156.     <p>
    1157. 

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

  1158.       <code>false</code>.
    1159. 

  1159.     </p>
    1160. 

  1160.     <pre>
    1161. 

  1161. x = new BigNumber(1)
    1162. 

  1162. x.isInteger()                   // true
    1163. 

  1163. y = new BigNumber(123.456)
    1164. 

  1164. y.isInteger()                   // false</pre>
    1165. 

  1165. 

  1166. 

  1167. 

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

  1169.     <p>
    1170. 

  1170.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1171. 

  1171.       <code>base</code>: <i>number</i><br />
    1172. 

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

  1173.     </p>
    1174. 

  1174.     <p>
    1175. 

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

  1176.       <code>n</code>, otherwise returns <code>false</code>.
    1177. 

  1177.     </p>
    1178. 

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

  1179.     <pre>
    1180. 

  1180. (0.3 - 0.2) &lt; 0.1                       // true
    1181. 

  1181. x = new BigNumber(0.3).minus(0.2)
    1182. 

  1182. x.isLessThan(0.1)                       // false
    1183. 

  1183. BigNumber(0).lt(x)                      // true
    1184. 

  1184. BigNumber(11.1, 2).lt(11, 3)            // true</pre>
    1185. 

  1185. 

  1186. 

  1187. 

  1188.     <h5 id="lte">
    1189. 

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

  1190.     </h5>
    1191. 

  1191.     <p>
    1192. 

  1192.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1193. 

  1193.       <code>base</code>: <i>number</i><br />
    1194. 

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

  1195.     </p>
    1196. 

  1196.     <p>
    1197. 

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

  1198.       <code>n</code>, otherwise returns <code>false</code>.
    1199. 

  1199.     </p>
    1200. 

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

  1201.     <pre>
    1202. 

  1202. 0.1 &lt;= (0.3 - 0.2)                                // false
    1203. 

  1203. x = new BigNumber(0.1)
    1204. 

  1204. x.isLessThanOrEqualTo(BigNumber(0.3).minus(0.2))  // true
    1205. 

  1205. BigNumber(-1).lte(x)                              // true
    1206. 

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

  1207. 

  1208. 

  1209. 

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

  1211.     <p>
    1212. 

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

  1213.       returns <code>false</code>.
    1214. 

  1214.     </p>
    1215. 

  1215.     <pre>
    1216. 

  1216. x = new BigNumber(NaN)
    1217. 

  1217. x.isNaN()                       // true
    1218. 

  1218. y = new BigNumber('Infinity')
    1219. 

  1219. y.isNaN()                       // false</pre>
    1220. 

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

  1221. 

  1222. 

  1223. 

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

  1225.     <p>
    1226. 

  1226.       Returns <code>true</code> if the value of this BigNumber is negative, otherwise returns
    1227. 

  1227.       <code>false</code>.
    1228. 

  1228.     </p>
    1229. 

  1229.     <pre>
    1230. 

  1230. x = new BigNumber(-0)
    1231. 

  1231. x.isNegative()                  // true
    1232. 

  1232. y = new BigNumber(2)
    1233. 

  1233. y.isNegative()                  // false</pre>
    1234. 

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

  1235. 

  1236. 

  1237. 

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

  1239.     <p>
    1240. 

  1240.       Returns <code>true</code> if the value of this BigNumber is positive, otherwise returns
    1241. 

  1241.       <code>false</code>.
    1242. 

  1242.     </p>
    1243. 

  1243.     <pre>
    1244. 

  1244. x = new BigNumber(-0)
    1245. 

  1245. x.isPositive()                  // false
    1246. 

  1246. y = new BigNumber(2)
    1247. 

  1247. y.isPositive()                  // true</pre>
    1248. 

  1248. 

  1249. 

  1250. 

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

  1252.     <p>
    1253. 

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

  1254.       returns <code>false</code>.
    1255. 

  1255.     </p>
    1256. 

  1256.     <pre>
    1257. 

  1257. x = new BigNumber(-0)
    1258. 

  1258. x.isZero() && x.isneg()         // true
    1259. 

  1259. y = new BigNumber(Infinity)
    1260. 

  1260. y.isZero()                      // false</pre>
    1261. 

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

  1262. 

  1263. 

  1264. 

  1265.     <h5 id="minus">
    1266. 

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

  1267.     </h5>
    1268. 

  1268.     <p>
    1269. 

  1269.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1270. 

  1270.       <code>base</code>: <i>number</i><br />
    1271. 

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

  1272.     </p>
    1273. 

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

  1274.     <p>The return value is always exact and unrounded.</p>
    1275. 

  1275.     <pre>
    1276. 

  1276. 0.3 - 0.1                       // 0.19999999999999998
    1277. 

  1277. x = new BigNumber(0.3)
    1278. 

  1278. x.minus(0.1)                    // '0.2'
    1279. 

  1279. x.minus(0.6, 20)                // '0'</pre>
    1280. 

  1280. 

  1281. 

  1282. 

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

  1284.     <p>
    1285. 

  1285.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1286. 

  1286.       <code>base</code>: <i>number</i><br />
    1287. 

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

  1288.     </p>
    1289. 

  1289.     <p>
    1290. 

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

  1291.       the integer remainder of dividing this BigNumber by <code>n</code>.
    1292. 

  1292.     </p>
    1293. 

  1293.     <p>
    1294. 

  1294.       The value returned, and in particular its sign, is dependent on the value of the
    1295. 

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

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

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

  1298.       precision) and BigDecimal's <code>remainder</code> method.
    1299. 

  1299.     </p>
    1300. 

  1300.     <p>The return value is always exact and unrounded.</p>
    1301. 

  1301.     <p>
    1302. 

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

  1303.       modulo modes.
    1304. 

  1304.     </p>
    1305. 

  1305.     <pre>
    1306. 

  1306. 1 % 0.9                         // 0.09999999999999998
    1307. 

  1307. x = new BigNumber(1)
    1308. 

  1308. x.modulo(0.9)                   // '0.1'
    1309. 

  1309. y = new BigNumber(33)
    1310. 

  1310. y.mod('a', 33)                  // '3'</pre>
    1311. 

  1311. 

  1312. 

  1313. 

  1314.     <h5 id="times">
    1315. 

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

  1316.     </h5>
    1317. 

  1317.     <p>
    1318. 

  1318.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1319. 

  1319.       <code>base</code>: <i>number</i><br />
    1320. 

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

  1321.     </p>
    1322. 

  1322.     <p>
    1323. 

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

  1324.     </p>
    1325. 

  1325.     <p>The return value is always exact and unrounded.</p>
    1326. 

  1326.     <pre>
    1327. 

  1327. 0.6 * 3                         // 1.7999999999999998
    1328. 

  1328. x = new BigNumber(0.6)
    1329. 

  1329. y = x.multipliedBy(3)           // '1.8'
    1330. 

  1330. BigNumber('7e+500').times(y)    // '1.26e+501'
    1331. 

  1331. x.multipliedBy('-a', 16)        // '-6'</pre>
    1332. 

  1332. 

  1333. 

  1334. 

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

  1336.     <p>
    1337. 

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

  1338.       <code>-1</code>.
    1339. 

  1339.     </p>
    1340. 

  1340.     <pre>
    1341. 

  1341. x = new BigNumber(1.8)
    1342. 

  1342. x.negated()                     // '-1.8'
    1343. 

  1343. y = new BigNumber(-1.3)
    1344. 

  1344. y.negated()                     // '1.3'</pre>
    1345. 

  1345. 

  1346. 

  1347. 

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

  1349.     <p>
    1350. 

  1350.       <code>n</code>: <i>number|string|BigNumber</i><br />
    1351. 

  1351.       <code>base</code>: <i>number</i><br />
    1352. 

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

  1353.     </p>
    1354. 

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

  1355.     <p>The return value is always exact and unrounded.</p>
    1356. 

  1356.     <pre>
    1357. 

  1357. 0.1 + 0.2                       // 0.30000000000000004
    1358. 

  1358. x = new BigNumber(0.1)
    1359. 

  1359. y = x.plus(0.2)                 // '0.3'
    1360. 

  1360. BigNumber(0.7).plus(x).plus(y)  // '1'
    1361. 

  1361. x.plus('0.1', 8)                // '0.225'</pre>
    1362. 

  1362. 

  1363. 

  1364. 

  1365.     <h5 id="sd">
    1366. 

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

  1367.     </h5>
    1368. 

  1368.     <p>
    1369. 

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

  1370.       inclusive, or <code>true</code> or <code>false</code><br />
    1371. 

  1371.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive.
    1372. 

  1372.     </p>
    1373. 

  1373.     <p>
    1374. 

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

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

  1376.       <code>rm</code>.
    1377. 

  1377.     </p>
    1378. 

  1378.     <p>
    1379. 

  1379.       If <code>d</code> is omitted or is <code>null</code> or <code>undefined</code>, the return
    1380. 

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

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

  1382.     </p>
    1383. 

  1383.     <p>
    1384. 

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

  1385.       part of a number are counted as significant digits, otherwise they are not.
    1386. 

  1386.     </p>
    1387. 

  1387.     <p>
    1388. 

  1388.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1389. 

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

  1390.     </p>
    1391. 

  1391.     <p>
    1392. 

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

  1393.     </p>
    1394. 

  1394.     <pre>
    1395. 

  1395. x = new BigNumber(9876.54321)
    1396. 

  1396. x.precision(6)                         // '9876.54'
    1397. 

  1397. x.sd()                                 // 9
    1398. 

  1398. x.precision(6, BigNumber.ROUND_UP)     // '9876.55'
    1399. 

  1399. x.sd(2)                                // '9900'
    1400. 

  1400. x.precision(2, 1)                      // '9800'
    1401. 

  1401. x                                      // '9876.54321'
    1402. 

  1402. y = new BigNumber(987000)
    1403. 

  1403. y.precision()                          // 3
    1404. 

  1404. y.sd(true)                             // 6</pre>
    1405. 

  1405. 

  1406. 

  1407. 

  1408. <h5 id="shift">shiftedBy<code class='inset'>.shiftedBy(n) <i>&rArr; BigNumber</i></code></h5>
    1409. 

  1409.     <p>
    1410. 

  1410.       <code>n</code>: <i>number</i>: integer,
    1411. 

  1411.       <code>-9007199254740991</code> to <code>9007199254740991</code> inclusive
    1412. 

  1412.     </p>
    1413. 

  1413.     <p>
    1414. 

  1414.       Returns a BigNumber whose value is the value of this BigNumber shifted by <code>n</code>
    1415. 

  1415.       places.
    1416. 

  1416.     <p>
    1417. 

  1417.       The shift is of the decimal point, i.e. of powers of ten, and is to the left if <code>n</code>
    1418. 

  1418.       is negative or to the right if <code>n</code> is positive.
    1419. 

  1419.     </p>
    1420. 

  1420.     <p>The return value is always exact and unrounded.</p>
    1421. 

  1421.     <p>
    1422. 

  1422.       Throws if <code>n</code> is invalid. See <a href='#Errors'>Errors</a>.
    1423. 

  1423.     </p>
    1424. 

  1424.     <pre>
    1425. 

  1425. x = new BigNumber(1.23)
    1426. 

  1426. x.shiftedBy(3)                      // '1230'
    1427. 

  1427. x.shiftedBy(-3)                     // '0.00123'</pre>
    1428. 

  1428. 

  1429. 

  1430. 

  1431.     <h5 id="sqrt">squareRoot<code class='inset'>.sqrt() <i>&rArr; BigNumber</i></code></h5>
    1432. 

  1432.     <p>
    1433. 

  1433.       Returns a BigNumber whose value is the square root of the value of this BigNumber,
    1434. 

  1434.       rounded according to the current
    1435. 

  1435.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
    1436. 

  1436.       <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
    1437. 

  1437.     </p>
    1438. 

  1438.     <p>
    1439. 

  1439.       The return value will be correctly rounded, i.e. rounded as if the result was first calculated
    1440. 

  1440.       to an infinite number of correct digits before rounding.
    1441. 

  1441.     </p>
    1442. 

  1442.     <pre>
    1443. 

  1443. x = new BigNumber(16)
    1444. 

  1444. x.squareRoot()                  // '4'
    1445. 

  1445. y = new BigNumber(3)
    1446. 

  1446. y.sqrt()                        // '1.73205080756887729353'</pre>
    1447. 

  1447. 

  1448. 

  1449. 

  1450.     <h5 id="toE">
    1451. 

  1451.       toExponential<code class='inset'>.toExponential([dp [, rm]]) <i>&rArr; string</i></code>
    1452. 

  1452.     </h5>
    1453. 

  1453.     <p>
    1454. 

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

  1455.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1456. 

  1456.     </p>
    1457. 

  1457.     <p>
    1458. 

  1458.       Returns a string representing the value of this BigNumber in exponential notation rounded
    1459. 

  1459.       using rounding mode <code>rm</code> to <code>dp</code> decimal places, i.e with one digit
    1460. 

  1460.       before the decimal point and <code>dp</code> digits after it.
    1461. 

  1461.     </p>
    1462. 

  1462.     <p>
    1463. 

  1463.       If the value of this BigNumber in exponential notation has fewer than <code>dp</code> fraction
    1464. 

  1464.       digits, the return value will be appended with zeros accordingly.
    1465. 

  1465.     </p>
    1466. 

  1466.     <p>
    1467. 

  1467.       If <code>dp</code> is omitted, or is <code>null</code> or <code>undefined</code>, the number
    1468. 

  1468.       of digits after the decimal point defaults to the minimum number of digits necessary to
    1469. 

  1469.       represent the value exactly.<br />
    1470. 

  1470.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1471. 

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

  1472.     </p>
    1473. 

  1473.     <p>
    1474. 

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

  1475.     </p>
    1476. 

  1476.      <pre>
    1477. 

  1477. x = 45.6
    1478. 

  1478. y = new BigNumber(x)
    1479. 

  1479. x.toExponential()               // '4.56e+1'
    1480. 

  1480. y.toExponential()               // '4.56e+1'
    1481. 

  1481. x.toExponential(0)              // '5e+1'
    1482. 

  1482. y.toExponential(0)              // '5e+1'
    1483. 

  1483. x.toExponential(1)              // '4.6e+1'
    1484. 

  1484. y.toExponential(1)              // '4.6e+1'
    1485. 

  1485. y.toExponential(1, 1)           // '4.5e+1'  (ROUND_DOWN)
    1486. 

  1486. x.toExponential(3)              // '4.560e+1'
    1487. 

  1487. y.toExponential(3)              // '4.560e+1'</pre>
    1488. 

  1488. 

  1489. 

  1490. 

  1491.     <h5 id="toFix">
    1492. 

  1492.       toFixed<code class='inset'>.toFixed([dp [, rm]]) <i>&rArr; string</i></code>
    1493. 

  1493.     </h5>
    1494. 

  1494.     <p>
    1495. 

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

  1496.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1497. 

  1497.     </p>
    1498. 

  1498.     <p>
    1499. 

  1499.       Returns a string representing the value of this BigNumber in normal (fixed-point) notation
    1500. 

  1500.       rounded to <code>dp</code> decimal places using rounding mode <code>rm</code>.
    1501. 

  1501.     </p>
    1502. 

  1502.     <p>
    1503. 

  1503.       If the value of this BigNumber in normal notation has fewer than <code>dp</code> fraction
    1504. 

  1504.       digits, the return value will be appended with zeros accordingly.
    1505. 

  1505.     </p>
    1506. 

  1506.    <p>
    1507. 

  1507.       Unlike <code>Number.prototype.toFixed</code>, which returns exponential notation if a number
    1508. 

  1508.       is greater or equal to <code>10<sup>21</sup></code>, this method will always return normal
    1509. 

  1509.       notation.
    1510. 

  1510.     </p>
    1511. 

  1511.     <p>
    1512. 

  1512.       If <code>dp</code> is omitted or is <code>null</code> or <code>undefined</code>, the return
    1513. 

  1513.       value will be unrounded and in normal notation. This is also unlike
    1514. 

  1514.       <code>Number.prototype.toFixed</code>, which returns the value to zero decimal places.<br />
    1515. 

  1515.       It is useful when fixed-point notation is required and the current
    1516. 

  1516.       <a href="#exponential-at"><code>EXPONENTIAL_AT</code></a> setting causes
    1517. 

  1517.       <code><a href='#toS'>toString</a></code> to return exponential notation.<br />
    1518. 

  1518.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1519. 

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

  1520.     </p>
    1521. 

  1521.     <p>
    1522. 

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

  1523.     </p>
    1524. 

  1524.     <pre>
    1525. 

  1525. x = 3.456
    1526. 

  1526. y = new BigNumber(x)
    1527. 

  1527. x.toFixed()                     // '3'
    1528. 

  1528. y.toFixed()                     // '3.456'
    1529. 

  1529. y.toFixed(0)                    // '3'
    1530. 

  1530. x.toFixed(2)                    // '3.46'
    1531. 

  1531. y.toFixed(2)                    // '3.46'
    1532. 

  1532. y.toFixed(2, 1)                 // '3.45'  (ROUND_DOWN)
    1533. 

  1533. x.toFixed(5)                    // '3.45600'
    1534. 

  1534. y.toFixed(5)                    // '3.45600'</pre>
    1535. 

  1535. 

  1536. 

  1537. 

  1538.     <h5 id="toFor">
    1539. 

  1539.       toFormat<code class='inset'>.toFormat([dp [, rm]]) <i>&rArr; string</i></code>
    1540. 

  1540.     </h5>
    1541. 

  1541.     <p>
    1542. 

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

  1543.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1544. 

  1544.     </p>
    1545. 

  1545.     <p>
    1546. 

  1546.       <p>
    1547. 

  1547.       Returns a string representing the value of this BigNumber in normal (fixed-point) notation
    1548. 

  1548.       rounded to <code>dp</code> decimal places using rounding mode <code>rm</code>, and formatted
    1549. 

  1549.       according to the properties of the <a href='#format'><code>FORMAT</code></a> object.
    1550. 

  1550.     </p>
    1551. 

  1551.     <p>
    1552. 

  1552.       See the examples below for the properties of the
    1553. 

  1553.       <a href='#format'><code>FORMAT</code></a> object, their types and their usage.
    1554. 

  1554.     </p>
    1555. 

  1555.     <p>
    1556. 

  1556.       If <code>dp</code> is omitted or is <code>null</code> or <code>undefined</code>, then the
    1557. 

  1557.       return value is not rounded to a fixed number of decimal places.<br />
    1558. 

  1558.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1559. 

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

  1560.     </p>
    1561. 

  1561.     <p>
    1562. 

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

  1563.     </p>
    1564. 

  1564.     <pre>
    1565. 

  1565. format = {
    1566. 

  1566.     decimalSeparator: '.',
    1567. 

  1567.     groupSeparator: ',',
    1568. 

  1568.     groupSize: 3,
    1569. 

  1569.     secondaryGroupSize: 0,
    1570. 

  1570.     fractionGroupSeparator: ' ',
    1571. 

  1571.     fractionGroupSize: 0
    1572. 

  1572. }
    1573. 

  1573. BigNumber.config({ FORMAT: format })
    1574. 

  1574. 

  1575. x = new BigNumber('123456789.123456789')
    1576. 

  1576. x.toFormat()                    // '123,456,789.123456789'
    1577. 

  1577. x.toFormat(1)                   // '123,456,789.1'
    1578. 

  1578. 

  1579. // If a reference to the object assigned to FORMAT has been retained,
    1580. 

  1580. // the format properties can be changed directly
    1581. 

  1581. format.groupSeparator = ' '
    1582. 

  1582. format.fractionGroupSize = 5
    1583. 

  1583. x.toFormat()                    // '123 456 789.12345 6789'
    1584. 

  1584. 

  1585. BigNumber.config({
    1586. 

  1586.     FORMAT: {
    1587. 

  1587.         decimalSeparator: ',',
    1588. 

  1588.         groupSeparator: '.',
    1589. 

  1589.         groupSize: 3,
    1590. 

  1590.         secondaryGroupSize: 2
    1591. 

  1591.     }
    1592. 

  1592. })
    1593. 

  1593. 

  1594. x.toFormat(6)                   // '12.34.56.789,123'</pre>
    1595. 

  1595. 

  1596. 

  1597. 

  1598.     <h5 id="toFr">
    1599. 

  1599.       toFraction<code class='inset'>.toFraction([max]) <i>&rArr; [string, string]</i></code>
    1600. 

  1600.     </h5>
    1601. 

  1601.     <p>
    1602. 

  1602.       <code>max</code>: <i>number|string|BigNumber</i>: integer &gt;= <code>1</code> and &lt;=
    1603. 

  1603.       <code>Infinity</code>
    1604. 

  1604.     </p>
    1605. 

  1605.     <p>
    1606. 

  1606.       Returns a string array representing the value of this BigNumber as a simple fraction with an
    1607. 

  1607.       integer numerator and an integer denominator. The denominator will be a positive non-zero
    1608. 

  1608.       value less than or equal to <code>max</code>.
    1609. 

  1609.     </p>
    1610. 

  1610.     <p>
    1611. 

  1611.       If a maximum denominator, <code>max</code>, is not specified, or is <code>null</code> or
    1612. 

  1612.       <code>undefined</code>, the denominator will be the lowest value necessary to represent the
    1613. 

  1613.       number exactly.
    1614. 

  1614.     </p>
    1615. 

  1615.     <p>
    1616. 

  1616.       Throws if <code>max</code> is invalid. See <a href='#Errors'>Errors</a>.
    1617. 

  1617.     </p>
    1618. 

  1618.     <pre>
    1619. 

  1619. x = new BigNumber(1.75)
    1620. 

  1620. x.toFraction()                  // '7, 4'
    1621. 

  1621. 

  1622. pi = new BigNumber('3.14159265358')
    1623. 

  1623. pi.toFraction()                 // '157079632679,50000000000'
    1624. 

  1624. pi.toFraction(100000)           // '312689, 99532'
    1625. 

  1625. pi.toFraction(10000)            // '355, 113'
    1626. 

  1626. pi.toFraction(100)              // '311, 99'
    1627. 

  1627. pi.toFraction(10)               // '22, 7'
    1628. 

  1628. pi.toFraction(1)                // '3, 1'</pre>
    1629. 

  1629. 

  1630. 

  1631. 

  1632.     <h5 id="toJSON">toJSON<code class='inset'>.toJSON() <i>&rArr; string</i></code></h5>
    1633. 

  1633.     <p>As <code>valueOf</code>.</p>
    1634. 

  1634.     <pre>
    1635. 

  1635. x = new BigNumber('177.7e+457')
    1636. 

  1636. y = new BigNumber(235.4325)
    1637. 

  1637. z = new BigNumber('0.0098074')
    1638. 

  1638. 

  1639. // Serialize an array of three BigNumbers
    1640. 

  1640. str = JSON.stringify( [x, y, z] )
    1641. 

  1641. // "["1.777e+459","235.4325","0.0098074"]"
    1642. 

  1642. 

  1643. // Return an array of three BigNumbers
    1644. 

  1644. JSON.parse(str, function (key, val) {
    1645. 

  1645.     return key === '' ? val : new BigNumber(val)
    1646. 

  1646. })</pre>
    1647. 

  1647. 

  1648. 

  1649. 

  1650.     <h5 id="toN">toNumber<code class='inset'>.toNumber() <i>&rArr; number</i></code></h5>
    1651. 

  1651.     <p>Returns the value of this BigNumber as a JavaScript number primitive.</p>
    1652. 

  1652.     <p>
    1653. 

  1653.       This method is identical to using type coercion with the unary plus operator.
    1654. 

  1654.     </p>
    1655. 

  1655.     <pre>
    1656. 

  1656. x = new BigNumber(456.789)
    1657. 

  1657. x.toNumber()                    // 456.789
    1658. 

  1658. +x                              // 456.789
    1659. 

  1659. 

  1660. y = new BigNumber('45987349857634085409857349856430985')
    1661. 

  1661. y.toNumber()                    // 4.598734985763409e+34
    1662. 

  1662. 

  1663. z = new BigNumber(-0)
    1664. 

  1664. 1 / z.toNumber()                // -Infinity
    1665. 

  1665. 1 / +z                          // -Infinity</pre>
    1666. 

  1666. 

  1667. 

  1668. 

  1669.     <h5 id="toP">
    1670. 

  1670.       toPrecision<code class='inset'>.toPrecision([sd [, rm]]) <i>&rArr; string</i></code>
    1671. 

  1671.     </h5>
    1672. 

  1672.     <p>
    1673. 

  1673.       <code>sd</code>: <i>number</i>: integer, <code>1</code> to <code>1e+9</code> inclusive<br />
    1674. 

  1674.       <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    1675. 

  1675.     </p>
    1676. 

  1676.     <p>
    1677. 

  1677.       Returns a string representing the value of this BigNumber rounded to <code>sd</code>
    1678. 

  1678.       significant digits using rounding mode <code>rm</code>.
    1679. 

  1679.     </p>
    1680. 

  1680.     <p>
    1681. 

  1681.       If <code>sd</code> is less than the number of digits necessary to represent the integer part
    1682. 

  1682.       of the value in normal (fixed-point) notation, then exponential notation is used.
    1683. 

  1683.     </p>
    1684. 

  1684.     <p>
    1685. 

  1685.       If <code>sd</code> is omitted, or is <code>null</code> or <code>undefined</code>, then the
    1686. 

  1686.       return value is the same as <code>n.toString()</code>.<br />
    1687. 

  1687.       If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
    1688. 

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

  1689.     </p>
    1690. 

  1690.     <p>
    1691. 

  1691.       Throws if <code>sd</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
    1692. 

  1692.     </p>
    1693. 

  1693.      <pre>
    1694. 

  1694. x = 45.6
    1695. 

  1695. y = new BigNumber(x)
    1696. 

  1696. x.toPrecision()                 // '45.6'
    1697. 

  1697. y.toPrecision()                 // '45.6'
    1698. 

  1698. x.toPrecision(1)                // '5e+1'
    1699. 

  1699. y.toPrecision(1)                // '5e+1'
    1700. 

  1700. y.toPrecision(2, 0)             // '4.6e+1'  (ROUND_UP)
    1701. 

  1701. y.toPrecision(2, 1)             // '4.5e+1'  (ROUND_DOWN)
    1702. 

  1702. x.toPrecision(5)                // '45.600'
    1703. 

  1703. y.toPrecision(5)                // '45.600'</pre>
    1704. 

  1704. 

  1705. 

  1706. 

  1707.     <h5 id="toS">toString<code class='inset'>.toString([base]) <i>&rArr; string</i></code></h5>
    1708. 

  1708.     <p>
    1709. 

  1709.       <code>base</code>: <i>number</i>: integer, <code>2</code> to <code>ALPHABET.length</code>
    1710. 

  1710.       inclusive (see <a href='#alphabet'><code>ALPHABET</code></a>).
    1711. 

  1711.     </p>
    1712. 

  1712.     <p>
    1713. 

  1713.       Returns a string representing the value of this BigNumber in the specified base, or base
    1714. 

  1714.       <code>10</code> if <code>base</code> is omitted or is <code>null</code> or
    1715. 

  1715.       <code>undefined</code>.
    1716. 

  1716.     </p>
    1717. 

  1717.     <p>
    1718. 

  1718.       For bases above <code>10</code>, and using the default base conversion alphabet
    1719. 

  1719.       (see <a href='#alphabet'><code>ALPHABET</code></a>), values from <code>10</code> to
    1720. 

  1720.       <code>35</code> are represented by <code>a-z</code>
    1721. 

  1721.       (as with <code>Number.prototype.toString</code>).
    1722. 

  1722.     </p>
    1723. 

  1723.     <p>
    1724. 

  1724.       If a base is specified the value is rounded according to the current
    1725. 

  1725.       <a href='#decimal-places'><code>DECIMAL_PLACES</code></a>
    1726. 

  1726.       and <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
    1727. 

  1727.     </p>
    1728. 

  1728.     <p>
    1729. 

  1729.       If a base is not specified, and this BigNumber has a positive
    1730. 

  1730.       exponent that is equal to or greater than the positive component of the
    1731. 

  1731.       current <a href="#exponential-at"><code>EXPONENTIAL_AT</code></a> setting,
    1732. 

  1732.       or a negative exponent equal to or less than the negative component of the
    1733. 

  1733.       setting, then exponential notation is returned.
    1734. 

  1734.     </p>
    1735. 

  1735.     <p>If <code>base</code> is <code>null</code> or <code>undefined</code> it is ignored.</p>
    1736. 

  1736.     <p>
    1737. 

  1737.       Throws if <code>base</code> is invalid. See <a href='#Errors'>Errors</a>.
    1738. 

  1738.     </p>
    1739. 

  1739.     <pre>
    1740. 

  1740. x = new BigNumber(750000)
    1741. 

  1741. x.toString()                    // '750000'
    1742. 

  1742. BigNumber.config({ EXPONENTIAL_AT: 5 })
    1743. 

  1743. x.toString()                    // '7.5e+5'
    1744. 

  1744. 

  1745. y = new BigNumber(362.875)
    1746. 

  1746. y.toString(2)                   // '101101010.111'
    1747. 

  1747. y.toString(9)                   // '442.77777777777777777778'
    1748. 

  1748. y.toString(32)                  // 'ba.s'
    1749. 

  1749. 

  1750. BigNumber.config({ DECIMAL_PLACES: 4 });
    1751. 

  1751. z = new BigNumber('1.23456789')
    1752. 

  1752. z.toString()                    // '1.23456789'
    1753. 

  1753. z.toString(10)                  // '1.2346'</pre>
    1754. 

  1754. 

  1755. 

  1756. 

  1757.     <h5 id="valueOf">valueOf<code class='inset'>.valueOf() <i>&rArr; string</i></code></h5>
    1758. 

  1758.     <p>
    1759. 

  1759.       As <code>toString</code>, but does not accept a base argument and includes the minus sign
    1760. 

  1760.       for negative zero.
    1761. 

  1761.     </p>
    1762. 

  1762.     <pre>
    1763. 

  1763. x = new BigNumber('-0')
    1764. 

  1764. x.toString()                    // '0'
    1765. 

  1765. x.valueOf()                     // '-0'
    1766. 

  1766. y = new BigNumber('1.777e+457')
    1767. 

  1767. y.valueOf()                     // '1.777e+457'</pre>
    1768. 

  1768. 

  1769. 

  1770. 

  1771.     <h4 id="instance-properties">Properties</h4>
    1772. 

  1772.     <p>The properties of a BigNumber instance:</p>
    1773. 

  1773.     <table>
    1774. 

  1774.       <tr>
    1775. 

  1775.         <th>Property</th>
    1776. 

  1776.         <th>Description</th>
    1777. 

  1777.         <th>Type</th>
    1778. 

  1778.         <th>Value</th>
    1779. 

  1779.       </tr>
    1780. 

  1780.       <tr>
    1781. 

  1781.         <td class='centre' id='coefficient'><b>c</b></td>
    1782. 

  1782.         <td>coefficient<sup>*</sup></td>
    1783. 

  1783.         <td><i>number</i><code>[]</code></td>
    1784. 

  1784.         <td> Array of base <code>1e14</code> numbers</td>
    1785. 

  1785.       </tr>
    1786. 

  1786.       <tr>
    1787. 

  1787.         <td class='centre' id='exponent'><b>e</b></td>
    1788. 

  1788.         <td>exponent</td>
    1789. 

  1789.         <td><i>number</i></td>
    1790. 

  1790.         <td>Integer, <code>-1000000000</code> to <code>1000000000</code> inclusive</td>
    1791. 

  1791.       </tr>
    1792. 

  1792.       <tr>
    1793. 

  1793.         <td class='centre' id='sign'><b>s</b></td>
    1794. 

  1794.         <td>sign</td>
    1795. 

  1795.         <td><i>number</i></td>
    1796. 

  1796.         <td><code>-1</code> or <code>1</code></td>
    1797. 

  1797.       </tr>
    1798. 

  1798.     </table>
    1799. 

  1799.     <p><sup>*</sup>significand</p>
    1800. 

  1800.     <p>
    1801. 

  1801.       The value of any of the <code>c</code>, <code>e</code> and <code>s</code> properties may also
    1802. 

  1802.       be <code>null</code>.
    1803. 

  1803.     </p>
    1804. 

  1804.     <p>
    1805. 

  1805.       The above properties are best considered to be read-only. In early versions of this library it
    1806. 

  1806.       was okay to change the exponent of a BigNumber by writing to its exponent property directly,
    1807. 

  1807.       but this is no longer reliable as the value of the first element of the coefficient array is
    1808. 

  1808.       now dependent on the exponent.
    1809. 

  1809.     </p>
    1810. 

  1810.     <p>
    1811. 

  1811.       Note that, as with JavaScript numbers, the original exponent and fractional trailing zeros are
    1812. 

  1812.       not necessarily preserved.
    1813. 

  1813.     </p>
    1814. 

  1814.     <pre>x = new BigNumber(0.123)              // '0.123'
    1815. 

  1815. x.toExponential()                     // '1.23e-1'
    1816. 

  1816. x.c                                   // '1,2,3'
    1817. 

  1817. x.e                                   // -1
    1818. 

  1818. x.s                                   // 1
    1819. 

  1819. 

  1820. y = new Number(-123.4567000e+2)       // '-12345.67'
    1821. 

  1821. y.toExponential()                     // '-1.234567e+4'
    1822. 

  1822. z = new BigNumber('-123.4567000e+2')  // '-12345.67'
    1823. 

  1823. z.toExponential()                     // '-1.234567e+4'
    1824. 

  1824. z.c                                   // '1,2,3,4,5,6,7'
    1825. 

  1825. z.e                                   // 4
    1826. 

  1826. z.s                                   // -1</pre>
    1827. 

  1827. 

  1828. 

  1829. 

  1830.     <h4 id="zero-nan-infinity">Zero, NaN and Infinity</h4>
    1831. 

  1831.     <p>
    1832. 

  1832.       The table below shows how &plusmn;<code>0</code>, <code>NaN</code> and
    1833. 

  1833.       &plusmn;<code>Infinity</code> are stored.
    1834. 

  1834.     </p>
    1835. 

  1835.     <table>
    1836. 

  1836.       <tr>
    1837. 

  1837.         <th> </th>
    1838. 

  1838.         <th class='centre'>c</th>
    1839. 

  1839.         <th class='centre'>e</th>
    1840. 

  1840.         <th class='centre'>s</th>
    1841. 

  1841.       </tr>
    1842. 

  1842.       <tr>
    1843. 

  1843.         <td>&plusmn;0</td>
    1844. 

  1844.         <td><code>[0]</code></td>
    1845. 

  1845.         <td><code>0</code></td>
    1846. 

  1846.         <td><code>&plusmn;1</code></td>
    1847. 

  1847.       </tr>
    1848. 

  1848.       <tr>
    1849. 

  1849.         <td>NaN</td>
    1850. 

  1850.         <td><code>null</code></td>
    1851. 

  1851.         <td><code>null</code></td>
    1852. 

  1852.         <td><code>null</code></td>
    1853. 

  1853.       </tr>
    1854. 

  1854.       <tr>
    1855. 

  1855.         <td>&plusmn;Infinity</td>
    1856. 

  1856.         <td><code>null</code></td>
    1857. 

  1857.         <td><code>null</code></td>
    1858. 

  1858.         <td><code>&plusmn;1</code></td>
    1859. 

  1859.       </tr>
    1860. 

  1860.     </table>
    1861. 

  1861.     <pre>
    1862. 

  1862. x = new Number(-0)              // 0
    1863. 

  1863. 1 / x == -Infinity              // true
    1864. 

  1864. 

  1865. y = new BigNumber(-0)           // '0'
    1866. 

  1866. y.c                             // '0' ( [0].toString() )
    1867. 

  1867. y.e                             // 0
    1868. 

  1868. y.s                             // -1</pre>
    1869. 

  1869. 

  1870. 

  1871. 

  1872.     <h4 id='Errors'>Errors</h4>
    1873. 

  1873.     <p>The table below shows the errors that are thrown.</p>
    1874. 

  1874.     <p>
    1875. 

  1875.       The errors are generic <code>Error</code> objects whose message begins
    1876. 

  1876.       <code>'[BigNumber Error]'</code>.
    1877. 

  1877.     </p>
    1878. 

  1878.     <table class='error-table'>
    1879. 

  1879.       <tr>
    1880. 

  1880.         <th>Method</th>
    1881. 

  1881.         <th>Throws</th>
    1882. 

  1882.       </tr>
    1883. 

  1883.       <tr>
    1884. 

  1884.         <td rowspan=6>
    1885. 

  1885.           <code>BigNumber</code><br />
    1886. 

  1886.           <code>comparedTo</code><br />
    1887. 

  1887.           <code>dividedBy</code><br />
    1888. 

  1888.           <code>dividedToIntegerBy</code><br />
    1889. 

  1889.           <code>isEqualTo</code><br />
    1890. 

  1890.           <code>isGreaterThan</code><br />
    1891. 

  1891.           <code>isGreaterThanOrEqualTo</code><br />
    1892. 

  1892.           <code>isLessThan</code><br />
    1893. 

  1893.           <code>isLessThanOrEqualTo</code><br />
    1894. 

  1894.           <code>minus</code><br />
    1895. 

  1895.           <code>modulo</code><br />
    1896. 

  1896.           <code>plus</code><br />
    1897. 

  1897.           <code>multipliedBy</code>
    1898. 

  1898.         </td>
    1899. 

  1899.         <td>Base not a primitive number</td>
    1900. 

  1900.       </tr>
    1901. 

  1901.       <tr>
    1902. 

  1902.         <td>Base not an integer</td>
    1903. 

  1903.       </tr>
    1904. 

  1904.       <tr>
    1905. 

  1905.         <td>Base out of range</td>
    1906. 

  1906.       </tr>
    1907. 

  1907.        <tr>
    1908. 

  1908.         <td>Number primitive has more than 15 significant digits<sup>*</sup></td>
    1909. 

  1909.       </tr>
    1910. 

  1910.       <tr>
    1911. 

  1911.         <td>Not a base... number<sup>*</sup></td>
    1912. 

  1912.       </tr>
    1913. 

  1913.       <tr>
    1914. 

  1914.         <td>Not a number<sup>*</sup></td>
    1915. 

  1915.       </tr>
    1916. 

  1916.       <tr>
    1917. 

  1917.         <td><code>clone</code></td>
    1918. 

  1918.         <td>Object expected</td>
    1919. 

  1919.       </tr>
    1920. 

  1920.       <tr>
    1921. 

  1921.         <td rowspan=24><code>config</code></td>
    1922. 

  1922.         <td>Object expected</td>
    1923. 

  1923.       </tr>
    1924. 

  1924.       <tr>
    1925. 

  1925.         <td><code>DECIMAL_PLACES</code> not a primitive number</td>
    1926. 

  1926.       </tr>
    1927. 

  1927.       <tr>
    1928. 

  1928.         <td><code>DECIMAL_PLACES</code> not an integer</td>
    1929. 

  1929.       </tr>
    1930. 

  1930.       <tr>
    1931. 

  1931.         <td><code>DECIMAL_PLACES</code> out of range</td>
    1932. 

  1932.       </tr>
    1933. 

  1933.       <tr>
    1934. 

  1934.         <td><code>ROUNDING_MODE</code> not a primitive number</td>
    1935. 

  1935.       </tr>
    1936. 

  1936.       <tr>
    1937. 

  1937.         <td><code>ROUNDING_MODE</code> not an integer</td>
    1938. 

  1938.       </tr>
    1939. 

  1939.       <tr>
    1940. 

  1940.         <td><code>ROUNDING_MODE</code> out of range</td>
    1941. 

  1941.       </tr>
    1942. 

  1942.       <tr>
    1943. 

  1943.         <td><code>EXPONENTIAL_AT</code> not a primitive number</td>
    1944. 

  1944.       </tr>
    1945. 

  1945.       <tr>
    1946. 

  1946.         <td><code>EXPONENTIAL_AT</code> not an integer</td>
    1947. 

  1947.       </tr>
    1948. 

  1948.       <tr>
    1949. 

  1949.         <td><code>EXPONENTIAL_AT</code> out of range</td>
    1950. 

  1950.       </tr>
    1951. 

  1951.       <tr>
    1952. 

  1952.         <td><code>RANGE</code> not a primitive number</td>
    1953. 

  1953.       </tr>
    1954. 

  1954.       <tr>
    1955. 

  1955.         <td><code>RANGE</code> not an integer</td>
    1956. 

  1956.       </tr>
    1957. 

  1957.       <tr>
    1958. 

  1958.         <td><code>RANGE</code> cannot be zero</td>
    1959. 

  1959.       </tr>
    1960. 

  1960.       <tr>
    1961. 

  1961.         <td><code>RANGE</code> cannot be zero</td>
    1962. 

  1962.       </tr>
    1963. 

  1963.       <tr>
    1964. 

  1964.         <td><code>CRYPTO</code> not true or false</td>
    1965. 

  1965.       </tr>
    1966. 

  1966.       <tr>
    1967. 

  1967.         <td><code>crypto</code> unavailable</td>
    1968. 

  1968.       </tr>
    1969. 

  1969.       <tr>
    1970. 

  1970.         <td><code>MODULO_MODE</code> not a primitive number</td>
    1971. 

  1971.       </tr>
    1972. 

  1972.       <tr>
    1973. 

  1973.         <td><code>MODULO_MODE</code> not an integer</td>
    1974. 

  1974.       </tr>
    1975. 

  1975.       <tr>
    1976. 

  1976.         <td><code>MODULO_MODE</code> out of range</td>
    1977. 

  1977.       </tr>
    1978. 

  1978.       <tr>
    1979. 

  1979.         <td><code>POW_PRECISION</code> not a primitive number</td>
    1980. 

  1980.       </tr>
    1981. 

  1981.       <tr>
    1982. 

  1982.         <td><code>POW_PRECISION</code> not an integer</td>
    1983. 

  1983.       </tr>
    1984. 

  1984.       <tr>
    1985. 

  1985.         <td><code>POW_PRECISION</code> out of range</td>
    1986. 

  1986.       </tr>
    1987. 

  1987.       <tr>
    1988. 

  1988.         <td><code>FORMAT</code> not an object</td>
    1989. 

  1989.       </tr>
    1990. 

  1990.       <tr>
    1991. 

  1991.         <td><code>ALPHABET</code> invalid</td>
    1992. 

  1992.       </tr>
    1993. 

  1993.       <tr>
    1994. 

  1994.         <td rowspan=3>
    1995. 

  1995.           <code>decimalPlaces</code><br />
    1996. 

  1996.           <code>precision</code><br />
    1997. 

  1997.           <code>random</code><br />
    1998. 

  1998.           <code>shiftedBy</code><br />
    1999. 

  1999.           <code>toExponential</code><br />
    2000. 

  2000.           <code>toFixed</code><br />
    2001. 

  2001.           <code>toFormat</code><br />
    2002. 

  2002.           <code>toPrecision</code>
    2003. 

  2003.         </td>
    2004. 

  2004.         <td>Argument not a primitive number</td>
    2005. 

  2005.       </tr>
    2006. 

  2006.       <tr>
    2007. 

  2007.         <td>Argument not an integer</td>
    2008. 

  2008.       </tr>
    2009. 

  2009.       <tr>
    2010. 

  2010.         <td>Argument out of range</td>
    2011. 

  2011.       </tr>
    2012. 

  2012.       <tr>
    2013. 

  2013.         <td>
    2014. 

  2014.           <code>decimalPlaces</code><br />
    2015. 

  2015.           <code>precision</code>
    2016. 

  2016.         </td>
    2017. 

  2017.         <td>Argument not true or false</td>
    2018. 

  2018.       </tr>
    2019. 

  2019.       <tr>
    2020. 

  2020.         <td><code>exponentiatedBy</code></td>
    2021. 

  2021.         <td>Argument not an integer</td>
    2022. 

  2022.       </tr>
    2023. 

  2023.       <tr>
    2024. 

  2024.         <td>
    2025. 

  2025.           <code>minimum</code><br />
    2026. 

  2026.           <code>maximum</code>
    2027. 

  2027.         </td>
    2028. 

  2028.         <td>Not a number<sup>*</sup></td>
    2029. 

  2029.       </tr>
    2030. 

  2030.       <tr>
    2031. 

  2031.         <td>
    2032. 

  2032.           <code>random</code>
    2033. 

  2033.         </td>
    2034. 

  2034.         <td>crypto unavailable</td>
    2035. 

  2035.       </tr>
    2036. 

  2036.       <tr>
    2037. 

  2037.         <td rowspan=2><code>toFraction</code></td>
    2038. 

  2038.         <td>Argument not an integer</td>
    2039. 

  2039.       </tr>
    2040. 

  2040.       <tr>
    2041. 

  2041.         <td>Argument out of range</td>
    2042. 

  2042.       </tr>
    2043. 

  2043.       <tr>
    2044. 

  2044.         <td rowspan=3><code>toString</code></td>
    2045. 

  2045.         <td>Base not a primitive number</td>
    2046. 

  2046.       </tr>
    2047. 

  2047.       <tr>
    2048. 

  2048.         <td>Base not an integer</td>
    2049. 

  2049.       </tr>
    2050. 

  2050.       <tr>
    2051. 

  2051.         <td>Base out of range</td>
    2052. 

  2052.       </tr>
    2053. 

  2053.     </table>
    2054. 

  2054.     <p><sup>*</sup>Only thrown if <code>BigNumber.DEBUG</code> is <code>true</code>.</p>
    2055. 

  2055.     <p>To determine if an exception is a BigNumber Error:</p>
    2056. 

  2056.     <pre>
    2057. 

  2057. try {
    2058. 

  2058.     // ...
    2059. 

  2059. } catch (e) {
    2060. 

  2060.     if (e instanceof Error && e.message.indexOf('[BigNumber Error]') === 0) {
    2061. 

  2061.         // ...
    2062. 

  2062.     }
    2063. 

  2063. }</pre>
    2064. 

  2064. 

  2065. 

  2066. 

  2067.     <h4 id='faq'>FAQ</h4>
    2068. 

  2068. 

  2069.     <h6>Why are trailing fractional zeros removed from BigNumbers?</h6>
    2070. 

  2070.     <p>
    2071. 

  2071.       Some arbitrary-precision libraries retain trailing fractional zeros as they can indicate the
    2072. 

  2072.       precision of a value. This can be useful but the results of arithmetic operations can be
    2073. 

  2073.       misleading.
    2074. 

  2074.     </p>
    2075. 

  2075.     <pre>
    2076. 

  2076. x = new BigDecimal("1.0")
    2077. 

  2077. y = new BigDecimal("1.1000")
    2078. 

  2078. z = x.add(y)                      // 2.1000
    2079. 

  2079. 

  2080. x = new BigDecimal("1.20")
    2081. 

  2081. y = new BigDecimal("3.45000")
    2082. 

  2082. z = x.multiply(y)                 // 4.1400000</pre>
    2083. 

  2083.     <p>
    2084. 

  2084.       To specify the precision of a value is to specify that the value lies
    2085. 

  2085.       within a certain range.
    2086. 

  2086.     </p>
    2087. 

  2087.     <p>
    2088. 

  2088.       In the first example, <code>x</code> has a value of <code>1.0</code>. The trailing zero shows
    2089. 

  2089.       the precision of the value, implying that it is in the range <code>0.95</code> to
    2090. 

  2090.       <code>1.05</code>. Similarly, the precision indicated by the trailing zeros of <code>y</code>
    2091. 

  2091.       indicates that the value is in the range <code>1.09995</code> to <code>1.10005</code>.
    2092. 

  2092.     </p>
    2093. 

  2093.     <p>
    2094. 

  2094.       If we  add the two lowest values in the ranges we have, <code>0.95 + 1.09995 = 2.04995</code>,
    2095. 

  2095.       and if we add the two highest values we have, <code>1.05 + 1.10005 = 2.15005</code>, so the
    2096. 

  2096.       range of the result of the addition implied by the precision of its operands is
    2097. 

  2097.       <code>2.04995</code> to <code>2.15005</code>.
    2098. 

  2098.     </p>
    2099. 

  2099.     <p>
    2100. 

  2100.       The result given by BigDecimal of <code>2.1000</code> however, indicates that the value is in
    2101. 

  2101.       the range <code>2.09995</code> to <code>2.10005</code> and therefore the precision implied by
    2102. 

  2102.       its trailing zeros may be misleading.
    2103. 

  2103.     </p>
    2104. 

  2104.     <p>
    2105. 

  2105.       In the second example, the true range is <code>4.122744</code> to <code>4.157256</code> yet
    2106. 

  2106.       the BigDecimal answer of <code>4.1400000</code> indicates a range of <code>4.13999995</code>
    2107. 

  2107.       to  <code>4.14000005</code>. Again, the precision implied by the trailing zeros may be
    2108. 

  2108.       misleading.
    2109. 

  2109.     </p>
    2110. 

  2110.     <p>
    2111. 

  2111.       This library, like binary floating point and most calculators, does not retain trailing
    2112. 

  2112.       fractional zeros. Instead, the <code>toExponential</code>, <code>toFixed</code> and
    2113. 

  2113.       <code>toPrecision</code> methods enable trailing zeros to be added if and when required.<br />
    2114. 

  2114.     </p>
    2115. 

  2115.   </div>
    2116. 

  2116. 

  2117. </body>
    2118. 

  2118. </html>
    2119.