driving_physics 0.0.2.1 → 0.0.3.1

data/test/disk.rb

@@ -1,116 +1,78 @@
 require 'minitest/autorun'
 require 'driving_physics/disk'
+require 'matrix'
 
-D = DrivingPhysics::Disk
+include DrivingPhysics
 
-describe D do
+describe Disk do
   describe "Disk.volume" do
     it "calculates the volume (m^3) of disk given radius and width" do
-      cubic_m = D.volume(1.0, 1.0)
+      cubic_m = Disk.volume(1.0, 1.0)
       expect(cubic_m).must_equal Math::PI
 
-      cubic_m = D.volume(0.35, 0.2)
+      cubic_m = Disk.volume(0.35, 0.2)
       expect(cubic_m).must_be_within_epsilon 0.076969
     end
   end
 
   describe "Disk.volume_l" do
     it "calculates the volume (L) of a disk given radius and width" do
-      liters = D.volume_l(1.0, 1.0)
+      liters = Disk.volume_l(1.0, 1.0)
       expect(liters).must_equal Math::PI * 1000
 
-      liters = D.volume_l(0.35, 0.2)
+      liters = Disk.volume_l(0.35, 0.2)
       expect(liters).must_be_within_epsilon 76.96902
     end
   end
 
   describe "Disk.density" do
     it "calculates the density (kg/L) given mass and volume" do
-      expect(D.density(25.0, 25.0)).must_equal 1.0
-      expect(D.density(50.0, 25.0)).must_equal 2.0
+      expect(Disk.density(25.0, 25.0)).must_equal 1.0
+      expect(Disk.density(50.0, 25.0)).must_equal 2.0
     end
   end
 
   describe "Disk.mass" do
     it "calculates the mass (kg) of a disk given radius, width, and density" do
-      skip
-      expect(D.mass(0.35, 0.2, D::DENSITY)).must_be_within_epsilon 25.015
+      expect(Disk.mass(0.35, 0.2, Disk::DENSITY)).must_be_within_epsilon 76.969
     end
   end
 
   describe "Disk.rotational_inertia" do
     it "calculates rotational inertia for a disk given radius and mass" do
