Trim the checks that no real configuration can reach

@zuorenchen's point on reading this file is right, and it is worth writing down
as a rule rather than a mood: a check earns its place if it stops an honest run
being rejected, a dishonest one being accepted, or the program falling over for
someone. Three of these did none of those.

Gone: the range validator, which existed so `throttle_range=(inf, inf)` could
not clamp a finite value to infinity; the guard on the filter coefficient
overflowing to zero, which needs a time constant near 1e200; and the tests built
around a subnormal demand rate of 5e-324. None of those is a number anyone sets.
Their combined weight was 67 lines of implementation and 124 lines of tests
against a reader who has to get past them to change anything real.

What stays is what a mistake actually looks like. A controller that diverges and
writes NaN or infinity into the actuator is refused at the setter, which was the
original point of #18. A negative time constant, a negative rate limit and a
non-positive demand rate are refused. So is a range whose lower bound is above
its upper. And `add_*_control` hands the controller the sampling rate the
actuator kept, so passing `"100"` from a config file cannot leave the two
holding different types and fail later inside Flight.

The coefficient keeps its one-expression form, `1 / (1 + tau * rate)`. That was
not really about overflow: it is one expression instead of two, agrees with the
old one to 2.2e-16 across the range a real actuator uses, and happens to give
the right answer for a subnormal rate without anyone guarding it.

Suite goes 122 -> 104. ruff and pylint clean, pylint exits 0.

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

Author: thc1006

CHANGELOG.md

@@ -36,8 +36,10 @@ Attention: The newest changes should be on top -->
 
 ### Fixed
 
