From a1d0a0aee8f65365f1246c91a92c1a13dbb74c05 Mon Sep 17 00:00:00 2001
From: Tjaden Hess <tah83@cornell.edu>
Date: Wed, 31 Oct 2018 17:57:57 -0400
Subject: [PATCH] Implement Le, Gt, Ge

---
 .../examples/comparison_operators.code        |  8 +++
 zokrates_core/src/flatten/mod.rs              | 54 ++++++++++++++++++-
 2 files changed, 61 insertions(+), 1 deletion(-)
 create mode 100644 zokrates_cli/examples/comparison_operators.code

diff --git a/zokrates_cli/examples/comparison_operators.code b/zokrates_cli/examples/comparison_operators.code
new file mode 100644
index 00000000..e7f8c73f
--- /dev/null
+++ b/zokrates_cli/examples/comparison_operators.code
@@ -0,0 +1,8 @@
+// comparison operator example
+def main(field x) -> (field):
+  field y = if x >= 3 then 1 else 5 fi
+  field z = if y <= x then x**3 else y**3 fi
+  y = if x < 3 then 2 else 6 fi
+  z = if y > z then 1 else 2 fi
+  x = if x == x then x else y fi
+  return x + y + z
diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs
index ab9da03c..797fdef9 100644
--- a/zokrates_core/src/flatten/mod.rs
+++ b/zokrates_core/src/flatten/mod.rs
@@ -355,13 +355,31 @@ impl Flattener {
 
                 FlatExpression::Identifier(name_1_y)
             },
+            BooleanExpression::Le(box lhs, box rhs) => {
+                let lt = self.flatten_boolean_expression(functions_flattened,
+                                                         arguments_flattened,
+                                                         statements_flattened,
+                                                         BooleanExpression::Lt(box lhs.clone(), box rhs.clone()));
+                let eq = self.flatten_boolean_expression(functions_flattened,
+                                                         arguments_flattened,
+                                                         statements_flattened,
+                                                         BooleanExpression::Eq(box lhs.clone(), box rhs.clone()));
+                FlatExpression::Add(box eq, box lt)
+            }
+            BooleanExpression::Gt(lhs, rhs) => self.flatten_boolean_expression(functions_flattened,
+                                                                               arguments_flattened,
+                                                                               statements_flattened,
+                                                                               BooleanExpression::Lt(rhs, lhs)),
+            BooleanExpression::Ge(lhs, rhs) => self.flatten_boolean_expression(functions_flattened,
+                                                                               arguments_flattened,
+                                                                               statements_flattened,
+                                                                               BooleanExpression::Le(rhs, lhs)),
             BooleanExpression::Value(b) => {
                 FlatExpression::Number(match b {
                     true => T::from(1),
                     false => T::from(0)
                 })
             }
-            _ => unimplemented!(),
         }
     }
 
@@ -1746,6 +1764,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn geq_leq() {
+        let expression_le =
+            BooleanExpression::Le(
+                box FieldElementExpression::Number(FieldPrime::from(32)),
+                box FieldElementExpression::Number(FieldPrime::from(4))
+            );
+
+        let expression_ge =
+            BooleanExpression::Ge(
+                box FieldElementExpression::Number(FieldPrime::from(32)),
+                box FieldElementExpression::Number(FieldPrime::from(4))
+            );
+
+        let mut functions_flattened = vec![];
+        let mut flattener = Flattener::new(FieldPrime::get_required_bits());
+
+        flattener.load_corelib(&mut functions_flattened);
+
+        flattener.flatten_boolean_expression(
+            &functions_flattened,
+            &vec![],
+            &mut vec![],
+            expression_le
+        );
+
+        flattener.flatten_boolean_expression(
+            &functions_flattened,
+            &vec![],
+            &mut vec![],
+            expression_ge
+        );
+    }
+
     #[test]
     fn field_array() {