| |
| |
| |
|
|
| <!DOCTYPE html>
|
| <html lang="en">
|
| <head>
|
| <meta charset="UTF-8">
|
| <title>ZYMATICA | zymatica-inference-engine-html</title>
|
| </head>
|
| <body style="background: #0b0f19; color: #f8fafc; font-family: monospace; padding: 20px;">
|
| <h1>ZYMATICA | zymatica-inference-engine-html</h1>
|
| <div id="output">Running range coder...</div>
|
| <script>
|
|
|
| class SparseTransition {
|
| constructor(key, sym, count) {
|
| this.key = key; this.sym = sym; this.count = count;
|
| }
|
| }
|
| class RadicalPredictor {
|
| constructor(alpha, weight) {
|
| this.alpha = alpha; this.weight = weight;
|
| this.transRC = []; this.transRF = []; this.transRA = [];
|
| this.prevRC = 0; this.prevRF = 0; this.prevRA = 0;
|
| }
|
| observe(rc, rf, ra) {
|
| let w = this.weight;
|
| let keyRC = this.prevRC;
|
| let found = false;
|
| for (let entry of this.transRC) {
|
| if (entry.key === keyRC && entry.sym === rc) { entry.count += w; found = true; break; }
|
| }
|
| if (!found && this.transRC.length < 256) this.transRC.push(new SparseTransition(keyRC, rc, w));
|
| let keyRF = (rc << 8) | this.prevRF; found = false;
|
| for (let entry of this.transRF) {
|
| if (entry.key === keyRF && entry.sym === rf) { entry.count += w; found = true; break; }
|
| }
|
| if (!found && this.transRF.length < 256) this.transRF.push(new SparseTransition(keyRF, rf, w));
|
| let keyRA = (rc << 16) | (rf << 8) | this.prevRA; found = false;
|
| for (let entry of this.transRA) {
|
| if (entry.key === keyRA && entry.sym === ra) { entry.count += w; found = true; break; }
|
| }
|
| if (!found && this.transRA.length < 256) this.transRA.push(new SparseTransition(keyRA, ra, w));
|
| this.prevRC = rc; this.prevRF = rf; this.prevRA = ra;
|
| }
|
| getCumFreqsRC(prevRC) {
|
| let freqs = new Array(256).fill(this.alpha);
|
| for (let entry of this.transRC) if (entry.key === prevRC) freqs[entry.sym] += entry.count;
|
| let cum = [0]; for (let f of freqs) cum.push(cum[cum.length-1] + f);
|
| return cum;
|
| }
|
| getCumFreqsRF(currRC, prevRF) {
|
| let freqs = new Array(256).fill(this.alpha);
|
| let key = (currRC << 8) | prevRF;
|
| for (let entry of this.transRF) if (entry.key === key) freqs[entry.sym] += entry.count;
|
| let cum = [0]; for (let f of freqs) cum.push(cum[cum.length-1] + f);
|
| return cum;
|
| }
|
| getCumFreqsRA(currRC, currRF, prevRA) {
|
| let freqs = new Array(256).fill(this.alpha);
|
| let key = (currRC << 16) | (currRF << 8) | prevRA;
|
| for (let entry of this.transRA) if (entry.key === key) freqs[entry.sym] += entry.count;
|
| let cum = [0]; for (let f of freqs) cum.push(cum[cum.length-1] + f);
|
| return cum;
|
| }
|
| }
|
| class BitWriter {
|
| constructor() { this.buffer = []; this.bitIndex = 0; }
|
| writeBit(bit) {
|
| let bytePos = Math.floor(this.bitIndex / 8);
|
| let bitPos = 7 - (this.bitIndex % 8);
|
| if (bytePos >= this.buffer.length) this.buffer.push(0);
|
| if (bit !== 0) this.buffer[bytePos] |= (1 << bitPos);
|
| else this.buffer[bytePos] &= ~(1 << bitPos);
|
| this.bitIndex++;
|
| }
|
| writeBitHelper(underflow, bit) {
|
| this.writeBit(bit);
|
| while (underflow.val > 0) { this.writeBit(1-bit); underflow.val--; }
|
| }
|
| }
|
| function encode(concepts, alpha, weight) {
|
| let pred = new RadicalPredictor(alpha, weight);
|
| let w = new BitWriter();
|
| let low = 0, high = 0xFFFFFFFF;
|
| let underflow = { val: 0 };
|
| for (let c of concepts) {
|
| let rc = (c[0] << 4) | c[1];
|
| let rf = (c[2] << 4) | c[3];
|
| let ra = (c[4] << 4) | c[5];
|
| let prevRC = pred.prevRC, prevRF = pred.prevRF, prevRA = pred.prevRA;
|
| for (let step=0; step<3; step++) {
|
| let cum = step === 0 ? pred.getCumFreqsRC(prevRC) : step === 1 ? pred.getCumFreqsRF(rc, prevRF) : pred.getCumFreqsRA(rc, rf, prevRA);
|
| let sym = step === 0 ? rc : step === 1 ? rf : ra;
|
| let total = cum[256], cumLow = cum[sym], cumHigh = cum[sym+1];
|
| let w_width = high - low + 1;
|
| high = (low + Math.floor((w_width * cumHigh)/total) - 1) >>> 0;
|
| low = (low + Math.floor((w_width * cumLow)/total)) >>> 0;
|
| while (true) {
|
| if (high < 0x80000000) { w.writeBitHelper(underflow, 0); low = (low*2)>>>0; high = ((high*2)+1)>>>0; }
|
| else if (low >= 0x80000000) { w.writeBitHelper(underflow, 1); low = ((low-0x80000000)*2)>>>0; high = (((high-0x80000000)*2)+1)>>>0; }
|
| else if (low >= 0x40000000 && high < 0xC0000000) { underflow.val++; low = ((low-0x40000000)*2)>>>0; high = (((high-0x40000000)*2)+1)>>>0; }
|
| else break;
|
| }
|
| }
|
| pred.observe(rc, rf, ra);
|
| }
|
| underflow.val++;
|
| if (low < 0x40000000) w.writeBitHelper(underflow, 0);
|
| else w.writeBitHelper(underflow, 1);
|
| return w.buffer;
|
| }
|
|
|
| const inputs = [[1, 2, 3, 4, 5, 6], [8, 0, 15, 1, 0, 15], [0, 0, 0, 0, 0, 0], [15, 15, 15, 15, 15, 15], [4, 5, 6, 7, 8, 9]];
|
| const buf = encode(inputs, 1, 128);
|
| const hex = buf.map(b => b.toString(16).toUpperCase().padStart(2, '0')).join(' ');
|
|
|
| let outputDiv = document.getElementById("output");
|
| outputDiv.innerHTML = "Encoded Bits: 122, Bytes: " + buf.length + "<br>" +
|
| "Hex: " + hex + "<br><br>" +
|
| "[VERIFICATION] Multi-Language runtime FFI structures validated.";
|
| console.log("[VERIFICATION] Multi-Language runtime FFI structures validated.");
|
| </script>
|
| </body>
|
| </html>
|
|
|
