Struct BoxEmbedding 

pub struct BoxEmbedding {
    pub min: Vec<f32>,
    pub max: Vec<f32>,
}

A box embedding representing an entity in d-dimensional space.

Boxes are axis-aligned hyperrectangles defined by min/max bounds in each dimension. Coreference is modeled as high mutual conditional probability (overlap).

Fields

min: Vec<f32>

Lower bound in each dimension (d-dimensional vector).

max: Vec<f32>

Upper bound in each dimension (d-dimensional vector).

Implementations

impl BoxEmbedding

pub fn new(min: Vec<f32>, max: Vec<f32>) -> Self

Create a new box embedding.

Panics

Panics if min.len() != max.len() or if any min[i] > max[i].

pub fn dim(&self) -> usize

Get the dimension of the box.

pub fn volume(&self) -> f32

Compute the volume of the box.

Volume = product of (max - min) for each dimension.

pub fn intersection_volume(&self, other: &Self) -> f32

Compute the intersection volume with another box.

Returns 0.0 if boxes are disjoint.

pub fn conditional_probability(&self, other: &Self) -> f32

Compute conditional probability P(self | other).

This is the BERE model’s coreference metric: P(A|B) = Vol(A ∩ B) / Vol(B)

Returns a value in [0.0, 1.0] where:

• 1.0 = self is completely contained in other
• 0.0 = boxes are disjoint

pub fn coreference_score(&self, other: &Self) -> f32

Compute mutual coreference score.

Coreference requires high mutual conditional probability: score = (P(A|B) + P(B|A)) / 2

This ensures both boxes largely contain each other (high overlap).

pub fn is_contained_in(&self, other: &Self) -> bool

Check if this box is contained in another box.

Returns true if self ⊆ other (all dimensions).

pub fn is_disjoint(&self, other: &Self) -> bool

Check if boxes are disjoint (no overlap).

pub fn from_vector(vector: &[f32], radius: f32) -> Self

Create a box embedding from a vector embedding.

Converts a point embedding to a box by creating a small hypercube around the point. The box size is controlled by radius.

Arguments

• vector - Vector embedding (point in space)
• radius - Half-width of the box in each dimension

Example

let vector = vec![0.5, 0.5, 0.5];
let box_embedding = BoxEmbedding::from_vector(&vector, 0.1);
// Creates box: min=[0.4, 0.4, 0.4], max=[0.6, 0.6, 0.6]

pub fn from_vector_adaptive(vector: &[f32], radius_factor: f32) -> Self

Create a box embedding from a vector with adaptive radius.

Uses a radius proportional to the vector’s magnitude, creating larger boxes for vectors further from the origin.

Arguments

• vector - Vector embedding
• radius_factor - Multiplier for adaptive radius (default: 0.1)

pub fn center(&self) -> Vec<f32>

Get the center point of the box.

Returns the midpoint in each dimension.

pub fn size(&self) -> Vec<f32>

Get the size (width) in each dimension.

pub fn intersection(&self, other: &Self) -> Self

Compute the intersection box with another box.

Returns a new box representing the overlapping region. If boxes are disjoint, returns a zero-volume box.

pub fn union(&self, other: &Self) -> Self

Compute the union box (bounding box containing both).

pub fn overlap_prob(&self, other: &Self) -> f32

Compute overlap probability (Jaccard-style).

P(overlap) = Vol(intersection) / Vol(union)

pub fn distance(&self, other: &Self) -> f32

Compute minimum Euclidean distance between two boxes.

Returns 0.0 if boxes overlap.

Trait Implementations

impl Clone for BoxEmbedding

fn clone(&self) -> BoxEmbedding

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BoxEmbedding

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BoxEmbedding

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BoxEmbedding

fn eq(&self, other: &BoxEmbedding) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BoxEmbedding

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for BoxEmbedding