Update: use lexical for writing floating point values

Cargo.toml

@@ -11,11 +11,10 @@ categories = ["parser-implementations", "science", "compilers", "emulators"]
 [dependencies]
 dot-writer = { version = "0.1.2", optional = true }
 indexmap = "1.6.1"
-lexical = "5.2.0"
+lexical = "6.1.1" 
 nom = "6.1.0"
 num-complex = "0.4.0"
 petgraph = "0.5.1"
-ryu = "1.0.10"
 serde = { version = "1.0.125", features = ["derive"] }
 thiserror = "1.0.30"
 

src/expression.rs

@@ -17,6 +17,7 @@ use std::collections::{hash_map::DefaultHasher, HashMap};
 use std::f64::consts::PI;
 use std::fmt;
 use std::hash::{Hash, Hasher};
+use std::num::NonZeroI32;
 use std::str::FromStr;
 
 #[cfg(test)]
@@ -435,16 +436,29 @@ impl<'a> FromStr for Expression {
 /// - When both are non-zero, show with the correct operator in between
 #[inline(always)]
 fn format_complex(value: &Complex64) -> String {
+    const FORMAT: u128 = lexical::format::STANDARD;
+    let options = lexical::WriteFloatOptions::builder()
+        .negative_exponent_break(NonZeroI32::new(-5))
+        .positive_exponent_break(NonZeroI32::new(15))
+        .trim_floats(true)
+        .build()
+        .unwrap();
     if value.re == 0f64 && value.im == 0f64 {
         "0".to_owned()
     } else if value.im == 0f64 {
-        ryu::Buffer::new().format(value.re).to_owned()
+        lexical::to_string_with_options::<_, FORMAT>(value.re, &options)
     } else if value.re == 0f64 {
-        ryu::Buffer::new().format(value.im).to_owned() + "i"
+        lexical::to_string_with_options::<_, FORMAT>(value.im, &options) + "i"
     } else {
-        let mut buf = ryu::Buffer::new();
-        let op = if value.im > 0f64 { "+" } else { "" };
-        buf.format(value.re).to_owned() + op + buf.format(value.im) + "i"
+        let mut out = lexical::to_string_with_options::<_, FORMAT>(value.re, &options);
+        if value.im > 0f64 {
+            out.push_str("+")
+        }
+        out.push_str(&lexical::to_string_with_options::<_, FORMAT>(
+            value.im, &options,
+        ));
+        out.push_str("i");
+        out
     }
 }
 

src/instruction.rs

@@ -886,7 +886,7 @@ impl Instruction {
     /// let mut instructions = program.to_instructions(true);
     /// instructions.iter_mut().for_each(|inst| inst.apply_to_expressions(Expression::simplify));
     ///
-    /// assert_eq!(instructions[0].to_string(), String::from("SHIFT-PHASE 0 \"rf\" 4.0"))
+    /// assert_eq!(instructions[0].to_string(), String::from("SHIFT-PHASE 0 \"rf\" 4"))
     ///
     /// ```
     pub fn apply_to_expressions(&mut self, mut closure: impl FnMut(&mut Expression)) {

src/parser/expression.rs

@@ -261,8 +261,8 @@ mod tests {
         let cases = vec![
             "pi",
             "sin(pi)",
-            "(1.0+(2.0*3.0))",
-            "((1.0+2.0)*3.0)",
+            "(1+(2*3))",
+            "((1+2)*3)",
             "%theta",
             "cis(%theta)",
             "(%a+%b)",

src/program/calibration.rs

@@ -353,9 +353,9 @@ mod tests {
                     "RX(pi/2) 0\n"
                 ),
                 expected: concat!(
-                    "PULSE 1 \"xy\" gaussian(duration: 1.0, fwhm: 2.0, t0: 3.0)\n",
-                    "PULSE 2 \"xy\" gaussian(duration: 1.0, fwhm: 2.0, t0: 3.0)\n",
-                    "PULSE 3 \"xy\" gaussian(duration: 1.0, fwhm: 2.0, t0: 3.0)\n"
+                    "PULSE 1 \"xy\" gaussian(duration: 1, fwhm: 2, t0: 3)\n",
+                    "PULSE 2 \"xy\" gaussian(duration: 1, fwhm: 2, t0: 3)\n",
+                    "PULSE 3 \"xy\" gaussian(duration: 1, fwhm: 2, t0: 3)\n"
                 ),
             },
             TestCase {
@@ -364,7 +364,7 @@ mod tests {
                     "    PULSE 0 \"xy\" gaussian(duration: 1, fwhm: 2, t0: 3)\n",
                     "X 0\n"
                 ),
-                expected: "PULSE 0 \"xy\" gaussian(duration: 1.0, fwhm: 2.0, t0: 3.0)\n",
+                expected: "PULSE 0 \"xy\" gaussian(duration: 1, fwhm: 2, t0: 3)\n",
             },
             TestCase {
                 input: concat!(
@@ -374,7 +374,7 @@ mod tests {
                     "    PULSE 0 \"xy\" gaussian(duration: 1, fwhm: 2, t0: 3)\n",
                     "X 0\n"
                 ),
-                expected: "PULSE 0 \"xy\" gaussian(duration: 1.0, fwhm: 2.0, t0: 3.0)\n",
+                expected: "PULSE 0 \"xy\" gaussian(duration: 1, fwhm: 2, t0: 3)\n",
             },
             TestCase {
                 input: concat!(

src/program/mod.rs

@@ -272,7 +272,7 @@ DEFCAL I 0:
 DEFFRAME 0 \"rx\":
     HARDWARE-OBJECT: \"hardware\"
 DEFWAVEFORM custom:
-    1.0, 2.0
+    1, 2
 I 0
 ";
         let program = Program::from_str(input).unwrap();
@@ -290,9 +290,9 @@ I 0
 DEFFRAME 0 \"rx\":
 \tHARDWARE-OBJECT: \"hardware\"
 DEFWAVEFORM custom:
-\t1.0, 2.0
+\t1, 2
 DEFCAL I 0:
-\tDELAY 0 1.0
+\tDELAY 0 1
 I 0
 "
         );