Merge pull request #44 from kubouch/float-ranges

Floating point ranges

crates/nu-parser/tests/test_parser.rs

@@ -403,6 +403,38 @@ mod range {
         }
     }
 
+    #[test]
+    fn parse_float_range() {
+        let engine_state = EngineState::new();
+        let mut working_set = StateWorkingSet::new(&engine_state);
+
+        let (block, err) = parse(&mut working_set, None, b"2.0..4.0..10.0", true);
+
+        assert!(err.is_none());
+        assert!(block.len() == 1);
+        match &block[0] {
+            Statement::Pipeline(Pipeline { expressions }) => {
+                assert!(expressions.len() == 1);
+                assert!(matches!(
+                    expressions[0],
+                    Expression {
+                        expr: Expr::Range(
+                            Some(_),
+                            Some(_),
+                            Some(_),
+                            RangeOperator {
+                                inclusion: RangeInclusion::Inclusive,
+                                ..
+                            }
+                        ),
+                        ..
+                    }
+                ))
+            }
+            _ => panic!("No match"),
+        }
+    }
+
     #[test]
     fn bad_parse_does_crash() {
         let engine_state = EngineState::new();

crates/nu-protocol/src/value/range.rs

@@ -1,3 +1,5 @@
+use std::cmp::Ordering;
+
 use crate::{
     ast::{RangeInclusion, RangeOperator},
     *,
@@ -150,31 +152,52 @@ impl RangeIterator {
     }
 }
 
+// Compare two floating point numbers. The decision interval for equality is dynamically scaled
+// as the value being compared increases in magnitude.
+fn compare_floats(val: f64, other: f64) -> Option<Ordering> {
+    let prec = f64::EPSILON.max(val.abs() * f64::EPSILON);
+
+    if (other - val).abs() < prec {
+        return Some(Ordering::Equal);
+    }
+
+    val.partial_cmp(&other)
+}
+
 impl Iterator for RangeIterator {
     type Item = Value;
     fn next(&mut self) -> Option<Self::Item> {
-        use std::cmp::Ordering;
         if self.done {
             return None;
         }
 
         let ordering = if matches!(self.end, Value::Nothing { .. }) {
-            Ordering::Less
+            Some(Ordering::Less)
         } else {
             match (&self.curr, &self.end) {
-                (Value::Int { val: curr, .. }, Value::Int { val: end, .. }) => curr.cmp(end),
-                // (Value::Float { val: curr, .. }, Value::Float { val: end, .. }) => curr.cmp(end),
-                // (Value::Float { val: curr, .. }, Value::Int { val: end, .. }) => curr.cmp(end),
-                // (Value::Int { val: curr, .. }, Value::Float { val: end, .. }) => curr.cmp(end),
-                _ => {
-                    self.done = true;
-                    return Some(Value::Error {
-                        error: ShellError::CannotCreateRange(self.span),
-                    });
+                (Value::Int { val: curr, .. }, Value::Int { val: end, .. }) => Some(curr.cmp(end)),
+                (Value::Float { val: curr, .. }, Value::Float { val: end, .. }) => {
+                    compare_floats(*curr, *end)
                 }
+                (Value::Float { val: curr, .. }, Value::Int { val: end, .. }) => {
+                    compare_floats(*curr, *end as f64)
+                }
+                (Value::Int { val: curr, .. }, Value::Float { val: end, .. }) => {
+                    compare_floats(*curr as f64, *end)
+                }
+                _ => None,
             }
         };
 
+        let ordering = if let Some(ord) = ordering {
+            ord
+        } else {
+            self.done = true;
+            return Some(Value::Error {
+                error: ShellError::CannotCreateRange(self.span),
+            });
+        };
+
         let desired_ordering = if self.moves_up {
             Ordering::Less
         } else {