driving_physics 0.0.1.2 → 0.0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef486c39982798a7331f49f601e648d520a65977161180631cc4c5d3340a9011
-  data.tar.gz: 9e30b74ae34cb77a711d5d9631983b0c070872900123a1dde2d3dd03bdab854b
+  metadata.gz: 89628c4f71193088741435eb426419edf7c9ac78cad2169c4718f2a365db0881
+  data.tar.gz: a229fa52ed29f6dcb8eab0513e845732e0735dd272e516e4f26603aeabe7f312
 SHA512:
-  metadata.gz: 46eaf512dad64ca39ec20451d7acce1b1819ecd64125ee858f92c26e5edd7b0ec0e7ef01af8f73daa0d37868e0ffd76bd3b29478093219cd906d8d9e38026bcd
-  data.tar.gz: ae2e01ae8e7986c9d2e659ff5a0934ed5359e20cf2757d7724118bb59e0fb0199180249815f2f28f55f48a2336511a0b43f0d6fab042ed5d20a5ab6a897baef1
+  metadata.gz: 42a6061d1ef6e2c989e5fb88141e8a84daaafc3c9a2f31e057d2fb7a384fbaa1c195d05deab18b2703fd5e79b539557543ec8eaf8632cd2a5f776359c7c3e340
+  data.tar.gz: 2860d2b6c17c5d4e9d73868de36bdcf48341d74712666c109d422c97975899b0fde2248b58c060d02e02561ba3dff471d7b66c694a44e5d143108a20f828e477

data/README.md

@@ -10,8 +10,27 @@ using `Vector` class from `matrix.rb` in stdlib.
 
 This is very much a **Work In Progress**.  Implemented so far:
 
+### mruby Support
+
+This is big.  This library is primarily a Ruby library, intended for use with
+CRuby (MRI), JRuby, etc.  **mruby** is the redheaded stepchild, with severe
+implications for a codebase that wants to support both sides.  Supporting
+mruby here meant:
+
+1. Editing the codebase (minimally) to remove *mruby-deadends*.
+2. Creating `rake` tasks to process normal .rb files into *mruby-compatible*
+   .rb files
+3. Assembling all needed library .rb files into a master .rb file
+4. Compiling the library to bytecode
+5. Executing a toplevel/main script against the library
+6. Optionally executing toplevel/main bytecode against the library
+
+See the main Rakefile near the top for mruby stuff.
+
+### Library Features
+
 * Spinning: rotational inertia and friction / hysteresis
-* Tires: traction force via friction and the normal force
+* Tires: traction force via friction (static and kinetic) and the normal force
 * Vectors: 2D Vector forces and 3D Vector torques
 * Motor: torque curves, rotating mass with friction
 * Gearbox: gear ratios, final drive, rotating mass with friction

data/Rakefile

@@ -16,6 +16,90 @@ end
 
 task default: :test
 
