Fix all lint issues: formatting, raw pointers, strict float comparison, Julia fmt

Author: ciaranra

crates/pecos-foreign/tests/conformance_test.rs

@@ -1,8 +1,8 @@
 //! Test the conformance suite itself by running it against a real simulator
-//! wrapped as a ForeignSimulator.
+//! wrapped as a `ForeignSimulator`.
 //!
-//! We wrap PECOS's SparseStab in C-ABI callbacks and run the conformance tests.
-//! Since SparseStab is a correct Clifford simulator, all tests must pass.
+//! We wrap PECOS's `SparseStab` in C-ABI callbacks and run the conformance tests.
+//! Since `SparseStab` is a correct Clifford simulator, all tests must pass.
 
 use pecos_core::QubitId;
 use pecos_foreign::conformance::run_conformance_tests;
@@ -11,7 +11,7 @@ use pecos_simulators::{CliffordGateable, SparseStab};
 
 use std::cell::UnsafeCell;
 
-/// Wrap SparseStab behind C-ABI function pointers.
+/// Wrap `SparseStab` behind C-ABI function pointers.
 /// This is a "real" foreign simulator -- same interface a Go/C author would use.
 struct SimHolder {
     sim: UnsafeCell<SparseStab>,

crates/pecos-foreign/tests/engine_test.rs

@@ -28,7 +28,7 @@ unsafe fn run_circuit(
 
     let mut circuit_bytes: *mut u8 = std::ptr::null_mut();
     let mut circuit_len: usize = 0;
-    unsafe { pecos_circuit_build(circuit, &mut circuit_bytes, &mut circuit_len) };
+    unsafe { pecos_circuit_build(circuit, &raw mut circuit_bytes, &raw mut circuit_len) };
     unsafe { pecos_circuit_free(circuit) };
 
     // Process
@@ -39,8 +39,8 @@ unsafe fn run_circuit(
             engine,
             circuit_bytes,
             circuit_len,
-            &mut output_bytes,
-            &mut output_len,
+            &raw mut output_bytes,
+            &raw mut output_len,
         )
     };
     unsafe { pecos_free_bytes(circuit_bytes, circuit_len) };
@@ -53,23 +53,21 @@ unsafe fn run_circuit(
         pecos_parse_outcomes(
             output_bytes,
             output_len,
-            &mut outcomes_ptr,
-            &mut num_outcomes,
+            &raw mut outcomes_ptr,
+            &raw mut num_outcomes,
         )
     };
     unsafe { pecos_free_bytes(output_bytes, output_len) };
     assert_eq!(rc, 0, "parse outcomes failed");
 
-    let results = if num_outcomes > 0 && !outcomes_ptr.is_null() {
+    if num_outcomes > 0 && !outcomes_ptr.is_null() {
         let slice = unsafe { std::slice::from_raw_parts(outcomes_ptr, num_outcomes) };
         let v = slice.to_vec();
         unsafe { pecos_free_outcomes(outcomes_ptr, num_outcomes) };
         v
     } else {
         vec![]
-    };
-
-    results
+    }
 }
 
 #[test]
@@ -105,7 +103,7 @@ fn test_bell_state_correlation() {
                 let q0: usize = 0;
                 let q1: usize = 1;
                 let pair = [q0, q1];
-                pecos_circuit_h(c, &q0, 1);
+                pecos_circuit_h(c, &raw const q0, 1);
                 pecos_circuit_cx(c, pair.as_ptr(), 1);
                 pecos_circuit_mz(c, [q0, q1].as_ptr(), 2);
             })
