Retro/pcjs
Watch
1
0
Fork
You've already forked pcjs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Trying a second approach to the Int36 class that sticks to unsigned numbers internally (only downside so far is that the detecting arithmetic overflow/underflow is more work and hasn't been implemented yet)

Browse source
This commit is contained in:
Jeff Parsons 2017-02-15 16:16:32 -08:00 • committed by Jeff Parsons
commit 6bc0d8ac49
3 changed files with 713 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

154
modules/shared/lib/int36.js
View file

@ -1,5 +1,5 @@
/**
* @fileoverview Support for 36-bit integers
* @fileoverview Support for 36-bit integers (using unsigned JavaScript numbers)
* @author <a href="mailto:Jeff@pcjs.org">Jeff Parsons</a> (@jeffpar)
* @copyright © Jeff Parsons 2012-2017
*
@ -37,11 +37,8 @@ var DEBUG = true;
* @property {number|null} remainder
* @property {number} error
*
* The 'value' property stores the 36-bit value as a signed integer, meaning if the sign bit
* (bit 35) is set, we store the corresponding negative (two's complement) value. While there
* might be some slight benefits to always storing the 36-bit value as an unsigned quantity
* and negating it "on demand", I like having JavaScript's native representation match the
* emulated value.
* The 'value' property stores the 36-bit value as an unsigned integer. When the value
* should be interpreted as a signed quantity, subtract BIT36 whenever value > MAXSIGNED.
*
* The 'extended' property stores an additional 36 bits of data from a multiplication;
* it must also be set prior to a division. Internally, it will be set to null whenever the
@ -60,15 +57,16 @@ class Int36 {
* The constructor, which simply calls set(), creates an Int36 from either:
*
* 1) another Int36
* 2) a single (signed) 36-bit value, with an optional 36-bit extension
* 2) a single 36-bit value, with an optional 36-bit extension
* 3) nothing (initial value will be zero)
*
* We guarantee that an Int36 value will be (and will always remain) a signed value within this range:
* We guarantee that an Int36 value will be (and always remain) an unsigned value within this range:
*
* -Math.pow(2, 35) <= i <= Math.pow(2, 35) - 1
* 0 <= i <= Math.pow(2, 36) - 1
*
* Those lower and upper bounds are defined as Int36.MINVAL and Int36.MAXVAL. The sign of an Int36
* value is determined by (and should always match) its highest bit (bit 35).
* The lower bound is ZERO and the upper bound is Int36.MAXVAL. Whenever an Int36 value should be
* interpreted as a signed value, call isNegative() to check the sign bit (bit 35) and call negate()
* as appropriate.
*
* NOTE: We use modern bit numbering, where bit 0 is the right-most (least-significant) bit and
* bit 35 is the left-most bit. This is opposite of the PDP-10 convention, which defined bit 0 as the
@ -78,7 +76,7 @@ class Int36 {
*
* -Math.pow(2, 53) <= i <= Math.pow(2, 53)
*
* it seems unwise to ever permit the internal value to creep outside the signed 36-bit range, because
* it seems unwise to ever permit the internal value to creep outside the 36-bit range, because
* floating-point operations will drop least-significant bits in favor of most-significant bits when a
* result becomes too large, which is the opposite of what integer operations traditionally do. There
* might be some optimization benefits to performing our internal 36-bit truncation "lazily", but at
@ -134,17 +132,18 @@ class Int36 {
}
/**
* toDecimal()
* toDecimal(fUnsigned)
*
* @this {Int36}
* @param {boolean} fUnsigned
* @return {string}
*/
toDecimal()
toDecimal(fUnsigned)
{
var s = "", fNeg = false;
var i36Div = new Int36(10000000000);
var i36Tmp = new Int36(this.value, this.extended);
if (i36Tmp.isNegative()) {
if (!fUnsigned && i36Tmp.isNegative()) {
i36Tmp.negate();
fNeg = true;
}
@ -172,6 +171,10 @@ class Int36 {
*/
toString(radix = 10, fUnsigned)
{
if (radix == 10) {
return this.toDecimal(fUnsigned);
}
var value = this.value;
var extended = this.extended;
@ -187,23 +190,13 @@ class Int36 {
return s;
}
if (radix != 10) {
fUnsigned = true;
} else {
return this.toDecimal();
}
if (fUnsigned || extended) {
if (value < 0) value += Int36.BIT36;
if (extended != null) {
if (fUnsigned) extended += Int36.BIT36;
/*
* TODO: Need a radix-independent solution for these extended (up to 72-bit) values,
* because after 52 bits, JavaScript will start dropping least-significant bits. Until
* then, you're better off sticking with octal (see above).
*/
value = extended * Int36.BIT36 + value;
}
if (extended != null) {
/*
* TODO: Need a radix-independent solution for these extended (up to 72-bit) values,
* because after 52 bits, JavaScript will start dropping least-significant bits. Until
* then, you're better off sticking with octal (see above).
*/
value = extended * Int36.BIT36 + value;
}
return value.toString(radix);
}
@ -227,15 +220,11 @@ class Int36 {
this.extended = null;
this.remainder = null;
this.error = Int36.ERROR.NONE;
if (result > Int36.MAXVAL) {
result %= Int36.BIT36;
if (result > Int36.MAXVAL) result -= Int36.BIT36;
this.error |= Int36.ERROR.OVERFLOW;
} else if (result < Int36.MINVAL) {
result %= Int36.BIT36;
if (result < Int36.MINVAL) result += Int36.BIT36;
this.error |= Int36.ERROR.UNDERFLOW;
if (result < 0) {
result += Int36.BIT36;
}
result %= Int36.BIT36;
return result;
}
@ -321,13 +310,13 @@ class Int36 {
var fNeg = false, extended;
var n1 = this.value, n2 = value;
if (n1 < 0) {
if (n1) n1 = -n1;
if (n1 > Int36.MAXSIGNED) {
n1 = Int36.BIT36 - n1;
fNeg = !fNeg;
}
if (n2 < 0) {
if (n2) n2 = -n2;
if (n2 > Int36.MAXSIGNED) {
n2 = Int36.BIT36 - n2;
fNeg = !fNeg;
}
@ -352,7 +341,9 @@ class Int36 {
this.value = this.truncate(value);
this.extended = this.truncate(extended);
if (fNeg) this.negate();
if (fNeg) {
this.negate();
}
}
/**
@ -398,8 +389,8 @@ class Int36 {
*/
var bNegLo = 0, bNegHi = 0;
if (divisor < 0 && divisor > Int36.MINVAL) {
divisor = -divisor;
if (divisor > Int36.MAXSIGNED) {
divisor = Int36.BIT36 - divisor;
bNegLo = 1 - bNegLo;
}
@ -411,10 +402,6 @@ class Int36 {
var value = this.value;
var extended = this.extended || 0;
if (value < 0) {
value += Int36.BIT36;
}
if (!divisor) {
this.error |= Int36.ERROR.DIVZERO;
}
@ -448,11 +435,11 @@ class Int36 {
this.extended = null;
this.remainder = bitsRem[0];
if (bNegLo && this.value && this.value > Int36.MINVAL) {
this.value = -this.value;
if (bNegLo && this.value && this.value > Int36.MINSIGNED) {
this.value = Int36.BIT36 - this.value;
}
if (bNegHi && this.remainder && this.remainder > Int36.MINVAL) {
this.remainder = -this.remainder;
if (bNegHi && this.remainder && this.remainder > Int36.MINSIGNED) {
this.remainder = Int36.BIT36 - this.remainder;
}
}
return this.value;
@ -465,60 +452,37 @@ class Int36 {
*/
isNegative()
{
return (this.extended < 0 || this.extended == null && this.value < 0);
return (this.extended > Int36.MAXSIGNED || this.extended == null && this.value > Int36.MAXSIGNED);
}
/**
* negate()
*
* Converts the current value to its two's complement. If we were dealing with 8-bit values:
*
* Original Two's One's
* ------- ----- -----
* -128 -128 127
* -127 127 126
* ... ... ...
* -1 1 0
* 0 0 -1
* 1 -1 -2
* ... ... ...
* 126 -126 -127
* 127 -127 -128
*
* you can see that, when performing two's complement, MINVAL and ZERO are not modified.
*
* However, in our happy little world, since JavaScript numbers CAN represent both positive and negative
* MINVAL values, we don't need to exclude MINVAL from the conversion.
*/
negate()
{
this.error = Int36.ERROR.NONE;
/*
* Perform two's complement on the value.
*/
if (this.value /* && this.value > Int36.MINVAL */) {
this.value = -this.value;
}
if (this.extended == null) {
/*
* Set extended to match the sign of the value.
* Set extended to match the sign of the (negated) value.
*/
this.extended = (this.value < 0? -1 : 0);
this.extended = (this.value > Int36.MAXSIGNED? 0 : Int36.MAXVAL);
}
else if (this.value) {
/*
* Perform one's complement on the extended value.
*/
this.extended = -this.extended - 1;
this.extended = Int36.MAXVAL - this.extended;
}
else {
/*
* Perform two's complement on the extended value.
*/
if (this.extended /* && this.extended > Int36.MINVAL */) {
this.extended = -this.extended;
}
if (this.extended) this.extended = Int36.BIT36 - this.extended;
}
/*
* Perform two's complement on the value.
*/
if (this.value) this.value = Int36.BIT36 - this.value;
this.error = Int36.ERROR.NONE;
}
/**
@ -624,12 +588,10 @@ class Int36 {
*/
static validate(num)
{
var value = Math.trunc(num) % Int36.BIT36;
if (value > Int36.MAXVAL) {
value -= Int36.BIT36;
} else if (value < Int36.MINVAL) {
value += Int36.BIT36;
if (num < 0 && num >= Int36.MINSIGNED) {
num += Int36.BIT36;
}
var value = Math.trunc(Math.abs(num)) % Int36.BIT36;
if (DEBUG && num !== value) {
console.log("Int36.validate(" + num + " out of range, truncated to " + value + ")");
}
@ -647,7 +609,9 @@ Int36.ERROR = {
Int36.BIT18 = Math.pow(2, 18); // 262,144
Int36.BIT36 = Math.pow(2, 36); // 68,719,476,736
Int36.MAXVAL = Math.pow(2, 35) - 1; // 34,359,738,367
Int36.MINVAL = -Math.pow(2, 35); // -34,359,738,368
Int36.MAXSIGNED = Math.pow(2, 35) - 1; // 34,359,738,367
Int36.MINSIGNED = -Math.pow(2, 35); // -34,359,738,368
Int36.MAXVAL = Math.pow(2, 36) - 1; // 68,719,476,735
if (NODE) module.exports = Int36;