### Get Token Vectors Directly

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Retrieves or generates hypervectors for individual tokens. Ensures consistent hypervector generation for the same token and allows building custom associations by binding token hypervectors.

```rust
use hypervector::{set_global_seed, TieBreaker};
use hypervector::mbat::MBAT;
use hypervector::encoder::ObjectEncoder;

fn main() {
    set_global_seed(42);

    let mut encoder = ObjectEncoder::<MBAT>::new(1000, TieBreaker::AlwaysPositive);

    // Get hypervector for a token (generates if not exists)
    let alice_hv = encoder.get_token_vector("Alice");
    let bob_hv = encoder.get_token_vector("Bob");

    // Same token always returns the same hypervector
    let alice_hv_again = encoder.get_token_vector("Alice");
    assert_eq!(alice_hv, alice_hv_again);

    // Different tokens are nearly orthogonal
    let similarity = alice_hv.cosine_similarity(&bob_hv);
    println!("Similarity between 'Alice' and 'Bob': {:.3}", similarity);
    assert!(similarity.abs() < 0.1);

    // Build custom associations using token vectors
    let role_hv = encoder.get_token_vector("role");
    let engineer_hv = encoder.get_token_vector("engineer");

    // Create key-value binding: role -> engineer
    let role_engineer = role_hv.bind(&engineer_hv);
}
```

--------------------------------

### Encode 1D and 2D Spatial Input with SSPEncoder

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Demonstrates creating an SSPEncoder for 1D and 2D spatial inputs and encoding positions. Ensure the ssp_dim is even.

```rust
use hypervector::ssp::SSPEncoder;
use rand::rngs::StdRng;
use rand::SeedableRng;

fn main() {
    let mut rng = StdRng::seed_from_u64(42);

    // Create an encoder for 1D input with 2048-dimensional SSP output
    // ssp_dim must be even (for cosine/sine pairs)
    let encoder = SSPEncoder::new(2048, 1, &mut rng);

    // Encode a 1D spatial position
    let position = [0.5f32];
    let encoded = encoder.encode(&position);
    assert_eq!(encoded.len(), 2048);

    // Create encoder for 2D spatial input
    let encoder_2d = SSPEncoder::new(2048, 2, &mut rng);
    let position_2d = [1.0f32, 2.5f32];
    let encoded_2d = encoder_2d.encode(&position_2d);
    assert_eq!(encoded_2d.len(), 2048);
}
```

--------------------------------

### Build Associative Memory with Binding and Bundling

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Use `ObjectEncoder` to create key-value hypervectors, bind them, and then bundle the bindings into a single memory hypervector for associative retrieval. Ensure `set_global_seed` is called for reproducible results.

```rust
use hypervector::{set_global_seed, Hypervector, TieBreaker};
use hypervector::mbat::MBAT;
use hypervector::encoder::ObjectEncoder;

fn main() {
    set_global_seed(42);

    let mut encoder = ObjectEncoder::<MBAT>::new(10000, TieBreaker::AlwaysPositive);

    // Create key-value associations
    let keys = ["apple", "banana", "cherry"];
    let values = ["red", "yellow", "red"];

    // Build associative memory by binding pairs and bundling results
    let mut bindings = Vec::new();
    for (key, value) in keys.iter().zip(values.iter()) {
        let key_hv = encoder.get_token_vector(key);
        let value_hv = encoder.get_token_vector(value);
        bindings.push(key_hv.bind(&value_hv));
    }

    // Bundle all bindings into a single memory hypervector
    let memory = Hypervector::<MBAT>::bundle_many(&bindings, TieBreaker::AlwaysPositive);

    // Query: What color is associated with "apple"?
    let query_key = encoder.get_token_vector("apple");
    let retrieved = memory.bind(&query_key);

    // Compare with known values to find the match
    let red_hv = encoder.get_token_vector("red");
    let yellow_hv = encoder.get_token_vector("yellow");

    let sim_red = retrieved.cosine_similarity(&red_hv);
    let sim_yellow = retrieved.cosine_similarity(&yellow_hv);

    println!("Query 'apple' - similarity to 'red': {:.3}", sim_red);
    println!("Query 'apple' - similarity to 'yellow': {:.3}", sim_yellow);
    // Should show higher similarity to 'red'
}
```