+#
+# mruby
+#
+
+MRBLIB_DIR = File.join %w[mruby mrblib]
+MRBLIB_FILE = File.join(MRBLIB_DIR, 'driving_physics.rb')
+MRBLIB_MRB = File.join(MRBLIB_DIR, 'driving_physics.mrb')
+MRUBY_DEMO_DIR = File.join %w[demo mruby]
+
+def write_mruby(input_file, output_file = MRBLIB_FILE, append: false)
+  file_obj = File.open(output_file, append ? 'a' : 'w')
+  line_count = 0
+
+  File.readlines(input_file).each { |line|
+    next if line.match /\A *(?:require|autoload)/
+    file_obj.write(line)
+    line_count += 1
+  }
+  file_obj.close
+  line_count
+end
+
+file MRBLIB_FILE do
+  line_count = write_mruby(File.join(%w[lib driving_physics.rb]), MRBLIB_FILE)
+  %w[mruby environment imperial power
+     disk tire motor gearbox powertrain car].each { |name|
+    file = File.join('lib', 'driving_physics', "#{name}.rb")
+    line_count += write_mruby(file, MRBLIB_FILE, append: true)
+    puts "wrote #{file} to #{MRBLIB_FILE}"
+  }
+  puts "wrote #{line_count} lines to #{MRBLIB_FILE}"
+end
+
+file MRBLIB_MRB => MRBLIB_FILE do
+  rb_file  = File.join(%w[mruby mrblib driving_physics.rb])
+  mrb_file = File.join(%w[mruby mrblib driving_physics.mrb])
+  sh 'mrbc', rb_file
+  puts format("%s: %d bytes (created %s)",
+              mrb_file, File.size(mrb_file), File.birthtime(mrb_file))
+end
+
+file MRUBY_DEMO_DIR do
+  mkdir_p MRUBY_DEMO_DIR
+end
+
+desc "Map/Filter/Reduce lib/**/*.rb to mruby/mrblib/driving_physics.rb"
+task mrblib: MRBLIB_FILE
+
+desc "Compile mruby/mrblib/driving_physics.rb to .mrb bytecode"
+task mrbc: MRBLIB_MRB
+
+%w[disk tire motor gearbox powertrain car].each { |name|
+  demo_file = File.join(MRUBY_DEMO_DIR, "#{name}.rb")
+  demo_mrb = File.join(MRUBY_DEMO_DIR, "#{name}.mrb")
+
+  file demo_file => MRUBY_DEMO_DIR do
+    write_mruby(File.join('demo', "#{name}.rb"), demo_file)
+  end
+
+  file demo_mrb => demo_file do
+    sh 'mrbc', demo_file
+  end
+
+  desc "run demo/#{name}.rb via mruby"
+  task "demo_#{name}" => [demo_file, MRBLIB_MRB] do
+    sh 'mruby', '-r', MRBLIB_MRB, demo_file
+  end
+
+  desc "run demo/#{name}.rb via mruby bytecode"
+  task "mrb_#{name}" => [demo_mrb, MRBLIB_MRB] do
+    sh 'mruby', '-r', MRBLIB_MRB, '-b', demo_mrb
+  end
+}
+
+desc "Remove generated .rb and .mrb files"
+task :clean do
+  [MRBLIB_DIR, MRUBY_DEMO_DIR].each { |dir|
+    Dir[File.join(dir, '*rb')].each { |file|
+      rm file unless File.directory?(file)
+    }
+  }
+end
+
+
 #
 # METRICS
 #

data/VERSION

@@ -1 +1 @@
-0.0.1.2
+0.0.2.1

data/demo/car.rb

@@ -41,6 +41,9 @@ clutch = :ok
 phase = :ignition
 flag = false
 rpm = 0
+
+
+
 puts <<EOF
 
 #
