toilscript 0.1.4 → 0.1.6

package/std/assembly/bignum/integer/u128.ts

@@ -0,0 +1,963 @@
+import { i128 } from './i128';
+import { i256 } from './i256';
+import { u256 } from './u256';
+
+// TODO import this on top level 'index.ts'
+import {
+  __clz128,
+  __ctz128,
+  __divmod_quot_hi,
+  __divmod_rem_hi,
+  __divmod_rem_lo,
+  __floatuntidf,
+  __multi3,
+  __res128_hi,
+  __udivmod128,
+  __udivmod128_10,
+} from '../globals';
+
+import { atou128, u128toDecimalString } from '../utils';
+
+@lazy const HEX_CHARS = '0123456789abcdef';
+
+export class u128 {
+  // CACHE: Static instances to avoid allocation
+  private static readonly _ZERO: u128 = new u128(0, 0);
+  private static readonly _ONE: u128 = new u128(1, 0);
+  private static readonly _MAX: u128 = new u128(-1, -1);
+
+  /**
+   * Create 128-bit unsigned integer from 64-bit parts
+   * @param lo low  64-bit part of 128-bit unsigned integer
+   * @param hi high 64-bit part of 128-bit unsigned integer
+   */
+  constructor(
+    public lo: u64 = 0,
+    public hi: u64 = 0,
+  ) {
+  }
+
+  @inline static get immutableZero(): u128 {
+    return u128._ZERO;
+  }
+
+  @inline static get immutableOne(): u128 {
+    return u128._ONE;
+  }
+
+  @inline static get immutableMin(): u128 {
+    return u128._ZERO;
+  }
+
+  @inline static get immutableMax(): u128 {
+    return u128._MAX;
+  }
+
+  @inline static get Zero(): u128 { return new u128(0, 0); }
+  @inline static get One(): u128 { return new u128(1, 0); }
+  @inline static get Min(): u128 { return new u128(0, 0); }
+  @inline static get Max(): u128 { return new u128(-1, -1); }
+
+  /**
+   * Ensures the current instance is not a static constant.
+   * If it is, throws an error.
+   * Cost: 3 integer comparisons. Cheap insurance.
+   */
+  @inline
+  private checkMutable(): void {
+    const ptr = changetype<usize>(this);
+    if (ptr == changetype<usize>(u128._ZERO) ||
+      ptr == changetype<usize>(u128._ONE) ||
+      ptr == changetype<usize>(u128._MAX)) {
+      throw new Error("u128: Immutable constant");
+    }
+  }
+
+  @inline
+  static fromString(value: string, radix: i32 = 10): u128 {
+    return atou128(value, radix);
+  }
+
+  @inline
+  static fromI256(value: i256): u128 {
+    return new u128(value.lo1, value.lo2);
+  }
+
+  @inline
+  static fromU256(value: u256): u128 {
+    return new u128(value.lo1, value.lo2);
+  }
+
+  @inline
+  static fromI128(value: i128): u128 {
+    return new u128(value.lo, value.hi);
+  }
+
+  @inline
+  static fromU128(value: u128): u128 {
+    return new u128(value.lo, value.hi);
+  }
+
+  @inline
+  static fromI64(value: i64): u128 {
+    if (value == 0) return u128.Zero;
+    if (value == 1) return u128.One;
+    return new u128(value, value >> 63);
+  }
+
+  @inline
+  static fromU64(value: u64): u128 {
+    if (value == 0) return u128.Zero;
+    if (value == 1) return u128.One;
+    return new u128(value);
+  }
+
+  // max safe uint for f64 actually 53-bits
+  @inline
+  static fromF64(value: f64): u128 {
+    return new u128(<u64>value, reinterpret<i64>(value) >> 63);
+  }
+
+  // max safe int for f32 actually 23-bits
+  @inline
+  static fromF32(value: f32): u128 {
+    return new u128(<u64>value, <u64>(reinterpret<i32>(value) >> 31));
+  }
+
+  @inline
+  static fromI32(value: i32): u128 {
+    if (value == 0) return u128.Zero;
+    if (value == 1) return u128.One;
+    return new u128(value, value >> 31);
+  }
+
+  @inline
+  static fromU32(value: u32): u128 {
+    if (value == 0) return u128.Zero;
+    if (value == 1) return u128.One;
+    return new u128(value);
+  }
+
+  @inline
+  static fromBool(value: bool): u128 {
+    return value ? u128.One : u128.Zero;
+  }
+
+  @inline
+  static fromBits(lo1: u32, lo2: u32, hi1: u32, hi2: u32): u128 {
+    return new u128(
+      <u64>lo1 | ((<u64>lo2) << 32),
+      <u64>hi1 | ((<u64>hi2) << 32),
+    );
+  }
+
+  @inline
+  static fromBytes<T>(array: T, bigEndian: bool = false): u128 {
+    // @ts-ignore
+    if (array instanceof u8[]) {
+      return bigEndian
+        // @ts-ignore
+        ? u128.fromBytesBE(<u8[]>array)
+        // @ts-ignore
+        : u128.fromBytesLE(<u8[]>array);
+    } else if (array instanceof Uint8Array) {
+      return bigEndian
+        ? u128.fromUint8ArrayBE(<Uint8Array>array)
+        : u128.fromUint8ArrayLE(<Uint8Array>array);
+    } else {
+      throw new TypeError("Unsupported generic type");
+    }
+  }
+
+  @inline
+  static fromBytesLE(array: u8[]): u128 {
+    if (array.length !== 16) throw new Error("Invalid length");
+    let buffer = array.dataStart;
+    return new u128(
+      load<u64>(buffer, 0),
+      load<u64>(buffer, 8)
+    );
+  }
+
+  @inline
+  static fromBytesBE(array: u8[]): u128 {
+    if (array.length !== 16) throw new Error("Invalid length");
+    let buffer = array.dataStart;
+    return new u128(
+      bswap<u64>(load<u64>(buffer, 8)),
+      bswap<u64>(load<u64>(buffer, 0))
+    );
+  }
+
+  @inline
+  static fromUint8ArrayLE(array: Uint8Array): u128 {
+    if (array.length !== 16) throw new Error("Invalid length");
+    let buffer = array.dataStart;
+    return new u128(
+      load<u64>(buffer, 0),
+      load<u64>(buffer, 8)
+    );
+  }
+
+  @inline
+  static fromUint8ArrayBE(array: Uint8Array): u128 {
+    if (array.length !== 16) throw new Error("Invalid length");
+    let buffer = array.dataStart;
+    return new u128(
+      bswap<u64>(load<u64>(buffer, 8)),
+      bswap<u64>(load<u64>(buffer, 0))
+    );
+  }
+
+  /**
+   * Create 128-bit unsigned integer from generic type T
+   * @param  value
+   * @returns 128-bit unsigned integer
+   */
+  @inline
+  static from<T>(value: T): u128 {
+    if (value instanceof bool) return u128.fromU64(<u64>value);
+    else if (value instanceof i8) return u128.fromI64(<i64>value);
+    else if (value instanceof u8) return u128.fromU64(<u64>value);
+    else if (value instanceof i16) return u128.fromI64(<i64>value);
+    else if (value instanceof u16) return u128.fromU64(<u64>value);
+    else if (value instanceof i32) return u128.fromI64(<i64>value);
+    else if (value instanceof u32) return u128.fromU64(<u64>value);
+    else if (value instanceof i64) return u128.fromI64(<i64>value);
+    else if (value instanceof u64) return u128.fromU64(<u64>value);
+    else if (value instanceof f32) return u128.fromF64(<f64>value);
+    else if (value instanceof f64) return u128.fromF64(<f64>value);
+    else if (value instanceof i128) return u128.fromI128(<i128>value);
+    else if (value instanceof u128) return u128.fromU128(<u128>value);
+    else if (value instanceof i256) return u128.fromI256(<i256>value);
+    else if (value instanceof u256) return u128.fromU256(<u256>value);
+    else if (value instanceof u8[]) return u128.fromBytes(<u8[]>value);
+    else if (value instanceof Uint8Array) return u128.fromBytes(<Uint8Array>value);
+    else if (value instanceof String) return u128.fromString(<string>value);
+    else throw new TypeError("Unsupported generic type");
+  }
+
+  @inline @operator.prefix('!')
+  static isEmpty(value: u128): bool {
+    return !(value.lo | value.hi);
+  }
+
+  @inline @operator('|')
+  static or(a: u128, b: u128): u128 {
+    return new u128(a.lo | b.lo, a.hi | b.hi);
+  }
+
+  @inline @operator('^')
+  static xor(a: u128, b: u128): u128 {
+    return new u128(a.lo ^ b.lo, a.hi ^ b.hi);
+  }
+
+  @inline @operator('&')
+  static and(a: u128, b: u128): u128 {
+    return new u128(a.lo & b.lo, a.hi & b.hi);
+  }
+
+  @inline @operator('<<')
+  static shl(value: u128, shift: i32): u128 {
+    // Cache check: if shift is 0 or invalid, return existing constants if possible
+    if (shift <= 0) {
+      return shift == 0 ? value.clone() : u128.Zero; // Use cached Zero
+    }
+
+    if (shift >= 128) {
+      return u128.Zero; // Use cached Zero
+    }
+
+    // Unrolled shift logic
+    if (shift < 64) {
+      const lo = value.lo << shift;
+      const hi = (value.hi << shift) | (value.lo >>> (64 - shift));
+      return new u128(lo, hi);
+    } else {
+      // shift >= 64
+      return new u128(0, value.lo << (shift - 64));
+    }
+  }
+
+  @inline @operator('>>')
+  static shr(value: u128, shift: i32): u128 {
+    shift &= 127;
+    if (shift == 0) return value.clone();
+
+    // Unrolled shift logic
+    if (shift < 64) {
+      let hi = value.hi >> shift;
+      let lo = (value.hi << (64 - shift)) | (value.lo >> shift);
+      return new u128(lo, hi);
+    } else {
+      let s = shift - 64;
+      return new u128(value.hi >> s, 0);
+    }
+  }
+
+  @inline @operator('>>>')
+  static shr_u(value: u128, shift: i32): u128 {
+    return u128.shr(value, shift);
+  }
+
+  @inline
+  static rotl(value: u128, shift: i32): u128 {
+    let n = shift & 127;
+    if (n == 0) return value.clone();
+
+    let lo = value.lo;
+    let hi = value.hi;
+    if (n == 64) {
+      return new u128(hi, lo);
+    }
+    if (n & 64) {
+      let t = lo;
+      lo = hi;
+      hi = t;
+    }
+    let slo = lo << n;
+    let shi = hi << n;
+    let rlo = lo >> (64 - n);
+    let rhi = hi >> (64 - n);
+    return new u128(slo | rhi, shi | rlo);
+  }
+
+  @inline
+  static rotr(value: u128, shift: i32): u128 {
+    let n = shift & 127;
+    if (n == 0) return value.clone();
+
+    let lo = value.lo;
+    let hi = value.hi;
+    if (n == 64) {
+      return new u128(hi, lo);
+    }
+    if (n & 64) {
+      let t = lo;
+      lo = hi;
+      hi = t;
+    }
+    let slo = lo >> n;
+    let shi = hi >> n;
+    let rlo = lo << (64 - n);
+    let rhi = hi << (64 - n);
+    return new u128(slo | rhi, shi | rlo);
+  }
+
+  @inline @operator('+')
+  static add(a: u128, b: u128): u128 {
+    var alo = a.lo;
+    var lo = alo + b.lo;
+    var hi = a.hi + b.hi + u64(lo < alo);
+    return new u128(lo, hi);
+  }
+
+  @inline @operator('-')
+  static sub(a: u128, b: u128): u128 {
+    var alo = a.lo;
+    var lo = alo - b.lo;
+    var hi = a.hi - b.hi - u64(lo > alo);
+    return new u128(lo, hi);
+  }
+
+  // mul: u128 x u128 = u128
+  @inline @operator('*')
+  static mul(a: u128, b: u128): u128 {
+    return new u128(
+      __multi3(a.lo, a.hi, b.lo, b.hi),
+      __res128_hi
+    );
+  }
+
+  @inline @operator('/')
+  static div(a: u128, b: u128): u128 {
+    return new u128(
+      __udivmod128(a.lo, a.hi, b.lo, b.hi),
+      __divmod_quot_hi
+    );
+  }
+
+  @inline @operator('%')
+  static rem(a: u128, b: u128): u128 {
+    __udivmod128(a.lo, a.hi, b.lo, b.hi);
+    return new u128(__divmod_rem_lo, __divmod_rem_hi);
+  }
+
+  @inline
+  static div10(value: u128): u128 {
+    return new u128(
+      __udivmod128_10(value.lo, value.hi),
+      __divmod_quot_hi
+    );
+  }
+
+  @inline
+  static rem10(value: u128): u128 {
+    __udivmod128_10(value.lo, value.hi);
+    return new u128(__divmod_rem_lo, __divmod_rem_hi);
+  }
+
+  /**
+   * Calculate power of base with exponent
+   * @param  base     128-bit unsigned integer
+   * @param  exponent 32-bit signed integer
+   * @returns         128-bit unsigned integer
+   */
+  @operator('**')
+  static pow(base: u128, exponent: i32): u128 {
+    // any negative exponent produce zero
+
+    var result = u128.One;
+
+    if (base == result) return result;
+    var tmp = base.clone();
+    if (exponent <= 1) {
+      if (exponent < 0) return u128.Zero;
+      return exponent == 0 ? result : tmp;
+    }
+
+    if (ASC_SHRINK_LEVEL < 1) {
+      var lo = base.lo;
+      var hi = base.hi;
+      // if base > u64::max and exp > 1 always return "0"
+      if (!lo) return u128.Zero;
+      if (!hi) {
+        let lo1 = lo - 1;
+        // "1 ^ exponent" always return "1"
+        if (!lo1) return result;
+
+        // if base is power of two do "1 << log2(base) * exp"
+        if (!(lo & lo1)) {
+          let shift = <i32>(64 - clz(lo1)) * exponent;
+          // @ts-ignore
+          return shift < 128 ? result << shift : u128.Zero;
+        }
+      }
+
+      if (exponent <= 4) {
+        let baseSq = tmp.sqr();
+        switch (exponent) {
+          case 2:
+            return baseSq;        // base ^ 2
+          // @ts-ignore
+          case 3:
+            return baseSq * base; // base ^ 2 * base
+          case 4:
+            return baseSq.sqr();  // base ^ 2 * base ^ 2
+          default:
+            break;
+        }
+      }
+
+      let log = 32 - clz(exponent);
+      if (log <= 7) {
+        // 128 = 2 ^ 7, so need usually only seven cases
+        switch (log) {
+          case 7:
+            // @ts-ignore
+            if (exponent & 1) result *= tmp;
+            exponent >>= 1;
+            tmp.sqr();
+          case 6:
+            // @ts-ignore
+            if (exponent & 1) result *= tmp;
+            exponent >>= 1;
+            tmp.sqr();
+          case 5:
+            // @ts-ignore
+            if (exponent & 1) result *= tmp;
+            exponent >>= 1;
+            tmp.sqr();
+          case 4:
+            // @ts-ignore
+            if (exponent & 1) result *= tmp;
+            exponent >>= 1;
+            tmp.sqr();
+          case 3:
+            // @ts-ignore
+            if (exponent & 1) result *= tmp;
+            exponent >>= 1;
+            tmp.sqr();
+          case 2:
+            // @ts-ignore
+            if (exponent & 1) result *= tmp;
+            exponent >>= 1;
+            tmp.sqr();
+          case 1:
+            // @ts-ignore
+            if (exponent & 1) result *= tmp;
+        }
+        return result;
+      }
+    }
+
+    while (exponent > 0) {
+      // @ts-ignore
+      if (exponent & 1) result *= tmp;
+      exponent >>= 1;
+      tmp.sqr();
+    }
+    return result;
+  }
+
+  // compute floor(sqrt(x))
+  static sqrt(value: u128): u128 {
+    var rem = value.clone();
+    if (value < new u128(2)) {
+      return rem;
+    }
+    var res = u128.Zero;
+    // @ts-ignore
+    var pos = u128.One << (127 - (u128.clz(value) | 1));
+    // @ts-ignore
+    while (!pos.isZero()) {
+      // @ts-ignore
+      value = res + pos;
+      if (rem >= value) {
+        // @ts-ignore
+        rem = rem - value;
+        // @ts-ignore
+        res = pos + value;
+      }
+      // @ts-ignore
+      res >>= 1;
+      pos >>= 2;
+    }
+    return res;
+  }
+
+  @inline @operator('==')
+  static eq(a: u128, b: u128): bool {
+    return a.hi == b.hi && a.lo == b.lo;
+  }
+
+  @inline @operator('!=')
+  static ne(a: u128, b: u128): bool {
+    return !u128.eq(a, b);
+  }
+
+  @inline @operator('<')
+  static lt(a: u128, b: u128): bool {
+    var ah = a.hi, bh = b.hi;
+    return ah == bh ? a.lo < b.lo : ah < bh;
+  }
+
+  @inline @operator('>')
+  static gt(a: u128, b: u128): bool {
+    var ah = a.hi, bh = b.hi;
+    return ah == bh ? a.lo > b.lo : ah > bh;
+  }
+
+  @inline @operator('<=')
+  static le(a: u128, b: u128): bool {
+    return !u128.gt(a, b);
+  }
+
+  @inline @operator('>=')
+  static ge(a: u128, b: u128): bool {
+    return !u128.lt(a, b);
+  }
+
+  /**
+   * Get ordering
+   * if a > b then result is  1
+   * if a < b then result is -1
+   * if a = b then result is  0
+   * @param  a 128-bit unsigned integer
+   * @param  b 128-bit unsigned integer
+   * @returns  32-bit signed integer
+   */
+  @inline
+  static ord(a: u128, b: u128): i32 {
+    // if a > b => +1
+    // if a < b => -1
+    // if equal => 0
+    if (a.hi > b.hi) return 1;
+    if (a.hi < b.hi) return -1;
+    if (a.lo > b.lo) return 1;
+    if (a.lo < b.lo) return -1;
+    return 0;
+  }
+
+  /**
+   * Compute count of set (populated) bits
+   * @param  value 128-bit unsigned integer
+   * @returns      32-bit signed integer
+   */
+  @inline
+  static popcnt(value: u128): i32 {
+    return <i32>(popcnt(value.lo) + popcnt(value.hi));
+  }
+
+  /**
+   * Compute bit count of leading zeros
+   * @param  value 128-bit unsigned integer
+   * @returns      32-bit signed integer
+   */
+  @inline
+  static clz(value: u128): i32 {
+    return __clz128(value.lo, value.hi);
+  }
+
+  /**
+   * Compute bit count of trailing zeros
+   * @param  value 128-bit unsigned integer
+   * @returns      32-bit signed integer
+   */
+  @inline
+  static ctz(value: u128): i32 {
+    return __ctz128(value.lo, value.hi);
+  }
+
+  /**
+   * Calculate squared value (value ** 2)
+   * @param  value 128-bit unsigned integer
+   * @returns      128-bit unsigned integer
+   */
+  @inline
+  static sqr(value: u128): u128 {
+    return value.clone().sqr();
+  }
+
+  /**
+   * Calculate multiply and division as `number * numerator / denominator`
+   * without overflow in multiplication part.
+   *
+   * @returns 128-bit unsigned integer
+   */
+  static muldiv(a: u128, b: u128, c: u128): u128 {
+    let A = u256.fromU128(a);
+    let B = u256.fromU128(b);
+    let C = u256.fromU128(c);
+
+    let product = u256.mul(A, B);
+    let quotient = u256.div(product, C);
+
+    return quotient.toU128();
+  }
+
+  @inline
+  set(value: u128): this {
+    this.checkMutable();
+    this.lo = value.lo;
+    this.hi = value.hi;
+    return this;
+  }
+
+  @inline
+  setI64(value: i64): this {
+    this.checkMutable();
+    this.lo = value;
+    this.hi = value >> 63;
+    return this;
+  }
+
+  @inline
+  setU64(value: u64): this {
+    this.checkMutable();
+    this.lo = value;
+    this.hi = 0;
+    return this;
+  }
+
+  @inline
+  setI32(value: i32): this {
+    this.checkMutable();
+    this.lo = value;
+    this.hi = value >> 63;
+    return this;
+  }
+
+  @inline
+  setU32(value: u32): this {
+    this.checkMutable();
+    this.lo = value;
+    this.hi = 0;
+    return this;
+  }
+
+  @inline
+  isZero(): bool {
+    return !(this.lo | this.hi);
+  }
+
+  @inline @operator.prefix('~')
+  not(): u128 {
+    return new u128(~this.lo, ~this.hi);
+  }
+
+  @inline @operator.prefix('+')
+  pos(): u128 {
+    return this;
+  }
+
+  @inline @operator.prefix('-')
+  neg(): u128 {
+    var lo = ~this.lo;
+    var hi = ~this.hi;
+    var lo1 = lo + 1;
+    return new u128(lo1, hi + u64(lo1 < lo));
+  }
+
+  @operator.prefix('++')
+  preInc(): this {
+    this.checkMutable();
+    var lo = this.lo;
+    var lo1 = lo + 1;
+    this.hi += u64(lo1 < lo);
+    this.lo = lo1;
+    return this;
+  }
+
+  @operator.prefix('--')
+  preDec(): this {
+    this.checkMutable();
+    var lo = this.lo;
+    var lo1 = lo - 1;
+    this.hi -= u64(lo1 > lo);
+    this.lo = lo1;
+    return this;
+  }
+
+  @operator.postfix('++')
+  postInc(): u128 {
+    return this.clone().preInc();
+  }
+
+  @operator.postfix('--')
+  postDec(): u128 {
+    return this.clone().preDec();
+  }
+
+  /**
+   * Calculate inplace squared 128-bit unsigned integer (this ** 2)
+   * @returns 128-bit unsigned integer
+   */
+  sqr(): this {
+    this.checkMutable();
+    // Use built-in 128×128 => 128 multiplication
+    // i.e. "x * x"
+    let tmp = u128.mul(this, this);
+    this.lo = tmp.lo;
+    this.hi = tmp.hi;
+    return this;
+  }
+
+  /**
+   * Convert to 256-bit signed integer
+   * @returns 256-bit signed integer
+   */
+  @inline
+  toI256(): i256 {
+    return new i256(this.lo, this.hi);
+  }
+
+  /**
+   * Convert to 256-bit unsigned integer
+   * @returns 256-bit unsigned integer
+   */
+  @inline
+  toU256(): u256 {
+    return new u256(this.lo, this.hi);
+  }
+
+  /**
+   * Convert to 128-bit signed integer
+   * @returns 128-bit signed integer
+   */
+  @inline
+  toI128(): i128 {
+    return new i128(this.lo, this.hi);
+  }
+
+  /**
+   * Convert to 128-bit unsigned integer
+   * @returns 128-bit unsigned integer
+   */
+  @inline
+  toU128(): this {
+    return this;
+  }
+
+  /**
+   * Convert to 64-bit signed integer
+   * @returns 64-bit signed integer
+   */
+  @inline
+  toI64(): i64 {
+    return <i64>(
+      (this.lo & 0x7FFFFFFFFFFFFFFF) |
+      (this.hi & 0x8000000000000000)
+    );
+  }
+
+  /**
+   * Convert to 64-bit unsigned integer
+   * @returns 64-bit unsigned integer
+   */
+  @inline
+  toU64(): u64 {
+    return this.lo;
+  }
+
+  /**
+   * Convert to 32-bit signed integer
+   * @returns 32-bit signed integer
+   */
+  @inline
+  toI32(): i32 {
+    return <i32>this.toI64();
+  }
+
+  /**
+   * Convert to 32-bit unsigned integer
+   * @returns 32-bit unsigned integer
+   */
+  @inline
+  toU32(): u32 {
+    return <u32>this.lo;
+  }
+
+  /**
+   * Convert to 1-bit boolean
+   * @returns 1-bit boolean
+   */
+  @inline
+  toBool(): bool {
+    return (this.lo | this.hi) != 0;
+  }
+
+  /**
+   * Convert to 64-bit float number in deteministic way
+   * @returns 64-bit float
+   */
+  @inline
+  toF64(): f64 {
+    return __floatuntidf(this.lo, this.hi);
+  }
+
+  /**
+   * Convert to 32-bit float number
+   * @returns 32-bit float
+   */
+  @inline
+  toF32(): f32 {
+    return <f32>this.toF64();
+  }
+
+  /**
+   * Convert to generic type `T`. Useful inside other generics methods
+   * @param  T  is <bool | i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64 | f32 | f64 | i128 | u128 | u256 | u8[] | Uint8Array | `StaticArray<u8>` | string>
+   * @returns   type of `T`
+   */
+  @inline
+  as<T>(): T {
+    if (isBoolean<T>()) {
+      return <T>this.toBool();
+    } else if (isInteger<T>()) {
+      if (isSigned<T>()) {
+        // i8, i16, i32, i64
+        return <T>this.toI64();
+      } else {
+        // u8, u16, u32, u64
+        return <T>this.toU64();
+      }
+    } else if (isFloat<T>()) {
+      // f32, f64
+      return <T>this.toF64();
+    } else if (isString<T>()) {
+      return <T>this.toString();
+    } else if (isReference<T>()) {
+      let dummy = changetype<T>(0);
+      if (dummy instanceof u8[]) return <T>this.toBytes();
+      else if (dummy instanceof StaticArray<u8>) return <T>this.toStaticBytes();
+      else if (dummy instanceof Uint8Array) return <T>this.toUint8Array();
+      else if (dummy instanceof i128) return <T>this.toI128();
+      else if (dummy instanceof u128) return <T>this;
+      else if (dummy instanceof u256) return <T>this.toU256();
+      else throw new TypeError('Unsupported generic type');
+    } else throw new TypeError('Unsupported generic type');
+  }
+
+  /**
+   * Convert to byte array
+   * @param bigEndian Little or Big Endian? Default: false
+   * @returns  Array of bytes
+   */
+  @inline
+  toBytes(bigEndian: bool = false): u8[] {
+    var result = new Array<u8>(16);
+    this.toArrayBuffer(result.dataStart, bigEndian);
+    return result;
+  }
+
+  /**
+   * Convert to byte static array
+   * @param bigEndian Little or Big Endian? Default: false
+   * @returns  StaticArray of bytes
+   */
+  @inline
+  toStaticBytes(bigEndian: bool = false): StaticArray<u8> {
+    var result = new StaticArray<u8>(16);
+    this.toArrayBuffer(changetype<usize>(result), bigEndian);
+    return result;
+  }
+
+  /**
+   * Convert to Uint8Array
+   * @param bigEndian Little or Big Endian? Default: false
+   * @returns  Uint8Array
+   */
+  @inline
+  toUint8Array(bigEndian: bool = false): Uint8Array {
+    var result = new Uint8Array(16);
+    this.toArrayBuffer(result.dataStart, bigEndian);
+    return result;
+  }
+
+  /**
+   * Return copy of current 128-bit value
+   * @returns 128-bit unsigned integer
+   */
+  clone(): u128 {
+    return new u128(this.lo, this.hi);
+  }
+
+  toString(radix: i32 = 10): string {
+    assert(radix == 10 || radix == 16, 'radix argument must be between 10 or 16');
+    if (this.isZero()) return '0';
+
+    var result = '';
+    if (radix == 16) {
+      let shift: i32 = 124 - (u128.clz(this) & ~3);
+      while (shift >= 0) {
+        // @ts-ignore
+        result += HEX_CHARS.charAt(<i32>((this >> shift).lo & 15));
+        shift -= 4;
+      }
+      return result;
+    }
+    return u128toDecimalString(this);
+  }
+
+  @inline
+  private toArrayBufferLE(buffer: usize): void {
+    store<u64>(buffer, this.lo, 0 * sizeof<u64>());
+    store<u64>(buffer, this.hi, 1 * sizeof<u64>());
+  }
+
+  @inline
+  private toArrayBufferBE(buffer: usize): void {
+    store<u64>(buffer, bswap(this.hi), 0 * sizeof<u64>());
+    store<u64>(buffer, bswap(this.lo), 1 * sizeof<u64>());
+  }
+
+  @inline
+  private toArrayBuffer(buffer: usize, bigEndian: bool = false): void {
+    if (bigEndian) {
+      this.toArrayBufferBE(buffer);
+    } else {
+      this.toArrayBufferLE(buffer);
+    }
+  }
+}