Struct Discretize 

pub struct Discretize {
    pub range: f64,
    pub buckets: u64,
    /* private fields */
}

Discretize: bin a continuous f64 into N equal-width buckets.

Maps [0, range) to bucket indices [0, buckets). Values outside the range are clamped.

Signature: discretize(input: f64, range: f64, buckets: u64) -> (u64)

Use after a continuous distribution or interpolation to collapse values into categorical bins. Example: feed a normal distribution through discretize(100.0, 10) to get 10 histogram bins across [0, 100). Out-of-range inputs are clamped to the first or last bucket.

JIT level: P3 (compiled_u64 with jit_constants for range and buckets).

The range is positive and finite and there is at least one bucket, declared so the build refuses anything else on every engine, and the native form’s buckets - 1 never underflows. The body clamps to the range itself rather than to range - f64::EPSILON, an absolute epsilon that would make any range below it a “min > max” panic; the final min already sends an input at or past the range to the last bucket, so the bucket is the same everywhere.

Fields

range: f64

The range argument, as given at construction.

buckets: u64

The buckets argument, as given at construction.

Implementations

impl Discretize

pub fn new(range: f64, buckets: u64) -> Self

A discretize node with the given constant arguments.

Trait Implementations

impl PolydatNode for Discretize

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_u64(&self) -> Option<CompiledU64Op>

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 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 none_semantics.md Rule 1 (None in → None out, no eval invocation).

fn compiled_slot( &self, _wire_types: &[PortType], _engine: Engine, ) -> 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 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 (cone extraction, engines.md §2). 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.