cnum/dist/index.modern.mjs.map

Represent rational numbers in comfortably numeric way.

{"version":3,"file":"index.modern.mjs","sources":["../src/version.ts","../src/Token.ts","../src/Lexer.ts","../src/Parser.ts","../src/config.ts","../src/bigint.ts","../src/Rat.ts","../src/SternBrocotTree.ts","../src/Symbolizer.ts","../src/Polyrat.ts","../src/cnum.ts"],"sourcesContent":["export default '0.1.3'\n","export const enum TokenType {\n  identifier,\n  keyword,\n  separator,\n  operator,\n  literal,\n  comment,\n}\n\n/**\n * @class Token\n * @name Token\n */\nexport class Token {\n  type: TokenType\n  s: string\n\n  /**\n   * Initialize a token.\n   */\n  constructor(type: TokenType, s: string) {\n    this.type = type\n    this.s = s\n  }\n\n  /**\n   * The text representation.\n   */\n  toString(): string {\n    return `${this.type}(${this.s})`\n  }\n}\n\nexport default Token\n","import Token, { TokenType } from './Token'\n\nconst OPERATORS = {\n  '+': 'add',\n  '-': 'sub',\n  '*': 'mul',\n  '/': 'div',\n  '**': 'pow',\n  '^': 'pow',\n  '=': 'set',\n  '==': 'equals',\n  '<': 'isLessThan',\n  '>': 'isGreaterThan',\n}\n\n/**\n * @class Lexer\n * @name Lexer\n */\nexport class Lexer {\n  s: string\n\n  /**\n   * Initialize a lexer.\n   */\n  constructor(input: string) {\n    this.s = input\n  }\n\n  /**\n   * Yields tokens as they are lexed.\n   *\n   */\n  *lex(): Generator<Token> {\n    let onSpace = false\n    let onInteger = false\n    let onWord = false\n    let onOperator = false\n    let buffer = ''\n\n    // for each character\n    for (let i = 0; i < this.s.length; i++) {\n      const char = this.s[i] ?? '?'\n\n      // if a space, combine with subsequent spaces into a separator\n      if (/^\\s$/.exec(char)) {\n        if (onInteger) {\n          yield new Token(TokenType.literal, buffer)\n          onInteger = false\n          buffer = ''\n        } else if (onWord) {\n          yield new Token(TokenType.identifier, buffer)\n          onWord = false\n          buffer = ''\n        }\n        onSpace = true\n        buffer += char\n        continue\n      } else if (onSpace) {\n        yield new Token(TokenType.separator, '')\n        onSpace = false\n        buffer = ''\n      }\n\n      // if a digit, combine with subsequent digits into a literal\n      if (/^\\d$/.exec(char)) {\n        if (!onWord) {\n          onInteger = true\n        }\n        buffer += char\n        continue\n      } else if (onInteger) {\n        yield new Token(TokenType.literal, buffer)\n        onInteger = false\n        buffer = ''\n      }\n\n      // if a letter, combine with subsequent letters/numbers into an identifier\n      if (/^[a-z]$/.exec(char) || (onWord && /^\\d$/.exec(char))) {\n        onWord = true\n        buffer += char\n        continue\n      } else if (onWord) {\n        yield new Token(TokenType.identifier, buffer)\n        onWord = false\n        buffer = ''\n      }\n\n      // if another char, combine with subsequent char and match an operator\n      buffer += char\n      if (buffer in OPERATORS) {\n        yield new Token(TokenType.operator, buffer)\n        onOperator = false\n        buffer = ''\n        continue\n      }\n      if (onOperator) {\n        throw `Invalid operator \"${buffer}\"`\n      }\n      onOperator = true\n    }\n\n    if (onSpace) {\n      yield new Token(TokenType.separator, '')\n    }\n\n    if (onInteger) {\n      yield new Token(TokenType.literal, buffer)\n    }\n\n    if (onWord) {\n      yield new Token(TokenType.identifier, buffer)\n    }\n  }\n}\n\nexport default Lexer\n","import { Token, TokenType } from './Token'\n\ninterface Identifiers<T> {\n  [Key: string]: T\n}\n\n/**\n * @class Parser\n * @name Parser\n */\nexport class Parser {\n  tokens: Generator<Token>\n  identifiers: Identifiers<string> = {}\n\n  /**\n   * Initialize a parser from a token generator.\n   */\n  constructor(tokens: Generator<Token>) {\n    this.tokens = tokens\n  }\n\n  /**\n   * Evaluate the result.\n   */\n  evaluate(): bigint {\n    let n = 0n\n    for (const x of this.tokens) {\n      if (x.type === TokenType.identifier) {\n        if (!(x.s in this.identifiers)) {\n          throw `\"${x.s}\" is undefined`\n        }\n        n += BigInt(this.identifiers[x.s] ?? -1)\n      }\n      // else if (x.type === TokenType.separator) {\n      // }\n      // else if (x.type === TokenType.operator) {\n      //   if (x.s === '=') {\n      //   }\n      // }\n      else if (x.type === TokenType.literal) {\n        n += BigInt(x.s)\n      }\n    }\n    return n\n  }\n\n  /**\n   * The text representation.\n   */\n  toString(): string {\n    return this.evaluate().toString()\n  }\n}\n\nexport default Parser\n","/**\n * Machine epsilon gives an upper bound on the relative error due to rounding in floating point arithmetic.\n */\nexport const EPSILON = 1e-16\n// @todo why not Number.EPSILON?\n\n/**\n * Limit on the number of loops in algorithms.\n */\nexport const MAX_LOOPS = 512\n","/**\n * Find the greatest common denominator of the two numbers.\n */\nexport const gcd = (a: bigint, b: bigint): bigint => {\n  if (b === 1n || a === 1n) {\n    return 1n\n  }\n  while (b !== 0n) {\n    //[a, b] = [b, a % b] // not pretty???\n    const t = a % b\n    a = b\n    b = t\n  }\n  return a < 0n ? -a : a\n}\n\n/**\n * Returns true if the number is prime.\n */\nexport const isPrime = (n: bigint): boolean => {\n  if (n === 1n) return false\n  for (let i = 2n; i * i <= n; i++) {\n    if (n % i === 0n) return false\n  }\n  return true\n}\n\n/**\n * Yields the prime numbers.\n */\nexport function* primes(): Generator<bigint> {\n  for (let n = 2n; true; n++) {\n    if (isPrime(n)) {\n      yield n\n    }\n  }\n}\n\n/**\n * Finds the prime factors, returning them in ascending order as arrays with their exponent as the second element.\n */\nexport const primeFactors = (n: bigint): Array<[bigint, bigint]> => {\n  const f: Array<[bigint, bigint]> = []\n  for (const p of primes()) {\n    let e = 0n\n    while (n % p === 0n) {\n      e++\n      n /= p\n    }\n    if (e) f.push([p, e])\n    if (n === 1n) break\n  }\n  return f\n}\n","import { EPSILON } from './config'\nimport { gcd, primeFactors } from './bigint'\nimport { rationalApproximation, continuedFraction } from './SternBrocotTree'\n\n/**\n * @class Rational Number\n * @name Rat\n */\nexport class Rat {\n  n: bigint\n  d: bigint\n\n  /**\n   * Initialize a rational number.\n   */\n  constructor(\n    numerator: bigint | number = 0n,\n    denominator: bigint | number = 1n,\n  ) {\n    this.n = BigInt(numerator)\n    this.d = BigInt(denominator)\n    this.normalize()\n  }\n\n  /**\n   * The decimal approximation.\n   */\n  valueOf(): number {\n    return Number(this.n) / Number(this.d)\n  }\n\n  /**\n   * The text representation.\n   */\n  toString(): string {\n    return this.n.toString() + (this.d === 1n ? '' : `/${  this.d.toString()}`)\n  }\n\n  /**\n   * Returns a text profile of the number in various formats and it's value after common transformations.\n   */\n  public get profile(): string {\n    const p = [`Rat: ${this.toString()} (≈${+this})`]\n    p.push(`Mixed: ${this.mixedFractionString()}`)\n    p.push(`Continued: ${this.continuedFractionString()}`)\n    p.push(`Factorization: ${this.primeFactorizationString()}`)\n    p.push(`Egyptian: ${this.egyptianFractionString()}`)\n    p.push(`Babylonian: ${this.babylonianFractionString()}`)\n    p.push(`psin(t): ${this.psin().toString()}`)\n    p.push(`pcos(t): ${this.pcos().toString()}`)\n    p.push(`ptan(t): ${this.ptan().toString()}`)\n    return p.join('\\n')\n  }\n\n  /**\n   * Clone this.\n   */\n  clone(): Rat {\n    return new Rat(this.n, this.d)\n  }\n\n  /**\n   * Normalize the numerator and denominator by factoring out the common denominators.\n   */\n  normalize(): void {\n    // normalize 0/±1, ±1/0, 0/0\n    if (this.n === 0n) {\n      if (this.d !== 0n) {\n        this.d = 1n\n      }\n      return\n    }\n    if (this.d === 0n) {\n      this.n = this.n > 0n ? 1n : -1n\n      return\n    }\n\n    // normalize 1/1\n    if (this.n === this.d) {\n      this.n = this.d = 1n\n      return\n    }\n\n    // remove negative denominator\n    if (this.d < 0n) {\n      this.n = -this.n\n      this.d = -this.d\n    }\n\n    // reduce numerator and denomitator by the greatest common divisor\n    const divisor = gcd(this.n, this.d)\n    this.n /= divisor\n    this.d /= divisor\n  }\n\n  /**\n   * Add this to that.\n   */\n  add(that: Rat): Rat {\n    const r = new Rat(this.n * that.d + that.n * this.d, this.d * that.d)\n    r.normalize()\n    return r\n  }\n\n  /**\n   * Subtract this from that.\n   */\n  sub(that: Rat): Rat {\n    return this.add(that.neg())\n  }\n\n  /**\n   * Multiply that by this.\n   */\n  mul(that: Rat): Rat {\n    const r = new Rat(this.n * that.n, this.d * that.d)\n    r.normalize()\n    return r\n  }\n\n  /**\n   * Divide this by that.\n   */\n  div(that: Rat): Rat {\n    const r = new Rat(this.n * that.d, this.d * that.n)\n    r.normalize()\n    return r\n  }\n\n  /**\n   * Mediant of this and that.\n   */\n  mediant(that: Rat): Rat {\n    const r = new Rat(this.n + that.n, this.d + that.d)\n    r.normalize()\n    return r\n  }\n\n  /**\n   * Minimum of this and that.\n   */\n  min(that: Rat): Rat {\n    return this.isLessThan(that) ? this : that\n  }\n\n  /**\n   * Maximum of this and that.\n   */\n  max(that: Rat): Rat {\n    return this.isGreaterThan(that) ? this : that\n  }\n\n  /**\n   * Raise this to the power of that.\n   */\n  pow(that: Rat): Rat {\n    // zero\n    if (that.n === 0n) {\n      return new Rat(1n)\n    }\n    // integer\n    if (that.d === 1n) {\n      return new Rat(Number(this.n) ** Number(that.n), Number(this.d) ** Number(that.n))\n    }\n    // fraction\n    const estimate = Math.pow(+this, +that)\n    return floatToRat(estimate)\n  }\n\n  /**\n   * Returns the dot product of this and that.\n   */\n  dot(that: Rat): bigint {\n    return this.n * that.n + this.d * that.d\n  }\n\n  /**\n   * Returns true if this equals that.\n   */\n  equals(that: Rat): boolean {\n    return this.n === that.n && this.d === that.d\n  }\n\n  /**\n   * Returns true if this approximates the number.\n   */\n  approximates(n: number): boolean {\n    return Math.abs(+this - n) < EPSILON\n  }\n\n  /**\n   * Returns true if this is greater than that.\n   */\n  isGreaterThan(that: Rat): boolean {\n    return this.n * that.d > that.n * this.d\n  }\n\n  /**\n   * Returns true if this is less than that.\n   */\n  isLessThan(that: Rat): boolean {\n    return this.n * that.d < that.n * this.d\n  }\n\n  /**\n   * Absolute value of this.\n   */\n  abs(): Rat {\n    const r = this.clone()\n    if (r.n < 0) r.n = -r.n\n    return r\n  }\n\n  /**\n   * Opposite (negative) of this.\n   */\n  neg(): Rat {\n    const r = this.clone()\n    r.n = -r.n\n    return r\n  }\n\n  /**\n   * Returns true if this is less than zero.\n   */\n  isNegative(): boolean {\n    return this.n < 0\n  }\n\n  /**\n   * Returns true if this is a finite number.\n   */\n  isFinite(): boolean {\n    return this.d !== 0n\n  }\n\n  /**\n   * The reciprocal, or multiplicative inverse, of this.\n   */\n  inv(): Rat {\n    return new Rat(this.d, this.n)\n  }\n\n  /**\n   * Square root of this.\n   */\n  sqrt(): Rat {\n    return this.root(2)\n  }\n\n  /**\n   * Returns the nth root, a number which approximates this when multiplied by itself n times.\n   */\n  root(n: number): Rat {\n    // Handle 0/±1, ±1/0, 0/0, ±1/1\n    if (this.n === 0n || this.d === 0n || this.n === this.d) {\n      return this.clone()\n    }\n\n    if (this.isNegative()) {\n      throw `Roots of negative numbers like ${this.toString()} are too complex for this basic library`\n    }\n\n    return floatToRat(Math.pow(+this, 1 / n))\n    // return functionToRat(r => r.pow(n), +this)\n  }\n\n  /**\n   * Return the closest integer approximation.\n   */\n  round(): bigint {\n    return BigInt(Math.round(+this))\n  }\n\n  /**\n   * Returns the largest integer equal to or smaller than.\n   */\n  floor(): bigint {\n    return BigInt(Math.floor(+this))\n  }\n\n  /**\n   * Returns the smallest integer equal to or greater than.\n   */\n  ceil(): bigint {\n    return BigInt(Math.ceil(+this))\n  }\n\n  /**\n   * Parametric sine: 2t / (1 + t²)\n   * @see https://youtu.be/Ui8OvmzDn7o?t=245\n   */\n  psin(): Rat {\n    if (this.d === 0n) return new Rat(0n)\n    const one = new Rat(1)\n    const two = new Rat(2)\n    const n = two.mul(this)\n    const d = one.add(this.pow(two))\n    return n.div(d)\n  }\n\n  /**\n   * Parametric cosine: (1 - t²) / (1 + t²)\n   */\n  pcos(): Rat {\n    if (this.d === 0n) return new Rat(-1n)\n    const one = new Rat(1)\n    const two = new Rat(2)\n    const t2 = this.pow(two)\n    const n = one.sub(t2)\n    const d = one.add(t2)\n    return n.div(d)\n  }\n\n  /**\n   * Parametric tangent: psin() / pcos()\n   */\n  ptan(): Rat {\n    return this.psin().div(this.pcos())\n  }\n\n  /**\n   * Mixed fraction as a string.\n   */\n  mixedFractionString(): string {\n    const integerPart = this.isNegative() ? this.ceil() : this.floor()\n    const fractionPart = this.sub(new Rat(integerPart)).toString()\n    return integerPart ? `${integerPart} + ${fractionPart}` : fractionPart\n  }\n\n  /**\n   * Returns the integers representing the continued fraction.\n   */\n  *continuedFraction(): Generator<number> {\n    if (this.n === 0n || this.d === 0n) {\n      yield +this\n    } else {\n      for (const n of continuedFraction(+this)) {\n        yield n\n      }\n    }\n  }\n\n  /**\n   * Continued fraction as a string.\n   */\n  continuedFractionString(): string {\n    const a: string[] = []\n    for (const r of this.continuedFraction()) {\n      a.push(r.toString())\n    }\n    const n = a.shift()\n    if (n !== undefined && this.d !== 0n) {\n      let s = n.toString()\n      if (a.length) {\n        s += `; ${  a.join(', ')}`\n      }\n      return `[${s}]`\n    }\n    return '[]'\n  }\n\n  /**\n   * Returns an array of the prime factors with their exponents.\n   */\n  primeFactorization(): Array<[bigint, bigint]> {\n    const f: Array<[bigint, bigint]> = []\n    if (this.n !== 1n) {\n      f.push(...primeFactors(this.n))\n    }\n    if (this.d !== 1n) {\n      f.push(\n        ...primeFactors(this.d).map((f) => {\n          f[1] = -f[1]\n          return f\n        }),\n      )\n    }\n    return f.sort((a, b) => {\n      return Number(a[0] - b[0])\n    })\n  }\n\n  /**\n   * Prime factorization as a calc string.\n   */\n  primeFactorizationString(): string {\n    const a: string[] = []\n    for (const p of this.primeFactorization()) {\n      a.push(p[1] === 1n ? p[0].toString() : `${p[0]}^${p[1]}`)\n    }\n    return a.join(' * ')\n  }\n\n  /**\n   * A list of unit fractions which add up to this number.\n   */\n  egyptianFraction(): Array<Rat> {\n    const r: Rat[] = []\n    const f = new Rat(1n)\n    let t = this.clone()\n\n    // start with the integer part if non-zero\n    const integerPart = this.floor()\n    if (integerPart) {\n      const integerRat = new Rat(integerPart)\n      r.push(integerRat)\n      t = t.sub(integerRat)\n    }\n\n    if (t.n === 0n) {\n      return r\n    }\n\n    // increment the denominator of f, substracting it from t when bigger, until t has a numerator of 1\n    while (t.n !== 1n) {\n      f.d++\n      if (t.isGreaterThan(f)) {\n        r.push(f.clone())\n        t = t.sub(f)\n      }\n    }\n\n    // include the final t\n    r.push(t)\n\n    return r\n  }\n\n  /**\n   * Egyptian fraction as a calc string.\n   */\n  egyptianFractionString(): string {\n    return this.egyptianFraction().join(' + ')\n  }\n\n  /**\n   * A dictionary with the exponents of 60 and their coefficents, which add up to this number.\n   */\n  babylonianFraction(): Array<string> {\n    const a: string[] = []\n    let n = Number(this.floor())\n    let r = Math.abs(+this - n)\n    let d = 0\n    // consume increasing powers until the integer part is divided\n    for (let p = 0; n > 0; p++) {\n      d = n % 60\n      if (d !== 0) {\n        a.unshift(`${d} * 60^${p}`)\n      }\n      n = (n - d) / 60\n    }\n    // consume decreasing powers until the remainder is accumulated\n    // @todo use a more precise calculation to get rid of this abhorrent epsilon\n    for (let p = -1; r > 1e-10; p--) {\n      r *= 60\n      d = Math.floor(r)\n      r -= d\n      if (d !== 0) {\n        a.push(`${d} * 60^${p}`)\n      }\n      n = (n - d) / 60\n    }\n    return a\n  }\n\n  /**\n   * Babylonian fraction as a calc string.\n   */\n  babylonianFractionString(): string {\n    const a: string[] = []\n    const f = this.babylonianFraction()\n    for (const i of f) {\n      a.push(`${i}`)\n    }\n    return a.join(' + ')\n  }\n}\n\n/**\n * Find a Rat approximation of the floating point number.\n */\nexport const floatToRat = (n: number): Rat => {\n  // Handle special values: 0/0, 1/0, -1/0\n  if (isNaN(n)) return new Rat(0, 0)\n  if (n === Infinity) return new Rat(1, 0)\n  if (n === -Infinity) return new Rat(-1, 0)\n\n  // Shortcut for numbers close to an integer or 1/integer\n  if (Math.abs(n % 1) < EPSILON) return new Rat(Math.round(n))\n  if (Math.abs((1 / n) % 1) < EPSILON) return new Rat(1, Math.round(1 / n))\n\n  // Traverse the Stern–Brocot tree until a good approximation is found\n  // If negative, search for the positive value and negate the result\n  const negative = n < 1\n  const r = rationalApproximation(Math.abs(n))\n  return negative ? r.neg() : r\n}\n\n/**\n * Parse the string for a numeric value and return it as a Rat.\n */\nexport const parseRat = (s: string): Rat => {\n  // Handle special values: 0/0, 1/0, -1/0\n  if (s === 'NaN') return new Rat(0, 0)\n  if (s === 'Infinity') return new Rat(1, 0)\n  if (s === '-Infinity') return new Rat(-1, 0)\n\n  const [n, d] = s.split('/', 2)\n  if (d === undefined) {\n    return floatToRat(Number(n))\n  }\n  return new Rat(BigInt(n ?? 1), BigInt(d))\n}\n\n/**\n * Pi, an approximation of the ratio between a circle's circumference and it's diameter.\n */\n// export const π = new Rat(3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587n, 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n)\n\nexport default Rat\n","import { MAX_LOOPS } from './config'\nimport Rat from './Rat'\n\n/**\n * Find the rational number that best approximates the floating point number.\n */\nexport function rationalApproximation(n: number): Rat {\n  let m0 = 1n,\n    m1 = 0n,\n    m2 = 0n,\n    m3 = 1n\n  const r = new Rat(1n)\n  for (let i = 0; i < MAX_LOOPS; i++) {\n    if (r.approximates(n)) break\n    if (+r > n) {\n      m0 += m1\n      m2 += m3\n    } else {\n      m1 += m0\n      m3 += m2\n    }\n    r.n = m0 + m1\n    r.d = m2 + m3\n  }\n  return r\n}\n\n/**\n * Yield false for each left and true for each right.\n */\nexport function* pathToValue(n: number): Generator<boolean> {\n  let m0 = 1n,\n    m1 = 0n,\n    m2 = 0n,\n    m3 = 1n\n  const r = new Rat(1n)\n  for (let i = 0; i < MAX_LOOPS; i++) {\n    if (r.approximates(n)) break\n    const direction = n > +r\n    yield direction\n    if (!direction) {\n      m0 += m1\n      m2 += m3\n    } else {\n      m1 += m0\n      m3 += m2\n    }\n    r.n = m0 + m1\n    r.d = m2 + m3\n  }\n}\n\n/**\n * Yield the values of the continued fraction, ie. the length of runs left/right.\n */\nexport function* continuedFraction(n: number): Generator<number> {\n  let last = true\n  let run = 0\n  for (const direction of pathToValue(n)) {\n    if (direction === last) {\n      run++\n    } else {\n      yield run\n      run = 1\n      last = direction\n    }\n  }\n  yield run + 1\n}\n","/**\n * @class Symbolizer\n * @name Symbolizer\n */\nexport class Symbolizer {\n  symbols: string[] = []\n\n  /**\n   * Initialize a symbolizer.\n   */\n  constructor(symbols?: string) {\n    if (symbols) this.symbols = symbols.split('')\n  }\n\n  /**\n   * Symbol generator.\n   */\n  *generator(): Generator<string> {\n    for (let i = 0; ; i++) {\n      if (i < this.symbols.length) {\n        yield this.symbols[i] ?? '?'\n      } else {\n        yield String.fromCharCode(945 + i - this.symbols.length)\n      }\n    }\n  }\n}\n\nexport default Symbolizer\n","import { Rat } from './Rat'\nimport Symbolizer from './Symbolizer'\n\nexport interface Coefficents {\n  [Key: string]: bigint\n}\n\n/**\n * @class Rational polynumber\n * @name Polyrat\n */\nexport class Polyrat {\n  // coefficent values are indexed with their the exponents in each dimension, comma-separated, as the key\n  coefficents: Coefficents = {}\n\n  // the dimension is how many params there are, defined by the length of the exponent keys\n  dimension = 0\n\n  // unique symbols for each dimension\n  latinSymbols = ''\n  greekSymbols = ''\n\n  /**\n   * Initialize a rational polynumber.\n   */\n  constructor(coefficents?: Coefficents) {\n    if (coefficents) {\n      this.coefficents = coefficents\n    }\n    if (Object.keys(this.coefficents).length) {\n      const ck = Object.keys(this.coefficents)\n      this.dimension = ck[0] ? ck[0].split(',').length : 0\n    }\n    const lsg = new Symbolizer('xyzw').generator()\n    for (let i = 0; i < this.dimension; i++) {\n      this.latinSymbols += lsg.next().value\n    }\n    const gsg = new Symbolizer().generator()\n    for (let i = 0; i < this.dimension; i++) {\n      this.greekSymbols += gsg.next().value\n    }\n  }\n\n  /**\n   * Evaluate the result given the parameters for each dimension.\n   */\n  evaluate(parameters: Rat[]): Rat {\n    let result: Rat = new Rat()\n    for (const [exponents, coefficent] of Object.entries(this.coefficents)) {\n      let value: Rat = new Rat(coefficent)\n      const dimensions = exponents.split(',')\n      for (let i = 0; i < dimensions.length; i++) {\n        if (i in parameters) {\n          const base = parameters[i] ?? new Rat(1)\n          const dimension = parseInt(dimensions[i] ?? '1', 10)\n          value = value.mul(base.pow(new Rat(dimension)))\n        }\n      }\n      result = result.add(value)\n    }\n    return result\n  }\n\n  /**s\n   * The text representation.\n   */\n  toString(): string {\n    return `${this.constructor.name}(${this.toJSON()})`\n  }\n\n  /**\n   * The JSON representation.\n   */\n  toJSON(): string {\n    // return JSON.stringify(this.coefficents)\n    const r = []\n    for (const [exponents, coefficent] of Object.entries(this.coefficents)) {\n      r.push(`\"${exponents}\":\"${coefficent.toString()}\"`)\n    }\n    return `{${r.join(',')}}`\n  }\n\n  /**\n   * The formula in the human way with exponents as HTML sups.\n   */\n  toHTMLFormula(): string {\n    const r: string[] = []\n    for (const [exponents, coefficent] of Object.entries(this.coefficents)) {\n      const t: string[] = []\n      const f = coefficent.toString()\n      if (f !== '1') t.push(f)\n      const dimensions = exponents.split(',')\n      for (let i = 0; i < dimensions.length; i++) {\n        if (dimensions[i] !== '0') {\n          if (dimensions[i] === '1') {\n            t.push(this.latinSymbols[i] ?? '?')\n          } else {\n            t.push(\n              `${this.latinSymbols[i] ?? '?'}<sup>${parseInt(\n                dimensions[i] ?? '?',\n                10,\n              )}</sup>`,\n            )\n          }\n        }\n      }\n      if (t) r.push(t.join(''))\n    }\n    if (r.length === 0) return '0'\n    return r.join(' + ')\n  }\n\n  /**\n   * The formula in the standard alpha form as HTML.\n   */\n  toStandardAlphaFormHTML(): string {\n    const rn: string[] = []\n    const rd: string[] = []\n    if (!Object.keys(this.coefficents).length) return '0'\n    for (const [exponents, coefficent] of Object.entries(this.coefficents)) {\n      const tn: string[] = []\n      const td: string[] = []\n      const f = coefficent.toString()\n      if (f !== '1') tn.push(f)\n      const dimensions = exponents.split(',')\n      for (let i = 0; i < dimensions.length; i++) {\n        if (dimensions[i] !== '0') {\n          if (dimensions[i] === '1') {\n            tn.push(this.greekSymbols[i] ?? '?')\n          } else {\n            const exponent = parseInt(dimensions[i] ?? '0', 10)\n            if (exponent > 0) {\n              tn.push(`${this.greekSymbols[i] ?? '?'}<sup>${exponent}</sup>`)\n            } else if (exponent === -1) {\n              td.push(this.greekSymbols[i] ?? '?')\n            } else {\n              td.push(`${this.greekSymbols[i] ?? '?'}<sup>${-exponent}</sup>`)\n            }\n          }\n        }\n      }\n      if (tn.length) rn.push(tn.join(''))\n      if (td.length) rd.push(td.join(''))\n    }\n    if (rn.length === 0) rn.push('1')\n    if (rd.length === 0) return rn.join(' + ')\n    return `${rn.join(' + ')  } / ${  rd.join(' + ')}`\n  }\n\n  /**\n   * The \"calc\" code for evaluating the value.\n   */\n  toCalcFormula(): string {\n    const r: string[] = []\n    for (const [exponents, coefficent] of Object.entries(this.coefficents)) {\n      const t: string[] = []\n      const f = coefficent.toString()\n      if (f !== '1') t.push(f)\n      const dimensions = exponents.split(',')\n      for (let i = 0; i < dimensions.length; i++) {\n        if (dimensions[i] !== '0') {\n          if (dimensions[i] === '1') {\n            t.push(this.latinSymbols[i] ?? '?')\n          } else {\n            t.push(\n              `${this.latinSymbols[i] ?? '?'}^${parseInt(\n                dimensions[i] ?? '0',\n                10,\n              )}`,\n            )\n          }\n        }\n      }\n      if (t.length) r.push(t.join('*'))\n    }\n    if (r.length === 0) return '0'\n    return r.join(' + ')\n  }\n\n  /**\n   * The GLSL code for evaluating the value.\n   */\n  toGLSLFormula(): string {\n    const r: string[] = []\n    for (const [exponents, coefficent] of Object.entries(this.coefficents)) {\n      const t: string[] = []\n      const f = coefficent.toString()\n      if (f !== '1') t.push(`${f  }.0`)\n      const dimensions = exponents.split(',')\n      for (let i = 0; i < dimensions.length; i++) {\n        if (dimensions[i] !== '0') {\n          let exponent = parseInt(dimensions[i] ?? '0', 10)\n          const recipricol = exponent < 0\n          // pow doesn't work for < 0\n          // t.push(`pow(${this.symbols[i]},${exponent}.0)`)\n          // muliply instead\n          if (recipricol) {\n            t.push('1.0/(1.0')\n            exponent = -exponent\n          }\n          t.push(\n            (this.latinSymbols[i] ?? '?').repeat(exponent).split('').join('*'),\n          )\n          if (recipricol) {\n            t.push('1.0)')\n          }\n        }\n      }\n      if (t.length) r.push(t.join('*'))\n    }\n    if (r.length === 0) return '0.0'\n    return r.join('+')\n  }\n\n  /**\n   * Clone this.\n   */\n  clone(): Polyrat {\n    return new Polyrat(this.coefficents)\n  }\n}\n\n/**\n * Parse the string and return it as a Polyrat.\n */\nexport const stringToPolyrat = (s: string): Polyrat => {\n  return new Polyrat(JSON.parse(s) as Coefficents)\n}\n\nexport default Polyrat\n","import VERSION from './version'\nimport Lexer from './Lexer'\nimport Parser from './Parser'\n\nclass cnum {\n  static get version(): string {\n    return VERSION\n  }\n  static evaluate(expression: string): string {\n    const lexer = new Lexer(expression)\n    const parser = new Parser(lexer.lex())\n    return parser.toString()\n  }\n}\n\nexport default cnum\nexport { Rat, floatToRat, parseRat } from './Rat'\nexport { Polyrat } from './Polyrat'\n"],"names":["VERSION","Token","constructor","type","s","this","toString","OPERATORS","input","lex","onSpace","onInteger","onOperator","buffer","i","length","_this$s$i","exec","char","onWord","Parser","tokens","identifiers","evaluate","n","x","_this$identifiers$x$s","BigInt","isPrime","primes","e","p","f","push","Rat","numerator","denominator","d","normalize","valueOf","Number","profile","mixedFractionString","continuedFractionString","primeFactorizationString","egyptianFractionString","babylonianFractionString","psin","pcos","ptan","join","clone","divisor","a","b","t","gcd","add","that","r","sub","neg","mul","div","mediant","min","isLessThan","max","isGreaterThan","pow","estimate","Math","floatToRat","dot","equals","approximates","abs","isNegative","isFinite","inv","sqrt","root","round","floor","ceil","one","two","t2","integerPart","fractionPart","continuedFraction","last","run","direction","pathToValue","m0","m1","m2","m3","shift","undefined","primeFactorization","primeFactors","map","sort","egyptianFraction","integerRat","babylonianFraction","unshift","isNaN","Infinity","negative","rationalApproximation","parseRat","split","Symbolizer","symbols","generator","_this$symbols$i","fromCharCode","Polyrat","coefficents","dimension","latinSymbols","greekSymbols","Object","keys","ck","lsg","next","value","gsg","parameters","exponents","coefficent","entries","dimensions","base","_parameters$i","parseInt","_dimensions$i","result","name","toJSON","toHTMLFormula","_this$latinSymbols$i","_this$latinSymbols$i2","_dimensions$i2","toStandardAlphaFormHTML","tn","td","_this$greekSymbols$i","_dimensions$i3","exponent","_this$greekSymbols$i2","_this$greekSymbols$i3","_this$greekSymbols$i4","rn","rd","toCalcFormula","_this$latinSymbols$i3","_this$latinSymbols$i4","_dimensions$i4","toGLSLFormula","recipricol","_this$latinSymbols$i5","repeat","stringToPolyrat","JSON","parse","cnum","version","static","expression","lexer","Lexer"],"mappings":"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"}