code wiki / _hdl_build / nx_ciq_quadrant.nx
`nx_ciq_quadrant.nx` source

↩ module page · 192 lines · 11793 B
1// nx_ciq_quadrant.nx -- R2 of the CIQ arc, now MARKET-GENERIC: the QUADRANT-PLACER. For EACH market in
2// the registry it reads the persisted two-axis scores from the SOVEREIGN seg_store and places every entity
3// in the Gartner Magic Quadrant (x=Vision, y=Execute), then computes for NISHI the where-we-are ->
4// where-we-need-to-go answer: the GAP VECTOR to the Leaders boundary + the COMPUTED capability ROADMAP
5// (each not-yet-full nishi cell ranked by the EXACT permil it adds to its axis). Placement + gap are
6// persisted ("ciq:<market>:placement:<e>" / ":gap:nishi") for the visualizer. Thresholds = NAMED consts.
7// 100% sovereign, no-float. license_tier: ORIGINAL  expect_exit: 0
8import "nx_syscalls.nx"
9import "nx_canon_cid.nx"
10import "nx_seg_store.nx"
11import "nx_uxf_decode.nx"
12const QQ_MAGIC_1024: i64 = 1024
13const QQ_MAGIC_8192: i64 = 8192
14
15const QQ_STORE: *u8 = "knowledge/store/ciq-"
16const QQ_MAXLEVEL: i64 = 2
17const QQ_EX_MIN: i64 = 500
18const QQ_VIS_MIN: i64 = 500
19
20func qw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
21func qn(v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)} let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1} sys_write(1,bb,k); return 0 }
22func q_streq(a: *u8, b: *u8) -> i64 { var i: i64=0; while a[i]!=(0 as u8){ if a[i]!=b[i]{return 0} i=i+1 } if b[i]!=(0 as u8){return 0} return 1 }
23func q_itoa(v: i64, b: *u8) -> i64 { var m: i64=v; if m<0{m=0-m} let t: *u8=sys_mmap(32); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} b[k]=0 as u8; return k }
24func q_pint(s: *u8) -> i64 { var v: i64=0; var i: i64=0; var go: i64=1; while go==1 { let c: i64=s[i]; if c>=48 { if c<=57 { v=v*10+(c-48); i=i+1 } else { go=0 } } else { go=0 } } return v }
25func q_field(dk: *i64, dv: *i64, nf: i64, name: *u8) -> *u8 { var f: i64=0; while f<nf { if q_streq(dk[f] as *u8, name)==1 { return dv[f] as *u8 } f=f+1 } return 0 as *u8 }
26func q_split(buf: *u8, delim: i64, out: *i64, maxn: i64) -> i64 { var n: i64=0; var i: i64=0; var intok: i64=0; while buf[i]!=(0 as u8) { let c: i64=buf[i]; if c==delim { buf[i]=0 as u8; intok=0 } else { if intok==0 { if n<maxn { out[n]=(buf as i64)+i; n=n+1 } intok=1 } } i=i+1 } return n }
27func q_copy(src: *u8, dst: *u8) -> i64 { var i: i64=0; while src[i]!=(0 as u8){ dst[i]=src[i]; i=i+1 } dst[i]=0 as u8; return i }
28func q_key(buf: *u8, market: *u8, suffix: *u8) -> i64 { var o: i64=0; o=ss_cat(buf,o,"ciq:" as *u8); o=ss_cat(buf,o,market); o=ss_cat(buf,o,":" as *u8); o=ss_cat(buf,o,suffix); buf[o]=0 as u8; return o }
29
30func q_quad(ex: i64, vis: i64) -> i64 { if ex >= QQ_EX_MIN { if vis >= QQ_VIS_MIN { return 0 } return 1 } if vis >= QQ_VIS_MIN { return 2 } return 3 }
31func q_quadname(q: i64) -> *u8 { if q==0 { return "LEADER" as *u8 } if q==1 { return "CHALLENGER" as *u8 } if q==2 { return "VISIONARY" as *u8 } return "NICHE-PLAYER" as *u8 }
32
33// place + persist ONE market; writes placements+gap via shared writer sw. returns 1 ok / 0 unreadable.
34func place_market(market: *u8, sw: *i64) -> i64 {
  let gp: *i64 = sys_mmap(8) as *i64
  let gl: *i64 = sys_mmap(8) as *i64
  let dk: *i64 = sys_mmap(8 * 16) as *i64
  let dv: *i64 = sys_mmap(8 * 16) as *i64
  let mk: *u8 = sys_mmap(256); q_key(mk, market, "meta" as *u8)
  if ss_get(QQ_STORE, mk, gp, gl) != 1 { return 0 }
  let mnf: i64 = canon_decode(gp[0] as *u8, gl[0], dk, dv, 16)
  let ebuf: *u8 = sys_mmap(QQ_MAGIC_1024); q_copy(q_field(dk, dv, mnf, "entities" as *u8), ebuf)
  let cbuf: *u8 = sys_mmap(QQ_MAGIC_8192); q_copy(q_field(dk, dv, mnf, "caps" as *u8), cbuf)
  let ent: *i64 = sys_mmap(8 * 16) as *i64
  let capn: *i64 = sys_mmap(8 * 64) as *i64
  let N: i64 = q_split(ebuf, 44, ent, 16)
  let M: i64 = q_split(cbuf, 44, capn, 64)
48
  let exV: *i64 = sys_mmap(8 * 16) as *i64
  let viV: *i64 = sys_mmap(8 * 16) as *i64
  let qd: *i64 = sys_mmap(8 * 16) as *i64
  var nishi_idx: i64 = 0 - 1
  let kb: *u8 = sys_mmap(256)
  let suf: *u8 = sys_mmap(128)
  var i: i64 = 0
  while i < N {
      var so: i64 = 0; so = ss_cat(suf, so, "score:" as *u8); so = ss_cat(suf, so, ent[i] as *u8); suf[so] = 0 as u8
      q_key(kb, market, suf)
      var ex: i64 = 0; var vis: i64 = 0
      if ss_get(QQ_STORE, kb, gp, gl) == 1 { let snf: i64 = canon_decode(gp[0] as *u8, gl[0], dk, dv, 16); ex = q_pint(q_field(dk, dv, snf, "execute" as *u8)); vis = q_pint(q_field(dk, dv, snf, "vision" as *u8)) }
      exV[i] = ex; viV[i] = vis; qd[i] = q_quad(ex, vis)
      if q_streq(ent[i] as *u8, "nishi" as *u8) == 1 { nishi_idx = i }
      i = i + 1
  }
65
  qw("=== MARKET: " as *u8); qw(market); qw("  (x=Vision y=Execute; LEADER corner >= " as *u8); qn(QQ_EX_MIN); qw("/" as *u8); qn(QQ_VIS_MIN); qw(") ===\n" as *u8)
  var qq: i64 = 0
  while qq < 4 {
      qw("  " as *u8); qw(q_quadname(qq)); qw(": " as *u8)
      var cnt: i64 = 0; var e: i64 = 0
      while e < N { if qd[e] == qq { if cnt > 0 { qw(", " as *u8) } qw(ent[e] as *u8); qw("(" as *u8); qn(exV[e]); qw("/" as *u8); qn(viV[e]); qw(")" as *u8); cnt = cnt + 1 } e = e + 1 }
      if cnt == 0 { qw("(none)" as *u8) }
      qw("\n" as *u8); qq = qq + 1
  }
75
  // nishi gap + roadmap
  var ex_gap: i64 = 0; var vis_gap: i64 = 0
  if nishi_idx >= 0 {
      let nex: i64 = exV[nishi_idx]; let nvis: i64 = viV[nishi_idx]
      ex_gap = QQ_EX_MIN - nex; if ex_gap < 0 { ex_gap = 0 }
      vis_gap = QQ_VIS_MIN - nvis; if vis_gap < 0 { vis_gap = 0 }
      qw("  NISHI -> " as *u8); qw(q_quadname(qd[nishi_idx])); qw("  gap to LEADER: +" as *u8); qn(ex_gap); qw(" exec, +" as *u8); qn(vis_gap); qw(" vision\n" as *u8)
83
      let opc: *i64 = sys_mmap(8 * 64) as *i64
      let opx: *i64 = sys_mmap(8 * 64) as *i64
      let opl: *i64 = sys_mmap(8 * 64) as *i64
      let opw: *i64 = sys_mmap(8 * 64) as *i64
      var nop: i64 = 0; var exd: i64 = 0; var vsd: i64 = 0
      let cellbuf: *u8 = sys_mmap(512); let cellp: *i64 = sys_mmap(8 * 16) as *i64
      let csuf: *u8 = sys_mmap(128)
      var j: i64 = 0
      while j < M {
          var so2: i64 = 0; so2 = ss_cat(csuf, so2, "cap:" as *u8); so2 = ss_cat(csuf, so2, capn[j] as *u8); csuf[so2] = 0 as u8
          q_key(kb, market, csuf)
          if ss_get(QQ_STORE, kb, gp, gl) == 1 {
              let cnf: i64 = canon_decode(gp[0] as *u8, gl[0], dk, dv, 16)
              let ax: *u8 = q_field(dk, dv, cnf, "ax" as *u8)
              let wt: i64 = q_pint(q_field(dk, dv, cnf, "wt" as *u8))
              let cells: *u8 = q_field(dk, dv, cnf, "cells" as *u8)
              if cells != (0 as *u8) {
                  var isV: i64 = 0; if q_streq(ax, "V" as *u8) == 1 { isV = 1 }
                  q_copy(cells, cellbuf)
                  let nc: i64 = q_split(cellbuf, 59, cellp, 16)
                  if nishi_idx < nc {
                      let cell: *u8 = cellp[nishi_idx] as *u8
                      let c0: i64 = cell[0]
                      if c0 != (85 as u8) {
                          var level: i64 = c0 - 48; if level < 0 { level = 0 } if level > QQ_MAXLEVEL { level = QQ_MAXLEVEL }
                          if isV == 1 { vsd = vsd + QQ_MAXLEVEL * wt } else { exd = exd + QQ_MAXLEVEL * wt }
                          if level < QQ_MAXLEVEL { opc[nop] = capn[j]; opx[nop] = isV; opl[nop] = level; opw[nop] = wt; nop = nop + 1 }
                      }
                  }
              }
          }
          j = j + 1
      }
      let opg: *i64 = sys_mmap(8 * 64) as *i64
      var o: i64 = 0
      while o < nop { var den: i64 = exd; if opx[o] == 1 { den = vsd } var g: i64 = 0; if den > 0 { g = ((QQ_MAXLEVEL - opl[o]) * opw[o] * 1000) / den } opg[o] = g; o = o + 1 }
      var lim: i64 = 5; if nop < lim { lim = nop }
      var p: i64 = 0
      while p < lim {
          var best: i64 = p; var s: i64 = p + 1
          while s < nop { if opg[s] > opg[best] { best = s } s = s + 1 }
          if best != p { let tg: i64 = opg[p]; opg[p] = opg[best]; opg[best] = tg; let tc: i64 = opc[p]; opc[p] = opc[best]; opc[best] = tc; let tx: i64 = opx[p]; opx[p] = opx[best]; opx[best] = tx }
          p = p + 1
      }
      if lim > 0 {
          qw("  top builds:" as *u8)
          var r: i64 = 0
          while r < lim { qw(" [" as *u8); if opx[r] == 1 { qw("V+" as *u8) } else { qw("E+" as *u8) } qn(opg[r]); qw("]" as *u8); qw(opc[r] as *u8); r = r + 1 }
          qw("\n" as *u8)
      }
  }
135
  // persist placements + gap
  let nb1: *u8 = sys_mmap(32); let nb2: *u8 = sys_mmap(32)
  var pi: i64 = 0
  while pi < N {
      q_itoa(exV[pi], nb1); q_itoa(viV[pi], nb2)
      let rk: *i64 = sys_mmap(8 * 8) as *i64; let rv: *i64 = sys_mmap(8 * 8) as *i64
      rk[0]="quadrant" as *u8 as i64; rv[0]=q_quadname(qd[pi]) as i64
      rk[1]="execute" as *u8 as i64;  rv[1]=nb1 as i64
      rk[2]="vision" as *u8 as i64;   rv[2]=nb2 as i64
      let recb: *u8 = sys_mmap(256); let recl: i64 = canon_encode(rk, rv, 3, recb)
      let psuf: *u8 = sys_mmap(128); var po: i64 = 0; po = ss_cat(psuf, po, "placement:" as *u8); po = ss_cat(psuf, po, ent[pi] as *u8); psuf[po] = 0 as u8
      let pkb: *u8 = sys_mmap(256); q_key(pkb, market, psuf)
      ss_add(sw, 1, pkb, recb, recl)
      pi = pi + 1
  }
  let gk: *i64 = sys_mmap(8 * 8) as *i64; let gv: *i64 = sys_mmap(8 * 8) as *i64
  let gb1: *u8 = sys_mmap(32); let gb2: *u8 = sys_mmap(32); let gb3: *u8 = sys_mmap(32); let gb4: *u8 = sys_mmap(32)
  q_itoa(ex_gap, gb1); q_itoa(vis_gap, gb2); q_itoa(QQ_EX_MIN, gb3); q_itoa(QQ_VIS_MIN, gb4)
  gk[0]="ex_gap" as *u8 as i64; gv[0]=gb1 as i64
  gk[1]="vis_gap" as *u8 as i64; gv[1]=gb2 as i64
  gk[2]="ex_min" as *u8 as i64; gv[2]=gb3 as i64
  gk[3]="vis_min" as *u8 as i64; gv[3]=gb4 as i64
  let grb: *u8 = sys_mmap(256); let grl: i64 = canon_encode(gk, gv, 4, grb)
  let gsuf: *u8 = sys_mmap(64); var go2: i64 = 0; go2 = ss_cat(gsuf, go2, "gap:nishi" as *u8); gsuf[go2] = 0 as u8
  let gkb: *u8 = sys_mmap(256); q_key(gkb, market, gsuf)
  ss_add(sw, 1, gkb, grb, grl)
  return 1
163}
164
165func main() -> i64 {
  let gp: *i64 = sys_mmap(8) as *i64
  let gl: *i64 = sys_mmap(8) as *i64
  let dk: *i64 = sys_mmap(8 * 16) as *i64
  let dv: *i64 = sys_mmap(8 * 16) as *i64
  let mbuf: *u8 = sys_mmap(QQ_MAGIC_1024)
  var have: i64 = 0
  if ss_get(QQ_STORE, "ciq:markets" as *u8, gp, gl) == 1 { let mnf: i64 = canon_decode(gp[0] as *u8, gl[0], dk, dv, 16); let lst: *u8 = q_field(dk, dv, mnf, "list" as *u8); if lst != (0 as *u8) { q_copy(lst, mbuf); have = 1 } }
  if have == 0 { q_copy("connect" as *u8, mbuf) }
  let markets: *i64 = sys_mmap(8 * 16) as *i64
  let nm: i64 = q_split(mbuf, 44, markets, 16)
176
  let sw: *i64 = ss_begin()
  var placed: i64 = 0
  var mi: i64 = 0
  while mi < nm { if place_market(markets[mi] as *u8, sw) == 1 { placed = placed + 1 } mi = mi + 1 }
  ss_commit(QQ_STORE, sw, sys_now_ms())
182
  var pos_ok: i64 = 1
  if q_quad(600, 600) != 0 { pos_ok = 0 }
  if q_quad(600, 100) != 1 { pos_ok = 0 }
  if q_quad(100, 600) != 2 { pos_ok = 0 }
  if q_quad(100, 100) != 3 { pos_ok = 0 }
  qw("--- controls --- quadrant-bin(4 corners)=" as *u8); if pos_ok==1 { qw("PASS" as *u8) } else { qw("FAIL" as *u8) }
  qw("  markets_placed=" as *u8); qn(placed); qw("/" as *u8); qn(nm); qw("\n" as *u8)
  if pos_ok == 1 { if placed == nm { qw("QUADRANTGATE markets-generic verdict=GREEN\n" as *u8); sys_exit(0); return 0 } }
  qw("QUADRANTGATE verdict=RED\n" as *u8); sys_exit(1); return 1
192}
nx_ciq_quadrant.nx source

`nx_ciq_quadrant.nx` source
