Struct Pcg 

pub struct Pcg {
    pub seed: u64,
    pub stream: u64,
    /* private fields */
}

PCG-RXS-M-XS 64/64 random number generator with fixed seed and stream.

Signature: pcg(input: u64, seed: u64, stream: u64) -> u64

The seed and stream are init-time constants baked into the node. The input wire selects which element of the sequence to return. Seeking is O(log N) so any position can be accessed directly.

Use this when every thread/cycle needs an independent, deterministic random value from the same generator. The output is a full 64-bit pseudo-random value suitable for feeding into range reduction, unit-interval mapping, or distribution sampling.

JIT level: P2 (auto-emitted compiled_u64 closure with captured seed and stream; the body recomputes inc = 2*stream + 1 per call — a single mul+add, negligible vs the seek work). jit_constants: [seed, stream] in declaration order.

Fields

seed: u64

The seed argument, as given at construction.

stream: u64

The stream argument, as given at construction.

Implementations

impl Pcg

pub fn new(seed: u64, stream: u64) -> Self

A pcg node with the given constant arguments.

Trait Implementations

impl PolydatNode for Pcg

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

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 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.