{"id":50663591,"url":"https://github.com/cool-japan/oxieml","last_synced_at":"2026-06-08T04:04:30.954Z","repository":{"id":354304897,"uuid":"1210454112","full_name":"cool-japan/oxieml","owner":"cool-japan","description":"OxiEML - A Pure Rust crate that implements the EML operator eml(x, y) = exp(x) - ln(y) and builds uniform binary trees expressing all elementary functions using only this operator and the constant 1.","archived":false,"fork":false,"pushed_at":"2026-06-04T06:42:06.000Z","size":195,"stargazers_count":36,"open_issues_count":0,"forks_count":4,"subscribers_count":0,"default_branch":"master","last_synced_at":"2026-06-04T08:17:15.503Z","etag":null,"topics":["eml","mathematics","pure-rust","rust","rust-lang","science","scientific-calculator","scientific-computing"],"latest_commit_sha":null,"homepage":"https://github.com/cool-japan/oxieml","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/cool-japan.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null},"funding":{"github":"cool-japan"}},"created_at":"2026-04-14T12:38:59.000Z","updated_at":"2026-05-21T15:09:48.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/cool-japan/oxieml","commit_stats":null,"previous_names":["cool-japan/oxieml"],"tags_count":2,"template":false,"template_full_name":null,"purl":"pkg:github/cool-japan/oxieml","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Foxieml","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Foxieml/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Foxieml/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Foxieml/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/cool-japan","download_url":"https://codeload.github.com/cool-japan/oxieml/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cool-japan%2Foxieml/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34047285,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-08T02:00:07.615Z","response_time":111,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["eml","mathematics","pure-rust","rust","rust-lang","science","scientific-calculator","scientific-computing"],"created_at":"2026-06-08T04:04:30.283Z","updated_at":"2026-06-08T04:04:30.948Z","avatar_url":"https://github.com/cool-japan.png","language":"Rust","funding_links":["https://github.com/sponsors/cool-japan"],"categories":[],"sub_categories":[],"readme":"# OxiEML\n\n**All elementary functions from a single binary operator.**\n\nA Pure Rust crate that implements the EML operator `eml(x, y) = exp(x) - ln(y)`\nand builds uniform binary trees expressing **all elementary functions** using only\nthis operator and the constant `1`.\n\nBased on [arXiv:2603.21852](https://arxiv.org/abs/2603.21852) — *\"All elementary\nfunctions from a single binary operator\"* by Andrzej Odrzywolek (Jagiellonian\nUniversity, Institute of Theoretical Physics).\n\n## Key Capabilities\n\n1. **Uniform Tree Representation** — Every elementary function (exp, ln, sin, cos,\n   +, -, *, /, ^, sqrt, abs, ...) is expressed via the grammar `S -\u003e 1 | eml(S, S)`.\n\n2. **Symbolic Regression** — Discover closed-form mathematical formulas from\n   input/output data using gradient-based search over EML tree topologies.\n\n3. **Lowering \u0026 Code Generation** — Convert discovered EML trees to standard\n   operation trees for efficient evaluation, pretty-printing, and Rust code emission.\n\n4. **CLI Tool** — Parse, evaluate, and generate EML expressions from the command line.\n\n5. **SMT Integration** — Constraint solving via EML tree interval narrowing\n   (feature-gated for oxiz integration).\n\n6. **Gradient / Jacobian / Hessian** — Symbolic differentiation on `LoweredOp` with\n   `LoweredOp::grad(wrt)`, `grad_all()`, `jacobian(n)`, `hessian(n)`.\n\n7. **Extended Transcendentals** — `LoweredOp` has `Tan`, `Sinh`, `Cosh`, `Tanh`,\n   `Arcsin`, `Arccos`, `Arctan`, `Arcsinh`, `Arccosh`, `Arctanh` with canonical EML\n   shape recognition.\n\n8. **Interval Arithmetic** — `LoweredOp::eval_interval` for range analysis and\n   symreg pruning.\n\n9. **JIT Compilation** — Cranelift-based JIT for hot evaluation paths (feature: `jit`).\n\n10. **ODE Discovery** — SINDy-style ODE/PDE discovery from trajectory data\n    (`SymRegEngine::discover_ode`).\n\n11. **Multi-output Symbolic Regression** — `SymRegEngine::discover_multi` for\n    vector-valued formulas.\n\n12. **Dimensional Analysis** — SI unit-aware regression with `Units` algebra; rejects\n    dimensionally-inconsistent formulas.\n\n13. **Python Bindings** — PyO3-based Python bindings via maturin (feature: `python`).\n\n14. **WASM Bindings** — wasm-bindgen target with npm package `@cool-japan/oxieml`\n    (feature: `wasm`).\n\n15. **Noise-Robust Loss** — Huber and TrimmedMSE loss functions (`SymRegLoss` enum).\n\n16. **Constants Extraction** — Post-Adam rounding of floats to π, e, simple rationals.\n\n17. **Beam Search** — `SymRegStrategy::Beam{width}` for depth \u003e 4 topology exploration.\n\n18. **MCTS Search** — Monte Carlo Tree Search topology exploration (`symreg/mcts.rs`).\n\n19. **Serde Serialization** — JSON + oxicode binary for `EmlTree`/`LoweredOp`/\n    `DiscoveredFormula` (feature: `serde`).\n\n20. **TensorLogic Integration** — Bidirectional `LoweredOp ↔ TLExpr` mapping + soft-prior\n    export (feature: `tensorlogic`).\n\n21. **SciRS2 Integration** — ndarray adapter (feature: `scirs2`).\n\n## CLI Tool\n\nThe `oxieml` CLI can evaluate EML expressions, generate EML from function names,\nand verify claims about mathematical constants.\n\n```bash\n# Evaluate an EML expression\noxieml \"E(1, 1)\"\n#=\u003e MATCH: e (Euler's number) = 2.718281828459045\n\n# Generate EML from a function/constant name\noxieml -g pi\n#=\u003e E(1,E(E(1,E(E(1,E(E(1,E(1,E(1,1))),1)),E(E(1,1),1))),1))\n#=\u003e MATCH: Im ~ pi (diff = 0.00e0)\n\noxieml -g e\n#=\u003e E(1,1)\n\noxieml -g sin x0=0.5\n#=\u003e Result: 0.4794255386042034\n\n# Evaluate with variables\noxieml \"E(x0, 1)\" x0=2.0\n#=\u003e Result: 7.38905609893065  (= exp(2))\n\n# Read from file\noxieml --file expression.txt\n\n# List all available functions and constants\noxieml -l\n\n# Show help / version\noxieml --help\noxieml --version\n```\n\nIf the input is not a valid EML expression, the CLI auto-detects function names:\n\n```bash\noxieml pi          # same as: oxieml -g pi\noxieml sin         # generates sin(x0) template\n```\n\n## Quick Start (Library)\n\n```rust\nuse oxieml::{EmlTree, Canonical, EvalCtx};\n\n// Build exp(x) = eml(x, 1)\nlet x = EmlTree::var(0);\nlet exp_x = Canonical::exp(\u0026x);\n\n// Evaluate at x = 1.0 -\u003e e\nlet ctx = EvalCtx::new(\u0026[1.0]);\nlet result = exp_x.eval_real(\u0026ctx).unwrap();\nassert!((result - std::f64::consts::E).abs() \u003c 1e-10);\n\n// Euler's number: eml(1, 1) = exp(1) - ln(1) = e\nlet e = Canonical::euler();\nprintln!(\"{}\", e); // \"eml(1, 1)\"\n\n// Negation, addition, multiplication — all from eml and 1\nlet y = EmlTree::var(1);\nlet sum = Canonical::add(\u0026x, \u0026y);\nlet product = Canonical::mul(\u0026x, \u0026y);\n\n// Lower to standard operations for efficient evaluation\nlet lowered = exp_x.lower();\nprintln!(\"{}\", lowered.to_pretty()); // \"exp(x0)\"\nlet fast_result = lowered.eval(\u0026[1.0]);\n\n// Generate Rust source code\nlet code = oxieml::compile::compile_to_rust(\u0026exp_x, \"my_exp\");\nprintln!(\"{code}\");\n```\n\n## Parser\n\nParse EML expressions from strings and convert back:\n\n```rust\nuse oxieml::parser::{parse, to_compact_string};\n\n// Parse E(x, y) notation\nlet tree = parse(\"E(E(1, 1), 1)\").unwrap();\nassert_eq!(tree.depth(), 2);\n\n// Also accepts eml(x, y) notation\nlet tree = parse(\"eml(E(1, x0), 1)\").unwrap();\n\n// Convert back to compact string\nlet compact = to_compact_string(\u0026tree);\nassert_eq!(parse(\u0026compact).unwrap(), tree); // roundtrip\n```\n\n## Symbolic Regression\n\n```rust\nuse oxieml::symreg::{SymRegConfig, SymRegEngine};\n\n// Generate data from an unknown function\nlet inputs: Vec\u003cVec\u003cf64\u003e\u003e = (0..50).map(|i| vec![i as f64 * 0.1]).collect();\nlet targets: Vec\u003cf64\u003e = inputs.iter().map(|x| x[0].exp()).collect();\n\nlet config = SymRegConfig {\n    max_depth: 2,\n    learning_rate: 1e-2,\n    tolerance: 1e-8,\n    ..Default::default()\n};\n\nlet engine = SymRegEngine::new(config);\nlet formulas = engine.discover(\u0026inputs, \u0026targets, 1).unwrap();\n\nprintln!(\"Best formula: {}\", formulas[0].pretty);\nprintln!(\"MSE: {:.2e}\", formulas[0].mse);\n```\n\n## SMT / Constraint Solving\n\nWith the `smt` feature, oxieml integrates [OxiZ](https://crates.io/crates/oxiz) 0.2\nas a backend for deciding EML constraints. The solver uses **interval propagation**\n(EML-aware forward/backward rules for exp/ln) followed by **linear relaxation**\n(secant + tangent bounds) for OxiZ's LRA theory.\n\n```rust,ignore\nuse oxieml::{EmlTree, Canonical, EmlConstraint, EmlSmtSolver, SmtResult};\n\n// Constraint: exp(x) \u003e 0 — trivially true for all x\nlet x = EmlTree::var(0);\nlet one = EmlTree::one();\nlet exp_x = EmlTree::eml(\u0026x, \u0026one);\nlet c = EmlConstraint::GtZero(exp_x);\n\nlet solver = EmlSmtSolver::new(vec![(-10.0, 10.0)]);\nmatch solver.check_sat(\u0026c).unwrap() {\n    SmtResult::Sat(sol) =\u003e println!(\"SAT: x = {}\", sol.assignments[0]),\n    SmtResult::Unsat =\u003e println!(\"UNSAT — impossible\"),\n    SmtResult::Unknown =\u003e println!(\"unknown\"),\n}\n```\n\nThe `EmlSmtSolver` can prove **UNSAT** for cases the legacy `EmlNraSolver`\n(interval bisection) cannot — e.g., `ln(x) \u003e 0` with `x ∈ [-2, -1]` (ln\nundefined for non-positive reals). It falls back to bisection on OxiZ-tightened\nbounds to extract concrete SAT witnesses, since extracting real-valued models\nfrom OxiZ 0.2 is not yet ergonomic.\n\nEnable with:\n\n```toml\n[dependencies]\noxieml = { version = \"0.1\", features = [\"smt\"] }\n```\n\nThe `IntervalDomain` type is always available (no feature) for lightweight\npropagation use-cases.\n\n## What's New in v0.1.1\n\nReleased 2026-05-03.\n\n- Symbolic gradient, Jacobian, and Hessian on `LoweredOp`\n- Extended transcendentals in `LoweredOp` (`Tan`, `Sinh`, `Cosh`, `Tanh`, `Arcsin`,\n  `Arccos`, `Arctan`, `Arcsinh`, `Arccosh`, `Arctanh`)\n- Interval arithmetic on `LoweredOp` for domain analysis and symreg pruning\n- Noise-robust loss (`Huber`, `TrimmedMSE`) and constants extraction (π, e, rationals)\n- Beam search and MCTS topology strategies for depth \u003e 4\n- ODE/PDE discovery via `SymRegEngine::discover_ode`\n- Multi-output symbolic regression via `SymRegEngine::discover_multi`\n- Dimensional analysis: SI unit-aware regression with hard pruning\n- JIT compilation (Cranelift, `jit` feature): 5–20× speedup on long batches\n- Serde serialization for all types (`serde` feature)\n- Python bindings (`python` feature, maturin-packaged)\n- WASM bindings (`wasm` feature, npm: `@cool-japan/oxieml`)\n- TensorLogic integration (`tensorlogic` feature): soft-prior export\n- SciRS2 integration (`scirs2` feature): ndarray adapters\n- Constraint-guided symreg pruning via `EmlSmtSolver` (UNSAT-prune topologies)\n- CLI: `--grad`/`-d`, `--symreg`/`-s`, `--format`, `--output`, `--strategy` flags\n\n## Canonical Constructions (Complete Phylogenetic Tree)\n\nAll functions from the paper's phylogenetic tree (Figure 1) are implemented:\n\n### Table 1: Basic Operations\n\n| Function    | EML Construction               | Depth |\n|-------------|--------------------------------|-------|\n| `exp(x)`    | `eml(x, 1)`                   | 1     |\n| `e`         | `eml(1, 1)`                   | 1     |\n| `ln(x)`     | `eml(1, eml(eml(1, x), 1))`   | 3     |\n| `-x`        | via `(e-x) - e` composition   | 6     |\n| `0`         | `ln(1)`                        | 3     |\n\n### Table 2: Arithmetic\n\n| Function    | EML Construction               | Depth |\n|-------------|--------------------------------|-------|\n| `x + y`     | `sub(x, neg(y))`              | ~12   |\n| `x - y`     | `eml(ln(x), eml(y, 1))`       | ~7    |\n| `x * y`     | `exp(ln(x) + ln(y))`          | ~14   |\n| `x / y`     | `exp(ln(x) - ln(y))`          | ~14   |\n| `x ^ y`     | `exp(y * ln(x))`              | ~18   |\n| `1/x`       | `exp(-ln(x))`                 | ~10   |\n| `x^2`       | `pow(x, 2)`                   | deep  |\n\n### Table 3: Trigonometric\n\n| Function      | EML Construction                       | Depth |\n|---------------|----------------------------------------|-------|\n| `pi` (iπ)     | `ln(-1)` in complex domain            | 9     |\n| `sin(x)`      | `(exp(ix) - exp(-ix)) / 2i`           | ~52   |\n| `cos(x)`      | `(exp(ix) + exp(-ix)) / 2`            | ~52   |\n| `tan(x)`      | `sin(x) / cos(x)`                     | deep  |\n\n### Table 4: Inverse Trigonometric\n\n| Function      | EML Construction                              |\n|---------------|-----------------------------------------------|\n| `arcsin(x)`   | `-i * ln(ix + sqrt(1 - x^2))`                |\n| `arccos(x)`   | `-i * ln(x + i * sqrt(1 - x^2))`             |\n| `arctan(x)`   | `(-i/2) * ln((1 + ix) / (1 - ix))`           |\n\n### Table 5: Hyperbolic\n\n| Function    | EML Construction                |\n|-------------|---------------------------------|\n| `sinh(x)`   | `(exp(x) - exp(-x)) / 2`      |\n| `cosh(x)`   | `(exp(x) + exp(-x)) / 2`      |\n| `tanh(x)`   | `sinh(x) / cosh(x)`           |\n\n### Table 6: Inverse Hyperbolic\n\n| Function      | EML Construction                        |\n|---------------|-----------------------------------------|\n| `arcsinh(x)`  | `ln(x + sqrt(x^2 + 1))`               |\n| `arccosh(x)`  | `ln(x + sqrt(x^2 - 1))`               |\n| `arctanh(x)`  | `(1/2) * ln((1 + x) / (1 - x))`       |\n\n### Table 7: Other Functions \u0026 Constants\n\n| Function    | EML Construction         |\n|-------------|--------------------------|\n| `sqrt(x)`   | `x^0.5`                 |\n| `abs(x)`    | `sqrt(x^2)`             |\n| `nat(n)`    | `1 + 1 + ... + 1`       |\n| `-1`        | `neg(1)`                |\n| `-2`        | `neg(nat(2))`           |\n| `i`         | `exp(iπ/2)`             |\n\n## Architecture\n\n```\nDiscovery Phase              Execution Phase\n─────────────────           ──────────────────\nEML tree space     lower()  Standard ops\nS -\u003e 1 | eml(S,S) -------\u003e Add/Sub/Mul/Exp/Ln...\n     |                           |\n     | Adam optimizer            | to_pretty()\n     | (symreg)                  | compile_to_rust()\n     |                           | eval()\n  DiscoveredFormula         Fast evaluation\n\n     parse()                to_compact_string()\n\"E(1,1)\" -----\u003e EmlTree ---------\u003e \"E(1,1)\"\n                   |\n                   | -g pi / -g sin\n                   |\n              CLI evaluation \u0026 constant matching\n```\n\n## Module Overview\n\n| Module           | Purpose |\n|------------------|---------|\n| `tree`           | `EmlNode`/`EmlTree` — Arc-shared uniform binary trees |\n| `eval`           | Stack-machine evaluation (real, complex, batch) |\n| `grad`           | Automatic differentiation for parameter optimization |\n| `canonical`      | Complete phylogenetic tree: 30+ elementary functions |\n| `parser`         | Parse `E(x,y)` / `eml(x,y)` notation, roundtrip |\n| `simplify`       | EML tree algebraic simplification + CSE + constant folding |\n| `lower`          | EML → standard operation trees + pretty-print |\n| `lower_grad`     | Symbolic differentiation on `LoweredOp` (grad, Jacobian, Hessian) |\n| `lower_simplify` | Simplification rules on `LoweredOp` (constant folding, algebraic) |\n| `lower_interval` | Interval arithmetic on `LoweredOp` for range analysis |\n| `lower_units`    | SI unit inference and dimensional consistency checking |\n| `named_const`    | Named constant detection (π, e, √2, rationals) post-Adam |\n| `compile`        | EML → Rust source code generation (scalar, batch, closure) |\n| `symreg`         | Symbolic regression engine (topology enum + Adam + beam + MCTS) |\n| `symreg/topology`| Topology enumeration and semantic deduplication |\n| `symreg/mcts`    | Monte Carlo Tree Search topology exploration |\n| `symreg/numerics`| Adam optimizer, k-fold CV, noise-robust loss functions |\n| `symreg/constants`| Post-Adam constant extraction and rounding |\n| `smt`            | [feature: smt] Constraint solving (interval propagation + OxiZ LRA) |\n| `simd_eval`      | [feature: simd] SIMD batch evaluation via oxiblas-core |\n| `jit`            | [feature: jit] Cranelift JIT for OxiOp sequences |\n| `tensorlogic`    | [feature: tensorlogic] Bidirectional `LoweredOp ↔ TLExpr` |\n| `scirs2`         | [feature: scirs2] ndarray adapter for SciRS2 integration |\n| `python`         | [feature: python] PyO3 bindings for Python |\n| `wasm`           | [feature: wasm] wasm-bindgen bindings for browser/Node.js |\n| `units`          | SI unit algebra (7-exponent vector, `Units` struct) |\n| `solve`          | Symbolic equation solving |\n| `error`          | Error types |\n\n## Features\n\n```toml\n[dependencies]\noxieml = { version = \"0.1\", features = [\"smt\", \"simd\", \"parallel\"] }\n```\n\n| Feature        | Description |\n|----------------|-------------|\n| `smt`          | OxiZ SMT backend + interval propagation + NRA solver |\n| `simd`         | SIMD batch evaluation via oxiblas-core (aarch64 + x86_64) |\n| `parallel`     | Rayon parallel batch evaluation |\n| `tensorlogic`  | Bidirectional `LoweredOp ↔ TLExpr` bridge |\n| `scirs2`       | ndarray `Array2`/`Array1` adapters for SciRS2 workflows |\n| `serde`        | JSON + oxicode binary serialization for all types |\n| `python`       | PyO3 Python bindings (use `python-extension` for `.so`) |\n| `wasm`         | wasm-bindgen WASM bindings for browser/Node.js |\n| `jit`          | Cranelift JIT compiler for hot OxiOp sequences |\n\nCombine `simd,parallel` for SIMD-per-worker batch evaluation.\n\n## Performance\n\nMeasured on Apple M1 (8-core, NEON 128-bit), M1 MacBook Air, 2026-04:\n\n**Speedup from `parallel` feature** (RAYON_NUM_THREADS=1 → 8):\n\n| Workload | 1 thread | 8 threads | Speedup |\n|---|---|---|---|\n| `eval_batch` 10K points (exp tree walk) | 436 µs | 235 µs | **1.85×** |\n| `lowered_eval_batch` 100K points (SIMD) | 2.71 ms | 682 µs | **3.97×** |\n| `symreg_discover` (topology optimization) | 73.7 ms | 17.3 ms | **4.26×** |\n\n**Speedup from `simd` feature** (10K-point batch, LoweredOp IR):\n\n| Variant | time | Speedup |\n|---|---|---|\n| Scalar stack machine | 159.8 µs | 1.0× |\n| SIMD (F64x2 NEON via oxiblas-core) | 57.0 µs | **2.80×** |\n\nParallelism helps most for coarse-grained work (symreg topology optimization).\nSIMD gives ~2.8× on batch evaluation regardless of batch size. Combining both\nscales near-linearly on large batches (100K+ points).\n\n## Design Decisions\n\n- **`Arc\u003cEmlNode\u003e`** — O(1) subtree sharing during symbolic regression\n- **Stack-machine evaluator** — Post-order traversal avoids recursion overflow\n  on deep trees (sin alone needs 543 nodes)\n- **Complex64 internally** — Trig functions and π require `ln(-1) = iπ`;\n  complex eval is an internal detail, API is real-valued\n- **Discovery vs execution separation** — EML trees for search, lowered ops for speed\n- **Parser roundtrip** — `parse(to_compact_string(tree)) == tree`\n- **Pure Rust, zero FFI** — Deps: `num-complex`, `rand`;\n  optional: `rayon` (parallel), `oxiblas-core` (simd), `oxiz` + `num-rational` (smt)\n\n## Test Coverage\n\n434 tests covering:\n- Canonical tree construction (correctness, complex, symbolic)\n- Lowering, compilation, pretty-print, LaTeX\n- Symbolic gradient, Jacobian, Hessian (central-difference cross-checks)\n- Property-based gradient tests (proptest, 1024 cases)\n- Trig precision (sin/cos via canonical shapes, 0.0 vs ~1e-14 walk error)\n- Interval arithmetic containment and tightness\n- Serde round-trip (JSON + oxicode binary)\n- SIMD/parallel equivalence\n- SMT/constraint solving: interval propagation, OxiZ backend, SAT/UNSAT\n- Symbolic regression: Adam, Pareto, k-fold CV, beam, MCTS, multi-output, ODE\n- Unit-aware regression (dimensional analysis)\n- JIT compilation (scalar, vectorized, cache, hash stability)\n- TensorLogic bridge (to/from TLExpr, rewrite rules, soft-prior export)\n- CLI integration (eval, lower, grad, symreg, format, output flags)\n\n```bash\ncargo nextest run --all-features    # 434 tests\ncargo clippy --all-targets --all-features -- -D warnings   # zero warnings\ncargo bench --features simd,parallel                       # criterion benchmarks\n```\n\n## References\n\n- Paper: Andrzej Odrzywolek, *\"All elementary functions from a single binary operator\"*,\n  [arXiv:2603.21852](https://arxiv.org/abs/2603.21852) (v2: 2026-04-04),\n  Jagiellonian University, Institute of Theoretical Physics\n\n## COOLJAPAN Ecosystem\n\nOxiEML is part of the **COOLJAPAN Pure Rust Ecosystem** — one of the largest pure-Rust sovereignty stacks in existence, comprising 660 crates, ~26M SLoC, and 350,000+ passing tests across 50+ production-grade libraries. All projects enforce `fail0 + Clippy0` with zero C/Fortran dependencies by default.\n\n### Core Projects\n\n| Domain | Project | Description |\n|--------|---------|-------------|\n| Scientific Computing | [SciRS2](https://github.com/cool-japan/scirs) | Complete NumPy/SciPy/scikit-learn replacement (3M SLoC) |\n| Scientific Computing | [NumRS2](https://github.com/cool-japan/numrs) | High-performance numerical computing in Rust |\n| Scientific Computing | [QuantRS2](https://github.com/cool-japan/quantrs) | Full quantum computing framework |\n| Deep Learning | [ToRSh](https://github.com/cool-japan/torsh) | PyTorch-compatible framework with native sharding |\n| LLM | [OxiBonsai](https://github.com/cool-japan/oxibonsai) | Pure Rust 1-Bit LLM inference engine for PrismML Bonsai models |\n| GPU (CUDA) | [OxiCUDA](https://github.com/cool-japan/oxicuda) | NVIDIA CUDA Toolkit with type-safe, memory-safe Rust code |\n| Media \u0026 CV | [OxiMedia](https://github.com/cool-japan/oximedia) | FFmpeg + OpenCV replacement (106 crates) |\n| Geospatial | [OxiGDAL](https://github.com/cool-japan/oxigdal) | Pure Rust GDAL replacement (cloud-native, full CRS \u0026 formats) |\n| Semantic Web | [OxiRS](https://github.com/cool-japan/oxirs) | SPARQL 1.2, GraphQL, Digital Twin (Apache Jena replacement) |\n| Physics | [OxiPhysics](https://github.com/cool-japan/oxiphysics) | Unified physics engine — Bullet/OpenFOAM/LAMMPS/CalculiX replacement |\n| Formal Verification | [OxiLean](https://github.com/cool-japan/oxilean) | Memory-safe interactive theorem prover (Lean 4 inspired) |\n| Formal Verification | [OxiZ](https://github.com/cool-japan/oxiz) | High-performance SMT solver (Z3 replacement) |\n| Legal Technology | [Legalis-RS](https://github.com/cool-japan/legalis-rs) | Legal statute parser, analyzer \u0026 simulator |\n| Digital Humans | [OxiHuman](https://github.com/cool-japan/oxihuman) | Privacy-first parametric human body generator (WASM/WebGPU) |\n| Signal Processing | [Kizzasi](https://github.com/cool-japan/kizzasi) | Rust-native AGSP for continuous audio, sensor, robotics \u0026 video streams |\n| Tensor Logic | [TensorLogic](https://github.com/cool-japan/tensorlogic) | Logical rules → tensor equations (einsum graphs) with DSL + IR |\n| Math | **OxiEML** | All elementary functions from a single binary operator (this crate) |\n\nFull project list \u0026 latest releases → [cooljapan.tech](https://cooljapan.tech/) · [GitHub](https://github.com/cool-japan)\n\n## Sponsorship\n\nOxiEML is developed and maintained by **COOLJAPAN OU (Team Kitasan)**.\n\nThe COOLJAPAN Ecosystem represents one of the largest Pure Rust scientific computing efforts in existence — spanning 50+ projects, 650+ crates, and millions of lines of Rust code across scientific computing, machine learning, quantum computing, geospatial analysis, legal technology, multimedia processing, and more. Every line is written and maintained by a small dedicated team committed to a C/Fortran-free future for scientific software.\n\nIf you find OxiEML or any COOLJAPAN project useful, please consider sponsoring to support continued development.\n\n[![Sponsor](https://img.shields.io/badge/Sponsor-%E2%9D%A4-red?logo=github)](https://github.com/sponsors/cool-japan)\n\n**[https://github.com/sponsors/cool-japan](https://github.com/sponsors/cool-japan)**\n\nYour sponsorship helps us:\n- Maintain and expand the COOLJAPAN ecosystem (50+ projects, 650+ crates)\n- Keep the entire stack 100% Pure Rust — no C/Fortran/system library dependencies\n- Develop production-grade alternatives to OpenCV, FFmpeg, SciPy, NumPy, scikit-learn, PyTorch, TensorFlow, GDAL, and more\n- Provide long-term support, security updates, and documentation\n- Fund research into novel Rust-native algorithms and optimizations\n\n## License\n\nApache-2.0\n\n2026 COOLJAPAN OU (Team KitaSan)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcool-japan%2Foxieml","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcool-japan%2Foxieml","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcool-japan%2Foxieml/lists"}