@itwin/core-orbitgt 3.0.0-dev.77 → 3.0.0-dev.81

package/lib/esm/system/runtime/ALong.js

@@ -0,0 +1,684 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module OrbitGT
+ */
+import { ASystem } from "./ASystem";
+import { Numbers } from "./Numbers";
+import { Strings } from "./Strings";
+/**
+ * Class ALong defines a signed 64-bit integer using two (high and low) 64-bit floats.
+ *
+ * @version 1.0 February 2019
+ */
+/** @internal */
+export class ALong {
+    /**
+     * Create a new value.
+     * @param high the 32-bit high part.
+     * @param low the 32-bit low part.
+     */
+    constructor(high, low) {
+        this._high = high;
+        this._low = low;
+    }
+    /**
+     * Check if the number is zero.
+     * @return true if zero.
+     */
+    isZero() {
+        return (this._high == 0.0) && (this._low == 0.0);
+    }
+    /**
+     * Check if the number is not zero.
+     * @return true if zero.
+     */
+    isNonZero() {
+        return (this.isZero() == false);
+    }
+    /**
+     * Check if the number is one.
+     * @return true if one.
+     */
+    isOne() {
+        return (this._high == 0.0) && (this._low == 1.0);
+    }
+    /**
+     * Check if the number is positive.
+     * @return true if positive (false if zero).
+     */
+    isPositive() {
+        return this.isZero() ? false : (this._high < ALong._U31);
+    }
+    /**
+     * Check if the number is negative.
+     * @return true if negative (false if zero).
+     */
+    isNegative() {
+        return this.isZero() ? false : (this._high >= ALong._U31);
+    }
+    /**
+     * Normalize the number.
+     * @return this number for chaining operations.
+     */
+    static normalize2(high, low) {
+        // normalize the low part
+        let overflowLow = Numbers.floor(low / ALong._U32);
+        low = (low - overflowLow * ALong._U32); // inside range [0..U32[
+        high += overflowLow;
+        // normalize the high part
+        let overflowHigh = Numbers.floor(high / ALong._U32);
+        high = (high - overflowHigh * ALong._U32); // inside range [0..U32[
+        // return the result
+        return new ALong(high, low);
+    }
+    /**
+     * Negate the number.
+     * @return the result.
+     */
+    negate() {
+        /* Zero? */
+        if (this.isZero()) {
+            /* Return this immutable instance */
+            return this;
+        }
+        /* Compute */
+        let resultHigh = (ALong._U32 - 1.0 - this._high);
+        let resultLow = (ALong._U32 - this._low);
+        /* Overflow? */
+        if (resultLow == ALong._U32) {
+            resultLow = 0.0;
+            resultHigh += 1.0; // in case we try to invert ALong.MIN_VALUE we get ALong.MIN_VALUE as a result again
+        }
+        /* Return the result */
+        return new ALong(resultHigh, resultLow);
+    }
+    /**
+     * Add a number.
+     * @param value the value to add.
+     * @return the result.
+     */
+    add(value) {
+        /* Compute */
+        let resultHigh = (this._high + value._high);
+        let resultLow = (this._low + value._low);
+        /* Return the result */
+        return ALong.normalize2(resultHigh, resultLow);
+    }
+    /**
+     * Add a number.
+     * @param value the value to add.
+     * @return the result.
+     */
+    addInt(value) {
+        return this.add(ALong.fromInt(value));
+    }
+    /**
+     * Increase by one.
+     * @return the result.
+     */
+    increase() {
+        return this.addInt(1);
+    }
+    /**
+     * Subtract a number.
+     * @param value the value to subtract.
+     * @return the result.
+     */
+    sub(value) {
+        return this.add(value.negate());
+    }
+    /**
+     * Subtract a number.
+     * @param value the value to subtract.
+     * @return the result.
+     */
+    subInt(value) {
+        return this.sub(ALong.fromInt(value));
+    }
+    /**
+     * Decrease by one.
+     * @return the result.
+     */
+    decrease() {
+        return this.subInt(1);
+    }
+    /**
+     * Multiply two unsigned 32-bit integer values.
+     * @param v1 the first value.
+     * @param v2 the second value.
+     * @param high0 the initial high value of the result.
+     * @return the unsigned 64-bit product.
+     */
+    static mul2(v1, v2) {
+        /* Zero? */
+        if (v1.isZero())
+            return v1;
+        if (v2.isZero())
+            return v2;
+        /* Make the values unsigned */
+        let neg1 = v1.isNegative() ? 1 : 0;
+        if (neg1 == 1)
+            v1 = v1.negate();
+        let neg2 = v2.isNegative() ? 1 : 0;
+        if (neg2 == 1)
+            v2 = v2.negate();
+        /* Split first low into 16-bit parts */
+        let a1 = Numbers.floor(v1._low / ALong._U16);
+        ;
+        let a2 = (v1._low - a1 * ALong._U16);
+        /* Split second low into 16-bit parts */
+        let b1 = Numbers.floor(v2._low / ALong._U16);
+        ;
+        let b2 = (v2._low - b1 * ALong._U16);
+        /* Compute */
+        let resultHigh = (v1._high * v2._low + v1._low * v2._high) + (a1 * b1);
+        let resultLow = (a1 * b2 + a2 * b1) * ALong._U16 + (a2 * b2);
+        let result = ALong.normalize2(resultHigh, resultLow);
+        /* Return the result */
+        return (neg1 + neg2 == 1) ? result.negate() : result;
+    }
+    /**
+     * Multiply by a number.
+     * @param value the value to multiply.
+     * @return the result.
+     */
+    mul(value) {
+        return ALong.mul2(this, value);
+    }
+    /**
+     * Multiply by a number.
+     * @param value the value to multiply.
+     * @return the result.
+     */
+    mulInt(value) {
+        return this.mul(ALong.fromInt(value));
+    }
+    /**
+     * Divide by a number.
+     * @param value the value to divide by.
+     * @return the result.
+     */
+    div(value) {
+        /* Division by zero? */
+        ASystem.assertNot(value.isZero(), "ALong division by ALong zero");
+        /* Division by one? */
+        if (value.isOne())
+            return this;
+        /* Make the values unsigned */
+        let currentValue = this;
+        let neg1 = currentValue.isNegative();
+        if (neg1)
+            currentValue = currentValue.negate();
+        let value2 = value;
+        let neg2 = value2.isNegative();
+        if (neg2)
+            value2.negate();
+        let neg = (neg1 && !neg2) || (!neg1 && neg2);
+        /* Loop until the remainder is smaller than the value */
+        let result = ALong.ZERO;
+        while (currentValue.isLargerThanOrEqualTo(value2)) {
+            /* Shift the value as much as possible */
+            let test = value2;
+            let times = ALong.ONE;
+            if (test.isSmallerThan(currentValue)) {
+                while (test.isSmallerThan(currentValue)) {
+                    test = test.mulInt(2);
+                    times = times.mulInt(2);
+                }
+                test = test.divInt(2);
+                times = times.divInt(2);
+            }
+            /* Subtract the shifted value */
+            currentValue = currentValue.sub(test);
+            result = result.add(times);
+        }
+        /* Return the result */
+        return (neg) ? result.negate() : result;
+    }
+    /**
+     * Divide by a number.
+     * @param value the value to divide by.
+     * @return the result.
+     */
+    divInt(value) {
+        /* Division by zero? */
+        ASystem.assertNot(value == 0, "ALong division by int zero");
+        /* Division by one? */
+        if (value == 1)
+            return this;
+        /* Make the values unsigned */
+        let value1 = this;
+        let neg1 = value1.isNegative();
+        if (neg1)
+            value1 = value1.negate();
+        let neg2 = (value < 0);
+        if (neg2)
+            value = -1 * value;
+        let neg = (neg1 && !neg2) || (!neg1 && neg2);
+        /* Compute */
+        let valueF = (0.0 + value);
+        let h1 = Numbers.floor(value1._high / valueF);
+        let h2 = (value1._high - valueF * h1);
+        let l1 = Numbers.floor(value1._low / valueF);
+        let l2 = (value1._low - valueF * l1);
+        let t = (h2 * ALong._U32 + l2);
+        let t1 = Numbers.floor(t / valueF);
+        let t2 = (t - valueF * t1); // remainder
+        let result = ALong.normalize2(h1, l1 + t1);
+        /* Return the result */
+        return (neg) ? result.negate() : result;
+    }
+    /**
+     * Modulate by a number.
+     * @param value the value to modulate by.
+     * @return the result.
+     */
+    mod(value) {
+        /* Division by zero? */
+        ASystem.assertNot(value.isZero(), "ALong modulo by ALong zero");
+        /* Division by one? */
+        if (value.isOne())
+            return ALong.ZERO;
+        /* Compute */
+        let result = this.sub(this.div(value).mul(value));
+        /* Return the result */
+        return result;
+    }
+    /**
+     * Modulate by a number.
+     * @param value the value to modulate by.
+     * @return the modulo value.
+     */
+    modInt(value) {
+        /* Division by zero? */
+        ASystem.assertNot(value == 0, "ALong modulo by int zero");
+        /* Division by one? */
+        if (value == 1)
+            return 0;
+        /* Make the values unsigned */
+        let value1 = this;
+        let neg1 = value1.isNegative();
+        if (neg1)
+            value1 = value1.negate();
+        let neg2 = (value < 0);
+        if (neg2)
+            value = -1 * value;
+        let neg = (neg1 && !neg2) || (!neg1 && neg2);
+        /* Compute */
+        let valueF = (0.0 + value);
+        let h1 = Numbers.floor(value1._high / valueF);
+        let h2 = (value1._high - valueF * h1);
+        let l1 = Numbers.floor(value1._low / valueF);
+        let l2 = (value1._low - valueF * l1);
+        let t = (h2 * ALong._U32 + l2);
+        let t1 = Numbers.floor(t / valueF);
+        let t2 = (t - valueF * t1); // remainder
+        let result = Math.trunc(t2);
+        /* Return the result */
+        return result;
+    }
+    /**
+     * Create a new number.
+     * @param value the 64-bit float value.
+     * @return the new number.
+     */
+    static fromDouble(value) {
+        /* Make the value unsigned */
+        let neg = (value < 0.0);
+        if (neg)
+            value = (-1.0 * value);
+        /* Compute */
+        value = Numbers.floor(value);
+        let high = Numbers.floor(value / ALong._U32);
+        let low = (value - high * ALong._U32);
+        let result = ALong.normalize2(high, low);
+        /* Return the result */
+        return (neg) ? result.negate() : result;
+    }
+    /**
+     * Get a double.
+     * @return the double value.
+     */
+    toDouble() {
+        /* Make the value unsigned */
+        let value = this;
+        let neg = value.isNegative();
+        if (neg)
+            value = value.negate();
+        /* Compute */
+        let result = (value._high * ALong._U32) + value._low;
+        if (neg)
+            result *= -1.0;
+        /* Return the result */
+        return result;
+    }
+    /**
+     * Create a new number.
+     * @param value the 32-bit integer value.
+     * @return the new number.
+     */
+    static fromInt(value) {
+        return (value < 0.0) ? new ALong(ALong._U32 - 1.0, ALong._U32 + value) : new ALong(0.0, value);
+    }
+    /**
+     * Get a 32-bit integer.
+     * @return the integer value.
+     */
+    toInt() {
+        /* Make the value unsigned */
+        let value = this;
+        let neg = value.isNegative();
+        if (neg)
+            value = value.negate();
+        /* Compute */
+        let result = value._low;
+        if (neg)
+            result *= -1.0;
+        /* Return the result */
+        return Numbers.doubleToInt(result);
+    }
+    /**
+     * Create a new number.
+     * @param i1 the 32-bit high part.
+     * @param i0 the 32-bit low part.
+     * @return the new number.
+     */
+    static fromHighLow(i1, i0) {
+        if (i1 < 0.0)
+            i1 += ALong._U32; // make unsigned
+        if (i0 < 0.0)
+            i0 += ALong._U32;
+        return new ALong(i1, i0);
+    }
+    /**
+     * Get the high part.
+     * @return the integer value (0..4294967295)
+     */
+    getHigh() {
+        return this._high;
+    }
+    /**
+     * Get the low part.
+     * @return the integer value (0..4294967295)
+     */
+    getLow() {
+        return this._low;
+    }
+    /**
+     * Create a new number.
+     * @param b7 the most significant 8-bit byte of the high part (0..255).
+     * @param b6 the most third 8-bit byte of the high part (0..255).
+     * @param b5 the most second 8-bit byte of the high part (0..255).
+     * @param b4 the most least 8-bit byte of the high part (0..255).
+     * @param b3 the most significant 8-bit byte of the low part (0..255).
+     * @param b2 the most third 8-bit byte of the low part (0..255).
+     * @param b1 the most second 8-bit byte of the low part (0..255).
+     * @param b0 the most least 8-bit byte of the low part (0..255).
+     * @return the new number.
+     */
+    static fromBytes(b7, b6, b5, b4, b3, b2, b1, b0) {
+        if (b7 < 0.0)
+            b7 += ALong._U8; // make unsigned
+        if (b6 < 0.0)
+            b6 += ALong._U8;
+        if (b5 < 0.0)
+            b5 += ALong._U8;
+        if (b4 < 0.0)
+            b4 += ALong._U8;
+        if (b3 < 0.0)
+            b3 += ALong._U8;
+        if (b2 < 0.0)
+            b2 += ALong._U8;
+        if (b1 < 0.0)
+            b1 += ALong._U8;
+        if (b0 < 0.0)
+            b0 += ALong._U8;
+        let high = (b7 * ALong._U24 + b6 * ALong._U16 + b5 * ALong._U8 + b4);
+        let low = (b3 * ALong._U24 + b2 * ALong._U16 + b1 * ALong._U8 + b0);
+        return ALong.fromHighLow(high, low);
+    }
+    /**
+     * Get a byte.
+     * @param index the index of the byte (0..7 where 0 is low).
+     * @return the byte value (0..255)
+     */
+    getByte(index) {
+        let value = (index < 4) ? this._low : this._high; // this should be unsigned
+        let position = (index < 4) ? index : (index - 4);
+        for (let i = 0; i < position; i++)
+            value = Numbers.floor(value / 256.0);
+        return Math.trunc(value % 256);
+    }
+    /**
+     * Check if a number is equal.
+     * @param value the value to check.
+     * @return true if equal.
+     */
+    isEqualTo(value) {
+        return (value._high == this._high) && (value._low == this._low);
+    }
+    /**
+     * Check if a number is not equal.
+     * @param value the value to check.
+     * @return true if equal.
+     */
+    isNotEqualTo(value) {
+        return (this.isEqualTo(value) == false);
+    }
+    /**
+     * Check if a number is equal.
+     * @param value the value to check.
+     * @return true if equal.
+     */
+    same(value) {
+        return this.isEqualTo(value);
+    }
+    /**
+     * Check if a number is equal.
+     * @param value the value to check.
+     * @return true if equal.
+     */
+    equals(value) {
+        return this.isEqualTo(value);
+    }
+    /**
+     * Compare this long to another long.
+     * @param value the other long.
+     * @return zero if equal, positive if smaller, or negative if value is larger.
+     */
+    compareTo(value) {
+        let diff = this.sub(value);
+        if (diff.isZero())
+            return 0;
+        return diff.isNegative() ? -1 : 1;
+    }
+    /**
+     * Check if a value is larger.
+     * @param value the value to check.
+     * @return true if this number is larger than the check value.
+     */
+    isLargerThan(value) {
+        return (this.compareTo(value) > 0);
+    }
+    /**
+     * Check if a value is larger.
+     * @param value the value to check.
+     * @return true if this number is larger than the check value.
+     */
+    isLargerThanOrEqualTo(value) {
+        return (this.compareTo(value) >= 0);
+    }
+    /**
+     * Check if a value is smaller.
+     * @param value the value to check.
+     * @return true if this number is smaller than the check value.
+     */
+    isSmallerThan(value) {
+        return (this.compareTo(value) < 0);
+    }
+    /**
+     * Check if a value is smaller.
+     * @param value the value to check.
+     * @return true if this number is smaller than the check value.
+     */
+    isSmallerThanOrEqualTo(value) {
+        return (this.compareTo(value) <= 0);
+    }
+    /**
+     * Get the maximum value.
+     * @param v1 the first value.
+     * @param v2 the second value.
+     * @return the maximum value.
+     */
+    static max(v1, v2) {
+        return (v2.isLargerThan(v1)) ? v2 : v1;
+    }
+    /**
+     * Get the minimum value.
+     * @param v1 the first value.
+     * @param v2 the second value.
+     * @return the minimum value.
+     */
+    static min(v1, v2) {
+        return (v2.isSmallerThan(v1)) ? v2 : v1;
+    }
+    /**
+     * Create a number from a string.
+     * @param svalue the string value.
+     * @param radix the radix (2 to 36).
+     * @return the number.
+     */
+    static fromRadixString(svalue, radix) {
+        /* Check the radix */
+        ASystem.assertNot((radix < 2) || (radix > 36), "Invalid radix: " + radix);
+        /* Common values? */
+        if (Strings.equals(svalue, "0"))
+            return ALong.ZERO;
+        if (Strings.equals(svalue, "1"))
+            return ALong.ONE;
+        /* Negative? */
+        let neg = Strings.startsWith(svalue, "-");
+        if (neg)
+            svalue = Strings.substringFrom(svalue, 1);
+        /* Add all digits */
+        let result = ALong.ZERO;
+        let unit = ALong.ONE;
+        let radixHL = ALong.fromInt(radix);
+        let slength = Strings.getLength(svalue);
+        for (let i = 0; i < slength; i++) {
+            /* Add the next digit */
+            let charCode = Strings.charCodeAt(svalue, slength - 1 - i);
+            let digit = (charCode >= 65) ? (charCode - 65 + 10) : (charCode - 48);
+            if (digit > 0)
+                result = result.add(unit.mulInt(digit));
+            unit = unit.mul(radixHL);
+        }
+        /* Return the result */
+        return (neg) ? result.negate() : result;
+    }
+    /**
+     * Create a number from a decimal string.
+     * @param value the string value.
+     * @return the number.
+     */
+    static fromString(value) {
+        if (value == null)
+            return null;
+        return ALong.fromRadixString(value, 10);
+    }
+    /**
+     * Create a number from a hexadecimal string.
+     * @param value the string value.
+     * @return the number.
+     */
+    static fromHexString(value) {
+        if (value == null)
+            return null;
+        return ALong.fromRadixString(value, 16);
+    }
+    /**
+     * Convert the number to a string.
+     * @param radix the radix (2 to 36).
+     * @return the string.
+     */
+    getRadixString(radix) {
+        /* Check the radix */
+        ASystem.assertNot((radix < 2) || (radix > 36), "Invalid radix: " + radix);
+        /* Common values? */
+        let value = this;
+        if (value.isZero())
+            return "0";
+        /* Make the value unsigned */
+        let neg = value.isNegative();
+        if (neg)
+            value = value.negate();
+        /* Add all digits */
+        let result = "";
+        while (true) {
+            /* Add the next digit */
+            if (value.isZero())
+                break;
+            let digit = value.modInt(radix);
+            value = value.divInt(radix);
+            let sdigit = (digit < 10) ? Strings.charCodeToString(48 + digit) : Strings.charCodeToString(65 + digit - 10);
+            result = (sdigit + result);
+            /* Fail? */
+            ASystem.assertNot(Strings.getLength(result) > 20, "Failed to convert longHL to string (radix " + radix + "): " + this._high + ";" + this._low);
+        }
+        if (neg)
+            result = ("-" + result);
+        /* Return the result */
+        return result;
+    }
+    /**
+     * Convert the number to a decimal string.
+     * @return the string.
+     */
+    getString() {
+        return this.getRadixString(10);
+    }
+    /**
+     * Convert the number to a hexadecimal string.
+     * @return the string.
+     */
+    getHexString() {
+        return this.getRadixString(16);
+    }
+    /**
+     * The standard toString method.
+     * @see Object#toString
+     */
+    toString() {
+        return this.getString();
+    }
+}
+/** The value of a 32 bit unit */
+ALong._U32 = 4294967296.0;
+/** The value of a 31 bit unit */
+ALong._U31 = 2147483648.0;
+/** The value of a 24 bit unit */
+ALong._U24 = 16777216.0;
+/** The value of a 16 bit unit */
+ALong._U16 = 65536.0;
+/** The value of a 8 bit unit */
+ALong._U8 = 256.0;
+/** The integer value 0 */
+ALong.ZERO = new ALong(0.0, 0.0);
+/** The integer value 1 */
+ALong.ONE = new ALong(0.0, 1.0);
+/** The integer value 2 */
+ALong.TWO = new ALong(0.0, 2.0);
+/** The integer value 4 */
+ALong.FOUR = new ALong(0.0, 4.0);
+/** The integer value 10 */
+ALong.TEN = new ALong(0.0, 10.0);
+/** The integer value -1 */
+ALong.MINUS_ONE = new ALong(ALong._U32 - 1.0, ALong._U32 - 1.0);
+/** The maximum positive value of a signed_ 64-bit integer (9223372036854775807) */
+ALong.MAX_VALUE = new ALong(ALong._U31 - 1.0, ALong._U32 - 1.0);
+/** The minimum negative value of a signed 64-bit integer (-9223372036854775808) */
+ALong.MIN_VALUE = new ALong(ALong._U31, 0.0);
+//# sourceMappingURL=ALong.js.map