continuedfraction.js 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Robert Eisele
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# ContinuedFraction.js
+
+[![NPM Package](https://img.shields.io/npm/v/continuedfraction.js.svg?style=flat)](https://npmjs.org/package/continuedfraction.js "View this project on npm")
+[![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)
+
+
+A lightweight JavaScript library sitting on the shoulders of [Fraction.js](https://github.com/rawify/Fraction.js) for generating and evaluating **standard** and **generalized** continued fractions. It is built with generator-based sequences and convergent recurrences for fast execution.
+
+## Features
+
+- Generate the simple continued‑fraction expansion of √N
+- Convert any real number or rational to its continued‑fraction
+- Infinite generators for classic constants: φ (golden ratio), e, π, 4/π
+- Evaluate (simple or generalized) continued fractions to a `Fraction`
+
+## Example
+
+```js
+const frac = ContinuedFraction.eval(
+  ContinuedFraction.fromFraction(3021, 203),
+  10 // Max Steps
+);
+console.log(frac.toString()); // → "3021/203"
+```
+
+## Installation
+
+You can install `ContinuedFraction.js` via npm:
+
+```bash
+npm install continuedfraction.js
+```
+
+Or with yarn:
+
+```bash
+yarn add continuedfraction.js
+```
+
+Alternatively, download or clone the repository:
+
+```bash
+git clone https://github.com/rawify/ContinuedFraction.js
+```
+
+## Usage
+
+Include the `continuedfraction.min.js` file in your project:
+
+```html
+<script src="path/to/continuedfraction.min.js"></script>
+<script>
+  var x = ContinuedFraction.sqrt(2);
+</script>
+```
+
+Or in a Node.js project:
+
+```javascript
+const ContinuedFraction = require('continuedfraction.js');
+```
+
+or
+
+```javascript
+import ContinuedFraction from 'continuedfraction.js';
+```
+
+## ContinuedFraction API
+
+Import the static utility class and use its generators and evaluator:
+
+```javascript
+// 1) Continued‑fraction terms of √23
+const sqrtGen = ContinuedFraction.sqrt(23);
+console.log(sqrtGen.next().value); // 4
+console.log(sqrtGen.next().value); // 1, 3, 1, 8, …
+
+// 2) Continued‑fraction of a decimal
+let cnt = 0;
+for (let piCf of ContinuedFraction.fromNumber(Math.PI)) {
+  console.log(piCf);
+  if (cnt++ >= 10) break;
+}
+
+// 3) Golden ratio φ terms
+const phiGen = ContinuedFraction.PHI();
+console.log(phiGen.next().value); // 1, and forever 1…
+
+// 4) Evaluate the first 10 terms of e’s CF to a Fraction
+const approxE = ContinuedFraction.eval(ContinuedFraction.E, 10);
+console.log(approxE.toString()); // e ≈ “193/71”
+
+// 5) Generalized CF for π, 4/π
+const genPi = ContinuedFraction.PI();
+console.log(genPi.next().value);   // { a: 3, b: 0 }
+console.log(genPi.next().value);   // { a: 6, b: 1 }
+
+// 6) Continued‑fraction from two integers
+const halfCf = ContinuedFraction.fromFraction(1, 2);
+console.log([...halfCf]); // [0, 2]
+```
+
+### Methods
+
+| Method                   | Signature                                                         | Description                                                             |
+| ------------------------ | ----------------------------------------------------------------- | ----------------------------------------------------------------------- |
+| `sqrt(N: number)`        | `Generator<number>`                                               | Simple CF terms of √N                                                   |
+| `fromNumber(n)`          | `Generator<number>`                                               | CF terms of any real via Fraction.js                                    |
+| `fromFraction(a, b)`     | `Generator<number>`                                               | CF terms of the rational a/b                                            |
+| `PHI()`                  | `Generator<number>`                                               | Infinite 1’s for the golden ratio                                       |
+| `FOUR_OVER_PI()`         | `Generator<CFTerm>`                                               | Generalized CF terms for 4/π                                            |
+| `PI()`                   | `Generator<CFTerm>`                                               | Generalized CF terms for π                                              |
+| `E()`                    | `Generator<number>`                                               | CF expansion of e                                                       |
+| `eval(generator, steps)` | `(Generator|() => Generator, steps?: number) ⇒ Fraction`          | Evaluate (generalized) continued fraction to a `Fraction` approximation |
+
+## Coding Style
+
+As every library I publish, ContinuedFraction is also built to be as small as possible after compressing it with Google Closure Compiler in advanced mode. Thus the coding style orientates a little on maxing-out the compression rate. Please make sure you keep this style if you plan to extend the library.
+
+## Building the library
+
+After cloning the Git repository run:
+
+```
+npm install
+npm run build
+```
+
+## Copyright and Licensing
+
+Copyright (c) 2025, [Robert Eisele](https://raw.org/)
+Licensed under the MIT license.

package/continuedfraction.d.ts

@@ -0,0 +1,80 @@
+
+import type Fraction from 'fraction.js';
+
+/**
+ * A term of a generalized continued fraction.
+ */
+export interface CFTerm {
+    /** The aₙ coefficient */
+    a: number;
+    /** The bₙ coefficient */
+    b: number;
+}
+
+/**
+ * Utility class for generating continued-fraction expansions of various constants.
+ * All methods are static.
+ */
+export default class ContinuedFraction {
+    /**
+     * Infinite generator for the continued‐fraction terms of √N.
+     * @param N Integer whose square‐root CF expansion is desired (N ≥ 0)
+     * @yields Next continued‐fraction term of √N
+     */
+    static sqrt(N: number): Generator<number, void, unknown>;
+
+    /**
+     * 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: number | string | bigint): Generator<number, void, unknown>;
+
+    /**
+     * Generator for continued‐fraction terms of a rational a/b via Fraction.js.
+     * @param a Numerator (number, string, bigint, or Fraction)
+     * @param b Denominator (number, string, or bigint)
+     * @yields Next continued‐fraction term of a/b
+     */
+    static fromFraction(
+        a: number | string | bigint | Fraction,
+        b: number | string | bigint
+    ): Generator<number, void, unknown>;
+
+    /**
+     * Infinite generator of the golden ratio φ = [1; 1, 1, 1, …].
+     * @yields Always 1
+     */
+    static PHI(): Generator<number, void, unknown>;
+
+    /**
+     * Infinite generator for the generalized continued‐fraction terms of 4/π.
+     * @yields Term pairs { a, b } for the continued‐fraction
+     */
+    static FOUR_OVER_PI(): Generator<CFTerm, void, unknown>;
+
+    /**
+     * Infinite generator for the generalized continued‐fraction terms of π.
+     * @yields Term pairs { a, b } for the continued‐fraction
+     */
+    static PI(): Generator<CFTerm, void, unknown>;
+
+    /**
+     * Infinite generator of e = [2; 1, 2, 1, 1, 4, 1, …].
+     * @yields Next continued‐fraction term of e
+     */
+    static E(): Generator<number, void, unknown>;
+
+    /**
+     * Evaluate a (simple or generalized) continued fraction generator.
+     * @param generator A CF term generator or a function returning one
+     * @param steps Number of terms to include (default 10)
+     * @returns Rational approximation as a Fraction
+     */
+    static eval(
+        generator:
+            | Generator<number | CFTerm, any, any>
+            | (() => Generator<number | CFTerm, any, any>),
+        steps?: number
+    ): Fraction;
+}

package/dist/continuedfraction.js

@@ -0,0 +1,179 @@
+'use strict';
+const Fraction = require('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();
+        }
+
+        // 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))];
+        }
+
+        // final convergent = pCurr/qCurr
+        return pCurr['div'](qCurr);
+    }
+}
+
+Object.defineProperty(ContinuedFraction, "__esModule", { 'value': true });
+ContinuedFraction['default'] = ContinuedFraction;
+ContinuedFraction['ContinuedFraction'] = ContinuedFraction;
+module['exports'] = ContinuedFraction;

package/dist/continuedfraction.min.js

@@ -0,0 +1,10 @@
+/*
+ContinuedFraction.js v0.0.1 4/18/2025
+https://github.com/rawify/ContinuedFraction.js
+
+Copyright (c) 2025, Robert Eisele (https://raw.org/)
+Licensed under the MIT license.
+*/
+'use strict';(function(n){const e={sqrt:function*(a){const c=Math.floor(Math.sqrt(a));yield c;if(c*c!==a){var b=0,d=1,f=c;do b=f*d-b,d=(a-b*b)/d,f=Math.floor((c+b)/d),yield f;while(1)}},fromNumber:function*(a){yield*Fraction(a).toContinued()},fromFraction:function*(a,c){yield*Fraction(a,c).toContinued()},PHI:function*(){for(;;)yield 1},FOUR_OVER_PI:function*(){yield{a:1,b:0};for(let a=0;;a++)yield{a:2,b:(2*a+1)**2}},PI:function*(){yield{a:3,b:0};for(let a=1;;a++)yield{a:6,b:(2*a-1)**2}},E:function*(){yield 2;
+for(let a=1;;a++)yield 1,yield 2*a,yield 1},eval:function(a,c=10){"function"===typeof a&&(a=a());var b=a.next();if(b.done)return Fraction(0);b=Fraction(b.value.a??b.value);let d=Fraction(1),f=Fraction(1),h=Fraction(0);for(let k=1;k<c;k++){const {value:g,done:p}=a.next();if(p)break;const l=Fraction(g.a??g),m=Fraction(g.b??1);[f,b]=[b,l.mul(b).add(m.mul(f))];[h,d]=[d,l.mul(d).add(m.mul(h))]}return b.div(d)}};"function"===typeof define&&define.amd?define([],function(){return e}):"object"===typeof exports?
+(Object.defineProperty(e,"__esModule",{value:!0}),e["default"]=e,e.ContinuedFraction=e,module.exports=e):n.ContinuedFraction=e})(this);

package/dist/continuedfraction.mjs

@@ -0,0 +1,177 @@
+'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();
+        }
+
+        // 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))];
+        }
+
+        // final convergent = pCurr/qCurr
+        return pCurr['div'](qCurr);
+    }
+}
+export {
+  ContinuedFraction as default, ContinuedFraction
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+    "name": "continuedfraction.js",
+    "title": "ContinuedFraction.js",
+    "version": "0.0.1",
+    "homepage": "https://github.com/rawify/ContinuedFraction.js",
+    "bugs": "https://github.com/rawify/ContinuedFraction.js/issues",
+    "description": "The RAW continued fractions library",
+    "keywords": [
+        "math",
+        "continued fraction",
+        "fraction",
+        "bigint"
+    ],
+    "private": false,
+    "main": "./dist/continuedfraction.js",
+    "module": "./dist/continuedfraction.mjs",
+    "types": "./continuedfraction.d.ts",
+    "browser": "./dist/continuedfraction.min.js",
+    "unpkg": "./dist/continuedfraction.min.js",
+    "readmeFilename": "README.md",
+    "exports": {
+        ".": {
+            "types": "./continuedfraction.d.ts",
+            "require": "./dist/continuedfraction.js",
+            "import": "./dist/continuedfraction.mjs"
+        }
+    },
+    "repository": {
+        "type": "git",
+        "url": "git@github.com:rawify/ContinuedFraction.js.git"
+    },
+    "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/rawify"
+    },
+    "author": {
+        "name": "Robert Eisele",
+        "email": "robert@raw.org",
+        "url": "https://raw.org/"
+    },
+    "license": "MIT",
+    "engines": {
+        "node": "*"
+    },
+    "directories": {
+        "test": "tests"
+    },
+    "scripts": {
+        "build": "crude-build ContinuedFraction",
+        "test": "mocha tests/*.js"
+    },
+    "devDependencies": {
+        "crude-build": "^0.1.0",
+        "mocha": "^11.1.0"
+    },
+    "dependencies": {
+        "fraction.js": "^5.2.2"
+    }
+}