--------------------------------

### Bind Hypervectors (Association)

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Use the bind method to create an association between two hypervectors. The result is orthogonal to both inputs and can be unbound to retrieve one given the other. Binding many vectors at once is also supported. For MBAT, binding is self-inverse.

```rust
use hypervector::{set_global_seed, Hypervector, TieBreaker};
use hypervector::mbat::MBAT;

fn main() {
    set_global_seed(42);

    let key = Hypervector::<MBAT>::generate(10000);
    let value = Hypervector::<MBAT>::generate(10000);

    // Bind creates an association - result is orthogonal to both inputs
    let bound = key.bind(&value);

    // The bound vector is nearly orthogonal to both constituents
    let sim_key = key.cosine_similarity(&bound);
    let sim_val = value.cosine_similarity(&bound);

    println!("Similarity to key: {:.3}", sim_key);   // ~0.0
    println!("Similarity to value: {:.3}", sim_val); // ~0.0

    // Bind many hypervectors at once
    let vectors = Hypervector::<MBAT>::generate_many(10000, 3);
    let multi_bound = Hypervector::<MBAT>::bind_many(&vectors);

    // Using the * operator for binding
    let product = key.clone() * value.clone();

    // For MBAT, binding is self-inverse: binding twice recovers the original
    let recovered = bound.bind(&key);
    let recovery_sim = recovered.cosine_similarity(&value);
    println!("Recovery similarity: {:.3}", recovery_sim); // ~1.0
}
```

--------------------------------

### Encode JSON Object with Different VSA Types using ObjectEncoder

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Demonstrates using ObjectEncoder with MBAT, SSP, and FHRR VSAs to encode a JSON object. Ensure the global seed is set for reproducibility.

```rust
use hypervector::{set_global_seed, TieBreaker};
use hypervector::mbat::MBAT;
use hypervector::ssp::SSP;
use hypervector::fhrr::FHRR;
use hypervector::encoder::ObjectEncoder;
use serde_json::json;

fn main() {
    set_global_seed(42);

    let json_obj = json!({
        "type": "document",
        "content": "Hello world"
    });

    // MBAT encoder: bipolar vectors, element-wise product binding
    let mut mbat_encoder = ObjectEncoder::<MBAT>::new(1000, TieBreaker::AlwaysPositive);
    let mbat_encoded = mbat_encoder.encode_object(&json_obj);

    // SSP encoder: continuous vectors, circular convolution binding
    let mut ssp_encoder = ObjectEncoder::<SSP>::new(1000, TieBreaker::AlwaysPositive);
    let ssp_encoded = ssp_encoder.encode_object(&json_obj);

    // FHRR encoder: phase angle vectors, angle addition binding
    let mut fhrr_encoder = ObjectEncoder::<FHRR>::new(1000, TieBreaker::AlwaysPositive);
    let fhrr_encoded = fhrr_encoder.encode_object(&json_obj);

    println!("MBAT dim: {}", mbat_encoded.to_vec().len());
    println!("SSP dim: {}", ssp_encoded.to_vec().len());
    println!("FHRR dim: {}", fhrr_encoded.to_vec().len());
}
```

--------------------------------

### Generate MBAT Hypervector and Encode JSON

Source: https://github.com/rishikanthc/hypervector/blob/main/README.md

Demonstrates generating a random MBAT hypervector and encoding a JSON object using the ObjectEncoder. Ensure the global RNG seed is set for reproducibility. Supports other VSA implementations like SSP or FHRR by changing the import.

```rust
use hypervector::{set_global_seed, Hypervector, TieBreaker};
use hypervector::mbat::MBAT;
use hypervector::encoder::ObjectEncoder;
use serde_json::json;

fn main() {
    // Set the global RNG seed for reproducibility.
    set_global_seed(42);

    // Generate a random MBAT hypervector of dimension 1000.
    let hv = Hypervector::<MBAT>::generate(1000);
    println!("Generated MBAT hypervector: {:?}", hv);

    // Create an object encoder for MBAT hypervectors.
    let mut encoder = ObjectEncoder::<MBAT>::new(1000, TieBreaker::AlwaysPositive);

    // Define a JSON object.
    let json_obj = json!({
        "firstName": "Alice",
        "lastName": "Smith",
        "isActive": true,
        "hobbies": ["reading", "cycling"]
    });

    // Encode the JSON object into a hypervector.
    let encoded = encoder.encode_object(&json_obj);
    println!("Encoded JSON object: {:?}", encoded);
}
```

