Struct ParameterRange 

pub struct ParameterRange { /* private fields */ }

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

Invariants enforced by ParameterRange::new:

• min < max (both must be finite)
• min <= default <= max (default must be finite)
• step, when Some, must be finite and positive

Examples

use zeph_experiments::{ParameterRange, ParameterKind};

let range = ParameterRange::new(ParameterKind::Temperature, 0.0, 1.0, Some(0.1), 0.7).unwrap();

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);

Implementations

impl ParameterRange

pub fn new( kind: ParameterKind, min: f64, max: f64, step: Option<f64>, default: f64, ) -> Result<Self, EvalError>

Construct a validated ParameterRange.

Errors

Returns EvalError::InvalidRange if min >= max or either bound is non-finite. Returns EvalError::DefaultOutOfRange if default is outside [min, max].

step is not validated by this constructor; non-positive or non-finite values are treated as None by step_count and quantize.

Examples

use zeph_experiments::{ParameterRange, ParameterKind, EvalError};

let r = ParameterRange::new(ParameterKind::Temperature, 0.0, 1.0, Some(0.1), 0.7).unwrap();
assert!((r.min() - 0.0).abs() < f64::EPSILON);
assert!((r.max() - 1.0).abs() < f64::EPSILON);
assert!((r.default_value() - 0.7).abs() < f64::EPSILON);

assert!(matches!(
    ParameterRange::new(ParameterKind::Temperature, 1.0, 0.0, None, 0.5),
    Err(EvalError::InvalidRange { .. })
));
assert!(matches!(
    ParameterRange::new(ParameterKind::Temperature, 0.0, 1.0, None, 2.0),
    Err(EvalError::DefaultOutOfRange { .. })
));

pub fn kind(&self) -> ParameterKind

Return the ParameterKind this range applies to.

pub fn min(&self) -> f64

Return the minimum value (inclusive).

pub fn max(&self) -> f64

Return the maximum value (inclusive).

pub fn step(&self) -> Option<f64>

Return the discrete step size, or None for a continuous range.

pub fn default_value(&self) -> f64

Return the default (baseline) value.

Named default_value to avoid shadowing the Default trait keyword.

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::new(ParameterKind::Temperature, 0.0, 1.0, Some(0.5), 0.5).unwrap();
assert_eq!(r.step_count(), Some(3)); // 0.0, 0.5, 1.0

let r_continuous = ParameterRange::new(ParameterKind::Temperature, 0.0, 1.0, None, 0.5).unwrap();
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::new(ParameterKind::TopP, 0.1, 1.0, Some(0.1), 0.9).unwrap();
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::new(ParameterKind::Temperature, 0.0, 1.0, Some(0.1), 0.7).unwrap();
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, ...}.

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.