@@ -59,7 +62,7 @@ num_ticks.times { |i|
     rpm = DrivingPhysics.rpm(crank_omega)
 
     if i % 100 == 0 or rpm > motor.idle_rpm
-      puts Timer.display(i)
+      puts Timer.display(ms: i)
       puts format("%d rad  %d rad/s  %d rad/s/s",
                   crank_theta, crank_omega, crank_alpha)
       puts format("%d RPM  %d Nm starter torque", rpm, motor.starter_torque)
@@ -111,7 +114,7 @@ EOF
     crank_torque = car.powertrain.motor.torque(rpm)
 
     if flag or (i < 5000 and i % 100 == 0) or (i % 1000 == 0)
-      puts Timer.display(i)
+      puts Timer.display(ms: i)
       puts format("  Tire: %.1f r/s/s  %.2f r/s  %.3f r",
                   tire_alpha, tire_omega, tire_theta)
       puts format("   Car: %.1f m/s/s  %.2f m/s  %.3f m  (%.1f MPH)",

data/demo/gearbox.rb

@@ -21,10 +21,11 @@ alpha = 0.0
 omega = 0.0
 theta = 0.0
 
+num_ticks = duration * env.hz + 1
 start = Timer.now
-paused = 0
+paused = 0.0
 
-(duration * env.hz + 1).times { |i|
+num_ticks.times { |i|
   # just for info, not used in the simulation
   friction = gearbox.spinner.rotating_friction(omega)
 
@@ -41,7 +42,7 @@ paused = 0
     (i < 100 and i % 10 == 0) or
     (i < 1000 and i % 100 == 0) or
     i % 1000 == 0
-    puts Timer.display(i)
+    puts Timer.display(ms: i)
     puts format("RPM %d  Torque: %.3f Nm (%d Nm) Friction: %.3f Nm",
                 DrivingPhysics.rpm(omega), net_torque, torque, friction)
     puts format("%.1f rad  %.1f rad/s  %.1f rad/s/s", theta, omega, alpha)

data/demo/motor.rb

@@ -82,12 +82,11 @@ num_ticks.times { |i|
   omega += alpha * env.tick
   theta += omega * env.tick
 
-  net_torque = motor.implied_torque(alpha)
+  # prevent silly oscillations due to ticks or tiny floating point errors
+  omega = 0 if omega < 0.0001
 
-  # prevent silly oscillations due to tiny floating point errors
-  omega = 0 if omega < 0.00001
+  net_torque = motor.implied_torque(alpha)
   rpm = DrivingPhysics.rpm(omega)
-
   power = DrivingPhysics.power(net_torque, omega)
 
   if rpm > motor.idle_rpm and status == :ignition
@@ -122,7 +121,7 @@ num_ticks.times { |i|
     (i < 10_000 and i % 500 == 0) or
     (i % 5000 == 0) or
     (status == :idling and i % 100 == 0)
-    puts Timer.display(i)
+    puts Timer.display(ms: i)
     puts format("Throttle: %.1f%%", motor.throttle * 100)
     puts format("%d RPM  %.1f Nm (%d Nm)  %.1f kW   Friction: %.1f Nm",
                 DrivingPhysics.rpm(omega),
@@ -130,7 +129,7 @@ num_ticks.times { |i|
                 torque,
                 power / 1000,
                 motor.spinner.rotating_friction(omega))
-    puts format("%d rad  %.1f rad/s  %.1f rad/s/s", theta, omega, alpha)
+    puts format("%.3f rad/s/s  %.2f rad/s  %.1f rad", alpha, omega, theta)
     puts
 
     paused += CLI.pause if flag

data/demo/mruby/disk.rb

@@ -0,0 +1,81 @@
+
+include DrivingPhysics
+
+env = Environment.new
+disk = Disk.new(env)
+
+puts env
+puts disk
+puts
+
+axle_torque = 50
+alpha = disk.alpha(axle_torque)
+drive_force = disk.force(axle_torque)
+
+puts [format("Axle torque: %.1f Nm", axle_torque),
+      format("      Alpha: %.1f rad/s/s", alpha),
+      format("Drive force: %.1f N", drive_force),
+     ].join("\n")
+puts
+
+puts "* Spin up the disk with #{axle_torque} Nm of torque"
+puts "* Cut the power at some point"
+puts "* Observe"
+CLI.pause
+
+duration = 750 # sec
+
+dist = 0.0  # meters
+speed = 0.0 # meters/s
+
+theta = 0.0 # radians
+omega = 0.0 # radians/s
+
+paused = 0.0 # seconds
+num_ticks = duration * env.hz + 1
+flag = false # to display current stats
+start = Timer.now
+
+num_ticks.times { |i|
+  # shut off the powah!
+  if i == 18_950
+    flag = true
+    puts '#'
+    puts '# CUT POWER'
+    puts '#'
+    puts
+    axle_torque = 0
+  end
+
+  rotating_friction = disk.rotating_friction(omega)
+  net_torque = axle_torque + rotating_friction
+  net_force = disk.force(net_torque)
+
+  # rotational kinematics
+  alpha = disk.alpha(net_torque)
+  omega += alpha * env.tick
+  omega = 0.0 if omega.abs < 0.0001
+  theta += omega * env.tick
+
+  if flag or i < 10 or
+    (i < 20_000 and i%1000 == 0) or
+    (i % 10_000 == 0) or
+    i == duration * env.hz - 1
+
+    puts Timer.display(ms: i)
+    puts format(" Torque: %.1f Nm (%d Nm)  Friction: %.1f Nm",
+                net_torque, axle_torque, rotating_friction)
+    puts format("Radians: %.1f r  %.2f r/s  %.3f r/s^2", theta, omega, alpha)
+    puts format("   Revs: %d revs  %d revs/s  %d rpm",
+                DrivingPhysics.revs(theta),
+                DrivingPhysics.revs(omega),
+                DrivingPhysics.rpm(omega))
+    puts
+    if flag
+      paused += CLI.pause
+      flag = false
+    end
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/mruby/motor.rb

@@ -0,0 +1,137 @@
+
+# next fun idea: PID controller
+
+include DrivingPhysics
+
+env = Environment.new
+motor = Motor.new(env)
+puts env
+puts motor
+puts
+
+puts "Rev it up!"
+motor.throttle = 1.0
+[:torque, :power].each { |run|
+  puts
+  puts run.to_s.upcase + ':'
+
+  800.upto(7000) { |rpm|
+    next unless rpm % 200 == 0
+    omega = DrivingPhysics.omega(rpm)
+    torque = motor.torque(rpm)
+    case run
+    when :torque
+      count = (torque.to_f / 10).round
+      char = 'T'
+      val = torque.round.to_s.rjust(5, ' ')
+      fmt = "%s Nm"
+    when :power
+      power = DrivingPhysics.power(torque, omega)
+      kw = power.to_f / 1000
+      count = (kw / 5).round
+      char = 'P'
+      val = kw.round(1).to_s.rjust(5, ' ')
+      fmt = "%s kW"
+    else
+      raise "unknown"
+    end
+    puts format("%s RPM: #{fmt}\t%s",
+                rpm.to_s.rjust(4, ' '),
+                val,
+                char * count)
+  }
+}
+
+puts
+puts "Now, the simulation begins..."
+puts "---"
+puts "* Spin the motor up to #{motor.idle_rpm} RPM with the starter motor."
+puts "* Rev it up with the throttle."
+puts "* Let it die."
+CLI.pause
+
+alpha = 0.0
+omega = 0.0
+theta = 0.0
+
+duration = 60
+
+status = :ignition
+rpm = 0
+
+paused = 0.0
+num_ticks = duration * env.hz + 1
+start = Timer.now
+
+num_ticks.times { |i|
+  # this is an input torque; alpha is determined after inertia and friction
+  torque = case status
+           when :ignition
+             motor.starter_torque
+           when :running, :off_throttle, :idling
+             motor.torque(rpm)
+           else
+             0
+           end
+
+  # Motor#alpha incorporates inertia and friction
+  alpha = motor.alpha(torque, omega: omega)
+  omega += alpha * env.tick
+  theta += omega * env.tick
+
+  # prevent silly oscillations due to ticks or tiny floating point errors
+  omega = 0 if omega < 0.0001
+
+  net_torque = motor.implied_torque(alpha)
+  rpm = DrivingPhysics.rpm(omega)
+  power = DrivingPhysics.power(net_torque, omega)
+
+  if rpm > motor.idle_rpm and status == :ignition
+    status = :running
+    flag = true
+  end
+
+  if rpm > 7000 and status == :running
+    status = :off_throttle
+    motor.throttle = 0.0
+    flag = true
+  end
+
+  if rpm < 1000 and status == :off_throttle
+    status = :idling
+    motor.throttle = 0.06
+    flag = true
+  end
+
+  if status == :idling
+    if rpm < 999
+      motor.throttle += (1.0 - motor.throttle) * 0.005
+    elsif rpm > 1001
+      motor.throttle -= motor.throttle * 0.005
+    end
+  end
+
+  if flag or
+    (i < 10) or
+    (i < 100 and i % 10 == 0) or
+    (i < 1000 and i % 100 == 0) or
+    (i < 10_000 and i % 500 == 0) or
+    (i % 5000 == 0) or
+    (status == :idling and i % 100 == 0)
+    puts Timer.display(ms: i)
+    puts format("Throttle: %.1f%%", motor.throttle * 100)
+    puts format("%d RPM  %.1f Nm (%d Nm)  %.1f kW   Friction: %.1f Nm",
+                DrivingPhysics.rpm(omega),
+                net_torque,
+                torque,
+                power / 1000,
+                motor.spinner.rotating_friction(omega))
+    puts format("%.3f rad/s/s  %.2f rad/s  %.1f rad", alpha, omega, theta)
+    puts
+
+    paused += CLI.pause if flag
+    flag = false
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)

data/lib/driving_physics/car.rb

@@ -103,7 +103,7 @@ module DrivingPhysics
     end
 
     def corner_mass
-      Rational(self.total_mass) / @num_tires
+      self.total_mass / @num_tires
     end
 
     # per tire

data/lib/driving_physics/disk.rb

@@ -1,5 +1,5 @@
 require 'driving_physics/environment'
-require 'driving_physics/vector_force'
+#require 'driving_physics/vector_force'
 
 module DrivingPhysics
   # radius is always in meters
@@ -110,11 +110,11 @@ module DrivingPhysics
 
     def initialize(env)
       @env = env
-      @radius  = 350/1000r # m
-      @width   = 200/1000r # m
+      @radius  = 0.35
+      @width   = 0.2
       @density = DENSITY
-      @base_friction  = 5/100_000r  # constant resistance to rotation
-      @omega_friction = 5/100_000r  # scales with omega
+      @base_friction  = 5.0/100_000  # constant resistance to rotation
+      @omega_friction = 5.0/100_000  # scales with omega
       yield self if block_given?
     end
 

data/lib/driving_physics/gearbox.rb

@@ -27,8 +27,8 @@ module DrivingPhysics
       # represent all rotating mass
       @spinner = Disk.new(env) { |m|
         m.radius = 0.15
-        m.base_friction = 5/1000r
-        m.omega_friction = 15/100_000r
+        m.base_friction = 5.0/1000
+        m.omega_friction = 15.0/100_000
         m.mass = 15
       }
       @fixed_mass = 30 # kg

data/lib/driving_physics/motor.rb

@@ -25,8 +25,8 @@ module DrivingPhysics
       @spinner = Disk.new(@env) { |fly|
         fly.radius =  0.25 # m
         fly.mass   = 75    # kg
-        fly.base_friction  = 5/1000r
-        fly.omega_friction = 2/10_000r
+        fly.base_friction  = 5.0/1000
+        fly.omega_friction = 2.0/10_000
       }
       @starter_torque = 500  # Nm
       @idle_rpm       = 1000 # RPM
@@ -75,11 +75,8 @@ module DrivingPhysics
       raise(Stall, "RPM #{rpm}") if rpm < @rpms.first
       raise(OverRev, "RPM #{rpm}") if rpm > @rpms.last
 
-      last_rpm = 99999
-      last_tq = -1
-      torque = nil
+      last_rpm, last_tq, torque = 99999, -1, nil
 
-      # ew; there must be a better way
       @rpms.each_with_index { |r, i|
         tq = @torques[i]
         if last_rpm <= rpm and rpm <= r
@@ -87,8 +84,7 @@ module DrivingPhysics
           torque = last_tq + (tq - last_tq) * proportion
           break
         end
-        last_rpm = r
-        last_tq = tq
+        last_rpm, last_tq = r, tq
       }
       raise(SanityCheck, "RPM #{rpm}") if torque.nil?
 
@@ -101,3 +97,54 @@ module DrivingPhysics
     end
   end
 end
+
+
+# TODO: starter motor
+# Starter motor is power limited, not torque limited
+# Consider:
+# * 2.2 kW (3.75:1 gear reduction)
+# * 1.8 kW  (4.4:1 gear reduction)
+# On a workbench, a starter will draw 80 to 90 amps. However, during actual
+# start-up of an engine, a starter will draw 250 to 350 amps.
+# from https://www.motortrend.com/how-to/because-theres-more-to-a-starter-than-you-realize/
+
+# V - Potential, voltage
+# I - Current, amperage
+# R - Resistance, ohms
+# P - Power, wattage
+
+# Ohm's law: I = V / R (where R is held constant)
+# P = I * V
+# For resistors (where R is helod constant)
+#   = I^2 * R
+#   = V^2 / R
+
+
+# torque proportional to A
+# speed proportional to V
+
+
+# batteries are rated in terms of CCA - cold cranking amps
+
+# P = I * V
+# V = 12 (up to 14ish)
+# I = 300
+# P = 3600 or 3.6 kW
+
+
+# A starter rated at e.g. 2.2 kW will use more power on initial cranking
+# Sometimes up to 500 amperes are required, and some batteries will provide
+# over 600 cold cranking amps
+
+
+# Consider:
+
+# V = 12
+# R = resistance of battery, wiring, starter motor
+# L = inductance (approx 0)
+# I = current through motor
+# Vc = proportional to omega
+
+# rated power - Vc * I
+# input power - V * I
+# input power that is unable to be converted to output power is wasted as heat

data/lib/driving_physics/mruby.rb

@@ -0,0 +1,45 @@
+module DrivingPhysics
+  module CLI
+    # returns user input as a string
+    def self.prompt(msg = '')
+      print msg + ' ' unless msg.empty?
+      print '> '
+      $stdin.gets.chomp
+    end
+
+    # press Enter to continue, ignore input, return elapsed time
+    def self.pause(msg = '')
+      t = Timer.now
+      puts msg unless msg.empty?
+      puts '     [ Press Enter ]'
+      $stdin.gets
+      Timer.since(t)
+    end
+  end
+
+  module Timer
+    def self.now
+      Time.now
+    end
+
+    def self.since(t)
+      self.now - t
+    end
+
+    def self.elapsed(&work)
+      t = self.now
+      return yield, self.since(t)
+    end
+
+    # HH:MM:SS.mmm
+    def self.display(seconds: 0, ms: 0)
+      ms += (seconds * 1000).round if seconds > 0
+      DrivingPhysics.elapsed_display(ms)
+    end
+
+    def self.summary(start, num_ticks, paused = 0)
+      elapsed = self.since(start) - paused
+      format("%.3f s (%d ticks/s)", elapsed, num_ticks.to_f / elapsed)
+    end
+  end
+end

data/lib/driving_physics/tire.rb

@@ -26,14 +26,14 @@ module DrivingPhysics
 
     def initialize(env)
       @env = env
-      @radius = 350/1000r # m
-      @width  = 200/1000r # m
+      @radius = 0.35
+      @width  = 0.2
       @density = DENSITY
       @temp = @env.air_temp
-      @mu_s = 11/10r # static friction
-      @mu_k =  7/10r # kinetic friction
-      @base_friction = 5/10_000r
-      @omega_friction = 5/100_000r # scales with speed
+      @mu_s = 1.1 # static friction
+      @mu_k = 0.7 # kinetic friction
+      @base_friction = 5.0/10_000
+      @omega_friction = 5.0/100_000
       @roll_cof = DrivingPhysics::ROLL_COF
 
       yield self if block_given?

data/test/disk.rb

@@ -50,6 +50,7 @@ describe D do
       inertia = D.rotational_inertia(0.35, 25.0)
       expect(D.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
 
+      skip # Vector
       vector_torque = Vector[0, 0, 1000]
       vector_alpha = D.alpha vector_torque, inertia
       expect(vector_alpha).must_be_instance_of Vector
@@ -60,6 +61,7 @@ describe D do
 
   describe "Disk.torque_vector" do
     it "calculates a torque in the 3rd dimension given 2D force and radius" do
+      skip # Vector
       force = Vector[1000, 0]
       radius = Vector[0, 5]
       torque = D.torque_vector(force, radius)
@@ -71,6 +73,7 @@ describe D do
 
   describe "Disk.force_vector" do
     it "calculates a (3D) force given 3D torque and 2D radius" do
+      skip # Vector
       # let's invert the Disk.torque_vector case from above:
       torque = Vector[0, 0, 5000]
       radius = Vector[0, 5]

data/test/tire.rb

@@ -11,6 +11,7 @@ describe T do
       scalar_t = T.traction(scalar_nf, cof)
       expect(scalar_t).must_equal 10780.0
 
+      skip # Vector
       vector_nf = Vector[9800, 0]
       vector_t = T.traction(vector_nf, cof)
       expect(vector_t).must_equal Vector[10780.0, 0.0]
@@ -62,6 +63,7 @@ describe T do
       inertia = T.rotational_inertia(0.35, 25.0)
       expect(T.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
 
+      skip # Vector
       vector_torque = Vector[0, 0, 1000]
       vector_alpha = T.alpha vector_torque, inertia
       expect(vector_alpha).must_be_instance_of Vector
@@ -72,6 +74,7 @@ describe T do
 
   describe "Tire.torque_vector" do
     it "calculates a torque in the 3rd dimension given 2D force and radius" do
+      skip # Vector
       force = Vector[1000, 0]
       radius = Vector[0, 5]
       torque = T.torque_vector(force, radius)
@@ -84,6 +87,7 @@ describe T do
   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:
+      skip # Vector
       torque = Vector[0, 0, 5000]
       radius = Vector[0, 5]
       force = T.force_vector(torque, radius)
@@ -154,6 +158,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 # 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 +178,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 # Vector
       vector_nf = Vector[9800, 0]
       expect(@tire.tractable_torque(vector_nf)[0]).
         must_be_within_epsilon 3773.0

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.2.1
 platform: ruby
 authors:
 - Rick Hull
@@ -23,6 +23,8 @@ files:
 - demo/disk.rb
 - demo/gearbox.rb
 - demo/motor.rb
+- demo/mruby/disk.rb
+- demo/mruby/motor.rb
 - demo/powertrain.rb
 - demo/scalar_force.rb
 - demo/tire.rb
@@ -36,6 +38,7 @@ files:
 - lib/driving_physics/gearbox.rb
 - lib/driving_physics/imperial.rb
 - lib/driving_physics/motor.rb
+- lib/driving_physics/mruby.rb
 - lib/driving_physics/power.rb
 - lib/driving_physics/powertrain.rb
 - lib/driving_physics/scalar_force.rb