--------------------------------

### Generate MBAT Hypervectors

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Generates random MBAT (Matrix Binding of Additive Terms) hypervectors with bipolar elements {-1, +1}. Supports generating single hypervectors or multiple at once.

```rust
use hypervector::{set_global_seed, Hypervector};
use hypervector::mbat::MBAT;

fn main() {
    set_global_seed(42);

    // Generate a random MBAT hypervector with 1000 dimensions
    let hv = Hypervector::<MBAT>::generate(1000);

    // Convert to plain Vec<f32> for inspection or external use
    let vec = hv.to_vec();
    assert_eq!(vec.len(), 1000);

    // Each element is either 1.0 or -1.0 for MBAT
    for &val in &vec {
        assert!(val == 1.0 || val == -1.0);
    }

    // Generate multiple hypervectors at once
    let codebook: Vec<Hypervector<MBAT>> = Hypervector::<MBAT>::generate_many(1000, 10);
    assert_eq!(codebook.len(), 10);
}
```

--------------------------------

### Update SSPEncoder Lengthscale for Spatial Resolution

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Shows how to update the lengthscale of an SSPEncoder to change the spatial resolution of the encoding. Smaller lengthscales increase sensitivity to position changes.

```rust
use hypervector::ssp::SSPEncoder;
use rand::rngs::StdRng;
use rand::SeedableRng;

fn main() {
    let mut rng = StdRng::seed_from_u64(42);

    // Create encoder with default lengthscale (1.0)
    let mut encoder = SSPEncoder::new(2048, 1, &mut rng);

    // Encode a position with default lengthscale
    let pos = [1.0f32];
    let encoded_default = encoder.encode(&pos);

    // Update lengthscale for different spatial resolution
    encoder.update_lengthscale(0.5);
    let encoded_fine = encoder.encode(&pos);

    // The encodings differ due to different lengthscales
    println!("First 3 elements (default): {:?}", &encoded_default[0..3]);
    println!("First 3 elements (fine): {:?}", &encoded_fine[0..3]);
}
```

--------------------------------

### Access Token and Object Codebooks

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Accesses the token and object codebooks maintained by ObjectEncoder. The token codebook maps individual tokens (keys, values) to hypervectors, while the object codebook maps JSON strings to their encoded hypervectors.

```rust
use hypervector::{set_global_seed, TieBreaker};
use hypervector::mbat::MBAT;
use hypervector::encoder::ObjectEncoder;
use serde_json::json;

fn main() {
    set_global_seed(42);

    let mut encoder = ObjectEncoder::<MBAT>::new(1000, TieBreaker::AlwaysPositive);

    // Encode multiple objects
    let obj1 = json!({"name": "Alice", "role": "engineer"});
    let obj2 = json!({"name": "Bob", "role": "designer"});

    encoder.encode_object(&obj1);
    encoder.encode_object(&obj2);

    // Access the token codebook (maps tokens to hypervectors)
    let token_book = encoder.token_codebook();
    println!("Token codebook has {} entries", token_book.len());

    // Tokens include keys and values: "name", "role", "Alice", "Bob", etc.
    for token in token_book.keys() {
        println!("  Token: {}", token);
    }

    // Access the object codebook (maps JSON strings to encoded hypervectors)
    let object_book = encoder.object_codebook();
    println!("Object codebook has {} entries", object_book.len());
}
```

--------------------------------

### Bundle Hypervectors (Superposition)

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Bundles multiple hypervectors into a single vector that is similar to all constituents, useful for set operations and memory superposition. Supports various tie-breaking strategies and operator overloading for addition.

