Struct Signal 

#[repr(C)]
pub struct Signal {
    pub polarity: i8,
    pub magnitude: u8,
    pub multiplier: u8,
}

Signal: polarity × magnitude × multiplier (s = p × m × k)

The fundamental unit of neural communication. Compact 3-byte #[repr(C)] representation:

• polarity: -1 (inhibited), 0 (neutral), +1 (excited)
• magnitude: 0–255 (base intensity — intrinsic neuron drive)
• multiplier: 0–255 (contextual scaling — metabolic state, arousal, burst energy)

Effective magnitude = magnitude × multiplier (range 0–65,025).

Fields

polarity: i8

Polarity: -1 (inhibited), 0 (neutral), +1 (excited)

magnitude: u8

Magnitude: 0–255 (base intensity — intrinsic neuron drive)

multiplier: u8

Multiplier: 0–255 (contextual scaling — metabolic state, arousal, burst energy)

Default: 1 (neutral — effective magnitude equals base magnitude). 0 = silenced (effective magnitude is zero regardless of base magnitude).

Implementations

impl Signal

pub const ZERO: Signal

Zero signal (no activity)

pub const MAX_POSITIVE: Signal

Maximum positive signal

pub const MAX_NEGATIVE: Signal

Maximum negative signal

pub const BASELINE_MULTIPLIER: u8 = 1

Baseline multiplier constant — use when k=1 is intentional.

pub const fn effective_magnitude(&self) -> u16

Compute effective magnitude: magnitude × multiplier (0–65,025)

pub const fn current(&self) -> i32

Compute signed effective current: polarity × magnitude × multiplier

pub const fn zero() -> Signal

Create a zero / neutral signal

pub const fn positive(magnitude: u8) -> Signal

👎Deprecated:

use Signal::positive_amplified(mag, mul) — s = p × m × k requires all three values

Create a positive (excitatory) signal with multiplier = 1

pub const fn negative(magnitude: u8) -> Signal

👎Deprecated:

use Signal::negative_amplified(mag, mul) — s = p × m × k requires all three values

Create a negative (inhibitory) signal with multiplier = 1

pub const fn positive_amplified(magnitude: u8, multiplier: u8) -> Signal

Create a positive signal with explicit multiplier

pub const fn negative_amplified(magnitude: u8, multiplier: u8) -> Signal

Create a negative signal with explicit multiplier

pub const fn with_polarity(polarity: Polarity, magnitude: u8) -> Signal

👎Deprecated:

use Signal::with_polarity_amplified(pol, mag, mul) — s = p × m × k requires all three values

Create from Polarity enum and magnitude (type-safe, multiplier = 1)

pub const fn with_polarity_amplified( polarity: Polarity, magnitude: u8, multiplier: u8, ) -> Signal

Create from Polarity enum, magnitude, and multiplier (type-safe)

pub const fn new(polarity: i8, magnitude: u8) -> Signal

👎Deprecated:

use Signal::new_raw(pol, mag, mul) — s = p × m × k requires all three values

Create from raw i8 polarity and magnitude (unchecked, multiplier = 1)

pub const fn new_raw(polarity: i8, magnitude: u8, multiplier: u8) -> Signal

Create from raw components (unchecked)

pub const fn new_checked(polarity: i8, magnitude: u8) -> Option<Signal>

👎Deprecated:

use Signal::new_checked_full(pol, mag, mul) — s = p × m × k requires all three values

Create from raw i8 polarity with validation (multiplier = 1)

pub const fn new_checked_full( polarity: i8, magnitude: u8, multiplier: u8, ) -> Option<Signal>

Create from raw i8 polarity, magnitude, and multiplier with validation

pub fn from_floats(polarity_f: f32, magnitude_f: f32) -> Signal

👎Deprecated:

defaults multiplier to 1 — construct with explicit multiplier instead

Create from separate float components (multiplier = 1)

polarity_f: quantised to {-1, 0, +1} (dead-zone ±0.1) magnitude_f: clamped to 0.0–1.0, scaled to 0–255

pub fn from_signed(value: f32) -> Signal

👎Deprecated:

defaults multiplier to 1 — construct with explicit multiplier instead

Create from a single signed float (-1.0 to 1.0), multiplier = 1

Sign → polarity, absolute value → magnitude.

pub fn from_signed_i32(value: i32) -> Signal

👎Deprecated:

