import requests, base64, struct, math

API_KEY = "your_uuon_key"
BASE    = "http://compress.uuon.world"

data = [math.sin(i * 0.1) * 50 + 50 for i in range(1000)]

r = requests.post(
    f"{BASE}/algorithms/compression-field/compress-binary",
    headers={"x-api-key": API_KEY},
    json={"data": data, "zone_count": 8}
).json()

o = r["output"]
print(f"Compression ratio : {o['compression_ratio_b64']}x")
print(f"Shannon entropy H : {o['H_total']}")
print(f"Original size     : {o['original_bytes']} bytes")
print(f"Compressed size   : {o['compressed_bytes_b64']} bytes")

# Decode the packed binary
raw    = base64.b64decode(o["compressed_b64"])
floats = struct.unpack(f"{len(raw)//4}f", raw)
zones  = [(floats[i], floats[i+1]) for i in range(0, len(floats), 2)]
for i, (centroid, deviation) in enumerate(zones):
    print(f"Zone {i}: centroid={centroid:.4f}  max_dev={deviation:.4f}")

const KEY  = 'your_uuon_key';
const BASE = 'http://compress.uuon.world';

const data = Array.from({length: 1000}, (_, i) => Math.sin(i * 0.1) * 50 + 50);

const res = await fetch(`${BASE}/algorithms/compression-field/compress-binary`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'x-api-key': KEY },
  body: JSON.stringify({ data, zone_count: 8 })
});

const { output: o } = await res.json();
console.log(`Ratio  : ${o.compression_ratio_b64}x`);
console.log(`Entropy: ${o.H_total}`);
console.log(`Size   : ${o.original_bytes} to ${o.compressed_bytes_b64} bytes`);

// Decode binary in browser
const raw  = atob(o.compressed_b64);
const buf  = new ArrayBuffer(raw.length);
const u8   = new Uint8Array(buf);
for (let i = 0; i < raw.length; i++) u8[i] = raw.charCodeAt(i);
const f32  = new Float32Array(buf);
// f32 = [centroid_z0, maxdev_z0, centroid_z1, maxdev_z1, ...]

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/binary"
    "encoding/json"
    "fmt"
    "math"
    "net/http"
)

const apiKey = "your_uuon_key"
const base   = "http://compress.uuon.world"

func main() {
    data := make([]float64, 1000)
    for i := range data {
        data[i] = math.Sin(float64(i)*0.1)*50 + 50
    }
    body, _ := json.Marshal(map[string]interface{}{
        "data": data, "zone_count": 8,
    })
    req, _ := http.NewRequest("POST",
        base+"/algorithms/compression-field/compress-binary",
        bytes.NewBuffer(body))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-api-key", apiKey)

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    o := result["output"].(map[string]interface{})
    fmt.Printf("Ratio  : %vx\n", o["compression_ratio_b64"])
    fmt.Printf("Entropy: %v\n", o["H_total"])

    raw, _ := base64.StdEncoding.DecodeString(o["compressed_b64"].(string))
    for i := 0; i < len(raw)/4; i += 2 {
        c := math.Float32frombits(binary.LittleEndian.Uint32(raw[i*4:]))
        d := math.Float32frombits(binary.LittleEndian.Uint32(raw[(i+1)*4:]))
        fmt.Printf("Zone %d: centroid=%.4f  max_dev=%.4f\n", i/2, c, d)
    }
}

use base64::{engine::general_purpose, Engine};
use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let data: Vec<f64> = (0..1000)
        .map(|i| (i as f64 * 0.1).sin() * 50.0 + 50.0)
        .collect();

    let res: serde_json::Value = client
        .post("http://compress.uuon.world/algorithms/compression-field/compress-binary")
        .header("x-api-key", "your_uuon_key")
        .json(&json!({ "data": data, "zone_count": 8 }))
        .send().await?.json().await?;

    let o = &res["output"];
    println!("Ratio  : {}x", o["compression_ratio_b64"]);
    println!("Entropy: {}",  o["H_total"]);

    let raw = general_purpose::STANDARD.decode(o["compressed_b64"].as_str().unwrap())?;
    let floats: Vec<f32> = raw.chunks(4)
        .map(|c| f32::from_le_bytes(c.try_into().unwrap()))
        .collect();
    for (i, chunk) in floats.chunks(2).enumerate() {
        println!("Zone {}: centroid={:.4}  max_dev={:.4}", i, chunk[0], chunk[1]);
    }
    Ok(())
}

import fetch from 'node-fetch'; // npm install node-fetch

const KEY  = 'your_uuon_key';
const BASE = 'http://compress.uuon.world';

const data = Array.from({length: 1000}, (_, i) => Math.sin(i * 0.1) * 50 + 50);

const res = await fetch(`${BASE}/algorithms/compression-field/compress-binary`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'x-api-key': KEY },
  body: JSON.stringify({ data, zone_count: 8 })
});

const { output: o } = await res.json();
console.log(`Ratio  : ${o.compression_ratio_b64}x`);
console.log(`Entropy: ${o.H_total}`);

const buf    = Buffer.from(o.compressed_b64, 'base64');
const floats = [];
for (let i = 0; i < buf.length; i += 4) floats.push(buf.readFloatLE(i));
floats.forEach((v, i) => {
  if (i % 2 === 0) process.stdout.write(`Zone ${i/2}: centroid=${v.toFixed(4)}`);
  else console.log(`  max_dev=${v.toFixed(4)}`);
});

library(httr)
library(jsonlite)
library(base64enc)

API_KEY <- "your_uuon_key"
data    <- sin(seq(0, 99.9, by=0.1)) * 50 + 50

res <- POST(
  "http://compress.uuon.world/algorithms/compression-field/compress-binary",
  add_headers("x-api-key" = API_KEY, "Content-Type" = "application/json"),
  body = toJSON(list(data = data, zone_count = 8L), auto_unbox = TRUE)
)

o <- content(res)$output
cat("Ratio  :", o$compression_ratio_b64, "x\n")
cat("Entropy:", o$H_total, "\n")

raw    <- base64decode(o$compressed_b64)
con    <- rawConnection(raw)
floats <- readBin(con, "numeric", n = length(raw)/4, size = 4, endian = "little")
close(con)
matrix(floats, ncol=2, byrow=TRUE, dimnames=list(NULL, c("centroid","max_dev")))