```rust
use hypervector::{set_global_seed, Hypervector, TieBreaker};
use hypervector::mbat::MBAT;

fn main() {
    set_global_seed(42);

    let a = Hypervector::<MBAT>::generate(10000);
    let b = Hypervector::<MBAT>::generate(10000);

    // Bundle two hypervectors with a tie-breaking strategy
    // TieBreaker options: AlwaysPositive, AlwaysNegative, Random
    let bundled = a.bundle(&b, TieBreaker::Random);

    // The bundled vector is similar to both constituents (~0.5 similarity)
    let sim_a = bundled.cosine_similarity(&a);
    let sim_b = bundled.cosine_similarity(&b);

    println!("Similarity to a: {:.3}", sim_a); // ~0.5
    println!("Similarity to b: {:.3}", sim_b); // ~0.5

    // Bundle many hypervectors at once
    let vectors = Hypervector::<MBAT>::generate_many(10000, 5);
    let combined = Hypervector::<MBAT>::bundle_many(&vectors, TieBreaker::AlwaysPositive);

    // Using the + operator (default tie-breaker is Random)
    let c = Hypervector::<MBAT>::generate(10000);
    let sum = a.clone() + c;
}
```

--------------------------------

### Generate SSP Hypervectors

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Generates random SSP (Spatial Semantic Pointers) hypervectors with continuous-valued elements sampled from a normal distribution. These support circular convolution for binding.

```rust
use hypervector::Hypervector;
use hypervector::ssp::SSP;

fn main() {
    // Generate a random SSP hypervector with 2048 dimensions
    let hv = Hypervector::<SSP>::generate(2048);

    // Convert to Vec<f32> - values are continuous (not bipolar)
    let vec = hv.to_vec();
    assert_eq!(vec.len(), 2048);

    // SSP elements are real-valued (typically normally distributed)
    println!("First 5 elements: {:?}", &vec[0..5]);
}
```

--------------------------------

### Generate FHRR Hypervectors

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Generates random FHRR (Fourier Holographic Reduced Representations) hypervectors, represented as phase angles in radians. The `to_vec()` method returns the cosine of these angles.

```rust
use hypervector::Hypervector;
use hypervector::fhrr::FHRR;

fn main() {
    // Generate a random FHRR hypervector with 1000 dimensions
    let hv = Hypervector::<FHRR>::generate(1000);

    // to_vec() returns the cosine (real part) of each angle
    let vec = hv.to_vec();
    assert_eq!(vec.len(), 1000);

    // Values are cosine of phase angles, so in range [-1, 1]
    for &val in &vec {
        assert!(val >= -1.0 && val <= 1.0);
    }
}
```

--------------------------------

### Convert Hypervector to Vec<f32>

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Convert a hypervector to a `Vec<f32>` for interoperability. For MBAT, non-negative values become +1 and negative values become -1. For FHRR, `to_vec` returns the cosine of angles.

```rust
use hypervector::{set_global_seed, Hypervector};
use hypervector::mbat::MBAT;
use hypervector::fhrr::FHRR;

fn main() {
    set_global_seed(42);

    // Convert hypervector to Vec<f32>
    let hv = Hypervector::<MBAT>::generate(100);
    let vec: Vec<f32> = hv.to_vec();
    assert_eq!(vec.len(), 100);

    // Create hypervector from Vec<f32>
    // For MBAT: non-negative values become +1, negative become -1
    let input: Vec<f32> = (0..100)
        .map(|i| if i % 2 == 0 { 1.0 } else { -1.0 })
        .collect();
    let restored = Hypervector::<MBAT>::from_vec(input.clone());

    // Round-trip conversion preserves the data
    let output = restored.to_vec();
    assert_eq!(input, output);

    // FHRR: to_vec returns cosine of angles, from_vec takes cosine values
    let fhrr_input: Vec<f32> = vec![1.0, 0.5, 0.0, -0.5, -1.0];
    let fhrr_hv = Hypervector::<FHRR>::from_vec(fhrr_input.clone());
    let fhrr_output = fhrr_hv.to_vec();
    // Values should approximately match (acos then cos)
    for (orig, recon) in fhrr_input.iter().zip(fhrr_output.iter()) {
        assert!((orig - recon).abs() < 1e-5);
    }
}
```