package/src/continuedfraction.js

@@ -0,0 +1,179 @@
+/**
+ * @license ContinuedFraction.js v0.0.1 4/18/2025
+ * https://github.com/rawify/ContinuedFraction.js
+ *
+ * Copyright (c) 2025, Robert Eisele (https://raw.org/)
+ * Licensed under the MIT license.
+ **/
+
+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();
+        }
+
+        // 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))];
+        }
+
+        // final convergent = pCurr/qCurr
+        return pCurr['div'](qCurr);
+    }
+}

package/tests/continued.js

@@ -0,0 +1,50 @@
+
+const ContinuedFraction = require("continuedfraction.js");
+const assert = require('assert');
+
+function get(gen, num = 10) {
+
+    const res = [];
+    for (let i = 0; i < num; i++) {
+        let x = gen.next();
+        if (x.done) break;
+        res.push(x.value);
+    }
+    return res;
+}
+
+const tests = [
+
+    { label: "sqrt(2)", generator: ContinuedFraction.sqrt(2), expect: [1, 2, 2, 2, 2, 2, 2, 2, 2, 2] },
+    { label: "sqrt(3)", generator: ContinuedFraction.sqrt(3), expect: [1, 1, 2, 1, 2, 1, 2, 1, 2, 1] },
+    { label: "sqrt(5)", generator: ContinuedFraction.sqrt(5), expect: [2, 4, 4, 4, 4, 4, 4, 4, 4, 4] },
+    { label: "sqrt(7)", generator: ContinuedFraction.sqrt(7), expect: [2, 1, 1, 1, 4, 1, 1, 1, 4, 1] },
+
+    { label: "fromNumber(23.43)", generator: ContinuedFraction.fromNumber(23.43), expect: [23, 2, 3, 14] },
+    { label: "fromNumber(77)", generator: ContinuedFraction.fromNumber(77), expect: [77] },
+
+    { label: "PHI", generator: ContinuedFraction.PHI(), expect: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] },
+    { label: "PI", generator: ContinuedFraction.PI(), expect: [{ a: 3, b: 0 }, { a: 6, b: 1 }, { a: 6, b: 9 }, { a: 6, b: 25 }, { a: 6, b: 49 }, { a: 6, b: 81 }, { a: 6, b: 121 },{ a: 6, b: 169 },{ a: 6, b: 225 },{ a: 6, b: 289 }] },
+    { label: "FOUR_OVER_PI", generator: ContinuedFraction.FOUR_OVER_PI(), expect: [{ a: 1, b: 0 }, { a: 2, b: 1 }, { a: 2, b: 9 }, { a: 2, b: 25 }, { a: 2, b: 49 }, { a: 2, b: 81 }, { a: 2, b: 121 },{ a: 2, b: 169 },{ a: 2, b: 225 },{ a: 2, b: 289 }] },
+    { label: "E", generator: ContinuedFraction.E(), expect: [2, 1, 2, 1, 1, 4, 1, 1, 6, 1] },
+
+    { label: "eval(Fraction(271/13))", input: ContinuedFraction.eval(ContinuedFraction.fromFraction("271/13"), 10).toFraction(), expect: "271/13" },
+    { label: "eval(PHI)", input: ContinuedFraction.eval(ContinuedFraction.PHI, 21).toFraction(), expect: "17711/10946" }
+];
+
+describe('Continued Fraction', function () {
+
+    for (var i = 0; i < tests.length; i++) {
+
+        (function (test) {
+
+            it(test.label, function () {
+                if (test.generator)
+                    assert.deepEqual(get(test.generator, 10), test.expect);
+                else
+                    assert.deepEqual(test.input, test.expect);
+            });
+
+        })(tests[i]);
+    }
+});