code wiki / (root) / nx_fieldfit_lib.nx
`nx_fieldfit_lib.nx` source

↩ module page · 519 lines · 22307 B
1// nx_fieldfit_lib.nx -- FIT A PARAMETRIC IMPLICIT FIELD TO A SCANNED ORACLE. The machinery nx_skullsdf's `tune` grew
2// (anatomy AN17, 2026-09-18/19), extracted so any anatomy field -- a skull, an arm, a foot, a muscle belly, a tissue
3// layer -- is fitted by ONE optimiser with ONE objective and ONE fit-file contract, and a defect fixed here is fixed for
4// every field at once. The consumer hands over three functions as VALUES (NishiLang func-pointer locals and fields,
5// indirect calls up to six arguments):
6//   field(px, py, pz, a, b, P) -> signed distance at `fq` units per millimetre (negative inside) for parameter vector P,
7//                                 with a and b the consumer's two policy knobs (the skull passes sex and robusticity)
8//   region(x, y, z)            -> 0 .. nreg-1, the named anatomical region a point belongs to
9//   live(k)                    -> 1 for a station the field reads, 0 for a retired one (the descent skips it: two
10//                                 evaluations spent on a dead station are a pass that cannot move anything)
11//
12// THE OBJECTIVE IS TWO-SIDED, AND IT HAS TO BE. A one-directional score -- how far is each ORACLE point from my surface --
13// is trivially gamed by DELETING GEOMETRY: the skull's first tuning run shrank its orbits from 22 mm to 8 and its
14// maxilla from 30 mm to 13, improving the number 40 percent by filling in the eye sockets, because surface that does not
15// exist cannot be wrong. The REVERSE term charges every lattice point on OUR zero level its distance to the nearest
16// oracle sample, so a deleted feature is EXPENSIVE by construction. (The reverse term uses the nearest oracle VERTEX from
17// a spatial hash: an upper bound on the true point-to-surface distance -- it can overstate, never understate, the safe
18// direction for a penalty.)
19// THE OBJECTIVE IS REGION-BALANCED. A plain mean is dominated by whatever region has the most samples (the skull's vault
20// and base held 9,335 + 8,672 of ~31,000, so a 49 mm muzzle and 4 mm drilled orbits read as a 4 mm skull and the
21// surface objective fell 629 -> 531 while the chin moved +4 -> +19.6 mm). Each side is the mean of the PER-REGION means
22// (a region with no samples abstains), so the smallest region weighs what the largest does. No weight is typed: the
23// population decides.
24// THE DESCENT is coordinate descent: per live station try +step then -step, keep a move only if the MEASURED objective
25// falls; the step halves per pass, floor 1. No change is ever kept on the strength of looking better.
26// THE FIT FILE is newline-separated integers, loaded as a PREFIX: a file shorter than the vector applies to its first
27// entries and the rest keep their defaults, so growing a parametrisation never discards banked convergence; a file
28// shorter than `minlen` changes nothing (parsed into a temp and applied only when long enough, so a truncated write
29// cannot half-poison a field). Written whole by ff_save.
30// UNITS: objectives are reported in centi-millimetres; `lat` (the reverse lattice spacing), `ext` (the half-extent the
31// hash covers) and `dim` (cells per axis) are the consumer's, taken from the resource it fits.
32// LIB, no main. license_tier: ORIGINAL. No hw writes (Rule 26).
33import "nx_syscalls.nx"
34import "nx_atomic_rewrite.nx"
35
36const FF_I64: i64 = 8
37const FF_CENTI: i64 = 100                  // objectives are centi-millimetres
38const FF_CTX_BYTES: i64 = 256              // FfCtx: 21 fields of 8 bytes, one page-rounded map
39const FF_LOAD_HDR: i64 = 16                // the two-word length record sys_read_file fills
40const FF_SAVE_DIGITS: i64 = 16             // bytes reserved per integer on save (sign + 19 digits fits a page-rounded map)
41const FF_SAVE_SLACK: i64 = 64
42const FF_MODE644: i64 = 420
43
44// THE THIRD TERM, OPTIONAL: `extra(P)` returns a further mean error in centi-millimetres the consumer derives from its
45// own stations against the ruler's ORACLE readings (a landmark term: where the field PLACES its features against
46// where the ruler FOUND them on the oracle). MEASURED NEED (skull, 2026-09-19): with the two surface terms alone the
47// descent closed the orbit sockets to 2 mm slits and deepened the aperture to a 35 mm tunnel, because a surface
48// objective cannot see an opening; the ruler read 4 of 15 quantities in band. With has_extra = 1 the objective is the
49// three-way mean of the three error means (all centi-mm, no weight typed); the consumer's REAL ruler still judges the
50// emitted mesh outside the loop, so the term is a surrogate with a stated error, never the verdict.
51struct FfCtx { field: func(i64,i64,i64,i64,i64,*i64) -> i64, region: func(i64,i64,i64) -> i64, live: func(i64) -> i64, RX: *i64, RY: *i64, RZ: *i64, RG: *i64, n: i64, head: *i64, next: *i64, ext: i64, dim: i64, lat: i64, a: i64, b: i64, fq: i64, nreg: i64, sum: *i64, cnt: *i64, np: i64, cap: i64, extra: func(*i64) -> i64, has_extra: i64 }
52
53// a context sized for `cap` oracle samples, `np` stations, `nreg` regions, a dim^3 hash over +/- ext mm, lattice lat mm
54func ff_ctx_new(np: i64, nreg: i64, cap: i64, ext: i64, dim: i64, lat: i64, fq: i64) -> *FfCtx {
  let c: *FfCtx = (sys_mmap(FF_CTX_BYTES)) as *FfCtx
  c.np = np; c.nreg = nreg; c.cap = cap; c.ext = ext; c.dim = dim; c.lat = lat; c.fq = fq
  c.RX = sys_mmap(cap*FF_I64) as *i64
  c.RY = sys_mmap(cap*FF_I64) as *i64
  c.RZ = sys_mmap(cap*FF_I64) as *i64
  c.RG = sys_mmap(cap*FF_I64) as *i64
  c.next = sys_mmap(cap*FF_I64) as *i64
  c.head = sys_mmap(dim*dim*dim*FF_I64) as *i64
  c.sum = sys_mmap(nreg*FF_I64) as *i64
  c.cnt = sys_mmap(nreg*FF_I64) as *i64
  c.n = 0; c.a = 0; c.b = 0; c.has_extra = 0
  return c
67}
68
69// ==== the spatial hash over the oracle samples ====
70func ff_cell(c: *FfCtx, x: i64, y: i64, z: i64) -> i64 {
  let d: i64 = c.dim
  let e: i64 = c.ext
  var i: i64 = (x + e) * d / (e*2)
  var j: i64 = (y + e) * d / (e*2)
  var k: i64 = (z + e) * d / (e*2)
  if i < 0 { i = 0 }
  if j < 0 { j = 0 }
  if k < 0 { k = 0 }
  if i >= d { i = d-1 }
  if j >= d { j = d-1 }
  if k >= d { k = d-1 }
  return (i*d + j)*d + k
83}
84// bucket the oracle samples so the reverse term does not scan all of them per query
85func ff_bin(c: *FfCtx) -> i64 {
  let d: i64 = c.dim
  let head: *i64 = c.head
  let next: *i64 = c.next
  var q: i64 = 0
  while q < d*d*d { head[q] = 0-1; q = q + 1 }
  var i: i64 = 0
  while i < c.n {
      let h: i64 = ff_cell(c, c.RX[i], c.RY[i], c.RZ[i])
      next[i] = head[h]
      head[h] = i
      i = i + 1
  }
  return 0
99}
100// nearest oracle sample to (x,y,z) in whole millimetres, searching the home cell then one ring out; ext when none
101func ff_near(c: *FfCtx, x: i64, y: i64, z: i64) -> i64 {
  let d: i64 = c.dim
  let e: i64 = c.ext
  let RX: *i64 = c.RX
  let RY: *i64 = c.RY
  let RZ: *i64 = c.RZ
  let head: *i64 = c.head
  let next: *i64 = c.next
  var ci: i64 = (x + e) * d / (e*2)
  var cj: i64 = (y + e) * d / (e*2)
  var ck: i64 = (z + e) * d / (e*2)
  var best: i64 = 0-1
  var r: i64 = 0
  while r <= 1 {
      var di: i64 = 0 - r
      while di <= r {
          var dj: i64 = 0 - r
          while dj <= r {
              var dk: i64 = 0 - r
              while dk <= r {
                  let ii: i64 = ci+di
                  let jj: i64 = cj+dj
                  let kk: i64 = ck+dk
                  if ii >= 0 { if ii < d { if jj >= 0 { if jj < d { if kk >= 0 { if kk < d {
                      var p: i64 = head[(ii*d + jj)*d + kk]
                      while p >= 0 {
                          let ddx: i64 = x-RX[p]
                          let ddy: i64 = y-RY[p]
                          let ddz: i64 = z-RZ[p]
                          let d2: i64 = ddx*ddx + ddy*ddy + ddz*ddz
                          if best < 0 { best = d2 } else { if d2 < best { best = d2 } }
                          p = next[p]
                      }
                  } } } } } }
                  dk = dk + 1
              }
              dj = dj + 1
          }
          di = di + 1
      }
      if best >= 0 { r = 2 } else { r = r + 1 }
  }
  if best < 0 { return e }
  return ff_isqrt(best)
145}
146func ff_isqrt(v: i64) -> i64 { if v<=0 { return 0 } var x: i64=v; var y: i64=(x+1)/2; while y<x { x=y; y=(x+v/x)/2 } return x }
147
148// each oracle sample's region, classified ONCE per fit (the consumer's boxes may follow its loaded vector; they hold
149// for the run)
150func ff_regions(c: *FfCtx) -> i64 {
  var i: i64 = 0
  while i < c.n { c.RG[i] = c.region(c.RX[i], c.RY[i], c.RZ[i]); i = i + 1 }
  return 0
154}
155
156// ==== the region tables: the mean of the per-region means ====
157func ff_rtab_reset(c: *FfCtx) -> i64 {
  var r: i64 = 0
  while r < c.nreg { c.sum[r] = 0; c.cnt[r] = 0; r = r + 1 }
  return 0
161}
162// centi-mm from sums carried at `fq` units per mm; no region at all is the worst answer (ext mm)
163func ff_rtab_mean(c: *FfCtx, fq: i64) -> i64 {
  var acc: i64 = 0
  var nr: i64 = 0
  var r: i64 = 0
  while r < c.nreg {
      if c.cnt[r] > 0 { acc = acc + c.sum[r]*FF_CENTI/(c.cnt[r]*fq); nr = nr + 1 }
      r = r + 1
  }
  if nr == 0 { return c.ext*FF_CENTI }
  return acc/nr
173}
174// forward: each oracle sample's |field|, balanced over regions
175func ff_score_fwd(c: *FfCtx, P: *i64) -> i64 {
  ff_rtab_reset(c)
  var i: i64 = 0
  while i < c.n {
      var d: i64 = c.field(c.RX[i], c.RY[i], c.RZ[i], c.a, c.b, P)
      if d < 0 { d = 0 - d }
      let r: i64 = c.RG[i]
      c.sum[r] = c.sum[r] + d
      c.cnt[r] = c.cnt[r] + 1
      i = i + 1
  }
  if c.n == 0 { return 0 }
  return ff_rtab_mean(c, c.fq)
188}
189// reverse: every lattice point within half a step of our zero level, charged its distance to the nearest oracle sample
190func ff_score_rev(c: *FfCtx, P: *i64) -> i64 {
  ff_rtab_reset(c)
  let e: i64 = c.ext
  let step: i64 = c.lat
  let bq: i64 = step*c.fq
  var cnt: i64 = 0
  var x: i64 = 0 - e
  while x <= e {
      var y: i64 = 0 - e
      while y <= e {
          var z: i64 = 0 - e
          while z <= e {
              let d: i64 = c.field(x, y, z, c.a, c.b, P)
              if d > 0 - bq { if d < bq {
                  let r: i64 = c.region(x, y, z)
                  c.sum[r] = c.sum[r] + ff_near(c, x, y, z)
                  c.cnt[r] = c.cnt[r] + 1
                  cnt = cnt + 1
              } }
              z = z + step
          }
          y = y + step
      }
      x = x + step
  }
  if cnt == 0 { return e*FF_CENTI }
  return ff_rtab_mean(c, 1)
217}
218// the objective: the mean of both directions, so neither can be gamed alone; with a consumer's extra term, the mean
219// of the three (every term a mean error in centi-mm, so no weight is typed)
220func ff_score2(c: *FfCtx, P: *i64) -> i64 {
  let f: i64 = ff_score_fwd(c, P)
  let r: i64 = ff_score_rev(c, P)
  if c.has_extra == 1 {
      let e: i64 = c.extra(P)
      return (f + r + e)/3
  }
  return (f + r)/2
228}
229func ff_live_count(c: *FfCtx) -> i64 {
  var lv: i64 = 0
  var k: i64 = 0
  while k < c.np { lv = lv + c.live(k); k = k + 1 }
  return lv
234}
235func ff_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
236func ff_pn(v: i64) -> i64 {
  let b: *u8 = sys_mmap(32)
  let o: i64 = ff_wint(b, 0, v)
  sys_write(1, b, o)
  return 0
241}
242// COORDINATE DESCENT from P: returns the best objective; P holds the accepted vector. Convergence is PRINTED per pass
243// when verbose ({"pass":k,"step":s,"best_centi":b}), never assumed
244func ff_descend(c: *FfCtx, P: *i64, passes: i64, step0: i64, verbose: i64) -> i64 {
  var best: i64 = ff_score2(c, P)
  var step: i64 = step0
  if step < 1 { step = 8 }
  var pass: i64 = 0
  while pass < passes {
      var k: i64 = 0
      while k < c.np {
          if c.live(k) == 1 {
              let orig: i64 = P[k]
              P[k] = orig + step
              let up: i64 = ff_score2(c, P)
              P[k] = orig - step
              let dn: i64 = ff_score2(c, P)
              P[k] = orig
              if up < best { if up <= dn { best = up; P[k] = orig + step } }
              if dn < best { if dn < up { best = dn; P[k] = orig - step } }
          }
          k = k + 1
      }
      if verbose == 1 {
          ff_puts("{\x22pass\x22:" as *u8); ff_pn(pass)
          ff_puts(",\x22step\x22:" as *u8); ff_pn(step)
          ff_puts(",\x22best_centi\x22:" as *u8); ff_pn(best)
          ff_puts("}\n" as *u8)
      }
      step = step/2
      if step < 1 { step = 1 }
      pass = pass + 1
  }
  return best
275}
276
277// ==== the fit file ====
278// integer -> ascii into a buffer at offset o; returns the new offset (iterative, no allocation)
279func ff_wint(b: *u8, o: i64, v: i64) -> i64 {
  var x: i64 = v
  var oo: i64 = o
  if x < 0 { b[oo] = 45 as u8; oo = oo + 1; x = 0 - x }
  var tmp: i64 = x
  var nd: i64 = 1
  while tmp >= 10 { tmp = tmp/10; nd = nd + 1 }
  var k: i64 = nd
  while k > 0 {
      var div: i64 = 1
      var q: i64 = 1
      while q < k { div = div*10; q = q + 1 }
      b[oo] = (48 + (x/div) % 10) as u8
      oo = oo + 1
      k = k - 1
  }
  return oo
296}
297// load a PREFIX of P from a newline-separated integer file: returns the count applied (0 when absent or shorter than minlen)
298func ff_load_prefix(path: *u8, P: *i64, np: i64, minlen: i64) -> i64 {
  let ln: *i64 = sys_mmap(FF_LOAD_HDR) as *i64
  let buf: *u8 = sys_read_file(path, ln)
  if (buf as i64) == 0 { return 0 }
  let n: i64 = ln[0]
  let T: *i64 = sys_mmap(np*FF_I64) as *i64
  var i: i64 = 0
  var got: i64 = 0
  while i < n {
      var c: i64 = buf[i] as i64
      var neg: i64 = 0
      if c == 45 {
          neg = 1
          i = i + 1
          if i < n { c = buf[i] as i64 } else { c = 0 }
      }
      var isd: i64 = 0
      if c >= 48 { if c <= 57 { isd = 1 } }
      if isd == 1 {
          var v: i64 = 0
          var run: i64 = 1
          while run == 1 {
              v = v*10 + (c-48)
              i = i + 1
              if i < n { c = buf[i] as i64 } else { c = 0 }
              var still: i64 = 0
              if c >= 48 { if c <= 57 { still = 1 } }
              if still == 0 { run = 0 }
          }
          if neg == 1 { v = 0-v }
          if got < np { T[got] = v; got = got + 1 }
      } else {
          i = i + 1
      }
  }
  if got >= minlen {
      var lim: i64 = got
      if lim > np { lim = np }
      var q: i64 = 0
      while q < lim { P[q] = T[q]; q = q + 1 }
      return lim
  }
  return 0
341}
342// write the whole vector, one integer per line
343func ff_save(path: *u8, P: *i64, np: i64) -> i64 {
  let fb: *u8 = sys_mmap(np*FF_SAVE_DIGITS + FF_SAVE_SLACK)
  var fo: i64 = 0
  var w: i64 = 0
  while w < np {
      fo = ff_wint(fb, fo, P[w])
      fb[fo] = 10 as u8
      fo = fo + 1
      w = w + 1
  }
  let fd: i64 = sys_openat_wr(path, FF_MODE644)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, fb, fo)
  sys_close(fd)
  return fo