-      expect(D.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
+      expect(Disk.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
     end
   end
 
   describe "Disk.alpha" do
     it "calculates angular acceleration from torque and inertia" do
       scalar_torque = 1000
-      inertia = D.rotational_inertia(0.35, 25.0)
-      expect(D.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
+      inertia = Disk.rotational_inertia(0.35, 25.0)
+      expect(Disk.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
 
-      skip # Vector
+      skip unless DrivingPhysics.has_vector?
       vector_torque = Vector[0, 0, 1000]
-      vector_alpha = D.alpha vector_torque, inertia
+      vector_alpha = Disk.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 "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)
-      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 "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]
-      force = D.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 = D.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
-      @disk = D.new(@env)
+      @disk = Disk.new(@env)
     end
 
     it "initializes" do
-      skip
-      expect(@disk).must_be_instance_of D
-      expect(@disk.density).must_equal D::DENSITY # sanity check
-      expect(@disk.mass).must_be_within_epsilon 25.01
-
-      with_mass = D.new(@env) { |w|
-        w.mass = 99.01
-      }
+      expect(@disk).must_be_instance_of Disk
+      expect(@disk.density).must_equal Disk::DENSITY # sanity check
+      expect(@disk.mass).must_be_within_epsilon 76.969
+
+      with_mass = Disk.new(@env) { |w| w.mass = 99.01 }
       expect(with_mass.mass).must_equal 99.01
-      expect(with_mass.density).wont_equal D::DENSITY
+      expect(with_mass.density).wont_equal Disk::DENSITY
     end
 
     it "has a string representation" do
@@ -125,8 +87,7 @@ describe D do
     end
 
     it "has inertia" do
-      skip
-      expect(@disk.rotational_inertia).must_be_within_epsilon 1.5321
+      expect(@disk.rotational_inertia).must_be_within_epsilon 4.714
     end
   end
 end

data/test/gearbox.rb

@@ -0,0 +1,36 @@
+require 'minitest/autorun'
+require 'driving_physics/gearbox'
+
+include DrivingPhysics
+
+describe Gearbox do
+  it "has gear ratios" do
+  end
+
+  it "has a final drive" do
+  end
+
+  it "has a neutral gear" do
+  end
+
+  it "has a clutch with state" do
+  end
+
+  it "has mass" do
+  end
+
+  it "has rotating mass" do
+  end
+
+  it "converts crank torque to axle torque" do
+  end
+
+  it "has losses due to inertia and friction" do
+  end
+
+  it "converts crank omega to axle omega (and vice versa)" do
+  end
+
+  it "varies torque delivery based on gear ratio and clutch" do
+  end
+end

data/test/motor.rb

@@ -0,0 +1,236 @@
+require 'minitest/autorun'
+require 'driving_physics/motor'
+
+include DrivingPhysics
+
+describe "interpolate" do
+  it "validates xs and ys match in size" do
+    xs = [0, 5, 10, 15, 20]
+    ys = [10, 10, 10, 10, 5]
+    expect(DrivingPhysics.interpolate(1, xs: xs, ys: ys)).must_equal 10
+    expect { DrivingPhysics.interpolate(1, xs: xs + [10], ys: ys) }.must_raise
+    expect { DrivingPhysics.interpolate(1, xs: xs, ys: ys + [10]) }.must_raise
+  end
+
+  it "validates x is within the range of xs" do
+    xs = [0, 5, 10, 15, 20]
+    ys = [10, 10, 10, 10, 5]
+    expect(DrivingPhysics.interpolate(1, xs: xs, ys: ys)).must_equal 10
+    expect { DrivingPhysics.interpolate(-1, xs: xs, ys: ys) }.must_raise
+    expect { DrivingPhysics.interpolate(25, xs: xs, ys: ys) }.must_raise
+  end
+
+  it "validates the xs are in ascending order" do
+    xs = [0, 5, 10, 15, 20]
+    ys = [10, 10, 10, 10, 5]
+    expect(DrivingPhysics.interpolate(1, xs: xs, ys: ys)).must_equal 10
+    xs[1] = 15
+    expect {
+      DrivingPhysics.interpolate(16, xs: xs, ys: ys)
+    }.must_raise
+  end
+
+  it "performs linear interpolation to yield a y value for a valid x" do
+    xs = [0, 5, 10, 15, 20]
+    ys = [5, 5, 10, 10, 15]
+
+    expect(DrivingPhysics.interpolate(0, xs: xs, ys: ys)).must_equal 5
+    expect(DrivingPhysics.interpolate(1, xs: xs, ys: ys)).must_equal 5
+    expect(DrivingPhysics.interpolate(4, xs: xs, ys: ys)).must_equal 5
+    expect(DrivingPhysics.interpolate(5, xs: xs, ys: ys)).must_equal 5
+    expect(DrivingPhysics.interpolate(6, xs: xs, ys: ys)).must_equal 6
+    expect(DrivingPhysics.interpolate(7, xs: xs, ys: ys)).must_equal 7
+    expect(DrivingPhysics.interpolate(8, xs: xs, ys: ys)).must_equal 8
+    expect(DrivingPhysics.interpolate(9, xs: xs, ys: ys)).must_equal 9
+    expect(DrivingPhysics.interpolate(10, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(11, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(12, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(14, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(15, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(16, xs: xs, ys: ys)).must_equal 11
+    expect(DrivingPhysics.interpolate(17, xs: xs, ys: ys)).must_equal 12
+    expect(DrivingPhysics.interpolate(18, xs: xs, ys: ys)).must_equal 13
+    expect(DrivingPhysics.interpolate(19, xs: xs, ys: ys)).must_equal 14
+    expect(DrivingPhysics.interpolate(20, xs: xs, ys: ys)).must_equal 15
+  end
+end
+
+# shorthand
+def tc(rpms, torques)
+  TorqueCurve.new(rpms: rpms, torques: torques)
+end
+
+describe TorqueCurve do
+  before do
+    @default = TorqueCurve.new
+    @rpms =    [500, 1000, 3500, 6000, 7000, 7100]
+    @torques = [  0,  100,  300,  300,  250,    0]
+    @minr = [0, 1]
+    @mint = [0, 0]
+  end
+
+  it "maps rpm values to torque values" do
+    expect(@default.torque(3500)).must_be(:>, 100)
+  end
+
+  describe "initialize" do
+    it "accepts two arrays: rpms, and the corresponding torques" do
+      expect(tc(@rpms, @torques)).must_be_kind_of(TorqueCurve)
+    end
+
+    it "has defaults for rpms and torques" do
+      expect(@default).must_be_kind_of(TorqueCurve)
+    end
+
+    it "validates size match for rpms and torques" do
+      expect(  tc(  @minr, @mint) ).must_be_kind_of TorqueCurve
+      expect { tc(    [0], @mint) }.must_raise
+      expect { tc([0,1,2], @mint) }.must_raise
+      expect { tc(@minr,     [0]) }.must_raise
+      expect { tc(@minr, [0,1,0]) }.must_raise
+
+      rpms = [100, 2000, 30_000]
+      torques = [0, 500, 0]
+
+      expect(  tc( rpms, torques) ).must_be_kind_of TorqueCurve
+      expect { tc( rpms,  [0, 0]) }.must_raise
+      expect { tc([1,2], torques) }.must_raise
+      expect { tc([1,2,3,4], torques) }.must_raise
+    end
+
+
+    describe "rpms" do
+      it "validates rpms are positive" do
+        expect(  tc(    @minr, @mint) ).must_be_kind_of TorqueCurve
+        expect { tc([-10, 10], @mint) }.must_raise
+      end
+
+      it "validates rpms are in ascending order" do
+        expect(  tc( @minr, @mint) ).must_be_kind_of TorqueCurve
+        expect { tc([0, 0], @mint) }.must_raise
+        expect(  tc([99, 100], @mint) ).must_be_kind_of TorqueCurve
+        expect { tc([100, 99], @mint) }.must_raise
+      end
+    end
+
+    describe "torques" do
+      it "validates that torques start and end at zero" do
+        expect(  tc(@minr, @mint) ).must_be_kind_of TorqueCurve
+        expect { tc(@minr, [1,0]) }.must_raise
+        expect { tc(@minr, [0,1]) }.must_raise
+        expect { tc(@minr, [1,1]) }.must_raise
+
+        expect(  tc([1,2,3], [0,500,0]) ).must_be_kind_of TorqueCurve
+        expect { tc([1,2,3], [1,500,0]) }.must_raise
+        expect { tc([1,2,3], [0,500,1]) }.must_raise
+      end
+
+      it "validates that torques are positive" do
+        expect(  tc([1,2,3], [0, 5,0]) ).must_be_kind_of TorqueCurve
+        expect { tc([1,2,3], [0,-5,0]) }.must_raise
+      end
+    end
+  end
+
+  it "finds the peak torque and corresponding RPM" do
+    rpm, torque = *@default.peak
+    expect(rpm).must_be(:>, 1000)
+    expect(rpm).must_be(:<, 10_000)
+    expect(torque).must_be(:>, 0)
+    expect(torque).must_be(:<, 10_000)
+  end
+
+  it "interpolates to find the torque for a valid RPM" do
+    tc = tc(@rpms, @torques)
+    r1 = @rpms[1]
+    r2 = @rpms[2]
+
+    expect(tc.torque(r1)).must_equal @torques[1]
+    expect(tc.torque(r2)).must_equal @torques[2]
+
+    r3 = (r1 + r2) / 2
+    t3 = tc.torque(r3)
+    t3_expect = (@torques[1] + @torques[2]) / 2.0
+
+    expect(t3).must_be :>, @torques[1]
+    expect(t3).must_be :<, @torques[2]
+    expect(t3).must_be :>=, t3_expect.floor
+    expect(t3).must_be :<=, t3_expect.ceil
+  end
+
+  it "tracks min, idle, redline, and max rpms" do
+    expect(@default.min).must_be :>, 0
+    expect(@default.min).must_be :<, 1000
+    expect(@default.idle).must_be :>, @default.min
+    expect(@default.idle).must_be :<, 3000
+    expect(@default.redline).must_be :>, @default.idle
+    expect(@default.redline).must_be :<, 20_000
+    expect(@default.max).must_be :>, @default.redline
+    expect(@default.max).must_be :<, 20_000
+  end
+end
+
+describe Motor do
+  before do
+    @default = Motor.new(Environment.new)
+  end
+
+  it "has a throttle with state" do
+    expect(@default.throttle).must_equal 0.0
+    @default.throttle = 0.5
+    expect(@default.throttle).must_equal 0.5
+    expect(@default.throttle_pct).must_equal "50.0%"
+
+    expect { @default.throttle = 1.5 }.must_raise
+  end
+
+  it "has mass" do
+    expect(@default.mass).must_be :>, 0
+    expect(@default.fixed_mass).must_be :>, 0
+    expect(@default.rotating_mass).must_be :>, 0
+  end
+
+  it "has a torque curve" do
+    expect(@default.torque_curve).must_be_kind_of TorqueCurve
+  end
+
+  it "has idle RPM and redline RPM" do
+    expect(@default.idle).must_be :>, 500
+    expect(@default.idle).must_be :<, 1500
+
+    expect(@default.redline).must_be :>, @default.idle
+    expect(@default.redline).must_be :<, 10_000
+  end
+
+  it "has inertia and energy" do
+    expect(@default.inertia).must_be :>, 0
+    expect(@default.energy(99)).must_be :>, 0
+  end
+
+  it "determines crank alpha from torque" do
+    expect(@default.alpha(50)).must_be :>, 0
+  end
+
+  it "determines torque from crank alpha" do
+    a = @default.alpha(50, omega: 20)
+    t = @default.implied_torque(a)
+    # frictional losses
+    expect(t).must_be :>, 40
+    expect(t).must_be :<, 50
+  end
+
+  it "determines torque based on torque curve, RPM and throttle" do
+    @default.throttle = 1.0
+    expect(@default.torque(1000)).must_be :>, 0
+    expect(@default.torque(3500)).must_be :>, @default.torque(1000)
+  end
+
+  it "has an engine braking effect when the throttle is closed" do
+    @default.throttle = 0
+    expect(@default.torque(3500)).must_be :<, 0
+  end
+
+  it "has a starter motor to get running" do
+    expect(@default.starter_torque).must_be :>, 0
+  end
+end

data/test/powertrain.rb

@@ -0,0 +1,21 @@
+require 'minitest/autorun'
+require 'driving_physics/powertrain'
+
+include DrivingPhysics
+
+describe Powertrain do
+  it "has a motor and a gearbox" do
+  end
+
+  it "has mass" do
+  end
+
+  it "coverts rpm to axle torque" do
+  end
+
+  it "converts rpm to axle omega" do
+  end
+
+  it "determines crank rpm from axle_omega" do
+  end
+end

data/test/scalar_force.rb

@@ -12,8 +12,7 @@ describe ScalarForce do
   # ROT_COF's value is from observing that rotational resistance
   # matches air resistance at roughly 30 m/s in street cars
   it "approximates a reasonable rotational resistance constant" do
-    expect(30 * ScalarForce.air_resistance(1)).
-      must_be_within_epsilon(-1 * ROT_COF)
+    _(30 * ScalarForce.air_resistance(1)).must_be_within_epsilon(-1 * ROT_COF)
   end
 
   it "approximates a positive drag force" do
@@ -21,12 +20,10 @@ describe ScalarForce do
   end
 
   it "approximates a positive rotational resistance force" do
-    expect(ScalarForce.rotational_resistance 30).
-      must_be_within_epsilon(-383.13)
+    _(ScalarForce.rotational_resistance 30).must_be_within_epsilon(-383.13)
   end
 
   it "approximates a positive rolling resistance force" do
-    nf = 1000 * G
-    expect(ScalarForce.rolling_resistance nf).must_be_within_epsilon(-98.0)
+    _(ScalarForce.rolling_resistance(1000 * G)).must_be_within_epsilon(-98.0)
   end
 end

data/test/tire.rb

@@ -1,128 +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 # Vector
+      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 # Vector
+      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
-      skip # Vector
-      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:
-      skip # Vector
-      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
@@ -158,7 +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 # Vector
+      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).
@@ -178,7 +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 # Vector
+      skip unless DrivingPhysics.has_vector?
       vector_nf = Vector[9800, 0]
       expect(@tire.tractable_torque(vector_nf)[0]).
         must_be_within_epsilon 3773.0