/** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ (function (factory) { if (typeof module === "object" && typeof module.exports === "object") { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === "function" && define.amd) { define("@angular/compiler/src/i18n/big_integer", ["require", "exports"], factory); } })(function (require, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.BigIntExponentiation = exports.BigIntForMultiplication = exports.BigInteger = void 0; /** * Represents a big integer using a buffer of its individual digits, with the least significant * digit stored at the beginning of the array (little endian). * * For performance reasons, each instance is mutable. The addition operation can be done in-place * to reduce memory pressure of allocation for the digits array. */ var BigInteger = /** @class */ (function () { /** * Creates a big integer using its individual digits in little endian storage. */ function BigInteger(digits) { this.digits = digits; } BigInteger.zero = function () { return new BigInteger([0]); }; BigInteger.one = function () { return new BigInteger([1]); }; /** * Creates a clone of this instance. */ BigInteger.prototype.clone = function () { return new BigInteger(this.digits.slice()); }; /** * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate * `this` but instead returns a new instance, unlike `addToSelf`. */ BigInteger.prototype.add = function (other) { var result = this.clone(); result.addToSelf(other); return result; }; /** * Adds `other` to the instance itself, thereby mutating its value. */ BigInteger.prototype.addToSelf = function (other) { var maxNrOfDigits = Math.max(this.digits.length, other.digits.length); var carry = 0; for (var i = 0; i < maxNrOfDigits; i++) { var digitSum = carry; if (i < this.digits.length) { digitSum += this.digits[i]; } if (i < other.digits.length) { digitSum += other.digits[i]; } if (digitSum >= 10) { this.digits[i] = digitSum - 10; carry = 1; } else { this.digits[i] = digitSum; carry = 0; } } // Apply a remaining carry if needed. if (carry > 0) { this.digits[maxNrOfDigits] = 1; } }; /** * Builds the decimal string representation of the big integer. As this is stored in * little endian, the digits are concatenated in reverse order. */ BigInteger.prototype.toString = function () { var res = ''; for (var i = this.digits.length - 1; i >= 0; i--) { res += this.digits[i]; } return res; }; return BigInteger; }()); exports.BigInteger = BigInteger; /** * Represents a big integer which is optimized for multiplication operations, as its power-of-twos * are memoized. See `multiplyBy()` for details on the multiplication algorithm. */ var BigIntForMultiplication = /** @class */ (function () { function BigIntForMultiplication(value) { this.powerOfTwos = [value]; } /** * Returns the big integer itself. */ BigIntForMultiplication.prototype.getValue = function () { return this.powerOfTwos[0]; }; /** * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The * value for `b` is represented by a storage model that is optimized for this computation. * * This operation is implemented in N(log2(num)) by continuous halving of the number, where the * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is * used as exponent into the power-of-two multiplication of `b`. * * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the * algorithm unrolls into the following iterations: * * Iteration | num | LSB | b * 2^iter | Add? | product * -----------|------------|------|------------|------|-------- * 0 | 0b00101010 | 0 | 1337 | No | 0 * 1 | 0b00010101 | 1 | 2674 | Yes | 2674 * 2 | 0b00001010 | 0 | 5348 | No | 2674 * 3 | 0b00000101 | 1 | 10696 | Yes | 13370 * 4 | 0b00000010 | 0 | 21392 | No | 13370 * 5 | 0b00000001 | 1 | 42784 | Yes | 56154 * 6 | 0b00000000 | 0 | 85568 | No | 56154 * * The computed product of 56154 is indeed the correct result. * * The `BigIntForMultiplication` representation for a big integer provides memoized access to the * power-of-two values to reduce the workload in computing those values. */ BigIntForMultiplication.prototype.multiplyBy = function (num) { var product = BigInteger.zero(); this.multiplyByAndAddTo(num, product); return product; }; /** * See `multiplyBy()` for details. This function allows for the computed product to be added * directly to the provided result big integer. */ BigIntForMultiplication.prototype.multiplyByAndAddTo = function (num, result) { for (var exponent = 0; num !== 0; num = num >>> 1, exponent++) { if (num & 1) { var value = this.getMultipliedByPowerOfTwo(exponent); result.addToSelf(value); } } }; /** * Computes and memoizes the big integer value for `this.number * 2^exponent`. */ BigIntForMultiplication.prototype.getMultipliedByPowerOfTwo = function (exponent) { // Compute the powers up until the requested exponent, where each value is computed from its // predecessor. This is simple as `this.number * 2^(exponent - 1)` only has to be doubled (i.e. // added to itself) to reach `this.number * 2^exponent`. for (var i = this.powerOfTwos.length; i <= exponent; i++) { var previousPower = this.powerOfTwos[i - 1]; this.powerOfTwos[i] = previousPower.add(previousPower); } return this.powerOfTwos[exponent]; }; return BigIntForMultiplication; }()); exports.BigIntForMultiplication = BigIntForMultiplication; /** * Represents an exponentiation operation for the provided base, of which exponents are computed and * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix * representation that is lazily computed upon request. */ var BigIntExponentiation = /** @class */ (function () { function BigIntExponentiation(base) { this.base = base; this.exponents = [new BigIntForMultiplication(BigInteger.one())]; } /** * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for * further multiplication operations. */ BigIntExponentiation.prototype.toThePowerOf = function (exponent) { // Compute the results up until the requested exponent, where every value is computed from its // predecessor. This is because `this.base^(exponent - 1)` only has to be multiplied by `base` // to reach `this.base^exponent`. for (var i = this.exponents.length; i <= exponent; i++) { var value = this.exponents[i - 1].multiplyBy(this.base); this.exponents[i] = new BigIntForMultiplication(value); } return this.exponents[exponent]; }; return BigIntExponentiation; }()); exports.BigIntExponentiation = BigIntExponentiation; }); //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"big_integer.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/i18n/big_integer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Represents a big integer using a buffer of its individual digits, with the least significant\n * digit stored at the beginning of the array (little endian).\n *\n * For performance reasons, each instance is mutable. The addition operation can be done in-place\n * to reduce memory pressure of allocation for the digits array.\n */\nexport class BigInteger {\n  static zero(): BigInteger {\n    return new BigInteger([0]);\n  }\n\n  static one(): BigInteger {\n    return new BigInteger([1]);\n  }\n\n  /**\n   * Creates a big integer using its individual digits in little endian storage.\n   */\n  private constructor(private readonly digits: number[]) {}\n\n  /**\n   * Creates a clone of this instance.\n   */\n  clone(): BigInteger {\n    return new BigInteger(this.digits.slice());\n  }\n\n  /**\n   * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate\n   * `this` but instead returns a new instance, unlike `addToSelf`.\n   */\n  add(other: BigInteger): BigInteger {\n    const result = this.clone();\n    result.addToSelf(other);\n    return result;\n  }\n\n  /**\n   * Adds `other` to the instance itself, thereby mutating its value.\n   */\n  addToSelf(other: BigInteger): void {\n    const maxNrOfDigits = Math.max(this.digits.length, other.digits.length);\n    let carry = 0;\n    for (let i = 0; i < maxNrOfDigits; i++) {\n      let digitSum = carry;\n      if (i < this.digits.length) {\n        digitSum += this.digits[i];\n      }\n      if (i < other.digits.length) {\n        digitSum += other.digits[i];\n      }\n\n      if (digitSum >= 10) {\n        this.digits[i] = digitSum - 10;\n        carry = 1;\n      } else {\n        this.digits[i] = digitSum;\n        carry = 0;\n      }\n    }\n\n    // Apply a remaining carry if needed.\n    if (carry > 0) {\n      this.digits[maxNrOfDigits] = 1;\n    }\n  }\n\n  /**\n   * Builds the decimal string representation of the big integer. As this is stored in\n   * little endian, the digits are concatenated in reverse order.\n   */\n  toString(): string {\n    let res = '';\n    for (let i = this.digits.length - 1; i >= 0; i--) {\n      res += this.digits[i];\n    }\n    return res;\n  }\n}\n\n/**\n * Represents a big integer which is optimized for multiplication operations, as its power-of-twos\n * are memoized. See `multiplyBy()` for details on the multiplication algorithm.\n */\nexport class BigIntForMultiplication {\n  /**\n   * Stores all memoized power-of-twos, where each index represents `this.number * 2^index`.\n   */\n  private readonly powerOfTwos: BigInteger[];\n\n  constructor(value: BigInteger) {\n    this.powerOfTwos = [value];\n  }\n\n  /**\n   * Returns the big integer itself.\n   */\n  getValue(): BigInteger {\n    return this.powerOfTwos[0];\n  }\n\n  /**\n   * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The\n   * value for `b` is represented by a storage model that is optimized for this computation.\n   *\n   * This operation is implemented in N(log2(num)) by continuous halving of the number, where the\n   * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is\n   * used as exponent into the power-of-two multiplication of `b`.\n   *\n   * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the\n   * algorithm unrolls into the following iterations:\n   *\n   *  Iteration | num        | LSB  | b * 2^iter | Add? | product\n   * -----------|------------|------|------------|------|--------\n   *  0         | 0b00101010 | 0    | 1337       | No   | 0\n   *  1         | 0b00010101 | 1    | 2674       | Yes  | 2674\n   *  2         | 0b00001010 | 0    | 5348       | No   | 2674\n   *  3         | 0b00000101 | 1    | 10696      | Yes  | 13370\n   *  4         | 0b00000010 | 0    | 21392      | No   | 13370\n   *  5         | 0b00000001 | 1    | 42784      | Yes  | 56154\n   *  6         | 0b00000000 | 0    | 85568      | No   | 56154\n   *\n   * The computed product of 56154 is indeed the correct result.\n   *\n   * The `BigIntForMultiplication` representation for a big integer provides memoized access to the\n   * power-of-two values to reduce the workload in computing those values.\n   */\n  multiplyBy(num: number): BigInteger {\n    const product = BigInteger.zero();\n    this.multiplyByAndAddTo(num, product);\n    return product;\n  }\n\n  /**\n   * See `multiplyBy()` for details. This function allows for the computed product to be added\n   * directly to the provided result big integer.\n   */\n  multiplyByAndAddTo(num: number, result: BigInteger): void {\n    for (let exponent = 0; num !== 0; num = num >>> 1, exponent++) {\n      if (num & 1) {\n        const value = this.getMultipliedByPowerOfTwo(exponent);\n        result.addToSelf(value);\n      }\n    }\n  }\n\n  /**\n   * Computes and memoizes the big integer value for `this.number * 2^exponent`.\n   */\n  private getMultipliedByPowerOfTwo(exponent: number): BigInteger {\n    // Compute the powers up until the requested exponent, where each value is computed from its\n    // predecessor. This is simple as `this.number * 2^(exponent - 1)` only has to be doubled (i.e.\n    // added to itself) to reach `this.number * 2^exponent`.\n    for (let i = this.powerOfTwos.length; i <= exponent; i++) {\n      const previousPower = this.powerOfTwos[i - 1];\n      this.powerOfTwos[i] = previousPower.add(previousPower);\n    }\n    return this.powerOfTwos[exponent];\n  }\n}\n\n/**\n * Represents an exponentiation operation for the provided base, of which exponents are computed and\n * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for\n * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix\n * representation that is lazily computed upon request.\n */\nexport class BigIntExponentiation {\n  private readonly exponents = [new BigIntForMultiplication(BigInteger.one())];\n\n  constructor(private readonly base: number) {}\n\n  /**\n   * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for\n   * further multiplication operations.\n   */\n  toThePowerOf(exponent: number): BigIntForMultiplication {\n    // Compute the results up until the requested exponent, where every value is computed from its\n    // predecessor. This is because `this.base^(exponent - 1)` only has to be multiplied by `base`\n    // to reach `this.base^exponent`.\n    for (let i = this.exponents.length; i <= exponent; i++) {\n      const value = this.exponents[i - 1].multiplyBy(this.base);\n      this.exponents[i] = new BigIntForMultiplication(value);\n    }\n    return this.exponents[exponent];\n  }\n}\n"]}