driving_physics 0.0.0.2 → 0.0.1.2

data/test/car.rb

@@ -1,156 +0,0 @@
-require 'minitest/autorun'
-require 'driving_physics/car'
-
-C = DrivingPhysics::Car
-
-describe C do
-  before do
-    @env = DrivingPhysics::Environment.new
-    @c = C.new(@env)
-  end
-
-  def get_moving
-    @c.controls.brake_pedal = 0.0
-    @c.controls.drive_pedal = 1.0
-    @c.add_fuel 10
-    50.times { @c.tick! }
-    expect(@c.condition.speed).must_be :>, 0.0
-  end
-
-
-  it "initializes" do
-    expect(@c).must_be_instance_of C
-  end
-
-  it "has a string representation" do
-    str = @c.to_s
-    expect(str).must_be_instance_of String
-    expect(str.length).must_be(:>, 5)
-  end
-
-  it "adds fuel and reports overflow" do
-    expect(@c.condition.fuel).must_equal 0.0
-    @c.add_fuel 10.0
-    expect(@c.condition.fuel).must_equal 10.0
-    overflow = @c.add_fuel @c.fuel_capacity
-    expect(@c.condition.fuel).must_equal @c.fuel_capacity
-    expect(overflow).must_equal 10.0
-  end
-
-  it "varies drive_force based on drive_pedal and available fuel" do
-    expect(@c.drive_force).must_equal 0.0  # no pedal
-    @c.controls.drive_pedal = 1.0
-    expect(@c.drive_force).must_equal 0.0  # no fuel
-    @c.add_fuel 10
-
-    expect(@c.drive_force).must_equal @c.max_drive_force  # vroom!
-  end
-
-  it "has a drive vector in direction of @dir" do
-    @c.add_fuel 10
-    @c.controls.drive_pedal = 1.0
-    dv = @c.drive_force_vector
-    expect(dv).must_be_instance_of Vector
-    dvn = dv.normalize
-    [0,1].each { |dim|
-      expect(dvn[dim]).must_be_within_epsilon @c.condition.dir[dim]
-    }
-  end
-
-  it "varies brake_force based on brake_pedal" do
-    expect(@c.brake_force).must_equal 0.0  # no pedal
-    @c.controls.brake_pedal = 1.0
-    expect(@c.brake_force).must_equal @c.max_brake_force
-  end
-
-  it "has a brake vector opposing movement or @dir" do
-    # hmm, no good way to go in reverse
-    # just test against forward movement for now
-    @c.controls.brake_pedal = 1.0
-    bv = @c.brake_force_vector
-    expect(bv).must_be_instance_of Vector
-    bvn = bv.normalize
-    [0,1].each { |dim|
-      expect(bvn[dim]).must_be_within_epsilon @c.condition.dir[dim] * -1
-    }
-
-    get_moving
-
-    @c.controls.drive_pedal = 0.0
-    @c.controls.brake_pedal = 1.0
-    bdir = @c.brake_force_vector.normalize
-    vdir = @c.condition.vel.normalize
-    [0,1].each { |dim|
-      expect(bdir[dim]).must_be_within_epsilon vdir[dim] * -1
-    }
-  end
-
-  it "tracks the mass of remaining fuel" do
-    expect(@c.fuel_mass).must_equal 0.0
-    @c.add_fuel 10
-    expect(@c.fuel_mass).must_be_within_epsilon 7.1
-  end
-
-  it "tracks total_mass including fuel and driver" do
-    expect(@c.total_mass).must_equal @c.mass + @c.driver_mass
-    @c.add_fuel 10
-    expect(@c.total_mass).must_equal @c.mass + @c.fuel_mass + @c.driver_mass
-  end
-
-  it "computes the total weight based on G" do
-    expect(@c.weight).must_be_within_epsilon 10535.0
-  end
-
-  it "computes resistance forces based on instance variables" do
-    air = @c.air_resistance
-    expect(air).must_be_kind_of Vector
-    expect(air.magnitude).must_equal 0.0
-
-    rot = @c.rotational_resistance
-    expect(rot).must_be_kind_of Vector
-    expect(rot.magnitude).must_equal 0.0
-
-    roll = @c.rolling_resistance
-    expect(roll).must_be_kind_of Vector
-    expect(roll.magnitude).must_be :>, 0
-  end
-
-  describe C::Condition do
-    before do
-      @cond = @c.condition
-    end
-
-    it "intializes" do
-      expect(@cond).must_be_kind_of C::Condition
-    end
-
-    it "has a string representation" do
-      str = @cond.to_s
-      expect(str).must_be_kind_of String
-      expect(str.length).must_be :>, 5
-    end
-
-    it "has a lateral direction clockwise from @dir" do
-      lat = @cond.lat_dir
-      expect(lat).must_be_kind_of Vector
-      expect(lat.magnitude).must_be_within_epsilon 1.0
-      expect(lat.independent?(@cond.dir)).must_equal true
-    end
-
-    it "has a movement_dir based on velocity, or @dir when stopped" do
-      md = @cond.movement_dir
-      expect(md).must_be_kind_of Vector
-      expect(md.magnitude).must_be_within_epsilon 1.0
-      expect(md).must_equal @cond.dir
-
-      get_moving
-      md = @cond.movement_dir
-      expect(md).must_be_kind_of Vector
-      expect(md.magnitude).must_be_within_epsilon 1.0
-      vd = @cond.vel.normalize
-      [0,1].each { |dim|
-        expect(md[dim]).must_be_within_epsilon vd[dim]
-      }
-    end
-  end
-end

