autoeq-optim 0.5.58

AutoEQ objectives, constraints, and optimizer backends
Documentation
pub(super) fn parse_nonnegative_f64(s: &str) -> Result<f64, String> {
    let v: f64 = s.parse().map_err(|_| format!("invalid float: {s}"))?;
    if v >= 0.0 {
        Ok(v)
    } else {
        Err("value must be non-negative (>= 0)".to_string())
    }
}

pub(super) fn parse_finite_f64(s: &str) -> Result<f64, String> {
    let value: f64 = s.parse().map_err(|_| format!("invalid float: {s}"))?;
    if value.is_finite() {
        Ok(value)
    } else {
        Err("value must be finite".to_string())
    }
}

pub(super) fn parse_recombination_probability(s: &str) -> Result<f64, String> {
    let v: f64 = s.parse().map_err(|_| format!("invalid float: {s}"))?;
    if (0.0..=1.0).contains(&v) {
        Ok(v)
    } else {
        Err("recombination probability must be between 0.0 and 1.0".to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_nonnegative_f64_accepts_zero_and_positive() {
        assert_eq!(parse_nonnegative_f64("0").unwrap(), 0.0);
        assert_eq!(parse_nonnegative_f64("0.0").unwrap(), 0.0);
        assert_eq!(parse_nonnegative_f64("3.5").unwrap(), 3.5);
        assert_eq!(parse_nonnegative_f64("1e3").unwrap(), 1000.0);
    }

    #[test]
    fn parse_nonnegative_f64_rejects_negative_and_invalid() {
        assert!(parse_nonnegative_f64("-1").is_err());
        assert!(parse_nonnegative_f64("-0.001").is_err());
        assert!(parse_nonnegative_f64("not-a-number").is_err());
        assert!(parse_nonnegative_f64("").is_err());
    }

    #[test]
    fn parse_finite_f64_accepts_signed_values_and_rejects_non_finite_values() {
        assert_eq!(parse_finite_f64("-12").unwrap(), -12.0);
        assert_eq!(parse_finite_f64("0").unwrap(), 0.0);
        assert_eq!(parse_finite_f64("3.5").unwrap(), 3.5);
        for invalid in ["NaN", "inf", "-inf", "not-a-number", ""] {
            assert!(parse_finite_f64(invalid).is_err(), "accepted {invalid:?}");
        }
    }

    #[test]
    fn parse_recombination_probability_accepts_valid_range() {
        assert_eq!(parse_recombination_probability("0").unwrap(), 0.0);
        assert_eq!(parse_recombination_probability("1").unwrap(), 1.0);
        assert_eq!(parse_recombination_probability("0.5").unwrap(), 0.5);
        assert_eq!(parse_recombination_probability("0.0").unwrap(), 0.0);
        assert_eq!(parse_recombination_probability("1.0").unwrap(), 1.0);
    }

    #[test]
    fn parse_recombination_probability_rejects_out_of_range_and_invalid() {
        assert!(parse_recombination_probability("-0.1").is_err());
        assert!(parse_recombination_probability("1.0001").is_err());
        assert!(parse_recombination_probability("2").is_err());
        assert!(parse_recombination_probability("foo").is_err());
        assert!(parse_recombination_probability("").is_err());
    }
}