Home /Modules/math/BigNumOpsVerify.sleela

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"); }
  }
}