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

↩ module page · 182 lines · 10663 B
1// nx_ciq_analyst.nx -- R1 of the CIQ arc, now MARKET-GENERIC: the ANALYST. Reads the markets registry
2// ("ciq:markets" -> list) from the SOVEREIGN seg_store and, for EACH market, computes per entity the two
3// Gartner Magic-Quadrant axes in no-float permil (0..1000):
4//   Ability-to-Execute    = weighted level over the KNOWN E-axis cells / max possible
5//   Completeness-of-Vision = weighted level over the KNOWN V-axis cells / max possible
6// plus an honest data-COMPLETENESS permil per entity. LIAR-KILL: a FULL cell (level==max) with NO cited
7// evidence is invalid -> RED. Scores are written back ("ciq:<market>:score:<entity>") for the placer.
8// Generic over markets via inline key-building (ciq:<market>:meta / :cap:<name> / :score:<entity>), so a
9// new market = a new ingest organ + a markets-list entry, ZERO change here. Thresholds = NAMED consts
10// (rule #11). Mirrors nx_codata_ingest's sovereign store idiom. license_tier: ORIGINAL  expect_exit: 0
11import "nx_syscalls.nx"
12import "nx_canon_cid.nx"
13import "nx_seg_store.nx"
14import "nx_uxf_decode.nx"
15const AQ_MAGIC_1024: i64 = 1024
16const AQ_MAGIC_8192: i64 = 8192
17
18const AQ_STORE: *u8 = "knowledge/store/ciq-"
19const AQ_MAXLEVEL: i64 = 2
20const AQ_COMPL_FLOOR: i64 = 400
21
22func aw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
23func an(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 }
24func aq_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 }
25func aq_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 }
26func aq_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 }
27func aq_field(dk: *i64, dv: *i64, nf: i64, name: *u8) -> *u8 { var f: i64=0; while f<nf { if aq_streq(dk[f] as *u8, name)==1 { return dv[f] as *u8 } f=f+1 } return 0 as *u8 }
28func aq_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 }
29func aq_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 }
30func aq_hasev(cell: *u8) -> i64 { var i: i64=0; while cell[i]!=(0 as u8){ if cell[i]==(33 as u8){ if cell[i+1]!=(0 as u8){ return 1 } } i=i+1 } return 0 }
31func aq_invalid(level: i64, has_ev: i64) -> i64 { if level==AQ_MAXLEVEL { if has_ev==0 { return 1 } } return 0 }
32// build "ciq:<market>:<suffix>" into buf (NUL-terminated)
33func aq_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 }
34
35// score ONE market; write its score records into the shared writer sw. returns invalid-cell count (0=clean), or -1 if market unreadable.
36func score_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)
  aq_key(mk, market, "meta" as *u8)
  if ss_get(AQ_STORE, mk, gp, gl) != 1 { return 0 - 1 }
  let mnf: i64 = canon_decode(gp[0] as *u8, gl[0], dk, dv, 16)
  let ents_raw: *u8 = aq_field(dk, dv, mnf, "entities" as *u8)
  let caps_raw: *u8 = aq_field(dk, dv, mnf, "caps" as *u8)
  if ents_raw == (0 as *u8) { return 0 - 1 }
  if caps_raw == (0 as *u8) { return 0 - 1 }
  let ebuf: *u8 = sys_mmap(AQ_MAGIC_1024); aq_copy(ents_raw, ebuf)
  let cbuf: *u8 = sys_mmap(AQ_MAGIC_8192); aq_copy(caps_raw, cbuf)
  let ent: *i64 = sys_mmap(8 * 16) as *i64
  let capn: *i64 = sys_mmap(8 * 64) as *i64
  let N: i64 = aq_split(ebuf, 44, ent, 16)
  let M: i64 = aq_split(cbuf, 44, capn, 64)
