Struct ComplEx 

pub struct ComplEx { /* private fields */ }

ComplEx: complex bilinear model.

Entities and relations are complex vectors. Score is the real part of the Hermitian dot product: Re(sum_i h_i * r_i * conj(t_i))).

Higher scores = more likely, so the Scorer implementation returns the negated score (lower = more likely) for compatibility with distance-based evaluation.

Initialization: Xavier uniform Uniform(-sqrt(6/dim), sqrt(6/dim)).

Reference: Trouillon et al. (2016), “Complex Embeddings for Simple Link Prediction.”

Implementations

impl ComplEx

pub fn new(num_entities: usize, num_relations: usize, dim: usize) -> Self

Create a new ComplEx model with random initialization.

dim is the complex dimension (each embedding stores 2 * dim floats). Xavier uniform initialization: Uniform(-sqrt(6/dim), sqrt(6/dim)).

pub fn from_vecs( entities: Vec<Vec<f32>>, relations: Vec<Vec<f32>>, dim: usize, ) -> Self

Create from pre-built embedding vectors.

Both entities and relations must have inner length dim * 2.

Panics

Panics if any dimension is wrong.

pub fn entities_flat(&self) -> &[f32]

Flat entity embeddings (row-major, stride = dim() * 2).

pub fn relations_flat(&self) -> &[f32]

Flat relation embeddings (row-major, stride = dim() * 2).

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

Reconstruct entity embeddings as Vec<Vec<f32>>.

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

Reconstruct relation embeddings as Vec<Vec<f32>>.

pub fn dim(&self) -> usize

Complex dimension.

pub fn score_triple(&self, head: usize, relation: usize, tail: usize) -> f32

Raw score: Re(sum_i h_i * r_i * conj(t_i)).

Higher = more likely. Use Scorer::score for the negated distance-compatible version.

Entity/relation layout: first dim floats are real, next dim are imaginary.

Trait Implementations

impl Scorer for ComplEx

fn score(&self, head: usize, relation: usize, tail: usize) -> f32

Returns -score_triple() so that lower = more likely.

fn num_entities(&self) -> usize

Number of entities in the model.

fn score_all_tails(&self, head: usize, relation: usize) -> Vec<f32>

Score all entities as tail replacements for (head, relation, ?).

fn score_all_heads(&self, relation: usize, tail: usize) -> Vec<f32>

Score all entities as head replacements for (?, relation, tail).

fn top_k_tails( &self, head: usize, relation: usize, k: usize, ) -> Vec<(usize, f32)>

Return the top-k entities by score for (head, relation, ?).

fn top_k_heads( &self, relation: usize, tail: usize, k: usize, ) -> Vec<(usize, f32)>

Return the top-k entities by score for (?, relation, tail).

fn score_all_relations( &self, head: usize, tail: usize, num_relations: usize, ) -> Vec<f32>

Score all relations for (head, ?, tail).

fn top_k_relations( &self, head: usize, tail: usize, num_relations: usize, k: usize, ) -> Vec<(usize, f32)>

Return the top-k relations by score for (head, ?, tail).