Struct NOf 

pub struct NOf {
    pub n: u64,
    pub m: u64,
    /* private fields */
}

N-of-M deterministic fractional selection.

Signature: n_of(input: u64, n: u64, m: u64) -> u64

Returns 1 for exactly n out of every m consecutive inputs, 0 otherwise. Which specific inputs are selected within each window is determined by hashing, so the pattern is not simply “first n”.

This differs from unfair_coin(input, n/m): unfair_coin is probabilistic (each input independently has probability n/m), while n_of guarantees exact counts over each window of m inputs.

Use for precise fraction control: exactly 3 out of every 10 cycles are “special”, exactly 1 out of every 100 is an error, etc.

is_special := n_of(cycle, 3, 10)

Both n and m are init-time constant parameters, and both of their rules are checked when the node is built: 1 <= m <= 65536 by the per-parameter range constraint, and n <= m by the node-level validator, which is where a relation between two parameters belongs. Neither rule depends on the body running, so both hold on every engine.

The window is at most 65 536 positions because each call ranks its position against every other one in the window, m hashes per cycle. At the bound that is about a tenth of a millisecond a cycle; unbounded, a large m was a hang, one call taking longer than any run. The bound keeps every output of an m that was usable as it was.

JIT level: P3 (JitOp::NOfConst).

Fields

n: u64

The n argument, as given at construction.

m: u64

The m argument, as given at construction.

Implementations

impl NOf

pub fn new(n: u64, m: u64) -> Self

A n_of node with the given constant arguments.

Trait Implementations

impl PolydatNode for NOf

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.