55
  let exn: *i64 = sys_mmap(8 * 16) as *i64
  let exd: *i64 = sys_mmap(8 * 16) as *i64
  let vsn: *i64 = sys_mmap(8 * 16) as *i64
  let vsd: *i64 = sys_mmap(8 * 16) as *i64
  let known: *i64 = sys_mmap(8 * 16) as *i64
  var z: i64 = 0
  while z < N { exn[z]=0; exd[z]=0; vsn[z]=0; vsd[z]=0; known[z]=0; z=z+1 }
  var invalid: i64 = 0
64
  let kb: *u8 = sys_mmap(256)
  let capsuf: *u8 = sys_mmap(128)
  let cellbuf: *u8 = sys_mmap(512)
  let cellp: *i64 = sys_mmap(8 * 16) as *i64
  var j: i64 = 0
  while j < M {
      var so: i64 = 0; so = ss_cat(capsuf, so, "cap:" as *u8); so = ss_cat(capsuf, so, capn[j] as *u8); capsuf[so] = 0 as u8
      aq_key(kb, market, capsuf)
      if ss_get(AQ_STORE, kb, gp, gl) == 1 {
          let cnf: i64 = canon_decode(gp[0] as *u8, gl[0], dk, dv, 16)
          let ax: *u8 = aq_field(dk, dv, cnf, "ax" as *u8)
          let wtp: *u8 = aq_field(dk, dv, cnf, "wt" as *u8)
          let cells: *u8 = aq_field(dk, dv, cnf, "cells" as *u8)
          if cells != (0 as *u8) {
              let wt: i64 = aq_pint(wtp)
              var isV: i64 = 0
              if aq_streq(ax, "V" as *u8) == 1 { isV = 1 }
              aq_copy(cells, cellbuf)
              let nc: i64 = aq_split(cellbuf, 59, cellp, 16)
              var i: i64 = 0
              while i < N {
                  if i < nc {
                      let cell: *u8 = cellp[i] as *u8
                      let c0: i64 = cell[0]
                      if c0 != (85 as u8) {
                          var level: i64 = c0 - 48
                          if level < 0 { level = 0 }
                          if level > AQ_MAXLEVEL { level = AQ_MAXLEVEL }
                          let hev: i64 = aq_hasev(cell)
                          if aq_invalid(level, hev) == 1 { invalid = invalid + 1 }
                          known[i] = known[i] + 1
                          if isV == 1 { vsn[i] = vsn[i] + level * wt; vsd[i] = vsd[i] + AQ_MAXLEVEL * wt }
                          else { exn[i] = exn[i] + level * wt; exd[i] = exd[i] + AQ_MAXLEVEL * wt }
                      }
                  }
                  i = i + 1
              }
          }
      }
      j = j + 1
  }
106
  aw("-- market=" as *u8); aw(market); aw("  entities=" as *u8); an(N); aw("  capabilities=" as *u8); an(M); aw(" --\n" as *u8)
  let nb1: *u8 = sys_mmap(32); let nb2: *u8 = sys_mmap(32); let nb3: *u8 = sys_mmap(32); let nb4: *u8 = sys_mmap(32)
  var i2: i64 = 0
  while i2 < N {
      var exP: i64 = 0; if exd[i2] > 0 { exP = (exn[i2] * 1000) / exd[i2] }
      var vsP: i64 = 0; if vsd[i2] > 0 { vsP = (vsn[i2] * 1000) / vsd[i2] }
      var compl: i64 = 0; if M > 0 { compl = (known[i2] * 1000) / M }
      var flag: *u8 = "OK" as *u8
      if compl < AQ_COMPL_FLOOR { flag = "LOW-DATA" as *u8 }
      aw("   " as *u8); aw(ent[i2] as *u8); aw("  EXEC=" as *u8); an(exP); aw(" VIS=" as *u8); an(vsP); aw(" compl=" as *u8); an(compl); aw(" [" as *u8); aw(flag); aw("]\n" as *u8)
117
      aq_itoa(exP, nb1); aq_itoa(vsP, nb2); aq_itoa(compl, nb3); aq_itoa(known[i2], nb4)
      let rk: *i64 = sys_mmap(8 * 8) as *i64; let rv: *i64 = sys_mmap(8 * 8) as *i64
      rk[0]="execute" as *u8 as i64;      rv[0]=nb1 as i64
      rk[1]="vision" as *u8 as i64;       rv[1]=nb2 as i64
      rk[2]="completeness" as *u8 as i64; rv[2]=nb3 as i64
      rk[3]="known" as *u8 as i64;        rv[3]=nb4 as i64
      rk[4]="flag" as *u8 as i64;         rv[4]=flag as i64
      let recb: *u8 = sys_mmap(512); let recl: i64 = canon_encode(rk, rv, 5, recb)
      let scsuf: *u8 = sys_mmap(128); var sso: i64 = 0; sso = ss_cat(scsuf, sso, "score:" as *u8); sso = ss_cat(scsuf, sso, ent[i2] as *u8); scsuf[sso] = 0 as u8
      let skb: *u8 = sys_mmap(256); aq_key(skb, market, scsuf)
      ss_add(sw, 1, skb, recb, recl)
      i2 = i2 + 1
  }
  return invalid