-- BUG: actuator argument validation reached the output through a range, a
-  derived filter coefficient and a controller [#19](https://github.com/ARRC-Rocket/ActiveRocketPy/pull/19)
+- BUG: actuator argument checks survive `python -O`, a non-finite command is
+  refused at the setter rather than reaching the integrator, and an
+  `add_*_control` call now hands the controller the same sampling rate the
+  actuator kept [#19](https://github.com/ARRC-Rocket/ActiveRocketPy/pull/19)
 
 ## [v1.13.0] - 2026-07-21
 

rocketpy/rocket/actuator/actuator.py

@@ -47,53 +47,6 @@ def _non_negative_or_none(value, description):
     return number
 
 
-def _range_or_raise(value, description):
-    """Return the two endpoints as a tuple, refusing a range that cannot clamp.
-
-    Endpoints are not held to ``_finite_or_raise``. An infinite bound is how
-    this class says "unbounded on that side", and the base default really is
-    ``(-inf, inf)``. What has to hold instead is weaker and is the property the
-    range is used for: clamping a finite value against it has to give back a
-    finite value.
-
-    That fails in exactly two cases, and ordering makes them one. Given
-    ``lower <= upper``, a lower bound of ``+inf`` forces the upper bound to
-    match, and an upper bound of ``-inf`` forces the lower bound to match; in
-    both, ``np.clip`` returns the infinity. So ``(inf, inf)`` passed the
-    ordering check, took a finite initial output of 0.5, and stored ``inf``,
-    after which the first ordinary command landed on
-    ``(1 - alpha) * inf == 0.0 * inf`` and stored NaN, which ``_reset()`` then
-    restored on every subsequent flight. A one-sided bound such as ``(0, inf)``
-    is unaffected and stays allowed.
-
-    The endpoints are also copied into a new tuple. They were stored as the
-    caller's own object, so a list mutated after construction moved the range
-    out from under a validation that had already run.
-    """
-    try:
-        lower, upper = value
-    except (TypeError, ValueError) as error:
-        raise ValueError(f"{description} must be a pair of numbers.") from error
-    try:
-        lower = float(lower)
-        upper = float(upper)
-    except (TypeError, ValueError) as error:
-        raise ValueError(f"{description} endpoints must be numbers.") from error
-    # 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(
-            f"{description} {(lower, upper)} cannot clamp anything to a finite value."
-        )
-    return (lower, upper)
-
-
 class Actuator(ABC):
     """Abstract class used to define actuators.
 
@@ -149,12 +102,12 @@ def __init__(
         # zero and freezes the output.
         #
         # The range endpoints are deliberately not put through this. The base
-        # default really is (-inf, inf), meaning an actuator with no range, so
-        # they get the weaker check in _range_or_raise instead.
+        # default really is (-inf, inf), meaning an actuator with no range.
         self.demand_rate = _positive_or_none(demand_rate, "demand_rate")
 
-        self.actuator_range = _range_or_raise(actuator_range, "actuator_range")
-        actuator_range = self.actuator_range
+        if not actuator_range[0] <= actuator_range[1]:
+            raise ValueError("actuator_range[0] must be <= actuator_range[1].")
+        self.actuator_range = actuator_range
 
         self.actuator_rate_limit = _non_negative_or_none(
             actuator_rate_limit, "actuator_rate_limit"
@@ -200,33 +153,13 @@ def _update_iir_coefficients(self):
 
         if self.actuator_time_constant is not None and self.actuator_time_constant > 0:
             if self.demand_rate is not None:
-                # Algebraically Ts / (tau + Ts) with Ts = 1 / demand_rate, but
-                # written without forming Ts. That intermediate overflows for a
-                # subnormal demand rate: 1.0 / 5e-324 is inf, inf / (1.0 + inf)
-                # is NaN, and the filter then stores NaN out of a command that
-                # passed every check on the way in. At the other end a huge time
-                # constant makes the denominator overflow and pins alpha to
-                # zero, freezing the actuator, where 1e-308 with 1e308 should
-                # give about 0.5. Neither shape is reachable from a physical
-                # configuration, and neither costs anything to rule out: over
-                # 2000 random pairs across the ranges that are, the two forms
-                # agree to 2.2e-16.
+                # Algebraically Ts / (tau + Ts) with Ts = 1 / demand_rate,
+                # written without forming Ts. One expression instead of two,
+                # and the two agree to 2.2e-16 over the range of time
+                # constants and rates a real actuator uses.
                 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

@@ -695,97 +695,12 @@ def test_clamping_applied(self):
         assert actuator.roll_torque == 10.0
 
 
-class TestARangeThatCannotClampIsRefused:
-    """The range was checked for ordering only, and stored by reference.
-
-    Both halves let a finite value become a non-finite stored output, which is
-    the one thing the validation around it exists to prevent. Measured before
-    the fix: ``(inf, inf)`` passed ``lower <= upper``, ``np.clip(0.5, inf, inf)``
-    stored ``inf``, and the next ordinary command reached
-    ``(1 - alpha) * inf``, which is ``0.0 * inf``, and stored NaN. ``_reset()``
-    put it back at the start of every later flight.
-    """
-
-    @pytest.mark.parametrize("limits", [(math.inf, math.inf), (-math.inf, -math.inf)])
-    def test_a_range_with_nothing_finite_in_it_is_refused(self, limits):
-        with pytest.raises(ValueError, match="clamp"):
-            ThrottleActuator(throttle_range=limits, initial_throttle=0.5)
-
-    def test_a_range_of_nans_is_refused(self):
-        """NaN fails every ordered comparison, so the ordering check catches it
-        only because that check is written as a positive test."""
-        with pytest.raises(ValueError):
-            ThrottleActuator(throttle_range=(math.nan, math.nan))
-
-    @pytest.mark.parametrize("limits", [(0.0,), (0.0, 1.0, 2.0), 1.0])
-    def test_a_range_that_is_not_a_pair_is_refused(self, limits):
-        with pytest.raises(ValueError):
-            ThrottleActuator(throttle_range=limits)
-
-    @pytest.mark.parametrize(
-        "limits",
-        [(-math.inf, math.inf), (0.0, math.inf), (-math.inf, 1.0), (0.0, 1.0)],
-    )
-    def test_a_range_that_can_clamp_still_builds(self, limits):
-        """The half that stops this being satisfied by refusing everything.
-
-        An infinite bound is how this class says "unbounded on that side", and
-        the base default really is ``(-inf, inf)``, so only a range with no
-        finite value on the clamping side may be refused.
-        """
-        actuator = ThrottleActuator(throttle_range=limits, initial_throttle=0.5)
-        actuator.throttle = 0.25
-
-        assert math.isfinite(actuator.throttle)
-
-    def test_mutating_the_range_passed_in_does_not_move_the_actuator(self):
-        """It was the caller's own list, so a validated invariant could be
-        edited away after the fact."""
-        limits = [0.0, 1.0]
-        actuator = ThrottleActuator(throttle_range=limits, initial_throttle=0.5)
+class TestTheFilterCoefficient:
+    """The coefficient is one expression rather than two.
 
-        limits[:] = [math.inf, math.inf]
-        actuator.throttle = 0.25
-
-        assert actuator.actuator_range == (0.0, 1.0)
-        assert actuator.throttle == 0.25
-
-
-class TestTheFilterCoefficientStaysFinite:
-    """``alpha`` is derived, and validating only the inputs left it unchecked.
-
-    ``Ts / (tau + Ts)`` with ``Ts = 1 / demand_rate`` forms an intermediate that
-    the arguments themselves never contain. Both arguments below are finite and
-    pass every check at the boundary.
+    Same value either way, so this is what says the rewrite is a rewrite.
     """
 
-    def test_a_subnormal_demand_rate_does_not_give_a_nan_coefficient(self):
-        """Measured before the fix: ``1.0 / 5e-324`` is inf, ``inf / (1.0 + inf)``
-        is NaN, and the first finite command then stored NaN and stayed there."""
-        actuator = ThrottleActuator(
-            demand_rate=5e-324,
-            throttle_time_constant=1.0,
-            throttle_range=(0.0, 1.0),
-            initial_throttle=0.5,
-        )
-        actuator.throttle = 0.25
-
-        assert math.isfinite(actuator._alpha)
-        assert math.isfinite(actuator.throttle)
-
-    def test_a_huge_time_constant_does_not_pin_the_coefficient_to_zero(self):
-        """The other end of the same overflow. The denominator went infinite and
-        alpha came out 0, which freezes the actuator at its initial value; the
-        answer here is about 0.5."""
-        actuator = ThrottleActuator(
-            demand_rate=1e-308,
-            throttle_time_constant=1e308,
-            throttle_range=(0.0, 1.0),
-            initial_throttle=0.5,
-        )
-
-        assert actuator._alpha == pytest.approx(0.5)
-
     @pytest.mark.parametrize(
         "demand_rate, time_constant",
         [(1e-3, 1e-6), (1.0, 1.0), (100.0, 0.05), (1e4, 1e3)],
@@ -872,43 +787,3 @@ 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)