@stevenvo780/st-lang 4.4.0 → 4.5.1

package/dist/combinators-ski/abstract.js

@@ -0,0 +1,88 @@
+"use strict";
+// ============================================================
+// Bracket abstraction: λ-cálculo → SKI
+// ============================================================
+//
+// Algoritmo clásico de Curry para eliminar λ-abstracciones, traducido
+// como `lambda x . T  ≡  [x] T` con las reglas:
+//
+//   [x] x         = I
+//   [x] M         = K M             si x ∉ FV(M)
+//   [x] (M N)     = S ([x] M) ([x] N)
+//
+// Es el llamado "algoritmo (abc)" — simple, no optimizado: produce
+// términos grandes pero correctos. Hay variantes que aprovechan
+// patrones como `[x] (M x) = M` (η) o introducen B, C, W, T, K' para
+// reducir tamaño; aquí elegimos la canónica por claridad pedagógica.
+//
+// `toLambda` hace el camino inverso: codifica S, K, I como las
+// λ-abstracciones que los definen. No pretende invertir
+// `abstractFromLambda` exactamente — el round-trip es semántico
+// (alpha/beta-eta equivalente), no sintáctico.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abstractFromLambda = abstractFromLambda;
+exports.toLambda = toLambda;
+const types_1 = require("../lambda-calc/types");
+const types_2 = require("./types");
+// Convierte un λ-término a SKI puro (sólo S, K, I y variables libres).
+function abstractFromLambda(t) {
+    switch (t.kind) {
+        case 'var':
+            return (0, types_2.cvar)(t.name);
+        case 'app':
+            return { kind: 'app', fn: abstractFromLambda(t.fn), arg: abstractFromLambda(t.arg) };
+        case 'abs': {
+            // [param] body
+            const inner = abstractFromLambda(t.body);
+            return bracket(t.param, inner);
+        }
+    }
+}
+// [x] T  con T ya en SKI.
+function bracket(x, t) {
+    // [x] x = I
+    if (t.kind === 'var' && t.name === x)
+        return (0, types_2.I)();
+    // [x] M  = K M     si x ∉ FV(M)
+    if (!(0, types_2.freeVars)(t).has(x))
+        return (0, types_2.app)((0, types_2.K)(), t);
+    // En este punto t es necesariamente una aplicación: si fuese una
+    // constante S/K/I no tendría FV, y si fuese `var` su nombre ≠ x ya
+    // habría caído en la rama K. Mantengo el switch para que TS
+    // narrowee y queden cubiertas las ramas restantes.
+    switch (t.kind) {
+        case 'app':
+            // [x] (M N) = S ([x] M) ([x] N)
+            return (0, types_2.app)((0, types_2.S)(), bracket(x, t.fn), bracket(x, t.arg));
+        case 'var':
+        case 'S':
+        case 'K':
+        case 'I':
+            // Inalcanzable por las guardas previas; reproducimos K-rule
+            // por defensa para no caer en undefined.
+            return (0, types_2.app)((0, types_2.K)(), t);
+    }
+}
+// SKI → λ-cálculo. Codifica S, K, I como sus definiciones lambda
+// canónicas y deja las variables libres como variables. Útil para
+// round-trip: el resultado, normalizado en λ, debe ser
+// alpha-equivalente al término original aplicado a los mismos
+// argumentos (la equivalencia es semántica, no sintáctica).
+function toLambda(c) {
+    switch (c.kind) {
+        case 'I':
+            // I = λx.x
+            return (0, types_1.lam)('x', (0, types_1.v)('x'));
+        case 'K':
+            // K = λx.λy.x
+            return (0, types_1.lam)('x', (0, types_1.lam)('y', (0, types_1.v)('x')));
+        case 'S':
+            // S = λx.λy.λz. x z (y z)
+            return (0, types_1.lam)('x', (0, types_1.lam)('y', (0, types_1.lam)('z', (0, types_1.apN)((0, types_1.v)('x'), (0, types_1.v)('z'), (0, types_1.ap)((0, types_1.v)('y'), (0, types_1.v)('z'))))));
+        case 'var':
+            return (0, types_1.v)(c.name);
+        case 'app':
+            return (0, types_1.ap)(toLambda(c.fn), toLambda(c.arg));
+    }
+}
+//# sourceMappingURL=abstract.js.map

package/dist/combinators-ski/abstract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../src/combinators-ski/abstract.ts"],"names":[],"mappings":"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"}

package/dist/combinators-ski/index.d.ts

