<< lib/math/examples/BigNumOpsVerify.sleela SLeeLa Standard Library Definition. Definition: Regression guard for the native big-integer op set -- bigmul (now with an NTT fast path above 512 limbs), bigadd, and bigdivmod. It checks each native op against a pure-SLeeLa reference across sizes that exercise both the Karatsuba and NTT multiply paths, and must report PASS. >> #sleela 2.5 material; class BigNumOpsVerify { < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- > << Baseline identity for a worker-class example. >> String metaVersion = "1.0.0"; int metaId = 7908; String metaAuthor = "Max Rupplin"; String metaDate = "2026-11-06"; String metaCopyright = "MEARVK LLC"; String metaTrademark = "none"; String metaCorporation = "MEARVK LLC"; String metaOrigin = "International"; String metaBirthDate = "2026-11-06"; int metaScienceRating = 7; String metaNationalSchedule = "none"; String getMetaVersion() { return metaVersion; } void setMetaVersion(String v) { metaVersion = v; } int getMetaId() { return metaId; } void setMetaId(int v) { metaId = v; } String getAuthor() { return metaAuthor; } void setAuthor(String v) { metaAuthor = v; } String getDate() { return metaDate; } void setDate(String v) { metaDate = v; } String getCopyright() { return metaCopyright; } void setCopyright(String v) { metaCopyright = v; } String getTrademark() { return metaTrademark; } void setTrademark(String v) { metaTrademark = v; } String getCorporation() { return metaCorporation; } void setCorporation(String v) { metaCorporation = v; } String getOrigin() { return metaOrigin; } void setOrigin(String v) { metaOrigin = v; } String getBirthDate() { return metaBirthDate; } void setBirthDate(String v) { metaBirthDate = v; } int getScienceRating() { return metaScienceRating; } void setScienceRating(int v) { metaScienceRating = v; } String getNationalSchedule() { return metaNationalSchedule; } void setNationalSchedule(String v) { metaNationalSchedule = v; } int school(int[] a, int na, int[] b, int nb, int[] r) { int i = 0; while (i < na + nb) { r[i] = 0; i = i + 1; } i = 0; while (i < na) { long carry = 0; long ai = a[i]; int j = 0; while (j < nb) { long cur = r[i + j] + ai * b[j] + carry; r[i + j] = (int) (cur % 1000000000); carry = cur / 1000000000; j = j + 1; } int k = i + nb; while (carry > 0) { long cur = r[k] + carry; r[k] = (int) (cur % 1000000000); carry = cur / 1000000000; k = k + 1; } i = i + 1; } int sig = na + nb; while (sig > 1 && r[sig - 1] == 0) { sig = sig - 1; } return sig; } int fillRandom(int[] x, int n, int seed) { int i = 0; int s = seed; while (i < n) { s = (s * 48271 + 1) % 1000000000; if (s < 0) { s = 0 - s; } x[i] = s; i = i + 1; } return s; } int mulMismatch(int n, int seed) { int[] x = new int[n]; int[] y = new int[n]; int s = fillRandom(x, n, seed); fillRandom(y, n, s); int[] rn = new int[n + n]; int[] rs = new int[n + n]; int signtt = bigmul(x, y, rn); int sigsc = school(x, n, y, n, rs); int m = 0; if (signtt != sigsc) { m = m + 1; } int k = 0; while (k < n + n) { if (rn[k] != rs[k]) { m = m + 1; } k = k + 1; } return m; } void main() { print("Native big-integer op regression"); boolean ok = true; < multiply: Karatsuba path (small) and NTT path (>=512 limbs) > int mk = mulMismatch(100, 7); int mn = mulMismatch(600, 11); int mn2 = mulMismatch(2000, 17); print(" bigmul Karatsuba (100 limbs): mismatches=" + mk); print(" bigmul NTT (600 limbs): mismatches=" + mn); print(" bigmul NTT (2000 limbs): mismatches=" + mn2); if (mk != 0 || mn != 0 || mn2 != 0) { ok = false; } < bigadd: 999999999 + 1 = [0,1] > int[] a1 = new int[1]; a1[0] = 999999999; int[] b1 = new int[1]; b1[0] = 1; int[] s1 = new int[2]; int sg = bigadd(a1, b1, s1); boolean addOk = sg == 2 && s1[0] == 0 && s1[1] == 1; print(" bigadd 999999999+1: " + (addOk ? "ok" : "FAIL")); if (!addOk) { ok = false; } < bigdivmod: (123456789*1e9 + 500000000) / 7 = 17636684214285714 r 2 > int[] d1 = new int[2]; d1[0] = 500000000; d1[1] = 123456789; int[] q1 = new int[2]; int rem = bigdivmod(d1, 7, q1); boolean divOk = rem == 2 && q1[0] == 214285714 && q1[1] == 17636684; print(" bigdivmod /7: " + (divOk ? "ok" : "FAIL") + " rem=" + rem); if (!divOk) { ok = false; } if (ok) { print("RESULT: PASS - all native big-integer ops match references"); } else { print("RESULT: FAIL - a native big-integer op diverged"); } } }