Skip to main content

autoeq_optim/cli/
validate.rs

1use super::args::Args;
2use crate::LossType;
3use crate::de::Strategy;
4use std::process;
5
6/// Validate CLI arguments and exit with error message if validation fails
7pub fn validate_args(args: &Args) -> Result<(), String> {
8    // Check if strategy is valid when using DE algorithm
9    if args.algo == "autoeq:de" || args.algo.contains("de") {
10        use std::str::FromStr;
11        if let Err(err) = Strategy::from_str(&args.strategy) {
12            return Err(format!(
13                "Invalid DE strategy '{}': {}. Use --strategy-list to see available strategies.",
14                args.strategy, err
15            ));
16        }
17    }
18    // Check if algorithm is valid
19    if crate::optim::find_algorithm_info(&args.algo).is_some() {
20        // Algorithm is valid
21    } else {
22        return Err(format!(
23            "Unknown algorithm: '{}'. Use --algo-list to see available algorithms.",
24            args.algo
25        ));
26    }
27
28    // Check if local algorithm is valid (when refine is enabled)
29    if args.refine {
30        if crate::optim::find_algorithm_info(&args.local_algo).is_some() {
31            // Local algorithm is valid
32        } else {
33            return Err(format!(
34                "Unknown local algorithm: '{}'. Use --algo-list to see available algorithms.",
35                args.local_algo
36            ));
37        }
38    }
39
40    // Check min/max Q factor constraints
41    if args.min_q > args.max_q {
42        return Err(format!(
43            "Invalid Q factor range: min_q ({}) must be <= max_q ({})",
44            args.min_q, args.max_q
45        ));
46    }
47
48    // Check min/max frequency constraints
49    if args.min_freq > args.max_freq {
50        return Err(format!(
51            "Invalid frequency range: min_freq ({}) must be <= max_freq ({})",
52            args.min_freq, args.max_freq
53        ));
54    }
55
56    // Check min/max dB constraints
57    if args.min_db > args.max_db {
58        return Err(format!(
59            "Invalid dB range: min_db ({}) must be <= max_db ({})",
60            args.min_db, args.max_db
61        ));
62    }
63
64    // Check frequency bounds (reasonable audio range)
65    if args.min_freq < 20.0 {
66        return Err(format!(
67            "Invalid min_freq: {} Hz. Must be >= 20 Hz (reasonable audio range)",
68            args.min_freq
69        ));
70    }
71
72    if args.max_freq > 20000.0 {
73        return Err(format!(
74            "Invalid max_freq: {} Hz. Must be <= 20,000 Hz (reasonable audio range)",
75            args.max_freq
76        ));
77    }
78
79    // Check that max_freq does not exceed Nyquist frequency
80    let nyquist = args.sample_rate / 2.0;
81    if args.max_freq > nyquist {
82        return Err(format!(
83            "max_freq ({:.0} Hz) exceeds Nyquist frequency ({:.0} Hz) at sample rate {:.0} Hz. \
84             Biquad filters above Nyquist have undefined behavior.",
85            args.max_freq, nyquist, args.sample_rate
86        ));
87    }
88
89    // Check smoothing parameters
90    if args.smooth_n < 1 || args.smooth_n > 24 {
91        return Err(format!(
92            "Invalid smooth_n: {}. Must be in range [1..24]",
93            args.smooth_n
94        ));
95    }
96
97    // Check that population size is reasonable
98    if args.population == 0 {
99        return Err("Population size must be > 0".to_string());
100    }
101
102    // Check that maxeval is reasonable
103    if args.maxeval == 0 {
104        return Err("Maximum evaluations must be > 0".to_string());
105    }
106
107    // Check that num_filters is reasonable
108    if args.num_filters == 0 {
109        return Err("Number of filters must be > 0".to_string());
110    }
111
112    if args.num_filters > 50 {
113        return Err(format!(
114            "Number of filters ({}) is very high. Consider using <= 50 filters for reasonable performance",
115            args.num_filters
116        ));
117    }
118
119    // Check tolerance parameters
120    if args.tolerance <= 0.0 {
121        return Err("Tolerance must be > 0".to_string());
122    }
123
124    if args.atolerance < 0.0 {
125        return Err("Absolute tolerance must be >= 0".to_string());
126    }
127
128    // Check adaptive weight parameters (should be in [0, 1])
129    if args.adaptive_weight_f < 0.0 || args.adaptive_weight_f > 1.0 {
130        return Err("Adaptive weight for F must be between 0.0 and 1.0".to_string());
131    }
132
133    if args.adaptive_weight_cr < 0.0 || args.adaptive_weight_cr > 1.0 {
134        return Err("Adaptive weight for CR must be between 0.0 and 1.0".to_string());
135    }
136
137    // Validate multi-driver arguments
138    if args.loss == LossType::DriversFlat {
139        // Check that at least driver1 and driver2 are provided
140        if args.driver1.is_none() || args.driver2.is_none() {
141            return Err("Multi-driver optimization requires at least --driver1 and --driver2 when using --loss drivers-flat".to_string());
142        }
143
144        // Check crossover type
145        let valid_crossover_types = ["butterworth2", "linkwitzriley2", "linkwitzriley4"];
146        if !valid_crossover_types.contains(&args.crossover_type.as_str()) {
147            return Err(format!(
148                "Invalid crossover type '{}'. Valid types: {}",
149                args.crossover_type,
150                valid_crossover_types.join(", ")
151            ));
152        }
153
154        // Count number of drivers
155        let n_drivers = [&args.driver1, &args.driver2, &args.driver3, &args.driver4]
156            .iter()
157            .filter(|d| d.is_some())
158            .count();
159        if !(2..=4).contains(&n_drivers) {
160            return Err(format!(
161                "Multi-driver optimization requires 2-4 drivers, got {}",
162                n_drivers
163            ));
164        }
165    } else {
166        // If not using drivers-flat loss, driver arguments should not be provided
167        if args.driver1.is_some()
168            || args.driver2.is_some()
169            || args.driver3.is_some()
170            || args.driver4.is_some()
171        {
172            return Err("Driver arguments (--driver1, --driver2, etc.) can only be used with --loss drivers-flat".to_string());
173        }
174    }
175
176    Ok(())
177}
178
179/// Validate arguments and exit with error if validation fails
180pub fn validate_args_or_exit(args: &Args) {
181    if let Err(error) = validate_args(args) {
182        eprintln!("❌ Validation Error: {}", error);
183        process::exit(1);
184    }
185}
186
187#[cfg(test)]
188mod tests {
189    use super::super::args::Args;
190    use super::validate_args;
191    use crate::LossType;
192    use clap::Parser;
193    use std::path::PathBuf;
194
195    fn valid_args() -> Args {
196        Args::try_parse_from::<&[&str], _>(&["prog"]).unwrap()
197    }
198
199    #[test]
200    fn valid_default_args_pass() {
201        let args = valid_args();
202        assert!(validate_args(&args).is_ok());
203    }
204
205    #[test]
206    fn min_q_greater_than_max_q_fails() {
207        let mut args = valid_args();
208        args.min_q = 5.0;
209        args.max_q = 1.0;
210        let err = validate_args(&args).unwrap_err();
211        assert!(err.contains("min_q"));
212        assert!(err.contains("max_q"));
213    }
214
215    #[test]
216    fn min_freq_greater_than_max_freq_fails() {
217        let mut args = valid_args();
218        args.min_freq = 200.0;
219        args.max_freq = 100.0;
220        let err = validate_args(&args).unwrap_err();
221        assert!(err.contains("min_freq"));
222        assert!(err.contains("max_freq"));
223    }
224
225    #[test]
226    fn max_freq_above_nyquist_fails() {
227        let mut args = valid_args();
228        args.sample_rate = 1000.0;
229        args.max_freq = 600.0;
230        let err = validate_args(&args).unwrap_err();
231        assert!(err.contains("Nyquist"));
232    }
233
234    #[test]
235    fn driver_args_without_drivers_flat_loss_fails() {
236        let mut args = valid_args();
237        args.loss = LossType::SpeakerFlat;
238        args.driver1 = Some(PathBuf::from("d1.csv"));
239        let err = validate_args(&args).unwrap_err();
240        assert!(err.contains("Driver arguments"));
241    }
242
243    #[test]
244    fn drivers_flat_without_drivers_fails() {
245        let mut args = valid_args();
246        args.loss = LossType::DriversFlat;
247        let err = validate_args(&args).unwrap_err();
248        assert!(err.contains("requires at least --driver1 and --driver2"));
249    }
250
251    #[test]
252    fn drivers_flat_with_invalid_crossover_type_fails() {
253        let mut args = valid_args();
254        args.loss = LossType::DriversFlat;
255        args.driver1 = Some(PathBuf::from("d1.csv"));
256        args.driver2 = Some(PathBuf::from("d2.csv"));
257        args.crossover_type = "invalid".to_string();
258        let err = validate_args(&args).unwrap_err();
259        assert!(err.contains("Invalid crossover type"));
260    }
261
262    #[test]
263    fn drivers_flat_with_valid_crossover_passes() {
264        let mut args = valid_args();
265        args.loss = LossType::DriversFlat;
266        args.driver1 = Some(PathBuf::from("d1.csv"));
267        args.driver2 = Some(PathBuf::from("d2.csv"));
268        args.crossover_type = "linkwitzriley4".to_string();
269        assert!(validate_args(&args).is_ok());
270    }
271
272    #[test]
273    fn refine_with_unknown_local_algo_fails() {
274        let mut args = valid_args();
275        args.refine = true;
276        args.local_algo = "unknown".to_string();
277        let err = validate_args(&args).unwrap_err();
278        assert!(err.contains("Unknown local algorithm"));
279    }
280
281    #[test]
282    fn min_freq_below_reasonable_range_fails() {
283        let mut args = valid_args();
284        args.min_freq = 10.0;
285        let err = validate_args(&args).unwrap_err();
286        assert!(err.contains("Must be >= 20 Hz"));
287    }
288
289    #[test]
290    fn max_freq_above_reasonable_range_fails() {
291        let mut args = valid_args();
292        args.max_freq = 25000.0;
293        let err = validate_args(&args).unwrap_err();
294        assert!(err.contains("Must be <= 20,000 Hz"));
295    }
296
297    #[test]
298    fn smooth_n_out_of_range_fails() {
299        let mut args = valid_args();
300        args.smooth_n = 0;
301        let err = validate_args(&args).unwrap_err();
302        assert!(err.contains("smooth_n"));
303
304        let mut args = valid_args();
305        args.smooth_n = 25;
306        let err = validate_args(&args).unwrap_err();
307        assert!(err.contains("smooth_n"));
308    }
309
310    #[test]
311    fn population_zero_fails() {
312        let mut args = valid_args();
313        args.population = 0;
314        let err = validate_args(&args).unwrap_err();
315        assert!(err.contains("Population size"));
316    }
317
318    #[test]
319    fn maxeval_zero_fails() {
320        let mut args = valid_args();
321        args.maxeval = 0;
322        let err = validate_args(&args).unwrap_err();
323        assert!(err.contains("Maximum evaluations"));
324    }
325
326    #[test]
327    fn num_filters_zero_or_too_high_fails() {
328        let mut args = valid_args();
329        args.num_filters = 0;
330        let err = validate_args(&args).unwrap_err();
331        assert!(err.contains("Number of filters"));
332
333        let mut args = valid_args();
334        args.num_filters = 51;
335        let err = validate_args(&args).unwrap_err();
336        assert!(err.contains("<= 50 filters"));
337    }
338
339    #[test]
340    fn tolerance_non_positive_fails() {
341        let mut args = valid_args();
342        args.tolerance = 0.0;
343        let err = validate_args(&args).unwrap_err();
344        assert!(err.contains("Tolerance"));
345    }
346
347    #[test]
348    fn atolerance_negative_fails() {
349        let mut args = valid_args();
350        args.atolerance = -1.0;
351        let err = validate_args(&args).unwrap_err();
352        assert!(err.contains("Absolute tolerance"));
353    }
354
355    #[test]
356    fn adaptive_weights_out_of_range_fails() {
357        let mut args = valid_args();
358        args.adaptive_weight_f = 1.5;
359        let err = validate_args(&args).unwrap_err();
360        assert!(err.contains("Adaptive weight for F"));
361
362        let mut args = valid_args();
363        args.adaptive_weight_cr = -0.1;
364        let err = validate_args(&args).unwrap_err();
365        assert!(err.contains("Adaptive weight for CR"));
366    }
367
368    #[test]
369    fn invalid_de_strategy_fails() {
370        let mut args = valid_args();
371        args.algo = "autoeq:de".to_string();
372        args.strategy = "not-a-strategy".to_string();
373        let err = validate_args(&args).unwrap_err();
374        assert!(err.contains("Invalid DE strategy"));
375    }
376
377    #[test]
378    fn drivers_flat_with_too_few_drivers_fails() {
379        let mut args = valid_args();
380        args.loss = LossType::DriversFlat;
381        args.driver1 = Some(PathBuf::from("d1.csv"));
382        let err = validate_args(&args).unwrap_err();
383        assert!(err.contains("requires at least --driver1 and --driver2"));
384    }
385
386    #[test]
387    fn drivers_flat_accepts_all_valid_crossover_types() {
388        for ct in ["butterworth2", "linkwitzriley2", "linkwitzriley4"] {
389            let mut args = valid_args();
390            args.loss = LossType::DriversFlat;
391            args.driver1 = Some(PathBuf::from("d1.csv"));
392            args.driver2 = Some(PathBuf::from("d2.csv"));
393            args.crossover_type = ct.to_string();
394            assert!(
395                validate_args(&args).is_ok(),
396                "crossover {} should be valid",
397                ct
398            );
399        }
400    }
401}