Struct ScoringWeights 

pub struct ScoringWeights {
    pub vector: f32,
    pub warmth: f32,
    pub recency: f32,
    pub abstraction: f32,
    pub graph: f32,
    pub keyword: f32,
    pub causal: f32,
}

Weights for deterministic scoring formula.

Seven orthogonal factors, each weight ∈ [0, 1], summing to 1.0 (±ε).

score = w_v·S_vector + w_w·S_warmth + w_r·S_recency
      + w_a·S_abstraction + w_g·S_graph + w_k·S_keyword
      + w_c·S_causal

The causal factor scores entities by their proximity to recent events in the Event DAG. When no Event DAG data is available, adaptive weight renormalization zeros causal and redistributes its budget to the remaining factors.

Fields

vector: f32

Cosine similarity between query embedding and entity embedding

warmth: f32

Access frequency with temporal decay

recency: f32

Creation time decay (newer = higher)

abstraction: f32

Abstraction level (Principle > Summary > Raw)

graph: f32

Graph proximity via edge traversal (degrees of separation)

keyword: f32

Keyword/substring match score

causal: f32

Event DAG causal proximity (how recently events reference this entity)

Implementations

impl ScoringWeights

pub fn validate(&self) -> bool

Validate that all weights sum to 1.0 within epsilon tolerance.

The tolerance matches the PostgreSQL weights_sum_to_one CHECK constraint: ABS(sum - 1.0) < 0.001.

pub fn normalize(&mut self)

Normalize weights so they sum to exactly 1.0, preserving ratios.

Mathematical Properties

• Idempotent: normalize(normalize(w)) = normalize(w)
• Ratio-preserving: wᵢ/wⱼ is invariant under normalization
• No-op on zero: if all weights are 0, remains all zeros

pub fn legacy_six_factor() -> Self

Legacy 6-factor weights for backward compatibility.

Returns weights with causal = 0.0 and the original 6-factor defaults. Useful when Event DAG is not available.

fn sum(&self) -> f32

Sum of all weights.

pub fn score(&self, factors: &ScoringFactors) -> f32

Compute the weighted score given per-factor raw scores.

Each raw score should be in [0, 1]. The result is in [0, 1] when weights are valid (sum to 1.0).

Non-finite factor values (NaN, ±Inf) are clamped to [0, 1] to prevent silent propagation through downstream scoring.

Trait Implementations

impl Clone for ScoringWeights

fn clone(&self) -> ScoringWeights

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for ScoringWeights

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for ScoringWeights

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

Formats the value using the given formatter.

impl Default for ScoringWeights

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ScoringWeights

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ScoringWeights

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for ScoringWeights

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference [utoipa::openapi::schema::Schema]s for this type.