From f738932bbdbe5067d12b12b505798f9748a5932d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Joaqu=C3=ADn=20Tri=C3=B1anes?= Date: Tue, 22 Oct 2024 17:34:41 +0200 Subject: [PATCH] Fix range contains (#14011) # Description This PR changes the range contains logic to take the step into account. ```nushell # before 2 in 1..3.. # true # now 2 in 1..3.. # false ``` --- I encountered another issue while adding tests. Due to floating point precision, `2.1 in 1..1.1..3` will return `false`. The floating point error is even bigger than `f64::EPSILON` (`0.09999999999999876` vs `2.220446049250313e-16`). This issue disappears with bigger numbers. I tried a different algorithm (checking if the estimated number of steps is close enough to any integer) but the results are still pretty bad: ```rust let n_steps = (value - self.start) / self.step; // 14.999999999999988 (n_steps - n_steps.round()).abs() < f64::EPSILON // returns false ``` Maybe it can be shipped like this, the REPL already has floating point errors (`1.1 - 1` returns `0.10000000000000009`). Or maybe there's a way to fix this that I didn't think of. I'm open to ideas! But in any case performing this kind of checks on a range of floats seems more niche than doing it on a range of ints. # User-Facing Changes Code that depended on this behavior to check if a number is between `start` and `end` will potentially return a different value. # Tests + Formatting # After Submitting --- crates/nu-protocol/src/value/range.rs | 62 ++++++++++++++++----------- tests/repl/test_ranges.rs | 42 +++++++++++++++++- 2 files changed, 79 insertions(+), 25 deletions(-) diff --git a/crates/nu-protocol/src/value/range.rs b/crates/nu-protocol/src/value/range.rs index 6ec7ce16ad..77aa5a60ef 100644 --- a/crates/nu-protocol/src/value/range.rs +++ b/crates/nu-protocol/src/value/range.rs @@ -95,20 +95,27 @@ mod int_range { pub fn contains(&self, value: i64) -> bool { if self.step < 0 { - value <= self.start - && match self.end { - Bound::Included(end) => value >= end, - Bound::Excluded(end) => value > end, - Bound::Unbounded => true, - } + // Decreasing range + if value > self.start { + return false; + } + match self.end { + Bound::Included(end) if value < end => return false, + Bound::Excluded(end) if value <= end => return false, + _ => {} + }; } else { - self.start <= value - && match self.end { - Bound::Included(end) => value <= end, - Bound::Excluded(end) => value < end, - Bound::Unbounded => true, - } + // Increasing range + if value < self.start { + return false; + } + match self.end { + Bound::Included(end) if value > end => return false, + Bound::Excluded(end) if value >= end => return false, + _ => {} + }; } + (value - self.start) % self.step == 0 } pub fn into_range_iter(self, signals: Signals) -> Iter { @@ -330,20 +337,27 @@ mod float_range { pub fn contains(&self, value: f64) -> bool { if self.step < 0.0 { - value <= self.start - && match self.end { - Bound::Included(end) => value >= end, - Bound::Excluded(end) => value > end, - Bound::Unbounded => true, - } + // Decreasing range + if value > self.start { + return false; + } + match self.end { + Bound::Included(end) if value <= end => return false, + Bound::Excluded(end) if value < end => return false, + _ => {} + }; } else { - self.start <= value - && match self.end { - Bound::Included(end) => value <= end, - Bound::Excluded(end) => value < end, - Bound::Unbounded => true, - } + // Increasing range + if value < self.start { + return false; + } + match self.end { + Bound::Included(end) if value >= end => return false, + Bound::Excluded(end) if value > end => return false, + _ => {} + }; } + ((value - self.start) % self.step).abs() < f64::EPSILON } pub fn into_range_iter(self, signals: Signals) -> Iter { diff --git a/tests/repl/test_ranges.rs b/tests/repl/test_ranges.rs index 96f59eea84..8e7a557738 100644 --- a/tests/repl/test_ranges.rs +++ b/tests/repl/test_ranges.rs @@ -7,7 +7,7 @@ fn int_in_inc_range() -> TestResult { #[test] fn int_in_dec_range() -> TestResult { - run_test(r#"1 in 9.42..-4"#, "true") + run_test(r#"1 in 9..-4.42"#, "true") } #[test] @@ -15,6 +15,16 @@ fn int_in_exclusive_range() -> TestResult { run_test(r#"3 in 0..<3"#, "false") } +#[test] +fn float_in_inc_range() -> TestResult { + run_test(r#"1.58 in -4.42..9"#, "true") +} + +#[test] +fn float_in_dec_range() -> TestResult { + run_test(r#"1.42 in 9.42..-4.42"#, "true") +} + #[test] fn non_number_in_range() -> TestResult { fail_test(r#"'a' in 1..3"#, "subset comparison is not supported") @@ -34,3 +44,33 @@ fn range_and_reduction() -> TestResult { fn zip_ranges() -> TestResult { run_test(r#"1..3 | zip 4..6 | get 2.1"#, "6") } + +#[test] +fn int_in_stepped_range() -> TestResult { + run_test(r#"7 in 1..3..15"#, "true") +} + +#[test] +fn int_in_unbounded_stepped_range() -> TestResult { + run_test(r#"1000001 in 1..3.."#, "true") +} + +#[test] +fn int_not_in_unbounded_stepped_range() -> TestResult { + run_test(r#"2 in 1..3.."#, "false") +} + +#[test] +fn float_in_stepped_range() -> TestResult { + run_test(r#"5.5 in 1..1.5..10"#, "true") +} + +#[test] +fn float_in_unbounded_stepped_range() -> TestResult { + run_test(r#"100.5 in 1..1.5.."#, "true") +} + +#[test] +fn float_not_in_unbounded_stepped_range() -> TestResult { + run_test(r#"2.1 in 1.2..3.."#, "false") +}