gracio 1.0.0 → 1.0.1

package/dist/test/advanced-arithmetic.test.js

@@ -0,0 +1,63 @@
+import { expect } from 'chai';
+import { Gracio } from '../src/gracio.js';
+import { calculateDrift } from '../src/audit-util.js';
+describe('Advanced Arithmetic Operations', () => {
+    describe('Powers (.pow)', () => {
+        it('should calculate positive integer powers correctly', () => {
+            const a = Gracio.fromInt(2);
+            a.pow(10n);
+            expect(a.toString()).to.equal("1024/1");
+            expect(calculateDrift(a, Math.pow(2, 10))).to.be.below(1e-15);
+        });
+        it('should handle zero exponent (x^0 = 1)', () => {
+            const a = new Gracio(3n, 7n);
+            a.pow(0n);
+            expect(a.toString()).to.equal("1/1");
+        });
+        it('should handle negative exponents by inverting the ratio', () => {
+            const a = new Gracio(1n, 2n); // 1/2
+            a.pow(-2n); // (1/2)^-2 = 2^2 = 4
+            expect(a.toString()).to.equal("4/1");
+            expect(calculateDrift(a, Math.pow(0.5, -2))).to.be.below(1e-15);
+        });
+        it('should handle fractional ratios raised to powers', () => {
+            const a = new Gracio(3n, 4n);
+            a.pow(2n); // (3/4)^2 = 9/16
+            expect(a.toString()).to.equal("9/16");
+            expect(calculateDrift(a, Math.pow(0.75, 2))).to.be.below(1e-15);
+        });
+    });
+    describe('Roots (.root)', () => {
+        it('should calculate square roots of perfect squares', () => {
+            const a = Gracio.fromInt(4);
+            const res = Gracio.root(2n, a);
+            expect(res.toString()).to.contain("2");
+        });
+        it('should calculate cube roots of perfect cubes', () => {
+            const a = Gracio.fromInt(27);
+            const res = Gracio.root(3n, a);
+            expect(res.toString()).to.contain("3");
+        });
+        it('should handle approximate roots correctly', () => {
+            const a = Gracio.fromInt(2);
+            const res = Gracio.root(2n, a);
+            // sqrt(2) approx 1.414213...
+            expect(res.toFloat()).to.be.closeTo(1.414213, 0.0001);
+        });
+    });
+    describe('Common Denominator Stress Test', () => {
+        it('should maintain high performance during long additive chains with same denominator', () => {
+            const iterations = 100_000;
+            const start = performance.now();
+            let rSum = Gracio.fromInt(0);
+            const step = new Gracio(1n, 3n);
+            for (let i = 0; i < iterations; i++) {
+                rSum.add(step);
+            }
+            const end = performance.now();
+            console.log(`\n  Additive chain (${iterations} ops) took: ${(end - start).toFixed(2)}ms`);
+            expect(rSum.toString()).to.equal(`${iterations}/3`);
+            expect(end - start).to.be.below(100); // Should be extremely fast now
+        });
+    });
+});

package/dist/test/basic-arithmetic.test.js

@@ -0,0 +1,40 @@
+// test/basic-arithmetic.ts
+import { expect } from 'chai';
+import { Gracio } from '../src/gracio.js';
+import { calculateDrift } from '../src/audit-util.js';
+describe('Basic Arithmetic Operations', () => {
+    describe('Addition', () => {
+        it('should add two large numbers accurately', async () => {
+            const a = Gracio.fromInt(999999999999999);
+            const b = Gracio.fromInt(1);
+            const result = a.add(b);
+            expect(result.toString()).to.equal("1000000000000000/1");
+            expect(calculateDrift(result, 999999999999999 + 1)).to.be.below(1e-15);
+        });
+        it('should add decimal fractions accurately', async () => {
+            const a = new Gracio(1n, 10n);
+            const b = new Gracio(2n, 10n);
+            const result = a.add(b);
+            expect(result.toString()).to.equal("3/10");
+            expect(calculateDrift(result, 0.1 + 0.2)).to.be.below(1e-15);
+        });
+    });
+    describe('Multiplication', () => {
+        it('should multiply large numbers accurately', async () => {
+            const a = Gracio.fromInt(10000000000000000);
+            const b = Gracio.fromInt(10000000000000000);
+            const result = a.multiply(b);
+            expect(result.toString()).to.equal("100000000000000000000000000000000/1");
+            expect(calculateDrift(result, 10000000000000000 * 10000000000000000)).to.be.below(1e-15);
+        });
+    });
+    describe('Division', () => {
+        it('should divide accurately', async () => {
+            const a = Gracio.fromInt(10);
+            const b = Gracio.fromInt(3);
+            const result = a.divide(b);
+            expect(result.toString()).to.equal("10/3");
+            expect(calculateDrift(result, 10 / 3)).to.be.below(1e-15);
+        });
+    });
+});

package/dist/test/precision-comparison.test.js

@@ -0,0 +1,40 @@
+import { expect } from 'chai';
+import { Gracio } from '../src/gracio.js';
+import { auditOperation } from '../src/audit-util.js';
+describe('Precision & Performance Audit', () => {
+    it('should audit simple additive loops (The Common Denominator Case)', async () => {
+        const iterations = 10_000;
+        const stepValue = 0.1;
+        const exactResult = stepValue * iterations;
+        // Ratio setup: we want to measure the .add() loop specifically
+        let rSum = Gracio.fromInt(0);
+        const stepRatio = new Gracio(1n, 10n);
+        // Float setup
+        let fSum = 0;
+        const metrics = await auditOperation('Additive Loop (0.1 * N)', () => {
+            rSum.add(stepRatio);
+            return rSum; // Return the object so we can extract value at end
+        }, () => {
+            fSum += stepValue;
+            return fSum;
+        }, exactResult, (res) => res.toFloat(), iterations);
+        expect(metrics.performanceTax).to.be.below(10); // Should be very efficient now
+    });
+    it('should audit multiplicative chains', async () => {
+        const iterations = 1_000;
+        const stepValue = 1.1;
+        const exactResult = Math.pow(stepValue, iterations);
+        let rVal = Gracio.fromInt(1);
+        const stepRatio = new Gracio(11n, 10n);
+        let fVal = 1.0;
+        const metrics = await auditOperation('Multiplicative Chain (1.1 ^ N)', () => {
+            rVal.multiply(stepRatio);
+            return rVal;
+        }, () => {
+            fVal *= stepValue;
+            return fVal;
+        }, exactResult, (res) => res.toFloat(), iterations);
+        // Multiplicative chains grow numbers fast, so the tax will be higher than additive
+        expect(Number.isFinite(metrics.performanceTax)).to.be.true;
+    });
+});

package/dist/test/src/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gracio",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A high-performance, arbitrary-precision rational arithmetic library for TypeScript and JavaScript.",
   "author": "gglobensky",
   "license": "MIT",