358}
359
360
361// Versioned checked path. Existing legacy entry points remain explicitly unverified.
362const FF_FIT_LEGACY_UNVERIFIED: i64 = 0 - 2
363const FF_FIT_CONTRACT_MISMATCH: i64 = 0 - 3
364const FF_FIT_MALFORMED: i64 = 0 - 4
365const FF_FIT_INVALID: i64 = 0 - 5
366const FF_FIT_IO: i64 = 0 - 6
367const FF_FIT_MAGIC_BYTES: i64 = 7
368const FF_FIT_I64_DIGITS: i64 = 21
369const FF_FIT_ATOMIC_PATH_CAP: i64 = 512 // nx_atomic_rewrite ar_syncdir buffer contract
370const FF_FIT_I64_POS_LIMIT: i64 = 9223372036854775807
371struct FfFitContract { header: *u8, header_bytes: i64, np: i64, valid: func(*i64,i64) -> i64 }
372// header is the caller's exact versioned schema/frame/producer/reference/objective identity.
373// It starts NXFFIT2 and ends newline; all identities are part of byte equality, never parsed as numbers.
374func ff_contract_ok(C: *FfFitContract) -> i64 {
  if C.np <= 0 { return 0 }
  if C.header_bytes < 0 { return 0 }
  if C.header_bytes >= FF_FIT_I64_POS_LIMIT { return 0 }
  if C.np > (FF_FIT_I64_POS_LIMIT - 1 - C.header_bytes) / FF_FIT_I64_DIGITS { return 0 }
  if C.header_bytes <= FF_FIT_MAGIC_BYTES { return 0 }
  let magic: *u8 = "NXFFIT2" as *u8
  var i: i64 = 0
  while i < FF_FIT_MAGIC_BYTES { if C.header[i] != magic[i] { return 0 } i = i + 1 }
  if C.header[C.header_bytes - 1] != 10 { return 0 }
  return 1
385}
386// INTERNAL: called only by ff_parse_verified after contract/header/count bounds.
387// External bytes must enter through ff_load_verified; this is not a standalone boundary API.
388func ff_values_verified(b: *u8, n: i64, T: *i64, C: *FfFitContract) -> i64 {
  var i: i64 = C.header_bytes
  var k: i64 = 0
  while k < C.np {
      if i >= n { return FF_FIT_MALFORMED }
      var neg: i64 = 0
      if b[i] == 45 { neg = 1; i = i + 1 }
      var digits: i64 = 0
      var v: i64 = 0
      var run: i64 = 1
      while run == 1 {
          if i >= n { run = 0 } else {
              let c: i64 = b[i] as i64
              if c < 48 { run = 0 } else { if c > 57 { run = 0 } else {
                  let d: i64 = c - 48
                  if v > (FF_FIT_I64_POS_LIMIT - d) / 10 { return FF_FIT_MALFORMED }
                  v = v * 10 + d; digits = digits + 1; i = i + 1
              } }
          }
      }
      if digits == 0 { return FF_FIT_MALFORMED }
      if i >= n { return FF_FIT_MALFORMED }
      if b[i] != 10 { return FF_FIT_MALFORMED }
      i = i + 1
      if neg == 1 { v = 0 - v }
      T[k] = v; k = k + 1
  }
  if i != n { return FF_FIT_MALFORMED }
  if C.valid(T, C.np) != 1 { return FF_FIT_INVALID }
  return C.np
418}
419// INTERNAL: ff_load_verified has validated the contract and bounded this owned buffer.
420// Generic callers must use ff_load_verified rather than bypass its external-input checks.
421func ff_parse_verified(b: *u8, n: i64, P: *i64, C: *FfFitContract) -> i64 {
  if n < FF_FIT_MAGIC_BYTES { return FF_FIT_LEGACY_UNVERIFIED }
  var i: i64 = 0
  while i < FF_FIT_MAGIC_BYTES { if b[i] != C.header[i] { return FF_FIT_LEGACY_UNVERIFIED } i = i + 1 }
  if n < C.header_bytes { return FF_FIT_CONTRACT_MISMATCH }
  i = 0
  while i < C.header_bytes { if b[i] != C.header[i] { return FF_FIT_CONTRACT_MISMATCH } i = i + 1 }
  if C.np > (n - C.header_bytes) / 2 { return FF_FIT_MALFORMED }
  let T: *i64 = sys_mmap_shared(C.np * FF_I64) as *i64
  if (T as i64) <= 0 { return FF_FIT_IO }
  let rc: i64 = ff_values_verified(b, n, T, C)
  if rc == C.np { var k: i64 = 0; while k < C.np { P[k] = T[k]; k = k + 1 } }
  sys_munmap_direct(T as *u8, C.np * FF_I64)
  return rc
435}
436func ff_load_verified(path: *u8, P: *i64, C: *FfFitContract) -> i64 {
  if ff_contract_ok(C) != 1 { return FF_FIT_CONTRACT_MISMATCH }
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return FF_FIT_IO }
  let n: i64 = sys_lseek(fd, 0, 2)
  let limit: i64 = C.header_bytes + C.np * FF_FIT_I64_DIGITS
  if n < 0 { sys_close(fd); return FF_FIT_IO }
  if n > limit { sys_close(fd); return FF_FIT_MALFORMED }
  if sys_lseek(fd, 0, 0) != 0 { sys_close(fd); return FF_FIT_IO }
  let b: *u8 = sys_mmap_shared(n + 1)
  if (b as i64) <= 0 { sys_close(fd); return FF_FIT_IO }
  var total: i64 = 0
  while total < n {
      let got: i64 = sys_read(fd, ((b as i64) + total) as *u8, n - total)
      if got <= 0 { sys_close(fd); sys_munmap_direct(b, n + 1); return FF_FIT_IO }
      total = total + got
  }
  let extra: i64 = sys_read(fd, ((b as i64) + n) as *u8, 1)
  sys_close(fd)
  if extra != 0 { sys_munmap_direct(b, n + 1); return FF_FIT_MALFORMED }
  let rc: i64 = ff_parse_verified(b, n, P, C)
  sys_munmap_direct(b, n + 1)
  return rc
