continuedfraction.js 0.0.2 → 0.1.0

package/dist/continuedfraction.mjs

@@ -1,177 +1,960 @@
-'use strict';
-import Fraction from 'fraction.js';
-
-
-
-/**
- * Utility class for generating continued-fraction expansions of various constants.
- */
-const ContinuedFraction = {
-
-    /**
-     * Infinite generator for the continued-fraction terms of sqrt(N).
-     *   √N = [a0; (a1, a2, ..., a_p)], where the period ends when ak = 2*a0.
-     * For perfect squares, yields only a0 = floor(sqrt(N)) and then returns.
-     *
-     * @param {number} N - Integer whose square root CF expansion is desired (N ≥ 0).
-     * @yields {number} - Next continued-fraction term of √N.
-     */
-    "sqrt": function* (N) {
-
-        const a0 = Math.floor(Math.sqrt(N));
-        yield a0;
-        if (a0 * a0 === N) return; // perfect square: single-term CF
-
-        //while (true) {
-        let nk = 0;
-        let dk = 1;
-        let ak = a0;
-
-        do {
-            nk = ak * dk - nk;
-            dk = (N - nk * nk) / dk; // remains integer by construction
-            ak = Math.floor((a0 + nk) / dk);
-            yield ak;
-        } while (/* 2 * a0 !== ak */ true);
-        //}
-    },
-
-    /**
-     * Generator for continued-fraction terms of any real number via Fraction.js.
-     *
-     * @exports
-     * @param {number|string|BigInt} n - The real number to convert (as number or string).
-     * @yields {number} - Next continued-fraction term of n.
-     */
-    "fromNumber": function* (n) {
-
-        yield* Fraction(n)['toContinued']();
-    },
-
-    /**
-     * Generator for continued-fraction terms of a rational a/b via Fraction.js.
-     *
-     * @param {number|string|BigInt|Fraction} a - Numerator.
-     * @param {number|string|BigInt} b - Denominator.
-     * @yields {number} - Next continued-fraction term of a/b.
-     */
-    "fromFraction": function* (a, b) {
-
-        yield* Fraction(a, b)['toContinued']();
-    },
-
-    /**
-     * Infinite generator of the golden ratio φ = [1; 1, 1, 1, …].
-     *
-     * @yields {number} - Always 1.
-     */
-    "PHI": function* () {
-
-        while (true) {
-            yield 1;
-        }
-    },
-
-    /**
-     * Infinite generator for Continued‐fraction terms of 4/π:
-     *   4/π = 1 + 1²/(3 + 2²/(5 + 3²/(7 + …)))
-     * @yields {{a:number,b:number}} - Term pair (aₙ, bₙ) of the generalized continued fraction.
-     *   - first: a₀ = 1
-     *   - then: aₙ = 2n+1, bₙ = n²  (n ≥ 1)
-     */
-    "FOUR_OVER_PI": function* () {
-
-        yield { "a": 1, "b": 0 }; // a₀ = 1
-
-        for (let n = 0; true; n++) {
-            yield { "a": 2, "b": (n * 2 + 1) ** 2 };
-        }
-    },
-
-    /**
-     * Infinite generator for Continued‐fraction terms of π:
-     *   π = 3 + 1²/(6 + 3²/(6 + 5²/(6 + …)))
-     * @yields {{a:number,b:number}} - Term pair (aₙ, bₙ) of the generalized continued fraction.
-     *   - first: a₀ = 3
-     *   - then: aₙ = 6, bₙ = (2n-1)²  (n ≥ 1)
-     */
-    "PI": function* () {
-
-        yield { "a": 3, "b": 0 }; // a₀ = 3
-
-        for (let n = 1; true; n++) {
-            yield { "a": 6, "b": (n * 2 - 1) ** 2 };
-        }
-    },
-
-    /**
-     * Infinite generator of e = [2; 1, 2, 1, 1, 4, 1, …].
-     * Terms follow the pattern [2; (1,2m,1) for m = 1,2,3,…].
-     *
-     * @yields {number} - Next continued-fraction term of e.
-     */
-    "E": function* () {
-
-        yield 2; // a₀ = 2
-
-        for (let m = 1; ; m++) {
-            yield 1;
-            yield 2 * m;
-            yield 1;
-        }
-
-        /* Alternative:
-        yield { a: 2, b: 0 }; // a₀ = 2
-        yield { a: 1, b: 1 }; // a₁ = 1
-
-        for (let m = 2; ; m++) {
-            yield { a: n, b: m - 1 };
-        }
-        */
-    },
-
-    /**
-     * Evaluate a (simple or generalized) continued fraction generator.
-     * For generalized: terms are objects { a, b }, else regular numbers.
-     * 
-     * @param {Generator|Function} generator - Continued fraction term generator.
-     * @param {number} steps - Number of terms to evaluate.
-     * @returns {Fraction} - Rational approximation as Fraction.
-     */
-    "eval": function (generator, steps = 10) {
-
-        if (typeof generator === "function") {
-            generator = generator();
+// node_modules/fraction.js/dist/fraction.mjs
+if (typeof BigInt === "undefined") BigInt = function(n) {
+  if (isNaN(n)) throw new Error("");
+  return n;
+};
+var C_ZERO = BigInt(0);
+var C_ONE = BigInt(1);
+var C_TWO = BigInt(2);
+var C_FIVE = BigInt(5);
+var C_TEN = BigInt(10);
+var MAX_CYCLE_LEN = 2e3;
+var P = {
+  "s": C_ONE,
+  "n": C_ZERO,
+  "d": C_ONE
+};
+function assign(n, s) {
+  try {
+    n = BigInt(n);
+  } catch (e) {
+    throw InvalidParameter();
+  }
+  return n * s;
+}
+function trunc(x) {
+  return typeof x === "bigint" ? x : Math.floor(x);
+}
+function newFraction(n, d) {
+  if (d === C_ZERO) {
+    throw DivisionByZero();
+  }
+  const f = Object.create(Fraction.prototype);
+  f["s"] = n < C_ZERO ? -C_ONE : C_ONE;
+  n = n < C_ZERO ? -n : n;
+  const a = gcd(n, d);
+  f["n"] = n / a;
+  f["d"] = d / a;
+  return f;
+}
+function factorize(num) {
+  const factors = {};
+  let n = num;
+  let i = C_TWO;
+  let s = C_FIVE - C_ONE;
+  while (s <= n) {
+    while (n % i === C_ZERO) {
+      n /= i;
+      factors[i] = (factors[i] || C_ZERO) + C_ONE;
+    }
+    s += C_ONE + C_TWO * i++;
+  }
+  if (n !== num) {
+    if (n > 1)
+      factors[n] = (factors[n] || C_ZERO) + C_ONE;
+  } else {
+    factors[num] = (factors[num] || C_ZERO) + C_ONE;
+  }
+  return factors;
+}
+var parse = function(p1, p2) {
+  let n = C_ZERO, d = C_ONE, s = C_ONE;
+  if (p1 === void 0 || p1 === null) {
+  } else if (p2 !== void 0) {
+    if (typeof p1 === "bigint") {
+      n = p1;
+    } else if (isNaN(p1)) {
+      throw InvalidParameter();
+    } else if (p1 % 1 !== 0) {
+      throw NonIntegerParameter();
+    } else {
+      n = BigInt(p1);
+    }
+    if (typeof p2 === "bigint") {
+      d = p2;
+    } else if (isNaN(p2)) {
+      throw InvalidParameter();
+    } else if (p2 % 1 !== 0) {
+      throw NonIntegerParameter();
+    } else {
+      d = BigInt(p2);
+    }
+    s = n * d;
+  } else if (typeof p1 === "object") {
+    if ("d" in p1 && "n" in p1) {
+      n = BigInt(p1["n"]);
+      d = BigInt(p1["d"]);
+      if ("s" in p1)
+        n *= BigInt(p1["s"]);
+    } else if (0 in p1) {
+      n = BigInt(p1[0]);
+      if (1 in p1)
+        d = BigInt(p1[1]);
+    } else if (typeof p1 === "bigint") {
+      n = p1;
+    } else {
+      throw InvalidParameter();
+    }
+    s = n * d;
+  } else if (typeof p1 === "number") {
+    if (isNaN(p1)) {
+      throw InvalidParameter();
+    }
+    if (p1 < 0) {
+      s = -C_ONE;
+      p1 = -p1;
+    }
+    if (p1 % 1 === 0) {
+      n = BigInt(p1);
+    } else {
+      let z = 1;
+      let A = 0, B = 1;
+      let C = 1, D = 1;
+      let N = 1e7;
+      if (p1 >= 1) {
+        z = 10 ** Math.floor(1 + Math.log10(p1));
+        p1 /= z;
+      }
+      while (B <= N && D <= N) {
+        let M = (A + C) / (B + D);
+        if (p1 === M) {
+          if (B + D <= N) {
+            n = A + C;
+            d = B + D;
+          } else if (D > B) {
+            n = C;
+            d = D;
+          } else {
+            n = A;
+            d = B;
+          }
+          break;
+        } else {
+          if (p1 > M) {
+            A += C;
+            B += D;
+          } else {
+            C += A;
+            D += B;
+          }
+          if (B > N) {
+            n = C;
+            d = D;
+          } else {
+            n = A;
+            d = B;
+          }
         }
-
-        // pull off a₀ (with its b₀)
-        const first = generator['next']();
-        if (first['done']) return Fraction(0);
-
-        const a0 = Fraction(first['value']['a'] ?? first['value']);
-
-        // initialize convergents p₋₁/q₋₁ = 1/0, p₀/q₀ = a₀/1
-        let pCurr = a0, qCurr = Fraction(1);
-        let pPrev = Fraction(1), qPrev = Fraction(0);
-
-        // run through a₁… up to `steps-1` more
-        for (let k = 1; k < steps; k++) {
-            const { value, done } = generator['next']();
-            if (done) break;
-
-            const ak = Fraction(value['a'] ?? value),
-                bk = Fraction(value['b'] ?? 1);
-
-            // pₖ = aₖ·pₖ₋₁ + bₖ·pₖ₋₂
-            // qₖ = aₖ·qₖ₋₁ + bₖ·qₖ₋₂
-            [pPrev, pCurr] = [pCurr, ak['mul'](pCurr)['add'](bk['mul'](pPrev))];
-            [qPrev, qCurr] = [qCurr, ak['mul'](qCurr)['add'](bk['mul'](qPrev))];
+      }
+      n = BigInt(n) * BigInt(z);
+      d = BigInt(d);
+    }
+  } else if (typeof p1 === "string") {
+    let ndx = 0;
+    let v = C_ZERO, w = C_ZERO, x = C_ZERO, y = C_ONE, z = C_ONE;
+    let match = p1.replace(/_/g, "").match(/\d+|./g);
+    if (match === null)
+      throw InvalidParameter();
+    if (match[ndx] === "-") {
+      s = -C_ONE;
+      ndx++;
+    } else if (match[ndx] === "+") {
+      ndx++;
+    }
+    if (match.length === ndx + 1) {
+      w = assign(match[ndx++], s);
+    } else if (match[ndx + 1] === "." || match[ndx] === ".") {
+      if (match[ndx] !== ".") {
+        v = assign(match[ndx++], s);
+      }
+      ndx++;
+      if (ndx + 1 === match.length || match[ndx + 1] === "(" && match[ndx + 3] === ")" || match[ndx + 1] === "'" && match[ndx + 3] === "'") {
+        w = assign(match[ndx], s);
+        y = C_TEN ** BigInt(match[ndx].length);
+        ndx++;
+      }
+      if (match[ndx] === "(" && match[ndx + 2] === ")" || match[ndx] === "'" && match[ndx + 2] === "'") {
+        x = assign(match[ndx + 1], s);
+        z = C_TEN ** BigInt(match[ndx + 1].length) - C_ONE;
+        ndx += 3;
+      }
+    } else if (match[ndx + 1] === "/" || match[ndx + 1] === ":") {
+      w = assign(match[ndx], s);
+      y = assign(match[ndx + 2], C_ONE);
+      ndx += 3;
+    } else if (match[ndx + 3] === "/" && match[ndx + 1] === " ") {
+      v = assign(match[ndx], s);
+      w = assign(match[ndx + 2], s);
+      y = assign(match[ndx + 4], C_ONE);
+      ndx += 5;
+    }
+    if (match.length <= ndx) {
+      d = y * z;
+      s = /* void */
+      n = x + d * v + z * w;
+    } else {
+      throw InvalidParameter();
+    }
+  } else if (typeof p1 === "bigint") {
+    n = p1;
+    s = p1;
+    d = C_ONE;
+  } else {
+    throw InvalidParameter();
+  }
+  if (d === C_ZERO) {
+    throw DivisionByZero();
+  }
+  P["s"] = s < C_ZERO ? -C_ONE : C_ONE;
+  P["n"] = n < C_ZERO ? -n : n;
+  P["d"] = d < C_ZERO ? -d : d;
+};
+function modpow(b, e, m) {
+  let r = C_ONE;
+  for (; e > C_ZERO; b = b * b % m, e >>= C_ONE) {
+    if (e & C_ONE) {
+      r = r * b % m;
+    }
+  }
+  return r;
+}
+function cycleLen(n, d) {
+  for (; d % C_TWO === C_ZERO; d /= C_TWO) {
+  }
+  for (; d % C_FIVE === C_ZERO; d /= C_FIVE) {
+  }
+  if (d === C_ONE)
+    return C_ZERO;
+  let rem = C_TEN % d;
+  let t = 1;
+  for (; rem !== C_ONE; t++) {
+    rem = rem * C_TEN % d;
+    if (t > MAX_CYCLE_LEN)
+      return C_ZERO;
+  }
+  return BigInt(t);
+}
+function cycleStart(n, d, len) {
+  let rem1 = C_ONE;
+  let rem2 = modpow(C_TEN, len, d);
+  for (let t = 0; t < 300; t++) {
+    if (rem1 === rem2)
+      return BigInt(t);
+    rem1 = rem1 * C_TEN % d;
+    rem2 = rem2 * C_TEN % d;
+  }
+  return 0;
+}
+function gcd(a, b) {
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  while (1) {
+    a %= b;
+    if (!a)
+      return b;
+    b %= a;
+    if (!b)
+      return a;
+  }
+}
+function Fraction(a, b) {
+  parse(a, b);
+  if (this instanceof Fraction) {
+    a = gcd(P["d"], P["n"]);
+    this["s"] = P["s"];
+    this["n"] = P["n"] / a;
+    this["d"] = P["d"] / a;
+  } else {
+    return newFraction(P["s"] * P["n"], P["d"]);
+  }
+}
+var DivisionByZero = function() {
+  return new Error("Division by Zero");
+};
+var InvalidParameter = function() {
+  return new Error("Invalid argument");
+};
+var NonIntegerParameter = function() {
+  return new Error("Parameters must be integer");
+};
+Fraction.prototype = {
+  "s": C_ONE,
+  "n": C_ZERO,
+  "d": C_ONE,
+  /**
+   * Calculates the absolute value
+   *
+   * Ex: new Fraction(-4).abs() => 4
+   **/
+  "abs": function() {
+    return newFraction(this["n"], this["d"]);
+  },
+  /**
+   * Inverts the sign of the current fraction
+   *
+   * Ex: new Fraction(-4).neg() => 4
+   **/
+  "neg": function() {
+    return newFraction(-this["s"] * this["n"], this["d"]);
+  },
+  /**
+   * Adds two rational numbers
+   *
+   * Ex: new Fraction({n: 2, d: 3}).add("14.9") => 467 / 30
+   **/
+  "add": function(a, b) {
+    parse(a, b);
+    return newFraction(
+      this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"],
+      this["d"] * P["d"]
+    );
+  },
+  /**
+   * Subtracts two rational numbers
+   *
+   * Ex: new Fraction({n: 2, d: 3}).add("14.9") => -427 / 30
+   **/
+  "sub": function(a, b) {
+    parse(a, b);
+    return newFraction(
+      this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"],
+      this["d"] * P["d"]
+    );
+  },
+  /**
+   * Multiplies two rational numbers
+   *
+   * Ex: new Fraction("-17.(345)").mul(3) => 5776 / 111
+   **/
+  "mul": function(a, b) {
+    parse(a, b);
+    return newFraction(
+      this["s"] * P["s"] * this["n"] * P["n"],
+      this["d"] * P["d"]
+    );
+  },
+  /**
+   * Divides two rational numbers
+   *
+   * Ex: new Fraction("-17.(345)").inverse().div(3)
+   **/
+  "div": function(a, b) {
+    parse(a, b);
+    return newFraction(
+      this["s"] * P["s"] * this["n"] * P["d"],
+      this["d"] * P["n"]
+    );
+  },
+  /**
+   * Clones the actual object
+   *
+   * Ex: new Fraction("-17.(345)").clone()
+   **/
+  "clone": function() {
+    return newFraction(this["s"] * this["n"], this["d"]);
+  },
+  /**
+   * Calculates the modulo of two rational numbers - a more precise fmod
+   *
+   * Ex: new Fraction('4.(3)').mod([7, 8]) => (13/3) % (7/8) = (5/6)
+   * Ex: new Fraction(20, 10).mod().equals(0) ? "is Integer"
+   **/
+  "mod": function(a, b) {
+    if (a === void 0) {
+      return newFraction(this["s"] * this["n"] % this["d"], C_ONE);
+    }
+    parse(a, b);
+    if (C_ZERO === P["n"] * this["d"]) {
+      throw DivisionByZero();
+    }
+    return newFraction(
+      this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]),
+      P["d"] * this["d"]
+    );
+  },
+  /**
+   * Calculates the fractional gcd of two rational numbers
+   *
+   * Ex: new Fraction(5,8).gcd(3,7) => 1/56
+   */
+  "gcd": function(a, b) {
+    parse(a, b);
+    return newFraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]);
+  },
+  /**
+   * Calculates the fractional lcm of two rational numbers
+   *
+   * Ex: new Fraction(5,8).lcm(3,7) => 15
+   */
+  "lcm": function(a, b) {
+    parse(a, b);
+    if (P["n"] === C_ZERO && this["n"] === C_ZERO) {
+      return newFraction(C_ZERO, C_ONE);
+    }
+    return newFraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]));
+  },
+  /**
+   * Gets the inverse of the fraction, means numerator and denominator are exchanged
+   *
+   * Ex: new Fraction([-3, 4]).inverse() => -4 / 3
+   **/
+  "inverse": function() {
+    return newFraction(this["s"] * this["d"], this["n"]);
+  },
+  /**
+   * Calculates the fraction to some integer exponent
+   *
+   * Ex: new Fraction(-1,2).pow(-3) => -8
+   */
+  "pow": function(a, b) {
+    parse(a, b);
+    if (P["d"] === C_ONE) {
+      if (P["s"] < C_ZERO) {
+        return newFraction((this["s"] * this["d"]) ** P["n"], this["n"] ** P["n"]);
+      } else {
+        return newFraction((this["s"] * this["n"]) ** P["n"], this["d"] ** P["n"]);
+      }
+    }
+    if (this["s"] < C_ZERO) return null;
+    let N = factorize(this["n"]);
+    let D = factorize(this["d"]);
+    let n = C_ONE;
+    let d = C_ONE;
+    for (let k in N) {
+      if (k === "1") continue;
+      if (k === "0") {
+        n = C_ZERO;
+        break;
+      }
+      N[k] *= P["n"];
+      if (N[k] % P["d"] === C_ZERO) {
+        N[k] /= P["d"];
+      } else return null;
+      n *= BigInt(k) ** N[k];
+    }
+    for (let k in D) {
+      if (k === "1") continue;
+      D[k] *= P["n"];
+      if (D[k] % P["d"] === C_ZERO) {
+        D[k] /= P["d"];
+      } else return null;
+      d *= BigInt(k) ** D[k];
+    }
+    if (P["s"] < C_ZERO) {
+      return newFraction(d, n);
+    }
+    return newFraction(n, d);
+  },
+  /**
+   * Calculates the logarithm of a fraction to a given rational base
+   *
+   * Ex: new Fraction(27, 8).log(9, 4) => 3/2
+   */
+  "log": function(a, b) {
+    parse(a, b);
+    if (this["s"] <= C_ZERO || P["s"] <= C_ZERO) return null;
+    const allPrimes = {};
+    const baseFactors = factorize(P["n"]);
+    const T1 = factorize(P["d"]);
+    const numberFactors = factorize(this["n"]);
+    const T2 = factorize(this["d"]);
+    for (const prime in T1) {
+      baseFactors[prime] = (baseFactors[prime] || C_ZERO) - T1[prime];
+    }
+    for (const prime in T2) {
+      numberFactors[prime] = (numberFactors[prime] || C_ZERO) - T2[prime];
+    }
+    for (const prime in baseFactors) {
+      if (prime === "1") continue;
+      allPrimes[prime] = true;
+    }
+    for (const prime in numberFactors) {
+      if (prime === "1") continue;
+      allPrimes[prime] = true;
+    }
+    let retN = null;
+    let retD = null;
+    for (const prime in allPrimes) {
+      const baseExponent = baseFactors[prime] || C_ZERO;
+      const numberExponent = numberFactors[prime] || C_ZERO;
+      if (baseExponent === C_ZERO) {
+        if (numberExponent !== C_ZERO) {
+          return null;
         }
-
-        // final convergent = pCurr/qCurr
-        return pCurr['div'](qCurr);
+        continue;
+      }
+      let curN = numberExponent;
+      let curD = baseExponent;
+      const gcdValue = gcd(curN, curD);
+      curN /= gcdValue;
+      curD /= gcdValue;
+      if (retN === null && retD === null) {
+        retN = curN;
+        retD = curD;
+      } else if (curN * retD !== retN * curD) {
+        return null;
+      }
+    }
+    return retN !== null && retD !== null ? newFraction(retN, retD) : null;
+  },
+  /**
+   * Check if two rational numbers are the same
+   *
+   * Ex: new Fraction(19.6).equals([98, 5]);
+   **/
+  "equals": function(a, b) {
+    parse(a, b);
+    return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"];
+  },
+  /**
+   * Check if this rational number is less than another
+   *
+   * Ex: new Fraction(19.6).lt([98, 5]);
+   **/
+  "lt": function(a, b) {
+    parse(a, b);
+    return this["s"] * this["n"] * P["d"] < P["s"] * P["n"] * this["d"];
+  },
+  /**
+   * Check if this rational number is less than or equal another
+   *
+   * Ex: new Fraction(19.6).lt([98, 5]);
+   **/
+  "lte": function(a, b) {
+    parse(a, b);
+    return this["s"] * this["n"] * P["d"] <= P["s"] * P["n"] * this["d"];
+  },
+  /**
+   * Check if this rational number is greater than another
+   *
+   * Ex: new Fraction(19.6).lt([98, 5]);
+   **/
+  "gt": function(a, b) {
+    parse(a, b);
+    return this["s"] * this["n"] * P["d"] > P["s"] * P["n"] * this["d"];
+  },
+  /**
+   * Check if this rational number is greater than or equal another
+   *
+   * Ex: new Fraction(19.6).lt([98, 5]);
+   **/
+  "gte": function(a, b) {
+    parse(a, b);
+    return this["s"] * this["n"] * P["d"] >= P["s"] * P["n"] * this["d"];
+  },
+  /**
+   * Compare two rational numbers
+   * < 0 iff this < that
+   * > 0 iff this > that
+   * = 0 iff this = that
+   *
+   * Ex: new Fraction(19.6).compare([98, 5]);
+   **/
+  "compare": function(a, b) {
+    parse(a, b);
+    let t = this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"];
+    return (C_ZERO < t) - (t < C_ZERO);
+  },
+  /**
+   * Calculates the ceil of a rational number
+   *
+   * Ex: new Fraction('4.(3)').ceil() => (5 / 1)
+   **/
+  "ceil": function(places) {
+    places = C_TEN ** BigInt(places || 0);
+    return newFraction(
+      trunc(this["s"] * places * this["n"] / this["d"]) + (places * this["n"] % this["d"] > C_ZERO && this["s"] >= C_ZERO ? C_ONE : C_ZERO),
+      places
+    );
+  },
+  /**
+   * Calculates the floor of a rational number
+   *
+   * Ex: new Fraction('4.(3)').floor() => (4 / 1)
+   **/
+  "floor": function(places) {
+    places = C_TEN ** BigInt(places || 0);
+    return newFraction(
+      trunc(this["s"] * places * this["n"] / this["d"]) - (places * this["n"] % this["d"] > C_ZERO && this["s"] < C_ZERO ? C_ONE : C_ZERO),
+      places
+    );
+  },
+  /**
+   * Rounds a rational numbers
+   *
+   * Ex: new Fraction('4.(3)').round() => (4 / 1)
+   **/
+  "round": function(places) {
+    places = C_TEN ** BigInt(places || 0);
+    return newFraction(
+      trunc(this["s"] * places * this["n"] / this["d"]) + this["s"] * ((this["s"] >= C_ZERO ? C_ONE : C_ZERO) + C_TWO * (places * this["n"] % this["d"]) > this["d"] ? C_ONE : C_ZERO),
+      places
+    );
+  },
+  /**
+    * Rounds a rational number to a multiple of another rational number
+    *
+    * Ex: new Fraction('0.9').roundTo("1/8") => 7 / 8
+    **/
+  "roundTo": function(a, b) {
+    parse(a, b);
+    const n = this["n"] * P["d"];
+    const d = this["d"] * P["n"];
+    const r = n % d;
+    let k = trunc(n / d);
+    if (r + r >= d) {
+      k++;
+    }
+    return newFraction(this["s"] * k * P["n"], P["d"]);
+  },
+  /**
+   * Check if two rational numbers are divisible
+   *
+   * Ex: new Fraction(19.6).divisible(1.5);
+   */
+  "divisible": function(a, b) {
+    parse(a, b);
+    return !(!(P["n"] * this["d"]) || this["n"] * P["d"] % (P["n"] * this["d"]));
+  },
+  /**
+   * Returns a decimal representation of the fraction
+   *
+   * Ex: new Fraction("100.'91823'").valueOf() => 100.91823918239183
+   **/
+  "valueOf": function() {
+    return Number(this["s"] * this["n"]) / Number(this["d"]);
+  },
+  /**
+   * Creates a string representation of a fraction with all digits
+   *
+   * Ex: new Fraction("100.'91823'").toString() => "100.(91823)"
+   **/
+  "toString": function(dec) {
+    let N = this["n"];
+    let D = this["d"];
+    dec = dec || 15;
+    let cycLen = cycleLen(N, D);
+    let cycOff = cycleStart(N, D, cycLen);
+    let str = this["s"] < C_ZERO ? "-" : "";
+    str += trunc(N / D);
+    N %= D;
+    N *= C_TEN;
+    if (N)
+      str += ".";
+    if (cycLen) {
+      for (let i = cycOff; i--; ) {
+        str += trunc(N / D);
+        N %= D;
+        N *= C_TEN;
+      }
+      str += "(";
+      for (let i = cycLen; i--; ) {
+        str += trunc(N / D);
+        N %= D;
+        N *= C_TEN;
+      }
+      str += ")";
+    } else {
+      for (let i = dec; N && i--; ) {
+        str += trunc(N / D);
+        N %= D;
+        N *= C_TEN;
+      }
+    }
+    return str;
+  },
+  /**
+   * Returns a string-fraction representation of a Fraction object
+   *
+   * Ex: new Fraction("1.'3'").toFraction() => "4 1/3"
+   **/
+  "toFraction": function(showMixed) {
+    let n = this["n"];
+    let d = this["d"];
+    let str = this["s"] < C_ZERO ? "-" : "";
+    if (d === C_ONE) {
+      str += n;
+    } else {
+      let whole = trunc(n / d);
+      if (showMixed && whole > C_ZERO) {
+        str += whole;
+        str += " ";
+        n %= d;
+      }
+      str += n;
+      str += "/";
+      str += d;
     }
+    return str;
+  },
+  /**
+   * Returns a latex representation of a Fraction object
+   *
+   * Ex: new Fraction("1.'3'").toLatex() => "\frac{4}{3}"
+   **/
+  "toLatex": function(showMixed) {
+    let n = this["n"];
+    let d = this["d"];
+    let str = this["s"] < C_ZERO ? "-" : "";
+    if (d === C_ONE) {
+      str += n;
+    } else {
+      let whole = trunc(n / d);
+      if (showMixed && whole > C_ZERO) {
+        str += whole;
+        n %= d;
+      }
+      str += "\\frac{";
+      str += n;
+      str += "}{";
+      str += d;
+      str += "}";
+    }
+    return str;
+  },
+  /**
+   * Returns an array of continued fraction elements
+   *
+   * Ex: new Fraction("7/8").toContinued() => [0,1,7]
+   */
+  "toContinued": function() {
+    let a = this["n"];
+    let b = this["d"];
+    let res = [];
+    do {
+      res.push(trunc(a / b));
+      let t = a % b;
+      a = b;
+      b = t;
+    } while (a !== C_ONE);
+    return res;
+  },
+  "simplify": function(eps) {
+    const ieps = BigInt(1 / (eps || 1e-3) | 0);
+    const thisABS = this["abs"]();
+    const cont = thisABS["toContinued"]();
+    for (let i = 1; i < cont.length; i++) {
+      let s = newFraction(cont[i - 1], C_ONE);
+      for (let k = i - 2; k >= 0; k--) {
+        s = s["inverse"]()["add"](cont[k]);
+      }
+      let t = s["sub"](thisABS);
+      if (t["n"] * ieps < t["d"]) {
+        return s["mul"](this["s"]);
+      }
+    }
+    return this;
+  }
+};
+
+// src/continuedfraction.ts
+/**
+ * @license ContinuedFraction.js v0.1.0
+ * https://github.com/rawify/ContinuedFraction.js
+ *
+ * Copyright (c) 2026, Robert Eisele (https://raw.org/)
+ * Licensed under the MIT license.
+ **/
+var Fraction2 = Fraction;
+function iteratorFrom(source) {
+  return typeof source === "function" ? source() : source;
+}
+function coefficientOf(term) {
+  return typeof term === "object" && term !== null && "a" in term ? term.a : term;
 }
