driving_physics 0.0.1.2 → 0.0.3.1

data/test/tire.rb

@@ -1,124 +1,94 @@
 require 'minitest/autorun'
 require 'driving_physics/tire'
+require 'driving_physics/vector_force'
 
-T = DrivingPhysics::Tire
+include DrivingPhysics
 
-describe T do
+describe Tire do
   describe "Tire.traction" do
     it "calculates traction force from normal force and coeff of friction" do
       scalar_nf = 9800 # N
       cof = 1.1
-      scalar_t = T.traction(scalar_nf, cof)
+      scalar_t = Tire.traction(scalar_nf, cof)
       expect(scalar_t).must_equal 10780.0
 
+      skip unless DrivingPhysics.has_vector?
       vector_nf = Vector[9800, 0]
-      vector_t = T.traction(vector_nf, cof)
+      vector_t = Tire.traction(vector_nf, cof)
       expect(vector_t).must_equal Vector[10780.0, 0.0]
     end
   end
 
   describe "Tire.volume" do
     it "calculates the volume (m^3) of disk given radius and width" do
-      cubic_m = T.volume(1.0, 1.0)
+      cubic_m = Tire.volume(1.0, 1.0)
       expect(cubic_m).must_equal Math::PI
 
-      cubic_m = T.volume(0.35, 0.2)
+      cubic_m = Tire.volume(0.35, 0.2)
       expect(cubic_m).must_be_within_epsilon 0.076969
     end
   end
 
   describe "Tire.volume_l" do
     it "calculates the volume (L) of a disk given radius and width" do
-      liters = T.volume_l(1.0, 1.0)
+      liters = Tire.volume_l(1.0, 1.0)
       expect(liters).must_equal Math::PI * 1000
 
-      liters = T.volume_l(0.35, 0.2)
+      liters = Tire.volume_l(0.35, 0.2)
       expect(liters).must_be_within_epsilon 76.96902
     end
   end
 
   describe "Tire.density" do
     it "calculates the density (kg/L) given mass and volume" do
-      expect(T.density(25.0, 25.0)).must_equal 1.0
-      expect(T.density(50.0, 25.0)).must_equal 2.0
+      expect(Tire.density(25.0, 25.0)).must_equal 1.0
+      expect(Tire.density(50.0, 25.0)).must_equal 2.0
     end
   end
 
   describe "Tire.mass" do
     it "calculates the mass (kg) of a disk given radius, width, and density" do
-      expect(T.mass(0.35, 0.2, T::DENSITY)).must_be_within_epsilon 25.015
+      expect(Tire.mass(0.35, 0.2, Tire::DENSITY)).must_be_within_epsilon 25.015
     end
   end
 
   describe "Tire.rotational_inertia" do
     it "calculates rotational inertia for a disk given radius and mass" do
