Operators

See Concepts: Operators for the full overview.

Bind

bound = hv.bind(a, b)
released = hv.release(bound, b)  # this will recover `a`

hv.equal(a, b)                   # hash equality

bound := hv.Bind(a, b)                       
recovered := hv.Release(bound, b)        // this will recover `a`

eq := hv.Equal(a, b)                     // bool

#![allow(unused)]
fn main() {
let bound = operators::bind_hb(vec![a.clone(), b.clone()]); // Knot
let recovered = operators::release(&bound, &b);             // this will recover `a`

let eq = hyper_binary::equal(&a, &b);                       // bool
}

Release

Extracts one component from a binding: $A ⊘ B = A \otimes B^{- 1}$

release returns a Pointer — a directional reference from composite to role that retains both endpoints for inspection and serialization. The bit-level value is identical to bind(composite, inverse(role)).

bound = hv.bind(role, filler)
recovered = hv.release(bound, role)  # Pointer; ≈ filler at the bit level

bound := hv.Bind(role, filler)
recovered := hv.Release(bound, role)  // Pointer; ≈ filler at the bit level

#![allow(unused)]
fn main() {
let bound = operators::bind_hb(vec![role.clone(), filler.clone()]);
let recovered = operators::release(&bound, &role);  // Pointer
}

Expand (extend a Knot)

Extends an existing Knot with additional operands without re-binding from scratch. k.expand(c) on k = bind(a, b) gives the same result as bind(a, b, c) — but mutates k in place, so clone first if you need the original.

import copy

k = hv.bind(a, b)
k.expand(c)                 # k is now equivalent to hv.bind(a, b, c)

# To preserve the original, clone first:
base = hv.bind(a, b)
k1 = copy.copy(base)
k1.expand(c)                # base is untouched

k := hv.Bind(a, b)
k.Expand(c)                 // k is now equivalent to hv.Bind(a, b, c)

// To preserve the original, clone first (Clone returns HyperBinary):
base := hv.Bind(a, b)
k1 := base.Clone().(hv.Knot)
k1.Expand(c)                // base is untouched

#![allow(unused)]
fn main() {
let mut k = operators::bind_hb(vec![a.clone(), b.clone()]);
k.expand(vec![c.clone()]);   // k is now equivalent to bind_hb(vec![a, b, c])

// To preserve the original, clone first:
let base = operators::bind_hb(vec![a.clone(), b.clone()]);
let mut k1 = base.clone();
k1.expand(vec![c]);           // base is untouched
}

BindDirect

Like Bind, but returns a raw SparseSegmented instead of a Knot — no operand tracking. Cheaper for intermediate computations where you don’t need to reverse the bind or inspect the operand list.

# domain/pod default to the zero Domain/Pod
ss = hv.bind_direct(a, b, c)

# Or supply an explicit seed (annotates the resulting SparseSegmented):
ss = hv.bind_direct(a, b, domain=d, pod=p)

ss := hv.BindDirect(domain, pod, a, b, c)  // SparseSegmented

#![allow(unused)]
fn main() {
let ss = operators::bind_direct(domain, pod, &[a, b, c]);  // SparseSegmented
}

Bundle

p = hv.bundle(hv.Seed128(10, 1), a, b, c)

p := hv.Bundle(hv.NewSeed128(10, 1), a, b, c)

#![allow(unused)]
fn main() {
let p = operators::bundle(Seed128::new(10, 1), vec![a, b]);
}

Keyboard shortcuts