459}
460func ff_save_verified(path: *u8, P: *i64, C: *FfFitContract) -> i64 {
  if ff_contract_ok(C) != 1 { return FF_FIT_CONTRACT_MISMATCH }
  if C.valid(P, C.np) != 1 { return FF_FIT_INVALID }
  var plen: i64 = 0
  while path[plen] != 0 { if plen >= FF_FIT_ATOMIC_PATH_CAP - 1 { return FF_FIT_IO } plen = plen + 1 }
  let b: *u8 = sys_mmap_shared(C.header_bytes + C.np * FF_FIT_I64_DIGITS)
  if (b as i64) <= 0 { return FF_FIT_IO }
  var o: i64 = 0
  while o < C.header_bytes { b[o] = C.header[o]; o = o + 1 }
  var k: i64 = 0
  while k < C.np {
      if P[k] < (0 - FF_FIT_I64_POS_LIMIT) { sys_munmap_direct(b, C.header_bytes + C.np * FF_FIT_I64_DIGITS); return FF_FIT_MALFORMED }
      o = ff_wint(b, o, P[k]); b[o] = 10 as u8; o = o + 1; k = k + 1
  }
  let rc: i64 = atomic_rewrite(path, b, o)
  sys_munmap_direct(b, C.header_bytes + C.np * FF_FIT_I64_DIGITS)
  if rc != 0 { return FF_FIT_IO }
  return o
478}
479
480func ff_descend_checked(c: *FfCtx, P: *i64, passes: i64, step0: i64, verbose: i64, valid: func(*i64,i64) -> i64) -> i64 {
  if valid(P, c.np) != 1 { return FF_FIT_INVALID }
  if step0 <= 0 { return FF_FIT_INVALID }
  if passes < 0 { return FF_FIT_INVALID }
  var best: i64 = ff_score2(c, P)
  var step: i64 = step0
  var pass: i64 = 0
  while pass < passes {
      var k: i64 = 0
      while k < c.np {
          if c.live(k) == 1 {
              let orig: i64 = P[k]
              var up: i64 = best
              if orig <= FF_FIT_I64_POS_LIMIT - step {
                  P[k] = orig + step
                  if valid(P, c.np) == 1 { up = ff_score2(c, P) }
              }
              var dn: i64 = best
              if orig >= (0 - FF_FIT_I64_POS_LIMIT) + step {
                  P[k] = orig - step
                  if valid(P, c.np) == 1 { dn = ff_score2(c, P) }
              }
              P[k] = orig
              if up < best { if up <= dn { best = up; P[k] = orig + step } }
              if dn < best { if dn < up { best = dn; P[k] = orig - step } }
          }
          k = k + 1
      }
      if verbose == 1 {
          ff_puts("{\x22pass\x22:" as *u8); ff_pn(pass)
          ff_puts(",\x22step\x22:" as *u8); ff_pn(step)
          ff_puts(",\x22best_centi\x22:" as *u8); ff_pn(best)
          ff_puts("}\n" as *u8)
      }
      step = step/2
      if step < 1 { step = 1 }
      pass = pass + 1
  }
  return best
519}
nx_fieldfit_lib.nx source

`nx_fieldfit_lib.nx` source
