Struct PredictiveEncoder 

pub struct PredictiveEncoder { /* private fields */ }

Encodes based on causal predictive error from expected values.

This encoder is best understood as an adaptive EWMA anomaly detector with predictive-coding-style signed error spikes. It keeps per-channel history, predicts the next sample from prior samples only, and fires a spike when the signed prediction error is large enough. Positive errors emit polarity: true; negative errors emit polarity: false.

Mathematical Model

Tracks an exponentially weighted moving average of recent history means per channel. The first five samples are a warm-up period: they update history and initialize the prediction baseline but never emit spikes. After warm-up, each input is evaluated against the predictor state formed before that input is inserted, so the current observation cannot leak into its own prediction.

if history.len() < 5:
    push value; initialize prediction when five samples are available; no spike
else:
    prediction = threshold[i]
    error = value - prediction
    spike if |error| > threshold, with polarity = error >= 0
    push value
    threshold[i] = 0.9 * threshold[i] + 0.1 * mean(history[-5:])

When to Use

• Anomaly detection in sensor streams
• Learning patterns and detecting deviations
• Adaptive encoding that adjusts to baseline activity

Parameters

• history_depth: Number of past values to track per channel
• deviation_thresholds: Vec of (threshold, spike_value) pairs
• num_channels: Number of input channels

Examples

use axon_encoder::prelude::*;
let mut enc = PredictiveEncoder::try_new(8, vec![(0.5, 1)], 1)?;
// First five samples warm up without spikes.
for v in [1.0, 1.0, 1.0, 1.0, 1.0] {
    assert!(enc.encode_step(&[v]).spikes.is_empty());
}
// A large jump after warm-up can emit a prediction-error spike.
let _ = enc.encode_step(&[3.0]);

Implementations

impl PredictiveEncoder

pub fn new( history_depth: usize, deviation_thresholds: Vec<(f32, u16)>, num_channels: usize, ) -> Result<Self, PredictiveEncoderError>

Creates a new PredictiveEncoder.

Retains the historical PredictiveEncoderError surface for source compatibility. Prefer try_new for the unified EncoderError type used by other fallible constructors.

Errors

• PredictiveEncoderError::HistoryDepthTooSmall if history_depth < 5
• PredictiveEncoderError::NumChannelsTooLarge if num_channels > u16::MAX as usize + 1 (spike channel IDs are u16, so indices must stay in 0..=u16::MAX)
• PredictiveEncoderError::InvalidDeviationThreshold if any threshold is non-finite or negative

pub fn try_new( history_depth: usize, deviation_thresholds: Vec<(f32, u16)>, num_channels: usize, ) -> Result<Self, EncoderError>

Creates a new PredictiveEncoder, returning the unified EncoderError.

Prefer this over new when propagating constructor failures alongside other encoders via EncoderError. Each deviation_threshold must be finite and non-negative (same rule as TemporalEncoder::try_new).

pub fn encode_with_modulators( &mut self, input: &[f32], modulators: &NeuroModulators, gain_curves: &NeuromodulatorGainCurves, ) -> EncodedOutput

Encodes input using neuromodulator-driven gain curves.

Inherent wrapper so callers need not import ModulatedEncoder.

pub fn encode_step_with_modulators( &mut self, input: &[f32], modulators: &NeuroModulators, gain_curves: &NeuromodulatorGainCurves, ) -> EncodedOutput

Step-wise variant of encode_with_modulators.

Trait Implementations

impl Clone for PredictiveEncoder

fn clone(&self) -> PredictiveEncoder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PredictiveEncoder

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

Formats the value using the given formatter.

impl Encoder for PredictiveEncoder

fn encode(&mut self, input: &[f32]) -> EncodedOutput

Encodes a slice of analog values into spike events (batch mode).

fn encode_step(&mut self, input: &[f32]) -> EncodedOutput

Encodes a single step incrementally (streaming mode).

fn reset(&mut self)

Resets the encoder to its initial state

impl ModulatedEncoder for PredictiveEncoder

fn encode_with_gains( &mut self, input: &[f32], gains: EncodingGains, ) -> EncodedOutput

Encodes input using already evaluated encoding gains.

fn encode_step_with_gains( &mut self, input: &[f32], gains: EncodingGains, ) -> EncodedOutput

Encodes one streaming step using already evaluated encoding gains.

fn encode_with_modulators( &mut self, input: &[f32], modulators: &NeuroModulators, gain_curves: &NeuromodulatorGainCurves, ) -> EncodedOutput

Encodes input using neuromodulator-driven gain curves.

fn encode_step_with_modulators( &mut self, input: &[f32], modulators: &NeuroModulators, gain_curves: &NeuromodulatorGainCurves, ) -> EncodedOutput

Encodes one streaming step using neuromodulator-driven gain curves.

impl PartialEq for PredictiveEncoder

fn eq(&self, other: &PredictiveEncoder) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for PredictiveEncoder