@@ -131,8 +129,8 @@ fn test_deterministic_x_gate() {
     let outcomes = unsafe {
         run_circuit(engine, |c| {
             let q: usize = 0;
-            pecos_circuit_x(c, &q, 1);
-            pecos_circuit_mz(c, &q, 1);
+            pecos_circuit_x(c, &raw const q, 1);
+            pecos_circuit_mz(c, &raw const q, 1);
         })
     };
 
@@ -148,8 +146,8 @@ fn test_circuit_reuse() {
     let outcomes1 = unsafe {
         run_circuit(engine, |c| {
             let q: usize = 0;
-            pecos_circuit_h(c, &q, 1);
-            pecos_circuit_mz(c, &q, 1);
+            pecos_circuit_h(c, &raw const q, 1);
+            pecos_circuit_mz(c, &raw const q, 1);
         })
     };
     assert_eq!(outcomes1.len(), 1);
@@ -177,8 +175,8 @@ fn test_rotation_gate() {
     let outcomes = unsafe {
         run_circuit(engine, |c| {
             let q: usize = 0;
-            pecos_circuit_rx(c, std::f64::consts::PI, &q, 1);
-            pecos_circuit_mz(c, &q, 1);
+            pecos_circuit_rx(c, std::f64::consts::PI, &raw const q, 1);
+            pecos_circuit_mz(c, &raw const q, 1);
         })
     };
 
@@ -189,26 +187,26 @@ fn test_rotation_gate() {
 #[test]
 fn test_circuit_builder_reset() {
     // Test that circuit builder reset works
-    let circuit = unsafe { pecos_circuit_new() };
+    let circuit = pecos_circuit_new();
 
     // Build first circuit
     unsafe {
         let q: usize = 0;
-        pecos_circuit_h(circuit, &q, 1);
+        pecos_circuit_h(circuit, &raw const q, 1);
     }
     let mut bytes1: *mut u8 = std::ptr::null_mut();
     let mut len1: usize = 0;
-    unsafe { pecos_circuit_build(circuit, &mut bytes1, &mut len1) };
+    unsafe { pecos_circuit_build(circuit, &raw mut bytes1, &raw mut len1) };
 
     // Reset and build second circuit
     unsafe { pecos_circuit_reset(circuit) };
     unsafe {
         let q: usize = 0;
-        pecos_circuit_x(circuit, &q, 1);
+        pecos_circuit_x(circuit, &raw const q, 1);
     }
     let mut bytes2: *mut u8 = std::ptr::null_mut();
     let mut len2: usize = 0;
-    unsafe { pecos_circuit_build(circuit, &mut bytes2, &mut len2) };
+    unsafe { pecos_circuit_build(circuit, &raw mut bytes2, &raw mut len2) };
 
     // Both should produce valid circuits
     assert!(len1 > 0);

crates/pecos-foreign/tests/foreign_decoder_test.rs

@@ -1,7 +1,7 @@
-//! Integration test for ForeignDecoder.
+//! Integration test for `ForeignDecoder`.
 //!
 //! Implements a trivial "XOR decoder" as C-ABI functions in Rust, wraps it
-//! into a ForeignDecoder, and verifies it works through the Decoder trait.
+//! into a `ForeignDecoder`, and verifies it works through the Decoder trait.
 
 use ndarray::array;
 use pecos_decoder_core::Decoder;
@@ -122,7 +122,7 @@ fn test_foreign_decoder_basic() {
 
     // XOR of [0, 1, 0, 1] = 0
     assert_eq!(result.observable, vec![0, 0]);
-    assert_eq!(result.weight, 1.0);
+    assert!((result.weight - 1.0).abs() < f64::EPSILON);
     assert_eq!(result.converged, Some(true));
 }
 

crates/pecos-foreign/tests/foreign_simulator_test.rs

@@ -1,7 +1,7 @@
-//! Integration test for ForeignSimulator.
+//! Integration test for `ForeignSimulator`.
 //!
 //! Implements a toy computational-basis simulator as C-ABI functions, wraps it
-//! into a ForeignSimulator, and verifies it works through CliffordGateable.
+//! into a `ForeignSimulator`, and verifies it works through `CliffordGateable`.
 //!
 //! The toy simulator only tracks classical bit flips -- it's not a real quantum
 //! simulator, but it exercises the full vtable -> trait pipeline.

crates/pecos-foreign/tests/neo_integration_test.rs

@@ -1,7 +1,7 @@
-//! Integration test: ForeignSimulator with pecos-neo's CircuitRunner.
+//! Integration test: `ForeignSimulator` with pecos-neo's `CircuitRunner`.
 //!
 //! Proves that a foreign simulator (C-ABI vtable) can be used with
-//! pecos-neo's typed command system -- no ByteMessage serialization needed.
+//! pecos-neo's typed command system -- no `ByteMessage` serialization needed.
 
 use pecos_core::QubitId;
 use pecos_foreign::{ForeignMeasurementResult, ForeignSimulator, ForeignSimulatorVTable};

crates/pecos-selene-core/tests/adapter_conformance_test.rs

@@ -1,6 +1,6 @@
-//! Verify the SeleneAdapter works with Selene's own conformance test suite.
+//! Verify the `SeleneAdapter` works with Selene's own conformance test suite.
 //!
-//! Tests both rotation-capable (StateVec) and Clifford-only (Stabilizer) paths.
+//! Tests both rotation-capable (`StateVec`) and Clifford-only (Stabilizer) paths.
 
 use anyhow::{Result, anyhow};
 use pecos_core::{Angle64, QubitId};

docs/development/foreign-plugins.md

@@ -78,6 +78,7 @@ A decoder plugin implements 3 methods:
 ```python
 import pecos_rslib
 
+
 class MyDecoder:
     def __init__(self, checks, bits):
         self._checks = checks
@@ -94,6 +95,7 @@ class MyDecoder:
     def bit_count(self) -> int:
         return self._bits
 
+
 # Wrap and use
 decoder = pecos_rslib.PyForeignDecoder(MyDecoder(100, 50))
 result = decoder.decode(syndrome_bytes)
@@ -204,6 +206,7 @@ For universal (non-Clifford) simulators, add 3 rotation methods. All other rotat
 ```python
 import pecos_rslib
 
+
 class MyStabilizerSim:
     def __init__(self, n):
         self.n = n
@@ -224,14 +227,15 @@ class MyStabilizerSim:
     def mz(self, qubits: list[int]) -> list[tuple[bool, bool]]:
         results = []
         for q in qubits:
-            outcome = False       # measurement outcome
+            outcome = False  # measurement outcome
             deterministic = True  # whether outcome was deterministic
             results.append((outcome, deterministic))
         return results
 
     def reset(self):
         pass  # reset to |0...0>
 
+
 sim = pecos_rslib.PyForeignSimulator(MyStabilizerSim(10))
 ```
 

julia/PECOS.jl/src/Decoder.jl

@@ -49,7 +49,7 @@ struct DecodingResult
     """Weight/cost of the solution."""
     weight::Float64
     """Whether the decoder converged (nothing = unknown)."""
-    converged::Union{Bool, Nothing}
+    converged::Union{Bool,Nothing}
 end
 
 DecodingResult(observable, weight) = DecodingResult(observable, weight, nothing)
@@ -58,9 +58,10 @@ DecodingResult(observable, weight) = DecodingResult(observable, weight, nothing)
 Abstract type for all PECOS-compatible decoders.
 
 Subtypes must implement:
-- `decode(d, syndrome::Vector{UInt8}) -> DecodingResult`
-- `check_count(d) -> Int`
-- `bit_count(d) -> Int`
+
+  - `decode(d, syndrome::Vector{UInt8}) -> DecodingResult`
+  - `check_count(d) -> Int`
+  - `bit_count(d) -> Int`
 """
 abstract type AbstractDecoder end
 
@@ -78,7 +79,7 @@ function bit_count end
 
 # Global registry: maps Ptr{Cvoid} handles to Julia decoder objects.
 # Julia objects can't cross FFI directly, so we use integer handles.
-const _decoder_registry = Dict{UInt, AbstractDecoder}()
+const _decoder_registry = Dict{UInt,AbstractDecoder}()
 const _decoder_next_handle = Ref{UInt}(0)
 const _decoder_lock = ReentrantLock()
 
@@ -97,7 +98,7 @@ function _unregister_decoder(handle::Ptr{Cvoid})
     end
 end
 
-function _lookup_decoder(handle::Ptr{Cvoid})::Union{AbstractDecoder, Nothing}
+function _lookup_decoder(handle::Ptr{Cvoid})::Union{AbstractDecoder,Nothing}
     lock(_decoder_lock) do
         get(_decoder_registry, UInt(handle), nothing)
     end

julia/PECOS.jl/src/Simulator.jl

@@ -89,7 +89,7 @@ function rzz! end
 # Registry (same pattern as Decoder.jl)
 # ============================================================================
 
-const _sim_registry = Dict{UInt, AbstractCliffordSimulator}()
+const _sim_registry = Dict{UInt,AbstractCliffordSimulator}()
 const _sim_next_handle = Ref{UInt}(0)
 const _sim_lock = ReentrantLock()
 
@@ -108,7 +108,7 @@ function _unregister_simulator(handle::Ptr{Cvoid})
     end
 end
 
-function _lookup_simulator(handle::Ptr{Cvoid})::Union{AbstractCliffordSimulator, Nothing}
+function _lookup_simulator(handle::Ptr{Cvoid})::Union{AbstractCliffordSimulator,Nothing}
     lock(_sim_lock) do
         get(_sim_registry, UInt(handle), nothing)
     end