fix: make NaN == NaN inside Expression

This is the easiest way to resolve #316 in a way that doesn't break the
API (the other way being to use `OrderedFloat`).

quil-rs/proptest-regressions/expression/mod.txt

@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 0c84b97c710f57935dd9b81feff3bd3c65662286d475e4d0c02c5b89c4911e9a # shrinks to e = Infix(InfixExpression { left: Address(MemoryReference { name: "aa", index: 0 }), operator: Slash, right: Infix(InfixExpression { left: PiConstant, operator: Minus, right: PiConstant }) })

quil-rs/src/expression/mod.rs

@@ -115,7 +115,9 @@ impl PartialEq for Expression {
         match (self, other) {
             (Self::Address(left), Self::Address(right)) => left == right,
             (Self::Infix(left), Self::Infix(right)) => left == right,
-            (Self::Number(left), Self::Number(right)) => left == right,
+            (Self::Number(left), Self::Number(right)) => {
+                (left.re == right.re || left.re.is_nan() && right.re.is_nan()) && (left.im == right.im || left.im.is_nan() && right.im.is_nan())                            
+            },
             (Self::Prefix(left), Self::Prefix(right)) => left == right,
             (Self::FunctionCall(left), Self::FunctionCall(right)) => left == right,
             (Self::Variable(left), Self::Variable(right)) => left == right,
@@ -990,6 +992,7 @@ mod tests {
             prop_assert!(p.is_ok());
             let p = p.unwrap();
             let simple_p = p.clone().into_simplified();
+
             prop_assert_eq!(
                 simple_p.clone(),
                 simple_e.clone(),
@@ -1018,13 +1021,21 @@ mod tests {
             assert_eq!(input, &restring);
         }
     }
+
+    #[test]
+    fn test_nan_is_equal() {
+        let left = Expression::Number(f64::NAN.into());
+        let right = left.clone();
+        assert_eq!(left, right);
+    }
 
     #[test]
     fn specific_simplification_tests() {
         for (input, expected) in vec![
             ("pi", Expression::Number(PI.into())),
             ("pi/2", Expression::Number((PI / 2.0).into())),
             ("pi * pi", Expression::Number((PI.powi(2)).into())),
+            ("1.0/(1.0-1.0)", Expression::Number(f64::NAN.into())),
             (
                 "(a[0]*2*pi)/6.283185307179586",
                 Expression::Address(MemoryReference {