Add unit tests.

Change unit.py to keep angles in the range (-π, π].

Author: dbookstaber

py_ballisticcalc/unit.py

@@ -506,7 +506,7 @@ class UnitProps(NamedTuple):
     ('mil',): Unit.Mil,
     ('mrad',): Unit.MRad,
     ('thousandth', 'ths'): Unit.Thousandth,
-    ('inch/100yd', 'in/100yd', 'inch/100yd', 'in/100yard, inper100yd'): Unit.InchesPer100Yd,
+    ('inch/100yd', 'in/100yd', 'in/100yard', 'inper100yd'): Unit.InchesPer100Yd,
     ('centimeter/100m', 'cm/100m', 'cm/100meter', 'centimeter/100meter', 'cmper100m'): Unit.CmPer100m,
     ('hour', 'h'): Unit.OClock,
 
@@ -1001,11 +1001,11 @@ def _rad(self):
     @override
     @classmethod
     def to_raw(cls, value: Number, units: Unit) -> Number:
-        """Avoid going in circles: Truncates to [0, 2π)."""
+        """Normalize angle to (-π, π]."""
         radians = super().to_raw(value, units)
-        if radians > 2. * pi:
-            radians = radians % (2. * pi)
-        return radians
+        # Normalize to [-π, π)
+        r = (radians + pi) % (2.0 * pi) - pi
+        return r if r > -pi else pi  # move -π to +π
 
     # Angular.* unit aliases
     Radian: Final[Unit] = Unit.Radian

tests/test_computer.py

@@ -1,7 +1,4 @@
-"""Unittests for the py_ballisticcalc library"""
-
 import copy
-import math
 import pytest
 
 from py_ballisticcalc import (DragModel, Ammo, Weapon, Calculator, Shot, Wind, Atmo, TableG7, RangeError, TrajFlag,
@@ -254,24 +251,6 @@ def test_limit_start(self, loaded_engine_instance):
         assert len(t.trajectory) >= 1
         assert isinstance(t.error, RangeError)
 
-    def test_winds_sort(self):
-        """Test that the winds are sorted by until_distance"""
-        winds = [
-            Wind(Unit.MPS(0), Unit.Degree(90), Unit.Meter(100)),
-            Wind(Unit.MPS(1), Unit.Degree(60), Unit.Meter(300)),
-            Wind(Unit.MPS(2), Unit.Degree(30), Unit.Meter(200)),
-            Wind(Unit.MPS(2), Unit.Degree(30), Unit.Meter(50)),
-        ]
-        shot = Shot(
-            self.ammo, None, 0, 0, 0, None,
-            winds
-        )
-        sorted_winds = shot.winds
-        assert sorted_winds[0] is winds[3]
-        assert sorted_winds[1] is winds[0]
-        assert sorted_winds[2] is winds[2]
-        assert sorted_winds[3] is winds[1]
-
     def test_combined_flags(self):
         """Test that combined flags are correctly set in the trajectory"""
         dm = DragModel(bc=0.243, drag_table=TableG7)

tests/test_extremes.py

@@ -0,0 +1,135 @@
+import math
+import pytest
+
+from py_ballisticcalc import *
+from py_ballisticcalc.helpers import vacuum_range, EARTH_GRAVITY_CONSTANT_IN_SI
+from py_ballisticcalc.vector import Vector
+
+
+class TestAtmoBoundaries:
+    def test_humidity_accepts_fraction_and_percent(self):
+        a = Atmo.icao()
+        # Set as percent -> stored as fraction
+        a.humidity = 50
+        assert pytest.approx(a.humidity, abs=1e-12) == 0.5
+        # Set as fraction -> stored unchanged
+        a.humidity = 0.25
+        assert pytest.approx(a.humidity, abs=1e-12) == 0.25
+
+    @pytest.mark.parametrize("bad", [-0.01, -10, 100.01, 1e6])
+    def test_humidity_out_of_range_raises(self, bad):
+        a = Atmo.icao()
+        with pytest.raises(ValueError):
+            a.humidity = bad
+
+    def test_altitude_reuse_window_edges(self):
+        a = Atmo.icao(Distance.Foot(1000))
+        dr0, m0 = a.get_density_and_mach_for_altitude(1000.0)
+        # Exactly within 30 ft should reuse cached values
+        dr1, m1 = a.get_density_and_mach_for_altitude(1000.0 + 29.999)
+        assert dr1 == pytest.approx(dr0)
+        assert m1 == pytest.approx(m0)
+        # Outside window recomputes; values should still be sane
+        dr2, m2 = a.get_density_and_mach_for_altitude(1000.0 + 31.0)
+        assert 0 < dr2 < 2 and m2 > 0
+
+    def test_temperature_at_altitude_floor(self):
+        a = Atmo.icao()
+        with pytest.warns(RuntimeWarning):
+            t = a.temperature_at_altitude(1e9)
+        # Not below absolute-zero in Celsius
+        assert t >= Atmo.cLowestTempC - 1e-9
+
+
+class TestWindVectors:
+    @pytest.mark.parametrize(
+        "deg, expect_x, expect_z",
+        [
+            (0.0, 1.0, 0.0),    # tailwind
+            (90.0, 0.0, 1.0),   # from left to right -> +z
+            (180.0, -1.0, 0.0), # headwind
+            (270.0, 0.0, -1.0), # from right to left -> -z
+        ],
+    )
+    def test_cardinal_directions(self, deg, expect_x, expect_z):
+        w = Wind(velocity=Velocity.FPS(10), direction_from=Angular.Degree(deg))
+        v = w.vector
+        # Components scaled by 10 fps
+        assert v.x == pytest.approx(10 * expect_x, abs=1e-9)
+        assert v.z == pytest.approx(10 * expect_z, abs=1e-9)
+        assert v.y == 0.0
+
+
+class TestVectorEdge:
+    def test_normalize_near_zero_returns_unchanged(self):
+        eps = 1e-12
+        v = Vector(eps, -eps, eps)
+        n = v.normalize()
+        # Threshold in implementation is 1e-10
+        assert n == v
+
+
+class TestInterpolationTightSpacing:
+    def test_three_point_pchip_tiny_interval(self):
+        from py_ballisticcalc.interpolation import interpolate_3_pt
+        # Very tight spacing between first two points
+        x0, x1, x2 = 0.0, 1e-12, 1.0
+        y0, y1, y2 = 0.0, 1e-12, 1.0
+        # Should not raise and should be within envelope
+        y = interpolate_3_pt(5e-13, x0, y0, x1, y1, x2, y2)
+        assert 0.0 - 1e-12 <= y <= 1.0 + 1e-12
+
+
+class TestHelpersVacuum:
+    def test_vacuum_range_zero_or_ninety_angle(self):
+        assert vacuum_range(100.0, 0.0) == pytest.approx(0.0)
+        assert vacuum_range(100.0, 90.0) == pytest.approx(0.0)
+
+    def test_vacuum_range_negative_gravity_handled(self):
+        # Function flips sign of gravity if negative
+        g = -EARTH_GRAVITY_CONSTANT_IN_SI
+        r1 = vacuum_range(50.0, 45.0, gravity=g)
+        r2 = vacuum_range(50.0, 45.0, gravity=abs(g))
+        assert r1 == pytest.approx(r2)
+
+    def test_vacuum_angle_to_zero_domain_error(self):
+        # distance too large -> argument to asin > 1 => ValueError
+        from py_ballisticcalc.helpers import vacuum_angle_to_zero
+        v = 10.0
+        g = EARTH_GRAVITY_CONSTANT_IN_SI
+        # Make distance slightly larger than max range achievable at 45 deg
+        d = (v**2 / g) * 1.01
+        with pytest.raises(ValueError):
+            _ = vacuum_angle_to_zero(v, d, gravity=g)
+
+    def test_vacuum_velocity_to_zero_zero_angle_division_by_zero(self):
+        from py_ballisticcalc.helpers import vacuum_velocity_to_zero
+        with pytest.raises(ZeroDivisionError):
+            _ = vacuum_velocity_to_zero(1.0, 0.0)
+
+
+class TestUnitsDivisionErrors:
+    def test_division_by_zero_number_raises(self):
+        d = Distance.Meter(1.0)
+        with pytest.raises(ZeroDivisionError):
+            _ = d / 0
+
+    def test_division_by_zero_dimension_raises(self):
+        d = Distance.Meter(1.0)
+        z = Distance.Meter(0.0)
+        with pytest.raises(ZeroDivisionError):
+            _ = d / z
+
+
+class TestWindMaxDistance:
+    def test_custom_max_distance_used_for_default_until(self):
+        w = Wind(velocity=Velocity.FPS(1), direction_from=Angular.Degree(0), max_distance_feet=12345)
+        assert w.until_distance == Distance.Foot(12345)
+
+
+class TestVectorLargeMagnitude:
+    def test_magnitude_large_values(self):
+        # Should not raise; hypot returns inf for extremely large values
+        v = Vector(1e308, 1e308, 1e308)
+        m = v.magnitude()
+        assert math.isfinite(m) or math.isinf(m)

tests/test_hitresult.py

@@ -37,6 +37,11 @@ def test_flags(self):
         assert mach is not None, "MACH flag not found in HitResult"
         assert pytest.approx(mach.distance >> Distance.Yard, abs=0.5) == 963.0, "MACH distance"
 
+    def test_get_at_unrequested_flag(self):
+        hr = self.calc.fire(self.shot, trajectory_range=Distance.Meter(100), flags=TrajFlag.RANGE)
+        with pytest.raises(AttributeError):
+            _ = hr.flag(TrajFlag.ZERO)
+
     def test_danger_space(self):
         # Danger space on downward trajectory
         danger_space = self.shot_result.danger_space(Distance.Yard(500), Distance.Meter(1.5))

tests/test_interpolation.py

@@ -9,11 +9,12 @@
 from py_ballisticcalc.vector import Vector
 
 
-def make_base(t: float, pos: float, vel: float, mach: float) -> BaseTrajData:
-    return BaseTrajData(time=t, position=Vector(pos, 0.0, 0.0), velocity=Vector(vel, 0.0, 0.0), mach=mach)
+class TestInterpolationBasic:
 
+    @staticmethod
+    def make_base(t: float, pos: float, vel: float, mach: float) -> BaseTrajData:
+        return BaseTrajData(time=t, position=Vector(pos, 0.0, 0.0), velocity=Vector(vel, 0.0, 0.0), mach=mach)
 
-class TestInterpolationBasic:
     def test_pchip_monotone_preserves_shape_scalar(self):
         x0, x1, x2 = 0.0, 1.0, 2.0
         y0, y1, y2 = 0.0, 1.0, 1.5
@@ -33,9 +34,9 @@ def test_linear_scalar_agrees_with_exact_line(self):
             assert math.isclose(y, y0 + (y1 - y0) * (x - x0) / (x1 - x0), rel_tol=0, abs_tol=1e-12)
 
     def test_basetrajdata_interpolate_method_switch(self):
-        p0 = make_base(0.0, 0.0, 3000.0, 2.5)
-        p1 = make_base(1.0, 1.0, 2800.0, 2.3)
-        p2 = make_base(2.0, 1.5, 2600.0, 2.1)
+        p0 = self.make_base(0.0, 0.0, 3000.0, 2.5)
+        p1 = self.make_base(1.0, 1.0, 2800.0, 2.3)
+        p2 = self.make_base(2.0, 1.5, 2600.0, 2.1)
         # mid-point in first interval
         res_pchip = BaseTrajData.interpolate('time', 0.5, p0, p1, p2, method='pchip')
         res_linear = BaseTrajData.interpolate('time', 0.5, p0, p1, p2, method='linear')
@@ -45,17 +46,29 @@ def test_basetrajdata_interpolate_method_switch(self):
 
     def test_basetrajdata_interpolate_dimension_switch_on_position(self):
         # Use position.x as key
-        p0 = make_base(0.0, 0.0, 3000.0, 2.5)
-        p1 = make_base(1.0, 100.0, 2800.0, 2.3)
-        p2 = make_base(2.0, 200.0, 2600.0, 2.1)
+        p0 = self.make_base(0.0, 0.0, 3000.0, 2.5)
+        p1 = self.make_base(1.0, 100.0, 2800.0, 2.3)
+        p2 = self.make_base(2.0, 200.0, 2600.0, 2.1)
         res_lin = BaseTrajData.interpolate('position.x', 50.0, p0, p1, p2, method='linear')
         res_pc = BaseTrajData.interpolate('position.x', 50.0, p0, p1, p2, method='pchip')
         # Ensure times are between neighbor times when keying on position.x
         assert p0.time <= res_lin.time <= p1.time
         assert p0.time <= res_pc.time <= p1.time
 
+    def test_basetraj_linear_chooses_correct_segment(self):
+        # Create non-uniform key spacing and values; request linear at key in right segment
+        p0 = self.make_base(0.0, 0.0, 0.0, 0.2)
+        p1 = self.make_base(0.1, 1.0, 0.0, 0.3)
+        p2 = self.make_base(2.0, 2.0, 0.0, 0.4)
+        # Interpolate position.x keyed by time=1.0 (right segment)
+        r = BaseTrajData.interpolate('time', 1.0, p0, p1, p2, method="linear")
+        # Expect linear between p1 and p2 positions.x
+        expected = interpolate_2_pt(1.0, 0.1, p1.position.x, 2.0, p2.position.x)
+        assert abs(r.position.x - expected) < 1e-12
+
 
 class TestInterpolationEdge:
+
     def test_pchip_no_overshoot_near_peak_and_valley(self):
         # Local peak around x=1: increasing then decreasing
         x0, x1, x2 = 0.0, 1.0, 2.0
@@ -147,17 +160,6 @@ def test_pchip_equals_linear_on_colinear_points(self):
             y_ref = interpolate_2_pt(x, x0, y0, x1, y1) if x <= x1 else interpolate_2_pt(x, x1, y1, x2, y2)
             assert abs(y_p - y_ref) < 1e-12
 
-    def test_basetraj_linear_chooses_correct_segment(self):
-        # Create non-uniform key spacing and values; request linear at key in right segment
-        p0 = make_base(0.0, 0.0, 0.0, 0.2)
-        p1 = make_base(0.1, 1.0, 0.0, 0.3)
-        p2 = make_base(2.0, 2.0, 0.0, 0.4)
-        # Interpolate position.x keyed by time=1.0 (right segment)
-        r = BaseTrajData.interpolate('time', 1.0, p0, p1, p2, method="linear")
-        # Expect linear between p1 and p2 positions.x
-        expected = interpolate_2_pt(1.0, 0.1, p1.position.x, 2.0, p2.position.x)
-        assert abs(r.position.x - expected) < 1e-12
-
 
 class TestTrajectoryDataInterpolation:
 

tests/test_trajectory.py

@@ -111,3 +111,20 @@ def test_path_g7(self, loaded_engine_instance, data_point, distance, velocity, m
         assert len(data) == 11, "Trajectory Row Count"
         self.validate_one(data_point(data), distance, velocity, mach, energy, path, hold, windage, wind_adjustment,
                           time, ogv, adjustment_unit)
+
+
+class TestTrajFlagName:
+
+    def test_single_and_combined_flags(self):
+        assert TrajFlag.name(TrajFlag.NONE) == 'NONE'
+        assert TrajFlag.name(TrajFlag.ZERO_UP) == 'ZERO_UP'
+        assert TrajFlag.name(TrajFlag.ZERO_DOWN) == 'ZERO_DOWN'
+        assert TrajFlag.name(TrajFlag.ZERO) == 'ZERO'
+        combo = TrajFlag.ZERO | TrajFlag.APEX | TrajFlag.MACH
+        s = TrajFlag.name(combo)
+        # Ensure ZERO compresses up/down and includes others
+        assert 'ZERO' in s and 'APEX' in s and 'MACH' in s
+        assert 'ZERO_UP' not in s and 'ZERO_DOWN' not in s
+
+    def test_unknown_flag_returns_unknown(self):
+        assert TrajFlag.name(1 << 10) == 'UNKNOWN'

tests/test_units.py

@@ -65,6 +65,9 @@ def test_parse_unit_mixed_case_and_whitespace(self):
         assert _parse_unit(' Ft ') == Unit.Foot
         assert _parse_unit('  m / s ') == Unit.MPS
         assert _parse_unit('\tinHg\t') == Unit.InHg
+        # inches per 100 yards variants
+        assert _parse_unit('in/100yard') == Unit.InchesPer100Yd
+        assert _parse_unit('inper100yd') == Unit.InchesPer100Yd
 
     def test_parse_unit_pluralization_and_aliases(self):
         assert _parse_unit('yards') == Unit.Yard
@@ -102,7 +105,9 @@ def test_angular(self, u):
         back_n_forth_pytest(3, u, self.unit_class)
 
     def test_angle_truncation(self):
-        assert pytest.approx(Angular(720, Angular.Degree).raw_value) == Angular(0, Angular.Degree).raw_value
+        # Angles should be normalized to the interval (-180, 180] degrees.
+        assert pytest.approx(Angular(540, Angular.Degree).raw_value) == Angular(180, Angular.Degree).raw_value
+        assert pytest.approx(Angular(-270, Angular.Degree).raw_value) == Angular(90, Angular.Degree).raw_value
 
 
 class TestDistance:
@@ -164,6 +169,17 @@ class TestTemperature:
     def test_temperature(self, u):
         back_n_forth_pytest(3, u, self.unit_class)
 
+    def test_temperature_addition_clamps_absolute_zero(self):
+        t = Temperature.Kelvin(10)
+        t2 = t + (-1000)
+        assert (t2 >> Temperature.Kelvin) == pytest.approx(0.0)
+
+    def test_temperature_mul_div_raise(self):
+        with pytest.raises(TypeError):
+            _ = Temperature.Celsius(10) * 2
+        with pytest.raises(TypeError):
+            _ = Temperature.Celsius(10) / 2
+
 
 class TestVelocity:
     unit_class = Velocity

tests/test_wind.py

@@ -0,0 +1,37 @@
+import pytest
+
+from py_ballisticcalc.conditions import Ammo, Shot, Wind
+from py_ballisticcalc.drag_model import DragModel
+from py_ballisticcalc.drag_tables import TableG7
+from py_ballisticcalc.engines.base_engine import _WindSock
+from py_ballisticcalc.unit import Distance, Velocity, Angular, Unit
+
+
+class TestWindSock:
+    def test_winds_sort(self):
+        """Test that the winds are sorted by until_distance"""
+        winds = [
+            Wind(Unit.MPS(0), Unit.Degree(90), Unit.Meter(100)),
+            Wind(Unit.MPS(1), Unit.Degree(60), Unit.Meter(300)),
+            Wind(Unit.MPS(2), Unit.Degree(30), Unit.Meter(200)),
+            Wind(Unit.MPS(2), Unit.Degree(30), Unit.Meter(50)),
+        ]
+        shot = Shot(ammo=Ammo(DragModel(0.22, TableG7), Velocity.FPS(2600)), winds=winds)
+        sorted_winds = shot.winds
+        assert sorted_winds[0] is winds[3]
+        assert sorted_winds[1] is winds[0]
+        assert sorted_winds[2] is winds[2]
+        assert sorted_winds[3] is winds[1]
+
+    def test_windsock_switches_vectors_at_thresholds(self):
+        w1 = Wind(velocity=Velocity.FPS(10), direction_from=Angular.Degree(0), until_distance=Distance.Foot(50))
+        w2 = Wind(velocity=Velocity.FPS(20), direction_from=Angular.Degree(90), until_distance=Distance.Foot(100))
+        ws = _WindSock((w1, w2))
+        v0 = ws.vector_for_range(0.0)
+        assert v0.x > 0 and v0.z == pytest.approx(0.0)
+        v49 = ws.vector_for_range(49.0)
+        assert v49.x == pytest.approx(v0.x) and v49.z == pytest.approx(v0.z)
+        v50 = ws.vector_for_range(50.0)
+        # Now from left to right (+z), crosswind only
+        assert v50.x == pytest.approx(0.0, abs=1e-12)
+        assert v50.z > 0