Added lesser and greater than controls.

src/message.rs

@@ -3113,12 +3113,20 @@ mod docdefs {
 enum Operand {
     Add,
     Equal,
+    GreaterThan,
+    GreaterThanEqual,
+    LessThan,
+    LessThanEqual,
 }
 
 impl Operand {
     fn validate(&self, x: &Field, y: &Field) -> bool {
         match self {
             Self::Equal => x == y,
+            Self::GreaterThan => x > y,
+            Self::GreaterThanEqual => x >= y,
+            Self::LessThan => x < y,
+            Self::LessThanEqual => x <= y,
             _ => false,
         }
     }
@@ -3143,6 +3151,38 @@ mod operands {
         }
         assert!(!Operand::Equal.validate(&x, &y));
     }
+
+    #[test]
+    fn does_greater() {
+        let data: Vec<Field> = vec![1.into(), 2.into(), 3.into()];
+        assert!(!Operand::GreaterThan.validate(&data[0], &data[1]));
+        assert!(!Operand::GreaterThan.validate(&data[1], &data[1]));
+        assert!(Operand::GreaterThan.validate(&data[2], &data[1]));
+    }
+
+    #[test]
+    fn does_greater_equal() {
+        let data: Vec<Field> = vec![1.into(), 2.into(), 3.into()];
+        assert!(!Operand::GreaterThanEqual.validate(&data[0], &data[1]));
+        assert!(Operand::GreaterThanEqual.validate(&data[1], &data[1]));
+        assert!(Operand::GreaterThanEqual.validate(&data[2], &data[1]));
+    }
+
+    #[test]
+    fn does_lesser() {
+        let data: Vec<Field> = vec![1.into(), 2.into(), 3.into()];
+        assert!(Operand::LessThan.validate(&data[0], &data[1]));
+        assert!(!Operand::LessThan.validate(&data[1], &data[1]));
+        assert!(!Operand::LessThan.validate(&data[2], &data[1]));
+    }
+
+    #[test]
+    fn does_lesser_equal() {
+        let data: Vec<Field> = vec![1.into(), 2.into(), 3.into()];
+        assert!(Operand::LessThanEqual.validate(&data[0], &data[1]));
+        assert!(Operand::LessThanEqual.validate(&data[1], &data[1]));
+        assert!(!Operand::LessThanEqual.validate(&data[2], &data[1]));
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -3464,6 +3504,34 @@ impl Calculation {
                         .equal(&self.values[1].get(existing));
                 }
             }
+            Operand::GreaterThan => {
+                if self.values.len() >= 2 {
+                    result = self.values[0]
+                        .get(existing)
+                        .greater(&self.values[1].get(existing));
+                }
+            }
+            Operand::GreaterThanEqual => {
+                if self.values.len() >= 2 {
+                    result = self.values[0]
+                        .get(existing)
+                        .greater_equal(&self.values[1].get(existing));
+                }
+            }
+            Operand::LessThan => {
+                if self.values.len() >= 2 {
+                    result = self.values[0]
+                        .get(existing)
+                        .lesser(&self.values[1].get(existing));
+                }
+            }
+            Operand::LessThanEqual => {
+                if self.values.len() >= 2 {
+                    result = self.values[0]
+                        .get(existing)
+                        .lesser_equal(&self.values[1].get(existing));
+                }
+            }
         }
         result
     }
@@ -3527,6 +3595,70 @@ mod calculations {
         assert_eq!(result, expected);
     }
 
+    #[test]
+    fn can_greater_than() {
+        let data: Vec<(Field, Field)> = vec![
+            (0.into(), false.into()),
+            (1.into(), false.into()),
+            (2.into(), true.into()),
+        ];
+        for (item, expected) in data.iter() {
+            let mut calc = Calculation::new(Operand::GreaterThan);
+            calc.add_value(item.clone());
+            calc.add_value(data[1].0.clone());
+            let result = calc.calculate(&Field::None);
+            assert_eq!(&result, expected);
+        }
+    }
+
+    #[test]
+    fn can_greater_than_equal() {
+        let data: Vec<(Field, Field)> = vec![
+            (0.into(), false.into()),
+            (1.into(), true.into()),
+            (2.into(), true.into()),
+        ];
+        for (item, expected) in data.iter() {
+            let mut calc = Calculation::new(Operand::GreaterThanEqual);
+            calc.add_value(item.clone());
+            calc.add_value(data[1].0.clone());
+            let result = calc.calculate(&Field::None);
+            assert_eq!(&result, expected);
+        }
+    }
+
+    #[test]
+    fn can_lesser_than() {
+        let data: Vec<(Field, Field)> = vec![
+            (0.into(), true.into()),
+            (1.into(), false.into()),
+            (2.into(), false.into()),
+        ];
+        for (item, expected) in data.iter() {
+            let mut calc = Calculation::new(Operand::LessThan);
+            calc.add_value(item.clone());
+            calc.add_value(data[1].0.clone());
+            let result = calc.calculate(&Field::None);
+            assert_eq!(&result, expected);
+        }
+    }
+
+    #[test]
+    fn can_lesser_than_equal() {
+        let data: Vec<(Field, Field)> = vec![
+            (0.into(), true.into()),
+            (1.into(), true.into()),
+            (2.into(), false.into()),
+        ];
+        for (item, expected) in data.iter() {
+            let mut calc = Calculation::new(Operand::LessThanEqual);
+            calc.add_value(item.clone());
+            calc.add_value(data[1].0.clone());
+            let result = calc.calculate(&Field::None);
+            assert_eq!(&result, expected);
+        }
+    }
+
     #[test]
     fn can_add_numbers() {
         let mut calc = Calculation::new(Operand::Add);