Remove redundant arguments in macro calls where dt is 1.0

Author: mtilda

src/lib.rs

@@ -405,14 +405,14 @@ mod tests {
         pid.p(0.0, 100.0).i(0.0, 100.0).d(2.0, 100.0);
 
         // Test that there's no derivative since it's the first measurement
-        assert_eq!(pid_next_control_output!(pid, 0.0, 1.0).output, 0.0);
+        assert_eq!(pid_next_control_output!(pid, 0.0).output, 0.0);
 
         // Test that there's now a derivative
-        assert_eq!(pid_next_control_output!(pid, 5.0, 1.0).output, -10.0);
+        assert_eq!(pid_next_control_output!(pid, 5.0).output, -10.0);
 
         // Test derivative limit
         pid.d_limit = 5.0;
-        assert_eq!(pid_next_control_output!(pid, 10.0, 1.0).output, -5.0);
+        assert_eq!(pid_next_control_output!(pid, 10.0).output, -5.0);
     }
 
     /// Integral-only controller operation and limits
@@ -422,26 +422,26 @@ mod tests {
         pid.p(0.0, 100.0).i(2.0, 100.0).d(0.0, 100.0);
 
         // Test basic integration
-        assert_eq!(pid_next_control_output!(pid, 0.0, 1.0).output, 20.0);
-        assert_eq!(pid_next_control_output!(pid, 0.0, 1.0).output, 40.0);
-        assert_eq!(pid_next_control_output!(pid, 5.0, 1.0).output, 50.0);
+        assert_eq!(pid_next_control_output!(pid, 0.0).output, 20.0);
+        assert_eq!(pid_next_control_output!(pid, 0.0).output, 40.0);
+        assert_eq!(pid_next_control_output!(pid, 5.0).output, 50.0);
 
         // Test limit
         pid.i_limit = 50.0;
-        assert_eq!(pid_next_control_output!(pid, 5.0, 1.0).output, 50.0);
+        assert_eq!(pid_next_control_output!(pid, 5.0).output, 50.0);
         // Test that limit doesn't impede reversal of error integral
-        assert_eq!(pid_next_control_output!(pid, 15.0, 1.0).output, 40.0);
+        assert_eq!(pid_next_control_output!(pid, 15.0).output, 40.0);
 
         // Test that error integral accumulates negative values
         let mut pid2 = Pid::new(-10.0, 100.0);
         pid2.p(0.0, 100.0).i(2.0, 100.0).d(0.0, 100.0);
-        assert_eq!(pid_next_control_output!(pid2, 0.0, 1.0).output, -20.0);
-        assert_eq!(pid_next_control_output!(pid2, 0.0, 1.0).output, -40.0);
+        assert_eq!(pid_next_control_output!(pid2, 0.0).output, -20.0);
+        assert_eq!(pid_next_control_output!(pid2, 0.0).output, -40.0);
 
         pid2.i_limit = 50.0;
-        assert_eq!(pid_next_control_output!(pid2, -5.0, 1.0).output, -50.0);
+        assert_eq!(pid_next_control_output!(pid2, -5.0).output, -50.0);
         // Test that limit doesn't impede reversal of error integral
-        assert_eq!(pid_next_control_output!(pid2, -15.0, 1.0).output, -40.0);
+        assert_eq!(pid_next_control_output!(pid2, -15.0).output, -40.0);
     }
 
     /// Checks that a full PID controller's limits work properly through multiple output iterations
@@ -450,11 +450,11 @@ mod tests {
         let mut pid = Pid::new(10.0, 1.0);
         pid.p(1.0, 100.0).i(0.0, 100.0).d(0.0, 100.0);
 
-        let out = pid_next_control_output!(pid, 0.0, 1.0);
+        let out = pid_next_control_output!(pid, 0.0);
         assert_eq!(out.p, 10.0); // 1.0 * 10.0
         assert_eq!(out.output, 1.0);
 
-        let out = pid_next_control_output!(pid, 20.0, 1.0);
+        let out = pid_next_control_output!(pid, 20.0);
         assert_eq!(out.p, -10.0); // 1.0 * (10.0 - 20.0)
         assert_eq!(out.output, -1.0);
     }
