ceph/src/arrow/js/src/util/bn.ts

   1 // Licensed to the Apache Software Foundation (ASF) under one
   2 // or more contributor license agreements.  See the NOTICE file
   3 // distributed with this work for additional information
   4 // regarding copyright ownership.  The ASF licenses this file
   5 // to you under the Apache License, Version 2.0 (the
   6 // "License"); you may not use this file except in compliance
   7 // with the License.  You may obtain a copy of the License at
   8 //
   9 //   http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing,
  12 // software distributed under the License is distributed on an
  13 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14 // KIND, either express or implied.  See the License for the
  15 // specific language governing permissions and limitations
  16 // under the License.
  17
  18 import { ArrayBufferViewInput, toArrayBufferView } from './buffer';
  19 import { TypedArray, TypedArrayConstructor } from '../interfaces';
  20 import { BigIntArray, BigIntArrayConstructor } from '../interfaces';
  21 import { BigIntAvailable, BigInt64Array, BigUint64Array } from './compat';
  22
  23 /** @ignore */
  24 export const isArrowBigNumSymbol = Symbol.for('isArrowBigNum');
  25
  26 /** @ignore */ type BigNumArray = IntArray | UintArray;
  27 /** @ignore */ type IntArray = Int8Array | Int16Array | Int32Array;
  28 /** @ignore */ type UintArray = Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray;
  29
  30 /** @ignore */
  31 function BigNum(this: any, x: any, ...xs: any) {
  32     if (xs.length === 0) {
  33         return Object.setPrototypeOf(toArrayBufferView(this['TypedArray'], x), this.constructor.prototype);
  34     }
  35     return Object.setPrototypeOf(new this['TypedArray'](x, ...xs), this.constructor.prototype);
  36 }
  37
  38 BigNum.prototype[isArrowBigNumSymbol] = true;
  39 BigNum.prototype.toJSON = function<T extends BN<BigNumArray>>(this: T) { return `"${bignumToString(this)}"`; };
  40 BigNum.prototype.valueOf = function<T extends BN<BigNumArray>>(this: T) { return bignumToNumber(this); };
  41 BigNum.prototype.toString = function<T extends BN<BigNumArray>>(this: T) { return bignumToString(this); };
  42 BigNum.prototype[Symbol.toPrimitive] = function<T extends BN<BigNumArray>>(this: T, hint: 'string' | 'number' | 'default' = 'default') {
  43     switch (hint) {
  44         case 'number': return bignumToNumber(this);
  45         case 'string': return bignumToString(this);
  46         case 'default': return bignumToBigInt(this);
  47     }
  48     // @ts-ignore
  49     return bignumToString(this);
  50 };
  51
  52 /** @ignore */
  53 type TypedArrayConstructorArgs =
  54     [number | void] |
  55     [Iterable<number> | Iterable<bigint>] |
  56     [ArrayBufferLike, number | void, number | void] ;
  57
  58 /** @ignore */
  59 function SignedBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }
  60 /** @ignore */
  61 function UnsignedBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }
  62 /** @ignore */
  63 function DecimalBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }
  64
  65 Object.setPrototypeOf(SignedBigNum.prototype,   Object.create(Int32Array.prototype));
  66 Object.setPrototypeOf(UnsignedBigNum.prototype, Object.create(Uint32Array.prototype));
  67 Object.setPrototypeOf(DecimalBigNum.prototype,  Object.create(Uint32Array.prototype));
  68 Object.assign(SignedBigNum.prototype,   BigNum.prototype, { 'constructor': SignedBigNum,   'signed': true,  'TypedArray': Int32Array,  'BigIntArray': BigInt64Array  });
  69 Object.assign(UnsignedBigNum.prototype, BigNum.prototype, { 'constructor': UnsignedBigNum, 'signed': false, 'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });
  70 Object.assign(DecimalBigNum.prototype,  BigNum.prototype, { 'constructor': DecimalBigNum,  'signed': true,  'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });
  71
  72 /** @ignore */
  73 function bignumToNumber<T extends BN<BigNumArray>>(bn: T) {
  74     const { buffer, byteOffset, length, 'signed': signed } = bn;
  75     const words = new Int32Array(buffer, byteOffset, length);
  76     let number = 0, i = 0;
  77     const n = words.length;
  78     let hi, lo;
  79     while (i < n) {
  80         lo = words[i++];
  81         hi = words[i++];
  82         signed || (hi = hi >>> 0);
  83         number += (lo >>> 0) + (hi * (i ** 32));
  84     }
  85     return number;
  86 }
  87
  88 /** @ignore */
  89 export let bignumToString: { <T extends BN<BigNumArray>>(a: T): string };
  90 /** @ignore */
  91 export let bignumToBigInt: { <T extends BN<BigNumArray>>(a: T): bigint };
  92
  93 if (!BigIntAvailable) {
  94     bignumToString = decimalToString;
  95     bignumToBigInt = <any> bignumToString;
  96 } else {
  97     bignumToBigInt = (<T extends BN<BigNumArray>>(a: T) => a.byteLength === 8 ? new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0] : <any>decimalToString(a));
  98     bignumToString = (<T extends BN<BigNumArray>>(a: T) => a.byteLength === 8 ? `${new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0]}` : decimalToString(a));
  99 }
 100
 101 /** @ignore */
 102 function decimalToString<T extends BN<BigNumArray>>(a: T) {
 103     let digits = '';
 104     const base64 = new Uint32Array(2);
 105     let base32 = new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2);
 106     const checks = new Uint32Array((base32 = new Uint16Array(base32).reverse()).buffer);
 107     let i = -1;
 108     const n = base32.length - 1;
 109     do {
 110         for (base64[0] = base32[i = 0]; i < n;) {
 111             base32[i++] = base64[1] = base64[0] / 10;
 112             base64[0] = ((base64[0] - base64[1] * 10) << 16) + base32[i];
 113         }
 114         base32[i] = base64[1] = base64[0] / 10;
 115         base64[0] = base64[0] - base64[1] * 10;
 116         digits = `${base64[0]}${digits}`;
 117     } while (checks[0] || checks[1] || checks[2] || checks[3]);
 118     return digits ? digits : `0`;
 119 }
 120
 121 /** @ignore */
 122 export class BN<T extends BigNumArray> {
 123     /** @nocollapse */
 124     public static new<T extends BigNumArray>(num: T, isSigned?: boolean): (T & BN<T>) {
 125         switch (isSigned) {
 126             case true: return new (<any> SignedBigNum)(num) as (T & BN<T>);
 127             case false: return new (<any> UnsignedBigNum)(num) as (T & BN<T>);
 128         }
 129         switch (num.constructor) {
 130             case Int8Array:
 131             case Int16Array:
 132             case Int32Array:
 133             case BigInt64Array:
 134                 return new (<any> SignedBigNum)(num) as (T & BN<T>);
 135         }
 136         if (num.byteLength === 16) {
 137             return new (<any> DecimalBigNum)(num) as (T & BN<T>);
 138         }
 139         return new (<any> UnsignedBigNum)(num) as (T & BN<T>);
 140     }
 141     /** @nocollapse */
 142     public static signed<T extends IntArray>(num: T): (T & BN<T>) {
 143         return new (<any> SignedBigNum)(num) as (T & BN<T>);
 144     }
 145     /** @nocollapse */
 146     public static unsigned<T extends UintArray>(num: T): (T & BN<T>) {
 147         return new (<any> UnsignedBigNum)(num) as (T & BN<T>);
 148     }
 149     /** @nocollapse */
 150     public static decimal<T extends UintArray>(num: T): (T & BN<T>) {
 151         return new (<any> DecimalBigNum)(num) as (T & BN<T>);
 152     }
 153     constructor(num: T, isSigned?: boolean) {
 154         return BN.new(num, isSigned) as any;
 155     }
 156 }
 157
 158 /** @ignore */
 159 export interface BN<T extends BigNumArray> extends TypedArrayLike<T> {
 160
 161     new<T extends ArrayBufferViewInput>(buffer: T, signed?: boolean): T;
 162
 163     readonly signed: boolean;
 164     readonly TypedArray: TypedArrayConstructor<TypedArray>;
 165     readonly BigIntArray: BigIntArrayConstructor<BigIntArray>;
 166
 167     [Symbol.toStringTag]:
 168         'Int8Array'         |
 169         'Int16Array'        |
 170         'Int32Array'        |
 171         'Uint8Array'        |
 172         'Uint16Array'       |
 173         'Uint32Array'       |
 174         'Uint8ClampedArray';
 175
 176     /**
 177      * Convert the bytes to their (positive) decimal representation for printing
 178      */
 179     toString(): string;
 180     /**
 181      * Down-convert the bytes to a 53-bit precision integer. Invoked by JS for
 182      * arithmetic operators, like `+`. Easy (and unsafe) way to convert BN to
 183      * number via `+bn_inst`
 184      */
 185     valueOf(): number;
 186     /**
 187      * Return the JSON representation of the bytes. Must be wrapped in double-quotes,
 188      * so it's compatible with JSON.stringify().
 189      */
 190     toJSON(): string;
 191     [Symbol.toPrimitive](hint?: any): number | string | bigint;
 192 }
 193
 194 /** @ignore */
 195 interface TypedArrayLike<T extends BigNumArray> {
 196
 197     readonly length: number;
 198     readonly buffer: ArrayBuffer;
 199     readonly byteLength: number;
 200     readonly byteOffset: number;
 201     readonly BYTES_PER_ELEMENT: number;
 202
 203     includes(searchElement: number, fromIndex?: number | undefined): boolean;
 204     copyWithin(target: number, start: number, end?: number | undefined): this;
 205     every(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): boolean;
 206     fill(value: number, start?: number | undefined, end?: number | undefined): this;
 207     filter(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): T;
 208     find(predicate: (value: number, index: number, obj: T) => boolean, thisArg?: any): number | undefined;
 209     findIndex(predicate: (value: number, index: number, obj: T) => boolean, thisArg?: any): number;
 210     forEach(callbackfn: (value: number, index: number, array: T) => void, thisArg?: any): void;
 211     indexOf(searchElement: number, fromIndex?: number | undefined): number;
 212     join(separator?: string | undefined): string;
 213     lastIndexOf(searchElement: number, fromIndex?: number | undefined): number;
 214     map(callbackfn: (value: number, index: number, array: T) => number, thisArg?: any): T;
 215     reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number): number;
 216     reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number, initialValue: number): number;
 217     reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: T) => U, initialValue: U): U;
 218     reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number): number;
 219     reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number, initialValue: number): number;
 220     reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: T) => U, initialValue: U): U;
 221     reverse(): T;
 222     set(array: ArrayLike<number>, offset?: number | undefined): void;
 223     slice(start?: number | undefined, end?: number | undefined): T;
 224     some(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): boolean;
 225     sort(compareFn?: ((a: number, b: number) => number) | undefined): this;
 226     subarray(begin: number, end?: number | undefined): T;
 227     toLocaleString(): string;
 228     entries(): IterableIterator<[number, number]>;
 229     keys(): IterableIterator<number>;
 230     values(): IterableIterator<number>;
 231 }