From d2e695d94160915a2527ce7d3467cd24ea989ed8 Mon Sep 17 00:00:00 2001 From: Gbemiro Jiboye Date: Wed, 18 Mar 2026 23:36:44 +0100 Subject: [PATCH] text fixes --- INTEGRATOR.md | 54 +++++++++---------- .../turbo/ScalarTurboEvaluatorTest.java | 35 +++++++----- 2 files changed, 48 insertions(+), 41 deletions(-) diff --git a/INTEGRATOR.md b/INTEGRATOR.md index 21dae35..323371b 100755 --- a/INTEGRATOR.md +++ b/INTEGRATOR.md @@ -6,7 +6,7 @@ ## Executive Summary -| Metric | Your Integrator | Gaussian | Chebyshev | Simpson | Romberg | +| Metric | NumericalIntegrator | Gaussian | Chebyshev | Simpson | Romberg | |--------|---------|----------|-----------|---------|---------| | **Smooth Function Accuracy** | 15-16 digits | 15-16 digits | 12-14 digits | 6-8 digits | 10-12 digits | | **Log Singularity Handling** | **5-6 digits ✓** | 2-3 digits ✗ | 3-4 digits ✗ | Fails ✗ | Fails ✗ | @@ -25,7 +25,7 @@ ### 1. Singularity Handling -#### Your Integrator +#### NumericalIntegrator - ✅ Auto-detects logarithmic singularities at boundaries - ✅ Auto-detects power-law singularities (√-type) - ✅ Detects internal poles via spike detection @@ -69,7 +69,7 @@ double result = gaussianQuad(x -> 1/Math.sqrt(x), 0, 1); ### 2. Large Domain Compression -#### Your Integrator: [1, 200] +#### NumericalIntegrator: [1, 200] ``` Interval size: 199 units Strategy: Logarithmic map compresses [1,200] → [-1,1] @@ -101,13 +101,13 @@ Accuracy: Error > 0.03 (50% wrong) | Method | Result | Error | Time | Status | |--------|--------|-------|------|--------| -| **Your Integrator** | 0.0650624 | 1e-7 | 1100ms | ✓ Converged | +| **NumericalIntegrator** | 0.0650624 | 1e-7 | 1100ms | ✓ Converged | | Gaussian Quadrature | 0.0312456 | 0.034 | >5000ms | ✗ Timeout | | Chebyshev | (hangs) | — | >5000ms | ✗ Never converges | | Simpson (1M points) | 0.0523891 | 0.0127 | >10000ms | ✗ Too slow | | Romberg | Oscillates | undefined | — | ✗ Diverges | -**Why Your Integrator Wins:** +**Why NumericalIntegrator Wins:** 1. Logarithmic map concentrates nodes where needed 2. Aliasing detection catches undersampling 3. Adaptive subdivision refines oscillatory regions @@ -120,7 +120,7 @@ Accuracy: Error > 0.03 (50% wrong) ### Test 1: Smooth Function - `∫₀^π sin(x) dx = 2` ``` -Your Integrator: +NumericalIntegrator: Result: 2.0000000000000 Error: 0.0 Time: 250 ms @@ -146,14 +146,14 @@ Romberg (1e-10): ``` **Verdict:** Gaussian is fastest, but all deliver 16 digits. -**Your integrator** trades speed for **robustness** on harder problems. +**NumericalIntegrator** trades speed for **robustness** on harder problems. --- ### Test 2: Logarithmic Singularity - `∫₀.₀₀₁^1 ln(x) dx ≈ -0.992` ``` -Your Integrator: +NumericalIntegrator: Result: -0.9920922447210182 Error: 9.224472101820869e-5 Time: 30 ms @@ -194,7 +194,7 @@ Romberg (1e-10): ### Test 3: Power-Law Singularity - `∫₀.₀₀₁^1 1/√x dx ≈ 1.937` ``` -Your Integrator: +NumericalIntegrator: Result: 1.936754446796634 Error: 0.00024555 Time: 27 ms @@ -235,7 +235,7 @@ Romberg (1e-10): ### Test 4: Internal Pole - `∫₀.₁^0.49 1/(x-0.5) dx` (Pole at x=0.5) ``` -Your Integrator: +NumericalIntegrator: Result: -3.688879454113936 Error: — Time: 11 ms @@ -290,7 +290,7 @@ YOUR INTEGRATOR ████████ ██████░░ ████ ### 1. Adaptive Coordinate Transformations -Your integrator selects the optimal map based on function behavior: +NumericalIntegrator selects the optimal map based on function behavior: | Scenario | Map Used | Why | Benefit | |----------|----------|-----|---------| @@ -322,7 +322,7 @@ If initial tail error is > 1e6 but no poles detected: ### 3. Timeout Protection ```java -// Your integrator: Guaranteed to finish +// NumericalIntegrator: Guaranteed to finish integrate(f, 0, 1); // Max 1.5 seconds // Returns result or throws TimeoutException @@ -335,7 +335,7 @@ gaussianQuad(f, 0, 1); // May never return ### 4. Pole Detection and Handling -**Your Integrator:** +**NumericalIntegrator:** 1. Scans for internal poles (spike detection) 2. Refines pole location (ternary search: 60 iterations, 1e-16 precision) 3. Checks divergence (even vs. odd pole) @@ -352,7 +352,7 @@ gaussianQuad(f, 0, 1); // May never return ### 5. Relative Threshold Deduplication ```java -// Your integrator +// NumericalIntegrator double threshold = (b - a) * 1e-11; // Scales with interval // Prevents false duplicates on small intervals // Prevents merging distinct poles on large intervals @@ -393,7 +393,7 @@ double threshold = (b - a) * 1e-11; // Scales with interval **Example:** Archival/reference computations -### Use **Your Integrator** When: +### Use **NumericalIntegrator** When: - ✅ Function behavior is unknown - ✅ Must handle singularities - ✅ Can't afford crashes (production systems) @@ -420,17 +420,17 @@ Internal pole | 11 | Crash | Crash | Crash | Crash Oscillatory [1,200] | 1100 | Timeout | Timeout | Timeout | Diverge ``` -**Key insight:** Your integrator is slower on smooth functions (10-100x) but is the **only** one on pathological inputs. +**Key insight:** NumericalIntegrator is slower on smooth functions (10-100x) but is the **only** one on pathological inputs. --- ## Code Examples -### Example 1: Smooth Function (Your Integrator is Slower) +### Example 1: Smooth Function (NumericalIntegrator is Slower) ```java // Smooth function: sin(x) -IntegrationCoordinator1 ic = new IntegrationCoordinator1(); +NumericalIntegrator ic = new NumericalIntegrator(); double result = ic.integrate(x -> Math.sin(x), 0, Math.PI); // Time: 250 ms, Accuracy: 16 digits ✓ @@ -439,11 +439,11 @@ double result_g = gaussianQuad(x -> Math.sin(x), 0, Math.PI); // Time: 15 ms, Accuracy: 16 digits ✓ ``` -### Example 2: Singular Function (Your Integrator Dominates) +### Example 2: Singular Function (NumericalIntegrator Dominates) ```java // Singular function: ln(x) -IntegrationCoordinator1 ic = new IntegrationCoordinator1(); +NumericalIntegrator ic = new NumericalIntegrator(); double result = ic.integrate(x -> Math.log(x), 0.001, 1.0); // Time: 30 ms, Accuracy: 5 digits ✓✓✓ @@ -453,11 +453,11 @@ double result_g = gaussianQuad(x -> Math.log(x), 0.001, 1.0); // Error: 0.015 (1.5% off) ``` -### Example 3: Internal Pole (Your Integrator Only Works) +### Example 3: Internal Pole (NumericalIntegrator Only Works) ```java // Function with internal pole at x=0.5 -IntegrationCoordinator1 ic = new IntegrationCoordinator1(); +NumericalIntegrator ic = new NumericalIntegrator(); double result = ic.integrate(x -> 1/(x - 0.5), 0.1, 0.49); // Time: 11 ms // Result: -3.6889... ✓ (correctly integrated around pole) @@ -477,7 +477,7 @@ double result_g = gaussianQuad(x -> 1/(x - 0.5), 0.1, 0.49); - **5-6 digits**: 5-6 significant figures (1e-5 to 1e-6 relative error) - **3-4 digits**: 3-4 significant figures (1e-3 to 1e-4 relative error) -### Your Integrator's Accuracy Guarantees +### NumericalIntegrator's Accuracy Guarantees ``` Function Class | Guaranteed Accuracy | Method @@ -493,7 +493,7 @@ Oscillatory (limited) | 2-4 digits | Adaptive subdivision ## Computational Complexity -### Your Integrator +### NumericalIntegrator - **Best case** (smooth): O(N log N) where N=256 nodes - **Worst case** (singular): O(2^d · N) where d ≤ 18 (max depth) @@ -527,7 +527,7 @@ Oscillatory (limited) | 2-4 digits | Adaptive subdivision - **Gaussian Quadrature:** Golub & Welsch (1969), "Calculation of Gauss Quadrature Rules" - **Clenshaw-Curtis:** Clenshaw & Curtis (1960), "A method for numerical integration..." - **Adaptive Methods:** De Doncker et al., "Quadpack: A Subroutine Package for Automatic Integration" -- **Your Integrator Inspiration:** GSL (GNU Scientific Library) quad integration +- **NumericalIntegrator Inspiration:** GSL (GNU Scientific Library) quad integration --- @@ -551,7 +551,7 @@ Speed Smooth functions Pathological functions Robu ### The Killer Quote -> *"While Gaussian Quadrature is 10x faster on smooth integrands, IntegrationCoordinator1 is the **only** integrator that handles singular, oscillatory, and pathological functions without crashing, timing out, or returning garbage. Choose speed when you know your function is well-behaved. Choose robustness when you don't."* +> *"While Gaussian Quadrature is 10x faster on smooth integrands, NumericalIntegrator is the **only** integrator that handles singular, oscillatory, and pathological functions without crashing, timing out, or returning garbage. Choose speed when you know your function is well-behaved. Choose robustness when you don't."* --- @@ -572,4 +572,4 @@ Speed Smooth functions Pathological functions Robu --- -**Conclusion:** Use Your Integrator for production systems where reliability matters more than raw speed. Use Gaussian if you know your function is smooth and speed is critical. \ No newline at end of file +**Conclusion:** Use NumericalIntegrator for production systems where reliability matters more than raw speed. Use Gaussian if you know your function is smooth and speed is critical. \ No newline at end of file diff --git a/src/test/java/com/github/gbenroscience/parser/turbo/ScalarTurboEvaluatorTest.java b/src/test/java/com/github/gbenroscience/parser/turbo/ScalarTurboEvaluatorTest.java index be8f0a5..5bd04bb 100755 --- a/src/test/java/com/github/gbenroscience/parser/turbo/ScalarTurboEvaluatorTest.java +++ b/src/test/java/com/github/gbenroscience/parser/turbo/ScalarTurboEvaluatorTest.java @@ -147,7 +147,6 @@ public void testSum() throws Throwable { double[] vars = new double[0]; double v1 = compiled.applyScalar(vars); Assertions.assertEquals(v, v1); - } @Test @@ -205,7 +204,7 @@ public void testComplexExpression(boolean withFolding) throws Throwable { @Test public void testWithVariablesSimple() throws Throwable { - System.out.println("\n=== WITH VARIABLES: SIMPLE; FOLDING OFF ===\n"); + String expr = "x*sin(x)+2"; @@ -227,8 +226,7 @@ public void testWithVariablesSimple() throws Throwable { @Test public void testWithVariablesAdvanced() throws Throwable { - System.out.println("\n=== WITH VARIABLES: ADVANCED; FOLDING OFF ===\n"); - + String expr = "x=0;y=0;z=0;x*sin(x) + y*sin(y) + z / cos(x - y) + sqrt(x^2 + y^2)"; MathExpression interpreted = new MathExpression(expr, false); @@ -252,8 +250,7 @@ public void testWithVariablesAdvanced() throws Throwable { @Test public void testConstantFolding() throws Throwable { - System.out.println("\n=== CONSTANT FOLDING; FOLDING OFF ===\n"); - + String expr = "2^10 + 3^5 - 4! + sqrt(256)"; MathExpression interpreted = new MathExpression(expr, false); @@ -270,8 +267,7 @@ public void testConstantFolding() throws Throwable { @Test public void testQuadratic() throws Throwable { - System.out.println("\n=== QUADRATIC ROOTS: SIMPLE; ===\n"); - + String expr = "quadratic(@(x)3*x^2-4*x-18)"; MathExpression interpreted = new MathExpression(expr, false); @@ -287,8 +283,7 @@ public void testQuadratic() throws Throwable { @Test public void testTartaglia() throws Throwable { - System.out.println("\n=== Tartaglia's roots: SIMPLE; ===\n".toUpperCase()); - + String expr = "t_root(@(x)3*x^3-4*x-18)"; MathExpression interpreted = new MathExpression(expr, false); @@ -299,10 +294,22 @@ public void testTartaglia() throws Throwable { TurboExpressionEvaluator tee = TurboEvaluatorFactory.getCompiler(interpreted); FastCompositeExpression fce = tee.compile(); double[] v1 = fce.applyVector(vars); - System.out.println("v = "+Arrays.toString(v)); - System.out.println("v1 = "+Arrays.toString(v1)); - - + Assertions.assertTrue(Arrays.toString(v).equals(Arrays.toString(v1))); } + + @Test + public void testGeneralRoot() throws Throwable {//-1.8719243686213027618871370090528, -3.2052577019546360952204703423861 + + String expr = "root(@(x)3*x^3-4*x-18,2)"; + MathExpression interpreted = new MathExpression(expr, false); + + double[] vars = new double[0]; + + double v = interpreted.solveGeneric().scalar; + TurboExpressionEvaluator tee = TurboEvaluatorFactory.getCompiler(interpreted); + FastCompositeExpression fce = tee.compile(); + double v1 = fce.applyScalar(vars); + + } }