autoeq_optim/cli/
validate.rs1use super::args::Args;
2use crate::LossType;
3use crate::de::Strategy;
4use std::process;
5
6pub fn validate_args(args: &Args) -> Result<(), String> {
8 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 if crate::optim::find_algorithm_info(&args.algo).is_some() {
20 } else {
22 return Err(format!(
23 "Unknown algorithm: '{}'. Use --algo-list to see available algorithms.",
24 args.algo
25 ));
26 }
27
28 if args.refine {
30 if crate::optim::find_algorithm_info(&args.local_algo).is_some() {
31 } 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 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 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 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 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 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 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 if args.population == 0 {
99 return Err("Population size must be > 0".to_string());
100 }
101
102 if args.maxeval == 0 {
104 return Err("Maximum evaluations must be > 0".to_string());
105 }
106
107 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 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 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 if args.loss == LossType::DriversFlat {
139 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 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 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 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
179pub 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}