--------------------------------

### Encode JSON Objects with ObjectEncoder

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Encodes a JSON object into a hypervector using ObjectEncoder. Caches results for identical objects and allows retrieval from the codebook. Demonstrates similarity between different objects.

```rust
use hypervector::{set_global_seed, Hypervector, TieBreaker};
use hypervector::mbat::MBAT;
use hypervector::encoder::ObjectEncoder;
use serde_json::json;

fn main() {
    set_global_seed(42);

    // Create encoder with dimension 1000 and AlwaysPositive tie-breaking
    let mut encoder = ObjectEncoder::<MBAT>::new(1000, TieBreaker::AlwaysPositive);

    // Define a JSON object to encode
    let person = json!({
        "firstName": "Alice",
        "lastName": "Smith",
        "age": 30,
        "isActive": true,
        "hobbies": ["reading", "cycling", "hiking"]
    });

    // Encode the JSON object into a hypervector
    let encoded = encoder.encode_object(&person);
    assert_eq!(encoded.to_vec().len(), 1000);

    // Re-encoding the same object returns the cached result
    let encoded_again = encoder.encode_object(&person);
    assert_eq!(encoded, encoded_again);

    // Retrieve previously encoded object from codebook
    let retrieved = encoder.get_encoded_object(&person)
        .expect("Object should be in codebook");
    assert_eq!(&encoded, retrieved);

    // Different objects produce different encodings
    let another_person = json!({
        "firstName": "Bob",
        "lastName": "Jones",
        "age": 25,
        "isActive": false,
        "hobbies": ["gaming"]
    });
    let another_encoded = encoder.encode_object(&another_person);

    // Different objects have low similarity
    let similarity = encoded.cosine_similarity(&another_encoded);
    println!("Similarity between different objects: {:.3}", similarity);
}
```

--------------------------------

### Set Global RNG Seed

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Sets the seed for the global random number generator to ensure reproducible hypervector generation and operations. This is crucial for testing and debugging.

```rust
use hypervector::set_global_seed;

fn main() {
    // Set the global RNG seed for reproducible hypervector generation
    set_global_seed(42);

    // All subsequent hypervector operations will be deterministic
    // This is essential for testing and debugging
}
```

--------------------------------

### Compute Hamming Distance

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Measure the normalized Hamming distance between two hypervectors, representing the fraction of positions where they differ. For MBAT, this is the fraction of positions with different signs. The Hamming distance with self is 0.

```rust
use hypervector::{set_global_seed, Hypervector};
use hypervector::mbat::MBAT;

fn main() {
    set_global_seed(42);

    let a = Hypervector::<MBAT>::generate(10000);
    let b = Hypervector::<MBAT>::generate(10000);

    // Hamming distance with self is 0
    let self_dist = a.hamming_distance(&a);
    assert!(self_dist.abs() < 1e-6);

    // Random vectors have ~0.5 Hamming distance (half differ)
    let cross_dist = a.hamming_distance(&b);
    println!("Hamming distance: {:.3}", cross_dist); // ~0.5
    assert!((cross_dist - 0.5).abs() < 0.1);
}
```

--------------------------------

### Compute Cosine Similarity

Source: https://context7.com/rishikanthc/hypervector/llms.txt

Calculate the cosine similarity between two hypervectors. Random vectors are nearly orthogonal (similarity ~0), while identical vectors have a similarity of 1.0. Self-similarity is always 1.0.

```rust
use hypervector::{set_global_seed, Hypervector};
use hypervector::mbat::MBAT;

fn main() {
    set_global_seed(42);

    let a = Hypervector::<MBAT>::generate(10000);
    let b = Hypervector::<MBAT>::generate(10000);

    // Self-similarity is always 1.0
    let self_sim = a.cosine_similarity(&a);
    assert!((self_sim - 1.0).abs() < 1e-6);

    // Random high-dimensional vectors are nearly orthogonal
    let cross_sim = a.cosine_similarity(&b);
    println!("Cross similarity: {:.4}", cross_sim); // ~0.0 (close to 0)
    assert!(cross_sim.abs() < 0.1);
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.