Fixed Linting and formatting

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality_uncertain/benches/uncertain_benchmarks.rs

@@ -1,5 +1,5 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-use deep_causality_uncertain::{Uncertain, with_global_cache, SampledValue};
+use criterion::{Criterion, criterion_group, criterion_main};
+use deep_causality_uncertain::{SampledValue, Uncertain, with_global_cache};
 
 // --- Sampling Performance Benchmarks ---
 
@@ -174,4 +174,4 @@ criterion_group!(
     bench_sampling_with_cache_hits,
     bench_sampling_with_cache_misses,
 );
-criterion_main!(benches);
+criterion_main!(benches);

deep_causality_uncertain/examples/sensor/sensor_processing.rs

@@ -366,7 +366,7 @@ fn sensor_fusion_with_errors(
     // Detect sensor disagreement
     let temp_values: Vec<f64> = temp_sensors
         .iter()
-        .map(|(_, temp)| temp.expected_value(100).unwrap().clone())
+        .map(|(_, temp)| temp.expected_value(100).unwrap())
         .collect();
 
     if temp_values.len() > 1 {

deep_causality_uncertain/src/types/cache/global_cache.rs

@@ -98,11 +98,11 @@ impl GlobalSampleCache {
 //
 /// Global static instance of the cache, initialized once.
 #[cfg(not(test))]
-static GLOBAL_SAMPLE_CACHE: OnceLock<GlobalSampleCache> = OnceLock::new();
+static GLOBAL_SAMPLE_CACHE: OnceLock<GlobalSampleCache> = const { OnceLock::new() };
 
 #[cfg(test)]
 thread_local! {
-    static GLOBAL_SAMPLE_CACHE: OnceLock<GlobalSampleCache> = OnceLock::new();
+    static GLOBAL_SAMPLE_CACHE: OnceLock<GlobalSampleCache> = const { OnceLock::new() };
 }
 
 /// Executes a closure with a reference to the global sample cache.

deep_causality_uncertain/tests/algos/hypothesis/sprt_eval_tests.rs

@@ -67,6 +67,7 @@ rusty_fork_test! {
         assert!(!sprt_eval::evaluate_hypothesis(&ub_low, 1.0, 0.95, 0.01, 10, 0).unwrap());
     }
 
+    #[allow(clippy::bool_comparison)]
     #[test]
     fn test_evaluate_hypothesis_epsilon_effect() {
         // Test with a distribution that's exactly on the threshold
@@ -103,6 +104,7 @@ rusty_fork_test! {
         assert!(result_low_conf, "Should conclude true with low confidence");
     }
 
+    #[allow(clippy::bool_comparison)]
     #[test]
     fn test_evaluate_hypothesis_initial_sample_index() {
         // Test that initial_sample_index is used correctly

deep_causality_uncertain/tests/types/computation/node/node_tests.rs

@@ -28,7 +28,7 @@ fn test_computation_node_leaf_bool_construction_and_clone() {
     let cloned_node = node.clone();
 
     match cloned_node {
-        ComputationNode::LeafBool(DistributionEnum::Point(val)) => assert_eq!(val, true),
+        ComputationNode::LeafBool(DistributionEnum::Point(val)) => assert!(val),
         _ => panic!("Cloned node is not LeafBool(Point)"),
     }
 }
@@ -148,7 +148,7 @@ fn test_computation_node_function_op_bool_construction_and_clone() {
             operand: cloned_operand,
         } => {
             // Cannot directly compare Arc<dyn Fn>
-            assert_eq!(cloned_func(3.0), true); // Test the function still works
+            assert!(cloned_func(3.0)); // Test the function still works
             assert!(matches!(*cloned_operand, ComputationNode::LeafF64(_)));
         }
         _ => panic!("Cloned node is not FunctionOpBool"),

deep_causality_uncertain/tests/types/computation/operator/arithmetic_operator_tests.rs

@@ -48,9 +48,9 @@ fn test_arithmetic_operator_div() {
     assert_eq!(op.apply(6.0, -3.0), -2.0);
     assert_eq!(op.apply(-6.0, -3.0), 2.0);
     assert_eq!(op.apply(0.0, 5.0), 0.0);
-    assert_eq!(op.apply(5.0, 0.0).is_infinite(), true); // Division by zero is positive infinity
-    assert_eq!(op.apply(-5.0, 0.0).is_infinite(), true); // Division by zero is negative infinity
-    assert_eq!(op.apply(0.0, 0.0).is_nan(), true); // 0/0 is NaN
+    assert!(op.apply(5.0, 0.0).is_infinite()); // Division by zero is positive infinity
+    assert!(op.apply(-5.0, 0.0).is_infinite()); // Division by zero is negative infinity
+    assert!(op.apply(0.0, 0.0).is_nan()); // 0/0 is NaN
 }
 
 #[test]
@@ -69,7 +69,7 @@ fn test_arithmetic_operator_debug_clone_copy() {
     assert_eq!(format!("{:?}", op), "Add");
 
     // Test Clone
-    let cloned_op = op.clone();
+    let cloned_op = op;
     assert_eq!(cloned_op, op);
 
     // Test Copy (by assignment)

deep_causality_uncertain/tests/types/computation/operator/comparison_operator_tests.rs

@@ -60,7 +60,7 @@ fn test_comparison_operator_debug_clone_copy() {
     assert_eq!(format!("{:?}", op), "GreaterThan");
 
     // Test Clone
-    let cloned_op = op.clone();
+    let cloned_op = op;
     assert_eq!(cloned_op, op);
 
     // Test Copy (by assignment)

deep_causality_uncertain/tests/types/computation/operator/logical_operator_tests.rs

@@ -65,7 +65,7 @@ fn test_logical_operator_debug_clone_copy() {
     assert_eq!(format!("{:?}", op), "And");
 
     // Test Clone
-    let cloned_op = op.clone();
+    let cloned_op = op;
     assert_eq!(cloned_op, op);
 
     // Test Copy (by assignment)

deep_causality_uncertain/tests/types/distribution/distribution_tests.rs

@@ -33,10 +33,10 @@ fn test_distribution_enum_debug_clone_copy() {
     );
 
     // Test Clone
-    let cloned_point_f64 = point_f64.clone();
-    let cloned_normal = normal.clone();
-    let cloned_uniform = uniform.clone();
-    let cloned_bernoulli = bernoulli.clone();
+    let cloned_point_f64 = point_f64;
+    let cloned_normal = normal;
+    let cloned_uniform = uniform;
+    let cloned_bernoulli = bernoulli;
 
     assert!(matches!(cloned_point_f64, DistributionEnum::Point(1.0)));
     assert!(matches!(cloned_normal, DistributionEnum::Normal(_)));
@@ -84,7 +84,7 @@ fn test_distribution_enum_f64_sample_uniform() {
     let sample = dist.sample(&mut rng).unwrap();
     dbg!(&sample);
 
-    assert!(sample >= 0.0 && sample <= 1.0);
+    assert!((0.0..=1.0).contains(&sample));
 }
 
 #[test]
@@ -94,17 +94,17 @@ fn test_distribution_enum_bool_sample_point() {
     let sample = dist.sample(&mut rng).unwrap();
     dbg!(&sample);
 
-    assert_eq!(sample, true);
+    assert!(sample);
 }
 
+#[allow(clippy::bool_comparison)]
 #[test]
 fn test_distribution_enum_bool_sample_bernoulli() {
     let dist: DistributionEnum<bool> = DistributionEnum::Bernoulli(BernoulliParams::new(0.8));
     let mut rng = rng();
     let sample = dist.sample(&mut rng).unwrap();
-    // Cannot assert specific value due to randomness, but ensure it's a bool
     dbg!(&sample);
-
+    // Due to randomness, we can't assert exact equality, but they should both lean towards true
     assert!(sample == true || sample == false);
 }
 

deep_causality_uncertain/tests/types/distribution_parameters/bernoulli_params_tests.rs

@@ -28,7 +28,7 @@ fn test_bernoulli_params_debug_clone_copy() {
     assert_eq!(format!("{:?}", params), "BernoulliParams { p: 0.75 }");
 
     // Test Clone
-    let cloned_params = params.clone();
+    let cloned_params = params;
     assert_eq!(cloned_params.p, params.p);
 
     // Test Copy (by assignment)