fix: the rewritten coefficient still had an overflow, in the product

Attacking the previous commit rather than trusting it. Writing the filter
coefficient as `1 / (1 + tau * rate)` removed the overflow in `1 / rate`, and
left one in `tau * rate`: the product goes infinite where neither factor does,
`1 / inf` is 0, and an actuator whose coefficient is 0 never moves. Measured,
tau=1e200 at 1e200 Hz holds its initial 0.5 against a command of 0.25 for the
whole flight. That is the same silent freeze the demand-rate check further up
exists to prevent, so it raises now.

The bound is nowhere near anything real. A 0.01 s time constant at 100 Hz gives
0.5, and 10 s at 1000 Hz gives 1e-4. A small coefficient is what a slow actuator
is; only zero is broken, and only overflow reaches it.

Also restructure the ordering check in the range validator. It was written as
`not lower <= upper` to reject a pair of NaNs, which every ordered comparison
lets through. That reads as a double negative and pylint refuses it as C0117,
which is what turned the Linters job red. Naming NaN first and then comparing
says the same thing in the order a reader expects. Taking pylint's own
suggestion verbatim would have been a bug: `lower > upper` is false for two
NaNs.

The linter gate is the exit code, which is a bitmask, and not the score. The
score stays at 10.00/10 with a convention message present, which is how this got
pushed red. The three I0021 useless-suppression notes in motor.py, sensor.py and
stochastic_rocket.py are information messages, set no bit, and are left alone.

Signed-off-by: thc1006 <84045975+thc1006@users.noreply.github.com>

Author: thc1006

rocketpy/rocket/actuator/actuator.py

@@ -79,9 +79,13 @@ def _range_or_raise(value, description):
         upper = float(upper)
     except (TypeError, ValueError) as error:
         raise ValueError(f"{description} endpoints must be numbers.") from error
-    # Written as a positive test because NaN fails every ordered comparison, so
-    # a range of two NaNs would slip through a check phrased as a negation.
-    if not lower <= upper:
+    # NaN is named rather than left to the ordering check below. It fails every
+    # ordered comparison, so `lower > upper` waves a pair of NaNs through and
+    # `not lower <= upper` catches them only as a side effect, which reads as a
+    # double negative to a reader and as C0117 to pylint.
+    if np.isnan(lower) or np.isnan(upper):
+        raise ValueError(f"{description} endpoints must not be NaN.")
+    if lower > upper:
         raise ValueError(f"{description}[0] must be <= {description}[1].")
     if lower == np.inf or upper == -np.inf:
         raise ValueError(
@@ -210,6 +214,19 @@ def _update_iir_coefficients(self):
                 self._alpha = 1.0 / (
                     1.0 + self.actuator_time_constant * self.demand_rate
                 )
+                # The product can still overflow where neither factor does, and
+                # 1 / inf is 0, which is a filter that never moves: measured,
+                # tau=1e200 with a rate of 1e200 leaves an actuator that ignores
+                # every command and holds its initial output for the whole
+                # flight. Silence is the wrong answer to that, and the bound is
+                # not near anything real. A time constant of 0.01 s at 100 Hz
+                # gives 0.5, and 10 s at 1000 Hz gives 1e-4.
+                if self._alpha <= 0.0:
+                    raise ValueError(
+                        f"Actuator '{self.name}' time constant "
+                        f"{self.actuator_time_constant} and demand rate "
+                        f"{self.demand_rate} give a filter that cannot respond."
+                    )
             else:
                 warnings.warn(
                     f"Actuator time constant currently only implemented on discrete controllers. '{self.name}' dynamics not applied."

tests/unit/rocket/test_actuators.py

@@ -872,3 +872,43 @@ def test_the_controller_rate_is_usable_as_a_time_step(self, calisto, adder, extr
         controller = calisto._controllers[-1]
 
         assert 1 / controller.sampling_rate == pytest.approx(0.01)
+
+
+class TestAFilterThatCannotRespondIsRefused:
+    """The rewritten coefficient removed one overflow and left a second.
+
+    ``tau * demand_rate`` can overflow where neither factor does, and ``1 / inf``
+    is 0, which is a filter that never moves. Measured: an actuator built that
+    way holds its initial output against every command for the whole flight.
+    """
+
+    @pytest.mark.parametrize(
+        "time_constant, demand_rate", [(1e200, 1e200), (1e308, 1e10), (1e154, 1e155)]
+    )
+    def test_a_coefficient_that_overflows_to_zero_is_refused(
+        self, time_constant, demand_rate
+    ):
+        with pytest.raises(ValueError, match="cannot respond"):
+            ThrottleActuator(
+                demand_rate=demand_rate,
+                throttle_time_constant=time_constant,
+                throttle_range=(0.0, 1.0),
+                initial_throttle=0.5,
+            )
+
+    @pytest.mark.parametrize(
+        "time_constant, demand_rate, expected",
+        [(0.01, 100.0, 0.5), (10.0, 1000.0, 1e-4)],
+    )
+    def test_a_slow_actuator_is_still_allowed(
+        self, time_constant, demand_rate, expected
+    ):
+        """The half that stops this being satisfied by refusing slow actuators.
+        A small coefficient is what a slow actuator is; only zero is broken."""
+        actuator = ThrottleActuator(
+            demand_rate=demand_rate,
+            throttle_time_constant=time_constant,
+            throttle_range=(0.0, 1.0),
+        )
+
+        assert actuator._alpha == pytest.approx(expected, rel=1e-3)