132}
133
134func 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
139
  // markets registry (default "connect" if absent)
  let mbuf: *u8 = sys_mmap(AQ_MAGIC_1024)
  var have: i64 = 0
  if ss_get(AQ_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 = aq_field(dk, dv, mnf, "list" as *u8)
      if lst != (0 as *u8) { aq_copy(lst, mbuf); have = 1 }
  }
  if have == 0 { aq_copy("connect" as *u8, mbuf) }
  let markets: *i64 = sys_mmap(8 * 16) as *i64
  let nm: i64 = aq_split(mbuf, 44, markets, 16)
151
  aw("=== nx_ciq_analyst (market-generic) -- two-axis scores, no-float permil 0..1000 ===\n" as *u8)
  aw("markets=" as *u8); an(nm); aw("  (liar-kill: FULL cell w/o cited evidence = invalid -> RED)\n" as *u8)
154
  let sw: *i64 = ss_begin()
  var invalid: i64 = 0
  var scored: i64 = 0
  var mi: i64 = 0
  while mi < nm {
      let r: i64 = score_market(markets[mi] as *u8, sw)
      if r >= 0 { scored = scored + 1; invalid = invalid + r }
      else { aw("-- market=" as *u8); aw(markets[mi] as *u8); aw(" UNREADABLE (skipped)\n" as *u8) }
      mi = mi + 1
  }
  ss_commit(AQ_STORE, sw, sys_now_ms())
166
  var neg_ok: i64 = 1
  if aq_invalid(AQ_MAXLEVEL, 0) != 1 { neg_ok = 0 }
  if aq_invalid(AQ_MAXLEVEL, 1) != 0 { neg_ok = 0 }
  if aq_invalid(1, 0) != 0 { neg_ok = 0 }
  var pos_ok: i64 = 1
  if ((AQ_MAXLEVEL * 3 * 1000) / (AQ_MAXLEVEL * 3)) != 1000 { pos_ok = 0 }
173
  aw("--- controls --- liar-kill(neg)=" as *u8); if neg_ok==1 { aw("PASS" as *u8) } else { aw("FAIL" as *u8) }
  aw("  normalization(pos)=" as *u8); if pos_ok==1 { aw("PASS" as *u8) } else { aw("FAIL" as *u8) }
  aw("  markets_scored=" as *u8); an(scored); aw("/" as *u8); an(nm); aw("  invalid_cells=" as *u8); an(invalid); aw("\n" as *u8)
177
  var green: i64 = 0
  if invalid == 0 { if neg_ok == 1 { if pos_ok == 1 { if scored == nm { green = 1 } } } }
  if green == 1 { aw("ANALYSTGATE markets-generic scores_persisted=yes verdict=GREEN\n" as *u8); sys_exit(0); return 0 }
  aw("ANALYSTGATE verdict=RED\n" as *u8); sys_exit(1); return 1
182}
nx_ciq_analyst.nx source

`nx_ciq_analyst.nx` source