@@ -0,0 +1,6 @@
+export type { CTerm } from './types';
+export { S, K, I, cvar, app, ctermEq, freeVars, termToString } from './types';
+export { reduceStep, normalize, isNormalForm } from './reduce';
+export type { NormalizeResult } from './reduce';
+export { abstractFromLambda, toLambda } from './abstract';
+//# sourceMappingURL=index.d.ts.map

package/dist/combinators-ski/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/combinators-ski/index.ts"],"names":[],"mappings":"AAWA,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE9E,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC/D,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/combinators-ski/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// ============================================================
+// SKI combinatory logic — Punto de entrada público
+// ============================================================
+//
+// API:
+//   - Tipos: CTerm
+//   - Constructores: S(), K(), I(), cvar, app
+//   - Estructura: ctermEq, freeVars, termToString
+//   - Reducción: reduceStep, normalize, isNormalForm, NormalizeResult
+//   - Bracket abstraction: abstractFromLambda, toLambda
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLambda = exports.abstractFromLambda = exports.isNormalForm = exports.normalize = exports.reduceStep = exports.termToString = exports.freeVars = exports.ctermEq = exports.app = exports.cvar = exports.I = exports.K = exports.S = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "S", { enumerable: true, get: function () { return types_1.S; } });
+Object.defineProperty(exports, "K", { enumerable: true, get: function () { return types_1.K; } });
+Object.defineProperty(exports, "I", { enumerable: true, get: function () { return types_1.I; } });
+Object.defineProperty(exports, "cvar", { enumerable: true, get: function () { return types_1.cvar; } });
+Object.defineProperty(exports, "app", { enumerable: true, get: function () { return types_1.app; } });
+Object.defineProperty(exports, "ctermEq", { enumerable: true, get: function () { return types_1.ctermEq; } });
+Object.defineProperty(exports, "freeVars", { enumerable: true, get: function () { return types_1.freeVars; } });
+Object.defineProperty(exports, "termToString", { enumerable: true, get: function () { return types_1.termToString; } });
+var reduce_1 = require("./reduce");
+Object.defineProperty(exports, "reduceStep", { enumerable: true, get: function () { return reduce_1.reduceStep; } });
+Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return reduce_1.normalize; } });
+Object.defineProperty(exports, "isNormalForm", { enumerable: true, get: function () { return reduce_1.isNormalForm; } });
+var abstract_1 = require("./abstract");
+Object.defineProperty(exports, "abstractFromLambda", { enumerable: true, get: function () { return abstract_1.abstractFromLambda; } });
+Object.defineProperty(exports, "toLambda", { enumerable: true, get: function () { return abstract_1.toLambda; } });
+//# sourceMappingURL=index.js.map

package/dist/combinators-ski/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/combinators-ski/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mDAAmD;AACnD,+DAA+D;AAC/D,EAAE;AACF,OAAO;AACP,mBAAmB;AACnB,8CAA8C;AAC9C,kDAAkD;AAClD,sEAAsE;AACtE,wDAAwD;;;AAGxD,iCAA8E;AAArE,0FAAA,CAAC,OAAA;AAAE,0FAAA,CAAC,OAAA;AAAE,0FAAA,CAAC,OAAA;AAAE,6FAAA,IAAI,OAAA;AAAE,4FAAA,GAAG,OAAA;AAAE,gGAAA,OAAO,OAAA;AAAE,iGAAA,QAAQ,OAAA;AAAE,qGAAA,YAAY,OAAA;AAE5D,mCAA+D;AAAtD,oGAAA,UAAU,OAAA;AAAE,mGAAA,SAAS,OAAA;AAAE,sGAAA,YAAY,OAAA;AAG5C,uCAA0D;AAAjD,8GAAA,kBAAkB,OAAA;AAAE,oGAAA,QAAQ,OAAA"}

package/dist/combinators-ski/reduce.d.ts

@@ -0,0 +1,10 @@
+import type { CTerm } from './types';
+export declare function reduceStep(t: CTerm): CTerm | null;
+export interface NormalizeResult {
+    result: CTerm;
+    steps: number;
+    terminated: boolean;
+}
+export declare function normalize(t: CTerm, maxSteps?: number): NormalizeResult;
+export declare function isNormalForm(t: CTerm): boolean;
+//# sourceMappingURL=reduce.d.ts.map

package/dist/combinators-ski/reduce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce.d.ts","sourceRoot":"","sources":["../../src/combinators-ski/reduce.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGrC,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAgBjD;AA2DD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;CACrB;AAKD,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,SAAO,GAAG,eAAe,CASpE;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO,CAE9C"}

