diff --git a/CHANGELOG.md b/CHANGELOG.md index 388a41e08..a49d97d43 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,6 +19,7 @@ Bug fixes * Rhai and Rhai Grain now properly enforce object map size limits in all mutation scenarios ([`#1214`](https://github.com/rhaiscript/rhai/issues/1214)). * (Fuzzing) Fixed panic when assigning to a property of a constant object. * Fixed undefined behavior (an aliasing violation detected by Miri) when a variable is passed to a function that does not take its first argument by `&mut`, e.g. `x.contains("a")` or `f(x)` for a script function. This was a regression in 1.27.0. +* `sort` and `sort_desc` no longer panic on an array of floating-point numbers that contains NaN. NaN now sorts after every other number (before them for `sort_desc`) (thanks [`@Rockyrok77`](https://github.com/Rockyrok77)). Enhancements ------------ diff --git a/src/packages/array_basic.rs b/src/packages/array_basic.rs index a066cc100..25527d63e 100644 --- a/src/packages/array_basic.rs +++ b/src/packages/array_basic.rs @@ -1668,7 +1668,9 @@ pub mod array_functions { array.sort_by(|a, b| { let a = a.as_float().unwrap(); let b = b.as_float().unwrap(); - a.partial_cmp(&b).unwrap_or(Ordering::Equal) + // NaN sorts after every number, otherwise the order is not total and `sort_by` may panic. + a.partial_cmp(&b) + .unwrap_or_else(|| a.is_nan().cmp(&b.is_nan())) }); return Ok(()); } @@ -1775,7 +1777,11 @@ pub mod array_functions { array.sort_by(|a, b| { let a = a.as_float().unwrap(); let b = b.as_float().unwrap(); - match a.partial_cmp(&b).unwrap_or(Ordering::Equal) { + // NaN sorts before every number, otherwise the order is not total and `sort_by` may panic. + match a + .partial_cmp(&b) + .unwrap_or_else(|| a.is_nan().cmp(&b.is_nan())) + { Ordering::Less => Ordering::Greater, Ordering::Equal => Ordering::Equal, Ordering::Greater => Ordering::Less, diff --git a/tests/arrays.rs b/tests/arrays.rs index e64eb05da..4e23b3ea5 100644 --- a/tests/arrays.rs +++ b/tests/arrays.rs @@ -515,6 +515,27 @@ fn test_arrays_index_of() { assert_eq!(engine.eval::(r#"index_of([1,2,3], "foo")"#).unwrap(), -1); } +#[test] +#[cfg(not(feature = "no_float"))] +#[cfg(not(feature = "no_object"))] +fn test_arrays_sort_nan() { + let engine = Engine::new(); + + // 60 numbers, every fourth one NaN. + let setup = "let a = []; for i in 0..60 { a.push(if i % 4 == 0 { 0.0 / 0.0 } else { (i * 37 % 61).to_float() }); }"; + let floats = |a: Array| a.iter().map(|v| v.as_float().unwrap()).collect::>(); + + let sorted = floats(engine.eval::(&format!("{setup} a.sort(); a")).unwrap()); + assert_eq!(sorted.len(), 60); + assert!(sorted[..45].windows(2).all(|w| w[0] <= w[1])); + assert!(sorted[45..].iter().all(|v| v.is_nan())); + + let sorted = floats(engine.eval::(&format!("{setup} a.sort_desc(); a")).unwrap()); + assert_eq!(sorted.len(), 60); + assert!(sorted[..15].iter().all(|v| v.is_nan())); + assert!(sorted[15..].windows(2).all(|w| w[0] >= w[1])); +} + #[test] #[cfg(not(feature = "no_object"))] #[cfg(not(feature = "no_function"))]