+function numeratorOf(term) {
+  return typeof term === "object" && term !== null && "b" in term ? term.b : 1;
+}
+function validateSteps(steps) {
+  if (!Number.isSafeInteger(steps) || steps < 0) {
+    throw new RangeError("steps must be a non-negative safe integer");
+  }
+}
+var ContinuedFraction = class _ContinuedFraction {
+  constructor() {
+    throw new TypeError("ContinuedFraction is a static class");
+  }
+  /**
+   * Infinite generator for the continued-fraction terms of sqrt(N).
+   *   sqrt(N) = [a0; (a1, a2, ..., a_p)], with a period boundary at ak = 2*a0.
+   * For perfect squares, yields only a0 = floor(sqrt(N)) and then returns.
+   *
+   * @param N Integer whose square-root CF expansion is desired (N >= 0).
+   * @yields Next continued-fraction term of sqrt(N).
+   */
+  static *sqrt(N) {
+    if (!Number.isSafeInteger(N) || N < 0) {
+      throw new RangeError("N must be a non-negative safe integer");
+    }
+    const a0 = Math.floor(Math.sqrt(N));
+    yield a0;
+    if (a0 * a0 === N) return;
+    let nk = 0;
+    let dk = 1;
+    let ak = a0;
+    while (true) {
+      nk = ak * dk - nk;
+      dk = (N - nk * nk) / dk;
+      ak = Math.floor((a0 + nk) / dk);
+      yield ak;
+    }
+  }
+  /**
+   * Generator for continued-fraction terms of any real number via Fraction.js.
+   *
+   * @param n The real number to convert (as number, string, or bigint).
+   * @yields Next continued-fraction term of n.
+   */
+  static *fromNumber(n) {
+    yield* Fraction2(n).toContinued();
+  }
+  /**
+   * Generator for continued-fraction terms of a rational a/b via Fraction.js.
+   *
+   * @param a Numerator, Fraction, or complete fraction string.
+   * @param b Optional denominator.
+   * @yields Next continued-fraction term of a/b.
+   */
+  static *fromFraction(a, b) {
+    const fraction = b === void 0 ? Fraction2(a) : Fraction2(a).div(Fraction2(b));
+    yield* fraction.toContinued();
+  }
+  /**
+   * Yields a finite sequence of simple or generalized terms unchanged.
+   *
+   * @param terms Continued-fraction terms.
+   * @yields Each supplied term in order.
+   */
+  static *fromTerms(terms) {
+    yield* terms;
+  }
+  /**
+   * Infinite generator of the golden ratio phi = [1; 1, 1, 1, ...].
+   *
+   * @yields Always 1.
+   */
+  static *PHI() {
+    while (true) {
+      yield 1;
+    }
+  }
+  /**
+   * Infinite generator for Brouncker's generalized continued fraction of 4/pi:
+   *   4/pi = 1 + 1^2/(2 + 3^2/(2 + 5^2/(2 + ...)))
+   *
+   * @yields Term pair (a_n, b_n) of the generalized continued fraction.
+   *   - first: a_0 = 1
+   *   - then: a_n = 2, b_n = (2n-1)^2 (n >= 1)
+   */
+  static *FOUR_OVER_PI() {
+    yield { a: 1, b: 0 };
+    for (let n = 1; true; n++) {
+      yield { a: 2, b: (n * 2 - 1) ** 2 };
+    }
+  }
+  /**
+   * Infinite generator for a generalized continued fraction of pi:
+   *   pi = 3 + 1^2/(6 + 3^2/(6 + 5^2/(6 + ...)))
+   *
+   * @yields Term pair (a_n, b_n) of the generalized continued fraction.
+   *   - first: a_0 = 3
+   *   - then: a_n = 6, b_n = (2n-1)^2 (n >= 1)
+   */
+  static *PI() {
+    yield { a: 3, b: 0 };
+    for (let n = 1; true; n++) {
+      yield { a: 6, b: (n * 2 - 1) ** 2 };
+    }
+  }
+  /**
+   * Infinite generator of e = [2; 1, 2, 1, 1, 4, 1, ...].
+   * Terms follow the pattern [2; (1, 2m, 1) for m = 1, 2, 3, ...].
+   *
+   * @yields Next continued-fraction term of e.
+   */
+  static *E() {
+    yield 2;
+    for (let m = 1; true; m++) {
+      yield 1;
+      yield 2 * m;
+      yield 1;
+    }
+  }
+  /**
+   * Collects at most `steps` terms from a continued fraction.
+   *
+   * @param source Continued-fraction term iterator or a function returning one.
+   * @param steps Maximum number of terms to collect.
+   * @returns Collected terms in source order.
+   */
+  static toArray(source, steps = 10) {
+    validateSteps(steps);
+    const iterator = iteratorFrom(source);
+    const terms = [];
+    while (terms.length < steps) {
+      const result = iterator.next();
+      if (result.done) break;
+      terms.push(result.value);
+    }
+    return terms;
+  }
+  /**
+   * Generates every convergent of a simple or generalized continued fraction.
+   *
+   * @param source Continued-fraction term iterator or a function returning one.
+   * @yields Exact convergents as Fraction instances.
+   */
+  static *convergents(source) {
+    const iterator = iteratorFrom(source);
+    const first = iterator.next();
+    if (first.done) return;
+    let currentNumerator = Fraction2(coefficientOf(first.value));
+    let currentDenominator = Fraction2(1);
+    let previousNumerator = Fraction2(1);
+    let previousDenominator = Fraction2(0);
+    yield currentNumerator.div(currentDenominator);
+    while (true) {
+      const result = iterator.next();
+      if (result.done) return;
+      const coefficient = Fraction2(coefficientOf(result.value));
+      const numerator = Fraction2(numeratorOf(result.value));
+      [previousNumerator, currentNumerator] = [
+        currentNumerator,
+        coefficient.mul(currentNumerator).add(numerator.mul(previousNumerator))
+      ];
+      [previousDenominator, currentDenominator] = [
+        currentDenominator,
+        coefficient.mul(currentDenominator).add(numerator.mul(previousDenominator))
+      ];
+      yield currentNumerator.div(currentDenominator);
+    }
+  }
+  /**
+   * Evaluates a simple or generalized continued fraction generator.
+   * For generalized fractions terms are objects `{ a, b }`; otherwise they are coefficients.
+   *
+   * @param source Continued-fraction term iterator or a function returning one.
+   * @param steps Number of terms to evaluate.
+   * @returns Rational approximation as Fraction.
+   */
+  static eval(source, steps = 10) {
+    validateSteps(steps);
+    if (steps === 0) return Fraction2(0);
+    let approximation = Fraction2(0);
+    let count = 0;
+    for (const convergent of _ContinuedFraction.convergents(source)) {
+      approximation = convergent;
+      count++;
+      if (count === steps) break;
+    }
+    return approximation;
+  }
+};
+var continuedfraction_default = ContinuedFraction;
 export {
-  ContinuedFraction as default, ContinuedFraction
+  ContinuedFraction,
+  continuedfraction_default as default
 };
+//# sourceMappingURL=continuedfraction.mjs.map