data/test/wheel.rb

@@ -1,177 +0,0 @@
-require 'minitest/autorun'
-require 'driving_physics/wheel'
-
-W = DrivingPhysics::Wheel
-
-describe W do
-  describe "Wheel.traction" do
-    it "calculates traction force from normal force and coeff of friction" do
-      scalar_nf = 9800 # N
-      cof = 1.1
-      scalar_t = W.traction(scalar_nf, cof)
-      expect(scalar_t).must_equal 10780.0
-
-      vector_nf = Vector[9800, 0]
-      vector_t = W.traction(vector_nf, cof)
-      expect(vector_t).must_equal Vector[10780.0, 0.0]
-    end
-  end
-
-  describe "Wheel.volume" do
-    it "calculates the volume (m^3) of disk given radius and width" do
-      cubic_m = W.volume(1.0, 1.0)
-      expect(cubic_m).must_equal Math::PI
-
-      cubic_m = W.volume(0.35, 0.2)
-      expect(cubic_m).must_be_within_epsilon 0.076969
-    end
-  end
-
-  describe "Wheel.volume_l" do
-    it "calculates the volume (L) of a disk given radius and width" do
-      liters = W.volume_l(1.0, 1.0)
-      expect(liters).must_equal Math::PI * 1000
-
-      liters = W.volume_l(0.35, 0.2)
-      expect(liters).must_be_within_epsilon 76.96902
-    end
-  end
-
-  describe "Wheel.density" do
-    it "calculates the density (kg/L) given mass and volume" do
-      expect(W.density(25.0, 25.0)).must_equal 1.0
-      expect(W.density(50.0, 25.0)).must_equal 2.0
-    end
-  end
-
-  describe "Wheel.mass" do
-    it "calculates the mass (kg) of a disk given radius, width, and density" do
-      expect(W.mass(0.35, 0.2, W::DENSITY)).must_be_within_epsilon 25.015
-    end
-  end
-
-  describe "Wheel.rotational_inertia" do
-    it "calculates rotational inertia for a disk given radius and mass" do
-      expect(W.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
-    end
-  end
-
-  describe "Wheel.alpha" do
-    it "calculates angular acceleration from torque and inertia" do
-      scalar_torque = 1000
-      inertia = W.rotational_inertia(0.35, 25.0)
-      expect(W.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
-
-      vector_torque = Vector[0, 0, 1000]
-      vector_alpha = W.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 "Wheel.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 = W.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 "Wheel.force_vector" do
-    it "calculates a (3D) force given 3D torque and 2D radius" do
-      # let's invert the Wheel.torque_vector case from above:
-      torque = Vector[0, 0, 5000]
-      radius = Vector[0, 5]
-      force = W.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 = W.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
-      @w = W.new(@env)
-    end
-
-    it "initializes" do
-      expect(@w).must_be_instance_of W
-      expect(@w.density).must_equal W::DENSITY # sanity check
-      expect(@w.mass).must_be_within_epsilon 25.01
-
-      with_mass = W.new(@env, mass: 99.01)
-      expect(with_mass.mass).must_equal 99.01
-      expect(with_mass.density).wont_equal W::DENSITY
-    end
-
-    it "has a string representation" do
-      str = @w.to_s
-      expect(str).must_be_instance_of String
-      expect(str.length).must_be(:>, 5)
-    end
-
-    it "loses radius as it wears" do
-      expect(@w.radius).must_equal 350.0
-      @w.wear!(50)
-      expect(@w.radius).must_equal 300.0
-    end
-
-    it "calculates mass from current radius" do
-      expect(@w.mass).must_be_within_epsilon 25.01
-      @w.wear!(50)
-      expect(@w.mass).must_be_within_epsilon 18.378
-    end
-
-    it "has volume" do
-      expect(@w.volume).must_be_within_epsilon 0.07697
-      expect(@w.volume_l).must_be_within_epsilon 76.96902
-    end
-
-    it "has inertia" do
-      expect(@w.rotational_inertia).must_be_within_epsilon 1.5321
-    end
-
-    it "has traction force based on normal force" do
-      scalar_nf = 9800
-      expect(@w.traction scalar_nf).must_equal 10780.0
-      expect(@w.traction scalar_nf, static: false).must_equal 6860.0
-
-      vector_nf = Vector[9800, 0]
-      expect(@w.traction vector_nf).must_equal Vector[10780.0, 0.0]
-      expect(@w.traction vector_nf, static: false).
-        must_equal Vector[6860.0, 0.0]
-    end
-
-    it "determines (e.g. thrust) force based on axle torque" do
-      expect(@w.force 1000).must_be_within_epsilon 2857.143
-      @w.wear! 50
-      expect(@w.force 1000).must_be_within_epsilon 3333.333
-    end
-
-    it "determines tractable torque" do
-      scalar_nf = 9800
-      expect(@w.tractable_torque scalar_nf).must_be_within_epsilon 3773.0
-      kin_tq = @w.tractable_torque scalar_nf, static: false
-      expect(kin_tq).must_be_within_epsilon 2401.0
-
-      # not sure about how torque vectors work, but the "math" "works":
-      vector_nf = Vector[9800, 0]
-      expect(@w.tractable_torque(vector_nf)[0]).must_be_within_epsilon 3773.0
-    end
-  end
-end