Struct RateEncoder 

pub struct RateEncoder { /* private fields */ }

Encodes analog values as spike rates based on input intensity.

Each input channel is mapped to a firing rate between base_rate and max_rate. In batch mode (encode), each call generates independent probabilistic spikes. In streaming mode (encode_step), accumulates expected spikes and fires deterministically when the accumulated value exceeds a threshold per channel.

Mathematical Model

For batch encoding:

rate_hz = base_rate + normalized * (max_rate - base_rate)
probability = 1 - exp(-rate_hz * dt_seconds)
spike if random() < probability

For streaming (encode_step):

rate_hz = base_rate + normalized[i] * (max_rate - base_rate)
accumulator[i] += rate_hz * dt_seconds
spike if accumulator[i] >= 1.0 (then accumulator -= 1.0)

When to Use

• Converting continuous sensor values to spike rates
• Poisson-like spike generation with controllable average rates
• Real-time encoding where spike timing follows input intensity

Parameters

• base_rate: Minimum firing rate in hertz (Hz) when input is at range minimum
• max_rate: Maximum firing rate in hertz (Hz) when input is at range maximum
• range: Tuple of (min, max) input values
• dt_seconds: Duration, in seconds, represented by each encode step

Migration

RateEncoder::new keeps the previous constructor shape and uses dt_seconds = 0.1, which preserves the old deterministic / 10.0 increment for unit rates. Prefer RateEncoder::try_new for new code that wants explicit time-step configuration and validation.

Examples

use axon_encoder::prelude::*;
let mut enc = RateEncoder::try_new(5.0, 100.0, (0.0, 1.0), 0.010)?;
let out = enc.encode(&[0.0, 0.5, 1.0]);
// Stochastic batch mode: at most one spike per channel.
assert!(out.spikes.len() <= 3);

Implementations

impl RateEncoder

pub const DEFAULT_DT_SECONDS: f32 = 0.1

Compatibility time step used by RateEncoder::new.

A 100 ms step makes rate_hz * dt_seconds equal to the previous deterministic / 10.0 increment for the same rate value.

pub fn new(base_rate: f32, max_rate: f32, range: (f32, f32)) -> Self

Creates a rate encoder with the compatibility dt_seconds = 0.1.

Prefer RateEncoder::try_new when selecting an explicit sampling interval for new code.

Panics

Panics if rates or range are invalid (dt_seconds is always the valid default 0.1, so callers cannot panic via the time step).

pub fn try_new( base_rate: f32, max_rate: f32, range: (f32, f32), dt_seconds: f32, ) -> Result<Self, EncoderError>

Creates a rate encoder with an explicit time step in seconds.

Rates must be finite and non-negative with base_rate <= max_rate. dt_seconds must be finite and strictly positive. Range must be a non-degenerate finite f32 span (bounds finite, ordered, and max - min finite in f32).

pub fn dt_seconds(&self) -> f32

Returns the configured time step in seconds.

pub fn default_dt_seconds() -> f32

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.

Uses the internal accumulator-based rate scale path for streaming.

Trait Implementations

impl Clone for RateEncoder

fn clone(&self) -> RateEncoder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RateEncoder

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

Formats the value using the given formatter.

impl Encoder for RateEncoder

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 RateEncoder

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 RateEncoder

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RateEncoder