Struct LidMle 

pub struct LidMle { /* private fields */ }

lid_mle(distances, k) — Levina–Bickel maximum-likelihood estimate of the local intrinsic dimensionality at one query point, from its sorted ground-truth nearest-neighbor distances.

Given ascending distances r_1 ≤ … ≤ r_k to the k nearest neighbors,

    d̂ = m / Σ_{j=1..m} ln(r_k / r_j)        (m = number of valid terms)

the standard MLE (Levina & Bickel, NIPS 2004) with r_k as the cutoff radius. k is clamped to the available length. Terms with a non-positive r_j (exact duplicates / self-matches at distance 0, where ln(r_k/r_j) is undefined) are skipped — the conventional handling. Returns 0.0 for a degenerate query (fewer than one valid term, or a non-positive log-sum, e.g. all-duplicate neighbors) so the caller can filter it out of the aggregate.

Reporting the distribution of this per-query estimate (mean / p50 / p90) characterizes both the intrinsic dimension and its heterogeneity — the quantity that governs whether a 1-D locality ordering can work (a low, tight LID favors it; a high or skewed LID does not).

ASSUMES distances are true metric distances in ascending order (the dataset’s neighbor_distances / filtered_neighbor_distances facet). If that facet stores squared distances the estimate is scaled by ½ (double it); if it stores similarities (higher = closer) the result is meaningless — validate against the dataset’s metric first.

Implementations

impl LidMle

pub fn new() -> Self

A lid_mle node with the given constant arguments.

Trait Implementations

impl Default for LidMle

fn default() -> Self

Returns the “default value” for a type.

impl PolydatNode for LidMle

fn meta(&self) -> &NodeMeta

Return this node’s metadata (port names and types).

fn eval(&self, inputs: &[Value], outputs: &mut [Value])

Evaluate the node: read from inputs, write to outputs.

fn compiled_slot(&self, wire_types: &[PortType]) -> Option<CompiledSlotKit>

Return a slot-compiled closure for nodes with typed-slice ports (§8.4 layer 3): slice inputs read (ptr, len) slot pairs; vector outputs write into kernel-owned scratch. Checked by the compiled-kernel builders AFTER Self::compiled_u64 — pure-scalar nodes never need it. Default None: the node stays on typed eval.

fn scratch_layout(&self) -> Vec<ScratchElem>

The scratch entries a state owns for this node’s evaluation (axiom S3), one per entry in the order the node expects them in Self::eval_in. Empty for a node that evaluates over Values alone, which is every node but a native cone.

fn eval_in( &self, scratch: &mut [ScratchBuf], inputs: &[Value], outputs: &mut [Value], )

Self::eval with the node’s scratch, which the evaluating state owns and hands in: storage belongs to the state, never to the node, which is shared by every state of the program.

fn commutativity(&self) -> Commutativity

Declare which inputs are interchangeable for this node.

fn accepts_none_inputs(&self) -> bool

True iff this node should receive Value::None inputs directly rather than have the kernel propagate None through it. Default: false — most nodes follow SRD-74 Rule 1 (None in → None out, no eval invocation).

fn compiled_u64(&self) -> Option<Box<dyn Fn(&[u64], &mut [u64]) + Send + Sync>>

Return a compiled u64-only evaluation closure, if this node operates entirely in u64 space.

fn jit_constants(&self) -> Vec<u64>

Return assembly-time constants for JIT compilation.

fn purity(&self) -> Purity

Declare this node’s purity status per the runtime_model.md’s D2 axiom. Default: Purity::Pure. Override to declare an observable side channel (Purity::SideChannel) or eval-call-spanning state (Purity::Nondeterministic).

fn simd_variant(&self) -> Option<SimdVariant>

Explicit SIMD-native implementation of this scalar node, if one has been registered with a semantic contract.

fn fusion_subgraph(&self) -> Option<FusionSubgraph<'_>>

A synthetic fusion node’s view of the subgraph it stands in for (SRD-105 cone extraction). Program-identity hashing (PolydatProgram::canonical_hash) walks THROUGH fusion nodes into this subgraph, so identity is invariant to the engine mix: jit=off and jit=auto compiles of the same source hash identically, and resume-skip matching survives mode changes. Default None: ordinary nodes hash as themselves.