Struct ParameterRange 

pub struct ParameterRange {
    pub kind: ParameterKind,
    pub min: f64,
    pub max: f64,
    pub step: Option<f64>,
    pub default: f64,
}

A continuous or discrete range for a single tunable parameter.

When step is Some, the parameter is treated as discrete: values are quantized to the nearest grid point anchored at min. When step is None the parameter is treated as continuous and generators fall back to an internal default step count (typically 20 divisions).

Examples

use zeph_experiments::{ParameterRange, ParameterKind};

let range = ParameterRange {
    kind: ParameterKind::Temperature,
    min: 0.0,
    max: 1.0,
    step: Some(0.1),
    default: 0.7,
};

assert!(range.is_valid());
assert_eq!(range.step_count(), Some(11));
assert!((range.clamp(2.0) - 1.0).abs() < f64::EPSILON);
assert!((range.quantize(0.73) - 0.7).abs() < 1e-10);

Fields

kind: ParameterKind

The parameter this range applies to.

min: f64

Minimum value (inclusive).

max: f64

Maximum value (inclusive).

step: Option<f64>

Discrete step size. None means continuous (generators use a default step count).

default: f64

Default (baseline) value, typically read from the current agent config.

Implementations

impl ParameterRange

pub fn step_count(&self) -> Option<usize>

Number of discrete grid points in this range, or None if step is not set or ≤ 0.

The count is floor((max - min) / step) + 1.

Examples

use zeph_experiments::{ParameterRange, ParameterKind};

let r = ParameterRange { kind: ParameterKind::Temperature, min: 0.0, max: 1.0, step: Some(0.5), default: 0.5 };
assert_eq!(r.step_count(), Some(3)); // 0.0, 0.5, 1.0

let r_continuous = ParameterRange { step: None, ..r };
assert_eq!(r_continuous.step_count(), None);

pub fn clamp(&self, value: f64) -> f64

Clamp value to [min, max].

Examples

use zeph_experiments::{ParameterRange, ParameterKind};

let r = ParameterRange { kind: ParameterKind::TopP, min: 0.1, max: 1.0, step: Some(0.1), default: 0.9 };
assert!((r.clamp(2.0) - 1.0).abs() < f64::EPSILON);
assert!((r.clamp(-1.0) - 0.1).abs() < f64::EPSILON);

pub fn contains(&self, value: f64) -> bool

Return true if value lies within [min, max] (inclusive).

Examples

use zeph_experiments::{ParameterRange, ParameterKind};

let r = ParameterRange { kind: ParameterKind::Temperature, min: 0.0, max: 1.0, step: Some(0.1), default: 0.7 };
assert!(r.contains(0.5));
assert!(!r.contains(1.1));

pub fn quantize(&self, value: f64) -> f64

Quantize value to the nearest grid step anchored at min.

Formula: min + ((value - min) / step).round() * step, then clamped to [min, max]. Anchoring at min ensures grid points align to {min, min+step, min+2*step, ...}.

pub fn is_valid(&self) -> bool

Return true if this range is internally consistent.

Returns false if min > max, any bound or default is non-finite, or step is present but non-positive or non-finite.

Examples

use zeph_experiments::{ParameterRange, ParameterKind};

let valid = ParameterRange { kind: ParameterKind::Temperature, min: 0.0, max: 1.0, step: Some(0.1), default: 0.7 };
assert!(valid.is_valid());

let inverted = ParameterRange { min: 1.0, max: 0.0, ..valid };
assert!(!inverted.is_valid());

Trait Implementations

impl Clone for ParameterRange

fn clone(&self) -> ParameterRange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParameterRange

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ParameterRange

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ParameterRange

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

where __S: Serializer,

Serialize this value into the given Serde serializer.