BigNumOpsVerify.sleela
lib/math/examples/BigNumOpsVerify.sleela · 114 line(s) · sleela
<< 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"); }
}
}