From b0f266de1ecafe4dc27e159a1663a7c08c69d373 Mon Sep 17 00:00:00 2001
From: Kobi Gurkan <kobigurk@gmail.com>
Date: Mon, 23 Mar 2020 21:47:40 +0200
Subject: [PATCH] fmt

---
 r1cs-std/src/cmp.rs | 53 +++++++++++++++++++++++++++++++++++----------
 r1cs-std/src/lib.rs |  4 ++--
 2 files changed, 43 insertions(+), 14 deletions(-)

diff --git a/r1cs-std/src/cmp.rs b/r1cs-std/src/cmp.rs
index c7a660b..8ba9706 100644
--- a/r1cs-std/src/cmp.rs
+++ b/r1cs-std/src/cmp.rs
@@ -5,10 +5,7 @@ use crate::{
 };
 use algebra::PrimeField;
 use r1cs_core::{ConstraintSystem, SynthesisError};
-use std::{
-    cmp::Ordering,
-    marker::PhantomData
-};
+use std::{cmp::Ordering, marker::PhantomData};
 
 pub struct CmpGadget<ConstraintF: PrimeField> {
     constraint_field_type: PhantomData<ConstraintF>,
@@ -25,9 +22,17 @@ impl<ConstraintF: PrimeField> CmpGadget<ConstraintF> {
         let left;
         let right;
         match ordering {
-            Ordering::Less => { left = a; right = b; }
-            Ordering::Greater => {left = b; right = a; }
-            Ordering::Equal => { return Err(SynthesisError::Unsatisfiable); }
+            Ordering::Less => {
+                left = a;
+                right = b;
+            },
+            Ordering::Greater => {
+                left = b;
+                right = a;
+            },
+            Ordering::Equal => {
+                return Err(SynthesisError::Unsatisfiable);
+            },
         };
         let right_for_check = if should_also_check_equality {
             right.add_constant(cs.ns(|| "plus one"), &ConstraintF::one())?
@@ -41,7 +46,7 @@ impl<ConstraintF: PrimeField> CmpGadget<ConstraintF> {
     fn check_smaller_than_mod_minus_one_div_two<CS: ConstraintSystem<ConstraintF>>(
         mut cs: CS,
         a: &FpGadget<ConstraintF>,
-    ) -> Result<(), SynthesisError>  {
+    ) -> Result<(), SynthesisError> {
         let a_bits = a.to_bits(cs.ns(|| "a to bits"))?;
         Boolean::enforce_smaller_or_equal_than::<_, _, ConstraintF, _>(
             cs.ns(|| "enforce smaller than modulus minus one div two"),
@@ -60,7 +65,13 @@ impl<ConstraintF: PrimeField> CmpGadget<ConstraintF> {
         ordering: Ordering,
         should_also_check_equality: bool,
     ) -> Result<(), SynthesisError> {
-        let (left, right) = Self::process_cmp_inputs(cs.ns(|| "process cmp inputs"), a, b, ordering, should_also_check_equality)?;
+        let (left, right) = Self::process_cmp_inputs(
+            cs.ns(|| "process cmp inputs"),
+            a,
+            b,
+            ordering,
+            should_also_check_equality,
+        )?;
         Self::enforce_smaller_than_unchecked(cs.ns(|| "enforce smaller than"), &left, &right)
     }
 
@@ -72,7 +83,13 @@ impl<ConstraintF: PrimeField> CmpGadget<ConstraintF> {
         ordering: Ordering,
         should_also_check_equality: bool,
     ) -> Result<(), SynthesisError> {
-        let (left, right) = Self::process_cmp_inputs(cs.ns(|| "process cmp inputs"), a, b, ordering, should_also_check_equality)?;
+        let (left, right) = Self::process_cmp_inputs(
+            cs.ns(|| "process cmp inputs"),
+            a,
+            b,
+            ordering,
+            should_also_check_equality,
+        )?;
         Self::enforce_smaller_than(cs.ns(|| "enforce smaller than"), &left, &right)
     }
 
@@ -84,7 +101,13 @@ impl<ConstraintF: PrimeField> CmpGadget<ConstraintF> {
         ordering: Ordering,
         should_also_check_equality: bool,
     ) -> Result<Boolean, SynthesisError> {
-        let (left, right) = Self::process_cmp_inputs(cs.ns(|| "process cmp inputs"), a, b, ordering, should_also_check_equality)?;
+        let (left, right) = Self::process_cmp_inputs(
+            cs.ns(|| "process cmp inputs"),
+            a,
+            b,
+            ordering,
+            should_also_check_equality,
+        )?;
         Self::is_smaller_than(cs.ns(|| "enforce smaller than"), &left, &right)
     }
 
@@ -96,7 +119,13 @@ impl<ConstraintF: PrimeField> CmpGadget<ConstraintF> {
         ordering: Ordering,
         should_also_check_equality: bool,
     ) -> Result<Boolean, SynthesisError> {
-        let (left, right) = Self::process_cmp_inputs(cs.ns(|| "process cmp inputs"), a, b, ordering, should_also_check_equality)?;
+        let (left, right) = Self::process_cmp_inputs(
+            cs.ns(|| "process cmp inputs"),
+            a,
+            b,
+            ordering,
+            should_also_check_equality,
+        )?;
         Self::is_smaller_than_unchecked(cs.ns(|| "enforce smaller than"), &left, &right)
     }
 
diff --git a/r1cs-std/src/lib.rs b/r1cs-std/src/lib.rs
index 399fd0a..48c254c 100644
--- a/r1cs-std/src/lib.rs
+++ b/r1cs-std/src/lib.rs
@@ -60,21 +60,21 @@ pub use instantiated::jubjub;
 pub mod pairing;
 
 pub mod alloc;
+pub mod cmp;
 pub mod eq;
 pub mod select;
-pub mod cmp;
 
 pub mod prelude {
     pub use crate::{
         alloc::*,
         bits::{boolean::Boolean, uint32::UInt32, uint8::UInt8, ToBitsGadget, ToBytesGadget},
+        cmp::CmpGadget,
         eq::*,
         fields::FieldGadget,
         groups::GroupGadget,
         instantiated::*,
         pairing::PairingGadget,
         select::*,
-        cmp::CmpGadget,
     };
 }