diff --git a/CHANGELOG.md b/CHANGELOG.md index 5b29c870..d9f20b93 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,13 @@ All notable changes to Coderive are documented in this file. +## [v0.8.4] - Formula Lock-In - April 12, 2026 + +### ✨ Major Updates +- **LinearRecurrenceFormula moved to constant-space evaluation** — Removed range-sized recurrence precomputation tables so recurrence evaluation no longer allocates memory proportional to covered range size. +- **Linear recurrence composition in NaturalArray** — `addLinearRecurrenceFormula(...)` now composes newly added formulas with existing recurrence formulas (newer-over-older), mirroring the optimized conditional formula path. +- **Recurrence lookup cache cleanup** — Removed per-index recurrence-formula index caching to avoid linear growth of recurrence metadata with random index access. + ## [v0.8.0] - Fancy Machine - April 07, 2026 ### ✨ Major Updates diff --git a/README.md b/README.md index 565f523d..cb89660e 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@
-[![Version](https://img.shields.io/badge/version-0.8.0-536af5?style=flat-square&logo=github)](https://github.com/DanexCodr/Coderive/releases) +[![Version](https://img.shields.io/badge/version-0.8.4-536af5?style=flat-square&logo=github)](https://github.com/DanexCodr/Coderive/releases) [![Java](https://img.shields.io/badge/requires-Java%207%2B-ed8b00?style=flat-square&logo=openjdk&logoColor=white)](https://adoptium.net/) [![License](https://img.shields.io/badge/license-MIT-f5de53?style=flat-square)](LICENSE) [![Stars](https://img.shields.io/github/stars/DanexCodr/Coderive?style=flat-square&color=7289da&logo=github)](https://github.com/DanexCodr/Coderive/stargazers) diff --git a/VERSION b/VERSION index a3df0a69..b60d7196 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.8.0 +0.8.4 diff --git a/docs/partials/drawer.html b/docs/partials/drawer.html index 6892bd52..5f16ed32 100644 --- a/docs/partials/drawer.html +++ b/docs/partials/drawer.html @@ -41,6 +41,6 @@

External Links

- © 2025- DanexCodr · Coderive 0.8.0 + © 2025- DanexCodr · Coderive 0.8.4
diff --git a/docs/partials/home.html b/docs/partials/home.html index 69c653d8..ce760442 100644 --- a/docs/partials/home.html +++ b/docs/partials/home.html @@ -149,7 +149,7 @@

Parameter Skipping

- © 2025- DanexCodr · Coderive 0.8.0 + © 2025- DanexCodr · Coderive 0.8.4
GitHub diff --git a/install.sh b/install.sh index 94b11a2e..a8e9fb31 100755 --- a/install.sh +++ b/install.sh @@ -26,7 +26,7 @@ warn() { echo -e " ${YELLOW}⚠${RESET} $*"; } fail() { echo -e " ${RED}✘${RESET} $*" >&2; exit 1; } # ── Config ─────────────────────────────────────────────────────────────────── -VERSION="$(cat "$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd || pwd)/VERSION" 2>/dev/null || echo "0.8.0")" +VERSION="$(cat "$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd || pwd)/VERSION" 2>/dev/null || echo "0.8.4")" INSTALL_DIR="${CODERIVE_HOME:-$HOME/.coderive}" BIN_DIR="${CODERIVE_BIN:-$HOME/.local/bin}" JAR_NAME="Coderive.jar" diff --git a/source_.jar b/source_.jar index bde6b065..9abe65c0 100644 Binary files a/source_.jar and b/source_.jar differ diff --git a/src/main/cod/demo/src/bin/test.linearrecurrenceoptimization/__StaticModule__.codb b/src/main/cod/demo/src/bin/test.linearrecurrenceoptimization/__StaticModule__.codb new file mode 100644 index 00000000..9629f4d8 Binary files /dev/null and b/src/main/cod/demo/src/bin/test.linearrecurrenceoptimization/__StaticModule__.codb differ diff --git a/src/main/java/cod/range/NaturalArray.java b/src/main/java/cod/range/NaturalArray.java index 2ef9b447..91519054 100644 --- a/src/main/java/cod/range/NaturalArray.java +++ b/src/main/java/cod/range/NaturalArray.java @@ -63,7 +63,6 @@ public class NaturalArray { private List sequenceFormulas = new ArrayList(); private List conditionalFormulas = new ArrayList(); private List linearRecurrenceFormulas = new ArrayList(); - private Map linearRecurrenceFormulaIndexCache = new HashMap(); private Map computedCache = new HashMap(); // Pending updates for lazy assignment @@ -1427,7 +1426,14 @@ public void addLinearRecurrenceFormula(LinearRecurrenceFormula formula) { ArrayTracker.recordFormulaApplication(this); } - linearRecurrenceFormulas.add(formula); + if (linearRecurrenceFormulas.isEmpty()) { + linearRecurrenceFormulas.add(formula); + } else { + int lastIndex = linearRecurrenceFormulas.size() - 1; + LinearRecurrenceFormula current = linearRecurrenceFormulas.get(lastIndex); + LinearRecurrenceFormula merged = LinearRecurrenceFormula.compose(formula, current); + linearRecurrenceFormulas.set(lastIndex, merged); + } clearCache(); } @@ -1435,9 +1441,6 @@ public void clearCache() { if (computedCache != null) { computedCache.clear(); } - if (linearRecurrenceFormulaIndexCache != null) { - linearRecurrenceFormulaIndexCache.clear(); - } clearRecentCache(); lastIndex = null; lastValue = null; @@ -1507,32 +1510,6 @@ private Object evaluateConditionalFormulas(long index) { private Object evaluateLinearRecurrenceFormulas(long index) { if (linearRecurrenceFormulas.isEmpty()) return null; - Integer cachedFormulaIndex = linearRecurrenceFormulaIndexCache.get(index); - if (cachedFormulaIndex != null) { - int idx = cachedFormulaIndex.intValue(); - if (idx >= 0 && idx < linearRecurrenceFormulas.size()) { - LinearRecurrenceFormula cachedFormula = linearRecurrenceFormulas.get(idx); - if (cachedFormula != null && cachedFormula.contains(index)) { - try { - Object cachedResult = cachedFormula.evaluate(index); - if (cachedResult != null) { - if (computedCache == null) { - computedCache = new HashMap(); - } - computedCache.put(index, cachedResult); - return cachedResult; - } - } catch (ProgramError e) { - throw e; - } catch (Exception e) { - throw new InternalError( - "Linear recurrence formula evaluation failed at index " + index, e); - } - } - } - linearRecurrenceFormulaIndexCache.remove(index); - } - for (int i = linearRecurrenceFormulas.size() - 1; i >= 0; i--) { LinearRecurrenceFormula formula = linearRecurrenceFormulas.get(i); if (formula == null) { @@ -1547,10 +1524,6 @@ private Object evaluateLinearRecurrenceFormulas(long index) { computedCache = new HashMap(); } computedCache.put(index, result); - if (linearRecurrenceFormulaIndexCache == null) { - linearRecurrenceFormulaIndexCache = new HashMap(); - } - linearRecurrenceFormulaIndexCache.put(index, i); } return result; } catch (ProgramError e) { diff --git a/src/main/java/cod/range/formula/LinearRecurrenceFormula.java b/src/main/java/cod/range/formula/LinearRecurrenceFormula.java index fea973bb..d0bc02be 100644 --- a/src/main/java/cod/range/formula/LinearRecurrenceFormula.java +++ b/src/main/java/cod/range/formula/LinearRecurrenceFormula.java @@ -12,7 +12,8 @@ public class LinearRecurrenceFormula { public final AutoStackingNumber[] seedValues; public final long seedStartIndex; private final boolean hasConstantTerm; - private final AutoStackingNumber[] precomputedValues; + private final LinearRecurrenceFormula newerFormula; + private final LinearRecurrenceFormula olderFormula; private static final AutoStackingNumber ZERO = AutoStackingNumber.fromLong(0L); private static final AutoStackingNumber ONE = AutoStackingNumber.fromLong(1L); @@ -34,19 +35,51 @@ public LinearRecurrenceFormula( this.seedStartIndex = seedStartIndex; this.order = coefficientsByLag != null ? coefficientsByLag.length : 0; this.hasConstantTerm = !this.constantTerm.isZero(); - this.precomputedValues = buildPrecomputedValues(); + this.newerFormula = null; + this.olderFormula = null; + } + + private LinearRecurrenceFormula(long start, long end, + LinearRecurrenceFormula newerFormula, + LinearRecurrenceFormula olderFormula) { + this.start = start; + this.end = end; + this.recurrenceStart = 0L; + this.order = 0; + this.coefficientsByLag = null; + this.constantTerm = ZERO; + this.seedValues = null; + this.seedStartIndex = 0L; + this.hasConstantTerm = false; + this.newerFormula = newerFormula; + this.olderFormula = olderFormula; + } + + public static LinearRecurrenceFormula compose(LinearRecurrenceFormula newerFormula, LinearRecurrenceFormula olderFormula) { + if (newerFormula == null) return olderFormula; + if (olderFormula == null) return newerFormula; + long mergedStart = Math.min(newerFormula.start, olderFormula.start); + long mergedEnd = Math.max(newerFormula.end, olderFormula.end); + return new LinearRecurrenceFormula(mergedStart, mergedEnd, newerFormula, olderFormula); } public boolean contains(long index) { + if (isComposite()) { + return (newerFormula != null && newerFormula.contains(index)) + || (olderFormula != null && olderFormula.contains(index)); + } return index >= start && index <= end; } public Object evaluate(long index) { - if (precomputedValues != null) { - if (index < start || index > end) { - return null; + if (isComposite()) { + if (newerFormula != null && newerFormula.contains(index)) { + return newerFormula.evaluate(index); } - return precomputedValues[(int) (index - start)]; + if (olderFormula != null && olderFormula.contains(index)) { + return olderFormula.evaluate(index); + } + return null; } if (order <= 0 || seedValues == null || seedValues.length != order) { @@ -98,60 +131,8 @@ public Object evaluate(long index) { return result[0]; } - private AutoStackingNumber[] buildPrecomputedValues() { - if (order <= 0 || seedValues == null || seedValues.length != order) { - return null; - } - - long total = end - start + 1L; - if (total <= 0L || total > Integer.MAX_VALUE) { - return null; - } - - int size = (int) total; - AutoStackingNumber[] table = new AutoStackingNumber[size]; - java.util.HashMap values = new java.util.HashMap(); - - for (int i = 0; i < seedValues.length; i++) { - values.put(seedStartIndex + i, seedValues[i]); - } - - long computeStart = Math.min(start, seedStartIndex); - for (long idx = computeStart; idx <= end; idx++) { - AutoStackingNumber value = values.get(idx); - boolean hasIndex = values.containsKey(idx); - if (value == null && !hasIndex) { - if (idx >= recurrenceStart) { - AutoStackingNumber sum = hasConstantTerm ? constantTerm : ZERO; - for (int lag = 1; lag <= order; lag++) { - long prevIndex = idx - lag; - AutoStackingNumber prev = values.get(prevIndex); - boolean hasPrev = values.containsKey(prevIndex); - if (prev == null && !hasPrev) { - sum = null; - break; - } - AutoStackingNumber coeff = coefficientsByLag[lag - 1]; - AutoStackingNumber safeCoeff = coeff != null ? coeff : ZERO; - if (prev == null) { - sum = null; - break; - } - sum = sum.add(safeCoeff.multiply(prev)); - } - value = sum; - } else { - value = null; - } - values.put(idx, value); - } - - if (idx >= start) { - table[(int) (idx - start)] = value; - } - } - - return table; + private boolean isComposite() { + return newerFormula != null || olderFormula != null; } private AutoStackingNumber[][] matrixPow(AutoStackingNumber[][] base, long exp) {