package/dist/combinators-ski/reduce.js

@@ -0,0 +1,118 @@
+"use strict";
+// ============================================================
+// SKI combinatory logic — Reducción
+// ============================================================
+//
+// Reglas (weak reduction, leftmost-outermost):
+//   I x      → x
+//   K x y    → x          (descarta `y` aunque éste tenga redex propios)
+//   S x y z  → x z (y z)
+//
+// `reduceStep` aplica un único paso si encuentra un redex en la
+// cabeza o, si no, baja por las ramas siguiendo orden
+// leftmost-outermost. Como no hay binders ni captura, no se requiere
+// renombrar; la sustitución es pegado físico de subárboles.
+//
+// La forma normal SKI puede no existir (e.g. términos divergentes
+// equivalentes a Ω), por lo que `normalize` recibe `maxSteps`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceStep = reduceStep;
+exports.normalize = normalize;
+exports.isNormalForm = isNormalForm;
+// Devuelve el término reducido en UN paso, o `null` si no hay redex.
+function reduceStep(t) {
+    // Intenta primero un paso en la posición de cabeza.
+    const head = reduceHead(t);
+    if (head !== null)
+        return head;
+    // Si no hay redex en cabeza, baja recursivamente.
+    switch (t.kind) {
+        case 'app': {
+            const fn2 = reduceStep(t.fn);
+            if (fn2 !== null)
+                return { kind: 'app', fn: fn2, arg: t.arg };
+            const arg2 = reduceStep(t.arg);
+            if (arg2 !== null)
+                return { kind: 'app', fn: t.fn, arg: arg2 };
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+// Intenta una reducción en la posición de cabeza del término.
+// Devuelve `null` si no hay redex de cabeza.
+function reduceHead(t) {
+    if (t.kind !== 'app')
+        return null;
+    // Junta la cabeza (combinador o variable) con sus argumentos
+    // recorridos por la espina izquierda.
+    const spine = [];
+    let cursor = t;
+    while (cursor.kind === 'app') {
+        spine.unshift(cursor.arg);
+        cursor = cursor.fn;
+    }
+    // `cursor` es la cabeza definitiva (S/K/I/var); `spine` son los args
+    // aplicados de izquierda a derecha.
+    switch (cursor.kind) {
+        case 'I': {
+            const x = spine[0];
+            if (x === undefined)
+                return null;
+            // I x rest... → x rest...
+            return rebuild(x, spine.slice(1));
+        }
+        case 'K': {
+            const x = spine[0];
+            const y = spine[1];
+            if (x === undefined || y === undefined)
+                return null;
+            // K x y rest... → x rest...     (y se descarta)
+            return rebuild(x, spine.slice(2));
+        }
+        case 'S': {
+            const x = spine[0];
+            const y = spine[1];
+            const z = spine[2];
+            if (x === undefined || y === undefined || z === undefined)
+                return null;
+            // S x y z rest... → (x z (y z)) rest...
+            const reduced = {
+                kind: 'app',
+                fn: { kind: 'app', fn: x, arg: z },
+                arg: { kind: 'app', fn: y, arg: z },
+            };
+            return rebuild(reduced, spine.slice(3));
+        }
+        default:
+            return null;
+    }
+}
+// Reconstruye `head arg0 arg1 ...` como aplicación asociativa a la izquierda.
+function rebuild(head, args) {
+    let acc = head;
+    for (const a of args) {
+        acc = { kind: 'app', fn: acc, arg: a };
+    }
+    return acc;
+}
+// Itera reducciones hasta forma normal o agotar `maxSteps`.
+// `terminated=true` significa que no quedan redex (forma normal SKI);
+// `false` indica que se alcanzó el cap (típico para términos divergentes).
+function normalize(t, maxSteps = 1000) {
+    let current = t;
+    let steps = 0;
+    for (; steps < maxSteps; steps += 1) {
+        const next = reduceStep(current);
+        if (next === null)
+            return { result: current, steps, terminated: true };
+        current = next;
+    }
+    return { result: current, steps, terminated: false };
+}
+// ¿No hay más redex aplicable?
+function isNormalForm(t) {
+    return reduceStep(t) === null;
+}
+//# sourceMappingURL=reduce.js.map

package/dist/combinators-ski/reduce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce.js","sourceRoot":"","sources":["../../src/combinators-ski/reduce.ts"],"names":[],"mappings":"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"}

package/dist/combinators-ski/types.d.ts

@@ -0,0 +1,23 @@
+export type CTerm = {
+    kind: 'S';
+} | {
+    kind: 'K';
+} | {
+    kind: 'I';
+} | {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'app';
+    fn: CTerm;
+    arg: CTerm;
+};
+export declare const S: () => CTerm;
+export declare const K: () => CTerm;
+export declare const I: () => CTerm;
+export declare const cvar: (name: string) => CTerm;
+export declare function app(...ts: CTerm[]): CTerm;
+export declare function ctermEq(a: CTerm, b: CTerm): boolean;
+export declare function termToString(t: CTerm): string;
+export declare function freeVars(t: CTerm): Set<string>;
+//# sourceMappingURL=types.d.ts.map

package/dist/combinators-ski/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/combinators-ski/types.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,KAAK,GACb;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,GACb;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,GACb;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,GACb;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,KAAK,CAAA;CAAE,CAAC;AAG3C,eAAO,MAAM,CAAC,QAAO,KAAwB,CAAC;AAC9C,eAAO,MAAM,CAAC,QAAO,KAAwB,CAAC;AAC9C,eAAO,MAAM,CAAC,QAAO,KAAwB,CAAC;AAC9C,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,KAAG,KAAgC,CAAC;AAIrE,wBAAgB,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,KAAK,CAYzC;AAGD,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAcnD;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAgB7C;AAGD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,CAI9C"}

package/dist/combinators-ski/types.js

@@ -0,0 +1,102 @@
+"use strict";
+// ============================================================
+// SKI combinatory logic — Términos y constructores
+// ============================================================
+//
+// Sistema base de combinadores S, K, I (Schönfinkel / Curry). Es
+// Turing-completo y equivalente al λ-cálculo, pero sin variables
+// ligadas: toda función se construye combinando S, K, I y variables
+// libres mediante aplicación. Las λ-abstracciones se "eliminan"
+// vía bracket abstraction (ver `abstract.ts`).
+//
+// Reglas de reducción:
+//   I x      → x
+//   K x y    → x
+//   S x y z  → x z (y z)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cvar = exports.I = exports.K = exports.S = void 0;
+exports.app = app;
+exports.ctermEq = ctermEq;
+exports.termToString = termToString;
+exports.freeVars = freeVars;
+// ---------- Constructores convenientes ----------
+const S = () => ({ kind: 'S' });
+exports.S = S;
+const K = () => ({ kind: 'K' });
+exports.K = K;
+const I = () => ({ kind: 'I' });
+exports.I = I;
+const cvar = (name) => ({ kind: 'var', name });
+exports.cvar = cvar;
+// Aplicación n-aria asociativa a la izquierda: app(f, a, b, c) = ((f a) b) c.
+// Con un solo argumento devuelve el término tal cual; sin argumentos lanza.
+function app(...ts) {
+    const head = ts[0];
+    if (head === undefined) {
+        throw new Error('app() requiere al menos un término');
+    }
+    let acc = head;
+    for (let i = 1; i < ts.length; i += 1) {
+        const next = ts[i];
+        if (next === undefined)
+            break;
+        acc = { kind: 'app', fn: acc, arg: next };
+    }
+    return acc;
+}
+// Igualdad estructural (no hay alpha — no hay binders).
+function ctermEq(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'S':
+        case 'K':
+        case 'I':
+            return true;
+        case 'var':
+            return a.name === b.name;
+        case 'app': {
+            const bb = b;
+            return ctermEq(a.fn, bb.fn) && ctermEq(a.arg, bb.arg);
+        }
+    }
+}
+// Pretty-printer. Aplicación asociativa a la izquierda: agrupa con
+// paréntesis sólo cuando el argumento es a su vez una aplicación.
+function termToString(t) {
+    switch (t.kind) {
+        case 'S':
+            return 'S';
+        case 'K':
+            return 'K';
+        case 'I':
+            return 'I';
+        case 'var':
+            return t.name;
+        case 'app': {
+            const fn = termToString(t.fn);
+            const arg = t.arg.kind === 'app' ? `(${termToString(t.arg)})` : termToString(t.arg);
+            return `${fn} ${arg}`;
+        }
+    }
+}
+// Variables libres del término (no hay ligadas en SKI puro).
+function freeVars(t) {
+    const acc = new Set();
+    collect(t, acc);
+    return acc;
+}
+function collect(t, acc) {
+    switch (t.kind) {
+        case 'var':
+            acc.add(t.name);
+            return;
+        case 'app':
+            collect(t.fn, acc);
+            collect(t.arg, acc);
+            return;
+        default:
+            return;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/combinators-ski/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/combinators-ski/types.ts"],"names":[],"mappings":"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"}

package/dist/constructive-reals/index.d.ts

@@ -0,0 +1,132 @@
+export interface CReal {
+    /**
+     * Devuelve una aproximación dyádica de x con error < 2^{-precision}.
+     * numerator / denominator ≈ x, denominator = 2^precision.
+     */
+    approx(precision: number): {
+        numerator: bigint;
+        denominator: bigint;
+    };
+}
+/** Eleva 2 a un entero no negativo. */
+declare function pow2(n: number): bigint;
+/**
+ * Divide entero con "round half away from zero".
+ *   shiftRight(x, k) ≈ x / 2^k redondeado.
+ * Garantiza |shiftRight(x,k) - x/2^k| ≤ 1/2.
+ */
+declare function shiftRight(x: bigint, k: number): bigint;
+/**
+ * Calcula el número de bits del entero (|x| en binario).
+ * bitLength(0) = 0, bitLength(1) = 1, bitLength(7) = 3, bitLength(8) = 4.
+ */
+declare function bitLength(x: bigint): number;
+export declare function fromInt(n: number | bigint): CReal;
+export declare function fromRational(p: number | bigint, q: number | bigint): CReal;
+export declare function neg(a: CReal): CReal;
+export declare function abs(a: CReal): CReal;
+/**
+ * add(a,b) a precisión p:
+ *   pedimos a y b a precisión p+2.
+ *   error de cada uno < 2^{-(p+2)} → error en a+b < 2·2^{-(p+2)} = 2^{-(p+1)}.
+ *   Al pasar de escala p+2 a p (shift de 2), introducimos error
+ *   de redondeo ≤ 1/2 en la unidad p, = 2^{-(p+1)}.
+ *   Total: < 2^{-(p+1)} + 2^{-(p+1)} = 2^{-p}.  ✓
+ */
+export declare function add(a: CReal, b: CReal): CReal;
+export declare function sub(a: CReal, b: CReal): CReal;
+/**
+ * mul(a,b) a precisión p:
+ *   Necesitamos cotas sobre |a| y |b|. Tomamos una aproximación gruesa
+ *   a precisión 0 para estimar el tamaño en bits.
+ *   Sean |a| ≤ 2^A, |b| ≤ 2^B (con A,B no-negativos).
+ *   Trabajamos a precisión p + A + B + 3.
+ *   En esa escala el producto cabe y la cota de error queda < 2^{-p}.
+ *
+ *   Detalle del error: si â = a + ε_a con |ε_a| < 2^{-w} y análogamente
+ *   para b̂ (w = work precision en los operandos), entonces
+ *      â·b̂ - a·b = a·ε_b + b·ε_a + ε_a·ε_b.
+ *   |a·ε_b| ≤ 2^A · 2^{-w}, idem para b.
+ *   Eligiendo w = p + A + B + 3 ese error queda < 2·2^{-(p+B+3)}
+ *   acotado holgadamente por 2^{-(p+1)}, y el shift final añade otro
+ *   2^{-(p+1)}, dando < 2^{-p}.
+ */
+export declare function mul(a: CReal, b: CReal): CReal;
+/**
+ * div(a,b) a precisión p (b ≠ 0).
+ *   Encontramos k tal que |b| ≥ 2^{-k}.
+ *   Necesitamos también cota superior A_bits sobre |a|.
+ *   Trabajamos a precisión w = p + 2k + A_bits + 4.
+ *
+ *   Si â = a + ε_a, b̂ = b + ε_b, entonces
+ *     â/b̂ - a/b = (ε_a · b - a · ε_b) / (b · b̂).
+ *   |b · b̂| ≥ (2^{-k}) · (2^{-k} - 2^{-w}) ≥ 2^{-2k-1}.
+ *   |ε_a · b| ≤ 2^{-w} · (|b̂|+2^{-w}).
+ *   |a · ε_b| ≤ |â+2^{-w}| · 2^{-w}.
+ *   Tomando w = p + 2k + A_bits + 4 acotamos por < 2^{-p}.
+ */
+export declare function div(a: CReal, b: CReal): CReal;
+/**
+ * sqrt(a) para a ≥ 0. Si a < 0 (detectado con cota), lanza.
+ * Implementación: Newton-Raphson en bigint sobre x² = N donde
+ * N = aprox(a) a precisión 2·prec + buffer. La raíz cuadrada entera
+ * de N da nuestra aproximación a √a a precisión prec.
+ */
+export declare function sqrt(a: CReal): CReal;
+/** Raíz cuadrada entera (floor) de n ≥ 0 vía Newton. */
+declare function isqrt(n: bigint): bigint;
+/**
+ * compareWithEpsilon(a, b, epsPrec):
+ *   Si |a - b| < 2^{-epsPrec}, devuelve 0 (indistinguibles).
+ *   Si a > b + 2^{-epsPrec}, devuelve 1.
+ *   Si a < b - 2^{-epsPrec}, devuelve -1.
+ *
+ *   Implementación: comparamos aproximaciones a precisión epsPrec + 3.
+ *   |aw/2^w - a| < 2^{-w}, idem b. Entonces
+ *     (aw - bw)/2^w  está dentro de  (a - b) ± 2·2^{-w}.
+ *   Eligiendo w = epsPrec + 3:
+ *     • Si (aw - bw) > 2^{w - epsPrec} + 2 = 8 + 2 = 10 (en escala w),
+ *       entonces a - b > 2^{-epsPrec}, devolvemos 1.
+ *     • Análogo para -10.
+ *     • En otro caso, devolvemos 0.
+ */
+export declare function compareWithEpsilon(a: CReal, b: CReal, epsilonPrecision: number): -1 | 0 | 1;
+/**
+ * toString(r, digits): representación decimal con `digits` dígitos
+ * después del punto. Usa precisión binaria suficiente:
+ *   2^p > 10^digits  ⇔  p > digits · log2(10) ≈ digits · 3.322.
+ * Tomamos p = ceil(digits · 4) + 8 para holgura.
+ */
+export declare function toString(r: CReal, digits: number): string;
+/**
+ * exp(x) = Σ x^k / k!. Para que la serie converja rápido reducimos
+ * primero el argumento: escribimos x = q · ln(2) + r con |r| ≤ ln(2)/2
+ * usando q = round(x / ln(2)). Luego exp(x) = 2^q · exp(r).
+ *
+ * Para esta versión inicial hacemos una reducción más simple: si
+ * |x| > 1, dividimos por 2^k hasta que |x/2^k| < 1, calculamos
+ * exp(x/2^k) por serie, y elevamos al cuadrado k veces (exp(y)² = exp(2y)).
+ * Esto mantiene la convergencia de la serie acotada a ~prec términos.
+ */
+export declare function exp(x: CReal): CReal;
+export declare function log(x: CReal): CReal;
+export declare function sin(x: CReal): CReal;
+export declare function cos(x: CReal): CReal;
+/**
+ * pow(a, b) = exp(b · log(a)) para a > 0.
+ * Caso especial: si b es un entero, hacemos exponenciación rápida
+ * sobre CReal para evitar log de a (lo que permite a ≤ 0 si b es entero).
+ */
+export declare function pow(a: CReal, b: CReal | number): CReal;
+export declare const PI: CReal;
+export declare const E: CReal;
+export declare const SQRT2: CReal;
+/** @internal Exposed for whitebox tests. */
+export declare const __internals: {
+    shiftRight: typeof shiftRight;
+    bitLength: typeof bitLength;
+    isqrt: typeof isqrt;
+    pow2: typeof pow2;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/constructive-reals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constructive-reals/index.ts"],"names":[],"mappings":"AA6CA,MAAM,WAAW,KAAK;IACpB;;;OAGG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACvE;AAID,uCAAuC;AACvC,iBAAS,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG/B;AAED;;;;GAIG;AACH,iBAAS,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED;;;GAGG;AACH,iBAAS,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAMpC;AA8DD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CASjD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAuB1E;AAID,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAGnC;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAMnC;AAED;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAQ7C;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAQ7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAoB7C;AAsBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CA2B7C;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAoBpC;AAED,wDAAwD;AACxD,iBAAS,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAahC;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAW3F;AAID;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAgBzD;AAWD;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAqCnC;AAwBD,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CA0CnC;AA6CD,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAiBnC;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAenC;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,CAmBtD;AA2CD,eAAO,MAAM,EAAE,EAAE,KAAuC,CAAC;AAmBzD,eAAO,MAAM,CAAC,EAAE,KAAsC,CAAC;AAYvD,eAAO,MAAM,KAAK,EAAE,KAA0C,CAAC;AAI/D,4CAA4C;AAC5C,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC"}