@@ -465,25 +465,25 @@ mod tests {
         let mut pid = Pid::new(10.0, 100.0);
         pid.p(1.0, 100.0).i(0.1, 100.0).d(1.0, 100.0);
 
-        let out = pid_next_control_output!(pid, 0.0, 1.0);
+        let out = pid_next_control_output!(pid, 0.0);
         assert_eq!(out.p, 10.0); // 1.0 * 10.0
         assert_eq!(out.i, 1.0); // 0.1 * 10.0
         assert_eq!(out.d, 0.0); // -(1.0 * 0.0)
         assert_eq!(out.output, 11.0);
 
-        let out = pid_next_control_output!(pid, 5.0, 1.0);
+        let out = pid_next_control_output!(pid, 5.0);
         assert_eq!(out.p, 5.0); // 1.0 * 5.0
         assert_eq!(out.i, 1.5); // 0.1 * (10.0 + 5.0)
         assert_eq!(out.d, -5.0); // -(1.0 * 5.0)
         assert_eq!(out.output, 1.5);
 
-        let out = pid_next_control_output!(pid, 11.0, 1.0);
+        let out = pid_next_control_output!(pid, 11.0);
         assert_eq!(out.p, -1.0); // 1.0 * -1.0
         assert_eq!(out.i, 1.4); // 0.1 * (10.0 + 5.0 - 1)
         assert_eq!(out.d, -6.0); // -(1.0 * 6.0)
         assert_eq!(out.output, -5.6);
 
-        let out = pid_next_control_output!(pid, 10.0, 1.0);
+        let out = pid_next_control_output!(pid, 10.0);
         assert_eq!(out.p, 0.0); // 1.0 * 0.0
         assert_eq!(out.i, 1.4); // 0.1 * (10.0 + 5.0 - 1.0 + 0.0)
         assert_eq!(out.d, 1.0); // -(1.0 * -1.0)
@@ -502,8 +502,8 @@ mod tests {
 
         for _ in 0..5 {
             assert_eq!(
-                pid_next_control_output!(pid_f32, 0.0, 1.0).output,
-                pid_next_control_output!(pid_f64, 0.0, 1.0).output as f32
+                pid_next_control_output!(pid_f32, 0.0).output,
+                pid_next_control_output!(pid_f64, 0.0).output as f32
             );
         }
     }
@@ -532,7 +532,7 @@ mod tests {
         let mut pid = Pid::new(10.0, 100.0);
         pid.p(1.0, 100.0).i(0.1, 100.0).d(1.0, 100.0);
 
-        let out = pid_next_control_output!(pid, 0.0, 1.0);
+        let out = pid_next_control_output!(pid, 0.0);
         assert_eq!(out.p, 10.0); // 1.0 * 10.0
         assert_eq!(out.i, 1.0); // 0.1 * 10.0
         assert_eq!(out.d, 0.0); // -(1.0 * 0.0)
@@ -541,7 +541,7 @@ mod tests {
         pid.setpoint(0.0);
 
         assert_eq!(
-            pid_next_control_output!(pid, 0.0, 1.0),
+            pid_next_control_output!(pid, 0.0),
             ControlOutput {
                 p: 0.0,
                 i: 1.0,
@@ -557,7 +557,7 @@ mod tests {
         let mut pid = Pid::new(10.0f32, -10.0);
         pid.p(1.0, -50.0).i(1.0, -50.0).d(1.0, -50.0);
 
-        let out = pid_next_control_output!(pid, 0.0, 1.0);
+        let out = pid_next_control_output!(pid, 0.0);
         assert_eq!(out.p, 10.0);
         assert_eq!(out.i, 10.0);
         assert_eq!(out.d, 0.0);