RubyGems - ballistics-engine - Versions diffs - 0.21.5 → 0.22.11 - Mend

ballistics-engine 0.21.5 → 0.22.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64e76dd334d5a80138bcfe9ab08d1e0d9358b71ae3c34220cdb6e2ae3ceea60d
-  data.tar.gz: cc6b187d3976badb38ab9443473fce8a84a1cd5ecb2810b9beb7857910fffbdd
+  metadata.gz: 7fd3109e80b8fb96d2647e072eea4f8060caa3df7e661823879362caa732775b
+  data.tar.gz: 48a989637d61de7da186012d14af798611eb3803ed80f209f80294e6ed3c2b32
 SHA512:
-  metadata.gz: e9011fb8edd7dc0a311bcb215bed350839ac9975d6badd8e707f0ebd75cec3511e71142dc8ef993ba8134531d419eb444d2cafa0d511dd7311d638f6bbf169db
-  data.tar.gz: 1ab985a9b2eea40d2ad36392dba7a832be98e395cdd8ae58f44b83c72a541a2ce446e3f1ed5b4a164d3b55e1ca4abae37c49f82ea946dc6f0e287a262fb2f1e2
+  metadata.gz: e2d28d89a751928ba6b36f81150765ea94b81f050078ddba105bd287d41d27838cb32d6cda89c964cedae21bf49ed3aff7b7f573052d06b98f6e9a013f12331a
+  data.tar.gz: a49d7bab609e3077481659ad5180d36290d5f24e23519acd53ead7ccbca0467fa4008500c33f535df63cc8c58540261648ba700054f5c9b88bb98dcb2b037c87

data/Cargo.lock CHANGED Viewed

@@ -93,15 +93,15 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 [[package]]
 name = "ballistics-engine"
-version = "0.21.5"
+version = "0.22.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "163bc907032a1ebe17f623608facb2dd9d2ad0f005faa69a91f7055bf3356c46"
+checksum = "76e5814dcee860b6d400ef5bd432833afad4750328ab3666befe73fa2fe0eae4"
 dependencies = [
  "clap",
  "clap_complete",
  "csv",
  "dirs",
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
  "js-sys",
  "nalgebra",
  "ndarray",
@@ -121,7 +121,7 @@ dependencies = [
 [[package]]
 name = "ballistics_engine_rb"
-version = "0.21.5"
+version = "0.22.11"
 dependencies = [
  "ballistics-engine",
  "magnus",
@@ -193,6 +193,17 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+[[package]]
+name = "chacha20"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core",
+]
 [[package]]
 name = "clang-sys"
 version = "1.8.1"
@@ -268,6 +279,15 @@ dependencies = [
  "libc",
 ]
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -446,113 +466,41 @@ dependencies = [
 [[package]]
 name = "getrandom"
-version = "0.3.4"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
 dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
  "r-efi",
- "wasip2",
+ "rand_core",
  "wasm-bindgen",
 ]
 [[package]]
 name = "glam"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "333928d5eb103c5d4050533cec0384302db6be8ef7d3cebd30ec6a35350353da"
-[[package]]
-name = "glam"
-version = "0.15.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3abb554f8ee44336b72d522e0a7fe86a29e09f839a36022fa869a7dfe941a54b"
-[[package]]
-name = "glam"
-version = "0.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4126c0479ccf7e8664c36a2d719f5f2c140fbb4f9090008098d2c291fa5b3f16"
-[[package]]
-name = "glam"
-version = "0.17.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e01732b97afd8508eee3333a541b9f7610f454bb818669e66e90f5f57c93a776"
-[[package]]
-name = "glam"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525a3e490ba77b8e326fb67d4b44b4bd2f920f44d4cc73ccec50adc68e3bee34"
-[[package]]
-name = "glam"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b8509e6791516e81c1a630d0bd7fbac36d2fa8712a9da8662e716b52d5051ca"
-[[package]]
-name = "glam"
-version = "0.20.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43e957e744be03f5801a55472f593d43fabdebf25a4585db250f04d86b1675f"
-[[package]]
-name = "glam"
-version = "0.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "518faa5064866338b013ff9b2350dc318e14cc4fcd6cb8206d7e7c9886c98815"
-[[package]]
-name = "glam"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12f597d56c1bd55a811a1be189459e8fad2bbc272616375602443bdfb37fa774"
-[[package]]
-name = "glam"
-version = "0.23.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e4afd9ad95555081e109fe1d21f2a30c691b5f0919c67dfa690a2e1eb6bd51c"
-[[package]]
-name = "glam"
-version = "0.24.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5418c17512bdf42730f9032c74e1ae39afc408745ebb2acf72fbc4691c17945"
-[[package]]
-name = "glam"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "151665d9be52f9bb40fc7966565d39666f2d1e69233571b71b87791c7e0528b3"
-[[package]]
-name = "glam"
-version = "0.27.0"
+version = "0.30.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e05e7e6723e3455f4818c7b26e855439f7546cf617ef669d1adedb8669e5cb9"
+checksum = "19fc433e8437a212d1b6f1e68c7824af3aed907da60afa994e7f542d18d12aa9"
 [[package]]
 name = "glam"
-version = "0.28.0"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "779ae4bf7e8421cf91c0b3b64e7e8b40b862fba4d393f59150042de7c4965a94"
+checksum = "556f6b2ea90b8d15a74e0e7bb41671c9bdf38cd9f78c284d750b9ce58a2b5be7"
 [[package]]
 name = "glam"
-version = "0.29.3"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8babf46d4c1c9d92deac9f7be466f76dfc4482b6452fc5024b5e8daf6ffeb3ee"
+checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0"
 [[package]]
 name = "glam"
-version = "0.30.10"
+version = "0.33.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19fc433e8437a212d1b6f1e68c7824af3aed907da60afa994e7f542d18d12aa9"
+checksum = "7f22fb22f065b308be0d8724e3706c7fa3fc2a6c7d6899df4cad7860e7a75436"
 [[package]]
 name = "glob"
@@ -713,27 +661,15 @@ dependencies = [
 [[package]]
 name = "nalgebra"
-version = "0.34.1"
+version = "0.35.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4d5b3eff5cd580f93da45e64715e8c20a3996342f1e466599cf7a267a0c2f5f"
+checksum = "adc43a60c217b0c6ff46e47f26911015ad8d2e5a8be1af668c67e370d99a4346"
 dependencies = [
  "approx",
- "glam 0.14.0",
- "glam 0.15.2",
- "glam 0.16.0",
- "glam 0.17.3",
- "glam 0.18.0",
- "glam 0.19.0",
- "glam 0.20.5",
- "glam 0.21.3",
- "glam 0.22.0",
- "glam 0.23.0",
- "glam 0.24.2",
- "glam 0.25.0",
- "glam 0.27.0",
- "glam 0.28.0",
- "glam 0.29.3",
  "glam 0.30.10",
+ "glam 0.31.1",
+ "glam 0.32.1",
+ "glam 0.33.2",
  "matrixmultiply",
  "nalgebra-macros",
  "num-complex",
@@ -860,12 +796,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
-[[package]]
-name = "paste"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 [[package]]
 name = "pest"
 version = "2.8.5"
@@ -936,15 +866,6 @@ dependencies = [
  "portable-atomic",
 ]
-[[package]]
-name = "ppv-lite86"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
-dependencies = [
- "zerocopy",
-]
 [[package]]
 name = "proc-macro2"
 version = "1.0.106"
@@ -978,44 +899,32 @@ dependencies = [
 [[package]]
 name = "r-efi"
-version = "5.3.0"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 [[package]]
 name = "rand"
-version = "0.9.4"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
+checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
 dependencies = [
- "rand_chacha",
- "rand_core",
-]
-[[package]]
-name = "rand_chacha"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
-dependencies = [
- "ppv-lite86",
+ "chacha20",
+ "getrandom 0.4.3",
  "rand_core",
 ]
 [[package]]
 name = "rand_core"
-version = "0.9.5"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
-dependencies = [
- "getrandom 0.3.4",
-]
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
 [[package]]
 name = "rand_distr"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"
+checksum = "4d431c2703ccf129de4d45253c03f49ebb22b97d6ad79ee3ecfc7e3f4862c1d8"
 dependencies = [
  "num-traits",
  "rand",
@@ -1137,9 +1046,9 @@ checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984"
 [[package]]
 name = "safe_arch"
-version = "0.7.4"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323"
+checksum = "1f7caad094bd561859bcd467734a720c3c1f5d1f338995351fefe2190c45efed"
 dependencies = [
  "bytemuck",
 ]
@@ -1211,7 +1120,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
  "digest",
 ]
@@ -1229,14 +1138,13 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 [[package]]
 name = "simba"
-version = "0.9.1"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c99284beb21666094ba2b75bbceda012e610f5479dfcc2d6e2426f53197ffd95"
+checksum = "8f45c644a9f3a386f9288625d9f0c1e999e1acf07a37df35d0516c7f199d9cb2"
 dependencies = [
  "approx",
  "num-complex",
  "num-traits",
- "paste",
  "wide",
 ]
@@ -1325,15 +1233,6 @@ version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
-[[package]]
-name = "wasip2"
-version = "1.0.4+wasi-0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
-dependencies = [
- "wit-bindgen",
-]
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.108"
@@ -1405,9 +1304,9 @@ dependencies = [
 [[package]]
 name = "wide"
-version = "0.7.33"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce5da8ecb62bcd8ec8b7ea19f69a51275e91299be594ea5cc6ef7819e16cd03"
+checksum = "dfdfe6a32973f2d1b268b8895845a8a96cac2f0191e72c27cc929036060dbf89"
 dependencies = [
  "bytemuck",
  "safe_arch",
@@ -1428,32 +1327,6 @@ dependencies = [
  "windows-link",
 ]
-[[package]]
-name = "wit-bindgen"
-version = "0.57.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
-[[package]]
-name = "zerocopy"
-version = "0.8.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
-dependencies = [
- "zerocopy-derive",
-]
-[[package]]
-name = "zerocopy-derive"
-version = "0.8.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
 [[package]]
 name = "zip"
 version = "6.0.0"

data/Cargo.toml CHANGED Viewed

@@ -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.21.5"
+version = "0.22.11"
 edition = "2021"
 authors = ["Alex Jokela <email@tinycomputers.io>"]
 description = "Ruby bindings for ballistics-engine"
@@ -15,7 +15,7 @@ name = "ballistics_engine_rb"
 crate-type = ["cdylib"]
 [dependencies]
-ballistics-engine = { version = "0.21.5", default-features = false }
+ballistics-engine = { version = "0.22.11", default-features = false }
 magnus = "0.8"
 [profile.release]

data/README.md CHANGED Viewed

@@ -33,165 +33,120 @@ $ gem install ballistics-engine
 ## Quick Start
+The API is hash-in / hash-out — pass a hash of imperial-unit parameters, get a hash back.
 ```ruby
 require 'ballistics_engine'
-# Create ballistic inputs (168gr .308 Winchester)
-inputs = BallisticsEngine::BallisticInputs.new(
-  0.223,      # BC (G7)
-  168.0,      # bullet weight (grains)
-  2650.0,     # muzzle velocity (fps)
-  0.308,      # bullet diameter (inches)
-  1.2,        # bullet length (inches)
-  1.5,        # sight height (inches)
-  100.0,      # zero distance (yards)
-  0.0,        # shooting angle (degrees)
-  11.25,      # twist rate (inches)
-  true        # right-hand twist
-)
-# Optional: Add wind conditions
-wind = BallisticsEngine::WindConditions.new(
-  10.0,       # speed (mph)
-  90.0        # direction (degrees, 90 = from right)
-)
-# Optional: Add atmospheric conditions
-atmosphere = BallisticsEngine::AtmosphericConditions.new(
-  59.0,       # temperature (F)
-  29.92,      # pressure (inHg)
-  50.0,       # humidity (%)
-  0.0         # altitude (feet)
+# 168gr .308 with a 10 mph crosswind
+result = BallisticsEngine.solve(
+  "bc"                     => 0.223,   # G7 BC
+  "bullet_weight_grains"   => 168.0,
+  "muzzle_velocity_fps"    => 2650.0,
+  "bullet_diameter_inches" => 0.308,
+  "bullet_length_inches"   => 1.2,
+  "sight_height_inches"    => 1.5,
+  "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 }
 )
-# Create solver and calculate trajectory
-solver = BallisticsEngine::TrajectorySolver.new(inputs, wind, atmosphere)
-result = solver.solve
-# Access results
-puts "Max range: #{result.max_range_yards.round(1)} yards"
-puts "Time of flight: #{result.time_of_flight.round(3)} seconds"
-puts "Impact velocity: #{result.impact_velocity_fps.round(1)} fps"
-puts "Impact energy: #{result.impact_energy_ftlbs.round(1)} ft-lbs"
-# Iterate through trajectory points
-result.points.each do |point|
-  puts "Range: #{point.x.round(1)}yd, Drop: #{point.y.round(2)}yd, Velocity: #{point.velocity_fps.round(1)}fps"
+puts "Max range:       #{result['max_range_yards'].round(1)} yd"
+puts "Time of flight:  #{result['time_of_flight'].round(3)} s"
+puts "Impact velocity: #{result['impact_velocity_fps'].round(1)} fps"
+result["points"].each do |p|
+  puts "  range #{p['x'].round(1)}yd  drop #{p['y'].round(2)}yd  vel #{p['velocity_fps'].round(1)}fps"
 end
 ```
-## API Reference
-### Classes
+### Velocity-dependent BC (`bc_segments`)
-#### `BallisticInputs`
+Supply your own velocity:BC ladder (velocities in fps). The BC applies while the bullet's
+current speed is in `[velocity_min_fps, velocity_max_fps)`:
-Ballistic calculation parameters.
-**Constructor:**
 ```ruby
-BallisticInputs.new(
-  bc,                       # Ballistic coefficient
-  bullet_weight_grains,     # Bullet weight in grains
-  muzzle_velocity_fps,      # Muzzle velocity in fps
-  bullet_diameter_inches,   # Bullet diameter in inches
-  bullet_length_inches,     # Bullet length in inches
-  sight_height_inches,      # Sight height in inches
-  zero_distance_yards,      # Zero distance in yards
-  shooting_angle_degrees,   # Shooting angle in degrees
-  twist_rate_inches,        # Barrel twist rate in inches
-  is_right_twist            # Right-hand twist? (boolean)
-)
+BallisticsEngine.solve(inputs.merge(
+  "use_bc_segments"  => true,
+  "bc_segments_data" => [
+    { "velocity_min_fps" => 1800.0, "velocity_max_fps" => 4000.0, "bc" => 0.243 },
+    { "velocity_min_fps" => 1500.0, "velocity_max_fps" => 1800.0, "bc" => 0.228 },
+    { "velocity_min_fps" => 1200.0, "velocity_max_fps" => 1500.0, "bc" => 0.205 }
+  ]
+))
+# Also accepts [vmin_fps, vmax_fps, bc] triples.
 ```
-**Attributes:**
-- All constructor parameters are accessible as read/write attributes
+### Segmented wind (`wind_segments`)
-#### `WindConditions`
+Distance-keyed wind (independent of the velocity-keyed BC above) — e.g. downrange sensors:
-Wind parameters.
-**Constructor:**
 ```ruby
-WindConditions.new(
-  speed_mph,               # Wind speed in mph
-  direction_degrees        # Wind direction in degrees (0=headwind, 90=from right)
-)
+BallisticsEngine.solve(inputs.merge(
+  # [speed_mph, angle_degrees, until_yards]  (angle 90 = from the right)
+  "wind_segments" => [[5.0, 90.0, 150.0], [7.0, 90.0, 300.0], [9.0, 90.0, 1000.0]]
+))
 ```
-**Attributes:**
-- `speed_mph` - Wind speed in mph (read/write)
-- `direction_degrees` - Wind direction in degrees (read/write)
+### Zero angle and Monte Carlo
-#### `AtmosphericConditions`
-Atmospheric parameters.
-**Constructor:**
 ```ruby
-AtmosphericConditions.new(
-  temperature_f,           # Temperature in Fahrenheit
-  pressure_inhg,           # Pressure in inches of mercury
-  humidity_percent,        # Relative humidity (0-100)
-  altitude_feet            # Altitude in feet
-)
+z = BallisticsEngine.calculate_zero_angle(inputs.merge("target_distance_yards" => 1000.0))
+puts "zero: #{z['zero_angle_moa'].round(2)} MOA"
+mc = BallisticsEngine.monte_carlo(inputs.merge(
+  "num_simulations"      => 1000,
+  "velocity_std_dev_fps" => 10.0,
+  "bc_std_dev"           => 0.01,
+  "target_distance_yards"=> 1000.0
+))
+puts "hit probability: #{(mc['hit_probability'] * 100).round(1)}%"
 ```
-**Attributes:**
-- `temperature_f` - Temperature in Fahrenheit (read/write)
-- `pressure_inhg` - Pressure in inHg (read/write)
-- `humidity_percent` - Humidity percentage (read/write)
-- `altitude_feet` - Altitude in feet (read/write)
-#### `TrajectorySolver`
-Trajectory calculation engine.
-**Constructor:**
-```ruby
-TrajectorySolver.new(
-  inputs,                  # BallisticInputs object
-  wind = nil,              # WindConditions object (optional)
-  atmosphere = nil         # AtmosphericConditions object (optional)
-)
-```
-**Methods:**
-- `solve()` - Calculate trajectory, returns `TrajectoryResult`
-#### `TrajectoryResult`
-Trajectory calculation results.
-**Attributes:**
-- `max_range_yards` - Maximum range in yards
-- `max_height_yards` - Maximum height in yards
-- `time_of_flight` - Time of flight in seconds
-- `impact_velocity_fps` - Impact velocity in fps
-- `impact_energy_ftlbs` - Impact energy in ft-lbs
-- `points` - Array of `TrajectoryPoint` objects
-#### `TrajectoryPoint`
-Individual point along trajectory.
-**Attributes:**
-- `time` - Time in seconds
-- `x` - Downrange distance in yards
-- `y` - Vertical position in yards (relative to line of sight)
-- `z` - Lateral drift in yards
-- `velocity_fps` - Velocity in fps
-- `energy_ftlbs` - Energy in ft-lbs
-#### `DragModel`
-Ballistic coefficient drag model.
-**Class Methods:**
-- `DragModel.g1()` - G1 drag model
-- `DragModel.g7()` - G7 drag model
-- `DragModel.g8()` - G8 drag model
+## API Reference
+All functions live on the `BallisticsEngine` module and take a single hash with **string
+keys** in imperial units. Unknown keys are ignored; only the seven marked required are needed.
+### `BallisticsEngine.solve(hash) => hash`
+**Required:** `bc`, `bullet_weight_grains`, `muzzle_velocity_fps`, `bullet_diameter_inches`,
+`bullet_length_inches`, `sight_height_inches`, `zero_distance_yards`.
+**Optional (selected):**
+- Aim/geometry: `drag_model`("G7"), `shooting_angle_degrees`, `muzzle_angle_degrees`,
+  `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}`.
+- 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`.
+- 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`.
+**Returns:** `max_range_yards`, `max_height_yards`, `time_of_flight`, `impact_velocity_fps`,
+`impact_energy_ftlbs`, `points` (array of `{time, x, y, z, velocity_fps, energy_ftlbs}` — x=range,
+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`.
+### `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.
+### `BallisticsEngine.monte_carlo(hash) => hash`
+Bullet keys (optionally nested under `base_inputs`) plus std-dev params:
+`num_simulations`(1000), `velocity_std_dev_fps`, `angle_std_dev_radians`, `bc_std_dev`,
+`wind_speed_std_dev_mph`, `azimuth_std_dev_radians`, `target_distance_yards`,
+`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`.
 ## Development
 After checking out the repo, run `bundle install` to install dependencies.

data/lib/ballistics_engine.rb CHANGED Viewed

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

data/src/lib.rs CHANGED Viewed

@@ -1,6 +1,7 @@
-use magnus::{Error, RHash, function};
+use magnus::{Error, RArray, RHash, function};
 use ballistics_engine::{
-    DragModel, BallisticInputs, WindConditions, AtmosphericConditions, TrajectorySolver,
+    AtmosphericConditions, BCSegmentData, BallisticInputs, DragModel, MonteCarloParams,
+    TrajectorySolver, WindConditions, calculate_zero_angle_with_conditions, run_monte_carlo,
 };
 // Unit conversion constants
@@ -9,149 +10,410 @@ const FPS_TO_MPS: f64 = 0.3048;
 const YARDS_TO_METERS: f64 = 0.9144;
 const INCHES_TO_METERS: f64 = 0.0254;
 const MPH_TO_MPS: f64 = 0.44704;
+const MPH_TO_KMH: f64 = 1.609344;
+const INHG_TO_HPA: f64 = 33.8639;
 const DEGREES_TO_RADIANS: f64 = std::f64::consts::PI / 180.0;
+const JOULES_TO_FTLBS: f64 = 0.737562;
+const METERS_TO_INCHES: f64 = 39.37007874;
-/// Calculate trajectory from Ruby hash input
-fn solve_trajectory(ruby: &magnus::Ruby, inputs_hash: RHash) -> Result<RHash, Error> {
-    // Extract required values from Ruby hash
-    let bc: f64 = inputs_hash.fetch("bc")?;
-    let bullet_weight_grains: f64 = inputs_hash.fetch("bullet_weight_grains")?;
-    let muzzle_velocity_fps: f64 = inputs_hash.fetch("muzzle_velocity_fps")?;
-    let bullet_diameter_inches: f64 = inputs_hash.fetch("bullet_diameter_inches")?;
-    let bullet_length_inches: f64 = inputs_hash.fetch("bullet_length_inches")?;
-    let sight_height_inches: f64 = inputs_hash.fetch("sight_height_inches")?;
-    let zero_distance_yards: f64 = inputs_hash.fetch("zero_distance_yards")?;
-    // Optional values with defaults
-    let shooting_angle_degrees: f64 = inputs_hash.lookup2("shooting_angle_degrees", 0.0)?;
-    let twist_rate_inches: f64 = inputs_hash.lookup2("twist_rate_inches", 10.0)?;
-    let is_right_twist: bool = inputs_hash.lookup2("is_right_twist", true)?;
-    let enable_aerodynamic_jump: bool = inputs_hash.lookup2("enable_aerodynamic_jump", false)?;
-    // Coriolis (Earth-rotation) inputs. Requires latitude_degrees to take effect; with
-    // enable_coriolis + a latitude, shot_direction_degrees (compass bearing, 0=N, 90=E)
-    // drives the lateral drift and the vertical Eotvos term (east lifts, west depresses).
-    let enable_coriolis: bool = inputs_hash.lookup2("enable_coriolis", false)?;
-    let latitude_degrees: Option<f64> = inputs_hash.lookup::<_, Option<f64>>("latitude_degrees")?;
-    let shot_direction_degrees: f64 = inputs_hash.lookup2("shot_direction_degrees", 0.0)?;
-    // Drag model (default to G7)
-    let drag_model_str: String = inputs_hash.lookup2("drag_model", "G7")?;
-    let drag_model = match drag_model_str.to_uppercase().as_str() {
-        "G1" => DragModel::G1,
-        "G7" => DragModel::G7,
-        "G8" => DragModel::G8,
-        _ => return Err(Error::new(ruby.exception_arg_error(), "Invalid drag_model, must be G1, G7, or G8")),
-    };
-    // Create ballistic inputs using defaults and override specific fields
-    let ballistic_inputs = BallisticInputs {
-        bc_type: drag_model,
-        bc_value: bc,
-        bullet_diameter: bullet_diameter_inches * INCHES_TO_METERS,
-        bullet_mass: bullet_weight_grains * GRAINS_TO_KG,
-        bullet_length: bullet_length_inches * INCHES_TO_METERS,
-        muzzle_velocity: muzzle_velocity_fps * FPS_TO_MPS,
-        sight_height: sight_height_inches * INCHES_TO_METERS,
-        target_distance: zero_distance_yards * YARDS_TO_METERS,
-        shooting_angle: shooting_angle_degrees * DEGREES_TO_RADIANS,
-        twist_rate: twist_rate_inches,  // Already in inches per the struct definition
-        is_twist_right: is_right_twist,
-        caliber_inches: bullet_diameter_inches,
-        weight_grains: bullet_weight_grains,
-        enable_aerodynamic_jump,
-        enable_coriolis,
-        latitude: latitude_degrees,
-        shot_azimuth: shot_direction_degrees * DEGREES_TO_RADIANS,
-        ..Default::default()
-    };
+// Typed wrappers around RHash::lookup2 — magnus's lookup2<T,U,V> can't infer the output
+// type V from the default U, so give each call site a concrete return type here.
+fn opt_f64(h: &RHash, key: &str, default: f64) -> Result<f64, Error> {
+    h.lookup2(key, default)
+}
+fn opt_bool(h: &RHash, key: &str, default: bool) -> Result<bool, Error> {
+    h.lookup2(key, default)
+}
+fn opt_str(h: &RHash, key: &str, default: &str) -> Result<String, Error> {
+    h.lookup2(key, default.to_string())
+}
+fn opt_usize(h: &RHash, key: &str, default: usize) -> Result<usize, Error> {
+    h.lookup2(key, default)
+}
-    // Optional wind conditions (default to no wind)
-    let wind = if let Some(wind_hash) = inputs_hash.lookup::<_, Option<RHash>>("wind")? {
-        let speed_mph: f64 = wind_hash.lookup2("speed_mph", 0.0)?;
-        let direction_deg: f64 = wind_hash.lookup2("direction_degrees", 0.0)?;
+fn drag_from_str(ruby: &magnus::Ruby, s: &str) -> Result<DragModel, Error> {
+    match s.to_uppercase().as_str() {
+        "G1" => Ok(DragModel::G1),
+        "G7" => Ok(DragModel::G7),
+        "G8" => Ok(DragModel::G8),
+        _ => Err(Error::new(
+            ruby.exception_arg_error(),
+            "Invalid drag_model, must be G1, G7, or G8",
+        )),
+    }
+}
-        WindConditions {
-            speed: speed_mph * MPH_TO_MPS,
-            direction: direction_deg * DEGREES_TO_RADIANS,
-        }
+/// Build WindConditions from an optional `wind` sub-hash (mph & degrees -> m/s & radians).
+fn build_wind(h: &RHash) -> Result<WindConditions, Error> {
+    if let Some(w) = h.lookup::<_, Option<RHash>>("wind")? {
+        Ok(WindConditions {
+            speed: opt_f64(&w, "speed_mph", 0.0)? * MPH_TO_MPS,
+            direction: opt_f64(&w, "direction_degrees", 0.0)? * DEGREES_TO_RADIANS,
+        })
     } else {
-        WindConditions {
+        Ok(WindConditions {
             speed: 0.0,
             direction: 0.0,
-        }
-    };
+        })
+    }
+}
-    // Optional atmospheric conditions (default to standard conditions)
-    let atmosphere = if let Some(atm_hash) = inputs_hash.lookup::<_, Option<RHash>>("atmosphere")? {
-        let temp_f: f64 = atm_hash.lookup2("temperature_f", 59.0)?;
-        let pressure_inhg: f64 = atm_hash.lookup2("pressure_inhg", 29.92)?;
-        let humidity: f64 = atm_hash.lookup2("humidity_percent", 50.0)?;
-        let altitude_ft: f64 = atm_hash.lookup2("altitude_feet", 0.0)?;
-        // Convert to the units AtmosphericConditions expects.
-        let temp_c = (temp_f - 32.0) * 5.0 / 9.0;
-        // pressure is hectopascals (hPa/millibars), NOT pascals. 1 inHg = 33.8639 hPa.
-        // (Passing Pa here over-states air density ~100x and crushes the trajectory.)
-        let pressure_hpa = pressure_inhg * 33.8639;
-        let altitude_m = altitude_ft * 0.3048;
-        AtmosphericConditions {
-            temperature: temp_c,
-            pressure: pressure_hpa,
-            humidity,
-            altitude: altitude_m,
-        }
+/// 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> {
+    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,
+        })
     } else {
-        // Standard ICAO atmosphere
-        AtmosphericConditions {
-            temperature: 15.0, // 15°C (59°F)
-            pressure: 1013.25, // 1 atm in hPa (NOT Pa)
+        Ok(AtmosphericConditions {
+            temperature: 15.0,
+            pressure: 1013.25,
             humidity: 50.0,
             altitude: 0.0,
+        })
+    }
+}
+/// `bc_segments` = array of [mach, bc] pairs (Mach-keyed). Converts directly.
+fn extract_bc_segments(h: &RHash) -> Result<Option<Vec<(f64, f64)>>, Error> {
+    match h.lookup::<_, Option<Vec<(f64, f64)>>>("bc_segments")? {
+        Some(v) if !v.is_empty() => Ok(Some(v)),
+        _ => Ok(None),
+    }
+}
+/// `bc_segments_data` = array of {velocity_min_fps, velocity_max_fps, bc} hashes
+/// OR [vmin_fps, vmax_fps, bc] triples. Velocities stay in FPS: the solver compares
+/// BCSegmentData bounds directly against the bullet's velocity_fps (not m/s).
+/// RHash is not TryConvertOwned, so iterate by index and try the hash form first.
+fn extract_bc_segments_data(h: &RHash) -> Result<Vec<BCSegmentData>, Error> {
+    let mut out = Vec::new();
+    if let Some(arr) = h.lookup::<_, Option<RArray>>("bc_segments_data")? {
+        for i in 0..arr.len() {
+            if let Ok(seg) = arr.entry::<RHash>(i as isize) {
+                let bc = match seg.lookup::<_, Option<f64>>("bc")? {
+                    Some(v) => v,
+                    None => opt_f64(&seg, "bc_value", 0.0)?,
+                };
+                out.push(BCSegmentData {
+                    velocity_min: seg.fetch::<_, f64>("velocity_min_fps")?,
+                    velocity_max: seg.fetch::<_, f64>("velocity_max_fps")?,
+                    bc_value: bc,
+                });
+            } else {
+                let (vmin, vmax, bc): (f64, f64, f64) = arr.entry(i as isize)?;
+                out.push(BCSegmentData {
+                    velocity_min: vmin,
+                    velocity_max: vmax,
+                    bc_value: bc,
+                });
+            }
         }
+    }
+    Ok(out)
+}
+/// `wind_segments` = array of [speed_mph, angle_degrees, until_yards] -> (km/h, deg, meters).
+fn extract_wind_segments(h: &RHash) -> Result<Vec<(f64, f64, f64)>, Error> {
+    match h.lookup::<_, Option<Vec<(f64, f64, f64)>>>("wind_segments")? {
+        Some(v) => Ok(v
+            .into_iter()
+            .map(|(mph, ang, until_yd)| (mph * MPH_TO_KMH, ang, until_yd * YARDS_TO_METERS))
+            .collect()),
+        None => Ok(Vec::new()),
+    }
+}
+/// `powder_temp_curve` = array of [temp_f, velocity_fps] -> [(celsius, m/s)].
+fn extract_powder_curve(h: &RHash) -> Result<Option<Vec<(f64, f64)>>, Error> {
+    match h.lookup::<_, Option<Vec<(f64, f64)>>>("powder_temp_curve")? {
+        Some(v) if !v.is_empty() => Ok(Some(
+            v.into_iter()
+                .map(|(tf, vfps)| ((tf - 32.0) * 5.0 / 9.0, vfps * FPS_TO_MPS))
+                .collect(),
+        )),
+        _ => Ok(None),
+    }
+}
+/// 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> {
+    let drag_model = drag_from_str(ruby, &opt_str(h, "drag_model", "G7")?)?;
+    let bullet_diameter_inches: f64 = h.fetch("bullet_diameter_inches")?;
+    let bullet_weight_grains: f64 = h.fetch("bullet_weight_grains")?;
+    let bc_seg_data = extract_bc_segments_data(h)?;
+    let mut inputs = BallisticInputs {
+        bc_type: drag_model,
+        bc_value: h.fetch("bc")?,
+        bullet_diameter: bullet_diameter_inches * INCHES_TO_METERS,
+        bullet_mass: bullet_weight_grains * GRAINS_TO_KG,
+        bullet_length: h.fetch::<_, f64>("bullet_length_inches")? * INCHES_TO_METERS,
+        muzzle_velocity: h.fetch::<_, f64>("muzzle_velocity_fps")? * FPS_TO_MPS,
+        sight_height: h.fetch::<_, f64>("sight_height_inches")? * INCHES_TO_METERS,
+        target_distance: h.fetch::<_, f64>("zero_distance_yards")? * YARDS_TO_METERS,
+        // geometry / aim
+        shooting_angle: opt_f64(h, "shooting_angle_degrees", 0.0)? * DEGREES_TO_RADIANS,
+        muzzle_angle: opt_f64(h, "muzzle_angle_degrees", 0.0)? * DEGREES_TO_RADIANS,
+        azimuth_angle: opt_f64(h, "azimuth_angle_degrees", 0.0)? * DEGREES_TO_RADIANS,
+        twist_rate: opt_f64(h, "twist_rate_inches", 10.0)?, // inches/turn, NOT SI
+        is_twist_right: opt_bool(h, "is_right_twist", true)?,
+        caliber_inches: bullet_diameter_inches,
+        weight_grains: bullet_weight_grains,
+        muzzle_height: opt_f64(h, "muzzle_height_inches", 0.0)? * INCHES_TO_METERS,
+        target_height: opt_f64(h, "target_height_inches", 0.0)? * INCHES_TO_METERS,
+        // physics flags
+        enable_aerodynamic_jump: opt_bool(h, "enable_aerodynamic_jump", false)?,
+        enable_advanced_effects: opt_bool(h, "enable_advanced_effects", false)?,
+        enable_magnus: opt_bool(h, "enable_magnus", false)?,
+        enable_coriolis: opt_bool(h, "enable_coriolis", false)?,
+        latitude: h.lookup::<_, Option<f64>>("latitude_degrees")?,
+        shot_azimuth: opt_f64(h, "shot_direction_degrees", 0.0)? * DEGREES_TO_RADIANS,
+        use_enhanced_spin_drift: opt_bool(h, "use_enhanced_spin_drift", false)?,
+        use_form_factor: opt_bool(h, "use_form_factor", false)?,
+        use_cluster_bc: opt_bool(h, "use_cluster_bc", false)?,
+        enable_pitch_damping: opt_bool(h, "enable_pitch_damping", false)?,
+        enable_precession_nutation: opt_bool(h, "enable_precession_nutation", false)?,
+        use_rk4: opt_bool(h, "use_rk4", true)?,
+        use_adaptive_rk45: opt_bool(h, "use_adaptive_rk45", true)?,
+        tipoff_yaw: opt_f64(h, "tipoff_yaw_degrees", 0.0)? * DEGREES_TO_RADIANS,
+        tipoff_decay_distance: opt_f64(h, "tipoff_decay_distance_yards", 50.0)? * YARDS_TO_METERS,
+        // powder sensitivity
+        use_powder_sensitivity: opt_bool(h, "use_powder_sensitivity", false)?,
+        powder_temp_sensitivity: opt_f64(h, "powder_temp_sensitivity", 0.0)?, // (m/s)/C
+        powder_temp: (opt_f64(h, "powder_temp_f", 59.0)? - 32.0) * 5.0 / 9.0,
+        powder_temp_curve: extract_powder_curve(h)?,
+        powder_curve_temp_c: h
+            .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")?,
+        // sampling
+        enable_trajectory_sampling: opt_bool(h, "enable_trajectory_sampling", false)?,
+        // BC segments
+        use_bc_segments: opt_bool(h, "use_bc_segments", false)?,
+        bc_segments: extract_bc_segments(h)?,
+        bc_segments_data: if bc_seg_data.is_empty() {
+            None
+        } else {
+            Some(bc_seg_data)
+        },
+        // metadata
+        manufacturer: h.lookup::<_, Option<String>>("manufacturer")?,
+        bullet_model: h.lookup::<_, Option<String>>("bullet_model")?,
+        bullet_id: h.lookup::<_, Option<String>>("bullet_id")?,
+        bullet_cluster: h.lookup::<_, Option<usize>>("bullet_cluster")?,
+        ..Default::default()
     };
-    // Solve trajectory - handle Result properly
-    let solver = TrajectorySolver::new(ballistic_inputs, wind, atmosphere);
-    let result = solver.solve()
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+    // ground_threshold / sample_interval have non-trivial engine defaults (-100 m / 10 m);
+    // only override them if the caller supplied a value (in yards -> meters).
+    if let Some(gt) = h.lookup::<_, Option<f64>>("ground_threshold_yards")? {
+        inputs.ground_threshold = gt * YARDS_TO_METERS;
+    }
+    if let Some(si) = h.lookup::<_, Option<f64>>("sample_interval_yards")? {
+        inputs.sample_interval = si * YARDS_TO_METERS;
+    }
-    // Convert result to Ruby hash using Ruby context methods
-    let result_hash = ruby.hash_new();
+    Ok(inputs)
+}
-    result_hash.aset("max_range_yards", result.max_range / YARDS_TO_METERS)?;
-    result_hash.aset("max_height_yards", result.max_height / YARDS_TO_METERS)?;
-    result_hash.aset("time_of_flight", result.time_of_flight)?;
-    result_hash.aset("impact_velocity_fps", result.impact_velocity / FPS_TO_MPS)?;
-    result_hash.aset("impact_energy_ftlbs", result.impact_energy * 0.737562)?; // J to ft-lbs
+/// Calculate a trajectory from an imperial Ruby hash. Returns a Ruby hash.
+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)?;
-    // Convert trajectory points to array of hashes - use correct field name "points"
-    let points = ruby.ary_new();
-    for point in result.points {
-        let point_hash = ruby.hash_new();
-        point_hash.aset("time", point.time)?;
-        point_hash.aset("x", point.position.x / YARDS_TO_METERS)?;
-        point_hash.aset("y", point.position.y / YARDS_TO_METERS)?;
-        point_hash.aset("z", point.position.z / YARDS_TO_METERS)?;
+    let mut solver = TrajectorySolver::new(inputs, wind, atmosphere);
+    let segs = extract_wind_segments(&h)?;
+    if !segs.is_empty() {
+        solver.set_wind_segments(segs);
+    }
+    if let Some(mr) = h.lookup::<_, Option<f64>>("max_range_yards")? {
+        solver.set_max_range(mr * YARDS_TO_METERS);
+    }
+    if let Some(ts) = h.lookup::<_, Option<f64>>("time_step_seconds")? {
+        solver.set_time_step(ts);
+    }
-        // Use the velocity_magnitude field directly
-        point_hash.aset("velocity_fps", point.velocity_magnitude / FPS_TO_MPS)?;
+    let result = solver
+        .solve()
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
-        // Use the kinetic_energy field directly
-        point_hash.aset("energy_ftlbs", point.kinetic_energy * 0.737562)?;
+    let out = ruby.hash_new();
+    out.aset("max_range_yards", result.max_range / YARDS_TO_METERS)?;
+    out.aset("max_height_yards", result.max_height / YARDS_TO_METERS)?;
+    out.aset("time_of_flight", result.time_of_flight)?;
+    out.aset("impact_velocity_fps", result.impact_velocity / FPS_TO_MPS)?;
+    out.aset("impact_energy_ftlbs", result.impact_energy * JOULES_TO_FTLBS)?;
-        points.push(point_hash)?;
+    let points = ruby.ary_new();
+    for point in &result.points {
+        let ph = ruby.hash_new();
+        ph.aset("time", point.time)?;
+        ph.aset("x", point.position.x / YARDS_TO_METERS)?;
+        ph.aset("y", point.position.y / YARDS_TO_METERS)?;
+        ph.aset("z", point.position.z / YARDS_TO_METERS)?;
+        ph.aset("velocity_fps", point.velocity_magnitude / FPS_TO_MPS)?;
+        ph.aset("energy_ftlbs", point.kinetic_energy * JOULES_TO_FTLBS)?;
+        points.push(ph)?;
     }
+    out.aset("points", points)?;
-    result_hash.aset("points", points)?;
+    // Rich output (present only when the corresponding feature produced Some).
+    if let Some(samples) = &result.sampled_points {
+        let arr = ruby.ary_new();
+        for s in samples {
+            let sh = ruby.hash_new();
+            sh.aset("distance_yards", s.distance_m / YARDS_TO_METERS)?;
+            sh.aset("drop_inches", s.drop_m * METERS_TO_INCHES)?;
+            sh.aset("wind_drift_inches", s.wind_drift_m * METERS_TO_INCHES)?;
+            sh.aset("velocity_fps", s.velocity_mps / FPS_TO_MPS)?;
+            sh.aset("energy_ftlbs", s.energy_j * JOULES_TO_FTLBS)?;
+            sh.aset("time", s.time_s)?;
+            let flags = ruby.ary_new();
+            for f in &s.flags {
+                flags.push(format!("{:?}", f))?;
+            }
+            sh.aset("flags", flags)?;
+            arr.push(sh)?;
+        }
+        out.aset("sampled_points", arr)?;
+    }
+    if let Some(aj) = &result.aerodynamic_jump {
+        let jh = ruby.hash_new();
+        jh.aset("vertical_jump_moa", aj.vertical_jump_moa)?;
+        jh.aset("horizontal_jump_moa", aj.horizontal_jump_moa)?;
+        jh.aset("jump_angle_rad", aj.jump_angle_rad)?;
+        jh.aset("magnus_component_moa", aj.magnus_component_moa)?;
+        jh.aset("yaw_component_moa", aj.yaw_component_moa)?;
+        jh.aset("stabilization_factor", aj.stabilization_factor)?;
+        out.aset("aerodynamic_jump", jh)?;
+    }
+    if let Some(a) = &result.angular_state {
+        let ah = ruby.hash_new();
+        ah.aset("pitch_angle", a.pitch_angle)?;
+        ah.aset("yaw_angle", a.yaw_angle)?;
+        ah.aset("pitch_rate", a.pitch_rate)?;
+        ah.aset("yaw_rate", a.yaw_rate)?;
+        ah.aset("precession_angle", a.precession_angle)?;
+        ah.aset("nutation_phase", a.nutation_phase)?;
+        out.aset("angular_state", ah)?;
+    }
+    if let Some(v) = result.max_yaw_angle {
+        out.aset("max_yaw_angle_rad", v)?;
+    }
+    if let Some(v) = result.max_precession_angle {
+        out.aset("max_precession_angle_rad", v)?;
+    }
+    if let Some(v) = result.min_pitch_damping {
+        out.aset("min_pitch_damping", v)?;
+    }
+    if let Some(v) = result.transonic_mach {
+        out.aset("transonic_mach", v)?;
+    }
+    Ok(out)
+}
+/// Solve for the launch angle that zeroes at a target distance.
+fn calculate_zero_angle(ruby: &magnus::Ruby, h: RHash) -> Result<RHash, Error> {
+    let inputs = build_inputs(ruby, &h)?;
+    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 rad = calculate_zero_angle_with_conditions(
+        inputs,
+        target_yd * YARDS_TO_METERS,
+        target_h_in * INCHES_TO_METERS,
+        wind,
+        atmosphere,
+    )
+    .map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Unable to find zero angle for target distance {target_yd}: {e}"),
+        )
+    })?;
-    Ok(result_hash)
+    let out = ruby.hash_new();
+    out.aset("zero_angle_radians", rad)?;
+    out.aset("zero_angle_degrees", rad / DEGREES_TO_RADIANS)?;
+    out.aset("zero_angle_moa", rad / DEGREES_TO_RADIANS * 60.0)?;
+    Ok(out)
+}
+/// Monte Carlo dispersion. Reads `base_inputs` sub-hash (or the top-level hash) for the
+/// bullet, plus std-dev params, and returns per-shot ranges/velocities/positions + hit prob.
+fn monte_carlo(ruby: &magnus::Ruby, h: RHash) -> Result<RHash, Error> {
+    let base = match h.lookup::<_, Option<RHash>>("base_inputs")? {
+        Some(b) => b,
+        None => h,
+    };
+    let inputs = build_inputs(ruby, &base)?;
+    let params = MonteCarloParams {
+        num_simulations: opt_usize(&h, "num_simulations", 1000)?,
+        velocity_std_dev: opt_f64(&h, "velocity_std_dev_fps", 0.0)? * FPS_TO_MPS,
+        angle_std_dev: opt_f64(&h, "angle_std_dev_radians", 0.001)?,
+        bc_std_dev: opt_f64(&h, "bc_std_dev", 0.01)?,
+        wind_speed_std_dev: opt_f64(&h, "wind_speed_std_dev_mph", 0.0)? * MPH_TO_MPS,
+        target_distance: h
+            .lookup::<_, Option<f64>>("target_distance_yards")?
+            .map(|y| y * YARDS_TO_METERS),
+        base_wind_speed: opt_f64(&h, "base_wind_speed_mph", 0.0)? * MPH_TO_MPS,
+        base_wind_direction: opt_f64(&h, "base_wind_direction_degrees", 0.0)? * DEGREES_TO_RADIANS,
+        azimuth_std_dev: opt_f64(&h, "azimuth_std_dev_radians", 0.001)?,
+    };
+    let res = run_monte_carlo(inputs, params)
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+    let out = ruby.hash_new();
+    out.aset(
+        "ranges_yards",
+        res.ranges
+            .iter()
+            .map(|m| m / YARDS_TO_METERS)
+            .collect::<Vec<f64>>(),
+    )?;
+    out.aset(
+        "impact_velocities_fps",
+        res.impact_velocities
+            .iter()
+            .map(|v| v / FPS_TO_MPS)
+            .collect::<Vec<f64>>(),
+    )?;
+    let positions = ruby.ary_new();
+    for p in &res.impact_positions {
+        let ph = ruby.hash_new();
+        ph.aset("vertical_inches", p.y * METERS_TO_INCHES)?; // McCoy Y = vertical
+        ph.aset("lateral_inches", p.z * METERS_TO_INCHES)?; // McCoy Z = lateral
+        positions.push(ph)?;
+    }
+    out.aset("impact_positions", positions)?;
+    let radius_m = opt_f64(&h, "hit_radius_inches", 0.3 * METERS_TO_INCHES)? / METERS_TO_INCHES;
+    out.aset("hit_probability", res.hit_probability(radius_m))?;
+    out.aset("num_simulations", res.ranges.len())?;
+    Ok(out)
 }
 #[magnus::init]
 fn init(ruby: &magnus::Ruby) -> Result<(), Error> {
     let module = ruby.define_module("BallisticsEngine")?;
     module.define_module_function("solve", function!(solve_trajectory, 1))?;
+    module.define_module_function("calculate_zero_angle", function!(calculate_zero_angle, 1))?;
+    module.define_module_function("monte_carlo", function!(monte_carlo, 1))?;
     Ok(())
 }

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ballistics-engine
 version: !ruby/object:Gem::Version
-  version: 0.21.5
+  version: 0.22.11
 platform: ruby
 authors:
 - Alex Jokela
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-27 00:00:00.000000000 Z
+date: 2026-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys