ballistics-engine 0.48.0 → 0.50.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7a0d1f4919b0dbd4941a2b98921abb22d3cd42e99c7c1a010901a05eb61af38
-  data.tar.gz: 47dbe46168d35027c1b206bfc29e4769f0260f6e5d4710d339012cc59216dd00
+  metadata.gz: bf2213952856a92c87940abc9b7e23027d5ed76ea0663d71802f404cdcc6a9ad
+  data.tar.gz: c0b873d345e641ded5b8b989132154205092d4e70109624095b1b6e6a4727e6e
 SHA512:
-  metadata.gz: c1ac430c7692c581438b9e67fac672866d35371ed442887049436ee2e4b4a95c2f457a43a0912fec8702cb112032a8b241ac787dcea426cd80e12178a11fc4ab
-  data.tar.gz: e5a0a6fb34880d6f7d669b9df339bbdbb93af4c1515a533bf9c556f349fccae6f2ac079f7125e3ed92154f843969192aa9bef7fe952f7391fd2f3d08ee825950
+  metadata.gz: 9e52cc28510c5ff5bf87a8f9580551302405013bda69dad5fc0b7f505899bf8cebdf6007692b79db776a4f38a908d89dd0ee95b5f2e6e0065ba3ab597c5a6570
+  data.tar.gz: c941a4b498cea6e5e8867bc6c751d1282e46e07eaf2b813fc766c865adfd1c4f4cacbbb0b4670a1812d0908aa86821f776a677027d604f108ee8665b4824f4e7

data/Cargo.lock

