ballistics-ng 0.1.0.1 → 0.1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cab378877c914007cb15e44240be0256b9bc837
-  data.tar.gz: e764833a574ad53b621db05e3a876a436c15f667
+  metadata.gz: 03d24f50b7132229db03bb1eb7873a7828ed8858
+  data.tar.gz: 43cd6e8398d7f346ed6f0226b304a1dd000f014a
 SHA512:
-  metadata.gz: 33685521c47161c77bdbdea0cb6edc597b30f721b3723efba9b5f6ed0e8ee9959fa2ba619e4e27d62cb041a1dd1f52ccf7ed1c20367085b451a288ddbe9b7ff0
-  data.tar.gz: a167d4e4de9c66ee10feba372b65ce83629d9922a8c3eeccb686d5c4716840f4a8be6d947f6027ec776d524d1cefb9f6281cf67a171ed26c50a6f3c40f63faf1
+  metadata.gz: 2d13c3f18c4798d23088eadd755ce1685e2301f52449e7ae3a3f8b05acc2b5a0272006c2e3a6ac80c68e4b1f3a9e972a6efc27602987923469405c780b491a50
+  data.tar.gz: 58d7e56498841d05dc2129c2a128b753690f7e722c302b96dfa1d51a985320e433f143d35184bb687af25b82099947870049c49a4b988d19291eabe5c9ad07d8

data/README.md

@@ -1,12 +1,112 @@
+[![Build Status](https://travis-ci.org/rickhull/ballistics.svg)](https://travis-ci.org/rickhull/ballistics)
+[![Gem Version](https://badge.fury.io/rb/ballistics-ng.svg)](http://badge.fury.io/rb/ballistics-ng)
+[![Dependency Status](https://gemnasium.com/rickhull/ballistics.svg)](https://gemnasium.com/rickhull/ballistics)
+[![Security Status](https://hakiri.io/github/rickhull/ballistics/master.svg)](https://hakiri.io/github/rickhull/ballistics/master)
+
+# Ballistics-NG (next gen)
+
+This gem consists of a C extension which wraps the "GNU Ballistics" C library
+(which is not an official GNU project as far as I can tell) and some
+additional Ruby code for managing input data.
+
+Feed in projectile and atmospheric specifics in order to retrieve trajectory
+information at range.
+
+This project is originally based on the **ballistics** gem, which has been
+abandoned since 2013.  It is anticipated that this gem will take over the
+**ballistics** name, but until then, this gem is known as **ballistics-ng**
+
 # Install
 
 ```
-# Note, this project is based on an abandoned gem and has not settled on
-# a gem name yet
+$ gem install ballistics-ng
+```
+
+# Usage
+
+```ruby
+require 'ballistics/problem'
 
-# So first, clone this repo; then:
+prob = Ballistics::Problem.simple(gun_family: 'rifles',
+                                  gun_id: 'ar15_300_blk',
+			          cart_id: 'barnes_110_vor_tx')
 
-cd ballistics
-gem install rake-compiler
-rake rebuild
+puts prob.report
+puts
+puts
+puts prob.table
 ```
+
+```
+$ ruby -Ilib examples/table.rb
+
+GUN: AR-15 with 10.5 inch barrel (300 BLK)
+===
+      Chamber: 300 BLK
+Barrel length: 10.5
+ Sight height: 2.6
+   Zero Range: 50
+
+CARTRIDGE: Barnes 300 BLK 110gr VOR-TX
+=========
+   Case: 300 BLK
+MV @ 10: 2180
+MV @ 16: 2350
+   Desc: Hunting round for penetration and expansion
+
+PROJECTILE: Barnes 110gr TAC-TX 300 BLK
+==========
+Caliber: 0.308
+ Grains: 110
+BC (G1): 0.289
+   Desc: Black polymer tip, copper bullet
+
+
+Range   Time    FPS     Path
+0       0.000   2180.0  -2.6
+50      0.072   2043.1  -0.0
+100     0.147   1911.8  0.5
+150     0.229   1786.0  -1.4
+200     0.316   1666.5  -6.0
+250     0.409   1553.7  -13.7
+300     0.509   1448.3  -25.1
+350     0.616   1351.2  -40.6
+400     0.731   1263.9  -60.9
+450     0.854   1187.7  -86.6
+500     0.983   1123.6  -118.5
+```
+
+# Features
+
+## `Ballistics::Problem`
+
+* specify a gun and cartridge (etc) for meaningful results
+
+## `Ballistics::Atmosphere`
+
+* specify altitude, humidity, pressure, and temp
+* Army and ICAO atmospheres included at no charge
+
+## `Ballistics::Gun`
+
+* determines sight height, zero angle, chamber,
+  muzzle velocity per barrel length
+* determines the cartridge by chamber
+
+## `Ballistics::Cartridge`
+
+* organized by chamber (e.g. *300 BLK*)
+* *projectile* (see below)
+* *case* (determines the chamber)
+* optionally: *powder charge* (and *primer*) details
+
+## `Ballistics::Projectile`
+
+* organized by chamber
+* determines caliber, grains, ballistic coefficient, and drag function
+
+## Built In YAML Components
+
+* [guns](https://github.com/rickhull/ballistics/tree/master/lib/ballistics/guns)
+* [cartridges](https://github.com/rickhull/ballistics/tree/master/lib/ballistics/cartridges)
+* [projectiles](https://github.com/rickhull/ballistics/tree/master/lib/ballistics/projectiles)

data/Rakefile

@@ -1,19 +1,26 @@
-begin
-  require "rake/testtask"
+require "rake/testtask"
 
-  # add test task
-  Rake::TestTask.new do |t|
-    t.test_files = FileList['test/**/*.rb']
-  end
-  desc "Run minitest tests"
+# add test task
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end
+desc "Run minitest tests"
+
+desc "Run example scripts"
+task :examples do
+  Dir['examples/**/*.rb'].each { |fn|
+    puts
+    sh "ruby -Ilib #{fn}"
+    puts
+  }
+end
 
-  task default: :test
+task default: [:test, :examples]
+
+#
+# C EXTENSION
+#
 
-  @test_task = true
-rescue Exception => e
-  warn "testtask error: #{e}"
-  @test_task = false
-end
 
 begin
   gem "rake-compiler"
@@ -37,6 +44,11 @@ rescue Exception => e
   warn "rake-compiler error: #{e}"
 end
 
+#
+# GEM BUILD / PUBLISH
+#
+
+
 begin
   require 'buildar'
 

data/ext/ballistics/ext.c

@@ -1,5 +1,5 @@
 #include <ruby.h>
-#include <gnu_ballistics.h>
+#include "include/gnu_ballistics.h"
 
 VALUE method_zero_angle(VALUE self,
 			VALUE drag_function,

data/lib/ballistics/cartridge.rb

@@ -1,6 +1,8 @@
 require 'ballistics/yaml'
 
 class Ballistics::Cartridge
+  YAML_DIR = 'cartridges'
+
   MANDATORY = {
     "name" => :string,
     "case" => :string,
@@ -20,20 +22,14 @@ class Ballistics::Cartridge
     '.308' => 24,
   }
 
+  # 1% FPS gain/loss per inch of barrel length
+  FPS_INCH_FACTOR = 0.01
+
   # Load a built-in YAML file and instantiate cartridge objects
   # Return a hash of cartridge objects keyed by the cartridge id as in the YAML
   #
-  def self.find(short_name)
-    objects = {}
-    Ballistics::YAML.load_built_in('cartridges', short_name).each { |id, hsh|
-      obj = self.new(hsh)
-      if block_given?
-        objects[id] = obj if yield obj
-      else
-        objects[id] = obj
-      end
-    }
-    objects
+  def self.find(file: nil, id: nil)
+    Ballistics::YAML.find(klass: self, file: file, id: id)
   end
 
   # This is a helper method to perform loading of cartridges and projectiles
@@ -43,9 +39,8 @@ class Ballistics::Cartridge
   #
   def self.find_with_projectiles(chamber)
     require 'ballistics/projectile'
-
-    cartridges = self.find(chamber)
-    projectiles = Ballistics::Projectile.find(chamber)
+    cartridges = self.find(file: chamber)
+    projectiles = Ballistics::Projectile.find(file: chamber)
     self.cross_ref(cartridges, projectiles)
     cartridges
   end
@@ -82,15 +77,70 @@ class Ballistics::Cartridge
   #   and a known burn length
   # Guess a muzzle velocity for an unknown length
   #
-  def self.guess_mv(known_length, known_mv, burn_length, unknown_length)
-    inch_diff = known_length - unknown_length
-    known_bf = burn_length.to_f / known_length
-    unknown_bf = burn_length.to_f / unknown_length
-    # assume 1% FPS per inch; adjust for burn_length and take the average
-    fps_per_inch = known_mv * (known_bf + unknown_bf) / 2 / 100
+  def self.guess_mv(known_length, known_mv, barrel_length, burn_length = nil)
+    inch_diff = known_length - barrel_length
+    burn_factor = self.burn_factor(burn_length, known_length, barrel_length)
+    fps_per_inch = known_mv * burn_factor * FPS_INCH_FACTOR
     known_mv - inch_diff * fps_per_inch
   end
 
+  # Given at least two data points (barrel_length, muzzle_velocity)
+  # Estimate a muzzle velocity for an unknown length assuming the relationship
+  #   between barrel length and muzzle velocity is linear
+  def self.estimate_mv(known_mvs, barrel_length, burn_length = nil)
+    if !known_mvs.is_a?(Hash) or known_mvs.empty?
+      raise(TypeError, "populated Hash expected")
+    end
+    if known_mvs.length == 1
+      return self.guess_mv(known_mvs.keys.first,
+                           known_mvs.values.first,
+                           burn_length,
+                           barrel_length)
+    end
+    known_lengths = known_mvs.keys.sort
+    lb = known_lengths.first
+    ub = known_lengths.last
+    if lb < barrel_length and barrel_length < ub
+      # we can interpolate
+      known_lengths.each { |len|
+        if barrel_length < len
+          ub = len
+          break
+        end
+        lb = len
+      }
+    else
+      # we must extrapolate
+      if barrel_length < lb
+        lb, ub = known_lengths[0], known_lengths[1]
+      else
+        lb, ub = known_lengths[-2], known_lengths[-1]
+      end
+    end
+    lv, uv = known_mvs.fetch(lb), known_mvs.fetch(ub)
+
+    # TODO: consider adjusting m by burn_factor()
+    m, b = self.linear_coefficients(lb, ub, lv, uv)
+    m * barrel_length + b
+  end
+
+  # muzzle velocity curve is steeper below burn length and shallower above it
+  # the burn_factor can correct a linear prediction if we know the burn length
+  # take the average of the known and unknown
+  def self.burn_factor(burn_length, known_length, barrel_length)
+    return 1 unless burn_length
+    (burn_length.to_f / known_length + burn_length.to_f / barrel_length) / 2
+  end
+
+  # Assume: y = mx + b
+  # Given 2 points, return m and b
+  #
+  def self.linear_coefficients(x1, x2, y1, y2)
+    m = (y1 - y2) / (x1 - x2)
+    b = y1 - m * x1
+    [m, b]
+  end
+
   # Match and extract e.g. "16" from "16_inch_fps"
   BARREL_LENGTH_REGEX = /([0-9]+)_inch_fps/i
 
@@ -103,6 +153,7 @@ class Ballistics::Cartridge
     @yaml_data = hsh
     MANDATORY.each { |field, type|
       val = hsh.fetch(field)
+      val = val.to_s if field == "case" and type == :string
       Ballistics::YAML.check_type!(val, type)
       self.instance_variable_set("@#{field}", val)
     }
@@ -138,26 +189,12 @@ class Ballistics::Cartridge
 
   # estimate muzzle velocity for a given barrel length
   def mv(barrel_length, burn_length = nil)
+    # is MV already known?
     [barrel_length, barrel_length.floor, barrel_length.ceil].each { |candidate|
       mv = @muzzle_velocity[candidate]
       return mv if mv
     }
-    burn_length ||= BURN_LENGTH.fetch(@case)
-    known_lengths = @muzzle_velocity.keys
-
-    case known_lengths.length
-    when 0
-      raise "no muzzle velocities available"
-    when 1
-      known_length = known_lengths.first
-      self.class.guess_mv(known_length,
-                          @muzzle_velocity[known_length],
-                          burn_length,
-                          barrel_length)
-    else
-      # ok, now we need to interpolate if we can
-      raise "not implemented yet"
-    end
+    self.class.estimate_mv(@muzzle_velocity, barrel_length, BURN_LENGTH[@case])
   end
 
   def multiline

data/lib/ballistics/cartridges/300_blk.yaml

@@ -2,7 +2,7 @@
 # $id:
 #   name:
 #   case:
-#   projectile: # ref to projectiles.yaml
+#   projectile: # ref to projectiles/$case.yaml
 # AT LEAST ONE OF
 #   16_inch_fps:
 #   20_inch_fps:

data/lib/ballistics/gun.rb

@@ -3,6 +3,8 @@ require 'ballistics/yaml'
 class Ballistics::Gun
   class ChamberNotFound < KeyError; end
 
+  YAML_DIR = 'guns'
+
   MANDATORY = {
     "name"          => :string,
     "chamber"       => :string,
@@ -25,29 +27,8 @@ class Ballistics::Gun
   # Load a built-in YAML file and instantiate gun objects
   # Return a hash of gun objects keyed by gun id (per the YAML)
   #
-  def self.find(short_name)
-    objects = {}
-    Ballistics::YAML.load_built_in('guns', short_name).each { |id, hsh|
-      obj = self.new(hsh)
-      if block_given?
-        objects[id] = obj if yield obj
-      else
-        objects[id] = obj
-      end
-    }
-    objects
-  end
-
-  def self.find_id(id)
-    Ballistics::YAML::BUILT_IN.fetch('guns').each { |short_name|
-      object = self.find(short_name)[id]
-      return object if object
-    }
-    nil
-  end
-
-  def self.fetch_id(id)
-    self.find_id(id) or raise("id #{id} not found")
+  def self.find(file: nil, id: nil)
+    Ballistics::YAML.find(klass: self, file: file, id: id)
   end
 
   attr_reader(*MANDATORY.keys)
@@ -76,11 +57,11 @@ class Ballistics::Gun
     (hsh.keys - MANDATORY.keys - OPTIONAL.keys).each { |k|
       @extra[k] = hsh[k]
     }
-    @cartridges = []
+    @cartridges = {}
   end
 
   def chamber=(new_chamber)
-    @cartridges = []
+    @cartridges = {}
     @chamber = new_chamber
   end
 

data/lib/ballistics/problem.rb

@@ -15,11 +15,7 @@ class Ballistics::Problem
   }
 
   def self.simple(gun_id:, cart_id:, gun_family: nil)
-    if gun_family
-      gun = Ballistics::Gun.find(gun_family).fetch(gun_id)
-    else
-      gun = Ballistics::Gun.fetch_id(gun_id)
-    end
+    gun = Ballistics::Gun.find(file: gun_family, id: gun_id)
     cart = gun.cartridges.fetch(cart_id)
     self.new(projectile: cart.projectile,
              cartridge: cart,

data/lib/ballistics/projectile.rb

@@ -1,6 +1,8 @@
 require 'ballistics/yaml'
 
 class Ballistics::Projectile
+  YAML_DIR = 'projectiles'
+
   MANDATORY = {
     "name"   => :string,
     "cal"    => :float,
@@ -29,17 +31,8 @@ class Ballistics::Projectile
   # Load a built-in YAML file and instantiate projectile objects
   # Return a hash of projectile objects keyed by projectile id (per the YAML)
   #
-  def self.find(short_name)
-    objects = {}
-    Ballistics::YAML.load_built_in('projectiles', short_name).each { |id, hsh|
-      obj = self.new(hsh)
-      if block_given?
-        objects[id] = obj if yield obj
-      else
-        objects[id] = obj
-      end
-    }
-    objects
+  def self.find(file: nil, id: nil)
+    Ballistics::YAML.find(klass: self, file: file, id: id)
   end
 
   # Normalize common flat-base and boat-tail terms to flat or boat
@@ -82,7 +75,9 @@ class Ballistics::Projectile
     BALLISTIC_COEFFICIENT.each { |field, type|
       if hsh.key?(field)
         val = hsh[field]
-        Ballistics::YAML.check_type!(val, type)
+        if !Ballistics::YAML.check_type?(val, type)
+          raise(TypeError, "#{val} (#{field}) is not #{type}")
+        end
         self.instance_variable_set("@#{field}", val)
         @ballistic_coefficient[field] = val
       end
@@ -92,6 +87,7 @@ class Ballistics::Projectile
     OPTIONAL.each { |field, type|
       if hsh.key?(field)
         val = hsh[field]
+        val = val.to_s if field == "intended" and type == :string
         Ballistics::YAML.check_type!(val, type)
         if field == "base"
           @base = self.class.base(val)

data/lib/ballistics/yaml.rb

@@ -34,6 +34,32 @@ module Ballistics::YAML
     end
   end
 
+  def self.find(klass:, file: nil, id: nil)
+    candidates = {}
+    objects = {}
+    yd = klass::YAML_DIR or raise("no YAML_DIR for #{klass}")
+    if file
+      candidates = self.load_built_in(yd, file)
+    else
+      BUILT_IN.fetch(yd).each { |f|
+        candidates.merge!(self.load_built_in(yd, f))
+      }
+    end
+    if id
+      klass.new candidates.fetch id
+    else
+      candidates.each { |cid, hsh|
+        obj = klass.new hsh
+        if block_given?
+          objects[cid] = obj if yield obj
+        else
+          objects[cid] = obj
+        end
+      }
+      objects
+    end
+  end
+
   def self.check_type?(val, type)
     case type
     when :string, :reference

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ballistics-ng
 version: !ruby/object:Gem::Version
-  version: 0.1.0.1
+  version: 0.1.1.1
 platform: ruby
 authors:
 - Rick Hull
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-27 00:00:00.000000000 Z
+date: 2017-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: buildar
@@ -54,7 +54,7 @@ files:
 - examples/table.rb
 - ext/ballistics/ext.c
 - ext/ballistics/extconf.rb
-- ext/ballistics/gnu_ballistics.h
+- ext/ballistics/include/gnu_ballistics.h
 - lib/ballistics.rb
 - lib/ballistics/atmosphere.rb
 - lib/ballistics/cartridge.rb