-      expect(T.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
+      expect(Tire.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
     end
   end
 
   describe "Tire.alpha" do
     it "calculates angular acceleration from torque and inertia" do
       scalar_torque = 1000
-      inertia = T.rotational_inertia(0.35, 25.0)
-      expect(T.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
+      inertia = Tire.rotational_inertia(0.35, 25.0)
+      expect(Tire.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
 
+      skip unless DrivingPhysics.has_vector?
       vector_torque = Vector[0, 0, 1000]
-      vector_alpha = T.alpha vector_torque, inertia
+      vector_alpha = Tire.alpha vector_torque, inertia
       expect(vector_alpha).must_be_instance_of Vector
       expect(vector_alpha.size).must_equal 3
       expect(vector_alpha[2]).must_be_within_epsilon 653.06
     end
   end
 
-  describe "Tire.torque_vector" do
-    it "calculates a torque in the 3rd dimension given 2D force and radius" do
-      force = Vector[1000, 0]
-      radius = Vector[0, 5]
-      torque = T.torque_vector(force, radius)
-      expect(torque).must_be_instance_of Vector
-      expect(torque.size).must_equal 3
-      expect(torque[2]).must_be_within_epsilon 5000.0
-    end
-  end
-
-  describe "Tire.force_vector" do
-    it "calculates a (3D) force given 3D torque and 2D radius" do
-      # let's invert the Tire.torque_vector case from above:
-      torque = Vector[0, 0, 5000]
-      radius = Vector[0, 5]
-      force = T.force_vector(torque, radius)
-      expect(force).must_be_instance_of Vector
-      expect(force.size).must_equal 3
-      expect(force[0]).must_be_within_epsilon 1000.0
-
-      # now let's rotate the radius into the x-dimension
-      # right hand rule, positive torque means thumb into screen, clockwise
-      # negative-x radius means positive-y force
-      torque = Vector[0, 0, 500]
-      radius = Vector[-5, 0]
-      force = T.force_vector(torque, radius)
-      expect(force).must_be_instance_of Vector
-      expect(force.size).must_equal 3
-      expect(force[1]).must_be_within_epsilon 100.0
-    end
-  end
-
   describe "instance methods" do
     before do
       @env = DrivingPhysics::Environment.new
-      @tire = T.new(@env)
+      @tire = Tire.new(@env)
     end
 
     it "initializes" do
-      expect(@tire).must_be_instance_of T
-      expect(@tire.density).must_equal T::DENSITY # sanity check
+      expect(@tire).must_be_instance_of Tire
+      expect(@tire.density).must_equal Tire::DENSITY # sanity check
       expect(@tire.mass).must_be_within_epsilon 25.01
 
-      with_mass = T.new(@env) { |w|
+      with_mass = Tire.new(@env) { |w|
         w.mass = 99.01
       }
       expect(with_mass.mass).must_equal 99.01
-      expect(with_mass.density).wont_equal T::DENSITY
+      expect(with_mass.density).wont_equal Tire::DENSITY
     end
 
     it "has a string representation" do
@@ -154,6 +124,7 @@ describe T do
       expect(@tire.traction scalar_nf).must_equal 10780.0
       expect(@tire.traction scalar_nf, static: false).must_equal 6860.0
 
+      skip unless DrivingPhysics.has_vector?
       vector_nf = Vector[9800, 0]
       expect(@tire.traction vector_nf).must_equal Vector[10780.0, 0.0]
       expect(@tire.traction vector_nf, static: false).
@@ -173,6 +144,7 @@ describe T do
       expect(kin_tq).must_be_within_epsilon 2401.0
 
       # not sure about how torque vectors work, but the "math" "works":
+      skip unless DrivingPhysics.has_vector?
       vector_nf = Vector[9800, 0]
       expect(@tire.tractable_torque(vector_nf)[0]).
         must_be_within_epsilon 3773.0

data/test/vector_force.rb

@@ -1,52 +1,91 @@
 require 'minitest/autorun'
 require 'driving_physics/vector_force'
 
-include DrivingPhysics
+describe DrivingPhysics do
+  describe "random_centered_zero" do
+    it "generates uniformly random numbers centered on zero" do
+      hsh = {}
+      110_000.times {
+        num = DrivingPhysics.random_centered_zero(5)
+        hsh[num] ||= 0
+        hsh[num] += 1
+      }
+      # note, this will fail occasionally due to chance
+      hsh.values.each { |count|
+        expect(count).must_be(:>=, 9000)
+        expect(count).must_be(:<=, 11000)
+      }
+    end
 
-describe VectorForce do
-  before do
-    @drive_force = Vector[7000.0, 0.0]
-    @v = Vector[3.0, 0]
-    @mass = 1000
-    @weight = @mass * G
+    it "coerces magnitude=0 to magnitude=1" do
+      a = Array.new(999) { DrivingPhysics.random_centered_zero(0) }
+      expect(a.all? { |i| i == 0 }).must_equal false
+    end
   end
 
-  it "generates uniformly random numbers centered on zero" do
-    hsh = {}
-    110_000.times {
-      num = DrivingPhysics.random_centered_zero(5)
-      hsh[num] ||= 0
-      hsh[num] += 1
-    }
-    # note, this will fail occasionally due to chance
-    hsh.values.each { |count|
-      expect(count).must_be(:>=, 9000)
-      expect(count).must_be(:<=, 11000)
-    }
+  describe "random_unit_vector" do
+    it "generates a random unit vector" do
+      low_res = DrivingPhysics.random_unit_vector(2, resolution: 1)
+      if low_res[0] == 0.0
+        expect(low_res[1].abs).must_equal 1.0
+      elsif low_res[0].abs == 1.0
+        expect(low_res[1]).must_equal 0.0
+      elsif low_res[0].abs.round(3) == 0.707
+        expect(low_res[1].abs.round(3)) == 0.707
+      else
+        p low_res
+        raise "unexpected"
+      end
+
+      9.times {
+        high_res = DrivingPhysics.random_unit_vector(3, resolution: 9)
+        expect(high_res.magnitude).must_be_within_epsilon 1.0
+      }
+    end
   end
 
-  it "coerces magnitude=0 to magnitude=1" do
-    a = Array.new(999) { DrivingPhysics.random_centered_zero(0) }
-    expect(a.all? { |i| i == 0 }).must_equal false
+  describe "torque_vector" do
+    it "calculates a torque in the 3rd dimension given 2D force and radius" do
+      force = Vector[1000, 0]
+      radius = Vector[0, 5]
+      torque = DrivingPhysics.torque_vector(force, radius)
+      expect(torque).must_be_instance_of Vector
+      expect(torque.size).must_equal 3
+      expect(torque[2]).must_be_within_epsilon 5000.0
+    end
   end
 
-  it "generates a random unit vector" do
-    low_res = DrivingPhysics.random_unit_vector(2, resolution: 1)
-    if low_res[0] == 0.0
-      expect(low_res[1].abs).must_equal 1.0
-    elsif low_res[0].abs == 1.0
-      expect(low_res[1]).must_equal 0.0
-    elsif low_res[0].abs.round(3) == 0.707
-      expect(low_res[1].abs.round(3)) == 0.707
-    else
-      p low_res
-      raise "unexpected"
+  describe "force_vector" do
+    it "calculates a (3D) force given 3D torque and 2D radius" do
+      # let's invert the DrivingPhysics.torque_vector case from above:
+      torque = Vector[0, 0, 5000]
+      radius = Vector[0, 5]
+      force = DrivingPhysics.force_vector(torque, radius)
+      expect(force).must_be_instance_of Vector
+      expect(force.size).must_equal 3
+      expect(force[0]).must_be_within_epsilon 1000.0
+
+      # now let's rotate the radius into the x-dimension
+      # right hand rule, positive torque means thumb into screen, clockwise
+      # negative-x radius means positive-y force
+      torque = Vector[0, 0, 500]
+      radius = Vector[-5, 0]
+      force = DrivingPhysics.force_vector(torque, radius)
+      expect(force).must_be_instance_of Vector
+      expect(force.size).must_equal 3
+      expect(force[1]).must_be_within_epsilon 100.0
     end
+  end
+end
 
-    9.times {
-      high_res = DrivingPhysics.random_unit_vector(3, resolution: 9)
-      expect(high_res.magnitude).must_be_within_epsilon 1.0
-    }
+include DrivingPhysics
+
+describe VectorForce do
+  before do
+    @drive_force = Vector[7000.0, 0.0]
+    @v = Vector[3.0, 0]
+    @mass = 1000
+    @weight = @mass * G
   end
 
   it "calculates air resistance as the square of velocity" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: driving_physics
 version: !ruby/object:Gem::Version
-  version: 0.0.1.2
+  version: 0.0.3.1
 platform: ruby
 authors:
 - Rick Hull
@@ -9,7 +9,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 1980-01-01 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: device_control
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 description: WIP
 email:
 executables: []
@@ -23,6 +37,9 @@ files:
 - demo/disk.rb
 - demo/gearbox.rb
 - demo/motor.rb
+- demo/mruby/car.rb
+- demo/mruby/motor.rb
+- demo/pid_controller.rb
 - demo/powertrain.rb
 - demo/scalar_force.rb
 - demo/tire.rb
@@ -31,18 +48,25 @@ files:
 - lib/driving_physics.rb
 - lib/driving_physics/car.rb
 - lib/driving_physics/cli.rb
+- lib/driving_physics/cockpit.rb
 - lib/driving_physics/disk.rb
 - lib/driving_physics/environment.rb
 - lib/driving_physics/gearbox.rb
 - lib/driving_physics/imperial.rb
 - lib/driving_physics/motor.rb
+- lib/driving_physics/mruby.rb
+- lib/driving_physics/pid_controller.rb
 - lib/driving_physics/power.rb
 - lib/driving_physics/powertrain.rb
 - lib/driving_physics/scalar_force.rb
+- lib/driving_physics/timer.rb
 - lib/driving_physics/tire.rb
 - lib/driving_physics/vector_force.rb
 - test/disk.rb
 - test/driving_physics.rb
+- test/gearbox.rb
+- test/motor.rb
+- test/powertrain.rb
 - test/scalar_force.rb
 - test/tire.rb
 - test/vector_force.rb
@@ -65,8 +89,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.26
+rubygems_version: 3.4.4
 signing_key:
 specification_version: 4
-summary: WIP
+summary: 'Physics from first principles: mass, friction, rotation, etc'
 test_files: []