defaults multiplier to 1 — use Signal::from_current(val) for full p × m × k range

Create from a signed i32 (multiplier = 1, clamps magnitude to 255).

Warning: This discards values above ±255. For the full ±65,025 range, use [from_current] instead.

pub fn from_current(value: i32) -> Signal

Create from a signed i32 using the full p × m × k range (±65,025).

Decomposes the absolute value into magnitude × multiplier where both are 0–255. Values above 65,025 are clamped. Values ≤ 255 get multiplier=1. Values > 255 use magnitude=255 and multiplier=ceil(abs/255).

pub fn from_i16(value: i16) -> Signal

👎Deprecated:

defaults multiplier to 1 — use Signal::from_signed_i32(val) for large ranges or construct with explicit multiplier

Create from a signed i16 (multiplier = 1)

pub fn from_u8_bipolar(level: u8) -> Signal

👎Deprecated:

defaults multiplier to 1 — construct Signal with explicit multiplier instead

Create from u8 bipolar representation (128 = baseline)

pub fn from_spike_rate(rate_hz: f32, max_rate_hz: f32) -> Signal

👎Deprecated:

defaults multiplier to 1 — construct Signal with explicit multiplier instead

Create from spike rate (Hz)

pub fn from_spike_count(count: u32, window_ms: f32, max_rate_hz: f32) -> Signal

👎Deprecated:

defaults multiplier to 1 — construct Signal with explicit multiplier instead

Create from spike count in a time window

pub fn as_signed_i32(&self) -> i32

Get as signed i32 using effective magnitude (polarity × magnitude × multiplier)

pub fn magnitude_f32(&self) -> f32

Get base magnitude as float (0.0–1.0)

pub fn effective_magnitude_f32(&self) -> f32

Get effective magnitude as float (0.0–1.0, normalized to max 65025)

pub fn as_signed_f32(&self) -> f32

Get as signed float using effective magnitude (-1.0 to 1.0)

pub fn to_u8_bipolar(&self) -> u8

Convert to u8 bipolar (128 = baseline), using base magnitude only

pub fn to_spike_rate(&self, max_rate_hz: f32) -> f32

Convert to spike rate (Hz), using base magnitude

pub fn get_polarity(&self) -> Polarity

Get polarity as Polarity enum (type-safe)

pub fn is_active(&self) -> bool

Is this signal active (non-zero)?

pub fn is_positive(&self) -> bool

Is this a positive / excitatory signal?

pub fn is_negative(&self) -> bool

Is this a negative / inhibitory signal?

pub const fn with_multiplier(self, multiplier: u8) -> Signal

Set the multiplier (contextual scaling)

pub const fn amplify(self, delta: u8) -> Signal

Amplify: increase multiplier by delta (saturating)

pub const fn attenuate(self, delta: u8) -> Signal

Attenuate: decrease multiplier by delta (saturating)

pub fn add(&self, other: &Signal) -> Signal

Add two signals (same polarity adds, opposite cancels). Operates on base magnitude. Result gets multiplier = 1.

pub fn scale(&self, factor: f32) -> Signal

Scale base magnitude by a factor (multiplier unchanged)

pub fn decay(&mut self, retention: f32)

Apply decay to base magnitude (in-place, for temporal fields)

pub fn decayed(&self, retention: f32) -> Signal

Return a decayed copy

pub fn step_toward(&self, target: &Signal) -> Signal

Step toward target by one unit (base magnitude)

pub fn step_toward_by(&self, target: &Signal, delta: u8) -> Signal

Step toward target by specified delta (base magnitude)

pub fn step_toward_ratio(&self, target: &Signal, ratio: f32) -> Signal

Step toward target by fractional amount (0.0–1.0)

pub fn reached(&self, target: &Signal, tolerance: u8) -> bool

Check if this signal has reached the target (within tolerance, base magnitude)

Trait Implementations

impl Clone for Signal

fn clone(&self) -> Signal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Signal

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

Formats the value using the given formatter.

impl Default for Signal

fn default() -> Signal

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Signal

fn deserialize<__D>( __deserializer: __D, ) -> Result<Signal, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Signal

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

Formats the value using the given formatter.

impl From<PackedSignal> for Signal

fn from(p: PackedSignal) -> Signal

Converts to this type from the input type.

impl Hash for Signal

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Signal

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Signal

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Signal

impl Eq for Signal

impl StructuralPartialEq for Signal