@@ -43,9 +43,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "ballistics-engine"
-version = "0.48.0"
+version = "0.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9107a91d1664aa5cf4f56244ab5ce7baa07ed37a427bad2a335ad849b2cb8a03"
+checksum = "d7f153b52bc99ee2e1303ba87e230435c4736f7464461559a2e9046b25503a71"
 dependencies = [
  "getrandom",
  "js-sys",
@@ -65,7 +65,7 @@ dependencies = [
 
 [[package]]
 name = "ballistics_engine_rb"
-version = "0.48.0"
+version = "0.50.0"
 dependencies = [
  "ballistics-engine",
  "magnus",

data/Cargo.toml

@@ -3,7 +3,7 @@
 # rake-compiler/rb-sys cargo-metadata lookup resolves (newer rb-sys does not
 # normalize hyphens). The published gem name is set in the gemspec, independent.
 name = "ballistics_engine_rb"
-version = "0.48.0"
+version = "0.50.0"
 edition = "2021"
 authors = ["Alex Jokela <email@tinycomputers.io>"]
 description = "Ruby bindings for ballistics-engine"
@@ -18,7 +18,7 @@ crate-type = ["cdylib"]
 # `bridge` exposes ballistics_engine::bridge::bridge_call — the versioned JSON command
 # bridge that reaches every engine command from one string-in/string-out entry point.
 # It is pure serde/serde_json (already core engine deps), so it adds no new dependencies.
-ballistics-engine = { version = "0.48.0", default-features = false, features = ["bridge"] }
+ballistics-engine = { version = "0.50.0", default-features = false, features = ["bridge"] }
 magnus = "0.8"
 
 [profile.release]

data/README.md

@@ -51,8 +51,9 @@ result = BallisticsEngine.solve(
   "zero_distance_yards"    => 100.0,
   "drag_model"             => "G7",    # G1 | G7 | G8
   "wind"       => { "speed_mph" => 10.0, "direction_degrees" => 90.0 },
-  "atmosphere" => { "temperature_f" => 59.0, "pressure_inhg" => 29.92,
-                    "humidity_percent" => 50.0, "altitude_feet" => 0.0 }
+  # Readings: pass the ones you have and leave the rest out (see "Atmosphere" below).
+  "atmosphere" => { "temperature_f" => 72.0, "pressure_inhg" => 29.31,
+                    "humidity_percent" => 50.0, "altitude_feet" => 600.0 }
 )
 
 puts "Max range:       #{result['max_range_yards'].round(1)} yd"
@@ -121,11 +122,16 @@ keys** in imperial units. Unknown keys are ignored; only the seven marked requir
   `twist_rate_inches`(10), `is_right_twist`(true), `muzzle_height_inches`, `target_height_inches`.
 - Wind: `wind` = `{speed_mph, direction_degrees}`; `wind_segments` = `[[speed_mph, angle_deg, until_yards], ...]`.
 - Atmosphere: `atmosphere` = `{temperature_f, pressure_inhg, humidity_percent, altitude_feet}`.
+  `pressure_inhg` is absolute station pressure, not a sea-level-corrected altimeter setting.
+  See "Atmosphere readings" below.
 - BC: `use_bc_segments`, `bc_segments_data` (see above), `bc_segments` = `[[mach, bc], ...]`.
 - Coriolis: `enable_coriolis`, `latitude_degrees`, `shot_direction_degrees`.
 - Physics flags: `enable_advanced_effects`, `enable_magnus`, `enable_aerodynamic_jump`,
   `use_enhanced_spin_drift`, `use_form_factor`, `use_cluster_bc`, `enable_pitch_damping`,
   `enable_precession_nutation`, `enable_wind_shear` (+ `wind_shear_model`), `use_rk4`, `use_adaptive_rk45`.
+  Leaving `wind_shear_model` out picks `"power_law"` (the CLI's default model) when
+  `enable_wind_shear` is true and `"none"` when it is false; a model you pass, `"none"`
+  included, is used exactly as given.
 - Powder: `use_powder_sensitivity`, `powder_temp_sensitivity`, `powder_temp_f`,
   `powder_temp_curve` = `[[temp_f, velocity_fps], ...]`, `powder_curve_temp_f`.
 - Sampling/solver: `enable_trajectory_sampling`, `sample_interval_yards`, `max_range_yards`, `time_step_seconds`.
@@ -135,6 +141,20 @@ keys** in imperial units. Unknown keys are ignored; only the seven marked requir
 y=drop, z=windage, in yards). Present when enabled: `sampled_points`, `aerodynamic_jump`,
 `angular_state`, `max_yaw_angle_rad`, `max_precession_angle_rad`, `min_pitch_damping`, `transonic_mach`.
 
+#### Atmosphere readings
+
+A `temperature_f` or `pressure_inhg` key in the `atmosphere` hash is a reading and flies
+exactly as given, whatever its value and whatever the altitude. A real 59 °F or 29.92 inHg
+at 5000 ft flies as 59 °F or 29.92 inHg. Leave a key out (or set it to `nil`) when you have
+no reading. It then defaults to 59 °F / 29.92 inHg, and above 1 m of altitude it flies the
+ICAO standard air at `altitude_feet` instead (about 41 °F and 24.9 inHg at 5000 ft). With no
+`atmosphere` hash at all the shot is at sea level in standard air.
+
+Before engine 0.49.0 the binding could not tell the two apart. At any altitude above 1 m, a
+temperature within 0.1 °C of 15 °C (58.82 to 59.18 °F) or a pressure within 0.5 hPa of
+1013.25 hPa (about 29.906 to 29.936 inHg) was treated as omitted and replaced with standard
+air, even when it was a real reading.
+
 ### `BallisticsEngine.bridge_call(request_json) => String`
 
 Raw pass-through to the engine's versioned JSON command bridge: one full request
@@ -152,8 +172,8 @@ def bridge(command, request)
 end
 
 bridge("meta.version", {})
-# => {"ok"=>true, "api_version"=>1, "engine_version"=>"0.39.0",
-#     "command"=>"meta.version", "result"=>{"engine_version"=>"0.39.0"}}
+# => {"ok"=>true, "api_version"=>1, "engine_version"=>"0.50.0",
+#     "command"=>"meta.version", "result"=>{"engine_version"=>"0.50.0"}}
 
 # Every command reachable in this build:
 bridge("meta.capabilities", {})["result"]["commands"]
@@ -194,8 +214,9 @@ what this build can actually run.
 ### `BallisticsEngine.calculate_zero_angle(hash) => hash`
 
 Same bullet keys as `solve`, plus **required** `target_distance_yards` (and optional
-`target_height_inches`, `wind`, `atmosphere`). Returns `zero_angle_radians`,
-`zero_angle_degrees`, `zero_angle_moa`. Raises on non-convergence.
+`target_height_inches`, `wind`, `atmosphere`; atmosphere readings work as for `solve`).
+Returns `zero_angle_radians`, `zero_angle_degrees`, `zero_angle_moa`. Raises on
+non-convergence.
 
 ### `BallisticsEngine.monte_carlo(hash) => hash`
 
@@ -205,6 +226,8 @@ Bullet keys (optionally nested under `base_inputs`) plus std-dev params:
 `base_wind_speed_mph`, `base_wind_direction_degrees`, `hit_radius_inches`(≈11.8).
 Returns `ranges_yards`, `impact_velocities_fps`, `impact_positions`
 (`[{vertical_inches, lateral_inches}, ...]`), `hit_probability`, `num_simulations`.
+It has no atmosphere input: every simulation flies sea-level standard air, and an
+`atmosphere` hash is ignored.
 ## Development
 
 After checking out the repo, run `bundle install` to install dependencies.

data/lib/ballistics_engine.rb

@@ -4,7 +4,7 @@ require "ballistics_engine_rb"
 
 # Top-level module for the BallisticsEngine gem
 module BallisticsEngine
-  VERSION = "0.48.0"
+  VERSION = "0.50.0"
 
   class Error < StandardError; end
 end

data/src/lib.rs

@@ -1,7 +1,8 @@
 use magnus::{Error, RArray, RHash, function};
 use ballistics_engine::{
     AtmosphericConditions, BCSegmentData, BallisticInputs, DragModel, MonteCarloParams,
-    TrajectorySolver, WindConditions, calculate_zero_angle_with_conditions, run_monte_carlo,
+    StationAtmospherePresence, TrajectorySolver, WindConditions,
+    calculate_zero_angle_with_station_presence, run_monte_carlo,
 };
 use ballistics_engine::wind::WindSegment;
 
@@ -59,25 +60,43 @@ fn build_wind(h: &RHash) -> Result<WindConditions, Error> {
     }
 }
 
-/// Build AtmosphericConditions from an optional `atmosphere` sub-hash. Note:
-/// AtmosphericConditions.humidity is PERCENT (0-100), pressure is hPa, temp is Celsius.
-fn build_atmosphere(h: &RHash) -> Result<AtmosphericConditions, Error> {
+/// Build AtmosphericConditions from an optional `atmosphere` sub-hash, with which of its
+/// temperature and pressure are readings. Note: AtmosphericConditions.humidity is PERCENT
+/// (0-100), pressure is hPa, temp is Celsius.
+///
+/// A `temperature_f` or `pressure_inhg` key that is present (and not nil) is a reading and
+/// flies exactly as given, whatever its value and whatever the altitude. A key left out takes
+/// the 59 °F / 29.92 inHg default and keeps the engine's legacy rule: above 1 m of altitude
+/// the default becomes the ICAO standard air there, as an omitted value always has. With no
+/// `atmosphere` hash nothing is a reading, at sea level.
+fn build_atmosphere(
+    h: &RHash,
+) -> Result<(AtmosphericConditions, StationAtmospherePresence), Error> {
     if let Some(a) = h.lookup::<_, Option<RHash>>("atmosphere")? {
-        let temp_f = opt_f64(&a, "temperature_f", 59.0)?;
-        let pressure_inhg = opt_f64(&a, "pressure_inhg", 29.92)?;
-        Ok(AtmosphericConditions {
-            temperature: (temp_f - 32.0) * 5.0 / 9.0,
-            pressure: pressure_inhg * INHG_TO_HPA,
-            humidity: opt_f64(&a, "humidity_percent", 50.0)?,
-            altitude: opt_f64(&a, "altitude_feet", 0.0)? * FPS_TO_MPS,
-        })
+        let temp_f = a.lookup::<_, Option<f64>>("temperature_f")?;
+        let pressure_inhg = a.lookup::<_, Option<f64>>("pressure_inhg")?;
+        let presence = StationAtmospherePresence::new(temp_f.is_some(), pressure_inhg.is_some());
+        let temp_f = temp_f.unwrap_or(59.0);
+        let pressure_inhg = pressure_inhg.unwrap_or(29.92);
+        Ok((
+            AtmosphericConditions {
+                temperature: (temp_f - 32.0) * 5.0 / 9.0,
+                pressure: pressure_inhg * INHG_TO_HPA,
+                humidity: opt_f64(&a, "humidity_percent", 50.0)?,
+                altitude: opt_f64(&a, "altitude_feet", 0.0)? * FPS_TO_MPS,
+            },
+            presence,
+        ))
     } else {
-        Ok(AtmosphericConditions {
-            temperature: 15.0,
-            pressure: 1013.25,
-            humidity: 50.0,
-            altitude: 0.0,
-        })
+        Ok((
+            AtmosphericConditions {
+                temperature: 15.0,
+                pressure: 1013.25,
+                humidity: 50.0,
+                altitude: 0.0,
+            },
+            StationAtmospherePresence::NEITHER,
+        ))
     }
 }
 
@@ -149,6 +168,27 @@ fn extract_powder_curve(h: &RHash) -> Result<Option<Vec<(f64, f64)>>, Error> {
     }
 }
 
+/// The model `enable_wind_shear` turns on when the hash names none: the CLI's default
+/// `--wind-shear-model` and the profile the C ABI names, since neither lets a caller ask for
+/// shear without getting one.
+const DEFAULT_WIND_SHEAR_MODEL: &str = "power_law";
+
+/// Resolve `wind_shear_model`. A model the hash names, `"none"` included, is kept exactly as
+/// given. When the key is absent (or nil) the default follows the flag: `"power_law"` when
+/// `enable_wind_shear` is set, `"none"` when it is not.
+///
+/// The omitted model used to default to `"none"` whatever the flag said. `TrajectorySolver`,
+/// which every hash entry point here reaches, read that as the power law until engine
+/// 0.49.0; from 0.49.0 it reads `"none"` as no shear, so without this default a hash that
+/// only set the flag would silently lose the shear it has always had.
+fn resolve_wind_shear_model(h: &RHash, enable_wind_shear: bool) -> Result<String, Error> {
+    Ok(match h.lookup::<_, Option<String>>("wind_shear_model")? {
+        Some(model) => model,
+        None if enable_wind_shear => DEFAULT_WIND_SHEAR_MODEL.to_string(),
+        None => "none".to_string(),
+    })
+}
+
 /// Build a fully-populated BallisticInputs from an imperial Ruby hash (imperial -> SI).
 /// Shared by solve, calculate_zero_angle, and monte_carlo.
 fn build_inputs(ruby: &magnus::Ruby, h: &RHash) -> Result<BallisticInputs, Error> {
@@ -157,6 +197,8 @@ fn build_inputs(ruby: &magnus::Ruby, h: &RHash) -> Result<BallisticInputs, Error
     let bullet_weight_grains: f64 = h.fetch("bullet_weight_grains")?;
 
     let bc_seg_data = extract_bc_segments_data(h)?;
+    let enable_wind_shear = opt_bool(h, "enable_wind_shear", false)?;
+    let wind_shear_model = resolve_wind_shear_model(h, enable_wind_shear)?;
 
     let mut inputs = BallisticInputs {
         bc_type: drag_model,
@@ -202,8 +244,8 @@ fn build_inputs(ruby: &magnus::Ruby, h: &RHash) -> Result<BallisticInputs, Error
             .lookup::<_, Option<f64>>("powder_curve_temp_f")?
             .map(|tf| (tf - 32.0) * 5.0 / 9.0),
         // wind shear
-        enable_wind_shear: opt_bool(h, "enable_wind_shear", false)?,
-        wind_shear_model: opt_str(h, "wind_shear_model", "none")?,
+        enable_wind_shear,
+        wind_shear_model,
         // sampling
         enable_trajectory_sampling: opt_bool(h, "enable_trajectory_sampling", false)?,
         // BC segments
@@ -238,9 +280,10 @@ fn build_inputs(ruby: &magnus::Ruby, h: &RHash) -> Result<BallisticInputs, Error
 fn solve_trajectory(ruby: &magnus::Ruby, h: RHash) -> Result<RHash, Error> {
     let inputs = build_inputs(ruby, &h)?;
     let wind = build_wind(&h)?;
-    let atmosphere = build_atmosphere(&h)?;
+    let (atmosphere, presence) = build_atmosphere(&h)?;
 
-    let mut solver = TrajectorySolver::new(inputs, wind, atmosphere);
+    let mut solver =
+        TrajectorySolver::new_with_station_presence(inputs, wind, atmosphere, presence);
     let segs = extract_wind_segments(&h)?;
     if !segs.is_empty() {
         solver.set_wind_segments(segs);
@@ -338,14 +381,15 @@ fn calculate_zero_angle(ruby: &magnus::Ruby, h: RHash) -> Result<RHash, Error> {
     let target_yd: f64 = h.fetch("target_distance_yards")?;
     let target_h_in: f64 = h.lookup2("target_height_inches", 0.0)?;
     let wind = build_wind(&h)?;
-    let atmosphere = build_atmosphere(&h)?;
+    let (atmosphere, presence) = build_atmosphere(&h)?;
 
-    let rad = calculate_zero_angle_with_conditions(
+    let rad = calculate_zero_angle_with_station_presence(
         inputs,
         target_yd * YARDS_TO_METERS,
         target_h_in * INCHES_TO_METERS,
         wind,
         atmosphere,
+        presence,
     )
     .map_err(|e| {
         Error::new(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ballistics-engine
 version: !ruby/object:Gem::Version
-  version: 0.48.0
+  version: 0.50.0
 platform: ruby
 authors:
 - Alex Jokela
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys