+2020-01-19:
+
+- keep CONFIG_BIGNUM in the makefile
+- added os.chdir()
+- qjs: added -I option
+- more memory checks in the bignum operations
+- modified operator overloading semantics to be closer to the TC39
+ proposal
+- suppressed "use bigint" mode. Simplified "use math" mode
+- BigDecimal: changed suffix from 'd' to 'm'
+- misc bug fixes
+
2020-01-05:
- always compile the bignum code. Added '--bignum' option to qjs.
#
# QuickJS Javascript Engine
#
-# Copyright (c) 2017-2019 Fabrice Bellard
-# Copyright (c) 2017-2019 Charlie Gordon
+# Copyright (c) 2017-2020 Fabrice Bellard
+# Copyright (c) 2017-2020 Charlie Gordon
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
#CONFIG_PROFILE=y
# use address sanitizer
#CONFIG_ASAN=y
+# include the code for BigInt/BigFloat/BigDecimal and math mode
+CONFIG_BIGNUM=y
OBJDIR=.obj
CFLAGS+=-Werror
endif
DEFINES:=-D_GNU_SOURCE -DCONFIG_VERSION=\"$(shell cat VERSION)\"
+ifdef CONFIG_BIGNUM
+DEFINES+=-DCONFIG_BIGNUM
+endif
CFLAGS+=$(DEFINES)
CFLAGS_DEBUG=$(CFLAGS) -O0
CFLAGS_SMALL=$(CFLAGS) -Os
all: $(OBJDIR) $(OBJDIR)/quickjs.check.o $(OBJDIR)/qjs.check.o $(PROGS)
-QJS_LIB_OBJS=$(OBJDIR)/quickjs.o $(OBJDIR)/libregexp.o $(OBJDIR)/libunicode.o $(OBJDIR)/libbf.o $(OBJDIR)/cutils.o $(OBJDIR)/quickjs-libc.o
+QJS_LIB_OBJS=$(OBJDIR)/quickjs.o $(OBJDIR)/libregexp.o $(OBJDIR)/libunicode.o $(OBJDIR)/cutils.o $(OBJDIR)/quickjs-libc.o
-QJS_OBJS=$(OBJDIR)/qjs.o $(OBJDIR)/repl.o $(OBJDIR)/qjscalc.o $(QJS_LIB_OBJS)
+QJS_OBJS=$(OBJDIR)/qjs.o $(OBJDIR)/repl.o $(QJS_LIB_OBJS)
+ifdef CONFIG_BIGNUM
+QJS_LIB_OBJS+=$(OBJDIR)/libbf.o
+QJS_OBJS+=$(OBJDIR)/qjscalc.o
+endif
LIBS=-lm
ifndef CONFIG_WIN32
$(AR) rcs $@ $^
endif # CONFIG_LTO
-repl.c: $(QJSC) repl.js
+repl.c: $(QJSC) repl.js
$(QJSC) -c -o $@ -m repl.js
qjscalc.c: $(QJSC) qjscalc.js
HELLO_SRCS=examples/hello.js
HELLO_OPTS=-fno-string-normalize -fno-map -fno-promise -fno-typedarray \
-fno-typedarray -fno-regexp -fno-json -fno-eval -fno-proxy \
- -fno-date -fno-module-loader -fno-bigint
+ -fno-date -fno-module-loader
+ifdef CONFIG_BIGNUM
+HELLO_OPTS+=-fno-bigint
+endif
hello.c: $(QJSC) $(HELLO_SRCS)
$(QJSC) -e $(HELLO_OPTS) -o $@ $(HELLO_SRCS)
./qjs tests/test_loop.js
./qjs tests/test_std.js
ifndef CONFIG_DARWIN
+ifdef CONFIG_BIGNUM
./qjs --bignum tests/test_bjson.js
+else
+ ./qjs tests/test_bjson.js
+endif
./qjs examples/test_point.js
endif
+ifdef CONFIG_BIGNUM
+ ./qjs --bignum tests/test_op_overloading.js
./qjs --bignum tests/test_bignum.js
./qjs --qjscalc tests/test_qjscalc.js
+endif
ifdef CONFIG_M32
./qjs32 tests/test_closure.js
./qjs32 tests/test_op.js
./qjs32 tests/test_builtin.js
./qjs32 tests/test_loop.js
./qjs32 tests/test_std.js
+ifdef CONFIG_BIGNUM
+ ./qjs32 --bignum tests/test_op_overloading.js
./qjs32 --bignum tests/test_bignum.js
./qjs32 --qjscalc tests/test_qjscalc.js
endif
+endif
stats: qjs qjs32
./qjs -qd
Test262o: 0/11262 errors, 463 excluded
Test262o commit: 7da91bceb9ce7613f87db47ddd1292a2dda58b42 (es5-tests branch)
-Test262: 4/67619 errors, 913 excluded, 1660 skipped
-Test262bn: 4/69722 errors, 846 excluded, 672 skipped
-test262 commit: 19fd4bea797646ae9bbfc9d325f14052ca370b54
+Test262: 17/69942 errors, 855 excluded, 581 skipped
+test262 commit: 28b4fcca4b1b1d278dfe0cc0e69c7d9d59b31aab
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
-<!-- Created by GNU Texinfo 6.1, http://www.gnu.org/software/texinfo/ -->
+<!-- Created by GNU Texinfo 6.5, http://www.gnu.org/software/texinfo/ -->
<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Javascript Bignum Extensions</title>
<meta name="description" 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">
<!--
<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>
+<li><a name="toc-Operator-overloading" href="#Operator-overloading">2 Operator overloading</a></li>
+<li><a name="toc-BigInt-extensions" href="#BigInt-extensions">3 BigInt extensions</a></li>
+<li><a name="toc-BigFloat" href="#BigFloat">4 BigFloat</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-Introduction-1" href="#Introduction-1">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-Operators" href="#Operators">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>
+ <li><a name="toc-Builtin-Object-changes" href="#Builtin-Object-changes">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>
+<li><a name="toc-BigDecimal" href="#BigDecimal">5 BigDecimal</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>
+ <li><a name="toc-Operators-1" href="#Operators-1">5.1 Operators</a></li>
+ <li><a name="toc-BigDecimal-literals" href="#BigDecimal-literals">5.2 BigDecimal literals</a></li>
+ <li><a name="toc-Builtin-Object-changes-1" href="#Builtin-Object-changes-1">5.3 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>
+ <li><a name="toc-The-BigDecimal-function_002e" href="#The-BigDecimal-function_002e">5.3.1 The <code>BigDecimal</code> function.</a></li>
+ <li><a name="toc-Properties-of-the-BigDecimal-object" href="#Properties-of-the-BigDecimal-object">5.3.2 Properties of the <code>BigDecimal</code> object</a></li>
+ <li><a name="toc-Properties-of-the-BigDecimal_002eprototype-object" href="#Properties-of-the-BigDecimal_002eprototype-object">5.3.3 Properties of the <code>BigDecimal.prototype</code> object</a></li>
</ul></li>
- <li><a name="toc-Remaining-issues" href="#Remaining-issues">5.3 Remaining issues</a></li>
</ul></li>
+<li><a name="toc-Math-mode" href="#Math-mode">6 Math mode</a></li>
</ul>
</div>
language while being 100% backward compatible:
</p>
<ul>
-<li> Overloading of the standard operators
-to support new types such as complex numbers, fractions or matrices.
-
-</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> Operator overloading with a dispatch logic inspired from the proposal available at <a href="https://github.com/tc39/proposal-operator-overloading/">https://github.com/tc39/proposal-operator-overloading/</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><li> Arbitrarily large floating point numbers (<code>BigDecimal</code>) in base 10 based on the proposal available at
+<a href="https://github.com/littledan/proposal-bigdecimal">https://github.com/littledan/proposal-bigdecimal</a>.
+
+</li><li> <code>math</code> mode: arbitrarily large integers and floating point numbers are available by default. The integer division and power can be overloaded for example to return a fraction. The modulo operator (<code>%</code>) is defined as the Euclidian
+remainder. <code>^</code> is an alias to the power operator
+(<code>**</code>). <code>^^</code> is used as the exclusive or operator.
</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.
+mode which relies on BigFloat and 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>%</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>**</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>Operator overloading is inspired from the proposal available at
+<a href="https://github.com/tc39/proposal-operator-overloading/">https://github.com/tc39/proposal-operator-overloading/</a>. It
+implements the same dispatch logic but finds the operator sets by
+looking at the <code>Symbol.operatorSet</code> property in the objects. The
+changes were done in order to simplify the implementation.
</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>More precisely, the following modifications were made:
</p>
<ul>
-<li> Small integer (SmallInt): 32 bit integer<a name="DOCF3" href="#FOOT3"><sup>3</sup></a>.
+<li> <code>with operators from</code> is not supported. Operator overloading is always enabled.
-</li><li> Big integer (BigInt): arbitrarily large integer.
+</li><li> The dispatch is not based on a static <code>[[OperatorSet]]</code> field in all instances. Instead, a dynamic lookup the of the <code>Symbol.operatorSet</code> property is done. This property is typically added in the prototype of each object.
-</li><li> Floating point number (Float).
+</li><li> <code>Operators.create(...dictionaries)</code> is used to create a new OperatorSet object. The <code>Operators</code> function is supported as an helper to be closer to the TC39 proposal.
-</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>
+</li><li> <code>[]</code> cannot be overloaded.
-<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> 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><li> In math mode, the BigInt division and power operators can be overloaded with <code>Operators.updateBigIntOperators(dictionary)</code>.
</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. When the result is an Integer type, a dividend of zero yields a
-RangeError exception.
-</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.operatorDiv]</code> is
-invoked.
-</p>
-<p>The returned type of <code>a ** b</code> 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>b < 0</em> returns a Float in bigint mode. In math mode, <code>BigInt[Symbol.operatorPow]</code> is invoked.
-
-</li><li> <em>b >= 0</em> returns an integer.
-</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>
+<a name="BigInt-extensions"></a>
+<h2 class="chapter">3 BigInt extensions</h2>
-<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>A few properties are added to the BigInt object:
</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.
</dd>
</dl>
-<a name="BigInt_002eprototype"></a>
-<h4 class="subsection">3.5.2 <code>BigInt.prototype</code></h4>
+<a name="BigFloat"></a>
+<h2 class="chapter">4 BigFloat</h2>
-<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 environment. 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>
+<a name="Introduction-1"></a>
<h3 class="section">4.1 Introduction</h3>
<p>This extension adds the <code>BigFloat</code> primitive type. The
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>RNDN</code> (“round to nearest with ties to even”)<a name="DOCF1" href="#FOOT1"><sup>1</sup></a>. The status flags of the global environment cannot be
+read<a name="DOCF2" href="#FOOT2"><sup>2</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
function can change the global floating point environment for its
callees but not for its caller.
</p>
-<a name="Operators-1"></a>
+<a name="Operators"></a>
<h3 class="section">4.3 Operators</h3>
<p>The builtin operators are extended so that a BigFloat is returned if
<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>
+evaluated.<a name="DOCF3" href="#FOOT3"><sup>3</sup></a>
</p>
-<a name="Builtin-Object-changes-2"></a>
+<a name="Builtin-Object-changes"></a>
<h3 class="section">4.5 Builtin Object changes</h3>
<a name="BigFloat-function"></a>
<dd><p>Round to an integer. No additional rounding is performed.
</p>
</dd>
+<dt><code>abs(x)</code></dt>
+<dd><p>Return the absolute value of x. No additional rounding is performed.
+</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
<p>The following properties are modified:
</p>
<dl compact="compact">
+<dt><code>valueOf()</code></dt>
+<dd><p>Return the bigfloat primitive value corresponding to <code>this</code>.
+</p>
+</dd>
<dt><code>toString(radix)</code></dt>
<dd>
<p>For floating point numbers:
</li></ul>
+<p>The exponent letter is <code>e</code> for base 10, <code>p</code> for bases 2, 8,
+16 with a binary exponent and <code>@</code> for the other bases.
+</p>
</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>
+<dt><code>toPrecision(p, rnd_mode = BigFloatEnv.RNDNA, radix = 10)</code></dt>
+<dt><code>toFixed(p, rnd_mode = BigFloatEnv.RNDNA, radix = 10)</code></dt>
+<dt><code>toExponential(p, rnd_mode = BigFloatEnv.RNDNA, radix = 10)</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>.
+rounding mode and radix can be optionally specified. The radix must be
+between 2 and 36.
</p>
</dd>
</dl>
<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>.
+environment. The initial value is <code>113</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>.
+is <code>15</code>.
</p>
</dd>
<dt><code>setPrec(f, p[, e])</code></dt>
<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.
+is <code>undefined</code> it is set to <code>BigFloatEnv.expBitsMax</code>.
</p>
</dd>
<dt><code>precMin</code></dt>
</p>
</dd>
<dt><code>precMax</code></dt>
-<dd><p>Read-only integer. Return the maximum allowed precision. Must be at least 53.
+<dd><p>Read-only integer. Return the maximum allowed precision. Must be at least 113.
</p>
</dd>
<dt><code>expBitsMin</code></dt>
</dd>
<dt><code>expBitsMax</code></dt>
<dd><p>Read-only integer. Return the maximum allowed exponent size in
-bits. Must be at least 11.
+bits. Must be at least 15.
</p>
</dd>
<dt><code>RNDN</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.
+<dt><code>RNDA</code></dt>
+<dd><p>Read-only integer. Round away from zero rounding mode.
</p>
</dd>
-<dt><code>RNDF<a name="DOCF8" href="#FOOT8"><sup>8</sup></a></code></dt>
+<dt><code>RNDF<a name="DOCF4" href="#FOOT4"><sup>4</sup></a></code></dt>
<dd><p>Read-only integer. Faithful rounding mode. The result is
non-deterministically rounded to -Infinity or +Infinity. This rounding
mode usually gives a faster and deterministic running time for the
</dd>
</dl>
-<a name="Math-object-1"></a>
-<h4 class="subsection">4.5.4 <code>Math</code> object</h4>
+<a name="BigDecimal"></a>
+<h2 class="chapter">5 BigDecimal</h2>
-<p>The following properties are modified:
+<p>This extension adds the <code>BigDecimal</code> primitive type. The
+<code>BigDecimal</code> type represents floating point numbers in base
+10. It is inspired from the proposal available at
+<a href="https://github.com/littledan/proposal-bigdecimal">https://github.com/littledan/proposal-bigdecimal</a>.
+</p>
+<p>The <code>BigDecimal</code> floating point numbers are always normalized and
+finite. There is no concept of <code>-0</code>, <code>Infinity</code> or
+<code>NaN</code>. By default, all the computations are done with infinite
+precision.
+</p>
+<a name="Operators-1"></a>
+<h3 class="section">5.1 Operators</h3>
+
+<p>The following builtin operators support BigDecimal:
</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.
+<dt><code>+</code></dt>
+<dt><code>-</code></dt>
+<dt><code>*</code></dt>
+<dd><p>Both operands must be BigDecimal. The result is computed with infinite
+precision.
+</p></dd>
+<dt><code>%</code></dt>
+<dd><p>Both operands must be BigDecimal. The result is computed with infinite
+precision. A range error is throws in case of division by zero.
</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.
+<dt><code>/</code></dt>
+<dd><p>Both operands must be BigDecimal. A range error is throws in case of
+division by zero or if the result cannot be represented with infinite
+precision (use <code>BigDecimal.div</code> to specify the rounding).
+</p>
+</dd>
+<dt><code>**</code></dt>
+<dd><p>Both operands must be BigDecimal. The exponent must be a positive
+integer. The result is computed with infinite precision.
+</p>
+</dd>
+<dt><code>===</code></dt>
+<dd><p>When one of the operand is a BigDecimal, return true if both operands
+are a BigDecimal and if they are equal.
+</p>
+</dd>
+<dt><code>==</code></dt>
+<dt><code>!=</code></dt>
+<dt><code><=</code></dt>
+<dt><code>>=</code></dt>
+<dt><code><</code></dt>
+<dt><code>></code></dt>
+<dd>
+<p>Numerical comparison. When one of the operand is not a BigDecimal, it is
+converted to BigDecimal by using ToString(). Hence comparisons between
+Number and BigDecimal do not use the exact mathematical value of the
+Number value.
</p>
</dd>
</dl>
-<a name="Math-mode"></a>
-<h2 class="chapter">5 Math mode</h2>
+<a name="BigDecimal-literals"></a>
+<h3 class="section">5.2 BigDecimal literals</h3>
-<a name="Introduction-4"></a>
-<h3 class="section">5.1 Introduction</h3>
+<p>BigDecimal literals are decimal floating point numbers with a trailing
+<code>m</code> suffix.
+</p>
+<a name="Builtin-Object-changes-1"></a>
+<h3 class="section">5.3 Builtin Object changes</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 (e.g. fractions) can be computed for all operators and floating
-point literals have the <code>BigFloat</code> type by default.
+<a name="The-BigDecimal-function_002e"></a>
+<h4 class="subsection">5.3.1 The <code>BigDecimal</code> function.</h4>
+
+<p>It returns <code>0m</code> if no parameter is provided. Otherwise the first
+parameter is converted to a bigdecimal by using ToString(). Hence
+Number value are not converted to their exact numerical value as
+BigDecimal.
</p>
-<p>It propagates the same way as the <em>strict mode</em>. In
-this mode:
+<a name="Properties-of-the-BigDecimal-object"></a>
+<h4 class="subsection">5.3.2 Properties of the <code>BigDecimal</code> object</h4>
+
+<dl compact="compact">
+<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>
+<dt><code>mod(a, b[, e])</code></dt>
+<dt><code>sqrt(a, e)</code></dt>
+<dt><code>round(a, e)</code></dt>
+<dd><p>Perform the specified floating point operation and round the floating
+point result according to the rounding object <code>e</code>. If the
+rounding object is not present, the operation is executed with
+infinite precision.
</p>
-<ul>
-<li> The <code>^</code> operator is a similar to the power operator (<code>**</code>).
+<p>For <code>div</code>, a <code>RangeError</code> exception is thrown in case of
+division by zero or if the result cannot be represented with infinite
+precision if no rounding object is present.
+</p>
+<p>For <code>sqrt</code>, a range error is thrown if <code>a</code> is less than
+zero.
+</p>
+<p>The rounding object must contain the following properties:
+<code>roundingMode</code> is a string specifying the rounding mode
+(<code>"floor"</code>, <code>"ceiling"</code>, <code>"down"</code>, <code>"up"</code>,
+<code>"half-even"</code>, <code>"half-up"</code>). Either
+<code>maximumSignificantDigits</code> or <code>maximumFractionDigits</code> must
+be present to specify respectively the number of significant digits
+(must be >= 1) or the number of digits after the decimal point (must
+be >= 0).
+</p>
+</dd>
+</dl>
-</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>.
+<a name="Properties-of-the-BigDecimal_002eprototype-object"></a>
+<h4 class="subsection">5.3.3 Properties of the <code>BigDecimal.prototype</code> object</h4>
-</li><li> The logical xor operator is still available with the <code>^^</code> operator.
+<dl compact="compact">
+<dt><code>valueOf()</code></dt>
+<dd><p>Return the bigdecimal primitive value corresponding to <code>this</code>.
+</p>
+</dd>
+<dt><code>toString()</code></dt>
+<dd><p>Convert <code>this</code> to a string with infinite precision in base 10.
+</p>
+</dd>
+<dt><code>toPrecision(p, rnd_mode = "half-up")</code></dt>
+<dt><code>toFixed(p, rnd_mode = "half-up")</code></dt>
+<dt><code>toExponential(p, rnd_mode = "half-up")</code></dt>
+<dd><p>Convert the BigDecimal <code>this</code> to string with the specified
+precision <code>p</code>. There is no limit on the accepted precision
+<code>p</code>. The rounding mode can be optionally
+specified. <code>toPrecision</code> outputs either in decimal fixed notation
+or in decimal exponential notation with a <code>p</code> digits of
+precision. <code>toExponential</code> outputs in decimal exponential
+notation with <code>p</code> digits after the decimal point. <code>toFixed</code>
+outputs in decimal notation with <code>p</code> digits after the decimal
+point.
+</p>
+</dd>
+</dl>
-</li><li> The division operator invokes <code>BigInt[Symbol.operatorDiv]</code> in case both operands are integers.
+<a name="Math-mode"></a>
+<h2 class="chapter">6 Math mode</h2>
-</li><li> The power operator invokes <code>BigInt[Symbol.operatorPow]</code> in case both operands are integers and the exponent is strictly negative.
+<p>A new <em>math mode</em> is enabled with the <code>"use math"</code>
+directive. It propagates the same way as the <em>strict mode</em>. It is
+designed so that arbitrarily large integers and floating point numbers
+are available by default. In order to minimize the number of changes
+in the Javascript semantics, integers are represented either as Number
+or BigInt depending on their magnitude. Floating point numbers are
+always represented as BigFloat.
+</p>
+<p>The following changes are made to the Javascript semantics:
+</p>
+<ul>
+<li> Floating point literals (i.e. number with a decimal point or an exponent) are <code>BigFloat</code> by default (i.e. a <code>l</code> suffix is implied). Hence <code>typeof 1.0 === "bigfloat"</code>.
-</li><li> The modulo operator returns the Euclidian remainder (always positive) instead of the truncated remainder.
+</li><li> Integer literals (i.e. numbers without a decimal point or an exponent) with or without the <code>n</code> suffix are <code>BigInt</code> if their value cannot be represented as a safe integer. A safe integer is defined as a integer whose absolute value is smaller or equal to <code>2**53-1</code>. Hence <code>typeof 1 === "number "</code>, <code>typeof 1n === "number"</code> but <code>typeof 9007199254740992 === "bigint" </code>.
-</li><li> Floating point literals are <code>BigFloat</code> by default (i.e. a <code>l</code> suffix is implied).
+</li><li> All the bigint builtin operators and functions are modified so that their result is returned as a Number if it is a safe integer. Otherwise the result stays a BigInt.
-</li></ul>
+</li><li> The builtin operators are modified so that they return an exact result (which can be a BigInt) if their operands are safe integers. Operands between Number and BigInt are accepted provided the Number operand is a safe integer. The integer power with a negative exponent returns a BigFloat as result. The integer division returns a BigFloat as result.
-<a name="Builtin-Object-changes-3"></a>
-<h3 class="section">5.2 Builtin Object changes</h3>
+</li><li> The <code>^</code> operator is an alias to the power operator (<code>**</code>).
-<a name="Symbol-constructor-1"></a>
-<h4 class="subsection">5.2.1 <code>Symbol</code> constructor</h4>
+</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>.
-<p>The following global symbol is added for the operator overloading:
-</p><dl compact="compact">
-<dt><code>operatorMathMod</code></dt>
-</dl>
+</li><li> The logical xor operator is still available with the <code>^^</code> operator.
-<a name="Remaining-issues"></a>
-<h3 class="section">5.3 Remaining issues</h3>
+</li><li> The integer division operator can be overloaded by modifying the corresponding operator in <code>BigInt.prototype.[[OperatorSet]]</code>.
-<ol>
-<li> A new floating point literal suffix could be added for <code>Number</code> literals.
+</li><li> The integer power operator with a non zero negative exponent can be overloaded by modifying the corresponding operator in <code>BigInt.prototype.[[OperatorSet]]</code>.
-</li></ol>
+</li><li> The modulo operator (<code>%</code>) returns the Euclidian remainder (always positive) instead of the truncated remainder.
+
+</li></ul>
<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>
+<h3><a name="FOOT2" href="#DOCF2">(2)</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>
+<h3><a name="FOOT3" href="#DOCF3">(3)</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>
+<h3><a name="FOOT4" href="#DOCF4">(4)</a></h3>
<p>Could be removed in case a deterministic behavior for floating point operations is required.</p>
</div>
<hr>
@sp 7
@center @titlefont{Javascript Bignum Extensions}
@sp 3
-@center Version 2018-06-16
+@center Version 2020-01-11
@sp 3
@center Author: Fabrice Bellard
@end titlepage
-@setfilename spec.info
+@setfilename jsbignum.info
@settitle Javascript Bignum Extensions
@contents
@itemize
-@item Overloading of the standard operators
-to support new types such as complex numbers, fractions or matrices.
-
-@item Bigint mode where arbitrarily large integers are available by default (no @code{n} suffix is necessary as in the TC39 BigInt proposal@footnote{@url{https://tc39.github.io/proposal-bigint/}}).
+@item Operator overloading with a dispatch logic inspired from the proposal available at @url{https://github.com/tc39/proposal-operator-overloading/}.
@item Arbitrarily large floating point numbers (@code{BigFloat}) in base 2 using the IEEE 754 semantics.
-@item Optional @code{math} 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.
+@item Arbitrarily large floating point numbers (@code{BigDecimal}) in base 10 based on the proposal available at
+@url{https://github.com/littledan/proposal-bigdecimal}.
+
+@item @code{math} mode: arbitrarily large integers and floating point numbers are available by default. The integer division and power can be overloaded for example to return a fraction. The modulo operator (@code{%}) is defined as the Euclidian
+remainder. @code{^} is an alias to the power operator
+(@code{**}). @code{^^} is used as the exclusive or operator.
@end itemize
The extensions are independent from each other except the @code{math}
-mode which relies on the bigint mode and the operator overloading.
+mode which relies on BigFloat and operator overloading.
@chapter Operator overloading
-@section Introduction
-
-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} conversion.
-
-For unary operators, the custom function is looked up in the object
-and has the following name:
-
-@table @code
-@item unary +
-@code{Symbol.operatorPlus}
-
-@item unary -
-@code{Symbol.operatorNeg}
-
-@item ++
-@code{Symbol.operatorInc}
-
-@item --
-@code{Symbol.operatorDec}
-
-@item ~
-@code{Symbol.operatorNot}
-
-@end table
-
-For binary operators:
-
-@itemize
-
-@item
-If both operands have the same constructor function, then the operator
-is looked up in the constructor.
-
-@item
-Otherwise, the property @code{Symbol.operatorOrder} is looked up in both
-constructors and converted to @code{Int32}. The operator is then
-looked in the constructor with the larger @code{Symbol.operatorOrder}
-value. A @code{TypeError} is raised if both constructors have the same
-@code{Symbol.operatorOrder} value.
-
-@end itemize
-
-The operator is looked up with the following name:
-
-@table @code
-@item +
-@code{Symbol.operatorAdd}
-
-@item -
-@code{Symbol.operatorSub}
-
-@item *
-@code{Symbol.operatorMul}
-
-@item /
-@code{Symbol.operatorDiv}
-
-@item %
-@code{Symbol.operatorMod}
-
-@item % (math mode)
-@code{Symbol.operatorMathMod}
-
-@item **
-@code{Symbol.operatorPow}
-
-@item |
-@code{Symbol.operatorOr}
-
-@item ^
-@code{Symbol.operatorXor}
-
-@item &
-@code{Symbol.operatorAnd}
-
-@item <<
-@code{Symbol.operatorShl}
-
-@item >>
-@code{Symbol.operatorShr}
-
-@item <
-@code{Symbol.operatorCmpLT}
-
-@item >
-@code{Symbol.operatorCmpLT}, operands swapped
-
-@item <=
-@code{Symbol.operatorCmpLE}
-
-@item >=
-@code{Symbol.operatorCmpLE}, operands swapped
-
-@item ==, !=
-@code{Symbol.operatorCmpEQ}
-
-@end table
-
-The return value of @code{Symbol.operatorCmpLT}, @code{Symbol.operatorCmpLE} and
-@code{Symbol.operatorCmpEQ} is converted to @code{Boolean}.
-
-@section Builtin Object changes
-
-@subsection @code{Symbol} constructor
-
-The following global symbols are added for the operator overloading:
-@table @code
-@item operatorOrder
-@item operatorAdd
-@item operatorSub
-@item operatorMul
-@item operatorDiv
-@item operatorMod
-@item operatorPow
-@item operatorShl
-@item operatorShr
-@item operatorAnd
-@item operatorOr
-@item operatorXor
-@item operatorCmpLT
-@item operatorCmpLE
-@item operatorCmpEQ
-@item operatorPlus
-@item operatorNeg
-@item operatorNot
-@item operatorInc
-@item operatorDec
-@end table
-
-
-@chapter The BigInt Mode
+Operator overloading is inspired from the proposal available at
+@url{https://github.com/tc39/proposal-operator-overloading/}. It
+implements the same dispatch logic but finds the operator sets by
+looking at the @code{Symbol.operatorSet} property in the objects. The
+changes were done in order to simplify the implementation.
-@section Introduction
-
-The bigint mode is enabled with the @code{"use bigint"} directive. It
-propagates the same way as the strict mode. In bigint mode, all
-integers are considered as @code{bigint} (arbitrarily large integer,
-similar to the TC39 BigInt
-proposal@footnote{@url{https://tc39.github.io/proposal-bigint/}})
-instead of @code{number} (floating point number). In order to be able
-to exchange data between standard and bigint modes, numbers are
-internally represented as 3 different types:
+More precisely, the following modifications were made:
@itemize
-@item Small integer (SmallInt): 32 bit integer@footnote{Could be extended to 53 bits without changing the principle.}.
-
-@item Big integer (BigInt): arbitrarily large integer.
-
-@item Floating point number (Float).
-
-@end itemize
-
-In standard mode, the semantics of each operation is modified so that
-when it returns a @code{number}, it is either of SmallInt or
-Float. But the difference between SmallInt and Float is not observable
-in standard mode.
-
-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).
-
-The following table summarizes the observable types:
-
-@multitable @columnfractions .3 .3 .3
-@headitem Internal type @tab Observable type@* (standard mode) @tab Observable type@* (bigint mode)
-@item SmallInt @tab number @tab bigint
-@item BigInt @tab bigint @tab bigint
-@item Float @tab number @tab number
-@end multitable
-
-@section Changes that introduce incompatibilities with Javascript
-
-@subsection Standard mode
-
-There is no incompatibility with Javascript.
-
-@subsection Bigint mode
-
-The following changes are visible:
-
-@itemize
-
-@item Integer and Float are different types. Constants are typed. For example: @code{typeof 1.0 === "number"} and @code{typeof 1 === "bigint"}. Another consequence is that @code{1.0 === 1} is false.
-
-@item The range of integers is unlimited. In standard mode: @code{2**53 + 1 === 2**53}. This is no longer true with the bignum extensions.
-
-@item Binary bitwise operators do not truncate to 32 bits i.e. @code{0x800000000 | 1 === 0x800000001} while it gives @code{1} in standard mode.
+@item @code{with operators from} is not supported. Operator overloading is always enabled.
-@item Bitwise shift operators do not truncate to 32 bits and do not mask the shift count with @code{0x1f} i.e. @code{1 << 32 === 4294967296} while it gives @code{1} in standard mode. However, the @code{>>>} operator (unsigned right shift) which is useless with bignums keeps its standard mode behavior@footnote{The unsigned right right operator could be removed in bigint mode.}.
+@item The dispatch is not based on a static @code{[[OperatorSet]]} field in all instances. Instead, a dynamic lookup the of the @code{Symbol.operatorSet} property is done. This property is typically added in the prototype of each object.
-@item Operators with integer operands never return the minus zero floating point value as result. Hence @code{Object.is(0, -0) === true}. Use @code{-0.0} to create a minus zero floating point value.
+@item @code{Operators.create(...dictionaries)} is used to create a new OperatorSet object. The @code{Operators} function is supported as an helper to be closer to the TC39 proposal.
-@item The @code{ToPrimitive} abstract operation is called with the @code{"integer"} preferred type when an integer is required (e.g. for bitwise binary or shift operations).
+@item @code{[]} cannot be overloaded.
-@item The prototype of integers is no longer @code{Number.prototype}. Instead@* @code{Object.getPrototypeOf(1) === BigInt.prototype}. The prototype of floats remains Number.prototype.
+@item In math mode, the BigInt division and power operators can be overloaded with @code{Operators.updateBigIntOperators(dictionary)}.
-@item If the TC39 BigInt proposal is supported, there is no observable difference between integers and @code{bigint}s.
-
-@end itemize
-
-@section Operators
-
-@subsection Arithmetic operators
-
-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.
-
-The @code{+} operator also accepts strings as input and behaves like
-standard Javascript in this case.
-
-The binary operator @code{%} returns the truncated remainder of the
-division. When the result is an Integer type, a dividend of zero yields a
-RangeError exception.
-
-The binary operator @code{%} in math mode returns the Euclidian
-remainder of the division i.e. it is always positive.
-
-The binary operator @code{/} returns a float.
-
-The binary operator @code{/} in math mode returns a float if one of
-the operands is float. Otherwise, @code{BigInt[Symbol.operatorDiv]} is
-invoked.
-
-The returned type of @code{a ** b} is Float if @math{a} or @math{b}
-are Float. If @math{a} and @math{b} are integers:
-@itemize
-@item @math{b < 0} returns a Float in bigint mode. In math mode, @code{BigInt[Symbol.operatorPow]} is invoked.
-
-@item @math{b >= 0} returns an integer.
@end itemize
-The unary @code{-} and unary @code{+} return the same type as their
-operand. They performs no floating point rounding when the result is a
-float.
-
-The unary operators @code{++} and @code{--} return the same type as
-their operand.
-
-In standard mode:
-
-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.
-
-In bigint mode:
-
-If the operator returns an Integer and that the result fits a
-SmallInt, it is converted to SmallInt. Otherwise it is a BigInt.
-
-@subsection Logical operators
-
-In standard mode:
-
-The operands have their standard behavior. If the result fits a
-SmallInt it is converted to a SmallInt. Otherwise it is a Float.
-
-In bigint mode:
-
-The operands are converted to integer values. The floating point
-values are converted to integer by rounding them to zero.
-
-The logical operators are defined assuming the integers are
-represented in two complement notation.
-
-For @code{<<} and @code{<<}, the shift can be positive or negative. So
-@code{a << b} is defined as @math{\lfloor a/2^{-b} \rfloor} and
-@code{a >> b} is defined as @math{\lfloor a/2^{b} \rfloor}.
-
-The operator @code{>>>} is supported for backward compatibility and
-behaves the same way as Javascript i.e. implicit conversion to @code{Uint32}.
+@chapter BigInt extensions
-If the result fits a SmallInt it is converted to a SmallInt. Otherwise
-it is a BigInt.
-
-@subsection Relational operators
-
-The relational operators <, <=, >, >=, ==, != work as expected with
-integers and floating point numbers (e.g. @code{1.0 == 1} is true).
-
-The strict equality operators === and !== have the usual Javascript
-semantics. In particular, different types never equal, so @code{1.0
-=== 1} is false.
-
-@section Number literals
-
-Number literals in bigint mode have a slightly different behavior than
-in standard Javascript:
-
-@enumerate
-
-@item
-A number literal without a decimal point or an exponent is considered
-as an Integer. Otherwise it is a Float.
-
-@item
-Hexadecimal, octal or binary floating point literals are accepted with
-a decimal point or an exponent. The exponent is specified with the
-@code{p} letter assuming a base 2. The same convention is used by
-C99. Example: @code{0x1p3} is the same as @code{8.0}.
-
-@end enumerate
-
-@section Builtin Object changes
-
-@subsection @code{BigInt} function
-
-The @code{BigInt} 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.
-
-@code{BigInt} properties:
+A few properties are added to the BigInt object:
@table @code
-@item asIntN(bits, a)
-Set @math{b=a \pmod{2^{bits}}}. Return @math{b} if @math{b < 2^{bits-1}}
-otherwise @math{b-2^{bits}}.
-
-@item asUintN(bits, a)
-Return @math{a \pmod{2^{bits}}}.
-
@item tdiv(a, b)
Return @math{trunc(a/b)}. @code{b = 0} raises a RangeError
exception.
@end table
-@subsection @code{BigInt.prototype}
-
-It is a normal object.
-
-@subsection @code{Number} constructor
-
-The number constructor returns its argument rounded to a Float using
-the global floating point environment. In bigint mode, the Number
-constructor returns a Float. In standard mode, it returns a SmallInt
-if the value fits it, otherwise a Float.
-
-@subsection @code{Number.prototype}
-
-The following properties are modified:
-
-@table @code
-@item toString(radix)
-
-In bigint mode, integers are converted to the specified radix with
-infinite precision.
-
-@item toPrecision(p)
-@item toFixed(p)
-@item toExponential(p)
-
-In bigint mode, integers are accepted and converted to string with
-infinite precision.
-
-@item parseInt(string, radix)
-
-In bigint mode, an integer is returned and the conversion is done with
-infinite precision.
-
-@end table
-
-@subsection @code{Math} object
-
-The following properties are modified:
-
-@table @code
-@item abs(x)
-Absolute value. Return an integer if @code{x} is an Integer. Otherwise
-return a Float. No rounding is performed.
-
-@item min(a, b)
-@item max(a, b)
-No rounding is performed. The returned type is the same one as the
-minimum (resp. maximum) value.
-
-@end table
-
-@chapter Arbitrarily large floating point numbers
+@chapter BigFloat
@section Introduction
@item trunc(x)
Round to an integer. No additional rounding is performed.
+@item abs(x)
+Return the absolute value of x. No additional rounding is performed.
+
@item fmod(x, y[, e])
@item remainder(x, y[, e])
Floating point remainder. The quotient is truncated to zero (fmod) or
The following properties are modified:
@table @code
+@item valueOf()
+Return the bigfloat primitive value corresponding to @code{this}.
+
@item toString(radix)
For floating point numbers:
@end itemize
-@item toPrecision(p[, rnd_mode])
-@item toFixed(p[, rnd_mode])
-@item toExponential(p[, rnd_mode])
+The exponent letter is @code{e} for base 10, @code{p} for bases 2, 8,
+16 with a binary exponent and @code{@@} for the other bases.
+
+@item toPrecision(p, rnd_mode = BigFloatEnv.RNDNA, radix = 10)
+@item toFixed(p, rnd_mode = BigFloatEnv.RNDNA, radix = 10)
+@item toExponential(p, rnd_mode = BigFloatEnv.RNDNA, radix = 10)
Same semantics as the corresponding @code{Number} functions with
BigFloats. There is no limit on the accepted precision @code{p}. The
-rounding mode can be optionally specified. It is set by default to
-@code{BigFloatEnv.RNDNA}.
+rounding mode and radix can be optionally specified. The radix must be
+between 2 and 36.
@end table
@item prec
Getter. Return the precision in bits of the global floating point
-environment. The initial value is @code{53}.
+environment. The initial value is @code{113}.
@item expBits
Getter. Return the exponent size in bits of the global floating point
environment assuming an IEEE 754 representation. If @code{expBits <
expBitsMax}, then subnormal numbers are supported. The initial value
-is @code{11}.
+is @code{15}.
@item setPrec(f, p[, e])
Set the precision of the global floating point environment to @code{p}
@code{f}. Then the Float precision and exponent size are reset to
their precious value and the return value of @code{f} is returned (or
an exception is raised if @code{f} raised an exception). If @code{e}
-is @code{undefined} it is set to @code{BigFloatEnv.expBitsMax}. @code{p}
-must be >= 53 and @code{e} must be >= 11 so that the global precision
-is at least equivalent to the IEEE 754 64 bit doubles.
+is @code{undefined} it is set to @code{BigFloatEnv.expBitsMax}.
@item precMin
Read-only integer. Return the minimum allowed precision. Must be at least 2.
@item precMax
-Read-only integer. Return the maximum allowed precision. Must be at least 53.
+Read-only integer. Return the maximum allowed precision. Must be at least 113.
@item expBitsMin
Read-only integer. Return the minimum allowed exponent size in
@item expBitsMax
Read-only integer. Return the maximum allowed exponent size in
-bits. Must be at least 11.
+bits. Must be at least 15.
@item RNDN
Read-only integer. Round to nearest, with ties to even rounding mode.
@item RNDNA
Read-only integer. Round to nearest, with ties away from zero rounding mode.
-@item RNDNU
-Read-only integer. Round to nearest, with ties to +Infinity rounding mode.
+@item RNDA
+Read-only integer. Round away from zero rounding mode.
@item RNDF@footnote{Could be removed in case a deterministic behavior for floating point operations is required.}
Read-only integer. Faithful rounding mode. The result is
@end table
-@subsection @code{Math} object
+@chapter BigDecimal
-The following properties are modified:
+This extension adds the @code{BigDecimal} primitive type. The
+@code{BigDecimal} type represents floating point numbers in base
+10. It is inspired from the proposal available at
+@url{https://github.com/littledan/proposal-bigdecimal}.
+
+The @code{BigDecimal} floating point numbers are always normalized and
+finite. There is no concept of @code{-0}, @code{Infinity} or
+@code{NaN}. By default, all the computations are done with infinite
+precision.
+
+@section Operators
+
+The following builtin operators support BigDecimal:
@table @code
-@item abs(x)
-Absolute value. If @code{x} is a BigFloat, its absolute value is
-returned as a BigFloat. No rounding is performed.
-@item min(a, b)
-@item max(a, b)
-The returned type is the same one as the minimum (resp. maximum)
-value, so @code{BigFloat} values are accepted. When a @code{BigFloat}
-is returned, no rounding is performed.
+@item +
+@item -
+@item *
+Both operands must be BigDecimal. The result is computed with infinite
+precision.
+@item %
+Both operands must be BigDecimal. The result is computed with infinite
+precision. A range error is throws in case of division by zero.
-@end table
+@item /
+Both operands must be BigDecimal. A range error is throws in case of
+division by zero or if the result cannot be represented with infinite
+precision (use @code{BigDecimal.div} to specify the rounding).
-@chapter Math mode
+@item **
+Both operands must be BigDecimal. The exponent must be a positive
+integer. The result is computed with infinite precision.
-@section Introduction
+@item ===
+When one of the operand is a BigDecimal, return true if both operands
+are a BigDecimal and if they are equal.
-A new @emph{math mode} is enabled with the @code{"use math"}
-directive. @code{"use bigint"} is implied in math mode. With this
-mode, writing mathematical expressions is more intuitive, exact
-results (e.g. fractions) can be computed for all operators and floating
-point literals have the @code{BigFloat} type by default.
+@item ==
+@item !=
+@item <=
+@item >=
+@item <
+@item >
-It propagates the same way as the @emph{strict mode}. In
-this mode:
+Numerical comparison. When one of the operand is not a BigDecimal, it is
+converted to BigDecimal by using ToString(). Hence comparisons between
+Number and BigDecimal do not use the exact mathematical value of the
+Number value.
-@itemize
+@end table
-@item The @code{^} operator is a similar to the power operator (@code{**}).
+@section BigDecimal literals
-@item The power operator (both @code{^} and @code{**}) grammar is modified so that @code{-2^2} is allowed and yields @code{-4}.
+BigDecimal literals are decimal floating point numbers with a trailing
+@code{m} suffix.
-@item The logical xor operator is still available with the @code{^^} operator.
+@section Builtin Object changes
-@item The division operator invokes @code{BigInt[Symbol.operatorDiv]} in case both operands are integers.
+@subsection The @code{BigDecimal} function.
-@item The power operator invokes @code{BigInt[Symbol.operatorPow]} in case both operands are integers and the exponent is strictly negative.
+It returns @code{0m} if no parameter is provided. Otherwise the first
+parameter is converted to a bigdecimal by using ToString(). Hence
+Number value are not converted to their exact numerical value as
+BigDecimal.
-@item The modulo operator returns the Euclidian remainder (always positive) instead of the truncated remainder.
+@subsection Properties of the @code{BigDecimal} object
-@item Floating point literals are @code{BigFloat} by default (i.e. a @code{l} suffix is implied).
+@table @code
-@end itemize
+@item add(a, b[, e])
+@item sub(a, b[, e])
+@item mul(a, b[, e])
+@item div(a, b[, e])
+@item mod(a, b[, e])
+@item sqrt(a, e)
+@item round(a, e)
+Perform the specified floating point operation and round the floating
+point result according to the rounding object @code{e}. If the
+rounding object is not present, the operation is executed with
+infinite precision.
-@section Builtin Object changes
+For @code{div}, a @code{RangeError} exception is thrown in case of
+division by zero or if the result cannot be represented with infinite
+precision if no rounding object is present.
+
+For @code{sqrt}, a range error is thrown if @code{a} is less than
+zero.
+
+The rounding object must contain the following properties:
+@code{roundingMode} is a string specifying the rounding mode
+(@code{"floor"}, @code{"ceiling"}, @code{"down"}, @code{"up"},
+@code{"half-even"}, @code{"half-up"}). Either
+@code{maximumSignificantDigits} or @code{maximumFractionDigits} must
+be present to specify respectively the number of significant digits
+(must be >= 1) or the number of digits after the decimal point (must
+be >= 0).
-@subsection @code{Symbol} constructor
+@end table
+
+@subsection Properties of the @code{BigDecimal.prototype} object
-The following global symbol is added for the operator overloading:
@table @code
-@item operatorMathMod
+@item valueOf()
+Return the bigdecimal primitive value corresponding to @code{this}.
+
+@item toString()
+Convert @code{this} to a string with infinite precision in base 10.
+
+@item toPrecision(p, rnd_mode = "half-up")
+@item toFixed(p, rnd_mode = "half-up")
+@item toExponential(p, rnd_mode = "half-up")
+Convert the BigDecimal @code{this} to string with the specified
+precision @code{p}. There is no limit on the accepted precision
+@code{p}. The rounding mode can be optionally
+specified. @code{toPrecision} outputs either in decimal fixed notation
+or in decimal exponential notation with a @code{p} digits of
+precision. @code{toExponential} outputs in decimal exponential
+notation with @code{p} digits after the decimal point. @code{toFixed}
+outputs in decimal notation with @code{p} digits after the decimal
+point.
+
@end table
-@section Remaining issues
+@chapter Math mode
-@enumerate
+A new @emph{math mode} is enabled with the @code{"use math"}
+directive. It propagates the same way as the @emph{strict mode}. It is
+designed so that arbitrarily large integers and floating point numbers
+are available by default. In order to minimize the number of changes
+in the Javascript semantics, integers are represented either as Number
+or BigInt depending on their magnitude. Floating point numbers are
+always represented as BigFloat.
+
+The following changes are made to the Javascript semantics:
-@item A new floating point literal suffix could be added for @code{Number} literals.
+@itemize
-@end enumerate
+@item Floating point literals (i.e. number with a decimal point or an exponent) are @code{BigFloat} by default (i.e. a @code{l} suffix is implied). Hence @code{typeof 1.0 === "bigfloat"}.
+
+@item Integer literals (i.e. numbers without a decimal point or an exponent) with or without the @code{n} suffix are @code{BigInt} if their value cannot be represented as a safe integer. A safe integer is defined as a integer whose absolute value is smaller or equal to @code{2**53-1}. Hence @code{typeof 1 === "number "}, @code{typeof 1n === "number"} but @code{typeof 9007199254740992 === "bigint" }.
+
+@item All the bigint builtin operators and functions are modified so that their result is returned as a Number if it is a safe integer. Otherwise the result stays a BigInt.
+
+@item The builtin operators are modified so that they return an exact result (which can be a BigInt) if their operands are safe integers. Operands between Number and BigInt are accepted provided the Number operand is a safe integer. The integer power with a negative exponent returns a BigFloat as result. The integer division returns a BigFloat as result.
+
+@item The @code{^} operator is an alias to the power operator (@code{**}).
+
+@item The power operator (both @code{^} and @code{**}) grammar is modified so that @code{-2^2} is allowed and yields @code{-4}.
+
+@item The logical xor operator is still available with the @code{^^} operator.
+
+@item The integer division operator can be overloaded by modifying the corresponding operator in @code{BigInt.prototype.[[OperatorSet]]}.
+
+@item The integer power operator with a non zero negative exponent can be overloaded by modifying the corresponding operator in @code{BigInt.prototype.[[OperatorSet]]}.
+
+@item The modulo operator (@code{%}) returns the Euclidian remainder (always positive) instead of the truncated remainder.
+
+@end itemize
@bye
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
-<!-- Created by GNU Texinfo 6.1, http://www.gnu.org/software/texinfo/ -->
+<!-- Created by GNU Texinfo 6.5, http://www.gnu.org/software/texinfo/ -->
<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>QuickJS Javascript Engine</title>
<meta name="description" content="QuickJS Javascript Engine">
<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 name="qjs-interpreter"></a>
<h4 class="subsection">2.3.1 <code>qjs</code> interpreter</h4>
-<pre class="verbatim">usage: qjs [options] [files]
+<pre class="verbatim">usage: qjs [options] [file [args]]
</pre>
<p>Options are:
</p><dl compact="compact">
the <code>"use bigint"</code> and <code>"use math"</code> directives.
</p>
</dd>
+<dt><code>-I file</code></dt>
+<dt><code>--include file</code></dt>
+<dd><p>Include an additional file.
+</p>
+</dd>
</dl>
<p>Advanced options are:
and <code>err</code> the error code.
</p>
</dd>
+<dt><code>chdir(path)</code></dt>
+<dd><p>Change the current directory. Return the error code.
+</p>
+</dd>
<dt><code>mkdir(path, mode = 0o777)</code></dt>
<dd><p>Create a directory at <code>path</code>. Return the error code.
</p>
@subsection @code{qjs} interpreter
@verbatim
-usage: qjs [options] [files]
+usage: qjs [options] [file [args]]
@end verbatim
Options are:
Enable the bignum extensions: BigDecimal object, BigFloat object and
the @code{"use bigint"} and @code{"use math"} directives.
+@item -I file
+@item --include file
+Include an additional file.
+
@end table
Advanced options are:
Return @code{[str, err]} where @code{str} is the current working directory
and @code{err} the error code.
+@item chdir(path)
+Change the current directory. Return the error code.
+
@item mkdir(path, mode = 0o777)
Create a directory at @code{path}. Return the error code.
/* compute PI with a precision of 'prec' digits */
function calc_pi(prec) {
- const CHUD_A = 13591409d;
- const CHUD_B = 545140134d;
- const CHUD_C = 640320d;
- const CHUD_C3 = 10939058860032000d; /* C^3/24 */
+ const CHUD_A = 13591409m;
+ const CHUD_B = 545140134m;
+ const CHUD_C = 640320m;
+ const CHUD_C3 = 10939058860032000m; /* C^3/24 */
const CHUD_DIGITS_PER_TERM = 14.18164746272548; /* log10(C/12)*3 */
/* return [P, Q, G] */
var c, P, Q, G, P1, Q1, G1, P2, Q2, G2, b1;
if (a == (b - 1n)) {
b1 = BigDecimal(b);
- G = (2d * b1 - 1d) * (6d * b1 - 1d) * (6d * b1 - 5d);
+ G = (2m * b1 - 1m) * (6m * b1 - 1m) * (6m * b1 - 5m);
P = G * (CHUD_B * b1 + CHUD_A);
if (b & 1n)
P = -P;
if (need_G)
G = G1 * G2;
else
- G = 0d;
+ G = 0m;
}
return [P, Q, G];
}
Q = BigDecimal.div(Q, (P + Q * CHUD_A),
{ roundingMode: "half-even",
maximumSignificantDigits: prec });
- G = (CHUD_C / 12d) * BigDecimal.sqrt(CHUD_C,
+ G = (CHUD_C / 12m) * BigDecimal.sqrt(CHUD_C,
{ roundingMode: "half-even",
maximumSignificantDigits: prec });
return Q * G;
/* we add more digits to reduce the probability of bad rounding for
the last digits */
r = calc_pi(n_digits + 20);
- r = BigDecimal.round(r, { roundingMode: "down",
- maximumFractionDigits: n_digits })
- print(r);
+ print(r.toFixed(n_digits, "down"));
})();
static void fft_clear_cache(bf_context_t *s);
#endif
#ifdef USE_BF_DEC
-static void mp_pow_init(void);
static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos);
#endif
return a;
}
+/* signed addition with saturation */
+static inline slimb_t sat_add(slimb_t a, slimb_t b)
+{
+ slimb_t r;
+ r = a + b;
+ /* overflow ? */
+ if (((a ^ r) & (b ^ r)) < 0)
+ r = (a >> (LIMB_BITS - 1)) ^ (((limb_t)1 << (LIMB_BITS - 1)) - 1);
+ return r;
+}
+
#define malloc(s) malloc_is_forbidden(s)
#define free(p) free_is_forbidden(p)
#define realloc(p, s) realloc_is_forbidden(p, s)
memset(s, 0, sizeof(*s));
s->realloc_func = realloc_func;
s->realloc_opaque = realloc_opaque;
-#ifdef USE_BF_DEC
- mp_pow_init();
-#endif
}
void bf_context_end(bf_context_t *s)
if (r->sign == (rnd_mode == BF_RNDD))
add_one = inexact;
break;
+ case BF_RNDA:
+ add_one = inexact;
+ break;
case BF_RNDNA:
case BF_RNDF:
add_one = bit1;
break;
- case BF_RNDNU:
- if (bit1) {
- if (r->sign)
- add_one = bit0;
- else
- add_one = 1;
- }
- break;
default:
abort();
}
if (prec == BF_PREC_INF ||
rnd_mode == BF_RNDN ||
rnd_mode == BF_RNDNA ||
- rnd_mode == BF_RNDNU ||
+ rnd_mode == BF_RNDA ||
(rnd_mode == BF_RNDD && sign == 1) ||
(rnd_mode == BF_RNDU && sign == 0)) {
bf_set_inf(r, sign);
/* round to prec1 bits assuming 'r' is non zero and finite. 'r' is
assumed to have length 'l' (1 <= l <= r->len). Note: 'prec1' can be
- infinite (BF_PREC_INF). Can fail with BF_ST_MEM_ERROR in case of
+ infinite (BF_PREC_INF). 'ret' is 0 or BF_ST_INEXACT if the result
+ is known to be inexact. Can fail with BF_ST_MEM_ERROR in case of
overflow not returning infinity. */
-static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
+static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
+ int ret)
{
limb_t v, a;
- int shift, add_one, ret, rnd_mode;
+ int shift, add_one, rnd_mode;
slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
/* e_min and e_max are computed to match the IEEE 754 conventions */
/* round to prec bits */
rnd_mode = flags & BF_RND_MASK;
- ret = 0;
add_one = bf_get_rnd_add(&ret, r, l, prec, rnd_mode);
if (prec <= 0) {
}
r->expn -= shift;
}
- ret = __bf_round(r, prec1, flags, l);
+ ret = __bf_round(r, prec1, flags, l, 0);
}
// bf_print_str("r_final", r);
return ret;
}
if (a->expn == BF_EXP_ZERO)
return FALSE;
- is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA ||
- rnd_mode == BF_RNDNU);
+ is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
if (k < (prec + 2))
return FALSE;
bit_pos = a->len * LIMB_BITS - 1 - prec;
{
if (r->len == 0)
return 0;
- return __bf_round(r, prec, flags, r->len);
+ return __bf_round(r, prec, flags, r->len, 0);
}
/* for debugging */
return res;
}
-#define BF_CMP_EQ 1
-#define BF_CMP_LT 2
-#define BF_CMP_LE 3
-
-static int bf_cmp(const bf_t *a, const bf_t *b, int op)
+/* Standard floating point comparison: return 2 if one of the operands
+ is NaN (unordered) or -1, 0, 1 depending on the ordering assuming
+ -0 == +0 */
+int bf_cmp(const bf_t *a, const bf_t *b)
{
- BOOL is_both_zero;
int res;
- if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN)
- return 0;
- if (a->sign != b->sign) {
- is_both_zero = (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_ZERO);
- if (is_both_zero) {
- return op & BF_CMP_EQ;
- } else if (op & BF_CMP_LT) {
- return a->sign;
- } else {
- return FALSE;
- }
+ if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
+ res = 2;
+ } else if (a->sign != b->sign) {
+ if (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_ZERO)
+ res = 0;
+ else
+ res = 1 - 2 * a->sign;
} else {
res = bf_cmpu(a, b);
- if (res == 0) {
- return op & BF_CMP_EQ;
- } else if (op & BF_CMP_LT) {
- return (res < 0) ^ a->sign;
- } else {
- return FALSE;
- }
+ if (a->sign)
+ res = -res;
}
-}
-
-int bf_cmp_eq(const bf_t *a, const bf_t *b)
-{
- return bf_cmp(a, b, BF_CMP_EQ);
-}
-
-int bf_cmp_le(const bf_t *a, const bf_t *b)
-{
- return bf_cmp(a, b, BF_CMP_LE);
-}
-
-int bf_cmp_lt(const bf_t *a, const bf_t *b)
-{
- return bf_cmp(a, b, BF_CMP_LT);
+ return res;
}
/* Compute the number of bits 'n' matching the pattern:
slimb_t e_max;
if (r->len == 0)
return 0;
- e_max = ((limb_t)1 << BF_EXP_BITS_MAX) - 1;
+ e_max = ((limb_t)1 << BF_EXT_EXP_BITS_MAX) - 1;
e = bf_max(e, -e_max);
e = bf_min(e, e_max);
r->expn += e;
- return __bf_round(r, prec, flags, r->len);
+ return __bf_round(r, prec, flags, r->len, 0);
}
/* Return e such as a=m*2^e with m odd integer. return 0 if a is zero,
}
q_sign = a->sign ^ b->sign;
- is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA ||
- rnd_mode == BF_RNDNU);
+ is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
switch(rnd_mode) {
default:
case BF_RNDZ:
case BF_RNDU:
is_ceil = q_sign ^ 1;
break;
+ case BF_RNDA:
+ is_ceil = TRUE;
+ break;
case BF_DIVREM_EUCLIDIAN:
is_ceil = a->sign;
break;
- case BF_RNDNU:
- /* XXX: unsupported yet */
- abort();
}
a1->expn = a->expn;
return BF_ST_MEM_ERROR;
}
-int bf_fmod(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
- bf_flags_t flags)
+int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
+ bf_flags_t flags, int rnd_mode)
{
bf_t q_s, *q = &q_s;
int ret;
bf_init(r->ctx, q);
- ret = bf_divrem(q, r, a, b, prec, flags, BF_RNDZ);
- bf_delete(q);
- return ret;
-}
-
-int bf_remainder(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
- bf_flags_t flags)
-{
- bf_t q_s, *q = &q_s;
- int ret;
-
- bf_init(r->ctx, q);
- ret = bf_divrem(q, r, a, b, prec, flags, BF_RNDN);
+ ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
bf_delete(q);
return ret;
}
}
int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
- bf_flags_t flags)
+ bf_flags_t flags, int rnd_mode)
{
bf_t q_s, *q = &q_s;
int ret;
bf_init(r->ctx, q);
- ret = bf_divrem(q, r, a, b, prec, flags, BF_RNDN);
+ ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
bf_get_limb(pq, q, BF_GET_INT_MOD);
bf_delete(q);
return ret;
/* XXX: correct overflow/underflow handling */
/* XXX: rigorous error analysis needed */
extra_bits = ceil_log2(e) * 2 + 1;
- ret = bf_pow_ui_ui(B, radix, e, prec1 + extra_bits, BF_RNDN);
+ ret = bf_pow_ui_ui(B, radix, e, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
overflow = !bf_is_finite(B);
/* XXX: if bf_pow_ui_ui returns an exact result, can stop
after the next operation */
if (expn_sign)
- ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN);
+ ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
else
- ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN);
+ ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
if (ret & BF_ST_MEM_ERROR)
break;
if ((ret & BF_ST_INEXACT) &&
/* and more precision and retry */
ziv_extra_bits = ziv_extra_bits + (ziv_extra_bits / 2);
} else {
+ /* XXX: need to use __bf_round() to pass the inexact
+ flag for the subnormal case */
ret = bf_round(r, prec, flags) | (ret & BF_ST_INEXACT);
break;
}
c = to_digit(*p);
if (c >= 10)
break;
- if (unlikely(expn > ((EXP_MAX - 2 - 9) / 10))) {
+ if (unlikely(expn > ((BF_RAW_EXP_MAX - 2 - 9) / 10))) {
/* exponent overflow */
if (exp_is_neg) {
bf_set_zero(r, is_neg);
prec = prec0 + ziv_extra_bits;
/* XXX: rigorous error analysis needed */
extra_bits = ceil_log2(e) * 2 + 1;
- ret = bf_pow_ui_ui(r, radix, e, prec + extra_bits, BF_RNDN);
+ ret = bf_pow_ui_ui(r, radix, e, prec + extra_bits,
+ BF_RNDN | BF_FLAG_EXT_EXP);
if (!e_sign)
- ret |= bf_mul(r, r, a, prec + extra_bits, BF_RNDN);
+ ret |= bf_mul(r, r, a, prec + extra_bits,
+ BF_RNDN | BF_FLAG_EXT_EXP);
else
- ret |= bf_div(r, a, r, prec + extra_bits, BF_RNDN);
+ ret |= bf_div(r, a, r, prec + extra_bits,
+ BF_RNDN | BF_FLAG_EXT_EXP);
if (ret & BF_ST_MEM_ERROR)
return BF_ST_MEM_ERROR;
/* if the result is not exact, check that it can be safely
pos = a->len;
pos_incr = 1;
first_buf_pos = 0;
- } else if ((radix & (radix - 1)) != 0) {
+ } else if ((radix & (radix - 1)) == 0) {
+ a = (bf_t *)a1;
+ radix_bits = ceil_log2(radix);
+ digits_per_limb = LIMB_BITS / radix_bits;
+ pos_incr = digits_per_limb * radix_bits;
+ /* digits are aligned relative to the radix point */
+ pos = a->len * LIMB_BITS + smod(-a->expn, radix_bits);
+ first_buf_pos = 0;
+ } else {
limb_t n, radixl;
digits_per_limb = digits_per_limb_table[radix - 2];
pos = n;
pos_incr = 1;
first_buf_pos = pos * digits_per_limb - n_digits;
- } else {
- a = (bf_t *)a1;
- radix_bits = ceil_log2(radix);
- digits_per_limb = LIMB_BITS / radix_bits;
- pos_incr = digits_per_limb * radix_bits;
- pos = a->len * LIMB_BITS - a->expn + n_digits * radix_bits;
- first_buf_pos = 0;
}
buf_pos = digits_per_limb;
i = 0;
static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
limb_t prec, bf_flags_t flags, BOOL is_dec)
{
+ bf_context_t *ctx = a2->ctx;
DynBuf s_s, *s = &s_s;
int radix_bits;
// bf_print_str("ftoa", a2);
// printf("radix=%d\n", radix);
- dbuf_init2(s, a2->ctx, bf_dbuf_realloc);
+ dbuf_init2(s, ctx, bf_dbuf_realloc);
if (a2->expn == BF_EXP_NAN) {
dbuf_putstr(s, "NaN");
} else {
} else {
int fmt, ret;
slimb_t n_digits, n, i, n_max, n1;
- bf_t a1_s, *a1;
- bf_t a_s, *a = &a_s;
-
- /* make a positive number */
- a->tab = a2->tab;
- a->len = a2->len;
- a->expn = a2->expn;
- a->sign = 0;
-
+ bf_t a1_s, *a1 = &a1_s;
+
if ((radix & (radix - 1)) != 0)
radix_bits = 0;
else
radix_bits = ceil_log2(radix);
fmt = flags & BF_FTOA_FORMAT_MASK;
- a1 = &a1_s;
- bf_init(a2->ctx, a1);
+ bf_init(ctx, a1);
if (fmt == BF_FTOA_FORMAT_FRAC) {
- size_t pos, start;
- assert(!is_dec);
- /* one more digit for the rounding */
- n = 1 + bf_mul_log2_radix(bf_max(a->expn, 0), radix, TRUE, TRUE);
- n_digits = n + prec;
- n1 = n;
- if (bf_convert_to_radix(a1, &n1, a, radix, n_digits,
- flags & BF_RND_MASK, TRUE))
- goto fail1;
- start = s->size;
- output_digits(s, a1, radix, n_digits, n, is_dec);
- /* remove leading zeros because we allocated one more digit */
- pos = start;
- while ((pos + 1) < s->size && s->buf[pos] == '0' &&
- s->buf[pos + 1] != '.')
- pos++;
- if (pos > start) {
- memmove(s->buf + start, s->buf + pos, s->size - pos);
- s->size -= (pos - start);
+ if (is_dec || radix_bits != 0) {
+ if (bf_set(a1, a2))
+ goto fail1;
+#ifdef USE_BF_DEC
+ if (is_dec) {
+ if (bfdec_round((bfdec_t *)a1, prec, (flags & BF_RND_MASK) | BF_FLAG_RADPNT_PREC) & BF_ST_MEM_ERROR)
+ goto fail1;
+ n = a1->expn;
+ } else
+#endif
+ {
+ if (bf_round(a1, prec * radix_bits, (flags & BF_RND_MASK) | BF_FLAG_RADPNT_PREC) & BF_ST_MEM_ERROR)
+ goto fail1;
+ n = ceil_div(a1->expn, radix_bits);
+ }
+ if (flags & BF_FTOA_ADD_PREFIX) {
+ if (radix == 16)
+ dbuf_putstr(s, "0x");
+ else if (radix == 8)
+ dbuf_putstr(s, "0o");
+ else if (radix == 2)
+ dbuf_putstr(s, "0b");
+ }
+ if (a1->expn == BF_EXP_ZERO) {
+ dbuf_putstr(s, "0");
+ if (prec > 0) {
+ dbuf_putstr(s, ".");
+ for(i = 0; i < prec; i++) {
+ dbuf_putc(s, '0');
+ }
+ }
+ } else {
+ n_digits = prec + n;
+ if (n <= 0) {
+ /* 0.x */
+ dbuf_putstr(s, "0.");
+ for(i = 0; i < -n; i++) {
+ dbuf_putc(s, '0');
+ }
+ if (n_digits > 0) {
+ output_digits(s, a1, radix, n_digits, n_digits, is_dec);
+ }
+ } else {
+ output_digits(s, a1, radix, n_digits, n, is_dec);
+ }
+ }
+ } else {
+ size_t pos, start;
+ bf_t a_s, *a = &a_s;
+
+ /* make a positive number */
+ a->tab = a2->tab;
+ a->len = a2->len;
+ a->expn = a2->expn;
+ a->sign = 0;
+
+ /* one more digit for the rounding */
+ n = 1 + bf_mul_log2_radix(bf_max(a->expn, 0), radix, TRUE, TRUE);
+ n_digits = n + prec;
+ n1 = n;
+ if (bf_convert_to_radix(a1, &n1, a, radix, n_digits,
+ flags & BF_RND_MASK, TRUE))
+ goto fail1;
+ start = s->size;
+ output_digits(s, a1, radix, n_digits, n, is_dec);
+ /* remove leading zeros because we allocated one more digit */
+ pos = start;
+ while ((pos + 1) < s->size && s->buf[pos] == '0' &&
+ s->buf[pos + 1] != '.')
+ pos++;
+ if (pos > start) {
+ memmove(s->buf + start, s->buf + pos, s->size - pos);
+ s->size -= (pos - start);
+ }
}
} else {
#ifdef USE_BF_DEC
if (is_dec) {
+ if (bf_set(a1, a2))
+ goto fail1;
if (fmt == BF_FTOA_FORMAT_FIXED) {
n_digits = prec;
n_max = n_digits;
+ if (bfdec_round((bfdec_t *)a1, prec, (flags & BF_RND_MASK)) & BF_ST_MEM_ERROR)
+ goto fail1;
} else {
/* prec is ignored */
- prec = n_digits = a->len * LIMB_DIGITS;
- /* remove trailing zero digits */
+ prec = n_digits = a1->len * LIMB_DIGITS;
+ /* remove the trailing zero digits */
while (n_digits > 1 &&
- get_digit(a->tab, a->len, prec - n_digits) == 0) {
+ get_digit(a1->tab, a1->len, prec - n_digits) == 0) {
n_digits--;
}
n_max = n_digits + 4;
}
- bf_init(a2->ctx, a1);
- bf_set(a1, a);
n = a1->expn;
} else
#endif
- {
+ if (radix_bits != 0) {
+ if (bf_set(a1, a2))
+ goto fail1;
+ if (fmt == BF_FTOA_FORMAT_FIXED) {
+ slimb_t prec_bits;
+ n_digits = prec;
+ n_max = n_digits;
+ /* align to the radix point */
+ prec_bits = prec * radix_bits -
+ smod(-a1->expn, radix_bits);
+ if (bf_round(a1, prec_bits,
+ (flags & BF_RND_MASK)) & BF_ST_MEM_ERROR)
+ goto fail1;
+ } else {
+ limb_t digit_mask;
+ slimb_t pos;
+ /* position of the digit before the most
+ significant digit in bits */
+ pos = a1->len * LIMB_BITS +
+ smod(-a1->expn, radix_bits);
+ n_digits = ceil_div(pos, radix_bits);
+ /* remove the trailing zero digits */
+ digit_mask = ((limb_t)1 << radix_bits) - 1;
+ while (n_digits > 1 &&
+ (get_bits(a1->tab, a1->len, pos - n_digits * radix_bits) & digit_mask) == 0) {
+ n_digits--;
+ }
+ n_max = n_digits + 4;
+ }
+ n = ceil_div(a1->expn, radix_bits);
+ } else {
+ bf_t a_s, *a = &a_s;
+
+ /* make a positive number */
+ a->tab = a2->tab;
+ a->len = a2->len;
+ a->expn = a2->expn;
+ a->sign = 0;
+
if (fmt == BF_FTOA_FORMAT_FIXED) {
n_digits = prec;
n_max = n_digits;
} else {
slimb_t n_digits_max, n_digits_min;
- if (prec == BF_PREC_INF) {
- assert(radix_bits != 0);
- /* XXX: could use the exact number of bits */
- prec = a->len * LIMB_BITS;
- }
+ assert(prec != BF_PREC_INF);
n_digits = 1 + bf_mul_log2_radix(prec, radix, TRUE, TRUE);
/* max number of digits for non exponential
notation. The rational is to have the same rule
/* XXX: inefficient */
n_digits_max = n_digits;
n_digits_min = 1;
- bf_init(a2->ctx, b);
+ bf_init(ctx, b);
while (n_digits_min < n_digits_max) {
n_digits = (n_digits_min + n_digits_max) / 2;
if (bf_convert_to_radix(a1, &n, a, radix, n_digits,
*plen = s->size - 1;
return (char *)s->buf;
fail:
- bf_free(a2->ctx, s->buf);
+ bf_free(ctx, s->buf);
if (plen)
*plen = 0;
return NULL;
static int bf_const_get(bf_t *T, limb_t prec, bf_flags_t flags,
BFConstCache *c,
- void (*func)(bf_t *res, limb_t prec))
+ void (*func)(bf_t *res, limb_t prec), int sign)
{
limb_t ziv_extra_bits, prec1;
prec1 = c->prec;
}
bf_set(T, &c->val);
+ T->sign = sign;
if (!bf_can_round(T, prec, flags & BF_RND_MASK, prec1)) {
/* and more precision and retry */
ziv_extra_bits = ziv_extra_bits + (ziv_extra_bits / 2);
int bf_const_log2(bf_t *T, limb_t prec, bf_flags_t flags)
{
bf_context_t *s = T->ctx;
- return bf_const_get(T, prec, flags, &s->log2_cache, bf_const_log2_internal);
+ return bf_const_get(T, prec, flags, &s->log2_cache, bf_const_log2_internal, 0);
}
-int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags)
+/* return rounded pi * (1 - 2 * sign) */
+static int bf_const_pi_signed(bf_t *T, int sign, limb_t prec, bf_flags_t flags)
{
bf_context_t *s = T->ctx;
- return bf_const_get(T, prec, flags, &s->pi_cache, bf_const_pi_internal);
+ return bf_const_get(T, prec, flags, &s->pi_cache, bf_const_pi_internal,
+ sign);
+}
+
+int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags)
+{
+ return bf_const_pi_signed(T, 0, prec, flags);
}
void bf_clear_cache(bf_context_t *s)
break;
}
ziv_extra_bits = ziv_extra_bits * 2;
+ // printf("ziv_extra_bits=%" PRId64 "\n", (int64_t)ziv_extra_bits);
}
}
- return bf_round(r, prec, flags) | ret;
+ if (r->len == 0)
+ return ret;
+ else
+ return __bf_round(r, prec, flags, r->len, ret);
+}
+
+/* add (1 - 2*e_sign) * 2^e */
+static int bf_add_epsilon(bf_t *r, const bf_t *a, slimb_t e, int e_sign,
+ limb_t prec, int flags)
+{
+ bf_t T_s, *T = &T_s;
+ int ret;
+ /* small argument case: result = 1 + epsilon * sign(x) */
+ bf_init(a->ctx, T);
+ bf_set_ui(T, 1);
+ T->sign = e_sign;
+ T->expn += e;
+ ret = bf_add(r, r, T, prec, flags);
+ bf_delete(T);
+ return ret;
}
/* Compute the exponential using faithful rounding at precision 'prec'.
/* undo the range reduction */
for(i = 0; i < K; i++) {
- bf_mul(r, r, r, prec1, BF_RNDN);
+ bf_mul(r, r, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
}
/* undo the argument reduction */
- bf_mul_2exp(r, n, BF_PREC_INF, BF_RNDZ);
+ bf_mul_2exp(r, n, BF_PREC_INF, BF_RNDZ | BF_FLAG_EXT_EXP);
return BF_ST_INEXACT;
}
+/* crude overflow and underflow tests for exp(a). a_low <= a <= a_high */
+static int check_exp_underflow_overflow(bf_context_t *s, bf_t *r,
+ const bf_t *a_low, const bf_t *a_high,
+ limb_t prec, bf_flags_t flags)
+{
+ bf_t T_s, *T = &T_s;
+ bf_t log2_s, *log2 = &log2_s;
+ slimb_t e_min, e_max;
+
+ if (a_high->expn <= 0)
+ return 0;
+
+ e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
+ e_min = -e_max + 3;
+ if (flags & BF_FLAG_SUBNORMAL)
+ e_min -= (prec - 1);
+
+ bf_init(s, T);
+ bf_init(s, log2);
+ bf_const_log2(log2, LIMB_BITS, BF_RNDU);
+ bf_mul_ui(T, log2, e_max, LIMB_BITS, BF_RNDU);
+ /* a_low > e_max * log(2) implies exp(a) > e_max */
+ if (bf_cmp_lt(T, a_low) > 0) {
+ /* overflow */
+ bf_delete(T);
+ bf_delete(log2);
+ return bf_set_overflow(r, 0, prec, flags);
+ }
+ /* a_high < (e_min - 2) * log(2) implies exp(a) < (e_min - 2) */
+ bf_const_log2(log2, LIMB_BITS, BF_RNDD);
+ bf_mul_si(T, log2, e_min - 2, LIMB_BITS, BF_RNDD);
+ if (bf_cmp_lt(a_high, T)) {
+ int rnd_mode = flags & BF_RND_MASK;
+
+ /* underflow */
+ bf_delete(T);
+ bf_delete(log2);
+ if (rnd_mode == BF_RNDU) {
+ /* set the smallest value */
+ bf_set_ui(r, 1);
+ r->expn = e_min;
+ } else {
+ bf_set_zero(r, 0);
+ }
+ return BF_ST_UNDERFLOW | BF_ST_INEXACT;
+ }
+ bf_delete(log2);
+ bf_delete(T);
+ return 0;
+}
+
int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
bf_context_t *s = r->ctx;
+ int ret;
assert(r != a);
if (a->len == 0) {
if (a->expn == BF_EXP_NAN) {
return 0;
}
- /* crude overflow and underflow tests */
- if (a->expn > 0) {
- bf_t T_s, *T = &T_s;
- bf_t log2_s, *log2 = &log2_s;
- slimb_t e_min, e_max;
- e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
- e_min = -e_max + 3;
- if (flags & BF_FLAG_SUBNORMAL)
- e_min -= (prec - 1);
-
- bf_init(s, T);
- bf_init(s, log2);
- bf_const_log2(log2, LIMB_BITS, BF_RNDU);
- bf_mul_ui(T, log2, e_max, LIMB_BITS, BF_RNDU);
- /* a > e_max * log(2) implies exp(a) > e_max */
- if (bf_cmp_lt(T, a) > 0) {
- /* overflow */
- bf_delete(T);
- bf_delete(log2);
- return bf_set_overflow(r, 0, prec, flags);
- }
- /* a < e_min * log(2) implies exp(a) < e_min */
- bf_mul_si(T, log2, e_min, LIMB_BITS, BF_RNDD);
- if (bf_cmp_lt(a, T)) {
- int rnd_mode = flags & BF_RND_MASK;
-
- /* underflow */
- bf_delete(T);
- bf_delete(log2);
- if (rnd_mode == BF_RNDU) {
- /* set the smallest value */
- bf_set_ui(r, 1);
- r->expn = e_min;
- } else {
- bf_set_zero(r, 0);
- }
- return BF_ST_UNDERFLOW | BF_ST_INEXACT;
- }
- bf_delete(log2);
- bf_delete(T);
+ ret = check_exp_underflow_overflow(s, r, a, a, prec, flags);
+ if (ret)
+ return ret;
+ if (a->expn < 0 && (-a->expn) >= (prec + 2)) {
+ /* small argument case: result = 1 + epsilon * sign(x) */
+ bf_set_ui(r, 1);
+ return bf_add_epsilon(r, r, -(prec + 2), a->sign, prec, flags);
}
-
+
return bf_ziv_rounding(r, a, prec, flags, bf_exp_internal, NULL);
}
}
/* x and y finite and x > 0 */
-/* XXX: overflow/underflow handling */
static int bf_pow_generic(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
{
bf_context_t *s = r->ctx;
bf_init(s, T);
/* XXX: proof for the added precision */
prec1 = prec + 32;
- bf_log(T, x, prec1, BF_RNDF);
- bf_mul(T, T, y, prec1, BF_RNDF);
- bf_exp(r, T, prec1, BF_RNDF);
+ bf_log(T, x, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
+ bf_mul(T, T, y, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
+ if (bf_is_nan(T))
+ bf_set_nan(r);
+ else
+ bf_exp_internal(r, T, prec1, NULL); /* no overflow/underlow test needed */
bf_delete(T);
return BF_ST_INEXACT;
}
/* x and y finite, x > 0, y integer and y fits on one limb */
-/* XXX: overflow/underflow handling */
static int bf_pow_int(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
{
bf_context_t *s = r->ctx;
y1 = -y1;
/* XXX: proof for the added precision */
prec1 = prec + ceil_log2(y1) * 2 + 8;
- ret = bf_pow_ui(r, x, y1 < 0 ? -y1 : y1, prec1, BF_RNDN);
+ ret = bf_pow_ui(r, x, y1 < 0 ? -y1 : y1, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
if (y->sign) {
bf_init(s, T);
bf_set_ui(T, 1);
- ret |= bf_div(r, T, r, prec1, BF_RNDN);
+ ret |= bf_div(r, T, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
bf_delete(T);
}
return ret;
int cmp_x_abs_1;
bf_set_ui(r, 1);
cmp_x_abs_1 = bf_cmpu(x, r);
- if (cmp_x_abs_1 == 0 && (flags & BF_POW_JS_QUICKS) &&
+ if (cmp_x_abs_1 == 0 && (flags & BF_POW_JS_QUIRKS) &&
(y->expn >= BF_EXP_INF)) {
bf_set_nan(r);
} else if (cmp_x_abs_1 == 0 &&
if (bf_cmp_eq(T, r)) {
/* abs(x) = 1: nothing more to do */
ret = 0;
- } else if (y_is_int) {
- slimb_t T_bits, e;
- int_pow:
- T_bits = T->expn - bf_get_exp_min(T);
- if (T_bits == 1) {
- /* pow(2^b, y) = 2^(b*y) */
- bf_mul_si(T, y, T->expn - 1, LIMB_BITS, BF_RNDZ);
- bf_get_limb(&e, T, 0);
- bf_set_ui(r, 1);
- ret = bf_mul_2exp(r, e, prec, flags);
- } else if (prec == BF_PREC_INF) {
- slimb_t y1;
- /* specific case for infinite precision (integer case) */
- bf_get_limb(&y1, y, 0);
- assert(!y->sign);
- /* x must be an integer, so abs(x) >= 2 */
- if (y1 >= ((slimb_t)1 << BF_EXP_BITS_MAX)) {
- bf_delete(T);
- return bf_set_overflow(r, 0, BF_PREC_INF, flags);
- }
- ret = bf_pow_ui(r, T, y1, BF_PREC_INF, BF_RNDZ);
- } else {
- if (y->expn <= 31) {
- /* small enough power: use exponentiation in all cases */
- } else if (y->sign) {
- /* cannot be exact */
- goto general_case;
+ } else {
+ /* check the overflow/underflow cases */
+ {
+ bf_t al_s, *al = &al_s;
+ bf_t ah_s, *ah = &ah_s;
+ limb_t precl = LIMB_BITS;
+
+ bf_init(s, al);
+ bf_init(s, ah);
+ /* compute bounds of log(abs(x)) * y with a low precision */
+ /* XXX: compute bf_log() once */
+ /* XXX: add a fast test before this slow test */
+ bf_log(al, T, precl, BF_RNDD);
+ bf_log(ah, T, precl, BF_RNDU);
+ bf_mul(al, al, y, precl, BF_RNDD ^ y->sign);
+ bf_mul(ah, ah, y, precl, BF_RNDU ^ y->sign);
+ ret = check_exp_underflow_overflow(s, r, al, ah, prec, flags);
+ bf_delete(al);
+ bf_delete(ah);
+ if (ret)
+ goto done;
+ }
+
+ if (y_is_int) {
+ slimb_t T_bits, e;
+ int_pow:
+ T_bits = T->expn - bf_get_exp_min(T);
+ if (T_bits == 1) {
+ /* pow(2^b, y) = 2^(b*y) */
+ bf_mul_si(T, y, T->expn - 1, LIMB_BITS, BF_RNDZ);
+ bf_get_limb(&e, T, 0);
+ bf_set_ui(r, 1);
+ ret = bf_mul_2exp(r, e, prec, flags);
+ } else if (prec == BF_PREC_INF) {
+ slimb_t y1;
+ /* specific case for infinite precision (integer case) */
+ bf_get_limb(&y1, y, 0);
+ assert(!y->sign);
+ /* x must be an integer, so abs(x) >= 2 */
+ if (y1 >= ((slimb_t)1 << BF_EXP_BITS_MAX)) {
+ bf_delete(T);
+ return bf_set_overflow(r, 0, BF_PREC_INF, flags);
+ }
+ ret = bf_pow_ui(r, T, y1, BF_PREC_INF, BF_RNDZ);
} else {
- if (rnd_mode == BF_RNDF)
- goto general_case; /* no need to track exact results */
- /* see if the result has a chance to be exact:
- if x=a*2^b (a odd), x^y=a^y*2^(b*y)
- x^y needs a precision of at least floor_log2(a)*y bits
- */
- bf_mul_si(r, y, T_bits - 1, LIMB_BITS, BF_RNDZ);
- bf_get_limb(&e, r, 0);
- if (prec < e)
+ if (y->expn <= 31) {
+ /* small enough power: use exponentiation in all cases */
+ } else if (y->sign) {
+ /* cannot be exact */
goto general_case;
+ } else {
+ if (rnd_mode == BF_RNDF)
+ goto general_case; /* no need to track exact results */
+ /* see if the result has a chance to be exact:
+ if x=a*2^b (a odd), x^y=a^y*2^(b*y)
+ x^y needs a precision of at least floor_log2(a)*y bits
+ */
+ bf_mul_si(r, y, T_bits - 1, LIMB_BITS, BF_RNDZ);
+ bf_get_limb(&e, r, 0);
+ if (prec < e)
+ goto general_case;
+ }
+ ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_int, (void *)y);
}
- ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_int, (void *)y);
- }
- } else {
- if (rnd_mode != BF_RNDF) {
- bf_t *y1;
- if (y_emin < 0 && check_exact_power2n(r, T, -y_emin)) {
- /* the problem is reduced to a power to an integer */
+ } else {
+ if (rnd_mode != BF_RNDF) {
+ bf_t *y1;
+ if (y_emin < 0 && check_exact_power2n(r, T, -y_emin)) {
+ /* the problem is reduced to a power to an integer */
#if 0
- printf("\nn=%ld\n", -y_emin);
- bf_print_str("T", T);
- bf_print_str("r", r);
+ printf("\nn=%" PRId64 "\n", -(int64_t)y_emin);
+ bf_print_str("T", T);
+ bf_print_str("r", r);
#endif
- bf_set(T, r);
- y1 = &ytmp_s;
- y1->tab = y->tab;
- y1->len = y->len;
- y1->sign = y->sign;
- y1->expn = y->expn - y_emin;
- y = y1;
- goto int_pow;
+ bf_set(T, r);
+ y1 = &ytmp_s;
+ y1->tab = y->tab;
+ y1->len = y->len;
+ y1->sign = y->sign;
+ y1->expn = y->expn - y_emin;
+ y = y1;
+ goto int_pow;
+ }
}
+ general_case:
+ ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_generic, (void *)y);
}
- general_case:
- ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_generic, (void *)y);
}
+ done:
bf_delete(T);
r->sign = r_sign;
return ret;
bf_delete(T);
}
-int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
+static int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
{
bf_context_t *s1 = a->ctx;
bf_t T_s, *T = &T_s;
int is_neg;
assert(c != a && s != a);
- if (a->len == 0) {
- if (a->expn == BF_EXP_NAN) {
- if (c)
- bf_set_nan(c);
- if (s)
- bf_set_nan(s);
- return 0;
- } else if (a->expn == BF_EXP_INF) {
- if (c)
- bf_set_nan(c);
- if (s)
- bf_set_nan(s);
- return BF_ST_INVALID_OP;
- } else {
- if (c)
- bf_set_ui(c, 1);
- if (s)
- bf_set_zero(s, a->sign);
- return 0;
- }
- }
bf_init(s1, T);
bf_init(s1, U);
slimb_t cancel;
cancel = 0;
for(;;) {
- prec2 = prec1 + cancel;
+ prec2 = prec1 + a->expn + cancel;
bf_const_pi(U, prec2, BF_RNDF);
bf_mul_2exp(U, -1, BF_PREC_INF, BF_RNDZ);
- bf_remquo(&mod, T, a, U, prec2, BF_RNDN);
+ bf_remquo(&mod, T, a, U, prec2, BF_RNDN, BF_RNDN);
// printf("T.expn=%ld prec2=%ld\n", T->expn, prec2);
if (mod == 0 || (T->expn != BF_EXP_ZERO &&
(T->expn + prec2) >= (prec1 - 1)))
int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
+ if (a->len == 0) {
+ if (a->expn == BF_EXP_NAN) {
+ bf_set_nan(r);
+ return 0;
+ } else if (a->expn == BF_EXP_INF) {
+ bf_set_nan(r);
+ return BF_ST_INVALID_OP;
+ } else {
+ bf_set_ui(r, 1);
+ return 0;
+ }
+ }
+
+ /* small argument case: result = 1+r(x) with r(x) = -x^2/2 +
+ O(X^4). We assume r(x) < 2^(2*EXP(x) - 1). */
+ if (a->expn < 0) {
+ slimb_t e;
+ e = 2 * a->expn - 1;
+ if (e < -(prec + 2)) {
+ bf_set_ui(r, 1);
+ return bf_add_epsilon(r, r, e, 1, prec, flags);
+ }
+ }
+
return bf_ziv_rounding(r, a, prec, flags, bf_cos_internal, NULL);
}
int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
- return bf_ziv_rounding(r, a, prec, flags, bf_sin_internal, NULL);
-}
-
-static int bf_tan_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
-{
- bf_context_t *s = r->ctx;
- bf_t T_s, *T = &T_s;
- limb_t prec1;
-
if (a->len == 0) {
if (a->expn == BF_EXP_NAN) {
bf_set_nan(r);
}
}
+ /* small argument case: result = x+r(x) with r(x) = -x^3/6 +
+ O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
+ if (a->expn < 0) {
+ slimb_t e;
+ e = sat_add(2 * a->expn, a->expn - 2);
+ if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
+ bf_set(r, a);
+ return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
+ }
+ }
+
+ return bf_ziv_rounding(r, a, prec, flags, bf_sin_internal, NULL);
+}
+
+static int bf_tan_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
+{
+ bf_context_t *s = r->ctx;
+ bf_t T_s, *T = &T_s;
+ limb_t prec1;
+
/* XXX: precision analysis */
prec1 = prec + 8;
bf_init(s, T);
int bf_tan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
+ assert(r != a);
+ if (a->len == 0) {
+ if (a->expn == BF_EXP_NAN) {
+ bf_set_nan(r);
+ return 0;
+ } else if (a->expn == BF_EXP_INF) {
+ bf_set_nan(r);
+ return BF_ST_INVALID_OP;
+ } else {
+ bf_set_zero(r, a->sign);
+ return 0;
+ }
+ }
+
+ /* small argument case: result = x+r(x) with r(x) = x^3/3 +
+ O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
+ if (a->expn < 0) {
+ slimb_t e;
+ e = sat_add(2 * a->expn, a->expn - 1);
+ if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
+ bf_set(r, a);
+ return bf_add_epsilon(r, r, e, a->sign, prec, flags);
+ }
+ }
+
return bf_ziv_rounding(r, a, prec, flags, bf_tan_internal, NULL);
}
int cmp_1;
slimb_t prec1, i, K, l;
- if (a->len == 0) {
- if (a->expn == BF_EXP_NAN) {
- bf_set_nan(r);
- return 0;
- } else {
- if (a->expn == BF_EXP_INF)
- i = 1 - 2 * a->sign;
- else
- i = 0;
- i += add_pi2;
- /* return i*(pi/2) with -1 <= i <= 2 */
- if (i == 0) {
- bf_set_zero(r, add_pi2 ? 0 : a->sign);
- return 0;
- } else {
- /* PI or PI/2 */
- bf_const_pi(r, prec, BF_RNDF);
- if (i != 2)
- bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
- r->sign = (i < 0);
- return BF_ST_INEXACT;
- }
- }
- }
-
- bf_init(s, T);
- bf_set_ui(T, 1);
- cmp_1 = bf_cmpu(a, T);
- if (cmp_1 == 0 && !add_pi2) {
- /* short cut: abs(a) == 1 -> +/-pi/4 */
- bf_const_pi(r, prec, BF_RNDF);
- bf_mul_2exp(r, -2, BF_PREC_INF, BF_RNDZ);
- r->sign = a->sign;
- bf_delete(T);
- return BF_ST_INEXACT;
- }
-
/* XXX: precision analysis */
K = bf_isqrt((prec + 1) / 2);
l = prec / (2 * K) + 1;
prec1 = prec + K + 2 * l + 32;
- // printf("prec=%ld K=%ld l=%ld prec1=%ld\n", prec, K, l, prec1);
+ // printf("prec=%d K=%d l=%d prec1=%d\n", (int)prec, (int)K, (int)l, (int)prec1);
- if (cmp_1 > 0) {
+ bf_init(s, T);
+ cmp_1 = (a->expn >= 1); /* a >= 1 */
+ if (cmp_1) {
bf_set_ui(T, 1);
bf_div(T, T, a, prec1, BF_RNDN);
} else {
int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
+ bf_context_t *s = r->ctx;
+ bf_t T_s, *T = &T_s;
+ int res;
+
+ if (a->len == 0) {
+ if (a->expn == BF_EXP_NAN) {
+ bf_set_nan(r);
+ return 0;
+ } else if (a->expn == BF_EXP_INF) {
+ /* -PI/2 or PI/2 */
+ bf_const_pi_signed(r, a->sign, prec, flags);
+ bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
+ return BF_ST_INEXACT;
+ } else {
+ bf_set_zero(r, a->sign);
+ return 0;
+ }
+ }
+
+ bf_init(s, T);
+ bf_set_ui(T, 1);
+ res = bf_cmpu(a, T);
+ bf_delete(T);
+ if (res == 0) {
+ /* short cut: abs(a) == 1 -> +/-pi/4 */
+ bf_const_pi_signed(r, a->sign, prec, flags);
+ bf_mul_2exp(r, -2, BF_PREC_INF, BF_RNDZ);
+ return BF_ST_INEXACT;
+ }
+
+ /* small argument case: result = x+r(x) with r(x) = -x^3/3 +
+ O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
+ if (a->expn < 0) {
+ slimb_t e;
+ e = sat_add(2 * a->expn, a->expn - 1);
+ if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
+ bf_set(r, a);
+ return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
+ }
+ }
+
return bf_ziv_rounding(r, a, prec, flags, bf_atan_internal, (void *)FALSE);
}
BOOL is_acos = (BOOL)(intptr_t)opaque;
bf_t T_s, *T = &T_s;
limb_t prec1, prec2;
- int res;
-
- if (a->len == 0) {
- if (a->expn == BF_EXP_NAN) {
- bf_set_nan(r);
- return 0;
- } else if (a->expn == BF_EXP_INF) {
- bf_set_nan(r);
- return BF_ST_INVALID_OP;
- } else {
- if (is_acos) {
- bf_const_pi(r, prec, BF_RNDF);
- bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
- return BF_ST_INEXACT;
- } else {
- bf_set_zero(r, a->sign);
- return 0;
- }
- }
- }
- bf_init(s, T);
- bf_set_ui(T, 1);
- res = bf_cmpu(a, T);
- if (res > 0) {
- bf_delete(T);
- bf_set_nan(r);
- return BF_ST_INVALID_OP;
- } else if (res == 0 && a->sign == 0 && is_acos) {
- bf_set_zero(r, 0);
- bf_delete(T);
- return 0;
- }
/* asin(x) = atan(x/sqrt(1-x^2))
acos(x) = pi/2 - asin(x) */
prec2 = BF_PREC_INF;
else
prec2 = prec1;
+ bf_init(s, T);
bf_mul(T, a, a, prec2, BF_RNDN);
bf_neg(T);
bf_add_si(T, T, 1, prec2, BF_RNDN);
int bf_asin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
+ bf_context_t *s = r->ctx;
+ bf_t T_s, *T = &T_s;
+ int res;
+
+ if (a->len == 0) {
+ if (a->expn == BF_EXP_NAN) {
+ bf_set_nan(r);
+ return 0;
+ } else if (a->expn == BF_EXP_INF) {
+ bf_set_nan(r);
+ return BF_ST_INVALID_OP;
+ } else {
+ bf_set_zero(r, a->sign);
+ return 0;
+ }
+ }
+ bf_init(s, T);
+ bf_set_ui(T, 1);
+ res = bf_cmpu(a, T);
+ bf_delete(T);
+ if (res > 0) {
+ bf_set_nan(r);
+ return BF_ST_INVALID_OP;
+ }
+
+ /* small argument case: result = x+r(x) with r(x) = x^3/6 +
+ O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
+ if (a->expn < 0) {
+ slimb_t e;
+ e = sat_add(2 * a->expn, a->expn - 2);
+ if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
+ bf_set(r, a);
+ return bf_add_epsilon(r, r, e, a->sign, prec, flags);
+ }
+ }
+
return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)FALSE);
}
int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
+ bf_context_t *s = r->ctx;
+ bf_t T_s, *T = &T_s;
+ int res;
+
+ if (a->len == 0) {
+ if (a->expn == BF_EXP_NAN) {
+ bf_set_nan(r);
+ return 0;
+ } else if (a->expn == BF_EXP_INF) {
+ bf_set_nan(r);
+ return BF_ST_INVALID_OP;
+ } else {
+ bf_const_pi(r, prec, flags);
+ bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
+ return BF_ST_INEXACT;
+ }
+ }
+ bf_init(s, T);
+ bf_set_ui(T, 1);
+ res = bf_cmpu(a, T);
+ bf_delete(T);
+ if (res > 0) {
+ bf_set_nan(r);
+ return BF_ST_INVALID_OP;
+ } else if (res == 0 && a->sign == 0) {
+ bf_set_zero(r, 0);
+ return 0;
+ }
+
return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)TRUE);
}
#endif /* LIMB_BITS != 64 */
-static inline limb_t shrd(limb_t low, limb_t high, long shift)
+static inline __maybe_unused limb_t shrd(limb_t low, limb_t high, long shift)
{
if (shift != 0)
low = (low >> shift) | (high << (LIMB_BITS - shift));
return low;
}
-static inline limb_t shld(limb_t a1, limb_t a0, long shift)
+static inline __maybe_unused limb_t shld(limb_t a1, limb_t a0, long shift)
{
if (shift != 0)
return (a1 << shift) | (a0 >> (LIMB_BITS - shift));
/* fast integer division by a fixed constant */
typedef struct FastDivData {
- limb_t d; /* divisor (only user visible field) */
limb_t m1; /* multiplier */
- int shift1;
- int shift2;
+ int8_t shift1;
+ int8_t shift2;
} FastDivData;
-#if 1
/* From "Division by Invariant Integers using Multiplication" by
Torborn Granlund and Peter L. Montgomery */
/* d must be != 0 */
-static inline void fast_udiv_init(FastDivData *s, limb_t d)
+static inline __maybe_unused void fast_udiv_init(FastDivData *s, limb_t d)
{
int l;
limb_t q, r, m1;
- s->d = d;
if (d == 1)
l = 0;
else
return (t1 + t0) >> s->shift2;
}
-static inline limb_t fast_urem(limb_t a, const FastDivData *s)
-{
- limb_t q;
- q = fast_udiv(a, s);
- return a - q * s->d;
-}
+/* contains 10^i */
+const limb_t mp_pow_dec[LIMB_DIGITS + 1] = {
+ 1U,
+ 10U,
+ 100U,
+ 1000U,
+ 10000U,
+ 100000U,
+ 1000000U,
+ 10000000U,
+ 100000000U,
+ 1000000000U,
+#if LIMB_BITS == 64
+ 10000000000U,
+ 100000000000U,
+ 1000000000000U,
+ 10000000000000U,
+ 100000000000000U,
+ 1000000000000000U,
+ 10000000000000000U,
+ 100000000000000000U,
+ 1000000000000000000U,
+ 10000000000000000000U,
+#endif
+};
-#define fast_udivrem(q, r, a, s) q = fast_udiv(a, s), r = a - q * (s)->d
-
+/* precomputed from fast_udiv_init(10^i) */
+static const FastDivData mp_pow_div[LIMB_DIGITS + 1] = {
+#if LIMB_BITS == 32
+ { 0x00000001, 0, 0 },
+ { 0x9999999a, 1, 3 },
+ { 0x47ae147b, 1, 6 },
+ { 0x0624dd30, 1, 9 },
+ { 0xa36e2eb2, 1, 13 },
+ { 0x4f8b588f, 1, 16 },
+ { 0x0c6f7a0c, 1, 19 },
+ { 0xad7f29ac, 1, 23 },
+ { 0x5798ee24, 1, 26 },
+ { 0x12e0be83, 1, 29 },
#else
-
-static inline void fast_udiv_init(FastDivData *s, limb_t d)
-{
- s->d = d;
-}
-static inline limb_t fast_udiv(limb_t a, const FastDivData *s)
-{
- return a / s->d;
-}
-static inline limb_t fast_urem(limb_t a, const FastDivData *s)
-{
- return a % s->d;
-}
-
-#define fast_udivrem(q, r, a, s) q = a / (s)->d, r = a % (s)->d
-
+ { 0x0000000000000001, 0, 0 },
+ { 0x999999999999999a, 1, 3 },
+ { 0x47ae147ae147ae15, 1, 6 },
+ { 0x0624dd2f1a9fbe77, 1, 9 },
+ { 0xa36e2eb1c432ca58, 1, 13 },
+ { 0x4f8b588e368f0847, 1, 16 },
+ { 0x0c6f7a0b5ed8d36c, 1, 19 },
+ { 0xad7f29abcaf48579, 1, 23 },
+ { 0x5798ee2308c39dfa, 1, 26 },
+ { 0x12e0be826d694b2f, 1, 29 },
+ { 0xb7cdfd9d7bdbab7e, 1, 33 },
+ { 0x5fd7fe17964955fe, 1, 36 },
+ { 0x19799812dea11198, 1, 39 },
+ { 0xc25c268497681c27, 1, 43 },
+ { 0x6849b86a12b9b01f, 1, 46 },
+ { 0x203af9ee756159b3, 1, 49 },
+ { 0xcd2b297d889bc2b7, 1, 53 },
+ { 0x70ef54646d496893, 1, 56 },
+ { 0x2725dd1d243aba0f, 1, 59 },
+ { 0xd83c94fb6d2ac34d, 1, 63 },
#endif
+};
-/* contains 10^i */
-/* XXX: make it const */
-limb_t mp_pow_dec[LIMB_DIGITS + 1];
-static FastDivData mp_pow_div[LIMB_DIGITS + 1];
-
-static void mp_pow_init(void)
+/* divide by 10^shift with 0 <= shift <= LIMB_DIGITS */
+static inline limb_t fast_shr_dec(limb_t a, int shift)
{
- limb_t a;
- int i;
-
- a = 1;
- for(i = 0; i <= LIMB_DIGITS; i++) {
- mp_pow_dec[i] = a;
- fast_udiv_init(&mp_pow_div[i], a);
- a = a * 10;
- }
+ return fast_udiv(a, &mp_pow_div[shift]);
}
+/* division and remainder by 10^shift */
+#define fast_shr_rem_dec(q, r, a, shift) q = fast_shr_dec(a, shift), r = a - q * mp_pow_dec[shift]
+
limb_t mp_add_dec(limb_t *res, const limb_t *op1, const limb_t *op2,
mp_size_t n, limb_t carry)
{
l = high;
for(i = n - 1; i >= 0; i--) {
a = tab[i];
- fast_udivrem(q, r, a, &mp_pow_div[shift]);
+ fast_shr_rem_dec(q, r, a, shift);
tab_r[i] = q + l * mp_pow_dec[LIMB_DIGITS - shift];
l = r;
}
l = low;
for(i = 0; i < n; i++) {
a = tab[i];
- fast_udivrem(q, r, a, &mp_pow_div[LIMB_DIGITS - shift]);
+ fast_shr_rem_dec(q, r, a, LIMB_DIGITS - shift);
tab_r[i] = r * mp_pow_dec[shift] + l;
l = q;
}
return 0;
pos = (limb_t)bit_pos / LIMB_DIGITS;
shift = (limb_t)bit_pos % LIMB_DIGITS;
- fast_udivrem(q, v, r->tab[pos], &mp_pow_div[shift + 1]);
+ fast_shr_rem_dec(q, v, r->tab[pos], shift + 1);
(void)q;
if (v != 0)
return 1;
if (i < 0 || i >= len)
return 0;
shift = pos - i * LIMB_DIGITS;
- return fast_udiv(tab[i], &mp_pow_div[shift]) % 10;
+ return fast_shr_dec(tab[i], shift) % 10;
}
#if 0
a1 = tab[i];
else
a1 = 0;
- return fast_udiv(a0, &mp_pow_div[shift]) +
+ return fast_shr_dec(a0, shift) +
fast_urem(a1, &mp_pow_div[LIMB_DIGITS - shift]) *
mp_pow_dec[shift];
}
case BF_RNDF:
add_one = (digit1 >= 5);
break;
- case BF_RNDNU:
- if (digit1 >= 5) {
- if (r->sign)
- add_one = (digit0 != 0);
- else
- add_one = 1;
- }
+ case BF_RNDA:
+ add_one = inexact;
break;
default:
abort();
int shift, add_one, rnd_mode, ret;
slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
- /* e_min and e_max are computed to match the IEEE 754 conventions */
- /* XXX: does not matter for decimal numbers */
+ /* XXX: align to IEEE 754 2008 for decimal numbers ? */
e_range = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
e_min = -e_range + 3;
e_max = e_range;
prec = r->expn + prec1;
else
prec = prec1;
+ } else if (unlikely(r->expn < e_min) && (flags & BF_FLAG_SUBNORMAL)) {
+ /* restrict the precision in case of potentially subnormal
+ result */
+ assert(prec1 != BF_PREC_INF);
+ prec = prec1 - (e_min - r->expn);
} else {
prec = prec1;
}
/* check underflow */
if (unlikely(r->expn < e_min)) {
- underflow:
- bfdec_set_zero(r, r->sign);
- ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
- return ret;
+ if (flags & BF_FLAG_SUBNORMAL) {
+ /* if inexact, also set the underflow flag */
+ if (ret & BF_ST_INEXACT)
+ ret |= BF_ST_UNDERFLOW;
+ } else {
+ underflow:
+ bfdec_set_zero(r, r->sign);
+ ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
+ return ret;
+ }
}
/* check overflow */
if (i >= 0) {
shift = smod(bit_pos, LIMB_DIGITS);
if (shift != 0) {
- r->tab[i] = fast_udiv(r->tab[i], &mp_pow_div[shift]) *
+ r->tab[i] = fast_shr_dec(r->tab[i], shift) *
mp_pow_dec[shift];
}
} else {
/* number of digits after the decimal point */
/* XXX: check (2 extra digits for rounding + 2 digits) */
precl = (bf_max(a->expn - b->expn, 0) + 2 +
- 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
+ prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
} else {
/* number of limbs of the quotient (2 extra digits for rounding) */
- precl = (prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
+ precl = (prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
}
n = bf_max(a->len, precl);
}
q_sign = a->sign ^ b->sign;
- is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA ||
- rnd_mode == BF_RNDNU);
+ is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
switch(rnd_mode) {
default:
case BF_RNDZ:
case BF_RNDU:
is_ceil = q_sign ^ 1;
break;
+ case BF_RNDA:
+ is_ceil = TRUE;
+ break;
case BF_DIVREM_EUCLIDIAN:
is_ceil = a->sign;
break;
- case BF_RNDNU:
- /* XXX: unsupported yet */
- abort();
}
a1->expn = a->expn;
return BF_ST_MEM_ERROR;
}
-int bfdec_fmod(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
- bf_flags_t flags)
+int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+ bf_flags_t flags, int rnd_mode)
{
bfdec_t q_s, *q = &q_s;
int ret;
bfdec_init(r->ctx, q);
- ret = bfdec_divrem(q, r, a, b, prec, flags, BF_RNDZ);
+ ret = bfdec_divrem(q, r, a, b, prec, flags, rnd_mode);
bfdec_delete(q);
return ret;
}
bf_context_t *s = a->ctx;
int ret, k;
limb_t *a1, v;
- slimb_t n, n1;
+ slimb_t n, n1, prec1;
limb_t res;
assert(r != a);
bfdec_set_nan(r);
ret = BF_ST_INVALID_OP;
} else {
+ if (flags & BF_FLAG_RADPNT_PREC) {
+ prec1 = bf_max(floor_div(a->expn + 1, 2) + prec, 1);
+ } else {
+ prec1 = prec;
+ }
/* convert the mantissa to an integer with at least 2 *
prec + 4 digits */
- n = (2 * (prec + 2) + 2 * LIMB_DIGITS - 1) / (2 * LIMB_DIGITS);
+ n = (2 * (prec1 + 2) + 2 * LIMB_DIGITS - 1) / (2 * LIMB_DIGITS);
if (bfdec_resize(r, n))
goto fail;
a1 = bf_malloc(s, sizeof(limb_t) * 2 * n);
v = 0;
ret = 0;
} else if (a->expn <= 9) {
- v = fast_udiv(a->tab[a->len - 1], &mp_pow_div[LIMB_DIGITS - a->expn]);
+ v = fast_shr_dec(a->tab[a->len - 1], LIMB_DIGITS - a->expn);
if (a->sign)
v = -v;
ret = 0;
uint64_t v1;
uint32_t v_max;
#if LIMB_BITS == 64
- v1 = fast_udiv(a->tab[a->len - 1], &mp_pow_div[LIMB_DIGITS - a->expn]);
+ v1 = fast_shr_dec(a->tab[a->len - 1], LIMB_DIGITS - a->expn);
#else
v1 = (uint64_t)a->tab[a->len - 1] * 10 +
get_digit(a->tab, a->len, (a->len - 1) * LIMB_DIGITS - 1);
typedef int64_t slimb_t;
typedef uint64_t limb_t;
typedef uint128_t dlimb_t;
-#define EXP_MIN INT64_MIN
-#define EXP_MAX INT64_MAX
+#define BF_RAW_EXP_MIN INT64_MIN
+#define BF_RAW_EXP_MAX INT64_MAX
#define LIMB_DIGITS 19
#define BF_DEC_BASE UINT64_C(10000000000000000000)
typedef int32_t slimb_t;
typedef uint32_t limb_t;
typedef uint64_t dlimb_t;
-#define EXP_MIN INT32_MIN
-#define EXP_MAX INT32_MAX
+#define BF_RAW_EXP_MIN INT32_MIN
+#define BF_RAW_EXP_MAX INT32_MAX
#define LIMB_DIGITS 9
#define BF_DEC_BASE 1000000000U
#endif
/* in bits */
+/* minimum number of bits for the exponent */
#define BF_EXP_BITS_MIN 3
-#define BF_EXP_BITS_MAX (LIMB_BITS - 2)
+/* maximum number of bits for the exponent */
+#define BF_EXP_BITS_MAX (LIMB_BITS - 3)
+/* extended range for exponent, used internally */
+#define BF_EXT_EXP_BITS_MAX (BF_EXP_BITS_MAX + 1)
+/* minimum possible precision */
#define BF_PREC_MIN 2
-#define BF_PREC_MAX (((limb_t)1 << BF_EXP_BITS_MAX) - 2)
+/* minimum possible precision */
+#define BF_PREC_MAX (((limb_t)1 << (LIMB_BITS - 2)) - 2)
+/* some operations support infinite precision */
#define BF_PREC_INF (BF_PREC_MAX + 1) /* infinite precision */
#if LIMB_BITS == 64
#define BF_CHKSUM_MOD 975620677U
#endif
-#define BF_EXP_ZERO EXP_MIN
-#define BF_EXP_INF (EXP_MAX - 1)
-#define BF_EXP_NAN EXP_MAX
+#define BF_EXP_ZERO BF_RAW_EXP_MIN
+#define BF_EXP_INF (BF_RAW_EXP_MAX - 1)
+#define BF_EXP_NAN BF_RAW_EXP_MAX
/* +/-zero is represented with expn = BF_EXP_ZERO and len = 0,
+/-infinity is represented with expn = BF_EXP_INF and len = 0,
typedef enum {
BF_RNDN, /* round to nearest, ties to even */
BF_RNDZ, /* round to zero */
- BF_RNDD, /* round to -inf */
+ BF_RNDD, /* round to -inf (the code relies on (BF_RNDD xor BF_RNDU) = 1) */
BF_RNDU, /* round to +inf */
BF_RNDNA, /* round to nearest, ties away from zero */
- BF_RNDNU, /* round to nearest, ties to +inf */
+ BF_RNDA, /* round away from zero */
BF_RNDF, /* faithful rounding (nondeterministic, either RNDD or RNDU,
inexact flag is always set) */
} bf_rnd_t;
/* allow subnormal numbers. Only available if the number of exponent
- bits is < BF_EXP_BITS_MAX and prec != BF_PREC_INF. Not supported
- for decimal floating point numbers. */
+ bits is <= BF_EXP_BITS_USER_MAX and prec != BF_PREC_INF. */
#define BF_FLAG_SUBNORMAL (1 << 3)
/* 'prec' is the precision after the radix point instead of the whole
- mantissa. Can only be used with bf_round(), bfdec_round() and
- bfdev_div(). */
+ mantissa. Can only be used with bf_round() and
+ bfdec_[add|sub|mul|div|sqrt|round](). */
#define BF_FLAG_RADPNT_PREC (1 << 4)
#define BF_RND_MASK 0x7
#define BF_EXP_BITS_SHIFT 5
#define BF_EXP_BITS_MASK 0x3f
+/* shortcut for bf_set_exp_bits(BF_EXT_EXP_BITS_MAX) */
+#define BF_FLAG_EXT_EXP (BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT)
+
/* contains the rounding mode and number of exponents bits */
typedef uint32_t bf_flags_t;
static inline int bf_get_exp_bits(bf_flags_t flags)
{
- return BF_EXP_BITS_MAX - ((flags >> BF_EXP_BITS_SHIFT) & BF_EXP_BITS_MASK);
+ int e;
+ e = (flags >> BF_EXP_BITS_SHIFT) & BF_EXP_BITS_MASK;
+ if (e == BF_EXP_BITS_MASK)
+ return BF_EXP_BITS_MAX + 1;
+ else
+ return BF_EXP_BITS_MAX - e;
}
static inline bf_flags_t bf_set_exp_bits(int n)
{
- return (BF_EXP_BITS_MAX - n) << BF_EXP_BITS_SHIFT;
+ return ((BF_EXP_BITS_MAX - n) & BF_EXP_BITS_MASK) << BF_EXP_BITS_SHIFT;
}
/* returned status */
int bf_cmpu(const bf_t *a, const bf_t *b);
int bf_cmp_full(const bf_t *a, const bf_t *b);
-int bf_cmp_eq(const bf_t *a, const bf_t *b);
-int bf_cmp_le(const bf_t *a, const bf_t *b);
-int bf_cmp_lt(const bf_t *a, const bf_t *b);
+int bf_cmp(const bf_t *a, const bf_t *b);
+static inline int bf_cmp_eq(const bf_t *a, const bf_t *b)
+{
+ return bf_cmp(a, b) == 0;
+}
+
+static inline int bf_cmp_le(const bf_t *a, const bf_t *b)
+{
+ return bf_cmp(a, b) <= 0;
+}
+
+static inline int bf_cmp_lt(const bf_t *a, const bf_t *b)
+{
+ return bf_cmp(a, b) < 0;
+}
+
int bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
int bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec, bf_flags_t flags);
#define BF_DIVREM_EUCLIDIAN BF_RNDF
int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
limb_t prec, bf_flags_t flags, int rnd_mode);
-int bf_fmod(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
- bf_flags_t flags);
-int bf_remainder(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
- bf_flags_t flags);
+int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
+ bf_flags_t flags, int rnd_mode);
int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
- bf_flags_t flags);
+ bf_flags_t flags, int rnd_mode);
/* round to integer with infinite precision */
int bf_rint(bf_t *r, int rnd_mode);
int bf_round(bf_t *r, limb_t prec, bf_flags_t flags);
/* Conversion of floating point number to string. Return a null
terminated string or NULL if memory error. *plen contains its
length if plen != NULL. The exponent letter is "e" for base 10,
- "p" for bases 2, 8, 16 with the binary exponent and "@" for the
- other bases. */
+ "p" for bases 2, 8, 16 with a binary exponent and "@" for the other
+ bases. */
#define BF_FTOA_FORMAT_MASK (3 << 16)
/* fractional format: prec digits after the decimal point rounded with
(flags & BF_RND_MASK) */
#define BF_FTOA_FORMAT_FRAC (1 << 16)
-/* free format: use as many digits as necessary so that bf_atof()
- return the same number when using precision 'prec', rounding to
- nearest and the subnormal+exponent configuration of 'flags'. The
- result is meaningful only if 'a' is already rounded to the wanted
- precision.
+/* free format:
+
+ For binary radices with bf_ftoa() and for bfdec_ftoa(): use the minimum
+ number of digits to represent 'a'. The precision and the rounding
+ mode are ignored.
- Infinite precision (BF_PREC_INF) is supported when the radix is a
- power of two. */
+ For the non binary radices with bf_ftoa(): use as many digits as
+ necessary so that bf_atof() return the same number when using
+ precision 'prec', rounding to nearest and the subnormal
+ configuration of 'flags'. The result is meaningful only if 'a' is
+ already rounded to 'prec' bits. If the subnormal flag is set, the
+ exponent in 'flags' must also be set to the desired exponent range.
+*/
#define BF_FTOA_FORMAT_FREE (2 << 16)
/* same as BF_FTOA_FORMAT_FREE but uses the minimum number of digits
- (takes more computation time). */
+ (takes more computation time). Identical to BF_FTOA_FORMAT_FREE for
+ binary radices with bf_ftoa() and for bfdec_ftoa(). */
#define BF_FTOA_FORMAT_FREE_MIN (3 << 16)
/* force exponential notation for fixed or free format */
int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags);
int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
int bf_log(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-#define BF_POW_JS_QUICKS (1 << 16)
+#define BF_POW_JS_QUIRKS (1 << 16) /* (+/-1)^(+/-Inf) = NaN, 1^NaN = NaN */
int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags);
int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
{
return bf_cmp_full((const bf_t *)a, (const bf_t *)b);
}
+static inline int bfdec_cmp(const bfdec_t *a, const bfdec_t *b)
+{
+ return bf_cmp((const bf_t *)a, (const bf_t *)b);
+}
static inline int bfdec_cmp_eq(const bfdec_t *a, const bfdec_t *b)
{
- return bf_cmp_eq((const bf_t *)a, (const bf_t *)b);
+ return bfdec_cmp(a, b) == 0;
}
static inline int bfdec_cmp_le(const bfdec_t *a, const bfdec_t *b)
{
- return bf_cmp_le((const bf_t *)a, (const bf_t *)b);
+ return bfdec_cmp(a, b) <= 0;
}
static inline int bfdec_cmp_lt(const bfdec_t *a, const bfdec_t *b)
{
- return bf_cmp_lt((const bf_t *)a, (const bf_t *)b);
+ return bfdec_cmp(a, b) < 0;
}
int bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
bf_flags_t flags);
int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
limb_t prec, bf_flags_t flags, int rnd_mode);
-int bfdec_fmod(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
- bf_flags_t flags);
+int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+ bf_flags_t flags, int rnd_mode);
int bfdec_rint(bfdec_t *r, int rnd_mode);
int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags);
int bfdec_round(bfdec_t *r, limb_t prec, bf_flags_t flags);
limb_t prec, bf_flags_t flags);
/* the following functions are exported for testing only. */
-extern limb_t mp_pow_dec[LIMB_DIGITS + 1];
+extern const limb_t mp_pow_dec[LIMB_DIGITS + 1];
void bfdec_print_str(const char *str, const bfdec_t *a);
static inline int bfdec_resize(bfdec_t *r, limb_t len)
{
#include "cutils.h"
#include "quickjs-libc.h"
-/* enable bignums */
-#define CONFIG_BIGNUM
-
extern const uint8_t qjsc_repl[];
extern const uint32_t qjsc_repl_size;
#ifdef CONFIG_BIGNUM
void help(void)
{
printf("QuickJS version " CONFIG_VERSION "\n"
- "usage: " PROG_NAME " [options] [file]\n"
+ "usage: " PROG_NAME " [options] [file [args]]\n"
"-h --help list options\n"
"-e --eval EXPR evaluate EXPR\n"
"-i --interactive go to interactive mode\n"
"-m --module load as ES6 module (default=autodetect)\n"
" --script load as ES6 script (default=autodetect)\n"
+ "-I --include file include an additional file\n"
" --std make 'std' and 'os' available to the loaded script\n"
#ifdef CONFIG_BIGNUM
" --bignum enable the bignum extensions (BigFloat, BigDecimal)\n"
int load_std = 0;
int dump_unhandled_promise_rejection = 0;
size_t memory_limit = 0;
+ char *include_list[32];
+ int i, include_count = 0;
#ifdef CONFIG_BIGNUM
int load_jscalc, bignum_ext = 0;
#endif
fprintf(stderr, "qjs: missing expression for -e\n");
exit(2);
}
+ if (opt == 'I' || !strcmp(longopt, "include")) {
+ if (optind >= argc) {
+ fprintf(stderr, "expecting filename");
+ exit(1);
+ }
+ if (include_count >= countof(include_list)) {
+ fprintf(stderr, "too many included files");
+ exit(1);
+ }
+ include_list[include_count++] = argv[optind++];
+ continue;
+ }
if (opt == 'i' || !strcmp(longopt, "interactive")) {
interactive++;
continue;
if (bignum_ext || load_jscalc) {
JS_AddIntrinsicBigFloat(ctx);
JS_AddIntrinsicBigDecimal(ctx);
+ JS_AddIntrinsicOperators(ctx);
JS_EnableBignumExt(ctx, TRUE);
}
#endif
eval_buf(ctx, str, strlen(str), "<input>", JS_EVAL_TYPE_MODULE);
}
+ for(i = 0; i < include_count; i++) {
+ if (eval_file(ctx, include_list[i], module))
+ goto fail;
+ }
+
if (expr) {
if (eval_buf(ctx, expr, strlen(expr), "<cmdline>", 0))
goto fail;
#include "cutils.h"
#include "quickjs-libc.h"
-/* enable bignums */
-#define CONFIG_BIGNUM
-
typedef struct {
char *name;
char *short_name;
{ "promise", "Promise" },
#define FE_MODULE_LOADER 9
{ "module-loader", NULL },
+#ifdef CONFIG_BIGNUM
{ "bigint", "BigInt" },
+#endif
};
void namelist_add(namelist_t *lp, const char *name, const char *short_name,
FILE *fo;
JSRuntime *rt;
JSContext *ctx;
- BOOL use_lto, bignum_ext;
+ BOOL use_lto;
int module;
OutputTypeEnum output_type;
+#ifdef CONFIG_BIGNUM
+ BOOL bignum_ext = FALSE;
+#endif
out_filename = NULL;
output_type = OUTPUT_EXECUTABLE;
byte_swap = FALSE;
verbose = 0;
use_lto = FALSE;
- bignum_ext = FALSE;
/* add system modules */
namelist_add(&cmodule_list, "std", "std", 0);
}
if (i == countof(feature_list))
goto bad_feature;
- } else if (!strcmp(optarg, "bignum")) {
+ } else
+#ifdef CONFIG_BIGNUM
+ if (!strcmp(optarg, "bignum")) {
bignum_ext = TRUE;
- } else {
+ } else
+#endif
+ {
bad_feature:
fprintf(stderr, "unsupported feature: %s\n", optarg);
exit(1);
if (bignum_ext) {
JS_AddIntrinsicBigFloat(ctx);
JS_AddIntrinsicBigDecimal(ctx);
+ JS_AddIntrinsicOperators(ctx);
JS_EnableBignumExt(ctx, TRUE);
}
#endif
feature_list[i].init_name);
}
}
+#ifdef CONFIG_BIGNUM
if (bignum_ext) {
fprintf(fo,
" JS_AddIntrinsicBigFloat(ctx);\n"
" JS_AddIntrinsicBigDecimal(ctx);\n"
+ " JS_AddIntrinsicOperators(ctx);\n"
" JS_EnableBignumExt(ctx, 1);\n");
}
-
+#endif
fprintf(fo, " js_std_add_helpers(ctx, argc, argv);\n");
for(i = 0; i < init_module_list.count; i++) {
/*
* QuickJS Javascript Calculator
*
- * Copyright (c) 2017-2018 Fabrice Bellard
+ * Copyright (c) 2017-2020 Fabrice Bellard
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunction, Series, Matrix;
(function(global) {
- /* the types index are used to dispatch the operator functions */
- var OT_INT = 0;
- var OT_FRACTION = 10;
- var OT_FLOAT64 = 19;
- var OT_FLOAT = 20;
- var OT_COMPLEX = 30;
- var OT_MOD = 40;
- var OT_POLY = 50;
- var OT_POLYMOD = 55;
- var OT_RFUNC = 60;
- var OT_SERIES = 70;
- var OT_ARRAY = 80;
-
global.Integer = global.BigInt;
+ global.Float = global.BigFloat;
global.algebraicMode = true;
/* add non enumerable properties */
Object.defineProperty(obj, prop, desc);
}
}
+
+ /* same as proto[Symbol.operatorSet] = Operators.create(..op_list)
+ but allow shortcuts: left: [], right: [] or both
+ */
+ function operators_set(proto, ...op_list)
+ {
+ var new_op_list, i, a, j, b, k, obj, tab;
+ var fields = [ "left", "right" ];
+ new_op_list = [];
+ for(i = 0; i < op_list.length; i++) {
+ a = op_list[i];
+ if (a.left || a.right) {
+ tab = [ a.left, a.right ];
+ delete a.left;
+ delete a.right;
+ for(k = 0; k < 2; k++) {
+ obj = tab[k];
+ if (obj) {
+ if (!Array.isArray(obj)) {
+ obj = [ obj ];
+ }
+ for(j = 0; j < obj.length; j++) {
+ b = {};
+ Object.assign(b, a);
+ b[fields[k]] = obj[j];
+ new_op_list.push(b);
+ }
+ }
+ }
+ } else {
+ new_op_list.push(a);
+ }
+ }
+ proto[Symbol.operatorSet] =
+ Operators.create.call(null, ...new_op_list);
+ }
/* Integer */
var d, r, s, i, j, a;
d = n - 1;
s = 0;
- while (d & 1) {
+ while ((d & 1) == 0) {
d >>= 1;
s++;
}
- t = Math.min(t, small_primes.length);
+ if (small_primes.length < t)
+ t = small_primes.length;
loop: for(j = 0; j < t; j++) {
a = small_primes[j];
r = Integer.pmod(a, d, n);
return fact_rec(a, i) * fact_rec(i + 1, b);
}
}
-
+
+ /* math mode specific quirk to overload the integer division and power */
+ Operators.updateBigIntOperators(
+ {
+ "/"(a, b) {
+ if (algebraicMode) {
+ return Fraction.toFraction(a, b);
+ } else {
+ return Float(a) / Float(b);
+ }
+ },
+ "**"(a, b) {
+ if (algebraicMode) {
+ return generic_pow(a, b);
+ } else {
+ return Float(a) ** Float(b);
+ }
+ }
+ });
+
add_props(Integer, {
isInteger(a) {
- return typeof a === "bigint";
- },
- [Symbol.operatorOrder]: OT_INT,
- [Symbol.operatorDiv](a, b) {
- if (algebraicMode) {
- return Fraction.toFraction(a, b);
- } else {
- return Float(a) / Float(b);
- }
- },
- [Symbol.operatorPow](a, b) {
- if (algebraicMode) {
- return generic_pow(a, b);
- } else {
- return Float(a) ** Float(b);
- }
+ /* integers are represented either as bigint or as number */
+ return typeof a === "bigint" ||
+ (typeof a === "number" && Number.isSafeInteger(a));
},
gcd(a, b) {
var r;
return this * this;
},
abs() {
- return Math.abs(this);
+ var v = this;
+ if (v < 0)
+ v = -v;
+ return v;
},
conj() {
return this;
return obj;
}
+ function fraction_add(a, b) {
+ a = Fraction(a);
+ b = Fraction(b);
+ return Fraction.toFraction(a.num * b.den + a.den * b.num, a.den * b.den);
+ }
+ function fraction_sub(a, b) {
+ a = Fraction(a);
+ b = Fraction(b);
+ return Fraction.toFraction(a.num * b.den - a.den * b.num, a.den * b.den);
+ }
+ function fraction_mul(a, b) {
+ a = Fraction(a);
+ b = Fraction(b);
+ return Fraction.toFraction(a.num * b.num, a.den * b.den);
+ }
+ function fraction_div(a, b) {
+ a = Fraction(a);
+ b = Fraction(b);
+ return Fraction.toFraction(a.num * b.den, a.den * b.num);
+ }
+ function fraction_mod(a, b) {
+ var a1 = Fraction(a);
+ var b1 = Fraction(b);
+ return a - Integer.ediv(a1.num * b1.den, a1.den * b1.num) * b;
+ }
+ function fraction_eq(a, b) {
+ a = Fraction(a);
+ b = Fraction(b);
+ /* we assume the fractions are normalized */
+ return (a.num == b.num && a.den == b.den);
+ }
+ function fraction_lt(a, b) {
+ a = Fraction(a);
+ b = Fraction(b);
+ return (a.num * b.den < b.num * a.den);
+ }
+
+ /* operators are needed for fractions */
+ function float_add(a, b) {
+ return Float(a) + Float(b);
+ }
+ function float_sub(a, b) {
+ return Float(a) - Float(b);
+ }
+ function float_mul(a, b) {
+ return Float(a) * Float(b);
+ }
+ function float_div(a, b) {
+ return Float(a) / Float(b);
+ }
+ function float_mod(a, b) {
+ return Float(a) % Float(b);
+ }
+ function float_pow(a, b) {
+ return Float(a) ** Float(b);
+ }
+ function float_eq(a, b) {
+ /* XXX: may be better to use infinite precision for the comparison */
+ return Float(a) === Float(b);
+ }
+ function float_lt(a, b) {
+ a = Float(a);
+ b = Float(b);
+ /* XXX: may be better to use infinite precision for the comparison */
+ if (Float.isNaN(a) || Float.isNaN(b))
+ return undefined;
+ else
+ return a < b;
+ }
+
+ operators_set(Fraction.prototype,
+ {
+ "+": fraction_add,
+ "-": fraction_sub,
+ "*": fraction_mul,
+ "/": fraction_div,
+ "%": fraction_mod,
+ "**": generic_pow,
+ "==": fraction_eq,
+ "<": fraction_lt,
+ "pos"(a) {
+ return a;
+ },
+ "neg"(a) {
+ return Fraction(-a.num, a.den);
+ },
+ },
+ {
+ left: [Number, BigInt],
+ right: [Number, BigInt],
+ "+": fraction_add,
+ "-": fraction_sub,
+ "*": fraction_mul,
+ "/": fraction_div,
+ "%": fraction_mod,
+ "**": generic_pow,
+ "==": fraction_eq,
+ "<": fraction_lt,
+ },
+ {
+ left: Float,
+ right: Float,
+ "+": float_add,
+ "-": float_sub,
+ "*": float_mul,
+ "/": float_div,
+ "%": float_mod,
+ "**": float_pow,
+ "==": float_eq,
+ "<": float_lt,
+ });
+
add_props(Fraction, {
- [Symbol.operatorOrder]: OT_FRACTION,
/* (internal use) simplify 'a' to an integer when possible */
toFraction(a, b) {
var r = Fraction(a, b);
else
return r;
},
-
- [Symbol.operatorAdd](a, b) {
- a = Fraction(a);
- b = Fraction(b);
- return Fraction.toFraction(a.num * b.den + a.den * b.num, a.den * b.den);
- },
- [Symbol.operatorSub](a, b) {
- a = Fraction(a);
- b = Fraction(b);
- return Fraction.toFraction(a.num * b.den - a.den * b.num, a.den * b.den);
- },
- [Symbol.operatorMul](a, b) {
- a = Fraction(a);
- b = Fraction(b);
- return Fraction.toFraction(a.num * b.num, a.den * b.den);
- },
- [Symbol.operatorDiv](a, b) {
- a = Fraction(a);
- b = Fraction(b);
- return Fraction.toFraction(a.num * b.den, a.den * b.num);
- },
- [Symbol.operatorMathMod](a, b) {
- var a1 = Fraction(a);
- var b1 = Fraction(b);
- return a - Integer.ediv(a1.num * b1.den, a1.den * b1.num) * b;
- },
- [Symbol.operatorMod](a, b) {
- var a1 = Fraction(a);
- var b1 = Fraction(b);
- return a - Integer.tdiv(a1.num * b1.den, a1.den * b1.num) * b;
- },
- [Symbol.operatorPow]: generic_pow,
- [Symbol.operatorCmpEQ](a, b) {
- a = Fraction(a);
- b = Fraction(b);
- /* we assume the fractions are normalized */
- return (a.num == b.num && a.den == b.den);
- },
- [Symbol.operatorCmpLT](a, b) {
- a = Fraction(a);
- b = Fraction(b);
- return (a.num * b.den < b.num * a.den);
- },
- [Symbol.operatorCmpLE](a, b) {
- a = Fraction(a);
- b = Fraction(b);
- return (a.num * b.den <= b.num * a.den);
- },
});
add_props(Fraction.prototype, {
[Symbol.toPrimitive](hint) {
- if (hint === "integer") {
- return Integer.tdiv(this.num, this.den);
- } else if (hint === "string") {
+ if (hint === "string") {
return this.toString();
} else {
return Float(this.num) / this.den;
}
},
- [Symbol.operatorPlus]() {
- return this;
- },
- [Symbol.operatorNeg]() {
- return Fraction(-this.num, this.den);
- },
inverse() {
return Fraction(this.den, this.num);
},
},
abs() {
if (this.num < 0)
- return this[Symbol.operatorNeg]();
+ return -this;
else
return this;
},
/* Number (Float64) */
- add_props(Number, {
- [Symbol.operatorOrder]: OT_FLOAT64,
- /* operators are needed for fractions */
- [Symbol.operatorAdd](a, b) {
- return Number(a) + Number(b);
- },
- [Symbol.operatorSub](a, b) {
- return Number(a) - Number(b);
- },
- [Symbol.operatorMul](a, b) {
- return Number(a) * Number(b);
- },
- [Symbol.operatorDiv](a, b) {
- return Number(a) / Number(b);
- },
- [Symbol.operatorPow](a, b) {
- return Number(a) ** Number(b);
- },
- });
-
add_props(Number.prototype, {
inverse() {
- return 1.0 / this;
+ return 1 / this;
},
norm2() {
return this * this;
/* Float */
- global.Float = global.BigFloat;
-
var const_tab = [];
/* we cache the constants for small precisions */
get SQRT2() { return get_const(7); },
});
- add_props(Float, {
- [Symbol.operatorOrder]: OT_FLOAT,
- /* operators are needed for fractions */
- [Symbol.operatorAdd](a, b) {
- return Float(a) + Float(b);
- },
- [Symbol.operatorSub](a, b) {
- return Float(a) - Float(b);
- },
- [Symbol.operatorMul](a, b) {
- return Float(a) * Float(b);
- },
- [Symbol.operatorDiv](a, b) {
- return Float(a) / Float(b);
- },
- [Symbol.operatorPow](a, b) {
- return Float(a) ** Float(b);
- },
- });
-
add_props(Float.prototype, {
inverse() {
return 1.0 / this;
return this * this;
},
abs() {
- return Math.abs(this);
+ return Float.abs(this);
},
conj() {
return this;
return obj;
}
+
+ function complex_add(a, b) {
+ a = Complex(a);
+ b = Complex(b);
+ return Complex.toComplex(a.re + b.re, a.im + b.im);
+ }
+ function complex_sub(a, b) {
+ a = Complex(a);
+ b = Complex(b);
+ return Complex.toComplex(a.re - b.re, a.im - b.im);
+ }
+ function complex_mul(a, b) {
+ a = Complex(a);
+ b = Complex(b);
+ return Complex.toComplex(a.re * b.re - a.im * b.im,
+ a.re * b.im + a.im * b.re);
+ }
+ function complex_div(a, b) {
+ a = Complex(a);
+ b = Complex(b);
+ return a * b.inverse();
+ }
+ function complex_eq(a, b) {
+ a = Complex(a);
+ b = Complex(b);
+ return a.re == b.re && a.im == b.im;
+ }
+
+ operators_set(Complex.prototype,
+ {
+ "+": complex_add,
+ "-": complex_sub,
+ "*": complex_mul,
+ "/": complex_div,
+ "**": generic_pow,
+ "==": complex_eq,
+ "pos"(a) {
+ return a;
+ },
+ "neg"(a) {
+ return Complex(-a.re, -a.im);
+ }
+ },
+ {
+ left: [Number, BigInt, Float, Fraction],
+ right: [Number, BigInt, Float, Fraction],
+ "+": complex_add,
+ "-": complex_sub,
+ "*": complex_mul,
+ "/": complex_div,
+ "**": generic_pow,
+ "==": complex_eq,
+ });
+
add_props(Complex, {
- [Symbol.operatorOrder]: OT_COMPLEX,
/* simplify to real number when possible */
toComplex(re, im) {
if (algebraicMode && im == 0)
else
return Complex(re, im);
},
-
- [Symbol.operatorAdd](a, b) {
- a = Complex(a);
- b = Complex(b);
- return Complex.toComplex(a.re + b.re, a.im + b.im);
- },
- [Symbol.operatorSub](a, b) {
- a = Complex(a);
- b = Complex(b);
- return Complex.toComplex(a.re - b.re, a.im - b.im);
- },
- [Symbol.operatorMul](a, b) {
- a = Complex(a);
- b = Complex(b);
- return Complex.toComplex(a.re * b.re - a.im * b.im,
- a.re * b.im + a.im * b.re);
- },
- [Symbol.operatorDiv](a, b) {
- a = Complex(a);
- b = Complex(b);
- return a * b.inverse();
- },
- [Symbol.operatorPow]: generic_pow,
- [Symbol.operatorCmpEQ](a, b) {
- a = Complex(a);
- b = Complex(b);
- return a.re == b.re && a.im == b.im;
- }
});
add_props(Complex.prototype, {
- [Symbol.operatorPlus]() {
- return this;
- },
- [Symbol.operatorNeg]() {
- return Complex(-this.re, -this.im);
- },
inverse() {
var c = this.norm2();
return Complex(this.re / c, -this.im / c);
obj.mod = m;
return obj;
};
+
+ function mod_add(a, b) {
+ if (!(a instanceof Mod)) {
+ return Mod(a + b.res, b.mod);
+ } else if (!(b instanceof Mod)) {
+ return Mod(a.res + b, a.mod);
+ } else {
+ if (a.mod != b.mod)
+ throw TypeError("different modulo for binary operator");
+ return Mod(a.res + b.res, a.mod);
+ }
+ }
+ function mod_sub(a, b) {
+ if (!(a instanceof Mod)) {
+ return Mod(a - b.res, b.mod);
+ } else if (!(b instanceof Mod)) {
+ return Mod(a.res - b, a.mod);
+ } else {
+ if (a.mod != b.mod)
+ throw TypeError("different modulo for binary operator");
+ return Mod(a.res - b.res, a.mod);
+ }
+ }
+ function mod_mul(a, b) {
+ if (!(a instanceof Mod)) {
+ return Mod(a * b.res, b.mod);
+ } else if (!(b instanceof Mod)) {
+ return Mod(a.res * b, a.mod);
+ } else {
+ if (a.mod != b.mod)
+ throw TypeError("different modulo for binary operator");
+ return Mod(a.res * b.res, a.mod);
+ }
+ }
+ function mod_div(a, b) {
+ if (!(b instanceof Mod))
+ b = Mod(b, a.mod);
+ return mod_mul(a, b.inverse());
+ }
+ function mod_eq(a, b) {
+ return (a.mod == b.mod && a.res == b.res);
+ }
- add_props(Mod.prototype, {
- [Symbol.operatorPlus]() {
- return this;
- },
- [Symbol.operatorNeg]() {
- return Mod(-this.res, this.mod);
+ operators_set(Mod.prototype,
+ {
+ "+": mod_add,
+ "-": mod_sub,
+ "*": mod_mul,
+ "/": mod_div,
+ "**": generic_pow,
+ "==": mod_eq,
+ "pos"(a) {
+ return a;
+ },
+ "neg"(a) {
+ return Mod(-a.res, a.mod);
+ }
},
+ {
+ left: [Number, BigInt, Float, Fraction],
+ right: [Number, BigInt, Float, Fraction],
+ "+": mod_add,
+ "-": mod_sub,
+ "*": mod_mul,
+ "/": mod_div,
+ "**": generic_pow,
+ });
+
+ add_props(Mod.prototype, {
inverse() {
var a = this, m = a.mod;
if (Integer.isInteger(m)) {
},
});
- add_props(Mod, {
- [Symbol.operatorOrder]: OT_MOD,
- [Symbol.operatorAdd](a, b) {
- if (!(a instanceof Mod)) {
- return Mod(a + b.res, b.mod);
- } else if (!(b instanceof Mod)) {
- return Mod(a.res + b, a.mod);
- } else {
- if (a.mod != b.mod)
- throw TypeError("different modulo for binary operator");
- return Mod(a.res + b.res, a.mod);
- }
- },
- [Symbol.operatorSub](a, b) {
- if (!(a instanceof Mod)) {
- return Mod(a - b.res, b.mod);
- } else if (!(b instanceof Mod)) {
- return Mod(a.res - b, a.mod);
- } else {
- if (a.mod != b.mod)
- throw TypeError("different modulo for binary operator");
- return Mod(a.res - b.res, a.mod);
- }
- },
- [Symbol.operatorMul](a, b) {
- if (!(a instanceof Mod)) {
- return Mod(a * b.res, b.mod);
- } else if (!(b instanceof Mod)) {
- return Mod(a.res * b, a.mod);
- } else {
- if (a.mod != b.mod)
- throw TypeError("different modulo for binary operator");
- return Mod(a.res * b.res, a.mod);
- }
- },
- [Symbol.operatorDiv](a, b) {
- if (!(b instanceof Mod))
- b = Mod(b, a.mod);
- return Mod[Symbol.operatorMul](a, b.inverse());
- },
- [Symbol.operatorPow]: generic_pow,
- [Symbol.operatorCmpEQ](a, b) {
- if (!(a instanceof Mod) ||
- !(b instanceof Mod))
- return false;
- return (a.mod == b.mod && a.res == b.res);
- }
- });
-
/* Polynomial */
+ function polynomial_is_scalar(a)
+ {
+ if (typeof a === "number" ||
+ typeof a === "bigint" ||
+ typeof a === "bigfloat")
+ return true;
+ if (a instanceof Fraction ||
+ a instanceof Complex ||
+ a instanceof Mod)
+ return true;
+ return false;
+ }
+
Polynomial = function Polynomial(a)
{
if (new.target)
a = [ 0 ];
Object.setPrototypeOf(a, Polynomial.prototype);
return a.trim();
- } else if (a.constructor[Symbol.operatorOrder] <= OT_MOD) {
+ } else if (polynomial_is_scalar(a)) {
a = [a];
Object.setPrototypeOf(a, Polynomial.prototype);
return a;
a.length = i;
return a;
},
- [Symbol.operatorPlus]() {
- return this;
- },
- [Symbol.operatorNeg]() {
- var r, i, n, a;
- a = this;
- n = a.length;
- r = [];
- for(i = 0; i < n; i++)
- r[i] = -a[i];
- return Polynomial(r);
- },
conj() {
var r, i, n, a;
a = this;
},
});
- add_props(Polynomial, {
- [Symbol.operatorOrder]: OT_POLY,
- [Symbol.operatorAdd](a, b) {
- var tmp, r, i, n1, n2;
- a = Polynomial(a);
- b = Polynomial(b);
- if (a.length < b.length) {
- tmp = a;
- a = b;
- b = tmp;
- }
- n1 = b.length;
- n2 = a.length;
- r = [];
- for(i = 0; i < n1; i++)
- r[i] = a[i] + b[i];
- for(i = n1; i < n2; i++)
- r[i] = a[i];
- return Polynomial(r);
- },
- [Symbol.operatorSub](a, b) {
- return Polynomial[Symbol.operatorAdd](a, -b);
- },
- [Symbol.operatorMul](a, b) {
- var i, j, n1, n2, n, r;
- a = Polynomial(a);
- b = Polynomial(b);
- n1 = a.length;
- n2 = b.length;
- n = n1 + n2 - 1;
- r = [];
- for(i = 0; i < n; i++)
- r[i] = 0;
- for(i = 0; i < n1; i++) {
- for(j = 0; j < n2; j++) {
- r[i + j] += a[i] * b[j];
- }
+
+ function polynomial_add(a, b) {
+ var tmp, r, i, n1, n2;
+ a = Polynomial(a);
+ b = Polynomial(b);
+ if (a.length < b.length) {
+ tmp = a;
+ a = b;
+ b = tmp;
+ }
+ n1 = b.length;
+ n2 = a.length;
+ r = [];
+ for(i = 0; i < n1; i++)
+ r[i] = a[i] + b[i];
+ for(i = n1; i < n2; i++)
+ r[i] = a[i];
+ return Polynomial(r);
+ }
+ function polynomial_sub(a, b) {
+ return polynomial_add(a, -b);
+ }
+ function polynomial_mul(a, b) {
+ var i, j, n1, n2, n, r;
+ a = Polynomial(a);
+ b = Polynomial(b);
+ n1 = a.length;
+ n2 = b.length;
+ n = n1 + n2 - 1;
+ r = [];
+ for(i = 0; i < n; i++)
+ r[i] = 0;
+ for(i = 0; i < n1; i++) {
+ for(j = 0; j < n2; j++) {
+ r[i + j] += a[i] * b[j];
}
- return Polynomial(r);
- },
- [Symbol.operatorDiv](a, b) {
- if (b.constructor[Symbol.operatorOrder] <= OT_COMPLEX)
- return a * (1 / b);
- else
- return RationalFunction(Polynomial(a),
- Polynomial(b));
- },
- [Symbol.operatorPow]: generic_pow,
- [Symbol.operatorMathMod](a, b) {
- return Polynomial.divrem(a, b)[1];
- },
- [Symbol.operatorMod](a, b) {
- return Polynomial.divrem(a, b)[1];
- },
- [Symbol.operatorCmpEQ](a, b) {
- var n, i;
- if (!(a instanceof Polynomial) ||
- !(b instanceof Polynomial))
- return false;
- n = a.length;
- if (n != b.length)
+ }
+ return Polynomial(r);
+ }
+ function polynomial_div_scalar(a, b) {
+ return a * (1 / b);
+ }
+ function polynomial_div(a, b)
+ {
+ return RationalFunction(Polynomial(a),
+ Polynomial(b));
+ }
+ function polynomial_mod(a, b) {
+ return Polynomial.divrem(a, b)[1];
+ }
+ function polynomial_eq(a, b) {
+ var n, i;
+ n = a.length;
+ if (n != b.length)
+ return false;
+ for(i = 0; i < n; i++) {
+ if (a[i] != b[i])
return false;
- for(i = 0; i < n; i++) {
- if (a[i] != b[i])
- return false;
- }
- return true;
- },
+ }
+ return true;
+ }
+
+ operators_set(Polynomial.prototype,
+ {
+ "+": polynomial_add,
+ "-": polynomial_sub,
+ "*": polynomial_mul,
+ "/": polynomial_div,
+ "**": generic_pow,
+ "==": polynomial_eq,
+ "pos"(a) {
+ return a;
+ },
+ "neg"(a) {
+ var r, i, n, a;
+ n = a.length;
+ r = [];
+ for(i = 0; i < n; i++)
+ r[i] = -a[i];
+ return Polynomial(r);
+ },
+ },
+ {
+ left: [Number, BigInt, Float, Fraction, Complex, Mod],
+ "+": polynomial_add,
+ "-": polynomial_sub,
+ "*": polynomial_mul,
+ "/": polynomial_div,
+ "**": generic_pow, /* XXX: only for integer */
+ },
+ {
+ right: [Number, BigInt, Float, Fraction, Complex, Mod],
+ "+": polynomial_add,
+ "-": polynomial_sub,
+ "*": polynomial_mul,
+ "/": polynomial_div_scalar,
+ "**": generic_pow, /* XXX: only for integer */
+ });
+
+ add_props(Polynomial, {
divrem(a, b) {
var n1, n2, i, j, q, r, n, c;
if (b.deg() < 0)
return obj;
};
+ function polymod_add(a, b) {
+ if (!(a instanceof PolyMod)) {
+ return PolyMod(a + b.res, b.mod);
+ } else if (!(b instanceof PolyMod)) {
+ return PolyMod(a.res + b, a.mod);
+ } else {
+ if (a.mod != b.mod)
+ throw TypeError("different modulo for binary operator");
+ return PolyMod(a.res + b.res, a.mod);
+ }
+ }
+ function polymod_sub(a, b) {
+ return polymod_add(a, -b);
+ }
+ function polymod_mul(a, b) {
+ if (!(a instanceof PolyMod)) {
+ return PolyMod(a * b.res, b.mod);
+ } else if (!(b instanceof PolyMod)) {
+ return PolyMod(a.res * b, a.mod);
+ } else {
+ if (a.mod != b.mod)
+ throw TypeError("different modulo for binary operator");
+ return PolyMod(a.res * b.res, a.mod);
+ }
+ }
+ function polymod_div(a, b) {
+ if (!(b instanceof PolyMod))
+ b = PolyMod(b, a.mod);
+ return polymod_mul(a, b.inverse());
+ }
+ function polymod_eq(a, b) {
+ return (a.mod == b.mod && a.res == b.res);
+ }
+
+ operators_set(PolyMod.prototype,
+ {
+ "+": polymod_add,
+ "-": polymod_sub,
+ "*": polymod_mul,
+ "/": polymod_div,
+ "**": generic_pow,
+ "==": polymod_eq,
+ "pos"(a) {
+ return a;
+ },
+ "neg"(a) {
+ return PolyMod(-a.res, a.mod);
+ },
+ },
+ {
+ left: [Number, BigInt, Float, Fraction, Complex, Mod, Polynomial],
+ right: [Number, BigInt, Float, Fraction, Complex, Mod, Polynomial],
+ "+": polymod_add,
+ "-": polymod_sub,
+ "*": polymod_mul,
+ "/": polymod_div,
+ "**": generic_pow, /* XXX: only for integer */
+ });
+
add_props(PolyMod.prototype, {
- [Symbol.operatorPlus]() {
- return this;
- },
- [Symbol.operatorNeg]() {
- return PolyMod(-this.res, this.mod);
- },
inverse() {
var a = this, m = a.mod;
if (m instanceof Polynomial) {
},
});
- add_props(PolyMod, {
- [Symbol.operatorOrder]: OT_POLYMOD,
- [Symbol.operatorAdd](a, b) {
- if (!(a instanceof PolyMod)) {
- return PolyMod(a + b.res, b.mod);
- } else if (!(b instanceof PolyMod)) {
- return PolyMod(a.res + b, a.mod);
- } else {
- if (a.mod != b.mod)
- throw TypeError("different modulo for binary operator");
- return PolyMod(a.res + b.res, a.mod);
- }
- },
- [Symbol.operatorSub](a, b) {
- if (!(a instanceof PolyMod)) {
- return PolyMod(a - b.res, b.mod);
- } else if (!(b instanceof PolyMod)) {
- return PolyMod(a.res - b, a.mod);
- } else {
- if (a.mod != b.mod)
- throw TypeError("different modulo for binary operator");
- return PolyMod(a.res - b.res, a.mod);
- }
- },
- [Symbol.operatorMul](a, b) {
- if (!(a instanceof PolyMod)) {
- return PolyMod(a * b.res, b.mod);
- } else if (!(b instanceof PolyMod)) {
- return PolyMod(a.res * b, a.mod);
- } else {
- if (a.mod != b.mod)
- throw TypeError("different modulo for binary operator");
- return PolyMod(a.res * b.res, a.mod);
- }
- },
- [Symbol.operatorDiv](a, b) {
- if (!(b instanceof PolyMod))
- b = PolyMod(b, a.mod);
- return PolyMod[Symbol.operatorMul](a, b.inverse());
- },
- [Symbol.operatorPow]: generic_pow,
- [Symbol.operatorCmpEQ](a, b) {
- if (!(a instanceof PolyMod) ||
- !(b instanceof PolyMod))
- return false;
- return (a.mod == b.mod && a.res == b.res);
- }
- });
-
/* Rational function */
RationalFunction = function RationalFunction(a, b)
}
add_props(RationalFunction.prototype, {
- [Symbol.operatorPlus]() {
- return this;
- },
- [Symbol.operatorNeg]() {
- return RationalFunction(-this.num, this.den);
- },
inverse() {
return RationalFunction(this.den, this.num);
},
},
});
+ function ratfunc_add(a, b) {
+ a = RationalFunction.toRationalFunction(a);
+ b = RationalFunction.toRationalFunction(b);
+ return RationalFunction(a.num * b.den + a.den * b.num, a.den * b.den);
+ }
+ function ratfunc_sub(a, b) {
+ a = RationalFunction.toRationalFunction(a);
+ b = RationalFunction.toRationalFunction(b);
+ return RationalFunction(a.num * b.den - a.den * b.num, a.den * b.den);
+ }
+ function ratfunc_mul(a, b) {
+ a = RationalFunction.toRationalFunction(a);
+ b = RationalFunction.toRationalFunction(b);
+ return RationalFunction(a.num * b.num, a.den * b.den);
+ }
+ function ratfunc_div(a, b) {
+ a = RationalFunction.toRationalFunction(a);
+ b = RationalFunction.toRationalFunction(b);
+ return RationalFunction(a.num * b.den, a.den * b.num);
+ }
+ function ratfunc_eq(a, b) {
+ a = RationalFunction.toRationalFunction(a);
+ b = RationalFunction.toRationalFunction(b);
+ /* we assume the fractions are normalized */
+ return (a.num == b.num && a.den == b.den);
+ }
+
+ operators_set(RationalFunction.prototype,
+ {
+ "+": ratfunc_add,
+ "-": ratfunc_sub,
+ "*": ratfunc_mul,
+ "/": ratfunc_div,
+ "**": generic_pow,
+ "==": ratfunc_eq,
+ "pos"(a) {
+ return a;
+ },
+ "neg"(a) {
+ return RationalFunction(-this.num, this.den);
+ },
+ },
+ {
+ left: [Number, BigInt, Float, Fraction, Complex, Mod, Polynomial],
+ right: [Number, BigInt, Float, Fraction, Complex, Mod, Polynomial],
+ "+": ratfunc_add,
+ "-": ratfunc_sub,
+ "*": ratfunc_mul,
+ "/": ratfunc_div,
+ "**": generic_pow, /* should only be used with integers */
+ });
+
add_props(RationalFunction, {
- [Symbol.operatorOrder]: OT_RFUNC,
/* This function always return a RationalFunction object even
if it could simplified to a polynomial, so it is not
equivalent to RationalFunction(a) */
return obj;
}
},
- [Symbol.operatorAdd](a, b) {
- a = RationalFunction.toRationalFunction(a);
- b = RationalFunction.toRationalFunction(b);
- return RationalFunction(a.num * b.den + a.den * b.num, a.den * b.den);
- },
- [Symbol.operatorSub](a, b) {
- a = RationalFunction.toRationalFunction(a);
- b = RationalFunction.toRationalFunction(b);
- return RationalFunction(a.num * b.den - a.den * b.num, a.den * b.den);
- },
- [Symbol.operatorMul](a, b) {
- a = RationalFunction.toRationalFunction(a);
- b = RationalFunction.toRationalFunction(b);
- return RationalFunction(a.num * b.num, a.den * b.den);
- },
- [Symbol.operatorDiv](a, b) {
- a = RationalFunction.toRationalFunction(a);
- b = RationalFunction.toRationalFunction(b);
- return RationalFunction(a.num * b.den, a.den * b.num);
- },
- [Symbol.operatorPow]: generic_pow,
- [Symbol.operatorCmpEQ](a, b) {
- a = RationalFunction.toRationalFunction(a);
- b = RationalFunction.toRationalFunction(b);
- /* we assume the fractions are normalized */
- return (a.num == b.num && a.den == b.den);
- },
});
/* Power series */
}
return n;
};
+
+ function series_is_scalar_or_polynomial(a)
+ {
+ return polynomial_is_scalar(a) ||
+ (a instanceof Polynomial);
+ }
/* n is the maximum number of terms if 'a' is not a serie */
Series = function Series(a, n) {
if (a instanceof Series) {
return a;
- } else if (a.constructor[Symbol.operatorOrder] <= OT_POLY) {
+ } else if (series_is_scalar_or_polynomial(a)) {
if (n <= 0) {
/* XXX: should still use the polynomial degree */
return Series.zero(0, 0);
}
};
- add_props(Series.prototype, {
- [Symbol.operatorPlus]() {
- return this;
- },
- [Symbol.operatorNeg]() {
- var obj, n, i;
- n = this.length;
- obj = Series.zero(this.length, this.emin);
- for(i = 0; i < n; i++) {
- obj[i] = -this[i];
+ function series_add(v1, v2) {
+ var tmp, d, emin, n, r, i, j, v2_emin, c1, c2;
+ if (!(v1 instanceof Series)) {
+ tmp = v1;
+ v1 = v2;
+ v2 = tmp;
+ }
+ d = v1.emin + v1.length;
+ if (series_is_scalar_or_polynomial(v2)) {
+ v2 = Polynomial(v2);
+ if (d <= 0)
+ return v1;
+ v2_emin = 0;
+ } else if (v2 instanceof RationalFunction) {
+ /* compute the emin of the rational fonction */
+ i = get_emin(v2.num) - get_emin(v2.den);
+ if (d <= i)
+ return v1;
+ /* compute the serie with the required terms */
+ v2 = Series(v2, d - i);
+ v2_emin = v2.emin;
+ } else {
+ v2_emin = v2.emin;
+ d = Math.min(d, v2_emin + v2.length);
+ }
+ emin = Math.min(v1.emin, v2_emin);
+ n = d - emin;
+ r = Series.zero(n, emin);
+ /* XXX: slow */
+ for(i = emin; i < d; i++) {
+ j = i - v1.emin;
+ if (j >= 0 && j < v1.length)
+ c1 = v1[j];
+ else
+ c1 = 0;
+ j = i - v2_emin;
+ if (j >= 0 && j < v2.length)
+ c2 = v2[j];
+ else
+ c2 = 0;
+ r[i - emin] = c1 + c2;
+ }
+ return r.trim();
+ }
+ function series_sub(a, b) {
+ return series_add(a, -b);
+ }
+ function series_mul(v1, v2) {
+ var n, i, j, r, n, emin, n1, n2, k;
+ if (!(v1 instanceof Series))
+ v1 = Series(v1, v2.length);
+ else if (!(v2 instanceof Series))
+ v2 = Series(v2, v1.length);
+ emin = v1.emin + v2.emin;
+ n = Math.min(v1.length, v2.length);
+ n1 = v1.length;
+ n2 = v2.length;
+ r = Series.zero(n, emin);
+ for(i = 0; i < n1; i++) {
+ k = Math.min(n2, n - i);
+ for(j = 0; j < k; j++) {
+ r[i + j] += v1[i] * v2[j];
}
- return obj;
- },
+ }
+ return r.trim();
+ }
+ function series_div(v1, v2) {
+ if (!(v2 instanceof Series))
+ v2 = Series(v2, v1.length);
+ return series_mul(v1, v2.inverse());
+ }
+ function series_pow(a, b) {
+ if (Integer.isInteger(b)) {
+ return generic_pow(a, b);
+ } else {
+ if (!(a instanceof Series))
+ a = Series(a, b.length);
+ return exp(log(a) * b);
+ }
+ }
+ function series_eq(a, b) {
+ var n, i;
+ if (a.emin != b.emin)
+ return false;
+ n = a.length;
+ if (n != b.length)
+ return false;
+ for(i = 0; i < n; i++) {
+ if (a[i] != b[i])
+ return false;
+ }
+ return true;
+ }
+
+ operators_set(Series.prototype,
+ {
+ "+": series_add,
+ "-": series_sub,
+ "*": series_mul,
+ "/": series_div,
+ "**": series_pow,
+ "==": series_eq,
+ "pos"(a) {
+ return a;
+ },
+ "neg"(a) {
+ var obj, n, i;
+ n = a.length;
+ obj = Series.zero(a.length, a.emin);
+ for(i = 0; i < n; i++) {
+ obj[i] = -a[i];
+ }
+ return obj;
+ },
+ },
+ {
+ left: [Number, BigInt, Float, Fraction, Complex, Mod, Polynomial],
+ right: [Number, BigInt, Float, Fraction, Complex, Mod, Polynomial],
+ "+": series_add,
+ "-": series_sub,
+ "*": series_mul,
+ "/": series_div,
+ "**": series_pow,
+ });
+
+ add_props(Series.prototype, {
conj() {
var obj, n, i;
n = this.length;
});
add_props(Series, {
- [Symbol.operatorOrder]: OT_SERIES,
/* new series of length n and first exponent emin */
zero(n, emin) {
var r, i, obj;
Object.setPrototypeOf(r, obj);
return r;
},
- [Symbol.operatorAdd](v1, v2) {
- var tmp, d, emin, n, r, i, j, v2_emin, c1, c2;
- if (!(v1 instanceof Series)) {
- tmp = v1;
- v1 = v2;
- v2 = tmp;
- }
- d = v1.emin + v1.length;
- if (v2.constructor[Symbol.operatorOrder] <= OT_POLY) {
- v2 = Polynomial(v2);
- if (d <= 0)
- return v1;
- v2_emin = 0;
- } else if (v2 instanceof RationalFunction) {
- /* compute the emin of the rational fonction */
- i = get_emin(v2.num) - get_emin(v2.den);
- if (d <= i)
- return v1;
- /* compute the serie with the required terms */
- v2 = Series(v2, d - i);
- v2_emin = v2.emin;
- } else {
- v2_emin = v2.emin;
- d = Math.min(d, v2_emin + v2.length);
- }
- emin = Math.min(v1.emin, v2_emin);
- n = d - emin;
- r = Series.zero(n, emin);
- /* XXX: slow */
- for(i = emin; i < d; i++) {
- j = i - v1.emin;
- if (j >= 0 && j < v1.length)
- c1 = v1[j];
- else
- c1 = 0;
- j = i - v2_emin;
- if (j >= 0 && j < v2.length)
- c2 = v2[j];
- else
- c2 = 0;
- r[i - emin] = c1 + c2;
- }
- return r.trim();
- },
- [Symbol.operatorSub](a, b) {
- return Series[Symbol.operatorAdd](a, -b);
- },
- [Symbol.operatorMul](v1, v2) {
- var n, i, j, r, n, emin, n1, n2, k;
- if (!(v1 instanceof Series))
- v1 = Series(v1, v2.length);
- else if (!(v2 instanceof Series))
- v2 = Series(v2, v1.length);
- emin = v1.emin + v2.emin;
- n = Math.min(v1.length, v2.length);
- n1 = v1.length;
- n2 = v2.length;
- r = Series.zero(n, emin);
- for(i = 0; i < n1; i++) {
- k = Math.min(n2, n - i);
- for(j = 0; j < k; j++) {
- r[i + j] += v1[i] * v2[j];
- }
- }
- return r.trim();
- },
- [Symbol.operatorDiv](v1, v2) {
- if (!(v2 instanceof Series))
- v2 = Series(v2, v1.length);
- return Series[Symbol.operatorMul](v1, v2.inverse());
- },
- [Symbol.operatorPow](a, b) {
- if (Integer.isInteger(b)) {
- return generic_pow(a, b);
- } else {
- if (!(a instanceof Series))
- a = Series(a, b.length);
- return exp(log(a) * b);
- }
- },
- [Symbol.operatorCmpEQ](a, b) {
- var n, i;
- if (!(a instanceof Series) ||
- !(b instanceof Series))
- return false;
- if (a.emin != b.emin)
- return false;
- n = a.length;
- if (n != b.length)
- return false;
- for(i = 0; i < n; i++) {
- if (a[i] != b[i])
- return false;
- }
- return true;
- },
O(a) {
function ErrorO() {
return TypeError("invalid O() argument");
}
var n;
- if (a.constructor[Symbol.operatorOrder] <= OT_POLY) {
+ if (series_is_scalar_or_polynomial(a)) {
a = Polynomial(a);
n = a.deg();
if (n < 0)
},
});
- add_props(Array, {
- [Symbol.operatorOrder]: OT_ARRAY,
- [Symbol.operatorAdd](a, b) {
- var r, i, n;
- if (!Array.isArray(a) || !Array.isArray(b))
- throw TypeError("array expected");
- n = a.length;
- if (n != b.length)
- throw TypeError("incompatible array size");
- r = [];
- for(i = 0; i < n; i++)
- r[i] = a[i] + b[i];
- return r;
- },
- [Symbol.operatorSub](a, b) {
- var r, i, n;
- n = a.length;
- if (!Array.isArray(a) || !Array.isArray(b))
- throw TypeError("array expected");
- if (n != b.length)
- throw TypeError("incompatible array size");
- r = [];
- for(i = 0; i < n; i++)
- r[i] = a[i] - b[i];
- return r;
- },
- scalar_mul(a, b) {
- var r, i, n;
- n = a.length;
- r = [];
- for(i = 0; i < n; i++)
- r[i] = a[i] * b;
- return r;
- },
- [Symbol.operatorMul](a, b) {
- var h, w, l, i, j, k, r, rl, sum, a_mat, b_mat, a_is_array, b_is_array;
- a_is_array = Array.isArray(a);
- b_is_array = Array.isArray(b);
- if (!a_is_array && !b_is_array) {
- throw TypeError("array expected");
- } else if (!a_is_array && b_is_array) {
- return Array.scalar_mul(b, a);
- } else if (a_is_array && !b_is_array) {
- return Array.scalar_mul(a, b);
- }
- h = a.length;
- a_mat = Array.isArray(a[0]);
- if (a_mat) {
- l = a[0].length;
- } else {
- l = 1;
- }
- if (l != b.length)
- throw RangeError("incompatible matrix size");
- b_mat = Array.isArray(b[0]);
- if (b_mat)
- w = b[0].length;
- else
- w = 1;
- r = [];
- if (a_mat && b_mat) {
- for(i = 0; i < h; i++) {
- rl = [];
- for(j = 0; j < w; j++) {
- sum = 0;
- for(k = 0; k < l; k++) {
- sum += a[i][k] * b[k][j];
- }
- rl[j] = sum;
- }
- r[i] = rl;
- }
- } else if (a_mat && !b_mat) {
- for(i = 0; i < h; i++) {
+ function array_add(a, b) {
+ var r, i, n;
+ n = a.length;
+ if (n != b.length)
+ throw TypeError("incompatible array size");
+ r = [];
+ for(i = 0; i < n; i++)
+ r[i] = a[i] + b[i];
+ return r;
+ }
+ function array_sub(a, b) {
+ var r, i, n;
+ n = a.length;
+ if (n != b.length)
+ throw TypeError("incompatible array size");
+ r = [];
+ for(i = 0; i < n; i++)
+ r[i] = a[i] - b[i];
+ return r;
+ }
+ function array_scalar_mul(a, b) {
+ var r, i, n;
+ n = a.length;
+ r = [];
+ for(i = 0; i < n; i++)
+ r[i] = a[i] * b;
+ return r;
+ }
+ function array_mul(a, b) {
+ var h, w, l, i, j, k, r, rl, sum, a_mat, b_mat;
+ h = a.length;
+ a_mat = Array.isArray(a[0]);
+ if (a_mat) {
+ l = a[0].length;
+ } else {
+ l = 1;
+ }
+ if (l != b.length)
+ throw RangeError("incompatible matrix size");
+ b_mat = Array.isArray(b[0]);
+ if (b_mat)
+ w = b[0].length;
+ else
+ w = 1;
+ r = [];
+ if (a_mat && b_mat) {
+ for(i = 0; i < h; i++) {
+ rl = [];
+ for(j = 0; j < w; j++) {
sum = 0;
for(k = 0; k < l; k++) {
- sum += a[i][k] * b[k];
+ sum += a[i][k] * b[k][j];
}
- r[i] = sum;
+ rl[j] = sum;
}
- } else if (!a_mat && b_mat) {
- for(i = 0; i < h; i++) {
- rl = [];
- for(j = 0; j < w; j++) {
- rl[j] = a[i] * b[0][j];
- }
- r[i] = rl;
+ r[i] = rl;
+ }
+ } else if (a_mat && !b_mat) {
+ for(i = 0; i < h; i++) {
+ sum = 0;
+ for(k = 0; k < l; k++) {
+ sum += a[i][k] * b[k];
}
- } else {
- for(i = 0; i < h; i++) {
- r[i] = a[i] * b[0];
+ r[i] = sum;
+ }
+ } else if (!a_mat && b_mat) {
+ for(i = 0; i < h; i++) {
+ rl = [];
+ for(j = 0; j < w; j++) {
+ rl[j] = a[i] * b[0][j];
}
+ r[i] = rl;
}
- return r;
- },
- [Symbol.operatorDiv](a, b) {
- return Array[Symbol.operatorMul](a, b.inverse());
- },
- [Symbol.operatorPow]: generic_pow,
- [Symbol.operatorCmpEQ](a, b) {
- var n, i;
- n = a.length;
- if (n != b.length)
+ } else {
+ for(i = 0; i < h; i++) {
+ r[i] = a[i] * b[0];
+ }
+ }
+ return r;
+ }
+ function array_div(a, b) {
+ return array_mul(a, b.inverse());
+ }
+ function array_scalar_div(a, b) {
+ return a * b.inverse();
+ }
+ function array_eq(a, b) {
+ var n, i;
+ n = a.length;
+ if (n != b.length)
+ return false;
+ for(i = 0; i < n; i++) {
+ if (a[i] != b[i])
return false;
- for(i = 0; i < n; i++) {
- if (a[i] != b[i])
- return false;
+ }
+ return true;
+ }
+
+ operators_set(Array.prototype,
+ {
+ "+": array_add,
+ "-": array_sub,
+ "*": array_mul,
+ "/": array_div,
+ "==": array_eq,
+ "pos"(a) {
+ return a;
+ },
+ "neg"(a) {
+ var i, n, r;
+ n = a.length;
+ r = [];
+ for(i = 0; i < n; i++)
+ r[i] = -a[i];
+ return r;
}
- return true;
},
- });
+ {
+ right: [Number, BigInt, Float, Fraction, Complex, Mod,
+ Polynomial, PolyMod, RationalFunction, Series],
+ "*": array_scalar_mul,
+ "/": array_scalar_div,
+ "**": generic_pow, /* XXX: only for integer */
+ },
+ {
+ left: [Number, BigInt, Float, Fraction, Complex, Mod,
+ Polynomial, PolyMod, RationalFunction, Series],
+ "*"(a, b) { return array_scalar_mul(b, a); },
+ "/"(a, b) { return array_scalar_div(b, a); },
+ });
add_props(Array.prototype, {
- [Symbol.operatorPlus]() {
- return this;
- },
- [Symbol.operatorNeg]() {
- var i, n, r;
- n = this.length;
- r = [];
- for(i = 0; i < n; i++)
- r[i] = -this[i];
- return r;
- },
conj() {
var i, n, r;
n = this.length;
return a * Float.PI / 180;
}
+function sinh(a)
+{
+ var e = Float.exp(Float(a));
+ return (e - 1/e) * 0.5;
+}
+
+function cosh(a)
+{
+ var e = Float.exp(Float(a));
+ return (e + 1/e) * 0.5;
+}
+
+function tanh(a)
+{
+ var e = Float.exp(Float(a) * 2);
+ return (e - 1) / (e + 1);
+}
+
+function asinh(a)
+{
+ var x = Float(a);
+ return log(sqrt(x * x + 1) + x);
+}
+
+function acosh(a)
+{
+ var x = Float(a);
+ return log(sqrt(x * x - 1) + x);
+}
+
+function atanh(a)
+{
+ var x = Float(a);
+ return 0.5 * log((1 + x) / (1 - x));
+}
+
var idn = Matrix.idn;
var diag = Matrix.diag;
var trans = Matrix.trans;
DEF(BigFloat, "BigFloat")
DEF(BigFloatEnv, "BigFloatEnv")
DEF(BigDecimal, "BigDecimal")
+DEF(OperatorSet, "OperatorSet")
+DEF(Operators, "Operators")
#endif
DEF(Map, "Map")
DEF(Set, "Set") /* Map + 1 */
DEF(Symbol_unscopables, "Symbol.unscopables")
DEF(Symbol_asyncIterator, "Symbol.asyncIterator")
#ifdef CONFIG_BIGNUM
-DEF(Symbol_operatorOrder, "Symbol.operatorOrder")
-DEF(Symbol_operatorAdd, "Symbol.operatorAdd")
-DEF(Symbol_operatorSub, "Symbol.operatorSub")
-DEF(Symbol_operatorMul, "Symbol.operatorMul")
-DEF(Symbol_operatorDiv, "Symbol.operatorDiv")
-DEF(Symbol_operatorMod, "Symbol.operatorMod")
-DEF(Symbol_operatorPow, "Symbol.operatorPow")
-DEF(Symbol_operatorShl, "Symbol.operatorShl")
-DEF(Symbol_operatorShr, "Symbol.operatorShr")
-DEF(Symbol_operatorAnd, "Symbol.operatorAnd")
-DEF(Symbol_operatorOr, "Symbol.operatorOr")
-DEF(Symbol_operatorXor, "Symbol.operatorXor")
-DEF(Symbol_operatorCmpLT, "Symbol.operatorCmpLT")
-DEF(Symbol_operatorCmpLE, "Symbol.operatorCmpLE")
-DEF(Symbol_operatorCmpEQ, "Symbol.operatorCmpEQ")
-DEF(Symbol_operatorPlus, "Symbol.operatorPlus")
-DEF(Symbol_operatorNeg, "Symbol.operatorNeg")
-DEF(Symbol_operatorNot, "Symbol.operatorNot")
-DEF(Symbol_operatorInc, "Symbol.operatorInc")
-DEF(Symbol_operatorDec, "Symbol.operatorDec")
-DEF(Symbol_operatorMathMod, "Symbol.operatorMathMod")
+DEF(Symbol_operatorSet, "Symbol.operatorSet")
#endif
-
+
#endif /* DEF */
#if !defined(_WIN32)
+static JSValue js_os_chdir(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv)
+{
+ const char *target;
+ int err;
+
+ target = JS_ToCString(ctx, argv[0]);
+ if (!target)
+ return JS_EXCEPTION;
+ err = chdir(target);
+ JS_FreeCString(ctx, target);
+ return js_os_return(ctx, err);
+}
+
/* return [path, errorcode] */
static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
JS_PROP_STRING_DEF("platform", OS_PLATFORM, 0 ),
JS_CFUNC_DEF("getcwd", 0, js_os_getcwd ),
#if !defined(_WIN32)
+ JS_CFUNC_DEF("chdir", 0, js_os_chdir ),
JS_CFUNC_DEF("realpath", 1, js_os_realpath ),
JS_CFUNC_DEF("mkdir", 1, js_os_mkdir ),
JS_CFUNC_MAGIC_DEF("stat", 1, js_os_stat, 0 ),
DEF(is_undefined_or_null, 1, 1, 1, none)
#ifdef CONFIG_BIGNUM
DEF( mul_pow10, 1, 2, 1, none)
-DEF( math_div, 1, 2, 1, none)
DEF( math_mod, 1, 2, 1, none)
-DEF( math_pow, 1, 2, 1, none)
#endif
/* must be the last non short and non temporary opcode */
DEF( nop, 1, 0, 0, none)
def(set_arg_valid_upto, 3, 0, 0, arg) /* emitted in phase 1, removed in phase 2 */
-def(close_var_object, 1, 0, 0, none) /* emitted in phase 1, removed in phase 2 */
def( enter_scope, 3, 0, 0, u16) /* emitted in phase 1, removed in phase 2 */
def( leave_scope, 3, 0, 0, u16) /* emitted in phase 1, removed in phase 2 */
#include "list.h"
#include "quickjs.h"
#include "libregexp.h"
-
-/* enable bignums */
-#define CONFIG_BIGNUM
-
#ifdef CONFIG_BIGNUM
#include "libbf.h"
#endif
JS_CLASS_BIG_INT, /* u.object_data */
JS_CLASS_BIG_FLOAT, /* u.object_data */
JS_CLASS_FLOAT_ENV, /* u.float_env */
- JS_CLASS_BIG_DECIMAL, /* u.object_data */
+ JS_CLASS_BIG_DECIMAL, /* u.object_data */
+ JS_CLASS_OPERATOR_SET, /* u.operator_set */
#endif
JS_CLASS_MAP, /* u.map_state */
JS_CLASS_SET, /* u.map_state */
JSNumericOperations bigint_ops;
JSNumericOperations bigfloat_ops;
JSNumericOperations bigdecimal_ops;
+ uint32_t operator_count;
#endif
};
#define JS_MODE_STRICT (1 << 0)
#define JS_MODE_STRIP (1 << 1)
-#define JS_MODE_BIGINT (1 << 2)
-#define JS_MODE_MATH (1 << 3)
+#define JS_MODE_MATH (1 << 2)
typedef struct JSStackFrame {
struct JSStackFrame *prev_frame; /* NULL if first stack frame */
const uint8_t *cur_pc; /* only used in bytecode functions : PC of the
instruction after the call */
int arg_count;
- int js_mode; /* 0 or JS_MODE_BIGINT for C functions */
+ int js_mode; /* 0 or JS_MODE_MATH for C functions */
/* only used in generators. Current stack pointer value. NULL if
the function is running. */
JSValue *cur_sp;
#ifdef CONFIG_BIGNUM
bf_context_t *bf_ctx; /* points to rt->bf_ctx, shared by all contexts */
JSFloatEnv fp_env; /* global FP environment */
- BOOL bignum_ext; /* enable bigint mode, math mode and operator
- overloading */
+ BOOL bignum_ext : 8; /* enable math mode */
+ BOOL allow_operator_overloading : 8;
#endif
/* when the counter reaches zero, JSRutime.interrupt_handler is called */
int interrupt_counter;
JSAsyncFunctionState func_state;
} JSAsyncFunctionData;
+typedef enum {
+ /* binary operators */
+ JS_OVOP_ADD,
+ JS_OVOP_SUB,
+ JS_OVOP_MUL,
+ JS_OVOP_DIV,
+ JS_OVOP_MOD,
+ JS_OVOP_POW,
+ JS_OVOP_OR,
+ JS_OVOP_AND,
+ JS_OVOP_XOR,
+ JS_OVOP_SHL,
+ JS_OVOP_SAR,
+ JS_OVOP_SHR,
+ JS_OVOP_EQ,
+ JS_OVOP_LESS,
+
+ JS_OVOP_BINARY_COUNT,
+ /* unary operators */
+ JS_OVOP_POS = JS_OVOP_BINARY_COUNT,
+ JS_OVOP_NEG,
+ JS_OVOP_INC,
+ JS_OVOP_DEC,
+ JS_OVOP_NOT,
+
+ JS_OVOP_COUNT,
+} JSOverloadableOperatorEnum;
+
+typedef struct {
+ uint32_t operator_index;
+ JSObject *ops[JS_OVOP_BINARY_COUNT]; /* self operators */
+} JSBinaryOperatorDefEntry;
+
+typedef struct {
+ int count;
+ JSBinaryOperatorDefEntry *tab;
+} JSBinaryOperatorDef;
+
+typedef struct {
+ uint32_t operator_counter;
+ BOOL is_primitive; /* OperatorSet for a primitive type */
+ /* NULL if no operator is defined */
+ JSObject *self_ops[JS_OVOP_COUNT]; /* self operators */
+ JSBinaryOperatorDef left;
+ JSBinaryOperatorDef right;
+} JSOperatorSetData;
+
typedef struct JSReqModuleEntry {
JSAtom module_name;
JSModuleDef *module; /* used using resolution */
struct JSTypedArray *typed_array; /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_DATAVIEW */
#ifdef CONFIG_BIGNUM
struct JSFloatEnv *float_env; /* JS_CLASS_FLOAT_ENV */
+ struct JSOperatorSetData *operator_set; /* JS_CLASS_OPERATOR_SET */
#endif
struct JSMapState *map_state; /* JS_CLASS_MAP..JS_CLASS_WEAKSET */
struct JSMapIteratorData *map_iterator_data; /* JS_CLASS_MAP_ITERATOR, JS_CLASS_SET_ITERATOR */
static void js_promise_resolve_function_finalizer(JSRuntime *rt, JSValue val);
static void js_promise_resolve_function_mark(JSRuntime *rt, JSValueConst val,
JS_MarkFunc *mark_func);
+#ifdef CONFIG_BIGNUM
+static void js_operator_set_finalizer(JSRuntime *rt, JSValue val);
+static void js_operator_set_mark(JSRuntime *rt, JSValueConst val,
+ JS_MarkFunc *mark_func);
+#endif
static JSValue JS_ToStringFree(JSContext *ctx, JSValue val);
static int JS_ToBoolFree(JSContext *ctx, JSValue val);
static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val);
JSObject *p, JSAtom prop, int prop_flags);
#ifdef CONFIG_BIGNUM
static void js_float_env_finalizer(JSRuntime *rt, JSValue val);
-static JSValue JS_NewBigFloat(JSContext *ctx, bf_t *a);
-static JSValue JS_NewBigDecimal(JSContext *ctx, bfdec_t *a);
-static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint);
-static JSValue JS_NewBigInt(JSContext *ctx, bf_t *a);
+static JSValue JS_NewBigFloat(JSContext *ctx);
+static inline bf_t *JS_GetBigFloat(JSValueConst val)
+{
+ JSBigFloat *p = JS_VALUE_GET_PTR(val);
+ return &p->num;
+}
+static JSValue JS_NewBigDecimal(JSContext *ctx);
+static inline bfdec_t *JS_GetBigDecimal(JSValueConst val)
+{
+ JSBigDecimal *p = JS_VALUE_GET_PTR(val);
+ return &p->num;
+}
+static JSValue JS_NewBigInt(JSContext *ctx);
+static inline bf_t *JS_GetBigInt(JSValueConst val)
+{
+ JSBigFloat *p = JS_VALUE_GET_PTR(val);
+ return &p->num;
+}
+static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
+ BOOL convert_to_safe_integer);
+static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val);
static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val);
static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val);
static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf);
static const JSClassExoticMethods js_module_ns_exotic_methods;
static JSClassID js_class_id_alloc = JS_CLASS_INIT_COUNT;
-JS_BOOL JS_IsNumber(JSValueConst v)
-{
-#ifdef CONFIG_BIGNUM
- /* XXX: check the bignum case. Should use a different function */
- int tag = JS_VALUE_GET_TAG(v);
- return tag == JS_TAG_INT || tag == JS_TAG_BIG_INT ||
- tag == JS_TAG_BIG_FLOAT || JS_TAG_IS_FLOAT64(tag);
-#else
- int tag = JS_VALUE_GET_TAG(v);
- return tag == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag);
-#endif
-}
-
static void js_trigger_gc(JSRuntime *rt, size_t size)
{
BOOL force_gc;
{ JS_ATOM_BigFloat, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_BIG_FLOAT */
{ JS_ATOM_BigFloatEnv, js_float_env_finalizer, NULL }, /* JS_CLASS_FLOAT_ENV */
{ JS_ATOM_BigDecimal, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_BIG_DECIMAL */
+ { JS_ATOM_OperatorSet, js_operator_set_finalizer, js_operator_set_mark }, /* JS_CLASS_OPERATOR_SET */
#endif
{ JS_ATOM_Map, js_map_finalizer, js_map_mark }, /* JS_CLASS_MAP */
{ JS_ATOM_Set, js_map_finalizer, js_map_mark }, /* JS_CLASS_SET */
}
#ifdef CONFIG_BIGNUM
-static inline BOOL is_bigint_mode(JSContext *ctx)
+static inline BOOL is_math_mode(JSContext *ctx)
{
JSStackFrame *sf = ctx->current_stack_frame;
- return (sf && (sf->js_mode & JS_MODE_BIGINT));
+ return (sf && (sf->js_mode & JS_MODE_MATH));
}
#endif
if (v == (int32_t)v) {
return JS_NewInt32(ctx, v);
} else {
-#ifdef CONFIG_BIGNUM
- if (is_bigint_mode(ctx)) {
- bf_t a_s, *a = &a_s;
- bf_init(ctx->bf_ctx, a);
- bf_set_si(a, v);
- return JS_NewBigInt(ctx, a);
- } else
-#endif
- {
- return __JS_NewFloat64(ctx, (double)v);
- }
+ return __JS_NewFloat64(ctx, (double)v);
}
}
static force_inline JSValue JS_NewUint32(JSContext *ctx, uint32_t val)
{
-#ifdef CONFIG_BIGNUM
- return JS_NewInt64(ctx, val);
-#else
JSValue v;
if (val <= 0x7fffffff) {
v = JS_MKVAL(JS_TAG_INT, val);
v = __JS_NewFloat64(ctx, val);
}
return v;
-#endif
}
/* JSAtom support */
#ifdef CONFIG_BIGNUM
case JS_CLASS_BIG_INT: /* u.object_data */
case JS_CLASS_BIG_FLOAT: /* u.object_data */
+ case JS_CLASS_BIG_DECIMAL: /* u.object_data */
#endif
compute_value_size(p->u.object_data, hp);
break;
case JS_TAG_BIG_INT:
val = ctx->class_proto[JS_CLASS_BIG_INT];
break;
- case JS_TAG_INT:
- if (is_bigint_mode(ctx)) {
- val = ctx->class_proto[JS_CLASS_BIG_INT];
- } else {
- val = ctx->class_proto[JS_CLASS_NUMBER];
- }
- break;
- case JS_TAG_FLOAT64:
- val = ctx->class_proto[JS_CLASS_NUMBER];
- break;
case JS_TAG_BIG_FLOAT:
val = ctx->class_proto[JS_CLASS_BIG_FLOAT];
break;
case JS_TAG_BIG_DECIMAL:
val = ctx->class_proto[JS_CLASS_BIG_DECIMAL];
break;
-#else
+#endif
case JS_TAG_INT:
case JS_TAG_FLOAT64:
val = ctx->class_proto[JS_CLASS_NUMBER];
break;
-#endif
case JS_TAG_BOOL:
val = ctx->class_proto[JS_CLASS_BOOLEAN];
break;
}
p->u.array.count = len;
}
-#ifdef CONFIG_BIGNUM
- set_value(ctx, &prop->u.value, JS_NewUint32(ctx, len));
-#else
prop->u.value = JS_NewUint32(ctx, len);
-#endif
} else {
/* Note: length is always a uint32 because the object is an
array */
#define HINT_STRING 0
#define HINT_NUMBER 1
#define HINT_NONE 2
-#ifdef CONFIG_BIGNUM
-#define HINT_INTEGER 3
-#endif
/* don't try Symbol.toPrimitive */
#define HINT_FORCE_ORDINARY (1 << 4)
case HINT_NONE:
atom = JS_ATOM_default;
break;
-#ifdef CONFIG_BIGNUM
- case HINT_INTEGER:
- atom = JS_ATOM_integer;
- break;
-#endif
}
arg = JS_AtomToString(ctx, atom);
ret = JS_CallFree(ctx, method, val, 1, (JSValueConst *)&arg);
{
bf_t a_s, *a = &a_s;
int ret;
- bf_init(ctx->bf_ctx, a);
+ JSValue val;
+ val = JS_NewBigInt(ctx);
+ if (JS_IsException(val))
+ return val;
+ a = JS_GetBigInt(val);
ret = bf_atof(a, buf, NULL, radix, BF_PREC_INF, BF_RNDZ);
if (ret & BF_ST_MEM_ERROR) {
- bf_delete(a);
+ JS_FreeValue(ctx, val);
return JS_ThrowOutOfMemory(ctx);
}
- return JS_NewBigInt2(ctx, a, !(flags & ATOD_MODE_BIGINT));
+ val = JS_CompactBigInt1(ctx, val, (flags & ATOD_MODE_BIGINT) != 0);
+ return val;
}
static JSValue js_string_to_bigfloat(JSContext *ctx, const char *buf,
int radix, int flags, slimb_t *pexponent)
{
- bf_t a_s, *a = &a_s;
+ bf_t *a;
int ret;
-
- bf_init(ctx->bf_ctx, a);
+ JSValue val;
+
+ val = JS_NewBigFloat(ctx);
+ if (JS_IsException(val))
+ return val;
+ a = JS_GetBigFloat(val);
if (flags & ATOD_ACCEPT_SUFFIX) {
/* return the exponent to get infinite precision */
ret = bf_atof2(a, pexponent, buf, NULL, radix, BF_PREC_INF,
ctx->fp_env.flags);
}
if (ret & BF_ST_MEM_ERROR) {
- bf_delete(a);
+ JS_FreeValue(ctx, val);
return JS_ThrowOutOfMemory(ctx);
}
- return JS_NewBigFloat(ctx, a);
+ return val;
}
static JSValue js_string_to_bigdecimal(JSContext *ctx, const char *buf,
int radix, int flags, slimb_t *pexponent)
{
- bfdec_t a_s, *a = &a_s;
+ bfdec_t *a;
int ret;
- bfdec_init(ctx->bf_ctx, a);
+ JSValue val;
+
+ val = JS_NewBigDecimal(ctx);
+ if (JS_IsException(val))
+ return val;
+ a = JS_GetBigDecimal(val);
ret = bfdec_atof(a, buf, NULL, BF_PREC_INF,
BF_RNDZ | BF_ATOF_NO_NAN_INF);
if (ret & BF_ST_MEM_ERROR) {
- bfdec_delete(a);
+ JS_FreeValue(ctx, val);
return JS_ThrowOutOfMemory(ctx);
}
- return JS_NewBigDecimal(ctx, a);
+ return val;
}
#endif
strstart(p, "Infinity", &p)) {
#ifdef CONFIG_BIGNUM
if (atod_type == ATOD_TYPE_BIG_FLOAT) {
- bf_t a_s, *a = &a_s;
- bf_init(ctx->bf_ctx, a);
+ bf_t *a;
+ val = JS_NewBigFloat(ctx);
+ if (JS_IsException(val))
+ goto done;
+ a = JS_GetBigFloat(val);
bf_set_inf(a, is_neg);
- val = JS_NewBigFloat(ctx, a);
} else
#endif
{
} else if (*p == 'l') {
p++;
atod_type = ATOD_TYPE_BIG_FLOAT;
- } else if (*p == 'd') {
+ } else if (*p == 'm') {
p++;
atod_type = ATOD_TYPE_BIG_DECIMAL;
} else {
typedef enum JSToNumberHintEnum {
TON_FLAG_NUMBER,
- TON_FLAG_INTEGER,
TON_FLAG_NUMERIC,
} JSToNumberHintEnum;
{
uint32_t tag;
JSValue ret;
- int hint;
redo:
tag = JS_VALUE_GET_NORM_TAG(val);
ret = val;
break;
case JS_TAG_BIG_INT:
- if (flag == TON_FLAG_NUMBER && !is_bigint_mode(ctx)) {
+ if (flag != TON_FLAG_NUMERIC) {
JS_FreeValue(ctx, val);
return JS_ThrowTypeError(ctx, "cannot convert bigint to number");
}
- /* fall thru */
+ ret = val;
+ break;
case JS_TAG_BIG_FLOAT:
+ if (flag != TON_FLAG_NUMERIC) {
+ JS_FreeValue(ctx, val);
+ return JS_ThrowTypeError(ctx, "cannot convert bigfloat to number");
+ }
+ ret = val;
+ break;
#endif
case JS_TAG_FLOAT64:
case JS_TAG_INT:
ret = JS_NAN;
break;
case JS_TAG_OBJECT:
-#ifdef CONFIG_BIGNUM
- hint = flag == TON_FLAG_INTEGER ? HINT_INTEGER : HINT_NUMBER;
-#else
- hint = HINT_NUMBER;
-#endif
- val = JS_ToPrimitiveFree(ctx, val, hint);
+ val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
if (JS_IsException(val))
return JS_EXCEPTION;
goto redo;
ret = JS_NewInt32(ctx, 0);
} else {
int flags = ATOD_ACCEPT_BIN_OCT;
-#ifdef CONFIG_BIGNUM
- if (is_bigint_mode(ctx))
- flags |= ATOD_MODE_BIGINT;
-#endif
ret = js_atof(ctx, p, &p, 0, flags);
if (!JS_IsException(ret)) {
p += skip_spaces(p);
return JS_ToNumberHintFree(ctx, val, TON_FLAG_NUMBER);
}
-#ifdef CONFIG_BIGNUM
static JSValue JS_ToNumericFree(JSContext *ctx, JSValue val)
{
return JS_ToNumberHintFree(ctx, val, TON_FLAG_NUMERIC);
{
return JS_ToNumericFree(ctx, JS_DupValue(ctx, val));
}
-#endif
static __exception int __JS_ToFloat64Free(JSContext *ctx, double *pres,
JSValue val)
return JS_ToNumberFree(ctx, JS_DupValue(ctx, val));
}
+/* same as JS_ToNumber() but return 0 in case of NaN/Undefined */
static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
{
uint32_t tag;
}
break;
#ifdef CONFIG_BIGNUM
- case JS_TAG_BIG_INT:
- if (!is_bigint_mode(ctx))
- goto to_number;
- ret = val;
- break;
case JS_TAG_BIG_FLOAT:
{
bf_t a_s, *a, r_s, *r = &r_s;
else
ret = JS_DupValue(ctx, val);
} else {
- bf_init(ctx->bf_ctx, r);
- bf_set(r, a);
- bf_rint(r, BF_RNDZ);
- ret = JS_NewBigInt(ctx, r);
+ ret = JS_NewBigInt(ctx);
+ if (!JS_IsException(ret)) {
+ r = JS_GetBigInt(ret);
+ bf_set(r, a);
+ bf_rint(r, BF_RNDZ);
+ ret = JS_CompactBigInt(ctx, ret);
+ }
}
if (a == &a_s)
bf_delete(a);
break;
#endif
default:
-#ifdef CONFIG_BIGNUM
- to_number:
-#endif
val = JS_ToNumberFree(ctx, val);
if (JS_IsException(val))
return val;
break;
#ifdef CONFIG_BIGNUM
case JS_TAG_BIG_FLOAT:
- to_bf:
{
JSBigFloat *p = JS_VALUE_GET_PTR(val);
bf_get_int32(&ret, &p->num, 0);
JS_FreeValue(ctx, val);
}
break;
- case JS_TAG_BIG_INT:
- if (is_bigint_mode(ctx))
- goto to_bf;
- /* fall thru */
#endif
default:
val = JS_ToNumberFree(ctx, val);
return 0;
#ifdef CONFIG_BIGNUM
case JS_TAG_BIG_FLOAT:
- to_bf:
{
JSBigFloat *p = JS_VALUE_GET_PTR(val);
bf_get_int64(pres, &p->num, 0);
JS_FreeValue(ctx, val);
}
return 0;
- case JS_TAG_BIG_INT:
- if (is_bigint_mode(ctx))
- goto to_bf;
- /* fall thru */
#endif
default:
val = JS_ToNumberFree(ctx, val);
break;
#ifdef CONFIG_BIGNUM
case JS_TAG_BIG_FLOAT:
- to_bf:
{
JSBigFloat *p = JS_VALUE_GET_PTR(val);
bf_get_int64(&ret, &p->num, BF_GET_INT_MOD);
JS_FreeValue(ctx, val);
}
break;
- case JS_TAG_BIG_INT:
- if (is_bigint_mode(ctx))
- goto to_bf;
- /* fall thru */
#endif
default:
val = JS_ToNumberFree(ctx, val);
break;
#ifdef CONFIG_BIGNUM
case JS_TAG_BIG_FLOAT:
- to_bf:
{
JSBigFloat *p = JS_VALUE_GET_PTR(val);
bf_get_int32(&ret, &p->num, BF_GET_INT_MOD);
JS_FreeValue(ctx, val);
}
break;
- case JS_TAG_BIG_INT:
- if (is_bigint_mode(ctx))
- goto to_bf;
- /* fall thru */
#endif
default:
val = JS_ToNumberFree(ctx, val);
}
break;
#ifdef CONFIG_BIGNUM
- case JS_TAG_BIG_INT:
- {
- JSBigFloat *p = JS_VALUE_GET_PTR(val);
- if (!is_bigint_mode(ctx))
- goto to_number;
- bf_get_int32(&res, &p->num, 0);
- JS_FreeValue(ctx, val);
- }
- goto int_clamp;
case JS_TAG_BIG_FLOAT:
{
JSBigFloat *p = JS_VALUE_GET_PTR(val);
goto int_clamp;
#endif
default:
-#ifdef CONFIG_BIGNUM
- to_number:
-#endif
val = JS_ToNumberFree(ctx, val);
if (JS_IsException(val)) {
*pres = 0;
#define MAX_SAFE_INTEGER (((int64_t)1 << 53) - 1)
+static BOOL is_safe_integer(double d)
+{
+ return isfinite(d) && floor(d) == d &&
+ fabs(d) <= (double)MAX_SAFE_INTEGER;
+}
+
int JS_ToIndex(JSContext *ctx, uint64_t *plen, JSValueConst val)
{
int64_t v;
}
/* Note: can return an exception */
-/* XXX: bignum case */
static int JS_NumberIsInteger(JSContext *ctx, JSValueConst val)
{
double d;
return js_ftoa(ctx, val, 10, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
}
-static JSValue js_bigdecimal_to_string(JSContext *ctx, JSValueConst val)
+static JSValue js_bigdecimal_to_string1(JSContext *ctx, JSValueConst val,
+ limb_t prec, int flags)
{
JSValue ret;
bfdec_t *a;
saved_sign = a->sign;
if (a->expn == BF_EXP_ZERO)
a->sign = 0;
- str = bfdec_ftoa(NULL, a, 0, BF_RNDZ | BF_FTOA_FORMAT_FREE |
- BF_FTOA_JS_QUIRKS);
+ str = bfdec_ftoa(NULL, a, prec, flags | BF_FTOA_JS_QUIRKS);
a->sign = saved_sign;
if (!str)
return JS_ThrowOutOfMemory(ctx);
return ret;
}
+static JSValue js_bigdecimal_to_string(JSContext *ctx, JSValueConst val)
+{
+ return js_bigdecimal_to_string1(ctx, val, 0,
+ BF_RNDZ | BF_FTOA_FORMAT_FREE);
+}
+
#endif /* CONFIG_BIGNUM */
/* 2 <= base <= 36 */
#ifdef CONFIG_BIGNUM
+JSValue JS_NewBigInt64_1(JSContext *ctx, int64_t v)
+{
+ JSValue val;
+ bf_t *a;
+ val = JS_NewBigInt(ctx);
+ if (JS_IsException(val))
+ return val;
+ a = JS_GetBigInt(val);
+ if (bf_set_si(a, v)) {
+ JS_FreeValue(ctx, val);
+ return JS_ThrowOutOfMemory(ctx);
+ }
+ return val;
+}
+
JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
{
- BOOL is_bignum = is_bigint_mode(ctx);
- if (is_bignum && v == (int32_t)v) {
- return JS_NewInt32(ctx, v);
+ if (is_math_mode(ctx) &&
+ v >= -MAX_SAFE_INTEGER && v <= MAX_SAFE_INTEGER) {
+ return JS_NewInt64(ctx, v);
} else {
- bf_t a_s, *a = &a_s;
- bf_init(ctx->bf_ctx, a);
- bf_set_si(a, v);
- return JS_NewBigInt2(ctx, a, TRUE);
+ return JS_NewBigInt64_1(ctx, v);
}
}
JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
{
- BOOL is_bignum = is_bigint_mode(ctx);
- if (is_bignum && v == (int32_t)v) {
- return JS_NewInt32(ctx, v);
+ JSValue val;
+ if (is_math_mode(ctx) && v <= MAX_SAFE_INTEGER) {
+ val = JS_NewInt64(ctx, v);
} else {
- bf_t a_s, *a = &a_s;
- bf_init(ctx->bf_ctx, a);
- bf_set_ui(a, v);
- return JS_NewBigInt2(ctx, a, TRUE);
+ bf_t *a;
+ val = JS_NewBigInt(ctx);
+ if (JS_IsException(val))
+ return val;
+ a = JS_GetBigInt(val);
+ if (bf_set_ui(a, v)) {
+ JS_FreeValue(ctx, val);
+ return JS_ThrowOutOfMemory(ctx);
+ }
}
+ return val;
}
/* if the returned bigfloat is allocated it is equal to
p = str;
p += skip_spaces(p);
if ((p - str) == len) {
- bf_t a_s, *a = &a_s;
- bf_init(ctx->bf_ctx, a);
- bf_set_si(a, 0);
- val = JS_NewBigInt(ctx, a);
+ val = JS_NewBigInt64(ctx, 0);
} else {
flags = ATOD_INT_ONLY | ATOD_ACCEPT_BIN_OCT | ATOD_TYPE_BIG_INT;
- if (is_bigint_mode(ctx))
+ if (is_math_mode(ctx))
flags |= ATOD_MODE_BIGINT;
val = js_atof(ctx, p, &p, 0, flags);
p += skip_spaces(p);
case JS_TAG_INT:
case JS_TAG_NULL:
case JS_TAG_UNDEFINED:
- if (!is_bigint_mode(ctx))
+ if (!is_math_mode(ctx))
goto fail;
/* fall tru */
case JS_TAG_BOOL:
case JS_TAG_FLOAT64:
{
double d = JS_VALUE_GET_FLOAT64(val);
- if (!is_bigint_mode(ctx))
+ if (!is_math_mode(ctx))
goto fail;
if (!isfinite(d))
goto fail;
r = &p->num;
break;
case JS_TAG_BIG_FLOAT:
- if (!is_bigint_mode(ctx))
+ if (!is_math_mode(ctx))
goto fail;
p = JS_VALUE_GET_PTR(val);
if (!bf_is_finite(&p->num))
return NULL;
goto redo;
case JS_TAG_OBJECT:
- val = JS_ToPrimitiveFree(ctx, val,
- is_bigint_mode(ctx) ? HINT_INTEGER : HINT_NUMBER);
+ val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
if (JS_IsException(val))
return NULL;
goto redo;
if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
return val;
} else {
- bf_t a_s, *a, b_s, *b;
+ bf_t a_s, *a, *r;
int ret;
-
+ JSValue res;
+
+ res = JS_NewBigInt(ctx);
+ if (JS_IsException(res))
+ return JS_EXCEPTION;
a = JS_ToBigIntFree(ctx, &a_s, val);
- if (!a)
+ if (!a) {
+ JS_FreeValue(ctx, res);
return JS_EXCEPTION;
- b = &b_s;
- bf_init(ctx->bf_ctx, b);
- ret = bf_set(b, a);
+ }
+ r = JS_GetBigInt(res);
+ ret = bf_set(r, a);
JS_FreeBigInt(ctx, a, &a_s);
if (ret) {
- bf_delete(b);
+ JS_FreeValue(ctx, res);
return JS_ThrowOutOfMemory(ctx);
}
- return JS_NewBigInt2(ctx, b, TRUE);
+ return JS_CompactBigInt(ctx, res);
}
}
static JSBigFloat *js_new_bf(JSContext *ctx)
{
JSBigFloat *p;
- p = js_mallocz(ctx, sizeof(*p));
+ p = js_malloc(ctx, sizeof(*p));
if (!p)
return NULL;
p->header.ref_count = 1;
return p;
}
-/* WARNING: 'a' is freed */
-static JSValue JS_NewBigFloat(JSContext *ctx, bf_t *a)
+static JSValue JS_NewBigFloat(JSContext *ctx)
{
- JSValue ret;
JSBigFloat *p;
-
- p = js_new_bf(ctx);
- bf_memcpy(&p->num, a);
- ret = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
- return ret;
+ p = js_malloc(ctx, sizeof(*p));
+ if (!p)
+ return JS_EXCEPTION;
+ p->header.ref_count = 1;
+ bf_init(ctx->bf_ctx, &p->num);
+ return JS_MKPTR(JS_TAG_BIG_FLOAT, p);
}
-/* WARNING: 'a' is freed */
-static JSValue JS_NewBigDecimal(JSContext *ctx, bfdec_t *a)
+static JSValue JS_NewBigDecimal(JSContext *ctx)
{
- JSValue ret;
JSBigDecimal *p;
-
- p = js_mallocz(ctx, sizeof(*p));
+ p = js_malloc(ctx, sizeof(*p));
if (!p)
return JS_EXCEPTION;
p->header.ref_count = 1;
bfdec_init(ctx->bf_ctx, &p->num);
- bfdec_memcpy(&p->num, a);
- ret = JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
- return ret;
+ return JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
}
-/* WARNING: 'a' is freed */
-static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint)
+static JSValue JS_NewBigInt(JSContext *ctx)
{
- JSValue ret;
JSBigFloat *p;
- int32_t v;
-
- if (!force_bigint && bf_get_int32(&v, a, 0) == 0) {
- /* can fit in an int32 */
- ret = JS_NewInt32(ctx, v);
- bf_delete(a);
- } else {
- p = js_new_bf(ctx);
- bf_memcpy(&p->num, a);
- /* normalize the zero representation */
- if (bf_is_zero(&p->num))
- p->num.sign = 0;
- ret = JS_MKPTR(JS_TAG_BIG_INT, p);
- }
- return ret;
+ p = js_malloc(ctx, sizeof(*p));
+ if (!p)
+ return JS_EXCEPTION;
+ p->header.ref_count = 1;
+ bf_init(ctx->bf_ctx, &p->num);
+ return JS_MKPTR(JS_TAG_BIG_INT, p);
}
-static JSValue JS_NewBigInt(JSContext *ctx, bf_t *a)
+static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
+ BOOL convert_to_safe_integer)
{
- return JS_NewBigInt2(ctx, a, !is_bigint_mode(ctx));
+ int64_t v;
+ bf_t *a;
+
+ if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT)
+ return val; /* fail safe */
+ a = JS_GetBigInt(val);
+ if (convert_to_safe_integer && bf_get_int64(&v, a, 0) == 0 &&
+ v >= -MAX_SAFE_INTEGER && v <= MAX_SAFE_INTEGER) {
+ JS_FreeValue(ctx, val);
+ return JS_NewInt64(ctx, v);
+ } else if (a->expn == BF_EXP_ZERO && a->sign) {
+ JSBigFloat *p = JS_VALUE_GET_PTR(val);
+ assert(p->header.ref_count == 1);
+ a->sign = 0;
+ }
+ return val;
}
-/* return < 0 if exception, 0 if overloading method, 1 if overloading
- operator called */
-static __exception int js_call_binary_op_fallback(JSContext *ctx,
- JSValue *pret,
- JSValueConst op1,
- JSValueConst op2,
- OPCodeEnum op)
-{
- JSAtom op_name;
- JSValue method, ret, c1, c2;
- BOOL bool_result, swap_op;
- JSValueConst args[2];
+/* Convert the big int to a safe integer if in math mode. normalize
+ the zero representation. Could also be used to convert the bigint
+ to a short bigint value. The reference count of the value must be
+ 1. Cannot fail */
+static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val)
+{
+ return JS_CompactBigInt1(ctx, val, is_math_mode(ctx));
+}
+
+/* must be kept in sync with JSOverloadableOperatorEnum */
+static const char *js_overloadable_operator_names[JS_OVOP_COUNT] = {
+ "+",
+ "-",
+ "*",
+ "/",
+ "%",
+ "**",
+ "|",
+ "&",
+ "^",
+ "<<",
+ ">>",
+ ">>>",
+ "==",
+ "<",
+ "pos",
+ "neg",
+ "++",
+ "--",
+ "~",
+};
- bool_result = FALSE;
- swap_op = FALSE;
- c1 = JS_UNDEFINED;
- c2 = JS_UNDEFINED;
+static int get_ovop_from_opcode(OPCodeEnum op)
+{
switch(op) {
case OP_add:
- op_name = JS_ATOM_Symbol_operatorAdd;
- break;
+ return JS_OVOP_ADD;
case OP_sub:
- op_name = JS_ATOM_Symbol_operatorSub;
- break;
+ return JS_OVOP_SUB;
case OP_mul:
- op_name = JS_ATOM_Symbol_operatorMul;
- break;
+ return JS_OVOP_MUL;
case OP_div:
- case OP_math_div:
- op_name = JS_ATOM_Symbol_operatorDiv;
- break;
+ return JS_OVOP_DIV;
case OP_mod:
- op_name = JS_ATOM_Symbol_operatorMod;
- break;
- case OP_pow:
- case OP_math_pow:
- op_name = JS_ATOM_Symbol_operatorPow;
- break;
case OP_math_mod:
- op_name = JS_ATOM_Symbol_operatorMathMod;
- break;
- case OP_shl:
- op_name = JS_ATOM_Symbol_operatorShl;
- break;
- case OP_sar:
- op_name = JS_ATOM_Symbol_operatorShr;
- break;
- case OP_and:
- op_name = JS_ATOM_Symbol_operatorAnd;
- break;
+ return JS_OVOP_MOD;
+ case OP_pow:
+ return JS_OVOP_POW;
case OP_or:
- op_name = JS_ATOM_Symbol_operatorOr;
- break;
+ return JS_OVOP_OR;
+ case OP_and:
+ return JS_OVOP_AND;
case OP_xor:
- op_name = JS_ATOM_Symbol_operatorXor;
- break;
+ return JS_OVOP_XOR;
+ case OP_shl:
+ return JS_OVOP_SHL;
+ case OP_sar:
+ return JS_OVOP_SAR;
+ case OP_shr:
+ return JS_OVOP_SHR;
+ case OP_eq:
+ case OP_neq:
+ return JS_OVOP_EQ;
case OP_lt:
- op_name = JS_ATOM_Symbol_operatorCmpLT;
- bool_result = TRUE;
- break;
case OP_lte:
- op_name = JS_ATOM_Symbol_operatorCmpLE;
- bool_result = TRUE;
- break;
case OP_gt:
- op_name = JS_ATOM_Symbol_operatorCmpLT;
- bool_result = TRUE;
- swap_op = TRUE;
- break;
case OP_gte:
- op_name = JS_ATOM_Symbol_operatorCmpLE;
- bool_result = TRUE;
- swap_op = TRUE;
- break;
- case OP_eq:
- case OP_neq:
- op_name = JS_ATOM_Symbol_operatorCmpEQ;
- bool_result = TRUE;
- break;
+ return JS_OVOP_LESS;
+ case OP_plus:
+ return JS_OVOP_POS;
+ case OP_neg:
+ return JS_OVOP_NEG;
+ case OP_inc:
+ return JS_OVOP_INC;
+ case OP_dec:
+ return JS_OVOP_DEC;
default:
- goto fail;
+ abort();
+ }
+}
+
+/* return NULL if not present */
+static JSObject *find_binary_op(JSBinaryOperatorDef *def,
+ uint32_t operator_index,
+ JSOverloadableOperatorEnum op)
+{
+ JSBinaryOperatorDefEntry *ent;
+ int i;
+ for(i = 0; i < def->count; i++) {
+ ent = &def->tab[i];
+ if (ent->operator_index == operator_index)
+ return ent->ops[op];
}
- c1 = JS_GetProperty(ctx, op1, JS_ATOM_constructor);
- if (JS_IsException(c1))
+ return NULL;
+}
+
+/* return -1 if exception, 0 if no operator overloading, 1 if
+ overloaded operator called */
+static __exception int js_call_binary_op_fallback(JSContext *ctx,
+ JSValue *pret,
+ JSValueConst op1,
+ JSValueConst op2,
+ OPCodeEnum op,
+ BOOL is_numeric,
+ int hint)
+{
+ JSValue opset1_obj, opset2_obj, method, ret, new_op1, new_op2;
+ JSOperatorSetData *opset1, *opset2;
+ JSOverloadableOperatorEnum ovop;
+ JSObject *p;
+ JSValueConst args[2];
+
+ if (!ctx->allow_operator_overloading)
+ return 0;
+
+ opset2_obj = JS_UNDEFINED;
+ opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
+ if (JS_IsException(opset1_obj))
goto exception;
- c2 = JS_GetProperty(ctx, op2, JS_ATOM_constructor);
- if (JS_IsException(c2))
+ if (JS_IsUndefined(opset1_obj))
+ return 0;
+ opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
+ if (!opset1)
goto exception;
- if (JS_VALUE_GET_TAG(c1) != JS_TAG_OBJECT ||
- JS_VALUE_GET_TAG(c2) != JS_TAG_OBJECT)
- goto fail;
- if (JS_VALUE_GET_OBJ(c1) == JS_VALUE_GET_OBJ(c2)) {
- /* if same constructor, there is no ambiguity */
- method = JS_GetProperty(ctx, c1, op_name);
+
+ opset2_obj = JS_GetProperty(ctx, op2, JS_ATOM_Symbol_operatorSet);
+ if (JS_IsException(opset2_obj))
+ goto exception;
+ if (JS_IsUndefined(opset2_obj)) {
+ JS_FreeValue(ctx, opset1_obj);
+ return 0;
+ }
+ opset2 = JS_GetOpaque2(ctx, opset2_obj, JS_CLASS_OPERATOR_SET);
+ if (!opset2)
+ goto exception;
+
+ if (opset1->is_primitive && opset2->is_primitive) {
+ JS_FreeValue(ctx, opset1_obj);
+ JS_FreeValue(ctx, opset2_obj);
+ return 0;
+ }
+
+ ovop = get_ovop_from_opcode(op);
+
+ if (opset1->operator_counter == opset2->operator_counter) {
+ p = opset1->self_ops[ovop];
+ } else if (opset1->operator_counter > opset2->operator_counter) {
+ p = find_binary_op(&opset1->left, opset2->operator_counter, ovop);
} else {
- JSValue val;
- int order1, order2;
+ p = find_binary_op(&opset2->right, opset1->operator_counter, ovop);
+ }
+ if (!p) {
+ JS_ThrowTypeError(ctx, "operator %s: no function defined",
+ js_overloadable_operator_names[ovop]);
+ goto exception;
+ }
- /* different constructors: we use a user-defined ordering */
- val = JS_GetProperty(ctx, c1, JS_ATOM_Symbol_operatorOrder);
- if (JS_IsException(val))
- goto exception;
- if (JS_IsUndefined(val))
- goto undef_order;
- if (JS_ToInt32Free(ctx, &order1, val))
- goto exception;
- val = JS_GetProperty(ctx, c2, JS_ATOM_Symbol_operatorOrder);
- if (JS_IsException(val))
- goto exception;
- if (JS_IsUndefined(val)) {
- undef_order:
- JS_FreeValue(ctx, c1);
- JS_FreeValue(ctx, c2);
- *pret = JS_UNDEFINED;
- return 0;
+ if (opset1->is_primitive) {
+ if (is_numeric) {
+ new_op1 = JS_ToNumeric(ctx, op1);
+ } else {
+ new_op1 = JS_ToPrimitive(ctx, op1, hint);
}
- if (JS_ToInt32Free(ctx, &order2, val))
+ if (JS_IsException(new_op1))
goto exception;
- /* ambiguous priority: error */
- if (order1 == order2) {
- JS_ThrowTypeError(ctx, "operator_order is identical in both constructors");
- goto exception;
- }
- if (order1 > order2) {
- val = c1;
+ } else {
+ new_op1 = JS_DupValue(ctx, op1);
+ }
+
+ if (opset2->is_primitive) {
+ if (is_numeric) {
+ new_op2 = JS_ToNumeric(ctx, op2);
} else {
- val = c2;
+ new_op2 = JS_ToPrimitive(ctx, op2, hint);
}
- method = JS_GetProperty(ctx, val, op_name);
- }
- JS_FreeValue(ctx, c1);
- JS_FreeValue(ctx, c2);
- c1 = JS_UNDEFINED;
- c2 = JS_UNDEFINED;
- if (JS_IsException(method))
- goto exception;
- if (JS_IsUndefined(method) || JS_IsNull(method)) {
- *pret = JS_UNDEFINED;
- return 0;
+ if (JS_IsException(new_op2)) {
+ JS_FreeValue(ctx, new_op1);
+ goto exception;
+ }
+ } else {
+ new_op2 = JS_DupValue(ctx, op2);
}
- if (swap_op) {
- args[0] = op2;
- args[1] = op1;
+
+ /* XXX: could apply JS_ToPrimitive() if primitive type so that the
+ operator function does not get a value object */
+
+ method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+ if (ovop == JS_OVOP_LESS && (op == OP_lte || op == OP_gt)) {
+ args[0] = new_op2;
+ args[1] = new_op1;
} else {
- args[0] = op1;
- args[1] = op2;
+ args[0] = new_op1;
+ args[1] = new_op2;
}
ret = JS_CallFree(ctx, method, JS_UNDEFINED, 2, args);
+ JS_FreeValue(ctx, new_op1);
+ JS_FreeValue(ctx, new_op2);
if (JS_IsException(ret))
goto exception;
- if (bool_result) {
+ if (ovop == JS_OVOP_EQ) {
BOOL res = JS_ToBoolFree(ctx, ret);
if (op == OP_neq)
res ^= 1;
ret = JS_NewBool(ctx, res);
+ } else if (ovop == JS_OVOP_LESS) {
+ if (JS_IsUndefined(ret)) {
+ ret = JS_FALSE;
+ } else {
+ BOOL res = JS_ToBoolFree(ctx, ret);
+ if (op == OP_lte || op == OP_gte)
+ res ^= 1;
+ ret = JS_NewBool(ctx, res);
+ }
}
+ JS_FreeValue(ctx, opset1_obj);
+ JS_FreeValue(ctx, opset2_obj);
*pret = ret;
return 1;
- fail:
- JS_ThrowTypeError(ctx, "invalid types for binary operator");
exception:
- JS_FreeValue(ctx, c1);
- JS_FreeValue(ctx, c2);
+ JS_FreeValue(ctx, opset1_obj);
+ JS_FreeValue(ctx, opset2_obj);
+ *pret = JS_UNDEFINED;
+ return -1;
+}
+
+/* try to call the operation on the operatorSet field of 'obj'. Only
+ used for "/" and "**" on the BigInt prototype in math mode */
+static __exception int js_call_binary_op_simple(JSContext *ctx,
+ JSValue *pret,
+ JSValueConst obj,
+ JSValueConst op1,
+ JSValueConst op2,
+ OPCodeEnum op)
+{
+ JSValue opset1_obj, method, ret, new_op1, new_op2;
+ JSOperatorSetData *opset1;
+ JSOverloadableOperatorEnum ovop;
+ JSObject *p;
+ JSValueConst args[2];
+
+ opset1_obj = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_operatorSet);
+ if (JS_IsException(opset1_obj))
+ goto exception;
+ if (JS_IsUndefined(opset1_obj))
+ return 0;
+ opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
+ if (!opset1)
+ goto exception;
+ ovop = get_ovop_from_opcode(op);
+
+ p = opset1->self_ops[ovop];
+ if (!p) {
+ JS_FreeValue(ctx, opset1_obj);
+ return 0;
+ }
+
+ new_op1 = JS_ToNumeric(ctx, op1);
+ if (JS_IsException(new_op1))
+ goto exception;
+ new_op2 = JS_ToNumeric(ctx, op2);
+ if (JS_IsException(new_op2)) {
+ JS_FreeValue(ctx, new_op1);
+ goto exception;
+ }
+
+ method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+ args[0] = new_op1;
+ args[1] = new_op2;
+ ret = JS_CallFree(ctx, method, JS_UNDEFINED, 2, args);
+ JS_FreeValue(ctx, new_op1);
+ JS_FreeValue(ctx, new_op2);
+ if (JS_IsException(ret))
+ goto exception;
+ JS_FreeValue(ctx, opset1_obj);
+ *pret = ret;
+ return 1;
+ exception:
+ JS_FreeValue(ctx, opset1_obj);
+ *pret = JS_UNDEFINED;
+ return -1;
+}
+
+/* return -1 if exception, 0 if no operator overloading, 1 if
+ overloaded operator called */
+static __exception int js_call_unary_op_fallback(JSContext *ctx,
+ JSValue *pret,
+ JSValueConst op1,
+ OPCodeEnum op)
+{
+ JSValue opset1_obj, method, ret;
+ JSOperatorSetData *opset1;
+ JSOverloadableOperatorEnum ovop;
+ JSObject *p;
+
+ if (!ctx->allow_operator_overloading)
+ return 0;
+
+ opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
+ if (JS_IsException(opset1_obj))
+ goto exception;
+ if (JS_IsUndefined(opset1_obj))
+ return 0;
+ opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
+ if (!opset1)
+ goto exception;
+ if (opset1->is_primitive) {
+ JS_FreeValue(ctx, opset1_obj);
+ return 0;
+ }
+
+ ovop = get_ovop_from_opcode(op);
+
+ p = opset1->self_ops[ovop];
+ if (!p) {
+ JS_ThrowTypeError(ctx, "no overloaded operator %s",
+ js_overloadable_operator_names[ovop]);
+ goto exception;
+ }
+ method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+ ret = JS_CallFree(ctx, method, JS_UNDEFINED, 1, &op1);
+ if (JS_IsException(ret))
+ goto exception;
+ JS_FreeValue(ctx, opset1_obj);
+ *pret = ret;
+ return 1;
+ exception:
+ JS_FreeValue(ctx, opset1_obj);
*pret = JS_UNDEFINED;
return -1;
}
static int js_unary_arith_bigint(JSContext *ctx,
JSValue *pres, OPCodeEnum op, JSValue op1)
{
- bf_t a_s, r_s, *r = &r_s, *a;
+ bf_t a_s, *r, *a;
int ret, v;
+ JSValue res;
- if (op == OP_plus && !is_bigint_mode(ctx)) {
+ if (op == OP_plus && !is_math_mode(ctx)) {
JS_ThrowTypeError(ctx, "bigint argument with unary +");
JS_FreeValue(ctx, op1);
return -1;
}
+ res = JS_NewBigInt(ctx);
+ if (JS_IsException(res)) {
+ JS_FreeValue(ctx, op1);
+ return -1;
+ }
+ r = JS_GetBigInt(res);
a = JS_ToBigInt(ctx, &a_s, op1);
- bf_init(ctx->bf_ctx, r);
ret = 0;
switch(op) {
case OP_inc:
JS_FreeBigInt(ctx, a, &a_s);
JS_FreeValue(ctx, op1);
if (unlikely(ret)) {
- bf_delete(r);
+ JS_FreeValue(ctx, res);
throw_bf_exception(ctx, ret);
return -1;
}
- *pres = JS_NewBigInt(ctx, r);
+ res = JS_CompactBigInt(ctx, res);
+ *pres = res;
return 0;
}
static int js_unary_arith_bigfloat(JSContext *ctx,
JSValue *pres, OPCodeEnum op, JSValue op1)
{
- bf_t a_s, r_s, *r = &r_s, *a;
+ bf_t a_s, *r, *a;
int ret, v;
+ JSValue res;
- if (op == OP_plus && !is_bigint_mode(ctx)) {
+ if (op == OP_plus && !is_math_mode(ctx)) {
JS_ThrowTypeError(ctx, "bigfloat argument with unary +");
JS_FreeValue(ctx, op1);
return -1;
}
+ res = JS_NewBigFloat(ctx);
+ if (JS_IsException(res)) {
+ JS_FreeValue(ctx, op1);
+ return -1;
+ }
+ r = JS_GetBigFloat(res);
a = JS_ToBigFloat(ctx, &a_s, op1);
- bf_init(ctx->bf_ctx, r);
ret = 0;
switch(op) {
case OP_inc:
bf_delete(a);
JS_FreeValue(ctx, op1);
if (unlikely(ret & BF_ST_MEM_ERROR)) {
- bf_delete(r);
+ JS_FreeValue(ctx, res);
throw_bf_exception(ctx, ret);
return -1;
}
- *pres = JS_NewBigFloat(ctx, r);
+ *pres = res;
return 0;
}
static int js_unary_arith_bigdecimal(JSContext *ctx,
JSValue *pres, OPCodeEnum op, JSValue op1)
{
- bfdec_t r_s, *r = &r_s, *a;
+ bfdec_t *r, *a;
int ret, v;
-
- if (op == OP_plus && !is_bigint_mode(ctx)) {
+ JSValue res;
+
+ if (op == OP_plus && !is_math_mode(ctx)) {
JS_ThrowTypeError(ctx, "bigdecimal argument with unary +");
JS_FreeValue(ctx, op1);
return -1;
}
+ res = JS_NewBigDecimal(ctx);
+ if (JS_IsException(res)) {
+ JS_FreeValue(ctx, op1);
+ return -1;
+ }
+ r = JS_GetBigDecimal(res);
a = JS_ToBigDecimal(ctx, op1);
- bfdec_init(ctx->bf_ctx, r);
ret = 0;
switch(op) {
case OP_inc:
}
JS_FreeValue(ctx, op1);
if (unlikely(ret)) {
- bfdec_delete(r);
+ JS_FreeValue(ctx, res);
throw_bf_exception(ctx, ret);
return -1;
}
- *pres = JS_NewBigDecimal(ctx, r);
+ *pres = res;
return 0;
}
JSValue *sp,
OPCodeEnum op)
{
- JSValue op1, val, method;
- BOOL is_legacy;
- JSAtom op_name;
- int v;
+ JSValue op1, val;
+ int v, ret;
uint32_t tag;
op1 = sp[-1];
/* fast path for float64 */
if (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(op1)))
goto handle_float64;
- if (JS_IsObject(op1) && ctx->bignum_ext) {
- switch(op) {
- case OP_plus:
- op_name = JS_ATOM_Symbol_operatorPlus;
- break;
- case OP_neg:
- op_name = JS_ATOM_Symbol_operatorNeg;
- break;
- case OP_inc:
- op_name = JS_ATOM_Symbol_operatorInc;
- break;
- case OP_dec:
- op_name = JS_ATOM_Symbol_operatorDec;
- break;
- default:
- abort();
- }
- method = JS_GetProperty(ctx, op1, op_name);
- if (JS_IsException(method))
- return -1;
- if (JS_IsUndefined(method) || JS_IsNull(method))
- goto to_number;
- val = JS_CallFree(ctx, method, op1, 0, NULL);
- if (JS_IsException(val))
+ if (JS_IsObject(op1)) {
+ ret = js_call_unary_op_fallback(ctx, &val, op1, op);
+ if (ret < 0)
return -1;
- JS_FreeValue(ctx, op1);
- sp[-1] = val;
- } else {
- to_number:
- op1 = JS_ToNumericFree(ctx, op1);
- if (JS_IsException(op1))
- goto exception;
- is_legacy = is_bigint_mode(ctx) ^ 1;
- tag = JS_VALUE_GET_TAG(op1);
- switch(tag) {
- case JS_TAG_INT:
- {
- int64_t v64;
- v64 = JS_VALUE_GET_INT(op1);
- switch(op) {
- case OP_inc:
- case OP_dec:
- v = 2 * (op - OP_dec) - 1;
- v64 += v;
- break;
- case OP_plus:
- break;
- case OP_neg:
- if (v64 == 0 && is_legacy) {
- sp[-1] = __JS_NewFloat64(ctx, -0.0);
- return 0;
- } else {
- v64 = -v64;
- }
- break;
- default:
- abort();
+ if (ret) {
+ JS_FreeValue(ctx, op1);
+ sp[-1] = val;
+ return 0;
+ }
+ }
+
+ op1 = JS_ToNumericFree(ctx, op1);
+ if (JS_IsException(op1))
+ goto exception;
+ tag = JS_VALUE_GET_TAG(op1);
+ switch(tag) {
+ case JS_TAG_INT:
+ {
+ int64_t v64;
+ v64 = JS_VALUE_GET_INT(op1);
+ switch(op) {
+ case OP_inc:
+ case OP_dec:
+ v = 2 * (op - OP_dec) - 1;
+ v64 += v;
+ break;
+ case OP_plus:
+ break;
+ case OP_neg:
+ if (v64 == 0) {
+ sp[-1] = __JS_NewFloat64(ctx, -0.0);
+ return 0;
+ } else {
+ v64 = -v64;
}
- sp[-1] = JS_NewInt64(ctx, v64);
+ break;
+ default:
+ abort();
}
- break;
- case JS_TAG_BIG_INT:
- if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, op, op1))
- goto exception;
- break;
- case JS_TAG_BIG_FLOAT:
- if (ctx->rt->bigfloat_ops.unary_arith(ctx, sp - 1, op, op1))
- goto exception;
- break;
- case JS_TAG_BIG_DECIMAL:
- if (ctx->rt->bigdecimal_ops.unary_arith(ctx, sp - 1, op, op1))
- goto exception;
- break;
- default:
- handle_float64:
- {
- double d;
- d = JS_VALUE_GET_FLOAT64(op1);
- switch(op) {
- case OP_inc:
- case OP_dec:
- v = 2 * (op - OP_dec) - 1;
- d += v;
- break;
- case OP_plus:
- break;
- case OP_neg:
- d = -d;
- break;
- default:
- abort();
- }
- sp[-1] = __JS_NewFloat64(ctx, d);
+ sp[-1] = JS_NewInt64(ctx, v64);
+ }
+ break;
+ case JS_TAG_BIG_INT:
+ handle_bigint:
+ if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, op, op1))
+ goto exception;
+ break;
+ case JS_TAG_BIG_FLOAT:
+ if (ctx->rt->bigfloat_ops.unary_arith(ctx, sp - 1, op, op1))
+ goto exception;
+ break;
+ case JS_TAG_BIG_DECIMAL:
+ if (ctx->rt->bigdecimal_ops.unary_arith(ctx, sp - 1, op, op1))
+ goto exception;
+ break;
+ default:
+ handle_float64:
+ {
+ double d;
+ if (is_math_mode(ctx))
+ goto handle_bigint;
+ d = JS_VALUE_GET_FLOAT64(op1);
+ switch(op) {
+ case OP_inc:
+ case OP_dec:
+ v = 2 * (op - OP_dec) - 1;
+ d += v;
+ break;
+ case OP_plus:
+ break;
+ case OP_neg:
+ d = -d;
+ break;
+ default:
+ abort();
}
- break;
+ sp[-1] = __JS_NewFloat64(ctx, d);
}
+ break;
}
return 0;
exception:
static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
{
- JSValue op1, method, val;
-
+ JSValue op1, val;
+ int ret;
+
op1 = sp[-1];
if (JS_IsObject(op1)) {
- if (!ctx->bignum_ext)
- goto to_number;
- method = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorNot);
- if (JS_IsException(method))
- return -1;
- if (JS_IsUndefined(method) || JS_IsNull(method))
- goto to_number;
- val = JS_CallFree(ctx, method, op1, 0, NULL);
- if (JS_IsException(val))
+ ret = js_call_unary_op_fallback(ctx, &val, op1, OP_not);
+ if (ret < 0)
return -1;
- JS_FreeValue(ctx, op1);
- sp[-1] = val;
- } else {
- if (JS_IsString(op1)) {
- to_number:
- op1 = JS_ToNumberHintFree(ctx, op1, TON_FLAG_INTEGER);
- if (JS_IsException(op1))
- goto exception;
- }
- if (is_bigint_mode(ctx) || JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT) {
- if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, OP_not, op1))
- goto exception;
- } else {
- int32_t v1;
- if (unlikely(JS_ToInt32Free(ctx, &v1, op1)))
- goto exception;
- sp[-1] = JS_NewInt32(ctx, ~v1);
+ if (ret) {
+ JS_FreeValue(ctx, op1);
+ sp[-1] = val;
+ return 0;
}
}
+
+ op1 = JS_ToNumericFree(ctx, op1);
+ if (JS_IsException(op1))
+ goto exception;
+ if (is_math_mode(ctx) || JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT) {
+ if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, OP_not, op1))
+ goto exception;
+ } else {
+ int32_t v1;
+ if (unlikely(JS_ToInt32Free(ctx, &v1, op1)))
+ goto exception;
+ sp[-1] = JS_NewInt32(ctx, ~v1);
+ }
return 0;
exception:
sp[-1] = JS_UNDEFINED;
static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
JSValue *pres, JSValue op1, JSValue op2)
{
- bf_t a_s, b_s, r_s, *r, *a, *b;
- int ret, rnd_mode;
+ bf_t a_s, b_s, *r, *a, *b;
+ int ret;
+ JSValue res;
+ res = JS_NewBigFloat(ctx);
+ if (JS_IsException(res)) {
+ JS_FreeValue(ctx, op1);
+ JS_FreeValue(ctx, op2);
+ return -1;
+ }
+ r = JS_GetBigFloat(res);
a = JS_ToBigFloat(ctx, &a_s, op1);
b = JS_ToBigFloat(ctx, &b_s, op2);
- r = &r_s;
bf_init(ctx->bf_ctx, r);
switch(op) {
case OP_add:
case OP_mul:
ret = bf_mul(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
break;
- case OP_math_div:
case OP_div:
ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
break;
case OP_math_mod:
/* Euclidian remainder */
- rnd_mode = BF_DIVREM_EUCLIDIAN;
- goto do_mod;
+ ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
+ BF_DIVREM_EUCLIDIAN);
+ break;
case OP_mod:
- rnd_mode = BF_RNDZ;
- do_mod:
- {
- bf_t q_s, *q = &q_s;
- bf_init(ctx->bf_ctx, q);
- ret = bf_divrem(q, r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
- rnd_mode);
- bf_delete(q);
- }
+ ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
+ BF_RNDZ);
break;
case OP_pow:
- case OP_math_pow:
ret = bf_pow(r, a, b, ctx->fp_env.prec,
- ctx->fp_env.flags | BF_POW_JS_QUICKS);
+ ctx->fp_env.flags | BF_POW_JS_QUIRKS);
break;
default:
abort();
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
if (unlikely(ret & BF_ST_MEM_ERROR)) {
- bf_delete(r);
+ JS_FreeValue(ctx, res);
throw_bf_exception(ctx, ret);
return -1;
}
- *pres = JS_NewBigFloat(ctx, r);
+ *pres = res;
return 0;
}
static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
JSValue *pres, JSValue op1, JSValue op2)
{
- bf_t a_s, b_s, r_s, *r, *a, *b;
- int ret, rnd_mode;
+ bf_t a_s, b_s, *r, *a, *b;
+ int ret;
JSValue res;
+ res = JS_NewBigInt(ctx);
+ if (JS_IsException(res))
+ goto fail;
a = JS_ToBigInt(ctx, &a_s, op1);
if (!a)
goto fail;
JS_FreeBigInt(ctx, a, &a_s);
goto fail;
}
- r = &r_s;
- bf_init(ctx->bf_ctx, r);
+ r = JS_GetBigInt(res);
ret = 0;
switch(op) {
case OP_add:
case OP_mul:
ret = bf_mul(r, a, b, BF_PREC_INF, BF_RNDZ);
break;
- case OP_math_div:
- goto op_fallback;
case OP_div:
- if (!is_bigint_mode(ctx)) {
+ if (!is_math_mode(ctx)) {
bf_t rem_s, *rem = &rem_s;
bf_init(ctx->bf_ctx, rem);
ret = bf_divrem(r, rem, a, b, BF_PREC_INF, BF_RNDZ,
BF_RNDZ);
bf_delete(rem);
} else {
- bf_div(r, a, b, 53, bf_set_exp_bits(11) |
- BF_RNDN | BF_FLAG_SUBNORMAL);
- goto float64_result;
+ goto math_mode_div_pow;
}
break;
case OP_math_mod:
/* Euclidian remainder */
- rnd_mode = BF_DIVREM_EUCLIDIAN;
- goto do_int_mod;
+ ret = bf_rem(r, a, b, BF_PREC_INF, BF_RNDZ,
+ BF_DIVREM_EUCLIDIAN) & BF_ST_INVALID_OP;
+ break;
case OP_mod:
- rnd_mode = BF_RNDZ;
- do_int_mod:
- {
- bf_t q_s, *q = &q_s;
- bf_init(ctx->bf_ctx, q);
- ret = bf_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ,
- rnd_mode) & BF_ST_INVALID_OP;
- bf_delete(q);
- }
+ ret = bf_rem(r, a, b, BF_PREC_INF, BF_RNDZ,
+ BF_RNDZ) & BF_ST_INVALID_OP;
break;
case OP_pow:
- case OP_math_pow:
if (b->sign) {
- if (!is_bigint_mode(ctx)) {
+ if (!is_math_mode(ctx)) {
ret = BF_ST_INVALID_OP;
- } else if (op == OP_math_pow) {
- op_fallback:
- bf_delete(r);
+ } else {
+ math_mode_div_pow:
+ JS_FreeValue(ctx, res);
+ ret = js_call_binary_op_simple(ctx, &res, ctx->class_proto[JS_CLASS_BIG_INT], op1, op2, op);
+ if (ret != 0) {
+ JS_FreeBigInt(ctx, a, &a_s);
+ JS_FreeBigInt(ctx, b, &b_s);
+ JS_FreeValue(ctx, op1);
+ JS_FreeValue(ctx, op2);
+ if (ret < 0) {
+ return -1;
+ } else {
+ *pres = res;
+ return 0;
+ }
+ }
+ /* if no BigInt power operator defined, return a
+ bigfloat */
+ res = JS_NewBigFloat(ctx);
+ if (JS_IsException(res)) {
+ JS_FreeBigInt(ctx, a, &a_s);
+ JS_FreeBigInt(ctx, b, &b_s);
+ goto fail;
+ }
+ r = JS_GetBigFloat(res);
+ if (op == OP_div) {
+ ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags) & BF_ST_MEM_ERROR;
+ } else {
+ ret = bf_pow(r, a, b, ctx->fp_env.prec,
+ ctx->fp_env.flags | BF_POW_JS_QUIRKS) & BF_ST_MEM_ERROR;
+ }
JS_FreeBigInt(ctx, a, &a_s);
JS_FreeBigInt(ctx, b, &b_s);
- ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
- if (ret < 0) {
- return -1;
- } else if (ret == 0) {
- JS_ThrowTypeError(ctx, "operator must be defined for exact division or power");
+ if (unlikely(ret)) {
+ JS_FreeValue(ctx, res);
+ throw_bf_exception(ctx, ret);
return -1;
}
*pres = res;
return 0;
- } else {
- double dr;
- bf_pow(r, a, b, 53, bf_set_exp_bits(11) |
- BF_RNDN | BF_FLAG_SUBNORMAL);
- float64_result:
- bf_get_float64(r, &dr, BF_RNDN);
- bf_delete(r);
- JS_FreeBigInt(ctx, a, &a_s);
- JS_FreeBigInt(ctx, b, &b_s);
- JS_FreeValue(ctx, op1);
- JS_FreeValue(ctx, op2);
- *pres = __JS_NewFloat64(ctx, dr);
- return 0;
}
} else {
- ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUICKS);
+ ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUIRKS);
}
break;
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
if (unlikely(ret)) {
- bf_delete(r);
+ JS_FreeValue(ctx, res);
throw_bf_exception(ctx, ret);
return -1;
}
- *pres = JS_NewBigInt(ctx, r);
+ *pres = JS_CompactBigInt(ctx, res);
return 0;
fail:
+ JS_FreeValue(ctx, res);
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
return -1;
static int js_binary_arith_bigdecimal(JSContext *ctx, OPCodeEnum op,
JSValue *pres, JSValue op1, JSValue op2)
{
- bfdec_t r_s, *r, *a, *b;
- int ret, rnd_mode;
-
- /* big decimal result */
+ bfdec_t *r, *a, *b;
+ int ret;
+ JSValue res;
+
+ res = JS_NewBigDecimal(ctx);
+ if (JS_IsException(res))
+ goto fail;
+ r = JS_GetBigDecimal(res);
+
a = JS_ToBigDecimal(ctx, op1);
if (!a)
goto fail;
b = JS_ToBigDecimal(ctx, op2);
if (!b)
goto fail;
- r = &r_s;
- bfdec_init(ctx->bf_ctx, r);
switch(op) {
case OP_add:
ret = bfdec_add(r, a, b, BF_PREC_INF, BF_RNDZ);
case OP_mul:
ret = bfdec_mul(r, a, b, BF_PREC_INF, BF_RNDZ);
break;
- case OP_math_div:
case OP_div:
ret = bfdec_div(r, a, b, BF_PREC_INF, BF_RNDZ);
break;
case OP_math_mod:
/* Euclidian remainder */
- rnd_mode = BF_DIVREM_EUCLIDIAN;
- goto do_mod_dec;
+ ret = bfdec_rem(r, a, b, BF_PREC_INF, BF_RNDZ, BF_DIVREM_EUCLIDIAN);
+ break;
case OP_mod:
- rnd_mode = BF_RNDZ;
- do_mod_dec:
- {
- bfdec_t q_s, *q = &q_s;
- bfdec_init(ctx->bf_ctx, q);
- ret = bfdec_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ, rnd_mode);
- bfdec_delete(q);
- }
+ ret = bfdec_rem(r, a, b, BF_PREC_INF, BF_RNDZ, BF_RNDZ);
break;
case OP_pow:
- case OP_math_pow:
ret = js_bfdec_pow(r, a, b);
break;
default:
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
if (unlikely(ret)) {
- bfdec_delete(r);
+ JS_FreeValue(ctx, res);
throw_bf_exception(ctx, ret);
return -1;
}
- *pres = JS_NewBigDecimal(ctx, r);
+ *pres = res;
return 0;
fail:
+ JS_FreeValue(ctx, res);
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
return -1;
OPCodeEnum op)
{
JSValue op1, op2, res;
- BOOL is_legacy;
uint32_t tag1, tag2;
int ret;
double d1, d2;
}
/* try to call an overloaded operator */
- if (((tag1 == JS_TAG_OBJECT &&
- (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
- (tag2 == JS_TAG_OBJECT &&
- (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
- ctx->bignum_ext) {
- ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
+ if ((tag1 == JS_TAG_OBJECT &&
+ (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+ (tag2 == JS_TAG_OBJECT &&
+ (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+ ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
if (ret != 0) {
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
int64_t v;
v1 = JS_VALUE_GET_INT(op1);
v2 = JS_VALUE_GET_INT(op2);
- is_legacy = is_bigint_mode(ctx) ^ 1;
switch(op) {
case OP_sub:
v = (int64_t)v1 - (int64_t)v2;
break;
case OP_mul:
v = (int64_t)v1 * (int64_t)v2;
- if (is_legacy && v == 0 && (v1 | v2) < 0) {
+ if (is_math_mode(ctx) &&
+ (v < -MAX_SAFE_INTEGER || v > MAX_SAFE_INTEGER))
+ goto handle_bigint;
+ if (v == 0 && (v1 | v2) < 0) {
sp[-2] = __JS_NewFloat64(ctx, -0.0);
return 0;
}
break;
- case OP_math_div:
- if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
- goto exception;
- return 0;
case OP_div:
+ if (is_math_mode(ctx))
+ goto handle_bigint;
sp[-2] = __JS_NewFloat64(ctx, (double)v1 / (double)v2);
return 0;
case OP_math_mod:
}
break;
case OP_mod:
- if (is_legacy && (v1 < 0 || v2 <= 0)) {
+ if (v1 < 0 || v2 <= 0) {
sp[-2] = JS_NewFloat64(ctx, fmod(v1, v2));
return 0;
} else {
- if (unlikely(v2 == 0)) {
- throw_bf_exception(ctx, BF_ST_DIVIDE_ZERO);
- goto exception;
- }
v = (int64_t)v1 % (int64_t)v2;
}
break;
case OP_pow:
- case OP_math_pow:
- if (is_legacy) {
+ if (!is_math_mode(ctx)) {
sp[-2] = JS_NewFloat64(ctx, js_pow(v1, v2));
return 0;
} else {
- if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
- goto exception;
- return 0;
+ goto handle_bigint;
}
break;
default:
} else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
if (ctx->rt->bigfloat_ops.binary_arith(ctx, op, sp - 2, op1, op2))
goto exception;
+ } else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
+ handle_bigint:
+ if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+ goto exception;
} else if (tag1 == JS_TAG_FLOAT64 || tag2 == JS_TAG_FLOAT64) {
double dr;
/* float64 result */
if (JS_ToFloat64Free(ctx, &d2, op2))
goto exception;
handle_float64:
+ if (is_math_mode(ctx) && is_safe_integer(d1) && is_safe_integer(d2))
+ goto handle_bigint;
switch(op) {
case OP_sub:
dr = d1 - d2;
dr = d1 * d2;
break;
case OP_div:
- case OP_math_div:
dr = d1 / d2;
break;
case OP_mod:
dr += d2;
break;
case OP_pow:
- case OP_math_pow:
dr = js_pow(d1, d2);
break;
default:
abort();
}
sp[-2] = __JS_NewFloat64(ctx, dr);
- } else {
- if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
- goto exception;
}
return 0;
exception:
if (tag1 == JS_TAG_OBJECT || tag2 == JS_TAG_OBJECT) {
/* try to call an overloaded operator */
- if (((tag1 == JS_TAG_OBJECT &&
- (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
- (tag2 == JS_TAG_OBJECT &&
- (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
- ctx->bignum_ext) {
- ret = js_call_binary_op_fallback(ctx, &res, op1, op2, OP_add);
+ if ((tag1 == JS_TAG_OBJECT &&
+ (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED &&
+ tag2 != JS_TAG_STRING)) ||
+ (tag2 == JS_TAG_OBJECT &&
+ (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED &&
+ tag1 != JS_TAG_STRING))) {
+ ret = js_call_binary_op_fallback(ctx, &res, op1, op2, OP_add,
+ FALSE, HINT_NONE);
if (ret != 0) {
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
JSValue op1, op2, res;
int ret;
uint32_t tag1, tag2;
+ uint32_t v1, v2, r;
op1 = sp[-2];
op2 = sp[-1];
tag2 = JS_VALUE_GET_NORM_TAG(op2);
/* try to call an overloaded operator */
- if (((tag1 == JS_TAG_OBJECT &&
- (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
- (tag2 == JS_TAG_OBJECT &&
- (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
- ctx->bignum_ext) {
- ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
+ if ((tag1 == JS_TAG_OBJECT &&
+ (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+ (tag2 == JS_TAG_OBJECT &&
+ (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+ ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
if (ret != 0) {
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
}
}
- op1 = JS_ToNumberHintFree(ctx, op1, TON_FLAG_INTEGER);
+ op1 = JS_ToNumericFree(ctx, op1);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
goto exception;
}
- op2 = JS_ToNumberHintFree(ctx, op2, TON_FLAG_INTEGER);
+ op2 = JS_ToNumericFree(ctx, op2);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
goto exception;
}
- if (!is_bigint_mode(ctx)) {
- uint32_t v1, v2, r;
+ if (is_math_mode(ctx))
+ goto bigint_op;
- tag1 = JS_VALUE_GET_TAG(op1);
- tag2 = JS_VALUE_GET_TAG(op2);
- if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
- if (tag1 != tag2) {
- JS_FreeValue(ctx, op1);
- JS_FreeValue(ctx, op2);
- JS_ThrowTypeError(ctx, "both operands must be bigint");
- goto exception;
- } else {
- goto bigint_op;
- }
+ tag1 = JS_VALUE_GET_TAG(op1);
+ tag2 = JS_VALUE_GET_TAG(op2);
+ if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
+ if (tag1 != tag2) {
+ JS_FreeValue(ctx, op1);
+ JS_FreeValue(ctx, op2);
+ JS_ThrowTypeError(ctx, "both operands must be bigint");
+ goto exception;
} else {
- if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v1, op1))) {
- JS_FreeValue(ctx, op2);
- goto exception;
- }
- if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v2, op2)))
+ bigint_op:
+ if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
goto exception;
- switch(op) {
- case OP_shl:
- r = v1 << (v2 & 0x1f);
- break;
- case OP_sar:
- r = (int)v1 >> (v2 & 0x1f);
- break;
- case OP_and:
- r = v1 & v2;
- break;
- case OP_or:
- r = v1 | v2;
- break;
- case OP_xor:
- r = v1 ^ v2;
- break;
- default:
- abort();
- }
- sp[-2] = JS_NewInt32(ctx, r);
}
} else {
- bigint_op:
- if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+ if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v1, op1))) {
+ JS_FreeValue(ctx, op2);
+ goto exception;
+ }
+ if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v2, op2)))
goto exception;
+ switch(op) {
+ case OP_shl:
+ r = v1 << (v2 & 0x1f);
+ break;
+ case OP_sar:
+ r = (int)v1 >> (v2 & 0x1f);
+ break;
+ case OP_and:
+ r = v1 & v2;
+ break;
+ case OP_or:
+ r = v1 | v2;
+ break;
+ case OP_xor:
+ r = v1 ^ v2;
+ break;
+ default:
+ abort();
+ }
+ sp[-2] = JS_NewInt32(ctx, r);
}
return 0;
exception:
tag1 = JS_VALUE_GET_NORM_TAG(op1);
tag2 = JS_VALUE_GET_NORM_TAG(op2);
/* try to call an overloaded operator */
- if (((tag1 == JS_TAG_OBJECT &&
- (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
- (tag2 == JS_TAG_OBJECT &&
- (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
- ctx->bignum_ext) {
- res = js_call_binary_op_fallback(ctx, &ret, op1, op2, op);
+ if ((tag1 == JS_TAG_OBJECT &&
+ (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+ (tag2 == JS_TAG_OBJECT &&
+ (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+ res = js_call_binary_op_fallback(ctx, &ret, op1, op2, op,
+ FALSE, HINT_NUMBER);
if (res != 0) {
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
} else {
if (((tag1 == JS_TAG_BIG_INT && tag2 == JS_TAG_STRING) ||
(tag2 == JS_TAG_BIG_INT && tag1 == JS_TAG_STRING)) &&
- !is_bigint_mode(ctx)) {
+ !is_math_mode(ctx)) {
if (tag1 == JS_TAG_STRING) {
op1 = JS_StringToBigInt(ctx, op1);
if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT)
goto exception;
}
} else if (tag1 == tag2) {
- if (tag1 == JS_TAG_OBJECT && ctx->bignum_ext) {
+ if (tag1 == JS_TAG_OBJECT) {
/* try the fallback operator */
res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
- is_neq ? OP_neq : OP_eq);
+ is_neq ? OP_neq : OP_eq,
+ FALSE, HINT_NONE);
if (res != 0) {
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
(tag2 == JS_TAG_STRING && tag_is_number(tag1))) {
if ((tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) &&
- !is_bigint_mode(ctx)) {
+ !is_math_mode(ctx)) {
if (tag1 == JS_TAG_STRING) {
op1 = JS_StringToBigInt(ctx, op1);
if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT)
/* try the fallback operator */
res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
- is_neq ? OP_neq : OP_eq);
+ is_neq ? OP_neq : OP_eq,
+ FALSE, HINT_NONE);
if (res != 0) {
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
goto exception;
}
/* XXX: could forbid >>> in bignum mode */
- if (!is_bigint_mode(ctx) &&
+ if (!is_math_mode(ctx) &&
(JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT ||
JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_INT)) {
JS_ThrowTypeError(ctx, "bigint operands are forbidden for >>>");
static no_inline int js_mul_pow10(JSContext *ctx, JSValue *sp)
{
- bf_t a_s, *a, r_s, *r = &r_s;
- JSValue op1, op2;
- slimb_t e;
+ bf_t a_s, *a, *r;
+ JSValue op1, op2, res;
+ int64_t e;
int ret;
+ res = JS_NewBigFloat(ctx);
+ if (JS_IsException(res))
+ return -1;
+ r = JS_GetBigFloat(res);
op1 = sp[-2];
op2 = sp[-1];
a = JS_ToBigFloat(ctx, &a_s, op1);
if (!a)
return -1;
-#if LIMB_BITS == 32
- ret = JS_ToInt32(ctx, &e, op2);
-#else
- ret = JS_ToInt64(ctx, &e, op2);
-#endif
+ if (JS_IsBigInt(ctx, op2)) {
+ ret = JS_ToBigInt64(ctx, &e, op2);
+ } else {
+ ret = JS_ToInt64(ctx, &e, op2);
+ }
if (ret) {
if (a == &a_s)
bf_delete(a);
+ JS_FreeValue(ctx, res);
return -1;
}
- bf_init(ctx->bf_ctx, r);
bf_mul_pow_radix(r, a, 10, e, ctx->fp_env.prec, ctx->fp_env.flags);
if (a == &a_s)
bf_delete(a);
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
- sp[-2] = JS_NewBigFloat(ctx, r);
+ sp[-2] = res;
return 0;
}
d2 = JS_VALUE_GET_INT(op2);
goto number_test;
} else if (tag2 == JS_TAG_FLOAT64) {
-#ifdef CONFIG_BIGNUM
- if (is_bigint_mode(ctx)) {
- res = FALSE;
- } else
-#endif
- {
- d2 = JS_VALUE_GET_FLOAT64(op2);
- goto number_test;
- }
- } else
-#ifdef CONFIG_BIGNUM
- if (tag2 == JS_TAG_BIG_INT && is_bigint_mode(ctx)) {
- goto bigint_test;
- } else
-#endif
- {
+ d2 = JS_VALUE_GET_FLOAT64(op2);
+ goto number_test;
+ } else {
res = FALSE;
}
break;
d1 = JS_VALUE_GET_FLOAT64(op1);
if (tag2 == JS_TAG_FLOAT64) {
d2 = JS_VALUE_GET_FLOAT64(op2);
- } else if (tag2 == JS_TAG_INT
-#ifdef CONFIG_BIGNUM
- && !is_bigint_mode(ctx)
-#endif
- ) {
+ } else if (tag2 == JS_TAG_INT) {
d2 = JS_VALUE_GET_INT(op2);
} else {
res = FALSE;
case JS_TAG_BIG_INT:
{
bf_t a_s, *a, b_s, *b;
- if (tag1 == tag2) {
- /* OK */
- } else if (tag2 == JS_TAG_INT && is_bigint_mode(ctx)) {
- /* OK */
- } else {
+ if (tag1 != tag2) {
res = FALSE;
break;
}
- bigint_test:
a = JS_ToBigFloat(ctx, &a_s, op1);
b = JS_ToBigFloat(ctx, &b_s, op2);
res = bf_cmp_eq(a, b);
tag = JS_VALUE_GET_NORM_TAG(op1);
switch(tag) {
#ifdef CONFIG_BIGNUM
- case JS_TAG_INT:
- if (is_bigint_mode(ctx))
- atom = JS_ATOM_bigint;
- else
- atom = JS_ATOM_number;
- break;
case JS_TAG_BIG_INT:
atom = JS_ATOM_bigint;
break;
- case JS_TAG_FLOAT64:
- atom = JS_ATOM_number;
- break;
case JS_TAG_BIG_FLOAT:
atom = JS_ATOM_bigfloat;
break;
case JS_TAG_BIG_DECIMAL:
atom = JS_ATOM_bigdecimal;
break;
-#else
+#endif
case JS_TAG_INT:
case JS_TAG_FLOAT64:
atom = JS_ATOM_number;
break;
-#endif
case JS_TAG_UNDEFINED:
atom = JS_ATOM_undefined;
break;
/* we only propagate the bignum mode as some runtime functions
test it */
if (prev_sf)
- sf->js_mode = prev_sf->js_mode & JS_MODE_BIGINT;
+ sf->js_mode = prev_sf->js_mode & JS_MODE_MATH;
else
sf->js_mode = 0;
#else
v1 = JS_VALUE_GET_INT(op1);
v2 = JS_VALUE_GET_INT(op2);
r = (int64_t)v1 * v2;
-#ifdef CONFIG_BIGNUM
- if (unlikely((int)r != r) || (r == 0 && !is_bigint_mode(ctx)))
- goto binary_arith_slow;
-#else
if (unlikely((int)r != r)) {
+#ifdef CONFIG_BIGNUM
+ if (unlikely(sf->js_mode & JS_MODE_MATH) &&
+ (r < -MAX_SAFE_INTEGER || r > MAX_SAFE_INTEGER))
+ goto binary_arith_slow;
+#endif
d = (double)r;
goto mul_fp_res;
}
d = -0.0;
goto mul_fp_res;
}
-#endif
sp[-2] = JS_NewInt32(ctx, r);
sp--;
} else if (JS_VALUE_IS_BOTH_FLOAT(op1, op2)) {
+#ifdef CONFIG_BIGNUM
+ if (unlikely(sf->js_mode & JS_MODE_MATH))
+ goto binary_arith_slow;
+#endif
d = JS_VALUE_GET_FLOAT64(op1) * JS_VALUE_GET_FLOAT64(op2);
-#ifndef CONFIG_BIGNUM
mul_fp_res:
-#endif
sp[-2] = __JS_NewFloat64(ctx, d);
sp--;
} else {
}
}
BREAK;
-#ifdef CONFIG_BIGNUM
- CASE(OP_math_div):
- CASE(OP_div):
- goto binary_arith_slow;
-#else
CASE(OP_div):
{
JSValue op1, op2;
op2 = sp[-1];
if (likely(JS_VALUE_IS_BOTH_INT(op1, op2))) {
int v1, v2;
+ if (unlikely(sf->js_mode & JS_MODE_MATH))
+ goto binary_arith_slow;
v1 = JS_VALUE_GET_INT(op1);
v2 = JS_VALUE_GET_INT(op2);
sp[-2] = JS_NewFloat64(ctx, (double)v1 / (double)v2);
}
}
BREAK;
-#endif
CASE(OP_mod):
#ifdef CONFIG_BIGNUM
CASE(OP_math_mod):
}
BREAK;
CASE(OP_pow):
-#ifdef CONFIG_BIGNUM
- CASE(OP_math_pow):
-#endif
binary_arith_slow:
if (js_binary_arith_slow(ctx, sp, opcode))
goto exception;
tag = JS_VALUE_GET_TAG(op1);
if (tag == JS_TAG_INT) {
val = JS_VALUE_GET_INT(op1);
-#ifdef CONFIG_BIGNUM
- if (unlikely(val == INT32_MIN) ||
- (val == 0 && !is_bigint_mode(ctx)))
- goto slow_neg;
-#else
/* Note: -0 cannot be expressed as integer */
if (unlikely(val == 0)) {
d = -0.0;
d = -(double)val;
goto neg_fp_res;
}
-#endif
sp[-1] = JS_NewInt32(ctx, -val);
} else if (JS_TAG_IS_FLOAT64(tag)) {
d = -JS_VALUE_GET_FLOAT64(op1);
-#ifndef CONFIG_BIGNUM
neg_fp_res:
-#endif
sp[-1] = __JS_NewFloat64(ctx, d);
} else {
-#ifdef CONFIG_BIGNUM
- slow_neg:
-#endif
if (js_unary_arith_slow(ctx, sp, opcode))
goto exception;
}
#ifdef CONFIG_BIGNUM
{
int64_t r;
- if (is_bigint_mode(ctx)) {
+ if (unlikely(sf->js_mode & JS_MODE_MATH)) {
if (v2 > 0x1f)
goto shl_slow;
r = (int64_t)v1 << v2;
v2 = JS_VALUE_GET_INT(op2);
#ifdef CONFIG_BIGNUM
if (unlikely(v2 > 0x1f)) {
- if (is_bigint_mode(ctx))
+ if (unlikely(sf->js_mode & JS_MODE_MATH))
goto sar_slow;
else
v2 &= 0x1f;
ATOD_ACCEPT_UNDERSCORES;
#ifdef CONFIG_BIGNUM
flags |= ATOD_ACCEPT_SUFFIX;
- if (s->cur_func->js_mode & JS_MODE_BIGINT) {
+ if (s->cur_func->js_mode & JS_MODE_MATH) {
flags |= ATOD_MODE_BIGINT;
if (s->cur_func->js_mode & JS_MODE_MATH)
flags |= ATOD_TYPE_BIG_FLOAT;
} else
#ifdef CONFIG_BIGNUM
if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_FLOAT) {
- bf_t r_s, *r = &r_s;
slimb_t e;
int ret;
emit_op(s, OP_push_i32);
emit_u32(s, e);
} else {
- bf_init(s->ctx->bf_ctx, r);
- bf_set_si(r, e);
- val = JS_NewBigInt(s->ctx, r);
+ val = JS_NewBigInt64_1(s->ctx, e);
+ if (JS_IsException(val))
+ return -1;
ret = emit_push_const(s, val, 0);
JS_FreeValue(s->ctx, val);
if (ret < 0)
return -1;
if (js_parse_unary(s, 1))
return -1;
- if (s->cur_func->js_mode & JS_MODE_MATH)
- emit_op(s, OP_math_pow);
- else
- emit_op(s, OP_pow);
+ emit_op(s, OP_pow);
}
#else
if (s->token.val == TOK_POW) {
opcode = OP_mul;
break;
case '/':
-#ifdef CONFIG_BIGNUM
- if (s->cur_func->js_mode & JS_MODE_MATH)
- opcode = OP_math_div;
- else
-#endif
- opcode = OP_div;
+ opcode = OP_div;
break;
case '%':
#ifdef CONFIG_BIGNUM
op = assign_opcodes[op - TOK_MUL_ASSIGN];
#ifdef CONFIG_BIGNUM
if (s->cur_func->js_mode & JS_MODE_MATH) {
- if (op == OP_div)
- op = OP_math_div;
- else if (op == OP_mod)
+ if (op == OP_mod)
op = OP_math_mod;
- else if (op == OP_pow)
- op = OP_math_pow;
}
#endif
emit_op(s, op);
len = opcode_info[op].size;
pos_next = pos + len;
switch(op) {
- case OP_close_var_object:
- {
- if (s->var_object_idx >= 0) {
- /* close the var object and create a new one */
- add_pc2line_info(s, bc_out.size, line_num);
- dbuf_putc(&bc_out, OP_close_loc);
- dbuf_put_u16(&bc_out, s->var_object_idx);
- dbuf_putc(&bc_out, OP_special_object);
- dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_VAR_OBJECT);
- put_short_code(&bc_out, OP_put_loc, s->var_object_idx);
- }
- }
- break;
-
case OP_line_num:
/* line number info (for debug). We put it in a separate
compressed table to reduce memory usage and get better
}
#endif
#ifdef CONFIG_BIGNUM
- else if (s->ctx->bignum_ext && !strcmp(str, "use bigint")) {
- s->cur_func->js_mode |= JS_MODE_BIGINT;
- }
else if (s->ctx->bignum_ext && !strcmp(str, "use math")) {
- s->cur_func->js_mode |= JS_MODE_BIGINT | JS_MODE_MATH;
+ s->cur_func->js_mode |= JS_MODE_MATH;
}
#endif
}
}
if (js_parse_destructing_element(s, TOK_VAR, 1, TRUE, -1, TRUE))
goto fail;
- /* Close var object: necessary if direct eval call
- occurred in the assignment expression or if any
- variable was captured and a later direct eval call
- may instantiate it in the var object.
- The next pass will generate the capture if required.
- */
- emit_op(s, OP_close_var_object);
} else if (s->token.val == TOK_IDENT) {
if (s->token.u.ident.is_reserved) {
js_parse_error_reserved_identifier(s);
set_object_name(s, name);
emit_op(s, OP_put_arg);
emit_u16(s, idx);
- /* Close var object: see above comment. */
- emit_op(s, OP_close_var_object);
emit_label(s, label);
}
} else if (!has_opt_arg) {
case JS_TAG_EXCEPTION:
return JS_DupValue(ctx, val);
#ifdef CONFIG_BIGNUM
- case JS_TAG_INT:
- if (is_bigint_mode(ctx))
- obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_INT);
- else
- obj = JS_NewObjectClass(ctx, JS_CLASS_NUMBER);
- goto set_value;
case JS_TAG_BIG_INT:
obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_INT);
goto set_value;
- case JS_TAG_FLOAT64:
- obj = JS_NewObjectClass(ctx, JS_CLASS_NUMBER);
- goto set_value;
case JS_TAG_BIG_FLOAT:
obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_FLOAT);
goto set_value;
case JS_TAG_BIG_DECIMAL:
obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_DECIMAL);
goto set_value;
-#else
+#endif
case JS_TAG_INT:
case JS_TAG_FLOAT64:
obj = JS_NewObjectClass(ctx, JS_CLASS_NUMBER);
goto set_value;
-#endif
case JS_TAG_STRING:
/* XXX: should call the string constructor */
{
ret = JS_PreventExtensions(ctx, obj);
if (ret < 0)
return JS_EXCEPTION;
- if (reflect)
+ if (reflect) {
return JS_NewBool(ctx, ret);
- else
+ } else {
+ if (!ret)
+ return JS_ThrowTypeError(ctx, "proxy preventExtensions handler returned false");
return JS_DupValue(ctx, obj);
+ }
}
static JSValue js_object_hasOwnProperty(JSContext *ctx, JSValueConst this_val,
goto exception;
}
js_free_prop_enum(ctx, props, len);
- return JS_TRUE;
+ return JS_DupValue(ctx, obj);
exception:
js_free_prop_enum(ctx, props, len);
int argc, JSValueConst *argv)
{
JSValue val, obj;
-#ifdef CONFIG_BIGNUM
if (argc == 0) {
- if (is_bigint_mode(ctx))
- val = __JS_NewFloat64(ctx, 0);
- else
- val = JS_NewInt32(ctx, 0);
+ val = JS_NewInt32(ctx, 0);
} else {
val = JS_ToNumeric(ctx, argv[0]);
if (JS_IsException(val))
return val;
switch(JS_VALUE_GET_TAG(val)) {
+#ifdef CONFIG_BIGNUM
case JS_TAG_BIG_INT:
case JS_TAG_BIG_FLOAT:
{
val = __JS_NewFloat64(ctx, d);
}
break;
- case JS_TAG_INT:
- if (is_bigint_mode(ctx)) {
- /* always return a number in bignum mode */
- val = __JS_NewFloat64(ctx, JS_VALUE_GET_INT(val));
- }
+ case JS_TAG_BIG_DECIMAL:
+ val = JS_ToStringFree(ctx, val);
+ if (JS_IsException(val))
+ return val;
+ val = JS_ToNumberFree(ctx, val);
+ if (JS_IsException(val))
+ return val;
break;
+#endif
default:
break;
}
}
-#else
- if (argc == 0) {
- val = JS_NewInt32(ctx, 0);
- } else {
- val = JS_ToNumber(ctx, argv[0]);
- if (JS_IsException(val))
- return val;
- }
-#endif
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_NUMBER);
if (!JS_IsException(obj))
static JSValue js_number_isNaN(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
{
- /* XXX: should just check for float and big_float */
if (!JS_IsNumber(argv[0]))
return JS_FALSE;
return js_global_isNaN(ctx, this_val, argc, argv);
return JS_FALSE;
if (unlikely(JS_ToFloat64(ctx, &d, argv[0])))
return JS_EXCEPTION;
- return JS_NewBool(ctx, isfinite(d) && floor(d) == d &&
- fabs(d) <= (double)MAX_SAFE_INTEGER);
+ return JS_NewBool(ctx, is_safe_integer(d));
}
static const JSCFunctionListEntry js_number_funcs[] = {
return js_thisNumberValue(ctx, this_val);
}
+static int js_get_radix(JSContext *ctx, JSValueConst val)
+{
+ int radix;
+ if (JS_ToInt32Sat(ctx, &radix, val))
+ return -1;
+ if (radix < 2 || radix > 36) {
+ JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
+ return -1;
+ }
+ return radix;
+}
+
static JSValue js_number_toString(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv, int magic)
{
if (magic || JS_IsUndefined(argv[0])) {
base = 10;
} else {
- if (JS_ToInt32Sat(ctx, &base, argv[0]))
- goto fail;
- if (base < 2 || base > 36) {
- JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
+ base = js_get_radix(ctx, argv[0]);
+ if (base < 0)
goto fail;
- }
}
if (JS_ToFloat64Free(ctx, &d, val))
return JS_EXCEPTION;
p = str;
p += skip_spaces(p);
flags = ATOD_INT_ONLY | ATOD_ACCEPT_PREFIX_AFTER_SIGN;
-#ifdef CONFIG_BIGNUM
- if (is_bigint_mode(ctx))
- flags |= ATOD_MODE_BIGINT;
-#endif
ret = js_atof(ctx, p, NULL, radix, flags);
}
JS_FreeCString(ctx, str);
}
}
-#ifdef CONFIG_BIGNUM
-
-enum {
- MATH_OP_ABS,
- MATH_OP_FLOOR,
- MATH_OP_CEIL,
- MATH_OP_ROUND,
- MATH_OP_TRUNC,
- MATH_OP_SQRT,
- MATH_OP_FPROUND,
- MATH_OP_ACOS,
- MATH_OP_ASIN,
- MATH_OP_ATAN,
- MATH_OP_ATAN2,
- MATH_OP_COS,
- MATH_OP_EXP,
- MATH_OP_LOG,
- MATH_OP_POW,
- MATH_OP_SIN,
- MATH_OP_TAN,
- MATH_OP_FMOD,
- MATH_OP_REM,
- MATH_OP_SIGN,
-
- MATH_OP_ADD,
- MATH_OP_SUB,
- MATH_OP_MUL,
- MATH_OP_DIV,
-};
-
-static JSValue js_bigfloat_fop(JSContext *ctx, JSValueConst this_val,
- int argc, JSValueConst *argv, int magic)
-{
- bf_t a_s, *a, r_s, *r = &r_s;
- JSFloatEnv *fe;
- int rnd_mode;
- JSValue op1;
-
- op1 = JS_ToNumber(ctx, argv[0]);
- if (JS_IsException(op1))
- return op1;
- a = JS_ToBigFloat(ctx, &a_s, op1);
- fe = &ctx->fp_env;
- if (argc > 1) {
- fe = JS_GetOpaque2(ctx, argv[1], JS_CLASS_FLOAT_ENV);
- if (!fe) {
- if (a == &a_s)
- bf_delete(a);
- JS_FreeValue(ctx, op1);
- return JS_EXCEPTION;
- }
- }
-
- bf_init(ctx->bf_ctx, r);
- switch (magic) {
- case MATH_OP_ABS:
- bf_set(r, a);
- r->sign = 0;
- break;
- case MATH_OP_FLOOR:
- rnd_mode = BF_RNDD;
- goto rint;
- case MATH_OP_CEIL:
- rnd_mode = BF_RNDU;
- goto rint;
- case MATH_OP_ROUND:
- rnd_mode = BF_RNDNU;
- goto rint;
- case MATH_OP_TRUNC:
- rnd_mode = BF_RNDZ;
- rint:
- bf_set(r, a);
- fe->status |= bf_rint(r, rnd_mode);
- break;
- case MATH_OP_SQRT:
- fe->status |= bf_sqrt(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_FPROUND:
- bf_set(r, a);
- fe->status |= bf_round(r, fe->prec, fe->flags);
- break;
- case MATH_OP_ACOS:
- fe->status |= bf_acos(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_ASIN:
- fe->status |= bf_asin(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_ATAN:
- fe->status |= bf_atan(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_COS:
- fe->status |= bf_cos(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_EXP:
- fe->status |= bf_exp(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_LOG:
- fe->status |= bf_log(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_SIN:
- fe->status |= bf_sin(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_TAN:
- fe->status |= bf_tan(r, a, fe->prec, fe->flags);
- break;
- case MATH_OP_SIGN:
- if (bf_is_nan(a) || bf_is_zero(a)) {
- bf_set(r, a);
- } else {
- bf_set_si(r, 1 - 2 * a->sign);
- }
- break;
- default:
- abort();
- }
- if (a == &a_s)
- bf_delete(a);
- JS_FreeValue(ctx, op1);
- return JS_NewBigFloat(ctx, r);
-}
-
-static JSValue js_bigfloat_fop2(JSContext *ctx, JSValueConst this_val,
- int argc, JSValueConst *argv, int magic)
-{
- bf_t a_s, *a, b_s, *b, r_s, *r = &r_s;
- JSFloatEnv *fe;
- JSValue op1, op2;
-
- op1 = JS_ToNumber(ctx, argv[0]);
- if (JS_IsException(op1))
- return op1;
- op2 = JS_ToNumber(ctx, argv[1]);
- if (JS_IsException(op2)) {
- JS_FreeValue(ctx, op1);
- return op2;
- }
- a = JS_ToBigFloat(ctx, &a_s, op1);
- b = JS_ToBigFloat(ctx, &b_s, op2);
- fe = &ctx->fp_env;
- if (argc > 2) {
- fe = JS_GetOpaque2(ctx, argv[2], JS_CLASS_FLOAT_ENV);
- if (!fe) {
- if (a == &a_s)
- bf_delete(a);
- if (b == &b_s)
- bf_delete(b);
- JS_FreeValue(ctx, op1);
- JS_FreeValue(ctx, op2);
- return JS_EXCEPTION;
- }
- }
-
- bf_init(ctx->bf_ctx, r);
- switch (magic) {
- case MATH_OP_ATAN2:
- fe->status |= bf_atan2(r, a, b, fe->prec, fe->flags);
- break;
- case MATH_OP_POW:
- fe->status |= bf_pow(r, a, b, fe->prec, fe->flags | BF_POW_JS_QUICKS);
- break;
- case MATH_OP_FMOD:
- fe->status |= bf_fmod(r, a, b, fe->prec, fe->flags);
- break;
- case MATH_OP_REM:
- fe->status |= bf_remainder(r, a, b, fe->prec, fe->flags);
- break;
- case MATH_OP_ADD:
- fe->status |= bf_add(r, a, b, fe->prec, fe->flags);
- break;
- case MATH_OP_SUB:
- fe->status |= bf_sub(r, a, b, fe->prec, fe->flags);
- break;
- case MATH_OP_MUL:
- fe->status |= bf_mul(r, a, b, fe->prec, fe->flags);
- break;
- case MATH_OP_DIV:
- fe->status |= bf_div(r, a, b, fe->prec, fe->flags);
- break;
- default:
- abort();
- }
- if (a == &a_s)
- bf_delete(a);
- if (b == &b_s)
- bf_delete(b);
- JS_FreeValue(ctx, op1);
- JS_FreeValue(ctx, op2);
- return JS_NewBigFloat(ctx, r);
-}
-
-static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
- int argc, JSValueConst *argv, int magic)
-{
- BOOL is_max = magic;
- JSValue val, ret;
- int i;
- uint32_t tag;
-
- if (unlikely(argc == 0)) {
- return __JS_NewFloat64(ctx, is_max ? -1.0 / 0.0 : 1.0 / 0.0);
- }
-
- tag = JS_VALUE_GET_TAG(argv[0]);
- if (tag == JS_TAG_INT) {
- int a1, r1 = JS_VALUE_GET_INT(argv[0]);
- for(i = 1; i < argc; i++) {
- tag = JS_VALUE_GET_TAG(argv[i]);
- if (tag != JS_TAG_INT) {
- ret = JS_NewInt32(ctx, r1);
- goto generic_case;
- }
- a1 = JS_VALUE_GET_INT(argv[i]);
- if (is_max)
- r1 = max_int(r1, a1);
- else
- r1 = min_int(r1, a1);
- }
- ret = JS_NewInt32(ctx, r1);
- } else {
- ret = JS_ToNumber(ctx, argv[0]);
- if (JS_IsException(ret))
- return ret;
- i = 1;
- generic_case:
- for(; i < argc; i++) {
- val = JS_ToNumber(ctx, argv[i]);
- if (JS_IsException(val)) {
- JS_FreeValue(ctx, ret);
- return val;
- }
- if (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(ret)) &&
- JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(val))) {
- double r, a;
- r = JS_VALUE_GET_FLOAT64(ret);
- a = JS_VALUE_GET_FLOAT64(val);
- if (!isnan(r)) {
- if (isnan(a)) {
- r = a;
- } else {
- if (is_max)
- r = js_fmax(r, a);
- else
- r = js_fmin(r, a);
- }
- ret = __JS_NewFloat64(ctx, r);
- }
- } else {
- bf_t a_s, *a, r_s, *r;
- int res;
-
- r = JS_ToBigFloat(ctx, &r_s, ret);
- if (!bf_is_nan(r)) {
- a = JS_ToBigFloat(ctx, &a_s, val);
- res = bf_cmp_full(a, r);
- if (is_max)
- res = -res;
- if (bf_is_nan(a) || res < 0) {
- JS_FreeValue(ctx, ret);
- ret = JS_DupValue(ctx, val);
- }
- if (a == &a_s)
- bf_delete(a);
- }
- if (r == &r_s)
- bf_delete(r);
- JS_FreeValue(ctx, val);
- }
- }
- }
- return ret;
-}
-
-static JSValue js_math_abs(JSContext *ctx, JSValueConst this_val,
- int argc, JSValueConst *argv)
-{
- JSValue val;
- uint32_t tag;
-
- val = JS_ToNumeric(ctx, argv[0]);
- tag = JS_VALUE_GET_NORM_TAG(val);
- switch(tag) {
- case JS_TAG_INT:
- if (JS_VALUE_GET_INT(val) < 0)
- val = JS_NewInt64(ctx, -(int64_t)JS_VALUE_GET_INT(val));
- break;
- case JS_TAG_FLOAT64:
- val = __JS_NewFloat64(ctx, fabs(JS_VALUE_GET_FLOAT64(val)));
- break;
- case JS_TAG_BIG_FLOAT:
- case JS_TAG_BIG_INT:
- {
- JSBigFloat *p = JS_VALUE_GET_PTR(val);
- bf_t r_s, *r = &r_s;
- bf_init(ctx->bf_ctx, r);
- bf_set(r, &p->num);
- r->sign = 0;
- JS_FreeValue(ctx, val);
- if (tag == JS_TAG_BIG_FLOAT)
- val = JS_NewBigFloat(ctx, r);
- else
- val = JS_NewBigInt2(ctx, r, TRUE);
- }
- break;
- default:
- break;
- }
- return val;
-}
-
-#if 0
-/* XXX: should give exact rounding */
-/* XXX: correct NaN/Infinity handling */
-static JSValue js_math_hypot(JSContext *ctx, JSValueConst this_val,
- int argc, JSValueConst *argv)
-{
- bf_t a_s, *a, r_s, *r = &r_s, r2_s, *r2 = &r2_s;
- JSValue val;
- int i;
- BOOL is_float;
-
- bf_init(ctx->bf_ctx, r);
- bf_set_si(r, 0);
- for(i = 0; i < argc; i++) {
- val = JS_ToNumber(ctx, argv[i]);
- if (JS_IsException(val)) {
- bf_delete(r);
- return val;
- }
- a = JS_ToBigFloat(ctx, &is_float, &a_s, val);
- bf_add(r, r, a, ctx->fp_env.prec, ctx->fp_env.flags);
- if (a == &a_s)
- bf_delete(a);
- }
- bf_init(ctx->bf_ctx, r2);
- bf_sqrt(r2, r, ctx->fp_env.prec, ctx->fp_env.flags);
- bf_delete(r);
- return JS_NewBigFloat(ctx, r2);
-}
-#endif
-
-#else
-
static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv, int magic)
{
}
}
-#endif /* !CONFIG_BIGNUM */
-
static double js_math_sign(double a)
{
if (isnan(a) || a == 0.0)
static const JSCFunctionListEntry js_math_funcs[] = {
JS_CFUNC_MAGIC_DEF("min", 2, js_math_min_max, 0 ),
JS_CFUNC_MAGIC_DEF("max", 2, js_math_min_max, 1 ),
-#ifdef CONFIG_BIGNUM
- JS_CFUNC_DEF("abs", 1, js_math_abs ),
-#else
JS_CFUNC_SPECIAL_DEF("abs", 1, f_f, fabs ),
-#endif
JS_CFUNC_SPECIAL_DEF("floor", 1, f_f, floor ),
JS_CFUNC_SPECIAL_DEF("ceil", 1, f_f, ceil ),
JS_CFUNC_SPECIAL_DEF("round", 1, f_f, js_math_round ),
}
is_neg = 1;
number:
-#ifdef CONFIG_BIGNUM
- val = JS_DupValue(ctx, s->token.u.num.val);
- if (is_neg) {
- switch(JS_VALUE_GET_NORM_TAG(val)) {
- case JS_TAG_BIG_INT:
- case JS_TAG_BIG_FLOAT:
- {
- JSBigFloat *p;
- p = JS_VALUE_GET_PTR(val);
- bf_neg(&p->num);
- }
- break;
- case JS_TAG_FLOAT64:
- {
- double d;
- d = JS_VALUE_GET_FLOAT64(val);
- val = __JS_NewFloat64(ctx, -d);
- }
- break;
- default:
- case JS_TAG_INT:
- {
- int v;
- v = JS_VALUE_GET_INT(val);
- if (v == 0 && !is_bigint_mode(s->ctx))
- val = __JS_NewFloat64(ctx, -0.0);
- else
- val = JS_NewInt64(ctx, -(int64_t)v);
- }
- break;
- }
- }
-#else
val = s->token.u.num.val;
if (is_neg) {
double d;
JS_ToFloat64(ctx, &d, val); /* no exception possible */
val = JS_NewFloat64(ctx, -d);
}
-#endif
if (next_token(s))
goto fail;
break;
return r;
}
-#ifdef CONFIG_BIGNUM
-static inline BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v);
-#endif
-
static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
JSValueConst holder, JSValue val, JSValueConst key)
{
double d;
int p, i, c, sgn;
JSString *sp;
-
+ BOOL is_local;
+
rv = JS_NAN;
s = JS_ToString(ctx, argv[0]);
if (string_get_signed_field(sp, &p, &fields[0]))
goto done;
+ is_local = TRUE;
for (i = 1; i < 6; i++) {
if (string_get_field(sp, &p, &fields[i]))
break;
}
- if (i == 6 && p < sp->len && string_get(sp, p) == '.') {
+ if (i <= 3) {
+ /* no time: UTC by default */
+ is_local = FALSE;
+ } else if (i == 6 && p < sp->len && string_get(sp, p) == '.') {
/* parse milliseconds as a fractional part, round to nearest */
/* XXX: the spec does not indicate which rounding should be used */
int mul = 1000, ms = 0;
/* parse the time zone offset if present: [+-]HH:mm */
tz = 0;
- if (p < sp->len && ((sgn = string_get(sp, p)) == '+' || sgn == '-')) {
- if (string_get_field(sp, &p, &hh))
- goto done;
- if (string_get_field(sp, &p, &mm))
- goto done;
- tz = hh * 60 + mm;
- if (sgn == '-')
- tz = -tz;
+ if (p < sp->len) {
+ sgn = string_get(sp, p);
+ if (sgn == '+' || sgn == '-') {
+ if (string_get_field(sp, &p, &hh))
+ goto done;
+ if (string_get_field(sp, &p, &mm))
+ goto done;
+ tz = hh * 60 + mm;
+ if (sgn == '-')
+ tz = -tz;
+ is_local = FALSE;
+ } else if (sgn == 'Z') {
+ is_local = FALSE;
+ }
}
} else {
/* toString or toUTCString format */
// XXX: parse optional milliseconds?
/* parse the time zone offset if present: [+-]HHmm */
+ is_local = FALSE;
tz = 0;
for (tz = 0; p < sp->len; p++) {
sgn = string_get(sp, p);
}
}
}
- d = set_date_fields(fields, 0) - tz * 60000;
+ d = set_date_fields(fields, is_local) - tz * 60000;
rv = __JS_NewFloat64(ctx, d);
done:
#ifdef CONFIG_BIGNUM
+/* Operators */
+
+static void js_operator_set_finalizer(JSRuntime *rt, JSValue val)
+{
+ JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
+ int i, j;
+ JSBinaryOperatorDefEntry *ent;
+
+ if (opset) {
+ for(i = 0; i < JS_OVOP_COUNT; i++) {
+ if (opset->self_ops[i])
+ JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[i]));
+ }
+ for(j = 0; j < opset->left.count; j++) {
+ ent = &opset->left.tab[j];
+ for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+ if (ent->ops[i])
+ JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]));
+ }
+ }
+ js_free_rt(rt, opset->left.tab);
+ for(j = 0; j < opset->right.count; j++) {
+ ent = &opset->right.tab[j];
+ for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+ if (ent->ops[i])
+ JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]));
+ }
+ }
+ js_free_rt(rt, opset->right.tab);
+ js_free_rt(rt, opset);
+ }
+}
+
+static void js_operator_set_mark(JSRuntime *rt, JSValueConst val,
+ JS_MarkFunc *mark_func)
+{
+ JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
+ int i, j;
+ JSBinaryOperatorDefEntry *ent;
+
+ if (opset) {
+ for(i = 0; i < JS_OVOP_COUNT; i++) {
+ if (opset->self_ops[i])
+ JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[i]),
+ mark_func);
+ }
+ for(j = 0; j < opset->left.count; j++) {
+ ent = &opset->left.tab[j];
+ for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+ if (ent->ops[i])
+ JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]),
+ mark_func);
+ }
+ }
+ for(j = 0; j < opset->right.count; j++) {
+ ent = &opset->right.tab[j];
+ for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+ if (ent->ops[i])
+ JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]),
+ mark_func);
+ }
+ }
+ }
+}
+
+
+/* create an OperatorSet object */
+static JSValue js_operators_create_internal(JSContext *ctx,
+ int argc, JSValueConst *argv,
+ BOOL is_primitive)
+{
+ JSValue opset_obj, prop, obj;
+ JSOperatorSetData *opset, *opset1;
+ JSBinaryOperatorDef *def;
+ JSValueConst arg;
+ int i, j;
+ JSBinaryOperatorDefEntry *new_tab;
+ JSBinaryOperatorDefEntry *ent;
+ uint32_t op_count;
+
+ if (ctx->rt->operator_count == UINT32_MAX) {
+ return JS_ThrowTypeError(ctx, "too many operators");
+ }
+ opset_obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_OPERATOR_SET);
+ if (JS_IsException(opset_obj))
+ goto fail;
+ opset = js_mallocz(ctx, sizeof(*opset));
+ if (!opset)
+ goto fail;
+ JS_SetOpaque(opset_obj, opset);
+ if (argc >= 1) {
+ arg = argv[0];
+ /* self operators */
+ for(i = 0; i < JS_OVOP_COUNT; i++) {
+ prop = JS_GetPropertyStr(ctx, arg, js_overloadable_operator_names[i]);
+ if (JS_IsException(prop))
+ goto fail;
+ if (!JS_IsUndefined(prop)) {
+ if (check_function(ctx, prop)) {
+ JS_FreeValue(ctx, prop);
+ goto fail;
+ }
+ opset->self_ops[i] = JS_VALUE_GET_OBJ(prop);
+ }
+ }
+ }
+ /* left & right operators */
+ for(j = 1; j < argc; j++) {
+ arg = argv[j];
+ prop = JS_GetPropertyStr(ctx, arg, "left");
+ if (JS_IsException(prop))
+ goto fail;
+ def = &opset->right;
+ if (JS_IsUndefined(prop)) {
+ prop = JS_GetPropertyStr(ctx, arg, "right");
+ if (JS_IsException(prop))
+ goto fail;
+ if (JS_IsUndefined(prop)) {
+ JS_ThrowTypeError(ctx, "left or right property must be present");
+ goto fail;
+ }
+ def = &opset->left;
+ }
+ /* get the operator set */
+ obj = JS_GetProperty(ctx, prop, JS_ATOM_prototype);
+ JS_FreeValue(ctx, prop);
+ if (JS_IsException(obj))
+ goto fail;
+ prop = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_operatorSet);
+ JS_FreeValue(ctx, obj);
+ if (JS_IsException(prop))
+ goto fail;
+ opset1 = JS_GetOpaque2(ctx, prop, JS_CLASS_OPERATOR_SET);
+ if (!opset1) {
+ JS_FreeValue(ctx, prop);
+ goto fail;
+ }
+ op_count = opset1->operator_counter;
+ JS_FreeValue(ctx, prop);
+
+ /* we assume there are few entries */
+ new_tab = js_realloc(ctx, def->tab,
+ (def->count + 1) * sizeof(def->tab[0]));
+ if (!new_tab)
+ goto fail;
+ def->tab = new_tab;
+ def->count++;
+ ent = def->tab + def->count - 1;
+ memset(ent, 0, sizeof(def->tab[0]));
+ ent->operator_index = op_count;
+
+ for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+ prop = JS_GetPropertyStr(ctx, arg,
+ js_overloadable_operator_names[i]);
+ if (JS_IsException(prop))
+ goto fail;
+ if (!JS_IsUndefined(prop)) {
+ if (check_function(ctx, prop)) {
+ JS_FreeValue(ctx, prop);
+ goto fail;
+ }
+ ent->ops[i] = JS_VALUE_GET_OBJ(prop);
+ }
+ }
+ }
+ opset->is_primitive = is_primitive;
+ opset->operator_counter = ctx->rt->operator_count++;
+ return opset_obj;
+ fail:
+ JS_FreeValue(ctx, opset_obj);
+ return JS_EXCEPTION;
+}
+
+static JSValue js_operators_create(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv)
+{
+ return js_operators_create_internal(ctx, argc, argv, FALSE);
+}
+
+static JSValue js_operators_updateBigIntOperators(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv)
+{
+ JSValue opset_obj, prop;
+ JSOperatorSetData *opset;
+ const JSOverloadableOperatorEnum ops[2] = { JS_OVOP_DIV, JS_OVOP_POW };
+ JSOverloadableOperatorEnum op;
+ int i;
+
+ opset_obj = JS_GetProperty(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
+ JS_ATOM_Symbol_operatorSet);
+ if (JS_IsException(opset_obj))
+ goto fail;
+ opset = JS_GetOpaque2(ctx, opset_obj, JS_CLASS_OPERATOR_SET);
+ if (!opset)
+ goto fail;
+ for(i = 0; i < countof(ops); i++) {
+ op = ops[i];
+ prop = JS_GetPropertyStr(ctx, argv[0],
+ js_overloadable_operator_names[op]);
+ if (JS_IsException(prop))
+ goto fail;
+ if (!JS_IsUndefined(prop)) {
+ if (!JS_IsNull(prop) && check_function(ctx, prop)) {
+ JS_FreeValue(ctx, prop);
+ goto fail;
+ }
+ if (opset->self_ops[op])
+ JS_FreeValue(ctx, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[op]));
+ if (JS_IsNull(prop)) {
+ opset->self_ops[op] = NULL;
+ } else {
+ opset->self_ops[op] = JS_VALUE_GET_PTR(prop);
+ }
+ }
+ }
+ JS_FreeValue(ctx, opset_obj);
+ return JS_UNDEFINED;
+ fail:
+ JS_FreeValue(ctx, opset_obj);
+ return JS_EXCEPTION;
+}
+
+static int js_operators_set_default(JSContext *ctx, JSValueConst obj)
+{
+ JSValue opset_obj;
+
+ if (!JS_IsObject(obj)) /* in case the prototype is not defined */
+ return 0;
+ opset_obj = js_operators_create_internal(ctx, 0, NULL, TRUE);
+ if (JS_IsException(opset_obj))
+ return -1;
+ /* cannot be modified by the user */
+ JS_DefinePropertyValue(ctx, obj, JS_ATOM_Symbol_operatorSet,
+ opset_obj, 0);
+ return 0;
+}
+
+static JSValue js_dummy_operators_ctor(JSContext *ctx, JSValueConst new_target,
+ int argc, JSValueConst *argv)
+{
+ return js_create_from_ctor(ctx, new_target, JS_CLASS_OBJECT);
+}
+
+static JSValue js_global_operators(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv)
+{
+ JSValue func_obj, proto, opset_obj;
+
+ func_obj = JS_UNDEFINED;
+ proto = JS_NewObject(ctx);
+ if (JS_IsException(proto))
+ return JS_EXCEPTION;
+ opset_obj = js_operators_create_internal(ctx, argc, argv, FALSE);
+ if (JS_IsException(opset_obj))
+ goto fail;
+ JS_DefinePropertyValue(ctx, proto, JS_ATOM_Symbol_operatorSet,
+ opset_obj, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+ func_obj = JS_NewCFunction2(ctx, js_dummy_operators_ctor, "Operators",
+ 0, JS_CFUNC_constructor, 0);
+ if (JS_IsException(func_obj))
+ goto fail;
+ JS_SetConstructor2(ctx, func_obj, proto,
+ 0, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+ JS_FreeValue(ctx, proto);
+ return func_obj;
+ fail:
+ JS_FreeValue(ctx, proto);
+ JS_FreeValue(ctx, func_obj);
+ return JS_EXCEPTION;
+}
+
+static const JSCFunctionListEntry js_operators_funcs[] = {
+ JS_CFUNC_DEF("create", 1, js_operators_create ),
+ JS_CFUNC_DEF("updateBigIntOperators", 2, js_operators_updateBigIntOperators ),
+};
+
+/* must be called after all overloadable base types are initialized */
+void JS_AddIntrinsicOperators(JSContext *ctx)
+{
+ JSValue obj;
+
+ ctx->allow_operator_overloading = TRUE;
+ obj = JS_NewCFunction(ctx, js_global_operators, "Operators", 1);
+ JS_SetPropertyFunctionList(ctx, obj,
+ js_operators_funcs,
+ countof(js_operators_funcs));
+ JS_DefinePropertyValue(ctx, ctx->global_obj, JS_ATOM_Operators,
+ obj,
+ JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+ /* add default operatorSets */
+ js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BOOLEAN]);
+ js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_NUMBER]);
+ js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_STRING]);
+ js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_INT]);
+ js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT]);
+ js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_DECIMAL]);
+}
+
/* BigInt */
static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
{
uint32_t tag;
- BOOL is_legacy;
- int ret;
- is_legacy = is_bigint_mode(ctx) ^ 1;
redo:
tag = JS_VALUE_GET_NORM_TAG(val);
switch(tag) {
case JS_TAG_INT:
case JS_TAG_BOOL:
- if (is_legacy) {
- bf_t r_s, *r = &r_s;
- bf_init(ctx->bf_ctx, r);
- bf_set_si(r, JS_VALUE_GET_INT(val));
- val = JS_NewBigInt2(ctx, r, TRUE);
- } else {
- val = JS_NewInt32(ctx, JS_VALUE_GET_INT(val));
- }
+ val = JS_NewBigInt64(ctx, JS_VALUE_GET_INT(val));
break;
case JS_TAG_BIG_INT:
break;
case JS_TAG_FLOAT64:
case JS_TAG_BIG_FLOAT:
{
- bf_t *a, a_s, r_s, *r = &r_s;
+ bf_t *a, a_s;
+
a = JS_ToBigFloat(ctx, &a_s, val);
- bf_init(ctx->bf_ctx, r);
if (!bf_is_finite(a)) {
JS_FreeValue(ctx, val);
val = JS_ThrowRangeError(ctx, "cannot convert NaN or Infinity to bigint");
} else {
- bf_set(r, a);
- ret = bf_rint(r, BF_RNDZ);
+ JSValue val1 = JS_NewBigInt(ctx);
+ bf_t *r;
+ int ret;
+ if (JS_IsException(val1)) {
+ JS_FreeValue(ctx, val);
+ return JS_EXCEPTION;
+ }
+ r = JS_GetBigInt(val1);
+ ret = bf_set(r, a);
+ ret |= bf_rint(r, BF_RNDZ);
JS_FreeValue(ctx, val);
- if (is_legacy && (ret & BF_ST_INEXACT)) {
- bf_delete(r);
+ if (ret & BF_ST_MEM_ERROR) {
+ JS_FreeValue(ctx, val1);
+ val = JS_ThrowOutOfMemory(ctx);
+ } else if (ret & BF_ST_INEXACT) {
+ JS_FreeValue(ctx, val1);
val = JS_ThrowRangeError(ctx, "cannot convert to bigint: not an integer");
} else {
- val = JS_NewBigInt2(ctx, r, is_legacy);
+ val = JS_CompactBigInt(ctx, val1);
}
}
if (a == &a_s)
bf_delete(a);
}
break;
+ case JS_TAG_BIG_DECIMAL:
+ val = JS_ToStringFree(ctx, val);
+ if (JS_IsException(val))
+ break;
+ goto redo;
case JS_TAG_STRING:
val = JS_StringToBigIntErr(ctx, val);
break;
case JS_TAG_OBJECT:
- val = JS_ToPrimitiveFree(ctx, val,
- is_legacy ? HINT_NUMBER : HINT_INTEGER);
+ val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
if (JS_IsException(val))
break;
goto redo;
return JS_ToBigIntCtorFree(ctx, JS_DupValue(ctx, argv[0]));
}
-static inline BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v)
-{
- int tag = JS_VALUE_GET_TAG(v);
- if (tag == JS_TAG_BIG_INT)
- return TRUE;
- if (is_bigint_mode(ctx))
- return tag == JS_TAG_INT;
- else
- return FALSE;
-}
-
static JSValue js_thisBigIntValue(JSContext *ctx, JSValueConst this_val)
{
if (JS_IsBigInt(ctx, this_val))
if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
JSObject *p = JS_VALUE_GET_OBJ(this_val);
if (p->class_id == JS_CLASS_BIG_INT) {
- /* XXX: may relax the check in case the object comes from
- bignum mode */
if (JS_IsBigInt(ctx, p->u.object_data))
return JS_DupValue(ctx, p->u.object_data);
}
if (argc == 0 || JS_IsUndefined(argv[0])) {
base = 10;
} else {
- if (JS_ToInt32Sat(ctx, &base, argv[0]))
+ base = js_get_radix(ctx, argv[0]);
+ if (base < 0)
goto fail;
- if (base < 2 || base > 36) {
- JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
- goto fail;
- }
}
ret = js_bigint_to_string1(ctx, val, base);
JS_FreeValue(ctx, val);
JSValueConst this_val,
int argc, JSValueConst *argv, int magic)
{
- bf_t a_s, b_s, *a, *b, r_s, *r = &r_s, q_s, *q = &q_s;
+ bf_t a_s, b_s, *a, *b, *r, *q;
int status;
-
+ JSValue q_val, r_val;
+
+ q_val = JS_NewBigInt(ctx);
+ if (JS_IsException(q_val))
+ return JS_EXCEPTION;
+ r_val = JS_NewBigInt(ctx);
+ if (JS_IsException(r_val))
+ goto fail;
b = NULL;
a = JS_ToBigInt(ctx, &a_s, argv[0]);
if (!a)
- return JS_EXCEPTION;
+ goto fail;
b = JS_ToBigInt(ctx, &b_s, argv[1]);
if (!b) {
JS_FreeBigInt(ctx, a, &a_s);
- return JS_EXCEPTION;
+ goto fail;
}
- bf_init(ctx->bf_ctx, q);
- bf_init(ctx->bf_ctx, r);
+ q = JS_GetBigInt(q_val);
+ r = JS_GetBigInt(r_val);
status = bf_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ, magic & 0xf);
JS_FreeBigInt(ctx, a, &a_s);
JS_FreeBigInt(ctx, b, &b_s);
if (unlikely(status)) {
- bf_delete(q);
- bf_delete(r);
throw_bf_exception(ctx, status);
- return JS_EXCEPTION;
+ goto fail;
}
+ q_val = JS_CompactBigInt(ctx, q_val);
if (magic & 0x10) {
JSValue ret;
- /* XXX: handle exceptions */
ret = JS_NewArray(ctx);
- JS_SetPropertyUint32(ctx, ret, 0, JS_NewBigInt(ctx, q));
- JS_SetPropertyUint32(ctx, ret, 1, JS_NewBigInt(ctx, r));
+ if (JS_IsException(ret))
+ goto fail;
+ JS_SetPropertyUint32(ctx, ret, 0, q_val);
+ JS_SetPropertyUint32(ctx, ret, 1, JS_CompactBigInt(ctx, r_val));
return ret;
} else {
- bf_delete(r);
- return JS_NewBigInt(ctx, q);
+ JS_FreeValue(ctx, r_val);
+ return q_val;
}
+ fail:
+ JS_FreeValue(ctx, q_val);
+ JS_FreeValue(ctx, r_val);
+ return JS_EXCEPTION;
}
static JSValue js_bigint_sqrt(JSContext *ctx,
JSValueConst this_val,
int argc, JSValueConst *argv, int magic)
{
- bf_t a_s, *a, r_s, *r = &r_s, rem_s, *rem = &rem_s;
+ bf_t a_s, *a, *r, *rem;
int status;
+ JSValue r_val, rem_val;
+
+ r_val = JS_NewBigInt(ctx);
+ if (JS_IsException(r_val))
+ return JS_EXCEPTION;
+ rem_val = JS_NewBigInt(ctx);
+ if (JS_IsException(rem_val))
+ return JS_EXCEPTION;
+ r = JS_GetBigInt(r_val);
+ rem = JS_GetBigInt(rem_val);
a = JS_ToBigInt(ctx, &a_s, argv[0]);
if (!a)
- return JS_EXCEPTION;
- bf_init(ctx->bf_ctx, r);
- bf_init(ctx->bf_ctx, rem);
+ goto fail;
status = bf_sqrtrem(r, rem, a);
JS_FreeBigInt(ctx, a, &a_s);
if (unlikely(status & ~BF_ST_INEXACT)) {
- bf_delete(r);
- bf_delete(rem);
- return throw_bf_exception(ctx, status);
+ throw_bf_exception(ctx, status);
+ goto fail;
}
+ r_val = JS_CompactBigInt(ctx, r_val);
if (magic) {
JSValue ret;
- /* XXX: handle exceptions */
ret = JS_NewArray(ctx);
- JS_SetPropertyUint32(ctx, ret, 0, JS_NewBigInt(ctx, r));
- JS_SetPropertyUint32(ctx, ret, 1, JS_NewBigInt(ctx, rem));
+ if (JS_IsException(ret))
+ goto fail;
+ JS_SetPropertyUint32(ctx, ret, 0, r_val);
+ JS_SetPropertyUint32(ctx, ret, 1, JS_CompactBigInt(ctx, rem_val));
return ret;
} else {
- bf_delete(rem);
- return JS_NewBigInt(ctx, r);
+ JS_FreeValue(ctx, rem_val);
+ return r_val;
}
+ fail:
+ JS_FreeValue(ctx, r_val);
+ JS_FreeValue(ctx, rem_val);
+ return JS_EXCEPTION;
}
static JSValue js_bigint_op1(JSContext *ctx,
int argc, JSValueConst *argv, int asIntN)
{
uint64_t bits;
- bf_t a_s, *a = &a_s, r_s, *r = &r_s, mask_s, *mask = &mask_s;
-
+ bf_t a_s, *a = &a_s, *r, mask_s, *mask = &mask_s;
+ JSValue res;
+
if (JS_ToIndex(ctx, &bits, argv[0]))
return JS_EXCEPTION;
+ res = JS_NewBigInt(ctx);
+ if (JS_IsException(res))
+ return JS_EXCEPTION;
+ r = JS_GetBigInt(res);
a = JS_ToBigInt(ctx, &a_s, argv[1]);
- if (!a)
+ if (!a) {
+ JS_FreeValue(ctx, res);
return JS_EXCEPTION;
+ }
/* XXX: optimize */
- bf_init(ctx->bf_ctx, r);
+ r = JS_GetBigInt(res);
bf_init(ctx->bf_ctx, mask);
bf_set_ui(mask, 1);
bf_mul_2exp(mask, bits, BF_PREC_INF, BF_RNDZ);
}
bf_delete(mask);
JS_FreeBigInt(ctx, a, &a_s);
- return JS_NewBigInt(ctx, r);
+ return JS_CompactBigInt(ctx, res);
}
static const JSCFunctionListEntry js_bigint_funcs[] = {
if (argc == 0 || JS_IsUndefined(argv[0])) {
base = 10;
} else {
- if (JS_ToInt32Sat(ctx, &base, argv[0]))
- goto fail;
- if (base < 2 || base > 36) {
- JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
+ base = js_get_radix(ctx, argv[0]);
+ if (base < 0)
goto fail;
- }
}
ret = js_ftoa(ctx, val, base, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
JS_FreeValue(ctx, val);
return js_thisBigFloatValue(ctx, this_val);
}
-static int get_rnd_mode(JSContext *ctx, JSValueConst val)
+static int bigfloat_get_rnd_mode(JSContext *ctx, JSValueConst val)
{
int rnd_mode;
if (JS_ToInt32Sat(ctx, &rnd_mode, val))
{
JSValue val, ret;
int64_t f;
- int res, rnd_mode;
- bf_t a_s, *a, b;
+ int rnd_mode, radix;
val = js_thisBigFloatValue(ctx, this_val);
if (JS_IsException(val))
goto fail;
}
rnd_mode = BF_RNDNA;
+ radix = 10;
+ /* XXX: swap parameter order for rounding mode and radix */
if (argc > 1) {
- rnd_mode = get_rnd_mode(ctx, argv[1]);
+ rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
if (rnd_mode < 0)
goto fail;
}
-
- a = JS_ToBigFloat(ctx, &a_s, val);
- if (!a)
- goto fail;
- bf_init(ctx->bf_ctx, &b);
- bf_set_float64(&b, 1e21);
- res = bf_cmpu(a, &b);
- bf_delete(&b);
- if (a == &a_s)
- bf_delete(a);
- if (res >= 0) {
- ret = JS_ToString(ctx, val);
- } else {
- ret = js_ftoa(ctx, val, 10, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
+ if (argc > 2) {
+ radix = js_get_radix(ctx, argv[2]);
+ if (radix < 0)
+ goto fail;
}
+ ret = js_ftoa(ctx, val, radix, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
JS_FreeValue(ctx, val);
return ret;
fail:
{
JSValue val, ret;
int64_t f;
- int rnd_mode;
+ int rnd_mode, radix;
val = js_thisBigFloatValue(ctx, this_val);
if (JS_IsException(val))
goto fail;
}
rnd_mode = BF_RNDNA;
+ radix = 10;
if (argc > 1) {
- rnd_mode = get_rnd_mode(ctx, argv[1]);
+ rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
if (rnd_mode < 0)
goto fail;
}
- ret = js_ftoa(ctx, val, 10, f + 1,
+ if (argc > 2) {
+ radix = js_get_radix(ctx, argv[2]);
+ if (radix < 0)
+ goto fail;
+ }
+ ret = js_ftoa(ctx, val, radix, f + 1,
rnd_mode | BF_FTOA_FORMAT_FIXED | BF_FTOA_FORCE_EXP);
}
JS_FreeValue(ctx, val);
{
JSValue val, ret;
int64_t p;
- int rnd_mode;
+ int rnd_mode, radix;
val = js_thisBigFloatValue(ctx, this_val);
if (JS_IsException(val))
goto fail;
}
rnd_mode = BF_RNDNA;
+ radix = 10;
if (argc > 1) {
- rnd_mode = get_rnd_mode(ctx, argv[1]);
+ rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
if (rnd_mode < 0)
goto fail;
}
- ret = js_ftoa(ctx, val, 10, p, rnd_mode | BF_FTOA_FORMAT_FIXED);
+ if (argc > 2) {
+ radix = js_get_radix(ctx, argv[2]);
+ if (radix < 0)
+ goto fail;
+ }
+ ret = js_ftoa(ctx, val, radix, p, rnd_mode | BF_FTOA_FORMAT_FIXED);
}
JS_FreeValue(ctx, val);
return ret;
{
JSValue val;
if (argc == 0) {
- bf_t r_s, *r = &r_s;
- bf_init(ctx->bf_ctx, r);
+ bf_t *r;
+ val = JS_NewBigFloat(ctx);
+ if (JS_IsException(val))
+ return val;
+ r = JS_GetBigFloat(val);
bf_set_zero(r, 0);
- val = JS_NewBigFloat(ctx, r);
} else {
val = JS_DupValue(ctx, argv[0]);
redo:
break;
case JS_TAG_FLOAT64:
{
- bf_t r_s, *r = &r_s;
- bf_init(ctx->bf_ctx, r);
- bf_set_float64(r, JS_VALUE_GET_FLOAT64(val));
- val = JS_NewBigFloat(ctx, r);
+ bf_t *r;
+ double d = JS_VALUE_GET_FLOAT64(val);
+ val = JS_NewBigFloat(ctx);
+ if (JS_IsException(val))
+ break;
+ r = JS_GetBigFloat(val);
+ if (bf_set_float64(r, d))
+ goto fail;
}
break;
case JS_TAG_INT:
{
- bf_t r_s, *r = &r_s;
- bf_init(ctx->bf_ctx, r);
- bf_set_si(r, JS_VALUE_GET_INT(val));
- val = JS_NewBigFloat(ctx, r);
+ bf_t *r;
+ int32_t v = JS_VALUE_GET_INT(val);
+ val = JS_NewBigFloat(ctx);
+ if (JS_IsException(val))
+ break;
+ r = JS_GetBigFloat(val);
+ if (bf_set_si(r, v))
+ goto fail;
}
break;
case JS_TAG_BIG_INT:
val = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
}
break;
+ case JS_TAG_BIG_DECIMAL:
+ val = JS_ToStringFree(ctx, val);
+ if (JS_IsException(val))
+ break;
+ goto redo;
case JS_TAG_STRING:
{
const char *str, *p;
p = str;
p += skip_spaces(p);
if ((p - str) == len) {
- bf_t r_s, *r = &r_s;
- bf_init(ctx->bf_ctx, r);
- bf_set_si(r, 0);
- val = JS_NewBigFloat(ctx, r);
+ bf_t *r;
+ val = JS_NewBigFloat(ctx);
+ if (JS_IsException(val))
+ break;
+ r = JS_GetBigFloat(val);
+ bf_set_zero(r, 0);
err = 0;
} else {
val = js_atof(ctx, p, &p, 0, ATOD_ACCEPT_BIN_OCT |
}
}
return val;
+ fail:
+ JS_FreeValue(ctx, val);
+ return JS_EXCEPTION;
}
static JSValue js_bigfloat_get_const(JSContext *ctx,
- JSValueConst this_val, int magic)
+ JSValueConst this_val, int magic)
{
- bf_t r_s, *r = &r_s;
- bf_init(ctx->bf_ctx, r);
+ bf_t *r;
+ JSValue val;
+ val = JS_NewBigFloat(ctx);
+ if (JS_IsException(val))
+ return val;
+ r = JS_GetBigFloat(val);
switch(magic) {
case 0: /* PI */
bf_const_pi(r, ctx->fp_env.prec, ctx->fp_env.flags);
default:
abort();
}
- return JS_NewBigFloat(ctx, r);
+ return val;
}
static JSValue js_bigfloat_parseFloat(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
{
- bf_t a_s, *a = &a_s;
+ bf_t *a;
const char *str;
JSValue ret;
int radix;
if (!fe)
goto fail;
}
- bf_init(ctx->bf_ctx, a);
+ ret = JS_NewBigFloat(ctx);
+ if (JS_IsException(ret))
+ goto done;
+ a = JS_GetBigFloat(ret);
/* XXX: use js_atof() */
bf_atof(a, str, NULL, radix, fe->prec, fe->flags);
- ret = JS_NewBigFloat(ctx, a);
+ done:
JS_FreeCString(ctx, str);
return ret;
}
if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
return JS_FALSE;
p = JS_VALUE_GET_PTR(val);
- return JS_NewBool(ctx, bf_is_finite(&p->num));
+ return JS_NewBool(ctx, bf_is_nan(&p->num));
+}
+
+enum {
+ MATH_OP_ABS,
+ MATH_OP_FLOOR,
+ MATH_OP_CEIL,
+ MATH_OP_ROUND,
+ MATH_OP_TRUNC,
+ MATH_OP_SQRT,
+ MATH_OP_FPROUND,
+ MATH_OP_ACOS,
+ MATH_OP_ASIN,
+ MATH_OP_ATAN,
+ MATH_OP_ATAN2,
+ MATH_OP_COS,
+ MATH_OP_EXP,
+ MATH_OP_LOG,
+ MATH_OP_POW,
+ MATH_OP_SIN,
+ MATH_OP_TAN,
+ MATH_OP_FMOD,
+ MATH_OP_REM,
+ MATH_OP_SIGN,
+
+ MATH_OP_ADD,
+ MATH_OP_SUB,
+ MATH_OP_MUL,
+ MATH_OP_DIV,
+};
+
+static JSValue js_bigfloat_fop(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv, int magic)
+{
+ bf_t a_s, *a, *r;
+ JSFloatEnv *fe;
+ int rnd_mode;
+ JSValue op1, res;
+
+ op1 = JS_ToNumeric(ctx, argv[0]);
+ if (JS_IsException(op1))
+ return op1;
+ a = JS_ToBigFloat(ctx, &a_s, op1);
+ fe = &ctx->fp_env;
+ if (argc > 1) {
+ fe = JS_GetOpaque2(ctx, argv[1], JS_CLASS_FLOAT_ENV);
+ if (!fe)
+ goto fail;
+ }
+ res = JS_NewBigFloat(ctx);
+ if (JS_IsException(res)) {
+ fail:
+ if (a == &a_s)
+ bf_delete(a);
+ JS_FreeValue(ctx, op1);
+ return JS_EXCEPTION;
+ }
+ r = JS_GetBigFloat(res);
+ switch (magic) {
+ case MATH_OP_ABS:
+ bf_set(r, a);
+ r->sign = 0;
+ break;
+ case MATH_OP_FLOOR:
+ rnd_mode = BF_RNDD;
+ goto rint;
+ case MATH_OP_CEIL:
+ rnd_mode = BF_RNDU;
+ goto rint;
+ case MATH_OP_ROUND:
+ rnd_mode = BF_RNDNA;
+ goto rint;
+ case MATH_OP_TRUNC:
+ rnd_mode = BF_RNDZ;
+ rint:
+ bf_set(r, a);
+ fe->status |= bf_rint(r, rnd_mode);
+ break;
+ case MATH_OP_SQRT:
+ fe->status |= bf_sqrt(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_FPROUND:
+ bf_set(r, a);
+ fe->status |= bf_round(r, fe->prec, fe->flags);
+ break;
+ case MATH_OP_ACOS:
+ fe->status |= bf_acos(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_ASIN:
+ fe->status |= bf_asin(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_ATAN:
+ fe->status |= bf_atan(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_COS:
+ fe->status |= bf_cos(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_EXP:
+ fe->status |= bf_exp(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_LOG:
+ fe->status |= bf_log(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_SIN:
+ fe->status |= bf_sin(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_TAN:
+ fe->status |= bf_tan(r, a, fe->prec, fe->flags);
+ break;
+ case MATH_OP_SIGN:
+ if (bf_is_nan(a) || bf_is_zero(a)) {
+ bf_set(r, a);
+ } else {
+ bf_set_si(r, 1 - 2 * a->sign);
+ }
+ break;
+ default:
+ abort();
+ }
+ if (a == &a_s)
+ bf_delete(a);
+ JS_FreeValue(ctx, op1);
+ return res;
+}
+
+static JSValue js_bigfloat_fop2(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv, int magic)
+{
+ bf_t a_s, *a, b_s, *b, r_s, *r = &r_s;
+ JSFloatEnv *fe;
+ JSValue op1, op2, res;
+
+ op1 = JS_ToNumeric(ctx, argv[0]);
+ if (JS_IsException(op1))
+ return op1;
+ op2 = JS_ToNumeric(ctx, argv[1]);
+ if (JS_IsException(op2)) {
+ JS_FreeValue(ctx, op1);
+ return op2;
+ }
+ a = JS_ToBigFloat(ctx, &a_s, op1);
+ b = JS_ToBigFloat(ctx, &b_s, op2);
+ fe = &ctx->fp_env;
+ if (argc > 2) {
+ fe = JS_GetOpaque2(ctx, argv[2], JS_CLASS_FLOAT_ENV);
+ if (!fe)
+ goto fail;
+ }
+ res = JS_NewBigFloat(ctx);
+ if (JS_IsException(res)) {
+ fail:
+ if (a == &a_s)
+ bf_delete(a);
+ if (b == &b_s)
+ bf_delete(b);
+ JS_FreeValue(ctx, op1);
+ JS_FreeValue(ctx, op2);
+ return JS_EXCEPTION;
+ }
+ r = JS_GetBigFloat(res);
+ switch (magic) {
+ case MATH_OP_ATAN2:
+ fe->status |= bf_atan2(r, a, b, fe->prec, fe->flags);
+ break;
+ case MATH_OP_POW:
+ fe->status |= bf_pow(r, a, b, fe->prec, fe->flags | BF_POW_JS_QUIRKS);
+ break;
+ case MATH_OP_FMOD:
+ fe->status |= bf_rem(r, a, b, fe->prec, fe->flags, BF_RNDZ);
+ break;
+ case MATH_OP_REM:
+ fe->status |= bf_rem(r, a, b, fe->prec, fe->flags, BF_RNDN);
+ break;
+ case MATH_OP_ADD:
+ fe->status |= bf_add(r, a, b, fe->prec, fe->flags);
+ break;
+ case MATH_OP_SUB:
+ fe->status |= bf_sub(r, a, b, fe->prec, fe->flags);
+ break;
+ case MATH_OP_MUL:
+ fe->status |= bf_mul(r, a, b, fe->prec, fe->flags);
+ break;
+ case MATH_OP_DIV:
+ fe->status |= bf_div(r, a, b, fe->prec, fe->flags);
+ break;
+ default:
+ abort();
+ }
+ if (a == &a_s)
+ bf_delete(a);
+ if (b == &b_s)
+ bf_delete(b);
+ JS_FreeValue(ctx, op1);
+ JS_FreeValue(ctx, op2);
+ return res;
}
static const JSCFunctionListEntry js_bigfloat_funcs[] = {
return JS_NewInt32(ctx, bf_get_exp_bits(ctx->fp_env.flags));
}
-/* temporary fix for string conversion overflows */
-#define BF_EXP_BITS_MAX1 (BF_EXP_BITS_MAX - 1)
-
static JSValue js_float_env_setPrec(JSContext *ctx,
JSValueConst this_val,
int argc, JSValueConst *argv)
return JS_EXCEPTION;
if (prec < BF_PREC_MIN || prec > BF_PREC_MAX)
return JS_ThrowRangeError(ctx, "invalid precision");
- exp_bits = BF_EXP_BITS_MAX1;
+ exp_bits = BF_EXP_BITS_MAX;
if (argc > 2 && !JS_IsUndefined(argv[2])) {
if (JS_ToInt32Sat(ctx, &exp_bits, argv[2]))
return JS_EXCEPTION;
- if (exp_bits < BF_EXP_BITS_MIN || exp_bits > BF_EXP_BITS_MAX1)
+ if (exp_bits < BF_EXP_BITS_MIN || exp_bits > BF_EXP_BITS_MAX)
return JS_ThrowRangeError(ctx, "invalid number of exponent bits");
}
- flags = BF_RNDN | bf_set_exp_bits(exp_bits);
- if (exp_bits != BF_EXP_BITS_MAX1)
- flags |= BF_FLAG_SUBNORMAL;
+ flags = BF_RNDN | BF_FLAG_SUBNORMAL | bf_set_exp_bits(exp_bits);
saved_prec = ctx->fp_env.prec;
saved_flags = ctx->fp_env.flags;
case FE_EXP:
if (JS_ToInt32Sat(ctx, &b, val))
return JS_EXCEPTION;
- if (b < BF_EXP_BITS_MIN || b > BF_EXP_BITS_MAX1)
+ if (b < BF_EXP_BITS_MIN || b > BF_EXP_BITS_MAX)
return JS_ThrowRangeError(ctx, "invalid number of exponent bits");
- if (b == BF_EXP_BITS_MAX1)
- fe->flags &= ~BF_FLAG_SUBNORMAL;
fe->flags = (fe->flags & ~(BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT)) |
bf_set_exp_bits(b);
break;
case FE_RNDMODE:
- b = get_rnd_mode(ctx, val);
+ b = bigfloat_get_rnd_mode(ctx, val);
if (b < 0)
return JS_EXCEPTION;
fe->flags = (fe->flags & ~BF_RND_MASK) | b;
break;
case FE_SUBNORMAL:
b = JS_ToBool(ctx, val);
- if (bf_get_exp_bits(fe->flags) != BF_EXP_BITS_MAX1) {
- fe->flags = (fe->flags & ~BF_FLAG_SUBNORMAL) | (b ? BF_FLAG_SUBNORMAL: 0);
- }
+ fe->flags = (fe->flags & ~BF_FLAG_SUBNORMAL) | (b ? BF_FLAG_SUBNORMAL: 0);
break;
default:
b = JS_ToBool(ctx, val);
JS_PROP_INT32_DEF("RNDU", BF_RNDU, 0 ),
JS_PROP_INT32_DEF("RNDD", BF_RNDD, 0 ),
JS_PROP_INT32_DEF("RNDNA", BF_RNDNA, 0 ),
- JS_PROP_INT32_DEF("RNDNU", BF_RNDNU, 0 ),
+ JS_PROP_INT32_DEF("RNDA", BF_RNDA, 0 ),
JS_PROP_INT32_DEF("RNDF", BF_RNDF, 0 ),
JS_PROP_INT32_DEF("precMin", BF_PREC_MIN, 0 ),
JS_PROP_INT64_DEF("precMax", BF_PREC_MAX, 0 ),
JS_PROP_INT32_DEF("expBitsMin", BF_EXP_BITS_MIN, 0 ),
- JS_PROP_INT32_DEF("expBitsMax", BF_EXP_BITS_MAX1, 0 ),
+ JS_PROP_INT32_DEF("expBitsMax", BF_EXP_BITS_MAX, 0 ),
};
static const JSCFunctionListEntry js_float_env_proto_funcs[] = {
case JS_TAG_BOOL:
case JS_TAG_INT:
{
- bfdec_t r_s, *r = &r_s;
- bfdec_init(ctx->bf_ctx, r);
- bfdec_set_si(r, JS_VALUE_GET_INT(val));
- val = JS_NewBigDecimal(ctx, r);
+ bfdec_t *r;
+ int32_t v = JS_VALUE_GET_INT(val);
+
+ val = JS_NewBigDecimal(ctx);
+ if (JS_IsException(val))
+ break;
+ r = JS_GetBigDecimal(val);
+ if (bfdec_set_si(r, v)) {
+ JS_FreeValue(ctx, val);
+ val = JS_EXCEPTION;
+ break;
+ }
}
break;
case JS_TAG_FLOAT64:
p = str;
p += skip_spaces(p);
if ((p - str) == len) {
- bfdec_t r_s, *r = &r_s;
- bfdec_init(ctx->bf_ctx, r);
+ bfdec_t *r;
+ val = JS_NewBigDecimal(ctx);
+ if (JS_IsException(val))
+ break;
+ r = JS_GetBigDecimal(val);
bfdec_set_zero(r, 0);
- val = JS_NewBigDecimal(ctx, r);
err = 0;
} else {
val = js_atof(ctx, p, &p, 0, ATOD_TYPE_BIG_DECIMAL);
goto redo;
case JS_TAG_UNDEFINED:
{
- bfdec_t r_s, *r = &r_s;
+ bfdec_t *r;
if (!allow_null_or_undefined)
goto fail;
- bfdec_init(ctx->bf_ctx, r);
+ val = JS_NewBigDecimal(ctx);
+ if (JS_IsException(val))
+ break;
+ r = JS_GetBigDecimal(val);
bfdec_set_nan(r);
- val = JS_NewBigDecimal(ctx, r);
}
break;
default:
{
JSValue val;
if (argc == 0) {
- bfdec_t r_s, *r = &r_s;
- bfdec_init(ctx->bf_ctx, r);
+ bfdec_t *r;
+ val = JS_NewBigDecimal(ctx);
+ if (JS_IsException(val))
+ return val;
+ r = JS_GetBigDecimal(val);
bfdec_set_zero(r, 0);
- val = JS_NewBigDecimal(ctx, r);
} else {
val = JS_ToBigDecimalFree(ctx, JS_DupValue(ctx, argv[0]), FALSE);
}
return js_thisBigDecimalValue(ctx, this_val);
}
+static int js_bigdecimal_get_rnd_mode(JSContext *ctx, JSValueConst obj)
+{
+ const char *str;
+ size_t size;
+ int rnd_mode;
+
+ str = JS_ToCStringLen(ctx, &size, obj);
+ if (!str)
+ return -1;
+ if (strlen(str) != size)
+ goto invalid_rounding_mode;
+ if (!strcmp(str, "floor")) {
+ rnd_mode = BF_RNDD;
+ } else if (!strcmp(str, "ceiling")) {
+ rnd_mode = BF_RNDU;
+ } else if (!strcmp(str, "down")) {
+ rnd_mode = BF_RNDZ;
+ } else if (!strcmp(str, "up")) {
+ rnd_mode = BF_RNDA;
+ } else if (!strcmp(str, "half-even")) {
+ rnd_mode = BF_RNDN;
+ } else if (!strcmp(str, "half-up")) {
+ rnd_mode = BF_RNDNA;
+ } else {
+ invalid_rounding_mode:
+ JS_FreeCString(ctx, str);
+ JS_ThrowTypeError(ctx, "invalid rounding mode");
+ return -1;
+ }
+ JS_FreeCString(ctx, str);
+ return rnd_mode;
+}
+
typedef struct {
int64_t prec;
bf_flags_t flags;
JSValueConst obj)
{
JSValue prop;
- const char *str;
- size_t size;
int64_t val;
BOOL has_prec;
+ int rnd_mode;
if (!JS_IsObject(obj)) {
JS_ThrowTypeErrorNotAnObject(ctx);
prop = JS_GetProperty(ctx, obj, JS_ATOM_roundingMode);
if (JS_IsException(prop))
return -1;
- str = JS_ToCStringLen(ctx, &size, prop);
+ rnd_mode = js_bigdecimal_get_rnd_mode(ctx, prop);
JS_FreeValue(ctx, prop);
- if (!str)
- return -1;
- if (strlen(str) != size)
- goto invalid_rounding_mode;
- if (!strcmp(str, "floor")) {
- fe->flags = BF_RNDD;
- } else if (!strcmp(str, "ceiling")) {
- fe->flags = BF_RNDU;
- } else if (!strcmp(str, "down")) {
- fe->flags = BF_RNDZ;
- } else if (!strcmp(str, "half-even")) {
- fe->flags = BF_RNDN;
- } else if (!strcmp(str, "half-up")) {
- fe->flags = BF_RNDNA;
- } else {
- invalid_rounding_mode:
- JS_FreeCString(ctx, str);
- JS_ThrowTypeError(ctx, "invalid rounding mode");
+ if (rnd_mode < 0)
return -1;
- }
- JS_FreeCString(ctx, str);
+ fe->flags = rnd_mode;
prop = JS_GetProperty(ctx, obj, JS_ATOM_maximumSignificantDigits);
if (JS_IsException(prop))
if (!JS_IsUndefined(prop)) {
if (JS_ToInt64SatFree(ctx, &val, prop))
return -1;
- if (val < 0 || val > BF_PREC_MAX)
+ if (val < 1 || val > BF_PREC_MAX)
goto invalid_precision;
fe->prec = val;
has_prec = TRUE;
int argc, JSValueConst *argv, int magic)
{
bfdec_t *a, *b, r_s, *r = &r_s;
- JSValue op1, op2;
+ JSValue op1, op2, res;
BigDecimalEnv fe_s, *fe = &fe_s;
int op_count, ret;
fe->flags = BF_RNDZ;
fe->prec = BF_PREC_INF;
if (op_count < argc) {
- if (js_bigdecimal_get_env(ctx, fe, argv[op_count])) {
- fail:
- JS_FreeValue(ctx, op1);
- JS_FreeValue(ctx, op2);
- return JS_EXCEPTION;
- }
- if ((fe->flags & BF_FLAG_RADPNT_PREC) &&
- magic != MATH_OP_DIV &&
- magic != MATH_OP_ROUND) {
- JS_ThrowTypeError(ctx, "maximumFractionDigits is not supported for this operation");
+ if (js_bigdecimal_get_env(ctx, fe, argv[op_count]))
goto fail;
- }
}
- bfdec_init(ctx->bf_ctx, r);
+ res = JS_NewBigDecimal(ctx);
+ if (JS_IsException(res)) {
+ fail:
+ JS_FreeValue(ctx, op1);
+ JS_FreeValue(ctx, op2);
+ return JS_EXCEPTION;
+ }
+ r = JS_GetBigDecimal(res);
switch (magic) {
case MATH_OP_ADD:
ret = bfdec_add(r, a, b, fe->prec, fe->flags);
case MATH_OP_DIV:
ret = bfdec_div(r, a, b, fe->prec, fe->flags);
break;
+ case MATH_OP_FMOD:
+ ret = bfdec_rem(r, a, b, fe->prec, fe->flags, BF_RNDZ);
+ break;
case MATH_OP_SQRT:
ret = bfdec_sqrt(r, a, fe->prec, fe->flags);
break;
ret &= BF_ST_MEM_ERROR | BF_ST_DIVIDE_ZERO | BF_ST_INVALID_OP |
BF_ST_OVERFLOW;
if (ret != 0) {
- bfdec_delete(r);
+ JS_FreeValue(ctx, res);
return throw_bf_exception(ctx, ret);
} else {
- return JS_NewBigDecimal(ctx, r);
+ return res;
+ }
+}
+
+static JSValue js_bigdecimal_toFixed(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv)
+{
+ JSValue val, ret;
+ int64_t f;
+ int rnd_mode;
+
+ val = js_thisBigDecimalValue(ctx, this_val);
+ if (JS_IsException(val))
+ return val;
+ if (JS_ToInt64Sat(ctx, &f, argv[0]))
+ goto fail;
+ if (f < 0 || f > BF_PREC_MAX) {
+ JS_ThrowRangeError(ctx, "invalid number of digits");
+ goto fail;
+ }
+ rnd_mode = BF_RNDNA;
+ if (argc > 1) {
+ rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
+ if (rnd_mode < 0)
+ goto fail;
+ }
+ ret = js_bigdecimal_to_string1(ctx, val, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
+ JS_FreeValue(ctx, val);
+ return ret;
+ fail:
+ JS_FreeValue(ctx, val);
+ return JS_EXCEPTION;
+}
+
+static JSValue js_bigdecimal_toExponential(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv)
+{
+ JSValue val, ret;
+ int64_t f;
+ int rnd_mode;
+
+ val = js_thisBigDecimalValue(ctx, this_val);
+ if (JS_IsException(val))
+ return val;
+ if (JS_ToInt64Sat(ctx, &f, argv[0]))
+ goto fail;
+ if (JS_IsUndefined(argv[0])) {
+ ret = js_bigdecimal_to_string1(ctx, val, 0,
+ BF_RNDN | BF_FTOA_FORMAT_FREE_MIN | BF_FTOA_FORCE_EXP);
+ } else {
+ if (f < 0 || f > BF_PREC_MAX) {
+ JS_ThrowRangeError(ctx, "invalid number of digits");
+ goto fail;
+ }
+ rnd_mode = BF_RNDNA;
+ if (argc > 1) {
+ rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
+ if (rnd_mode < 0)
+ goto fail;
+ }
+ ret = js_bigdecimal_to_string1(ctx, val, f + 1,
+ rnd_mode | BF_FTOA_FORMAT_FIXED | BF_FTOA_FORCE_EXP);
+ }
+ JS_FreeValue(ctx, val);
+ return ret;
+ fail:
+ JS_FreeValue(ctx, val);
+ return JS_EXCEPTION;
+}
+
+static JSValue js_bigdecimal_toPrecision(JSContext *ctx, JSValueConst this_val,
+ int argc, JSValueConst *argv)
+{
+ JSValue val, ret;
+ int64_t p;
+ int rnd_mode;
+
+ val = js_thisBigDecimalValue(ctx, this_val);
+ if (JS_IsException(val))
+ return val;
+ if (JS_IsUndefined(argv[0])) {
+ return JS_ToStringFree(ctx, val);
+ }
+ if (JS_ToInt64Sat(ctx, &p, argv[0]))
+ goto fail;
+ if (p < 1 || p > BF_PREC_MAX) {
+ JS_ThrowRangeError(ctx, "invalid number of digits");
+ goto fail;
+ }
+ rnd_mode = BF_RNDNA;
+ if (argc > 1) {
+ rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
+ if (rnd_mode < 0)
+ goto fail;
}
+ ret = js_bigdecimal_to_string1(ctx, val, p,
+ rnd_mode | BF_FTOA_FORMAT_FIXED);
+ JS_FreeValue(ctx, val);
+ return ret;
+ fail:
+ JS_FreeValue(ctx, val);
+ return JS_EXCEPTION;
}
static const JSCFunctionListEntry js_bigdecimal_proto_funcs[] = {
JS_CFUNC_DEF("toString", 0, js_bigdecimal_toString ),
JS_CFUNC_DEF("valueOf", 0, js_bigdecimal_valueOf ),
+ JS_CFUNC_DEF("toPrecision", 1, js_bigdecimal_toPrecision ),
+ JS_CFUNC_DEF("toFixed", 1, js_bigdecimal_toFixed ),
+ JS_CFUNC_DEF("toExponential", 1, js_bigdecimal_toExponential ),
};
static const JSCFunctionListEntry js_bigdecimal_funcs[] = {
JS_CFUNC_MAGIC_DEF("sub", 2, js_bigdecimal_fop, MATH_OP_SUB ),
JS_CFUNC_MAGIC_DEF("mul", 2, js_bigdecimal_fop, MATH_OP_MUL ),
JS_CFUNC_MAGIC_DEF("div", 2, js_bigdecimal_fop, MATH_OP_DIV ),
+ JS_CFUNC_MAGIC_DEF("mod", 2, js_bigdecimal_fop, MATH_OP_FMOD ),
JS_CFUNC_MAGIC_DEF("round", 1, js_bigdecimal_fop, MATH_OP_ROUND ),
JS_CFUNC_MAGIC_DEF("sqrt", 1, js_bigdecimal_fop, MATH_OP_SQRT ),
};
count = min_int(final - from, len - to);
if (count > 0) {
p = JS_VALUE_GET_OBJ(this_val);
+ if (typed_array_is_detached(ctx, p))
+ return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
shift = typed_array_size_log2(p->class_id);
memmove(p->u.array.u.uint8_ptr + (to << shift),
p->u.array.u.uint8_ptr + (from << shift),
return JS_EXCEPTION;
}
+ if (typed_array_is_detached(ctx, p))
+ return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+
shift = typed_array_size_log2(p->class_id);
switch(shift) {
case 0:
typedef uint32_t JSClassID;
typedef uint32_t JSAtom;
-#if defined(__x86_64__) || defined(__aarch64__)
+#if INTPTR_MAX >= INT64_MAX
#define JS_PTR64
#define JS_PTR64_DEF(a) a
#else
void JS_AddIntrinsicBigInt(JSContext *ctx);
void JS_AddIntrinsicBigFloat(JSContext *ctx);
void JS_AddIntrinsicBigDecimal(JSContext *ctx);
-/* enable "use bigint", "use math" and operator overloading */
+/* enable operator overloading */
+void JS_AddIntrinsicOperators(JSContext *ctx);
+/* enable "use math" */
void JS_EnableBignumExt(JSContext *ctx, JS_BOOL enable);
JSValue js_string_codePointRange(JSContext *ctx, JSValueConst this_val,
return v;
}
-JS_BOOL JS_IsNumber(JSValueConst v);
+static inline JS_BOOL JS_IsNumber(JSValueConst v)
+{
+ int tag = JS_VALUE_GET_TAG(v);
+ return tag == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag);
+}
-static inline JS_BOOL JS_IsInteger(JSValueConst v)
+static inline JS_BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v)
{
int tag = JS_VALUE_GET_TAG(v);
- return tag == JS_TAG_INT || tag == JS_TAG_BIG_INT;
+ return tag == JS_TAG_BIG_INT;
}
static inline JS_BOOL JS_IsBigFloat(JSValueConst v)
/*
* QuickJS Read Eval Print Loop
*
- * Copyright (c) 2017-2019 Fabrice Bellard
- * Copyright (c) 2017-2019 Charlie Gordon
+ * Copyright (c) 2017-2020 Fabrice Bellard
+ * Copyright (c) 2017-2020 Charlie Gordon
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
var hex_mode = false;
var eval_mode = "std";
- function bignum_typeof(a) {
- "use bigint";
- return typeof a;
- }
-
- function eval_mode_typeof(a) {
- if (eval_mode === "std")
- return typeof a;
- else
- return bignum_typeof(a);
- }
-
function number_to_string(a, radix) {
var s;
if (!isFinite(a)) {
s = a.toString();
}
}
- if (eval_mode !== "std" && s.indexOf(".") < 0 &&
- ((radix == 16 && s.indexOf("p") < 0) ||
- (radix == 10 && s.indexOf("e") < 0))) {
- /* add a decimal point so that the floating point type
- is visible */
- s += ".0";
- }
return s;
}
}
function print_rec(a) {
var n, i, keys, key, type, s;
- type = eval_mode_typeof(a);
+ type = typeof(a);
if (type === "object") {
if (a === null) {
std.puts(a);
} else if (type === "bigfloat") {
std.puts(bigfloat_to_string(a, hex_mode ? 16 : 10));
} else if (type === "bigdecimal") {
- std.puts(a.toString() + "d");
+ std.puts(a.toString() + "m");
} else if (type === "symbol") {
std.puts(String(a));
} else if (type === "function") {
param = expr.substring(cmd.length + 1).trim();
if (param === "") {
std.puts("Running mode=" + eval_mode + "\n");
- } else if (param === "std" || param === "math" ||
- param === "bigint") {
+ } else if (param === "std" || param === "math") {
eval_mode = param;
} else {
std.puts("Invalid mode\n");
std.puts("\\p [m [e]] set the BigFloat precision to 'm' bits\n" +
"\\digits n set the BigFloat precision to 'ceil(n*log2(10))' bits\n");
if (!has_jscalc) {
- std.puts("\\mode [std|bigint|math] change the running mode (current = " + eval_mode + ")\n");
+ std.puts("\\mode [std|math] change the running mode (current = " + eval_mode + ")\n");
}
}
if (!config_numcalc) {
try {
if (eval_mode === "math")
expr = '"use math"; void 0;' + expr;
- else if (eval_mode === "bigint")
- expr = '"use bigint"; void 0;' + expr;
var now = (new Date).getTime();
/* eval as a script */
result = std.evalScript(expr, { backtrace_barrier: true });
+test262/test/language/expressions/arrow-function/eval-var-scope-syntax-err.js:47: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/expressions/async-generator/eval-var-scope-syntax-err.js:28: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/expressions/async-generator/named-eval-var-scope-syntax-err.js:28: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/expressions/class/super-evaluation-order.js:26: Test262Error: via ArgumentListEvaluation Expected SameValue(«0», «123») to be true
+test262/test/language/expressions/class/super-evaluation-order.js:26: strict mode: Test262Error: via ArgumentListEvaluation Expected SameValue(«0», «123») to be true
test262/test/language/expressions/dynamic-import/usage-from-eval.js:26: TypeError: $DONE() not called
test262/test/language/expressions/dynamic-import/usage-from-eval.js:26: strict mode: TypeError: $DONE() not called
+test262/test/language/expressions/function/eval-var-scope-syntax-err.js:48: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/expressions/generators/eval-var-scope-syntax-err.js:49: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/expressions/object/method-definition/async-gen-meth-eval-var-scope-syntax-err.js:32: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/expressions/object/method-definition/gen-meth-eval-var-scope-syntax-err.js:54: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/expressions/object/method-definition/meth-eval-var-scope-syntax-err.js:50: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
test262/test/language/expressions/optional-chaining/optional-call-preserves-this.js:21: TypeError: value has no property
test262/test/language/expressions/optional-chaining/optional-call-preserves-this.js:15: strict mode: TypeError: value has no property
+test262/test/language/statements/async-generator/eval-var-scope-syntax-err.js:28: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/statements/function/eval-var-scope-syntax-err.js:49: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
+test262/test/language/statements/generators/eval-var-scope-syntax-err.js:49: Test262Error: Expected a SyntaxError to be thrown but no exception was thrown at all
e = new BigFloatEnv(128);
assert(e.prec == 128);
a = BigFloat.sqrt(2l, e);
- assert(a == BigFloat.parseFloat("0x1.6a09e667f3bcc908b2fb1366ea957d3e", 0, e));
+ assert(a === BigFloat.parseFloat("0x1.6a09e667f3bcc908b2fb1366ea957d3e", 0, e));
assert(e.inexact === true);
assert(BigFloat.fpRound(a) == 0x1.6a09e667f3bcc908b2fb1366ea95l);
b = BigFloatEnv.setPrec(BigFloat.sqrt.bind(null, 2), 128);
- assert(a == b);
+ assert(a === b);
+
+ assert(BigFloat.isNaN(BigFloat(NaN)));
+ assert(BigFloat.isFinite(1l));
+ assert(!BigFloat.isFinite(1l/0l));
+
+ assert(BigFloat.abs(-3l) === 3l);
+ assert(BigFloat.sign(-3l) === -1l);
+
+ assert(BigFloat.exp(0.2l) === 1.2214027581601698339210719946396742l);
+ assert(BigFloat.log(3l) === 1.0986122886681096913952452369225256l);
+ assert(BigFloat.pow(2.1l, 1.6l) === 3.277561666451861947162828744873745l);
+
+ assert(BigFloat.sin(-1l) === -0.841470984807896506652502321630299l);
+ assert(BigFloat.cos(1l) === 0.5403023058681397174009366074429766l);
+ assert(BigFloat.tan(0.1l) === 0.10033467208545054505808004578111154l);
+
+ assert(BigFloat.asin(0.3l) === 0.30469265401539750797200296122752915l);
+ assert(BigFloat.acos(0.4l) === 1.1592794807274085998465837940224159l);
+ assert(BigFloat.atan(0.7l) === 0.610725964389208616543758876490236l);
+ assert(BigFloat.atan2(7.1l, -5.1l) === 2.1937053809751415549388104628759813l);
+
+ assert(BigFloat.floor(2.5l) === 2l);
+ assert(BigFloat.ceil(2.5l) === 3l);
+ assert(BigFloat.trunc(-2.5l) === -2l);
+ assert(BigFloat.round(2.5l) === 3l);
+
+ assert(BigFloat.fmod(3l,2l) === 1l);
+ assert(BigFloat.remainder(3l,2l) === -1l);
+
+ /* string conversion */
+ assert((1234.125l).toString(), "1234.125");
+ assert((1234.125l).toFixed(2), "1234.13");
+ assert((1234.125l).toFixed(2, "down"), "1234.12");
+ assert((1234.125l).toExponential(), "1.234125e+3");
+ assert((1234.125l).toExponential(5), "1.23413e+3");
+ assert((1234.125l).toExponential(5, BigFloatEnv.RNDZ), "1.23412e+3");
+ assert((1234.125l).toPrecision(6), "1234.13");
+ assert((1234.125l).toPrecision(6, BigFloatEnv.RNDZ), "1234.12");
+
+ /* string conversion with binary base */
+ assert((0x123.438l).toString(16), "123.438");
+ assert((0x323.438l).toString(16), "323.438");
+ assert((0x723.438l).toString(16), "723.438");
+ assert((0xf23.438l).toString(16), "f23.438");
+ assert((0x123.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "123.44");
+ assert((0x323.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "323.44");
+ assert((0x723.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "723.44");
+ assert((0xf23.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "f23.44");
+ assert((0x0.0000438l).toFixed(6, BigFloatEnv.RNDNA, 16), "0.000044");
+ assert((0x1230000000l).toFixed(1, BigFloatEnv.RNDNA, 16), "1230000000.0");
+ assert((0x123.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "123.44");
+ assert((0x123.438l).toPrecision(5, BigFloatEnv.RNDZ, 16), "123.43");
+ assert((0x323.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "323.44");
+ assert((0x723.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "723.44");
+ assert((-0xf23.438l).toPrecision(5, BigFloatEnv.RNDD, 16), "-f23.44");
+ assert((0x123.438l).toExponential(4, BigFloatEnv.RNDNA, 16), "1.2344p+8");
}
function test_bigdecimal()
{
- assert(1d === 1d);
- assert(1d !== 2d);
- test_less(1d, 2d);
- test_eq(2d, 2d);
+ assert(1m === 1m);
+ assert(1m !== 2m);
+ test_less(1m, 2m);
+ test_eq(2m, 2m);
- test_less(1, 2d);
- test_eq(2, 2d);
+ test_less(1, 2m);
+ test_eq(2, 2m);
- test_less(1.1, 2d);
- test_eq(Math.sqrt(4), 2d);
+ test_less(1.1, 2m);
+ test_eq(Math.sqrt(4), 2m);
- test_less(2n, 3d);
- test_eq(3n, 3d);
+ test_less(2n, 3m);
+ test_eq(3n, 3m);
- assert(BigDecimal("1234.1") === 1234.1d);
- assert(BigDecimal(" 1234.1") === 1234.1d);
- assert(BigDecimal(" 1234.1 ") === 1234.1d);
-
- assert(BigDecimal(0.1) === 0.1d);
- assert(BigDecimal(123) === 123d);
- assert(BigDecimal(true) === 1d);
+ assert(BigDecimal("1234.1") === 1234.1m);
+ assert(BigDecimal(" 1234.1") === 1234.1m);
+ assert(BigDecimal(" 1234.1 ") === 1234.1m);
- assert(123d + 1d === 124d);
- assert(123d - 1d === 122d);
+ assert(BigDecimal(0.1) === 0.1m);
+ assert(BigDecimal(123) === 123m);
+ assert(BigDecimal(true) === 1m);
- assert(3.2d * 3d === 9.6d);
- assert(10d / 2d === 5d);
- assertThrows(RangeError, () => { 10d / 3d } );
- assert(BigDecimal.div(20d, 3d,
- { roundingMode: "half-even",
- maximumSignificantDigits: 3 }) === 6.67d);
- assert(BigDecimal.div(20d, 3d,
- { roundingMode: "half-even",
- maximumFractionDigits: 3 }) === 6.667d);
+ assert(123m + 1m === 124m);
+ assert(123m - 1m === 122m);
- assert(10d % 3d === 1d);
- assert(-10d % 3d === -1d);
+ assert(3.2m * 3m === 9.6m);
+ assert(10m / 2m === 5m);
+ assertThrows(RangeError, () => { 10m / 3m } );
- assert(-10d % 3d === -1d);
+ assert(10m % 3m === 1m);
+ assert(-10m % 3m === -1m);
- assert(1234.5d ** 3d === 1881365963.625d);
- assertThrows(RangeError, () => { 2d ** 3.1d } );
- assertThrows(RangeError, () => { 2d ** -3d } );
+ assert(1234.5m ** 3m === 1881365963.625m);
+ assertThrows(RangeError, () => { 2m ** 3.1m } );
+ assertThrows(RangeError, () => { 2m ** -3m } );
- assert(BigDecimal.sqrt(2d,
+ assert(BigDecimal.sqrt(2m,
+ { roundingMode: "half-even",
+ maximumSignificantDigits: 4 }) === 1.414m);
+ assert(BigDecimal.sqrt(101m,
{ roundingMode: "half-even",
- maximumSignificantDigits: 4 }) === 1.414d);
+ maximumFractionDigits: 3 }) === 10.050m);
+ assert(BigDecimal.sqrt(0.002m,
+ { roundingMode: "half-even",
+ maximumFractionDigits: 3 }) === 0.045m);
- assert(BigDecimal.round(3.14159d,
+ assert(BigDecimal.round(3.14159m,
+ { roundingMode: "half-even",
+ maximumFractionDigits: 3 }) === 3.142m);
+
+ assert(BigDecimal.add(3.14159m, 0.31212m,
+ { roundingMode: "half-even",
+ maximumFractionDigits: 2 }) === 3.45m);
+ assert(BigDecimal.sub(3.14159m, 0.31212m,
+ { roundingMode: "down",
+ maximumFractionDigits: 2 }) === 2.82m);
+ assert(BigDecimal.mul(3.14159m, 0.31212m,
+ { roundingMode: "half-even",
+ maximumFractionDigits: 3 }) === 0.981m);
+ assert(BigDecimal.mod(3.14159m, 0.31211m,
+ { roundingMode: "half-even",
+ maximumFractionDigits: 4 }) === 0.0205m);
+ assert(BigDecimal.div(20m, 3m,
+ { roundingMode: "half-even",
+ maximumSignificantDigits: 3 }) === 6.67m);
+ assert(BigDecimal.div(20m, 3m,
{ roundingMode: "half-even",
- maximumFractionDigits: 3 }) === 3.142d);
+ maximumFractionDigits: 50 }) ===
+ 6.66666666666666666666666666666666666666666666666667m);
+
+ /* string conversion */
+ assert((1234.125m).toString(), "1234.125");
+ assert((1234.125m).toFixed(2), "1234.13");
+ assert((1234.125m).toFixed(2, "down"), "1234.12");
+ assert((1234.125m).toExponential(), "1.234125e+3");
+ assert((1234.125m).toExponential(5), "1.23413e+3");
+ assert((1234.125m).toExponential(5, "down"), "1.23412e+3");
+ assert((1234.125m).toPrecision(6), "1234.13");
+ assert((1234.125m).toPrecision(6, "down"), "1234.12");
+ assert((-1234.125m).toPrecision(6, "floor"), "-1234.13");
}
test_bigint1();
--- /dev/null
+"use strict";
+
+function assert(actual, expected, message) {
+ if (arguments.length == 1)
+ expected = true;
+
+ if (actual === expected)
+ return;
+
+ if (actual !== null && expected !== null
+ && typeof actual == 'object' && typeof expected == 'object'
+ && actual.toString() === expected.toString())
+ return;
+
+ throw Error("assertion failed: got |" + actual + "|" +
+ ", expected |" + expected + "|" +
+ (message ? " (" + message + ")" : ""));
+}
+
+/* operators overloading with Operators.create() */
+function test_operators_create() {
+ class Vec2
+ {
+ constructor(x, y) {
+ this.x = x;
+ this.y = y;
+ }
+ static mul_scalar(p1, a) {
+ var r = new Vec2();
+ r.x = p1.x * a;
+ r.y = p1.y * a;
+ return r;
+ }
+ toString() {
+ return "Vec2(" + this.x + "," + this.y + ")";
+ }
+ }
+
+ Vec2.prototype[Symbol.operatorSet] = Operators.create(
+ {
+ "+"(p1, p2) {
+ var r = new Vec2();
+ r.x = p1.x + p2.x;
+ r.y = p1.y + p2.y;
+ return r;
+ },
+ "-"(p1, p2) {
+ var r = new Vec2();
+ r.x = p1.x - p2.x;
+ r.y = p1.y - p2.y;
+ return r;
+ },
+ "=="(a, b) {
+ return a.x == b.x && a.y == b.y;
+ },
+ "<"(a, b) {
+ var r;
+ /* lexicographic order */
+ if (a.x == b.x)
+ r = (a.y < b.y);
+ else
+ r = (a.x < b.x);
+ return r;
+ },
+ "++"(a) {
+ var r = new Vec2();
+ r.x = a.x + 1;
+ r.y = a.y + 1;
+ return r;
+ }
+ },
+ {
+ left: Number,
+ "*"(a, b) {
+ return Vec2.mul_scalar(b, a);
+ }
+ },
+ {
+ right: Number,
+ "*"(a, b) {
+ return Vec2.mul_scalar(a, b);
+ }
+ });
+
+ var a = new Vec2(1, 2);
+ var b = new Vec2(3, 4);
+ var r;
+
+ r = a * 2 + 3 * b;
+ assert(r.x === 11 && r.y === 16);
+ assert(a == a, true);
+ assert(a == b, false);
+ assert(a != a, false);
+ assert(a < b, true);
+ assert(a <= b, true);
+ assert(b < a, false);
+ assert(b <= a, false);
+ assert(a <= a, true);
+ assert(a >= a, true);
+ a++;
+ assert(a.x === 2 && a.y === 3);
+ r = ++a;
+ assert(a.x === 3 && a.y === 4);
+ assert(r === a);
+}
+
+/* operators overloading thru inheritance */
+function test_operators()
+{
+ var Vec2;
+
+ function mul_scalar(p1, a) {
+ var r = new Vec2();
+ r.x = p1.x * a;
+ r.y = p1.y * a;
+ return r;
+ }
+
+ var vec2_ops = Operators({
+ "+"(p1, p2) {
+ var r = new Vec2();
+ r.x = p1.x + p2.x;
+ r.y = p1.y + p2.y;
+ return r;
+ },
+ "-"(p1, p2) {
+ var r = new Vec2();
+ r.x = p1.x - p2.x;
+ r.y = p1.y - p2.y;
+ return r;
+ },
+ "=="(a, b) {
+ return a.x == b.x && a.y == b.y;
+ },
+ "<"(a, b) {
+ var r;
+ /* lexicographic order */
+ if (a.x == b.x)
+ r = (a.y < b.y);
+ else
+ r = (a.x < b.x);
+ return r;
+ },
+ "++"(a) {
+ var r = new Vec2();
+ r.x = a.x + 1;
+ r.y = a.y + 1;
+ return r;
+ }
+ },
+ {
+ left: Number,
+ "*"(a, b) {
+ return mul_scalar(b, a);
+ }
+ },
+ {
+ right: Number,
+ "*"(a, b) {
+ return mul_scalar(a, b);
+ }
+ });
+
+ Vec2 = class Vec2 extends vec2_ops
+ {
+ constructor(x, y) {
+ super();
+ this.x = x;
+ this.y = y;
+ }
+ toString() {
+ return "Vec2(" + this.x + "," + this.y + ")";
+ }
+ }
+
+ var a = new Vec2(1, 2);
+ var b = new Vec2(3, 4);
+ var r;
+
+ r = a * 2 + 3 * b;
+ assert(r.x === 11 && r.y === 16);
+ assert(a == a, true);
+ assert(a == b, false);
+ assert(a != a, false);
+ assert(a < b, true);
+ assert(a <= b, true);
+ assert(b < a, false);
+ assert(b <= a, false);
+ assert(a <= a, true);
+ assert(a >= a, true);
+ a++;
+ assert(a.x === 2 && a.y === 3);
+ r = ++a;
+ assert(a.x === 3 && a.y === 4);
+ assert(r === a);
+}
+
+function test_default_op()
+{
+ assert(Object(1) + 2, 3);
+ assert(Object(1) + true, 2);
+ assert(-Object(1), -1);
+}
+
+test_operators_create();
+test_operators();
+test_default_op();
r = (1 << 31) < 0;
assert(r, false, "(1 << 31) < 0 === false");
+
+ assert(typeof 1 === "number");
+ assert(typeof 9007199254740991 === "number");
+ assert(typeof 9007199254740992 === "bigint");
}
function test_float()
{
- var e, a, b, sqrt2;
-
- assert(typeof 1 === "bigint");
assert(typeof 1.0 === "bigfloat");
assert(1 == 1.0);
assert(1 !== 1.0);
assert(a == [ 2,2,2,11,13,13,1009,618970019642690137449562111 ]);
}
+function test_fraction()
+{
+ assert((1/3 + 1).toString(), "4/3")
+ assert((2/3)^30, 1073741824/205891132094649);
+ assert(1/3 < 2/3);
+ assert(1/3 < 1);
+ assert(1/3 == 1.0/3);
+ assert(1.0/3 < 2/3);
+}
+
function test_mod()
{
var a, b, p;
test_float();
test_modulo();
+test_fraction();
test_mod();
test_polynomial();
test_poly_mod();
projects / quickjs.git / commitdiff