engine-tune 0.4.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Guts & Bolts LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,81 @@
+= EngineTune
+
+Interested in determining how well your engine will run under certain meteorological and geological conditions?
+
+This is the gem for you! (And I am sure there are a lot of you out there.)
+
+EngineTune returns the following calculations when supplied with altitude, altimeter (barometric pressure), temperature and dew point:
+
+* AE Relative Horsepower
+* Dyno Correction Factor
+* Air Density
+* Density Altitude
+* ICAO Relative Air Density
+* Virtual Temperature
+* Absolute Air Pressure
+* Vapor Pressure
+* Relative Humidity
+
+The calculations in this gem are modeled after  Richard Shelquist's Engine Tuner's Calculator, but have been re-factored to be more ruby-like. I urge you to read his technical articles on Density Altitude and Corrected Horsepower for detailed explanations of these concepts.
+
+http://wahiduddin.net/calc/calc_hp_dp.htm
+
+== Standard Usage
+
+<i>Note that all observations must be supplied using the metric system of measurement.</i>
+
+  observations = Hash.new
+  observations[:temperature] = 32.0 # Celsius
+  observations[:dew_point] = 22.0 # Celsius
+  observations[:altitude] = 149.0 # Meters
+  observations[:altimeter] = 1013.4 # Millibars
+
+  calculations = EngineTune.calculate(observations)
+
+  calculations.relative_horsepower
+    #=> 96.2 (as percentage)
+
+  calculations.density_altitude
+    #=> 876 (as meters)
+
+
+Calculations are returned in metric units, but if you prefer your calculations using the English system of measurement, do this:
+
+  calculations.metric = false
+
+  calculations.density_altitude
+    #=> 2874 (as feet)
+
+And if you forget what system of measurement your calculations object is using, just ask it:
+
+  calculations.metric = false
+
+  calculations.metric?
+    #=> false
+
+  calculations.english?
+    #=> true
+
+== The Calculator
+
+You can also bypass the calculations object and directly use the calculator:
+
+  temperature = 32.0 # Celsius
+  dew_point = 22.0 # Celsius
+  altitude = 149.0 # Meters
+  altimeter = 1013.4 # Millibars
+
+  EngineTune::Calculator.relative_horsepower(altimeter, altitude, dew_point, temperature)
+    #=> 96.2 (as percentage)
+
+Convenience methods to convert between metric and English units are provided as well:
+
+  EngineTune::Calculator.meters_to_feet 1054
+    #=> 3458.0052546
+
+  EngineTune::Calculator.inches_to_millibars 1223
+    #=> 41415.3694298
+
+== Copyright
+
+Copyright (c) 2010 Guts & Bolts LLC. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "engine-tune"
+    gem.summary = "Determine how well your engine will run under certain meteorological and geological conditions."
+    gem.description = "Determine how well your engine will run under certain meteorological and geological conditions."
+    gem.email = "theo@gutsbolts.com"
+    gem.homepage = "http://github.com/gutsbolts/engine-tune"
+    gem.authors = ["Theodore Mills"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "engine-tune #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.1

data/engine-tune.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{engine-tune}
+  s.version = "0.4.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Theodore Mills"]
+  s.date = %q{2010-07-07}
+  s.description = %q{Determine how well your engine will run under certain meteorological and geological conditions.}
+  s.email = %q{theo@gutsbolts.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "engine-tune.gemspec",
+     "lib/engine-tune.rb",
+     "lib/engine-tune/calculations.rb",
+     "lib/engine-tune/calculator.rb",
+     "test/helper.rb",
+     "test/test_calculations.rb",
+     "test/test_calculator.rb",
+     "test/test_engine_tune.rb",
+     "test/test_suite.rb"
+  ]
+  s.homepage = %q{http://github.com/gutsbolts/engine-tune}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Determine how well your engine will run under certain meteorological and geological conditions.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_calculations.rb",
+     "test/test_calculator.rb",
+     "test/test_engine_tune.rb",
+     "test/test_suite.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/engine-tune/calculations.rb

@@ -0,0 +1,103 @@
+module EngineTune
+  
+  #
+  # After getting instantiated with a set of meterological and geological observations, 
+  # a Calculations object can determine a number of calculations related to engine
+  # efficiency. 
+  #
+  class Calculations
+    
+    # Names of observations required for calculations to compute 
+    OBSERVATION_ATTRS = [:temperature, :dew_point, :altitude, :altimeter]    
+    OBSERVATION_ATTRS.each { |a| attr_accessor a }
+    
+    attr_writer :metric
+    
+    #
+    # Instantiates a new instance with a hash of observations including temperature, 
+    # dew_point, altimeter and altitude. These observations are the only required data
+    # to calculate all the engine tuning metrics exposed in this object. 
+    #
+    def initialize(observations)
+      observations.each { |method, value| send("#{method}=", value) }
+      @metric = true
+    end
+    
+    #
+    # Objects are equal if their observations are identical
+    #
+    def ==(object)
+      self.observations == object.observations
+    end
+    
+    #
+    # Returns a hash of observations for this set of calculations
+    #
+    def observations
+      OBSERVATION_ATTRS.inject({}) do |result, o| 
+        result[o] = send(o)
+        result
+      end
+    end
+    
+    #
+    # Returns true if calculations should be returned using the metric system
+    #
+    def metric?
+      @metric
+    end
+    
+    #
+    # Returns true if calculations should be returned using the English system
+    #
+    def english?
+      !@metric
+    end    
+    
+    def vapor_pressure
+      @vapor_pressure ||= EngineTune::Calculator.vapor_pressure(dew_point)
+      @vapor_pressure_inches ||= EngineTune::Calculator.millibars_to_inches(@vapor_pressure)
+      metric? ? @vapor_pressure : @vapor_pressure_inches
+    end
+    
+    def relative_humidity
+      @relative_humidity ||= EngineTune::Calculator.relative_humidity(temperature, dew_point)
+    end
+    
+    def absolute_pressure
+      @absolute_air_pressure ||= EngineTune::Calculator.absolute_pressure(altimeter, altitude)
+      @absolute_air_pressure_inches ||= EngineTune::Calculator.millibars_to_inches(@absolute_air_pressure)
+      metric? ? @absolute_air_pressure : @absolute_air_pressure_inches
+    end
+    
+    def density
+      @density ||= EngineTune::Calculator.density(altimeter, altitude, dew_point, temperature)
+    end
+    
+    def relative_density
+      @relative_density ||= EngineTune::Calculator.relative_density(altimeter, altitude, dew_point, temperature)
+    end
+    
+    def dyno_correction_factor
+      @dyno_correction_factor ||= EngineTune::Calculator.dyno_correction_factor(altimeter, altitude, dew_point, temperature)
+    end
+    
+    def virtual_temperature
+      @virtual_temperature ||= EngineTune::Calculator.virtual_temperature(altimeter, altitude, dew_point, temperature)
+      @virtual_temperature_f ||= EngineTune::Calculator.celsius_to_fahrenheit(@virtual_temperature)
+      metric? ? @virtual_temperature : @virtual_temperature_f
+    end
+    
+    def density_altitude
+      @density_altitude ||= EngineTune::Calculator.density_altitude(altimeter, altitude, dew_point, temperature)
+      @density_altitude_feet ||= EngineTune::Calculator.meters_to_feet(@density_altitude)
+      metric? ? @density_altitude : @density_altitude_feet
+    end
+    
+    def relative_horsepower
+      @relative_horsepower ||= EngineTune::Calculator.relative_horsepower(altimeter, altitude, dew_point, temperature)
+    end
+          
+  end
+
+end

data/lib/engine-tune/calculator.rb

@@ -0,0 +1,131 @@
+module EngineTune
+  
+  #
+  # A collection of formulas and calculations used to determine, among other things,
+  # the relative horsepower of an engine given different environmental conditions.
+  #
+  # These calculations are modeled after Richard Shelquist's Engine Tuner's Calculator, 
+  # but have been re-factored to be more ruby-like. I urge you to read his technical 
+  # articles on Density Altitude and Corrected Horsepower for detailed explanations of 
+  # these concepts.
+  #
+  # In some cases I took a guess at what a method should be named based on the calculation
+  # it is returning, so any better suggestions are welcomed. 
+  #
+  module Calculator
+    class << self
+      
+      def density_altitude(altimeter, altitude, dew_point, temperature)          
+          # Calculate geometric altitude Z (m) from geopotential altitude (m) H          
+          densaltzm = self.altitude_z(altimeter, altitude, dew_point, temperature)
+          unless (-5000..11000).include?(densaltzm)
+            	raise "Out of range for Troposhere Algorithm: Altitude =" + densaltzm.round + " meters"
+          end
+          densaltzm.round
+      end
+      
+      def dyno_correction_factor(altimeter, altitude, dew_point, temperature)        
+        vapor_pressure_mb = self.vapor_pressure(dew_point)
+        absolute_pressure_mb = self.absolute_pressure(altimeter, altitude)
+        absolute_pressure_in = millibars_to_inches(absolute_pressure_mb)
+        vapor_pressure_in = millibars_to_inches(vapor_pressure_mb)        
+        p1 = 29.235 / (absolute_pressure_in - vapor_pressure_in)
+      	p2 = ((temperature + 273) / 298)**0.5
+      	(1.18 * (p1 * p2) - 0.18)
+      end
+    
+
+      def virtual_temperature(altimeter, altitude, dew_point, temperature)        
+        absolute_pressure = self.absolute_pressure(altimeter, altitude)
+        vapor_pressure = self.vapor_pressure(dew_point)
+        ((temperature + 273.15) / (1- (0.377995 * vapor_pressure / absolute_pressure)))-273.15
+      end
+    
+      #
+      # Polynomial from Herman Wobus       
+      #
+      def vapor_pressure(temperature_c)                
+        values = [ 1.1112018e-17, -1.7892321e-15, 2.1874425e-13, -2.9883885e-11, 4.3884187e-09, -6.1117958e-07, 7.8736169e-05, -0.0090826951, 0.99999683 ]
+        pol = values.inject(-0.30994571E-19) { |result, v| result = v + temperature_c * result }        
+      	6.1078 / (pol**8)
+      end
+    
+      def geopotential_altitude(elevation_in_meters)        
+      	r = 6369E3;
+        ((r * elevation_in_meters) / (r + elevation_in_meters))
+      end
+    
+      def density(altimeter, altitude, dew_point, temperature)
+      	vapor_pressure = self.vapor_pressure(dew_point)
+      	absolute_pressure = self.absolute_pressure(altimeter, altitude) 
+      	
+      	rv, rd = 461.4964, 287.0531
+      	temperature_k = temperature + 273.15
+      	pv = vapor_pressure * 100
+      	pd = (absolute_pressure - vapor_pressure) * 100
+      	(pv / (rv * temperature_k)) + (pd / (rd * temperature_k))
+      end
+
+      def altitude(altimeter, elevation, dew_point, temperature)
+        density = self.density(altimeter, elevation, dew_point, temperature)
+      	g, po, to, l, r, m = 9.80665, 101325, 288.15, 6.5, 8.314320, 28.9644
+      	density = density * 1000
+      	p2 = ( (l * r)/(g* m - l * r) ) * Math.log( (r * to * density) / (m * po) )
+      	h = -(to / l)*( Math.exp(p2) -1 )
+      	h * 1000
+      end
+    
+      def altitude_z(altimeter, elevation, dew_point, temperature)
+      	altitude = self.altitude(altimeter, elevation, dew_point, temperature)
+      	r = 6369E3
+      	((r * altitude) / (r - altitude))
+      end
+    
+
+      def absolute_pressure(altimeter, altitude)
+      	k1, k2 = 0.190263, 8.417286E-5      	
+      	((altimeter**k1)-(k2 * self.geopotential_altitude(altitude)))**(1/k1)
+      end
+    
+      def relative_density(altimeter, altitude, dew_point, temperature)
+        density = self.density(altimeter, altitude, dew_point, temperature)
+        100 * (density / 1.225)
+      end
+    
+      def relative_humidity(temperature, dew_point)
+        (vapor_pressure(dew_point) / vapor_pressure(temperature)) * 100
+      end
+      
+      def relative_horsepower(altimeter, altitude, dew_point, temperature)
+        dyno_correction_factor = self.dyno_correction_factor(altimeter, altitude, dew_point, temperature)
+        round((100 / dyno_correction_factor), 1)
+      end
+      
+      #
+      # Systems of measurement conversion methods
+      #
+      
+      def millibars_to_inches(mb)
+        mb * (1/33.86389)
+      end
+      
+      def inches_to_millibars(inches)
+        inches * 33.8637526
+      end
+      
+      def meters_to_feet(meters)
+        meters * 3.2808399
+      end
+  
+      def round(f, d)
+        (f * 10**d).round.to_f / 10**d
+      end
+      
+      def celsius_to_fahrenheit(temp)
+        ((temp * 9.0) / 5.0) + 32.0
+      end
+      
+    end    
+    
+  end
+end

data/lib/engine-tune.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "engine-tune/calculations"
+require "engine-tune/calculator"
+
+#
+# An engine's efficiency can be impacted by environmental factors such as 
+# altitude and temperature. EngineForecast first collects environmental data 
+# based on the supplied latitude and longitude and then returns a set of calculations
+# to determine how great that impact is. 
+#
+module EngineTune
+  
+  def self.calculate(observations)
+    EngineTune::Calculations.new(observations)
+  end
+  
+end

data/test/helper.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'engine-tune'
+
+class Test::Unit::TestCase
+  def observations
+    { :altitude => 149.0, :temperature => 32.0, :dew_point=>22.0, :altimeter=>1013.4  }
+  end
+
+  def round(f, d)
+    (f * 10**d).round.to_f / 10**d
+  end
+
+  def self.correct_answers
+    {
+      :vapor_pressure => 26.4295210976309,
+      :density_altitude => 876,
+      :dyno_correction_factor => 1.0394157966139073,
+      :relative_horsepower => 96.2,
+      :virtual_temperature => 35.09294483203081,
+      :geopotential_altitude => 148.99651429099868,
+      :density => 1.1252290472090851,
+      :relative_density => 91.85543242523143,
+      :altitude => 876.1337602041878,
+      :altitude_z => 876.2542996883268,
+      :absolute_pressure => 995.6262086849655,
+      :relative_humidity => 55.58171762613951
+    }
+  end
+end

data/test/test_calculations.rb

@@ -0,0 +1,42 @@
+require 'helper'
+
+class EngineTune::TestCalculations < Test::Unit::TestCase
+  
+  def setup
+    @calculations = EngineTune::Calculations.new(observations)
+  end
+    
+  self.correct_answers.each do |method, answer|
+
+    # List of methods inside correct answers hash that are not exposed
+    # on the Calculations object so don't create a test for them
+    exceptions = [:geopotential_altitude, :altitude, :altitude_z]
+    
+    unless exceptions.include?(method)
+      define_method "test_calculations_#{method}" do
+        assert_equal round(answer, 13), round(@calculations.send(method), 13)
+      end
+    end
+  end
+  
+  def test_vapor_pressure_inches
+    @calculations.metric = false
+    assert_equal 0.780463233775887, round(@calculations.vapor_pressure, 15)
+  end
+  
+  def test_absolute_pressure_inches
+    @calculations.metric = false
+    assert_equal 29.4008221939348, round(@calculations.absolute_pressure, 13)
+  end
+  
+  def test_virtual_temperature_fahrenheit
+    @calculations.metric = false
+    assert_equal 95.1673006976555, round(@calculations.virtual_temperature, 13)
+  end
+
+  def test_density_altitude_feet
+    @calculations.metric = false
+    assert_equal 2874.0157524, round(@calculations.density_altitude, 7)
+  end
+  
+end

data/test/test_calculator.rb

@@ -0,0 +1,95 @@
+require 'helper'
+
+class EngineTune::TestCalculator < Test::Unit::TestCase
+  
+  def setup
+    observations.each { |k, v| instance_variable_set("@#{k}", v)}
+  end
+  
+  def correct_answers
+    Test::Unit::TestCase.correct_answers
+  end
+  
+  def test_vapor_pressure
+    value = EngineTune::Calculator.vapor_pressure(@dew_point)    
+    assert_equal correct_answers[:vapor_pressure] , round(value, 13)
+  end
+  
+  def test_density_altitude
+    value = EngineTune::Calculator.density_altitude(@altimeter, @altitude, @dew_point, @temperature)
+    assert_equal correct_answers[:density_altitude], value
+  end
+  
+  def test_dyno_correction_factor
+    value = EngineTune::Calculator.dyno_correction_factor(@altimeter, @altitude, @dew_point, @temperature)    
+    assert_equal correct_answers[:dyno_correction_factor], value
+  end
+  
+  def test_relative_horsepower
+    value = EngineTune::Calculator.relative_horsepower(@altimeter, @altitude, @dew_point, @temperature)
+    assert_equal correct_answers[:relative_horsepower], value
+  end
+  
+  def test_virtual_temperature
+    value = EngineTune::Calculator.virtual_temperature(@altimeter, @altitude, @dew_point, @temperature)
+    assert_equal correct_answers[:virtual_temperature], value
+  end
+  
+  def test_geopotential_altitude
+    assert_equal correct_answers[:geopotential_altitude], EngineTune::Calculator.geopotential_altitude(@altitude)
+  end
+  
+  def test_density
+    value = EngineTune::Calculator.density(@altimeter, @altitude, @dew_point, @temperature)
+    assert_equal correct_answers[:density], value
+  end
+  
+  def relative_density
+    value = EngineTune::Calculator.relative_density(@altimeter, @altitude, @dew_point, @temperature)
+    assert_equal correct_answers[:relative_density], value
+  end
+  
+  def test_altitude
+    value = EngineTune::Calculator.altitude(@altimeter, @altitude, @dew_point, @temperature)
+    assert_equal correct_answers[:altitude], value
+  end
+    
+  def test_altitude_z
+    value = EngineTune::Calculator.altitude_z(@altimeter, @altitude, @dew_point, @temperature)
+    assert_equal correct_answers[:altitude_z], value
+  end
+
+  def test_absolute_pressure
+    value = EngineTune::Calculator.absolute_pressure(@altimeter, @altitude)
+    assert_equal correct_answers[:absolute_pressure], value
+  end
+    
+  def test_relative_humidity
+    z = EngineTune::Calculator.relative_humidity(@temperature, @dew_point)
+    assert_equal round(correct_answers[:relative_humidity], 13), round(z, 13)
+  end
+  
+  # Measurement conversion tests
+  
+  def test_inches_to_millibars
+    assert_equal 997.96, round(EngineTune::Calculator.inches_to_millibars(29.47), 2)
+  end
+  
+  def test_millibars_to_inches
+    assert_equal 29.47, round(EngineTune::Calculator.millibars_to_inches(998), 2)
+  end
+  
+  def test_meters_to_feet
+    assert_equal 3458.0052546, EngineTune::Calculator.meters_to_feet(1054)
+  end
+
+  def test_round
+    number = 21345.56789999
+    assert_equal 21345.57, EngineTune::Calculator.round(number, 2)
+  end
+  
+  def test_celsius_to_fahrenheit
+    assert_equal 80.6, EngineTune::Calculator.celsius_to_fahrenheit(27)
+  end
+    
+end

data/test/test_engine_tune.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class EngineTune::TestEngineTune < Test::Unit::TestCase
+  
+  def test_calculate
+    assert_equal EngineTune::Calculations.new(observations), EngineTune.calculate(observations)
+  end
+  
+end

data/test/test_suite.rb

@@ -0,0 +1,5 @@
+require 'test_calculations'
+require 'test_calculator'
+require 'test_engine_tune'
+
+puts EngineTune::Calculator.inches_to_millibars 1223 

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: engine-tune
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 1
+  version: 0.4.1
+platform: ruby
+authors: 
+- Theodore Mills
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-07 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Determine how well your engine will run under certain meteorological and geological conditions.
+email: theo@gutsbolts.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- engine-tune.gemspec
+- lib/engine-tune.rb
+- lib/engine-tune/calculations.rb
+- lib/engine-tune/calculator.rb
+- test/helper.rb
+- test/test_calculations.rb
+- test/test_calculator.rb
+- test/test_engine_tune.rb
+- test/test_suite.rb
+has_rdoc: true
+homepage: http://github.com/gutsbolts/engine-tune
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Determine how well your engine will run under certain meteorological and geological conditions.
+test_files: 
+- test/helper.rb
+- test/test_calculations.rb
+- test/test_calculator.rb
+- test/test_engine_tune.rb
+- test/test_suite.rb