1055 lines
40 KiB
HTML
1055 lines
40 KiB
HTML
|
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
||
|
|
<html>
|
||
|
|
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
|
||
|
|
<head>
|
||
|
|
<title>Javascript Bignum Extensions</title>
|
||
|
|
|
||
|
|
<meta name="description" content="Javascript Bignum Extensions">
|
||
|
|
<meta name="keywords" content="Javascript Bignum Extensions">
|
||
|
|
<meta name="resource-type" content="document">
|
||
|
|
<meta name="distribution" content="global">
|
||
|
|
<meta name="Generator" content="makeinfo">
|
||
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
|
||
|
|
<link href="#SEC_Contents" rel="contents" title="Table of Contents">
|
||
|
|
<style type="text/css">
|
||
|
|
<!--
|
||
|
|
a.summary-letter {text-decoration: none}
|
||
|
|
blockquote.smallquotation {font-size: smaller}
|
||
|
|
div.display {margin-left: 3.2em}
|
||
|
|
div.example {margin-left: 3.2em}
|
||
|
|
div.indentedblock {margin-left: 3.2em}
|
||
|
|
div.lisp {margin-left: 3.2em}
|
||
|
|
div.smalldisplay {margin-left: 3.2em}
|
||
|
|
div.smallexample {margin-left: 3.2em}
|
||
|
|
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
|
||
|
|
div.smalllisp {margin-left: 3.2em}
|
||
|
|
kbd {font-style:oblique}
|
||
|
|
pre.display {font-family: inherit}
|
||
|
|
pre.format {font-family: inherit}
|
||
|
|
pre.menu-comment {font-family: serif}
|
||
|
|
pre.menu-preformatted {font-family: serif}
|
||
|
|
pre.smalldisplay {font-family: inherit; font-size: smaller}
|
||
|
|
pre.smallexample {font-size: smaller}
|
||
|
|
pre.smallformat {font-family: inherit; font-size: smaller}
|
||
|
|
pre.smalllisp {font-size: smaller}
|
||
|
|
span.nocodebreak {white-space:nowrap}
|
||
|
|
span.nolinebreak {white-space:nowrap}
|
||
|
|
span.roman {font-family:serif; font-weight:normal}
|
||
|
|
span.sansserif {font-family:sans-serif; font-weight:normal}
|
||
|
|
ul.no-bullet {list-style: none}
|
||
|
|
-->
|
||
|
|
</style>
|
||
|
|
|
||
|
|
|
||
|
|
</head>
|
||
|
|
|
||
|
|
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
|
||
|
|
<h1 class="settitle" align="center">Javascript Bignum Extensions</h1>
|
||
|
|
|
||
|
|
<a name="SEC_Contents"></a>
|
||
|
|
<h2 class="contents-heading">Table of Contents</h2>
|
||
|
|
|
||
|
|
<div class="contents">
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Introduction" href="#Introduction">1 Introduction</a></li>
|
||
|
|
<li><a name="toc-Operator-overloading" href="#Operator-overloading">2 Operator overloading</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Introduction-1" href="#Introduction-1">2.1 Introduction</a></li>
|
||
|
|
<li><a name="toc-Builtin-Object-changes" href="#Builtin-Object-changes">2.2 Builtin Object changes</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Symbol-constructor" href="#Symbol-constructor">2.2.1 <code>Symbol</code> constructor</a></li>
|
||
|
|
</ul></li>
|
||
|
|
</ul></li>
|
||
|
|
<li><a name="toc-The-BigInt-Mode" href="#The-BigInt-Mode">3 The BigInt Mode</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Introduction-2" href="#Introduction-2">3.1 Introduction</a></li>
|
||
|
|
<li><a name="toc-Changes-that-introduce-incompatibilities-with-Javascript" href="#Changes-that-introduce-incompatibilities-with-Javascript">3.2 Changes that introduce incompatibilities with Javascript</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Standard-mode" href="#Standard-mode">3.2.1 Standard mode</a></li>
|
||
|
|
<li><a name="toc-Bigint-mode" href="#Bigint-mode">3.2.2 Bigint mode</a></li>
|
||
|
|
</ul></li>
|
||
|
|
<li><a name="toc-Operators" href="#Operators">3.3 Operators</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Arithmetic-operators" href="#Arithmetic-operators">3.3.1 Arithmetic operators</a></li>
|
||
|
|
<li><a name="toc-Logical-operators" href="#Logical-operators">3.3.2 Logical operators</a></li>
|
||
|
|
<li><a name="toc-Relational-operators" href="#Relational-operators">3.3.3 Relational operators</a></li>
|
||
|
|
</ul></li>
|
||
|
|
<li><a name="toc-Number-literals" href="#Number-literals">3.4 Number literals</a></li>
|
||
|
|
<li><a name="toc-Builtin-Object-changes-1" href="#Builtin-Object-changes-1">3.5 Builtin Object changes</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-BigInt-function" href="#BigInt-function">3.5.1 <code>BigInt</code> function</a></li>
|
||
|
|
<li><a name="toc-BigInt_002eprototype" href="#BigInt_002eprototype">3.5.2 <code>BigInt.prototype</code></a></li>
|
||
|
|
<li><a name="toc-Number-constructor" href="#Number-constructor">3.5.3 <code>Number</code> constructor</a></li>
|
||
|
|
<li><a name="toc-Number_002eprototype" href="#Number_002eprototype">3.5.4 <code>Number.prototype</code></a></li>
|
||
|
|
<li><a name="toc-Math-object" href="#Math-object">3.5.5 <code>Math</code> object</a></li>
|
||
|
|
</ul></li>
|
||
|
|
</ul></li>
|
||
|
|
<li><a name="toc-Arbitrarily-large-floating-point-numbers" href="#Arbitrarily-large-floating-point-numbers">4 Arbitrarily large floating point numbers</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Introduction-3" href="#Introduction-3">4.1 Introduction</a></li>
|
||
|
|
<li><a name="toc-Floating-point-rounding" href="#Floating-point-rounding">4.2 Floating point rounding</a></li>
|
||
|
|
<li><a name="toc-Operators-1" href="#Operators-1">4.3 Operators</a></li>
|
||
|
|
<li><a name="toc-BigFloat-literals" href="#BigFloat-literals">4.4 BigFloat literals</a></li>
|
||
|
|
<li><a name="toc-Builtin-Object-changes-2" href="#Builtin-Object-changes-2">4.5 Builtin Object changes</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-BigFloat-function" href="#BigFloat-function">4.5.1 <code>BigFloat</code> function</a></li>
|
||
|
|
<li><a name="toc-BigFloat_002eprototype" href="#BigFloat_002eprototype">4.5.2 <code>BigFloat.prototype</code></a></li>
|
||
|
|
<li><a name="toc-BigFloatEnv-constructor" href="#BigFloatEnv-constructor">4.5.3 <code>BigFloatEnv</code> constructor</a></li>
|
||
|
|
<li><a name="toc-Math-object-1" href="#Math-object-1">4.5.4 <code>Math</code> object</a></li>
|
||
|
|
</ul></li>
|
||
|
|
</ul></li>
|
||
|
|
<li><a name="toc-Math-mode" href="#Math-mode">5 Math mode</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Introduction-4" href="#Introduction-4">5.1 Introduction</a></li>
|
||
|
|
<li><a name="toc-Builtin-Object-changes-3" href="#Builtin-Object-changes-3">5.2 Builtin Object changes</a>
|
||
|
|
<ul class="no-bullet">
|
||
|
|
<li><a name="toc-Symbol-constructor-1" href="#Symbol-constructor-1">5.2.1 <code>Symbol</code> constructor</a></li>
|
||
|
|
</ul></li>
|
||
|
|
<li><a name="toc-Remaining-issues" href="#Remaining-issues">5.3 Remaining issues</a></li>
|
||
|
|
</ul></li>
|
||
|
|
|
||
|
|
</ul>
|
||
|
|
</div>
|
||
|
|
|
||
|
|
|
||
|
|
<a name="Introduction"></a>
|
||
|
|
<h2 class="chapter">1 Introduction</h2>
|
||
|
|
|
||
|
|
<p>The Bignum extensions add the following features to the Javascript
|
||
|
|
language while being 100% backward compatible:
|
||
|
|
</p>
|
||
|
|
<ul>
|
||
|
|
<li> Overloading of the standard operators
|
||
|
|
to support new types such as complex numbers, fractions or matrixes.
|
||
|
|
|
||
|
|
</li><li> Bigint mode where arbitrarily large integers are available by default (no <code>n</code> suffix is necessary as in the TC39 BigInt proposal<a name="DOCF1" href="#FOOT1"><sup>1</sup></a>).
|
||
|
|
|
||
|
|
</li><li> Arbitrarily large floating point numbers (<code>BigFloat</code>) in base 2 using the IEEE 754 semantics.
|
||
|
|
|
||
|
|
</li><li> Optional <code>math</code> mode which modifies the semantics of the division, modulo and power operator. The division and power operator return a fraction with integer operands and the modulo operator is defined as the Euclidian remainder.
|
||
|
|
|
||
|
|
</li></ul>
|
||
|
|
|
||
|
|
<p>The extensions are independent from each other except the <code>math</code>
|
||
|
|
mode which relies on the bigint mode and the operator overloading.
|
||
|
|
</p>
|
||
|
|
<a name="Operator-overloading"></a>
|
||
|
|
<h2 class="chapter">2 Operator overloading</h2>
|
||
|
|
|
||
|
|
<a name="Introduction-1"></a>
|
||
|
|
<h3 class="section">2.1 Introduction</h3>
|
||
|
|
|
||
|
|
<p>If the operands of an operator have at least one object type, a custom
|
||
|
|
operator method is searched before doing the legacy Javascript
|
||
|
|
<code>ToNumber</code> conversion.
|
||
|
|
</p>
|
||
|
|
<p>For unary operators, the custom function is looked up in the object
|
||
|
|
and has the following name:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>unary +</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorPlus</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>unary -</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorNeg</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>++</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorInc</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>--</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorDec</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>~</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorNot</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<p>For binary operators:
|
||
|
|
</p>
|
||
|
|
<ul>
|
||
|
|
<li> If both operands have the same constructor function, then the operator
|
||
|
|
is looked up in the constructor.
|
||
|
|
|
||
|
|
</li><li> Otherwise, the property <code>Symbol.operatorOrder</code> is looked up in both
|
||
|
|
constructors and converted to <code>Int32</code>. The operator is then
|
||
|
|
looked in the constructor with the larger <code>Symbol.operatorOrder</code>
|
||
|
|
value. A <code>TypeError</code> is raised if both constructors have the same
|
||
|
|
<code>Symbol.operatorOrder</code> value.
|
||
|
|
|
||
|
|
</li></ul>
|
||
|
|
|
||
|
|
<p>The operator is looked up with the following name:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>+</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorAdd</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>-</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorSub</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>*</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorMul</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>/</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorDiv</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>/ (math mode)</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorMathDiv</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>%</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorMod</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>% (math mode)</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorMathMod</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>^ (math mode)</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorMathPow</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>**</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorPow</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>|</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorOr</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>^</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorXor</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>&</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorAnd</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code><<</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorShl</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>>></code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorShr</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code><</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorCmpLT</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>></code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorCmpLT</code>, operands swapped
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code><=</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorCmpLE</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>>=</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorCmpLE</code>, operands swapped
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>==, !=</code></dt>
|
||
|
|
<dd><p><code>Symbol.operatorCmpEQ</code>
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<p>The return value of <code>Symbol.operatorCmpLT</code>, <code>Symbol.operatorCmpLE</code> and
|
||
|
|
<code>Symbol.operatorCmpEQ</code> is converted to <code>Boolean</code>.
|
||
|
|
</p>
|
||
|
|
<a name="Builtin-Object-changes"></a>
|
||
|
|
<h3 class="section">2.2 Builtin Object changes</h3>
|
||
|
|
|
||
|
|
<a name="Symbol-constructor"></a>
|
||
|
|
<h4 class="subsection">2.2.1 <code>Symbol</code> constructor</h4>
|
||
|
|
|
||
|
|
<p>The following global symbols are added for the operator overloading:
|
||
|
|
</p><dl compact="compact">
|
||
|
|
<dt><code>operatorOrder</code></dt>
|
||
|
|
<dt><code>operatorAdd</code></dt>
|
||
|
|
<dt><code>operatorSub</code></dt>
|
||
|
|
<dt><code>operatorMul</code></dt>
|
||
|
|
<dt><code>operatorDiv</code></dt>
|
||
|
|
<dt><code>operatorMod</code></dt>
|
||
|
|
<dt><code>operatorPow</code></dt>
|
||
|
|
<dt><code>operatorShl</code></dt>
|
||
|
|
<dt><code>operatorShr</code></dt>
|
||
|
|
<dt><code>operatorAnd</code></dt>
|
||
|
|
<dt><code>operatorOr</code></dt>
|
||
|
|
<dt><code>operatorXor</code></dt>
|
||
|
|
<dt><code>operatorCmpLT</code></dt>
|
||
|
|
<dt><code>operatorCmpLE</code></dt>
|
||
|
|
<dt><code>operatorCmpEQ</code></dt>
|
||
|
|
<dt><code>operatorPlus</code></dt>
|
||
|
|
<dt><code>operatorNeg</code></dt>
|
||
|
|
<dt><code>operatorNot</code></dt>
|
||
|
|
<dt><code>operatorInc</code></dt>
|
||
|
|
<dt><code>operatorDec</code></dt>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
|
||
|
|
<a name="The-BigInt-Mode"></a>
|
||
|
|
<h2 class="chapter">3 The BigInt Mode</h2>
|
||
|
|
|
||
|
|
<a name="Introduction-2"></a>
|
||
|
|
<h3 class="section">3.1 Introduction</h3>
|
||
|
|
|
||
|
|
<p>The bigint mode is enabled with the <code>"use bigint"</code> directive. It
|
||
|
|
propagates the same way as the strict mode. In bigint mode, all
|
||
|
|
integers are considered as <code>bigint</code> (arbitrarily large integer,
|
||
|
|
similar to the TC39 BigInt
|
||
|
|
proposal<a name="DOCF2" href="#FOOT2"><sup>2</sup></a>)
|
||
|
|
instead of <code>number</code> (floating point number). In order to be able
|
||
|
|
to exchange data between standard and bigint modes, numbers are
|
||
|
|
internally represented as 3 different types:
|
||
|
|
</p>
|
||
|
|
<ul>
|
||
|
|
<li> Small integer (SmallInt): 32 bit integer<a name="DOCF3" href="#FOOT3"><sup>3</sup></a>.
|
||
|
|
|
||
|
|
</li><li> Big integer (BigInt): arbitrarily large integer.
|
||
|
|
|
||
|
|
</li><li> Floating point number (Float).
|
||
|
|
|
||
|
|
</li></ul>
|
||
|
|
|
||
|
|
<p>In standard mode, the semantics of each operation is modified so that
|
||
|
|
when it returns a <code>number</code>, it is either of SmallInt or
|
||
|
|
Float. But the difference between SmallInt and Float is not observable
|
||
|
|
in standard mode.
|
||
|
|
</p>
|
||
|
|
<p>In bigint mode, each operation behaves differently whether its
|
||
|
|
operands are integer or float. The difference between SmallInt and
|
||
|
|
BigInt is not observable (i.e. they are both integers).
|
||
|
|
</p>
|
||
|
|
<p>The following table summarizes the observable types:
|
||
|
|
</p>
|
||
|
|
<table>
|
||
|
|
<thead><tr><th width="30%">Internal type</th><th width="30%">Observable type<br> (standard mode)</th><th width="30%">Observable type<br> (bigint mode)</th></tr></thead>
|
||
|
|
<tr><td width="30%">SmallInt</td><td width="30%">number</td><td width="30%">bigint</td></tr>
|
||
|
|
<tr><td width="30%">BigInt</td><td width="30%">bigint</td><td width="30%">bigint</td></tr>
|
||
|
|
<tr><td width="30%">Float</td><td width="30%">number</td><td width="30%">number</td></tr>
|
||
|
|
</table>
|
||
|
|
|
||
|
|
<a name="Changes-that-introduce-incompatibilities-with-Javascript"></a>
|
||
|
|
<h3 class="section">3.2 Changes that introduce incompatibilities with Javascript</h3>
|
||
|
|
|
||
|
|
<a name="Standard-mode"></a>
|
||
|
|
<h4 class="subsection">3.2.1 Standard mode</h4>
|
||
|
|
|
||
|
|
<p>There is no incompatibility with Javascript.
|
||
|
|
</p>
|
||
|
|
<a name="Bigint-mode"></a>
|
||
|
|
<h4 class="subsection">3.2.2 Bigint mode</h4>
|
||
|
|
|
||
|
|
<p>The following changes are visible:
|
||
|
|
</p>
|
||
|
|
<ul>
|
||
|
|
<li> Integer and Float are different types. Constants are typed. For example: <code>typeof 1.0 === "number"</code> and <code>typeof 1 === "bigint"</code>. Another consequence is that <code>1.0 === 1</code> is false.
|
||
|
|
|
||
|
|
</li><li> The range of integers is unlimited. In standard mode: <code>2**53 + 1 === 2**53</code>. This is no longer true with the bignum extensions.
|
||
|
|
|
||
|
|
</li><li> Binary bitwise operators do not truncate to 32 bits i.e. <code>0x800000000 | 1 === 0x800000001</code> while it gives <code>1</code> in standard mode.
|
||
|
|
|
||
|
|
</li><li> Bitwise shift operators do not truncate to 32 bits and do not mask the shift count with <code>0x1f</code> i.e. <code>1 << 32 === 4294967296</code> while it gives <code>1</code> in standard mode. However, the <code>>>></code> operator (unsigned right shift) which is useless with bignums keeps its standard mode behavior<a name="DOCF4" href="#FOOT4"><sup>4</sup></a>.
|
||
|
|
|
||
|
|
</li><li> Operators with integer operands never return the minus zero floating point value as result. Hence <code>Object.is(0, -0) === true</code>. Use <code>-0.0</code> to create a minus zero floating point value.
|
||
|
|
|
||
|
|
</li><li> Division or modulo with a zero integer dividend raises an exception i.e. <code>1/0</code> throws a <code>RangeError</code> exception. However, division by the floating point zero returns Infinity or NaN as in standard mode: <code>1/0.0 === Infinity</code>. The same holds for zero elevated to a negative integer power i.e. <code>0**-1</code> throws a <code>RangeError</code> exception.
|
||
|
|
|
||
|
|
</li><li> The <code>ToPrimitive</code> abstract operation is called with the <code>"integer"</code> preferred type when an integer is required (e.g. for bitwise binary or shift operations).
|
||
|
|
|
||
|
|
</li><li> The prototype of integers is no longer <code>Number.prototype</code>. Instead<br> <code>Object.getPrototypeOf(1) === BigInt.prototype</code>. The prototype of floats remains Number.prototype.
|
||
|
|
|
||
|
|
</li><li> If the TC39 BigInt proposal is supported, there is no observable difference between integers and <code>bigint</code>s.
|
||
|
|
|
||
|
|
</li></ul>
|
||
|
|
|
||
|
|
<a name="Operators"></a>
|
||
|
|
<h3 class="section">3.3 Operators</h3>
|
||
|
|
|
||
|
|
<a name="Arithmetic-operators"></a>
|
||
|
|
<h4 class="subsection">3.3.1 Arithmetic operators</h4>
|
||
|
|
|
||
|
|
<p>The operands are converted to number values as in normal
|
||
|
|
Javascript. Then the general case is that an Integer is returned if
|
||
|
|
both operands are Integer. Otherwise, a float is returned.
|
||
|
|
</p>
|
||
|
|
<p>The <code>+</code> operator also accepts strings as input and behaves like
|
||
|
|
standard Javascript in this case.
|
||
|
|
</p>
|
||
|
|
<p>The binary operator <code>%</code> returns the truncated remainder of the
|
||
|
|
division.
|
||
|
|
</p>
|
||
|
|
<p>The binary operator <code>%</code> in math mode returns the Euclidian
|
||
|
|
remainder of the division i.e. it is always positive.
|
||
|
|
</p>
|
||
|
|
<p>The binary operator <code>/</code> returns a float.
|
||
|
|
</p>
|
||
|
|
<p>The binary operator <code>/</code> in math mode returns a float if one of
|
||
|
|
the operands is float. Otherwise, <code>BigInt[Symbol.operatorMathDiv]</code> is
|
||
|
|
invoked (and returns a fraction for example).
|
||
|
|
</p>
|
||
|
|
<p>When the result is an Integer type, a dividend of zero yields a
|
||
|
|
RangeError exception.
|
||
|
|
</p>
|
||
|
|
<p>The returned type of <code>a ** b</code> or <code>a ^ b</code> (math mode) is
|
||
|
|
Float if <em>a</em> or <em>b</em> are Float. If <em>a</em> and <em>b</em> are
|
||
|
|
integers:
|
||
|
|
</p><ul>
|
||
|
|
<li> <em>a = 0</em> and <em>b < 0</em> generates a RangeError exception
|
||
|
|
|
||
|
|
</li><li> <em>|a| \geq 2</em> and <em>b < 0</em> returns a Float in bigint mode. In math mode, <code>BigInt[Symbol.operatorMathPow]</code> is invoked (and returns a fraction for example)
|
||
|
|
|
||
|
|
</li><li> otherwise an integer is returned.
|
||
|
|
</li></ul>
|
||
|
|
|
||
|
|
<p>The unary <code>-</code> and unary <code>+</code> return the same type as their
|
||
|
|
operand. They performs no floating point rounding when the result is a
|
||
|
|
float.
|
||
|
|
</p>
|
||
|
|
<p>The unary operators <code>++</code> and <code>--</code> return the same type as
|
||
|
|
their operand.
|
||
|
|
</p>
|
||
|
|
<p>In standard mode:
|
||
|
|
</p>
|
||
|
|
<p>If the operator returns an Integer and that the result fits a
|
||
|
|
SmallInt, it is converted to SmallInt. Otherwise, the Integer is
|
||
|
|
converted to a Float.
|
||
|
|
</p>
|
||
|
|
<p>In bigint mode:
|
||
|
|
</p>
|
||
|
|
<p>If the operator returns an Integer and that the result fits a
|
||
|
|
SmallInt, it is converted to SmallInt. Otherwise it is a BigInt.
|
||
|
|
</p>
|
||
|
|
<a name="Logical-operators"></a>
|
||
|
|
<h4 class="subsection">3.3.2 Logical operators</h4>
|
||
|
|
|
||
|
|
<p>In standard mode:
|
||
|
|
</p>
|
||
|
|
<p>The operands have their standard behavior. If the result fits a
|
||
|
|
SmallInt it is converted to a SmallInt. Otherwise it is a Float.
|
||
|
|
</p>
|
||
|
|
<p>In bigint mode:
|
||
|
|
</p>
|
||
|
|
<p>The operands are converted to integer values. The floating point
|
||
|
|
values are converted to integer by rounding them to zero.
|
||
|
|
</p>
|
||
|
|
<p>The logical operators are defined assuming the integers are
|
||
|
|
represented in two complement notation.
|
||
|
|
</p>
|
||
|
|
<p>For <code><<</code> and <code><<</code>, the shift can be positive or negative. So
|
||
|
|
<code>a << b</code> is defined as <em>\lfloor a/2^{-b} \rfloor</em> and
|
||
|
|
<code>a >> b</code> is defined as <em>\lfloor a/2^{b} \rfloor</em>.
|
||
|
|
</p>
|
||
|
|
<p>The operator <code>>>></code> is supported for backward compatibility and
|
||
|
|
behaves the same way as Javascript i.e. implicit conversion to <code>Uint32</code>.
|
||
|
|
</p>
|
||
|
|
<p>If the result fits a SmallInt it is converted to a SmallInt. Otherwise
|
||
|
|
it is a BigInt.
|
||
|
|
</p>
|
||
|
|
<a name="Relational-operators"></a>
|
||
|
|
<h4 class="subsection">3.3.3 Relational operators</h4>
|
||
|
|
|
||
|
|
<p>The relational operators <, <=, >, >=, ==, != work as expected with
|
||
|
|
integers and floating point numbers (e.g. <code>1.0 == 1</code> is true).
|
||
|
|
</p>
|
||
|
|
<p>The strict equality operators === and !== have the usual Javascript
|
||
|
|
semantics. In particular, different types never equal, so <code>1.0
|
||
|
|
=== 1</code> is false.
|
||
|
|
</p>
|
||
|
|
<a name="Number-literals"></a>
|
||
|
|
<h3 class="section">3.4 Number literals</h3>
|
||
|
|
|
||
|
|
<p>Number literals in bigint mode have a slightly different behavior than
|
||
|
|
in standard Javascript:
|
||
|
|
</p>
|
||
|
|
<ol>
|
||
|
|
<li> A number literal without a decimal point or an exponent is considered
|
||
|
|
as an Integer. Otherwise it is a Float.
|
||
|
|
|
||
|
|
</li><li> Hexadecimal, octal or binary floating point literals are accepted with
|
||
|
|
a decimal point or an exponent. The exponent is specified with the
|
||
|
|
<code>p</code> letter assuming a base 2. The same convention is used by
|
||
|
|
C99. Example: <code>0x1p3</code> is the same as <code>8.0</code>.
|
||
|
|
|
||
|
|
</li></ol>
|
||
|
|
|
||
|
|
<a name="Builtin-Object-changes-1"></a>
|
||
|
|
<h3 class="section">3.5 Builtin Object changes</h3>
|
||
|
|
|
||
|
|
<a name="BigInt-function"></a>
|
||
|
|
<h4 class="subsection">3.5.1 <code>BigInt</code> function</h4>
|
||
|
|
|
||
|
|
<p>The <code>BigInt</code> function cannot be invoked as a constructor. When
|
||
|
|
invoked as a function, it converts its first parameter to an
|
||
|
|
integer. When a floating point number is given as parameter, it is
|
||
|
|
truncated to an integer with infinite precision.
|
||
|
|
</p>
|
||
|
|
<p><code>BigInt</code> properties:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>asIntN(bits, a)</code></dt>
|
||
|
|
<dd><p>Set <em>b=a \pmod{2^{bits}}</em>. Return <em>b</em> if <em>b < 2^{bits-1}</em>
|
||
|
|
otherwise <em>b-2^{bits}</em>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>asUintN(bits, a)</code></dt>
|
||
|
|
<dd><p>Return <em>a \pmod{2^{bits}}</em>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>tdiv(a, b)</code></dt>
|
||
|
|
<dd><p>Return <em>trunc(a/b)</em>. <code>b = 0</code> raises a RangeError
|
||
|
|
exception.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>fdiv(a, b)</code></dt>
|
||
|
|
<dd><p>Return <em>\lfloor a/b \rfloor</em>. <code>b = 0</code> raises a RangeError
|
||
|
|
exception.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>cdiv(a, b)</code></dt>
|
||
|
|
<dd><p>Return <em>\lceil a/b \rceil</em>. <code>b = 0</code> raises a RangeError
|
||
|
|
exception.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>ediv(a, b)</code></dt>
|
||
|
|
<dd><p>Return <em>sgn(b) \lfloor a/{|b|} \rfloor</em> (Euclidian
|
||
|
|
division). <code>b = 0</code> raises a RangeError exception.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>tdivrem(a, b)</code></dt>
|
||
|
|
<dt><code>fdivrem(a, b)</code></dt>
|
||
|
|
<dt><code>cdivrem(a, b)</code></dt>
|
||
|
|
<dt><code>edivrem(a, b)</code></dt>
|
||
|
|
<dd><p>Return an array of two elements. The first element is the quotient,
|
||
|
|
the second is the remainder. The same rounding is done as the
|
||
|
|
corresponding division operation.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>sqrt(a)</code></dt>
|
||
|
|
<dd><p>Return <em>\lfloor \sqrt(a) \rfloor</em>. A RangeError exception is
|
||
|
|
raised if <em>a < 0</em>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>sqrtrem(a)</code></dt>
|
||
|
|
<dd><p>Return an array of two elements. The first element is <em>\lfloor
|
||
|
|
\sqrt{a} \rfloor</em>. The second element is <em>a-\lfloor \sqrt{a}
|
||
|
|
\rfloor^2</em>. A RangeError exception is raised if <em>a < 0</em>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>floorLog2(a)</code></dt>
|
||
|
|
<dd><p>Return -1 if <em>a \leq 0</em> otherwise return <em>\lfloor \log2(a) \rfloor</em>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>ctz(a)</code></dt>
|
||
|
|
<dd><p>Return the number of trailing zeros in the two’s complement binary representation of a. Return -1 if <em>a=0</em>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<a name="BigInt_002eprototype"></a>
|
||
|
|
<h4 class="subsection">3.5.2 <code>BigInt.prototype</code></h4>
|
||
|
|
|
||
|
|
<p>It is a normal object.
|
||
|
|
</p>
|
||
|
|
<a name="Number-constructor"></a>
|
||
|
|
<h4 class="subsection">3.5.3 <code>Number</code> constructor</h4>
|
||
|
|
|
||
|
|
<p>The number constructor returns its argument rounded to a Float using
|
||
|
|
the global floating point environement. In bigint mode, the Number
|
||
|
|
constructor returns a Float. In standard mode, it returns a SmallInt
|
||
|
|
if the value fits it, otherwise a Float.
|
||
|
|
</p>
|
||
|
|
<a name="Number_002eprototype"></a>
|
||
|
|
<h4 class="subsection">3.5.4 <code>Number.prototype</code></h4>
|
||
|
|
|
||
|
|
<p>The following properties are modified:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>toString(radix)</code></dt>
|
||
|
|
<dd>
|
||
|
|
<p>In bigint mode, integers are converted to the specified radix with
|
||
|
|
infinite precision.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>toPrecision(p)</code></dt>
|
||
|
|
<dt><code>toFixed(p)</code></dt>
|
||
|
|
<dt><code>toExponential(p)</code></dt>
|
||
|
|
<dd>
|
||
|
|
<p>In bigint mode, integers are accepted and converted to string with
|
||
|
|
infinite precision.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>parseInt(string, radix)</code></dt>
|
||
|
|
<dd>
|
||
|
|
<p>In bigint mode, an integer is returned and the conversion is done with
|
||
|
|
infinite precision.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<a name="Math-object"></a>
|
||
|
|
<h4 class="subsection">3.5.5 <code>Math</code> object</h4>
|
||
|
|
|
||
|
|
<p>The following properties are modified:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>abs(x)</code></dt>
|
||
|
|
<dd><p>Absolute value. Return an integer if <code>x</code> is an Integer. Otherwise
|
||
|
|
return a Float. No rounding is performed.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>min(a, b)</code></dt>
|
||
|
|
<dt><code>max(a, b)</code></dt>
|
||
|
|
<dd><p>No rounding is performed. The returned type is the same one as the
|
||
|
|
minimum (resp. maximum) value.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<a name="Arbitrarily-large-floating-point-numbers"></a>
|
||
|
|
<h2 class="chapter">4 Arbitrarily large floating point numbers</h2>
|
||
|
|
|
||
|
|
<a name="Introduction-3"></a>
|
||
|
|
<h3 class="section">4.1 Introduction</h3>
|
||
|
|
|
||
|
|
<p>This extension adds the <code>BigFloat</code> primitive type. The
|
||
|
|
<code>BigFloat</code> type represents floating point numbers are in base 2
|
||
|
|
with the IEEE 754 semantics. A floating
|
||
|
|
point number is represented as a sign, mantissa and exponent. The
|
||
|
|
special values <code>NaN</code>, <code>+/-Infinity</code>, <code>+0</code> and <code>-0</code>
|
||
|
|
are supported. The mantissa and exponent can have any bit length with
|
||
|
|
an implementation specific minimum and maximum.
|
||
|
|
</p>
|
||
|
|
<a name="Floating-point-rounding"></a>
|
||
|
|
<h3 class="section">4.2 Floating point rounding</h3>
|
||
|
|
|
||
|
|
<p>Each floating point operation operates with infinite precision and
|
||
|
|
then rounds the result according to the specified floating point
|
||
|
|
environment (<code>BigFloatEnv</code> object). The status flags of the
|
||
|
|
environment are also set according to the result of the operation.
|
||
|
|
</p>
|
||
|
|
<p>If no floating point environment is provided, the global floating
|
||
|
|
point environment is used.
|
||
|
|
</p>
|
||
|
|
<p>The rounding mode of the global floating point environment is always
|
||
|
|
<code>RNDN</code> (“round to nearest with ties to even”)<a name="DOCF5" href="#FOOT5"><sup>5</sup></a>. The status flags of the global environment cannot be
|
||
|
|
read<a name="DOCF6" href="#FOOT6"><sup>6</sup></a>. The precision of the global environment is
|
||
|
|
<code>BigFloatEnv.prec</code>. The number of exponent bits of the global
|
||
|
|
environment is <code>BigFloatEnv.expBits</code>. If <code>BigFloatEnv.expBits</code> is
|
||
|
|
strictly smaller than the maximum allowed number of exponent bits
|
||
|
|
(<code>BigFloatEnv.expBitsMax</code>), then the global environment subnormal
|
||
|
|
flag is set to <code>true</code>. Otherwise it is set to <code>false</code>;
|
||
|
|
</p>
|
||
|
|
<p>For example, <code>prec = 53</code> and <code> expBits = 11</code> give exactly
|
||
|
|
the same precision as the IEEE 754 64 bit floating point type. It is
|
||
|
|
the default floating point precision.
|
||
|
|
</p>
|
||
|
|
<p>The global floating point environment can only be modified temporarily
|
||
|
|
when calling a function (see <code>BigFloatEnv.setPrec</code>). Hence a
|
||
|
|
function can change the global floating point environment for its
|
||
|
|
callees but not for its caller.
|
||
|
|
</p>
|
||
|
|
<a name="Operators-1"></a>
|
||
|
|
<h3 class="section">4.3 Operators</h3>
|
||
|
|
|
||
|
|
<p>The builtin operators are extended so that a BigFloat is returned if
|
||
|
|
at least one operand is a BigFloat. The computations are always done
|
||
|
|
with infinite precision and rounded according to the global floating
|
||
|
|
point environment.
|
||
|
|
</p>
|
||
|
|
<p><code>typeof</code> applied on a <code>BigFloat</code> returns <code>bigfloat</code>.
|
||
|
|
</p>
|
||
|
|
<p>BigFloat can be compared with all the other numeric types and the
|
||
|
|
result follows the expected mathematical relations.
|
||
|
|
</p>
|
||
|
|
<p>However, since BigFloat and Number are different types they are never
|
||
|
|
equal when using the strict comparison operators (e.g. <code>0.0 ===
|
||
|
|
0.0l</code> is false).
|
||
|
|
</p>
|
||
|
|
<a name="BigFloat-literals"></a>
|
||
|
|
<h3 class="section">4.4 BigFloat literals</h3>
|
||
|
|
|
||
|
|
<p>BigFloat literals are floating point numbers with a trailing <code>l</code>
|
||
|
|
suffix. BigFloat literals have an infinite precision. They are rounded
|
||
|
|
according to the global floating point environment when they are
|
||
|
|
evaluated.<a name="DOCF7" href="#FOOT7"><sup>7</sup></a>
|
||
|
|
</p>
|
||
|
|
<a name="Builtin-Object-changes-2"></a>
|
||
|
|
<h3 class="section">4.5 Builtin Object changes</h3>
|
||
|
|
|
||
|
|
<a name="BigFloat-function"></a>
|
||
|
|
<h4 class="subsection">4.5.1 <code>BigFloat</code> function</h4>
|
||
|
|
|
||
|
|
<p>The <code>BigFloat</code> function cannot be invoked as a constructor. When
|
||
|
|
invoked as a function: the parameter is converted to a primitive
|
||
|
|
type. If the result is a numeric type, it is converted to BigFloat
|
||
|
|
without rounding. If the result is a string, it is converted to
|
||
|
|
BigFloat using the precision of the global floating point environment.
|
||
|
|
</p>
|
||
|
|
<p><code>BigFloat</code> properties:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>LN2</code></dt>
|
||
|
|
<dt><code>PI</code></dt>
|
||
|
|
<dd><p>Getter. Return the value of the corresponding mathematical constant
|
||
|
|
rounded to nearest, ties to even with the current global
|
||
|
|
precision. The constant values are cached for small precisions.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>MIN_VALUE</code></dt>
|
||
|
|
<dt><code>MAX_VALUE</code></dt>
|
||
|
|
<dt><code>EPSILON</code></dt>
|
||
|
|
<dd><p>Getter. Return the minimum, maximum and epsilon <code>BigFloat</code> values
|
||
|
|
(same definition as the corresponding <code>Number</code> constants).
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>fpRound(a[, e])</code></dt>
|
||
|
|
<dd><p>Round the floating point number <code>a</code> according to the floating
|
||
|
|
point environment <code>e</code> or the global environment if <code>e</code> is
|
||
|
|
undefined.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>parseFloat(a[, radix[, e]])</code></dt>
|
||
|
|
<dd><p>Parse the string <code>a</code> as a floating point number in radix
|
||
|
|
<code>radix</code>. The radix is 0 (default) or from 2 to 36. The radix 0
|
||
|
|
means radix 10 unless there is a hexadecimal or binary prefix. The
|
||
|
|
result is rounded according to the floating point environment <code>e</code>
|
||
|
|
or the global environment if <code>e</code> is undefined.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>add(a, b[, e])</code></dt>
|
||
|
|
<dt><code>sub(a, b[, e])</code></dt>
|
||
|
|
<dt><code>mul(a, b[, e])</code></dt>
|
||
|
|
<dt><code>div(a, b[, e])</code></dt>
|
||
|
|
<dd><p>Perform the specified floating point operation and round the floating
|
||
|
|
point number <code>a</code> according to the floating point environment
|
||
|
|
<code>e</code> or the global environment if <code>e</code> is undefined. If
|
||
|
|
<code>e</code> is specified, the floating point status flags are updated.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>floor(x[, e])</code></dt>
|
||
|
|
<dt><code>ceil(x[, e])</code></dt>
|
||
|
|
<dt><code>round(x[, e])</code></dt>
|
||
|
|
<dt><code>trunc(x[, e])</code></dt>
|
||
|
|
<dd><p>Round to integer. A rounded <code>BigFloat</code> is returned. <code>e</code> is an
|
||
|
|
optional floating point environment.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>fmod(x, y[, e])</code></dt>
|
||
|
|
<dt><code>remainder(x, y[, e])</code></dt>
|
||
|
|
<dd><p>Floating point remainder. The quotient is truncated to zero (fmod) or
|
||
|
|
to the nearest integer with ties to even (remainder). <code>e</code> is an
|
||
|
|
optional floating point environment.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>sqrt(x[, e])</code></dt>
|
||
|
|
<dd><p>Square root. Return a rounded floating point number. <code>e</code> is an
|
||
|
|
optional floating point environment.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>sin(x[, e])</code></dt>
|
||
|
|
<dt><code>cos(x[, e])</code></dt>
|
||
|
|
<dt><code>tan(x[, e])</code></dt>
|
||
|
|
<dt><code>asin(x[, e])</code></dt>
|
||
|
|
<dt><code>acos(x[, e])</code></dt>
|
||
|
|
<dt><code>atan(x[, e])</code></dt>
|
||
|
|
<dt><code>atan2(x, y[, e])</code></dt>
|
||
|
|
<dt><code>exp(x[, e])</code></dt>
|
||
|
|
<dt><code>log(x[, e])</code></dt>
|
||
|
|
<dt><code>pow(x, y[, e])</code></dt>
|
||
|
|
<dd><p>Transcendental operations. Return a rounded floating point
|
||
|
|
number. <code>e</code> is an optional floating point environment.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<a name="BigFloat_002eprototype"></a>
|
||
|
|
<h4 class="subsection">4.5.2 <code>BigFloat.prototype</code></h4>
|
||
|
|
|
||
|
|
<p>The following properties are modified:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>toString(radix)</code></dt>
|
||
|
|
<dd>
|
||
|
|
<p>For floating point numbers:
|
||
|
|
</p>
|
||
|
|
<ul>
|
||
|
|
<li> If the radix is a power of two, the conversion is done with infinite
|
||
|
|
precision.
|
||
|
|
</li><li> Otherwise, the number is rounded to nearest with ties to even using
|
||
|
|
the global precision. It is then converted to string using the minimum
|
||
|
|
number of digits so that its conversion back to a floating point using
|
||
|
|
the global precision and round to nearest gives the same number.
|
||
|
|
|
||
|
|
</li></ul>
|
||
|
|
|
||
|
|
</dd>
|
||
|
|
<dt><code>toPrecision(p[, rnd_mode])</code></dt>
|
||
|
|
<dt><code>toFixed(p[, rnd_mode])</code></dt>
|
||
|
|
<dt><code>toExponential(p[, rnd_mode])</code></dt>
|
||
|
|
<dd><p>Same semantics as the corresponding <code>Number</code> functions with
|
||
|
|
BigFloats. There is no limit on the accepted precision <code>p</code>. The
|
||
|
|
rounding mode can be optionally specified. It is set by default to
|
||
|
|
<code>BigFloatEnv.RNDNA</code>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<a name="BigFloatEnv-constructor"></a>
|
||
|
|
<h4 class="subsection">4.5.3 <code>BigFloatEnv</code> constructor</h4>
|
||
|
|
|
||
|
|
<p>The <code>BigFloatEnv([p, [,rndMode]]</code> constructor cannot be invoked as a
|
||
|
|
function. The floating point environment contains:
|
||
|
|
</p>
|
||
|
|
<ul>
|
||
|
|
<li> the mantissa precision in bits
|
||
|
|
|
||
|
|
</li><li> the exponent size in bits assuming an IEEE 754 representation;
|
||
|
|
|
||
|
|
</li><li> the subnormal flag (if true, subnormal floating point numbers can
|
||
|
|
be generated by the floating point operations).
|
||
|
|
|
||
|
|
</li><li> the rounding mode
|
||
|
|
|
||
|
|
</li><li> the floating point status. The status flags can only be set by the floating point operations. They can be reset with <code>BigFloatEnv.prototype.clearStatus()</code> or with the various status flag setters.
|
||
|
|
|
||
|
|
</li></ul>
|
||
|
|
|
||
|
|
<p><code>new BigFloatEnv([p, [,rndMode]]</code> creates a new floating point
|
||
|
|
environment. The status flags are reset. If no parameter is given the
|
||
|
|
precision, exponent bits and subnormal flags are copied from the
|
||
|
|
global floating point environment. Otherwise, the precision is set to
|
||
|
|
<code>p</code>, the number of exponent bits is set to <code>expBitsMax</code> and the
|
||
|
|
subnormal flags is set to <code>false</code>. If <code>rndMode</code> is
|
||
|
|
<code>undefined</code>, the rounding mode is set to <code>RNDN</code>.
|
||
|
|
</p>
|
||
|
|
<p><code>BigFloatEnv</code> properties:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>prec</code></dt>
|
||
|
|
<dd><p>Getter. Return the precision in bits of the global floating point
|
||
|
|
environment. The initial value is <code>53</code>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>expBits</code></dt>
|
||
|
|
<dd><p>Getter. Return the exponent size in bits of the global floating point
|
||
|
|
environment assuming an IEEE 754 representation. If <code>expBits <
|
||
|
|
expBitsMax</code>, then subnormal numbers are supported. The initial value
|
||
|
|
is <code>11</code>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>setPrec(f, p[, e])</code></dt>
|
||
|
|
<dd><p>Set the precision of the global floating point environment to <code>p</code>
|
||
|
|
and the exponent size to <code>e</code> then call the function
|
||
|
|
<code>f</code>. Then the Float precision and exponent size are reset to
|
||
|
|
their precious value and the return value of <code>f</code> is returned (or
|
||
|
|
an exception is raised if <code>f</code> raised an exception). If <code>e</code>
|
||
|
|
is <code>undefined</code> it is set to <code>BigFloatEnv.expBitsMax</code>. <code>p</code>
|
||
|
|
must be >= 53 and <code>e</code> must be >= 11 so that the global precision
|
||
|
|
is at least equivalent to the IEEE 754 64 bit doubles.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>precMin</code></dt>
|
||
|
|
<dd><p>Read-only integer. Return the minimum allowed precision. Must be at least 2.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>precMax</code></dt>
|
||
|
|
<dd><p>Read-only integer. Return the maximum allowed precision. Must be at least 53.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>expBitsMin</code></dt>
|
||
|
|
<dd><p>Read-only integer. Return the minimum allowed exponent size in
|
||
|
|
bits. Must be at least 3.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>expBitsMax</code></dt>
|
||
|
|
<dd><p>Read-only integer. Return the maximum allowed exponent size in
|
||
|
|
bits. Must be at least 11.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>RNDN</code></dt>
|
||
|
|
<dd><p>Read-only integer. Round to nearest, with ties to even rounding mode.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>RNDZ</code></dt>
|
||
|
|
<dd><p>Read-only integer. Round to zero rounding mode.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>RNDD</code></dt>
|
||
|
|
<dd><p>Read-only integer. Round to -Infinity rounding mode.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>RNDU</code></dt>
|
||
|
|
<dd><p>Read-only integer. Round to +Infinity rounding mode.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>RNDNA</code></dt>
|
||
|
|
<dd><p>Read-only integer. Round to nearest, with ties away from zero rounding mode.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>RNDNU</code></dt>
|
||
|
|
<dd><p>Read-only integer. Round to nearest, with ties to +Infinity rounding mode.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>RNDF<a name="DOCF8" href="#FOOT8"><sup>8</sup></a></code></dt>
|
||
|
|
<dd><p>Read-only integer. Faithful rounding mode. The result is
|
||
|
|
non-deterministicly rounded to -Infinity or +Infinity. This rounding
|
||
|
|
mode usually gives a faster and deterministic running time for the
|
||
|
|
floating point operations.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<p><code>BigFloatEnv.prototype</code> properties:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>prec</code></dt>
|
||
|
|
<dd><p>Getter and setter (Integer). Return or set the precision in bits.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>expBits</code></dt>
|
||
|
|
<dd><p>Getter and setter (Integer). Return or set the exponent size in bits
|
||
|
|
assuming an IEEE 754 representation.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>rndMode</code></dt>
|
||
|
|
<dd><p>Getter and setter (Integer). Return or set the rounding mode.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>subnormal</code></dt>
|
||
|
|
<dd><p>Getter and setter (Boolean). subnormal flag. It is false when
|
||
|
|
<code>expBits = expBitsMax</code>.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>clearStatus()</code></dt>
|
||
|
|
<dd><p>Clear the status flags.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>invalidOperation</code></dt>
|
||
|
|
<dt><code>divideByZero</code></dt>
|
||
|
|
<dt><code>overflow</code></dt>
|
||
|
|
<dt><code>underflow</code></dt>
|
||
|
|
<dt><code>inexact</code></dt>
|
||
|
|
<dd><p>Getter and setter (Boolean). Status flags.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<a name="Math-object-1"></a>
|
||
|
|
<h4 class="subsection">4.5.4 <code>Math</code> object</h4>
|
||
|
|
|
||
|
|
<p>The following properties are modified:
|
||
|
|
</p>
|
||
|
|
<dl compact="compact">
|
||
|
|
<dt><code>abs(x)</code></dt>
|
||
|
|
<dd><p>Absolute value. If <code>x</code> is a BigFloat, its absolute value is
|
||
|
|
returned as a BigFloat. No rounding is performed.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
<dt><code>min(a, b)</code></dt>
|
||
|
|
<dt><code>max(a, b)</code></dt>
|
||
|
|
<dd><p>The returned type is the same one as the minimum (resp. maximum)
|
||
|
|
value, so <code>BigFloat</code> values are accepted. When a <code>BigFloat</code>
|
||
|
|
is returned, no rounding is performed.
|
||
|
|
</p>
|
||
|
|
</dd>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<a name="Math-mode"></a>
|
||
|
|
<h2 class="chapter">5 Math mode</h2>
|
||
|
|
|
||
|
|
<a name="Introduction-4"></a>
|
||
|
|
<h3 class="section">5.1 Introduction</h3>
|
||
|
|
|
||
|
|
<p>A new <em>math mode</em> is enabled with the <code>"use math"</code>
|
||
|
|
directive. <code>"use bigint"</code> is implied in math mode. With this
|
||
|
|
mode, writing mathematical expressions is more intuitive, exact
|
||
|
|
results (fractions) can be computed for all operators and floating
|
||
|
|
point literals have the <code>BigFloat</code> type by default.
|
||
|
|
</p>
|
||
|
|
<p>It propagates the same way as the <em>strict mode</em>. In
|
||
|
|
this mode:
|
||
|
|
</p>
|
||
|
|
<ul>
|
||
|
|
<li> The <code>^</code> operator is a similar to the power operator (<code>**</code>), except that <code>a ^ b</code> invokes <code>BigInt[Symbol.operatorMathPow]</code> if <em>a</em> and <em>b</em> are integers and <em>|a| \geq 2</em> and <em>b < 0</em>.
|
||
|
|
|
||
|
|
</li><li> The power operator (both <code>^</code> and <code>**</code>) grammar is modified so that <code>-2^2</code> is allowed and yields <code>-4</code>.
|
||
|
|
|
||
|
|
</li><li> The logical xor operator is still available with the <code>^^</code> operator.
|
||
|
|
|
||
|
|
</li><li> The division operator invokes <code>BigInt[Symbol.operatorMathDiv]</code> in case both operands are integers.
|
||
|
|
|
||
|
|
</li><li> The modulo operator returns the Euclidian remainder (always positive) instead of the truncated remainder.
|
||
|
|
|
||
|
|
</li><li> Floating point literals are <code>BigFloat</code> by default (i.e. a <code>l</code> suffix is implied).
|
||
|
|
|
||
|
|
</li></ul>
|
||
|
|
|
||
|
|
<a name="Builtin-Object-changes-3"></a>
|
||
|
|
<h3 class="section">5.2 Builtin Object changes</h3>
|
||
|
|
|
||
|
|
<a name="Symbol-constructor-1"></a>
|
||
|
|
<h4 class="subsection">5.2.1 <code>Symbol</code> constructor</h4>
|
||
|
|
|
||
|
|
<p>The following global symbols are added for the operator overloading:
|
||
|
|
</p><dl compact="compact">
|
||
|
|
<dt><code>operatorMathDiv</code></dt>
|
||
|
|
<dt><code>operatorMathMod</code></dt>
|
||
|
|
<dt><code>operatorMathPow</code></dt>
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
<a name="Remaining-issues"></a>
|
||
|
|
<h3 class="section">5.3 Remaining issues</h3>
|
||
|
|
|
||
|
|
<ol>
|
||
|
|
<li> New functions (e.g. <code>Math.div</code> and <code>Math.mod</code>) could be added to be able to call the normal division and modulo operators when in math mode.
|
||
|
|
|
||
|
|
</li><li> A new floating point literal suffix could be added for <code>Number</code> literals.
|
||
|
|
|
||
|
|
</li></ol>
|
||
|
|
|
||
|
|
<div class="footnote">
|
||
|
|
<hr>
|
||
|
|
<h4 class="footnotes-heading">Footnotes</h4>
|
||
|
|
|
||
|
|
<h3><a name="FOOT1" href="#DOCF1">(1)</a></h3>
|
||
|
|
<p><a href="https://tc39.github.io/proposal-bigint/">https://tc39.github.io/proposal-bigint/</a></p>
|
||
|
|
<h3><a name="FOOT2" href="#DOCF2">(2)</a></h3>
|
||
|
|
<p><a href="https://tc39.github.io/proposal-bigint/">https://tc39.github.io/proposal-bigint/</a></p>
|
||
|
|
<h3><a name="FOOT3" href="#DOCF3">(3)</a></h3>
|
||
|
|
<p>Could be extended to 53 bits without changing the principle.</p>
|
||
|
|
<h3><a name="FOOT4" href="#DOCF4">(4)</a></h3>
|
||
|
|
<p>The unsigned right right operator could be removed in bigint mode.</p>
|
||
|
|
<h3><a name="FOOT5" href="#DOCF5">(5)</a></h3>
|
||
|
|
<p>The
|
||
|
|
rationale is that the rounding mode changes must always be
|
||
|
|
explicit.</p>
|
||
|
|
<h3><a name="FOOT6" href="#DOCF6">(6)</a></h3>
|
||
|
|
<p>The rationale is to avoid side effects for the built-in
|
||
|
|
operators.</p>
|
||
|
|
<h3><a name="FOOT7" href="#DOCF7">(7)</a></h3>
|
||
|
|
<p>Base 10 floating point literals cannot usually be
|
||
|
|
exactly represented as base 2 floating point number. In order to
|
||
|
|
ensure that the literal is represented accurately with the current
|
||
|
|
precision, it must be evaluated at runtime.</p>
|
||
|
|
<h3><a name="FOOT8" href="#DOCF8">(8)</a></h3>
|
||
|
|
<p>Could be removed in case a deterministic behvior for floating point operations is required.</p>
|
||
|
|
</div>
|
||
|
|
<hr>
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
</body>
|
||
|
|
</html>
|