engineering_calculator 1.0.0 → 2.0.0

data/Gemfile

@@ -1,4 +1,3 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in engineering-calculator.gemspec
-gemspec
+gemspec

data/bin/engineering_calculator

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "engineering_calculator"
+
+calculator = EngineeringCalculator.init

data/engineering-calculator.gemspec

@@ -4,9 +4,9 @@ require File.expand_path('../lib/engineering_calculator/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Thomas Muntaner"]
   gem.email         = ["thomas.muntaner@gmail.com"]
-  gem.description   = %q{Provides engineering functions for ruby}
+  gem.description   = %q{Engineering calculator for ruby}
   gem.summary       = %q{Engineering Calculator}
-  gem.homepage      = "http://www.engineering-calculator.com"
+  gem.homepage      = "http://engineering-calculator.herokuapp.com"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")

data/lib/engineering_calculator/calculator/gas_dynamics_calculator.rb

@@ -0,0 +1,143 @@
+require "gas_dynamics"
+
+module EngineeringCalculator
+  class GasDynamicsCalculator
+    @@functions = ['fanno',
+                  'isentropic',
+                  'normal_shock',
+                  'oblique', 
+                  'prandtl_compression', 
+                  'prandtl_expansion', 
+                  'rayleigh']
+
+    def self.functions
+      display_functions
+    end
+
+    def self.function(fun)
+      if @@functions.include?(fun)
+        perform(fun)
+      else
+        display_functions
+      end
+    end
+
+    private
+
+    def self.perform(fun)
+      case fun
+      when 'fanno'
+        fanno
+      when 'isentropic'
+        isentropic
+      when 'normal_shock'
+        normal_shock
+      when 'oblique'
+        oblique
+      when 'prandtl_expansion'
+        prandtl_expansion
+      when 'prandtl_compression'
+        prandtl_compression
+      when 'rayleigh'
+        rayleigh
+      end
+    end
+
+    def self.display_functions
+      OutputManager.function_output_list(@@functions, "Gas Dynamics Functions")
+    end
+
+    def self.fanno
+      OutputManager.prompt("m:")
+      m = gets.chomp.to_f
+      OutputManager.prompt("gamma(1.4):")
+      gamma = gets.chomp.to_f
+      if m > 0 and gamma > 1
+        OutputManager.output_results(GasDynamics.fanno(m,gamma))
+      else
+        OutputManager.warning("Invalid Values")
+      end
+    end
+
+    def self.isentropic
+      OutputManager.prompt("m:")
+      m = gets.chomp.to_f
+      OutputManager.prompt("gamma(1.4):")
+      gamma = gets.chomp.to_f
+      if m > 0 and gamma > 1
+        OutputManager.output_results(GasDynamics.isentropic(m,gamma))
+      else
+        OutputManager.warning("Invalid Values")
+      end
+    end
+
+    def self.normal_shock
+      OutputManager.prompt("mx:")
+      mx = gets.chomp.to_f
+      OutputManager.prompt("gamma(1.4):")
+      gamma = gets.chomp.to_f
+      if mx > 0 and gamma > 1
+        OutputManager.output_results(GasDynamics.normal_shock(mx,gamma))
+      else
+        OutputManager.warning("Invalid Values")
+      end
+    end
+
+    def self.oblique
+      OutputManager.prompt("mx:")
+      mx = gets.chomp.to_f
+      OutputManager.prompt("gamma(1.4):")
+      gamma = gets.chomp.to_f
+      OutputManager.prompt("Turning Angle:")
+      delta = gets.chomp.to_f
+
+      if mx > 0 and gamma > 1
+        OutputManager.output_results(GasDynamics.oblique(mx,gamma,delta))
+      else
+        OutputManager.warning("Invalid Values")
+      end
+    end
+
+    def self.prandtl_compression
+      OutputManager.prompt("mx:")
+      mx = gets.chomp.to_f
+      OutputManager.prompt("gamma(1.4):")
+      gamma = gets.chomp.to_f
+      OutputManager.prompt("Turning Angle:")
+      delta = gets.chomp.to_f
+
+      if mx > 0 and gamma > 1
+        OutputManager.output_results(GasDynamics.prandtl_compression(mx,gamma,delta))
+      else
+        OutputManager.warning("Invalid Values")
+      end
+    end
+
+    def self.prandtl_expansion
+      OutputManager.prompt("mx:")
+      mx = gets.chomp.to_f
+      OutputManager.prompt("gamma(1.4):")
+      gamma = gets.chomp.to_f
+      OutputManager.prompt("Turning Angle:")
+      delta = gets.chomp.to_f
+
+      if mx > 0 and gamma > 1
+        OutputManager.output_results(GasDynamics.prandtl_expansion(mx,gamma,delta))
+      else
+        OutputManager.warning("Invalid Values")
+      end
+    end
+
+    def self.rayleigh
+      OutputManager.prompt("m:")
+      m = gets.chomp.to_f
+      OutputManager.prompt("gamma(1.4):")
+      gamma = gets.chomp.to_f
+      if m > 0 and gamma > 1
+        OutputManager.output_results(GasDynamics.rayleigh(m,gamma))
+      else
+        OutputManager.warning("Invalid Values")
+      end
+    end
+  end
+end

data/lib/engineering_calculator/calculator/support/action_manager.rb

@@ -0,0 +1,49 @@
+module EngineeringCalculator
+  class ActionManager
+
+    @@actions = ['use','calculators','quit', 'function', 'functions']
+
+    def self.action?(action)
+      is_action?(action)
+    end
+
+    def self.actions
+      formatted_actions(@@actions)
+    end
+
+    def self.perform(call,args=nil)
+      call_method(call,args)
+    end
+
+    private
+
+    def self.formatted_actions(actions)
+      actions.join(", ")
+    end
+
+    def self.is_action?(action)
+      return true if @@actions.include?(action)
+      return false
+    end
+
+    def self.call_method(call,args=nil)
+      case call
+      when 'use'
+        Calculator.use_calculator(args)
+      when 'calculators'
+        Calculator.calculator_list
+      when 'functions'
+        Calculator.functions
+      when 'function'
+        Calculator.function(args)
+      when 'quit'
+        return :quit
+      else
+        OutputManager.warning("Invalid action")
+        return false
+      end
+      return true
+    end
+
+  end
+end

data/lib/engineering_calculator/calculator/support/float_extend.rb

@@ -0,0 +1,6 @@
+class Float
+  def precision(pre)
+    mult = 10 ** pre
+    (self * mult).round.to_f / mult
+  end
+end

data/lib/engineering_calculator/calculator/support/output_manager.rb

@@ -0,0 +1,104 @@
+module EngineeringCalculator
+  class OutputManager
+
+    def self.title(text)
+      text "#{text.center(60).upcase}"
+    end
+
+    def self.prompt(text)
+      print "#{text} "
+    end
+
+    def self.message(text)
+      text "#{text.center(60)}"
+    end
+
+    def self.warning(text)
+      text "#{text.center(60)}"
+    end
+
+    def self.display_actions
+      text "Valid actions: #{ActionManager.actions}"
+    end
+
+    def self.display_welcome
+      text "<<< Engineering Calculator >>>"
+    end
+
+    def self.display_goodbye
+      text "<<< Goodbye >>>"
+    end
+
+    def self.output_list(array,title = nil)
+      format_list(array,title)
+    end
+
+    def self.function_output_list(array,title = nil)
+      format_function_list(array,title)
+    end
+
+    def self.output_results(results={})
+      format_output_results(results)
+    end
+
+    private
+
+    def self.format_function_list(array,title=nil)
+      if title != nil
+        puts "\n"
+        puts "-" * 60
+        text "#{title.center(60).upcase}"
+        i = 0
+        array.each do |item|
+          i = i+1
+          list "#{item}"
+        end
+        puts "\n"
+        puts "-" * 60
+        puts "\n"
+      else
+        list array.join(",")
+      end
+    end
+
+    def self.format_list(array,title=nil)
+      if title != nil
+        puts "\n"
+        puts "-" * 60
+        text "#{title.center(60).upcase}"
+        i = 0
+        array.each do |item|
+          i = i+1
+          list "#{i}\) #{item}"
+        end
+        puts "\n"
+        puts "-" * 60
+        puts "\n"
+      else
+        list array.join(",")
+      end
+    end
+    
+    def self.format_output_results(results={})
+      puts "\n"
+      puts "-" * 60
+      title("Results")
+      results.each do |key,value|
+        puts "#{key}".ljust(20) + "#{value.to_f.precision(4)}".ljust(40)
+      end
+      puts "\n"
+      puts "-" * 60
+      puts "\n"
+    end
+
+    private
+
+    def self.text(text = "")
+      puts "\n#{text.center(60)}\n\n"
+    end
+
+    def self.list(text= "")
+      puts "#{text.ljust(60,' ')}"
+    end
+  end
+end

data/lib/engineering_calculator/calculator.rb

@@ -0,0 +1,92 @@
+require "calculator/support/action_manager"
+require "calculator/support/output_manager"
+require "calculator/support/float_extend"
+require "calculator/gas_dynamics_calculator"
+
+module EngineeringCalculator
+  class Calculator
+
+    @calculators = ["Gas Dynamics"]
+    @@current_calculator = nil
+
+    def launch
+      OutputManager.display_welcome
+      main_loop
+    end
+
+    def main_loop
+      response = nil
+      OutputManager.display_actions
+      while response != :quit
+        response = prompt_user
+      end
+    end
+
+    def self.calculator_list
+      make_calculator_list
+    end
+
+    def self.use_calculator(calculator_number)
+      set_calculator(calculator_number)
+    end
+
+    def self.functions
+      list_functions
+    end
+
+    def self.function(fun)
+      perform(fun)
+    end
+
+    private
+
+    def self.perform(fun)
+      case @@current_calculator
+      when 1
+        GasDynamicsCalculator.function(fun)
+      else
+        OutputManager.warning("Please use a calculator first")
+        return false
+      end
+      return true
+    end
+
+    def self.list_functions
+      case @@current_calculator
+      when 1
+        GasDynamicsCalculator.functions
+      else
+        OutputManager.warning("Please use a calculator first")
+        return false
+      end
+      return true
+    end
+
+    def self.set_calculator(calculator_number)
+      num_in_array = calculator_number.to_i - 1
+      if num_in_array < @calculators.count and num_in_array != -1
+        OutputManager.message("Calculator: #{@calculators[num_in_array]}")
+        @@current_calculator = calculator_number.to_i
+        return true
+      else
+        OutputManager.output_list(@calculators,"Available Calculators")
+        return false
+      end
+    end
+
+    def self.make_calculator_list
+      OutputManager.output_list(@calculators,"Available Calculators")
+      return true
+    end
+
+    def prompt_user
+      input = nil
+      until ActionManager.action?(input) do
+        OutputManager.prompt(">")
+        input,args = gets.chomp.split(" ")
+      end
+      ActionManager.perform(input,args)
+    end
+
+  end
+end

data/lib/engineering_calculator/gas_dynamics.rb

@@ -2,158 +2,177 @@ require "helpers"
 
 module EngineeringCalculator
   module GasDynamics
-    def fanno(m,gamma)
-      p_ratio = 1/m * 1/Math.sqrt((2/(gamma+1)*(1+(gamma-1)/2*pow(m, 2))))
-     	rho_ratio = 1/m * Math.sqrt((2/(gamma+1)) * (1+(gamma-1)/2*pow(m, 2)))
-     	t_ratio = 1/(2/(gamma+1)*(1+(gamma-1)/2*pow(m, 2)))
-     	u_ratio = m * 1/Math.sqrt(2/(gamma+1) * (1 + (gamma-1)/2*pow(m, 2)))
-     	po_ratio = 1/m * pow(2/(gamma+1) * (1+(gamma-1)/2*pow(m, 2)),(gamma+1)/(gamma-1)/2)
-     	fanno_param = (1-pow(m, 2))/(gamma*pow(m, 2)) + (gamma+1)/(gamma*2)*Math.log(pow(m, 2)/(2/(gamma+1)*(1+(gamma-1)/2*pow(m, 2))))
-    	result = {
-    	    :p_ratio => p_ratio,
-    	    :rho_ratio => rho_ratio,
-    	    :t_ratio => t_ratio,
-    	    :u_ratio => u_ratio,
-    	    :po_ratio => po_ratio,
-    	    :fanno_param => fanno_param
-    	  }
-    	  return result
+
+    def self.fanno(m,gamma)
+      m = m.to_f
+      gamma = gamma.to_f
+
+      p_ratio     = 1/m * 1/Math.sqrt((2/(gamma+1)*(1+(gamma-1)/2*pow(m, 2))))
+      rho_ratio   = 1/m * Math.sqrt((2/(gamma+1)) * (1+(gamma-1)/2*pow(m, 2)))
+      t_ratio     = 1/(2/(gamma+1)*(1+(gamma-1)/2*pow(m, 2)))
+      u_ratio     = m * 1/Math.sqrt(2/(gamma+1) * (1 + (gamma-1)/2*pow(m, 2)))
+      po_ratio    = 1/m * pow(2/(gamma+1) * (1+(gamma-1)/2*pow(m, 2)),(gamma+1)/(gamma-1)/2)
+      fanno_param = (1-pow(m, 2))/(gamma*pow(m, 2)) + (gamma+1)/(gamma*2)*Math.log(pow(m, 2)/(2/(gamma+1)*(1+(gamma-1)/2*pow(m, 2))))
+
+      result = {
+        p_ratio:      p_ratio,
+        rho_ratio:    rho_ratio,
+        t_ratio:      t_ratio,
+        u_ratio:      u_ratio,
+        po_ratio:     po_ratio,
+        fanno_param:  fanno_param
+      }
     end
-    def isentropic(m,gamma)
-      ratio_t = pow(1 + (gamma - 1)/2 * pow(m, 2), -1)
-      ratio_p = pow(1 + (gamma - 1)/2 * pow(m, 2), -gamma/(gamma-1))
+
+    def self.isentropic(m,gamma)
+      m = m.to_f
+      gamma = gamma.to_f
+      
+      ratio_t   = pow(1 + (gamma - 1)/2 * pow(m, 2), -1)
+      ratio_p   = pow(1 + (gamma - 1)/2 * pow(m, 2), -gamma/(gamma-1))
       ratio_rho = pow(1 + (gamma - 1)/2 * pow(m, 2), -1/(gamma-1))
-      ratio_a = pow((gamma + 1)/2, -((gamma + 1)/(gamma - 1)/2))/m * pow(1 + (gamma - 1)/2 * pow(m, 2), ((gamma + 1)/(gamma - 1))/2)
+      ratio_a   = pow((gamma + 1)/2, -((gamma + 1)/(gamma - 1)/2))/m * pow(1 + (gamma - 1)/2 * pow(m, 2), ((gamma + 1)/(gamma - 1))/2)
+      
       result = {
-        :ratio_t => ratio_t,
-        :ratio_p => ratio_p,
-        :ratio_rho => ratio_rho,
-        :ratio_a => ratio_a
+        ratio_t:    ratio_t,
+        ratio_p:    ratio_p,
+        ratio_rho:  ratio_rho,
+        ratio_a:    ratio_a
       }
-      return result
     end
-    def normal_shock(mx,gamma)
-     	my = Math.sqrt((pow(mx,2)*(gamma-1)+2)/(2*gamma*pow(mx,2)-(gamma-1)))
-    	py_px = 2*gamma* pow(mx,2) /(gamma+1)-(gamma-1)/(gamma+1)
-    	rhoy_rhox = (gamma+1)*pow(mx,2)/((gamma-1)*pow(mx,2)+2)
-    	ty_tx = (1 + (gamma - 1)/2 * pow(mx, 2))*(2*gamma/(gamma - 1) * pow(mx, 2) - 1)/(pow(mx, 2)*(2*gamma/(gamma - 1) + (gamma - 1)/2))
-    	poy_pox = pow((gamma + 1)/2 * pow(mx, 2)/(1 + (gamma - 1)/2 * pow(mx, 2)), gamma/(gamma - 1)) * pow(1/(2 * gamma/(gamma+1) * pow(mx,2) - (gamma-1)/(gamma+1)), 1/(gamma - 1));
+
+    def self.normal_shock(mx,gamma)
+      my        = Math.sqrt((pow(mx,2)*(gamma-1)+2)/(2*gamma*pow(mx,2)-(gamma-1)))
+      py_px     = 2*gamma* pow(mx,2) /(gamma+1)-(gamma-1)/(gamma+1)
+      rhoy_rhox = (gamma+1)*pow(mx,2)/((gamma-1)*pow(mx,2)+2)
+      ty_tx     = (1 + (gamma - 1)/2 * pow(mx, 2))*(2*gamma/(gamma - 1) * pow(mx, 2) - 1)/(pow(mx, 2)*(2*gamma/(gamma - 1) + (gamma - 1)/2))
+      poy_pox   = pow((gamma + 1)/2 * pow(mx, 2)/(1 + (gamma - 1)/2 * pow(mx, 2)), gamma/(gamma - 1)) * pow(1/(2 * gamma/(gamma+1) * pow(mx,2) - (gamma-1)/(gamma+1)), 1/(gamma - 1));
+      
       result = {
-    	  :my => my,
-    	  :py_px => py_px,
-    	  :rhoy_rhox => rhoy_rhox,
-    	  :ty_tx => ty_tx,
-    	  :poy_pox => poy_pox
+        my:         my,
+        py_px:      py_px,
+        rhoy_rhox:  rhoy_rhox,
+        ty_tx:      ty_tx,
+        poy_pox:    poy_pox
       }
-      return result
     end
-    def oblique(mx,gamma,delta)
-     	pi = Math::PI
-      # Initial guess that beta and delta coincide.
-     	beta = delta*pi/180
-     	e = 1
-     	rhs = Math.tan(delta*pi/180)
-
-     	while (e >= 1*10**(-5))
-     		lhs = 2*(1/Math.tan(beta))*(pow(mx,2)*pow(Math.sin(beta),2)-1)/(pow(mx,2)*(gamma+Math.cos(2*beta))+2)
-     		e = rhs - lhs
-     		beta = beta + 0.00001
-     	end
-     	ratio_rho = (gamma+1) * pow(mx, 2)*pow(Math.sin(beta), 2) / ((gamma-1)*pow(mx, 2)*pow(Math.sin(beta), 2)+2)
-     	beta = beta*180/pi;
-
-     	ratio_p = 1+2*gamma/(gamma+1)*(pow(mx,2)*pow(Math.sin(beta*pi/180),2)-1);
-     	ratio_t = ratio_p*pow((gamma+1)*pow(mx,2)*pow(Math.sin(beta*pi/180),2)/((gamma-1)*pow(mx,2)*pow(Math.sin(beta*pi/180),2)+2),-1);
-     	my	= (1/Math.sin((beta-delta)*pi/180))*pow((1+0.5*(gamma-1)*pow(mx,2)*pow(Math.sin(beta*pi/180),2))/(gamma*pow(mx,2)*pow(Math.sin(beta*pi/180),2)-0.5*(gamma-1)),0.5);
-     	ratio_px = pow(1 + (gamma - 1)/2 * pow(mx, 2), -gamma/(gamma-1));
-     	ratio_py = pow(1 + (gamma - 1)/2 * pow(my, 2), -gamma/(gamma-1));
-     	ratio_po = ratio_px/ratio_py*ratio_p;
-     	result = {
-     	  :my => my,
-     	  :ratio_rho => ratio_rho,
-     	  :beta => beta,
-     	  :ratio_p => ratio_p,
-     	  :ratio_t => ratio_t,
-     	  :ratio_po => ratio_po
-     	}
-     	return result
+
+    def self.oblique(mx,gamma,delta)
+      pi    = Math::PI
+      beta  = delta*pi/180 # Initial guess that beta and delta coincide.
+      e     = 1
+      rhs   = Math.tan(delta*pi/180)
+
+      while (e >= 1*10**(-5))
+        lhs   = 2*(1/Math.tan(beta))*(pow(mx,2)*pow(Math.sin(beta),2)-1)/(pow(mx,2)*(gamma+Math.cos(2*beta))+2)
+        e     = rhs - lhs
+        beta  = beta + 0.00001
+      end
+
+      ratio_rho = (gamma+1) * pow(mx, 2)*pow(Math.sin(beta), 2) / ((gamma-1)*pow(mx, 2)*pow(Math.sin(beta), 2)+2)
+      beta      = beta*180/pi;
+      ratio_p   = 1+2*gamma/(gamma+1)*(pow(mx,2)*pow(Math.sin(beta*pi/180),2)-1);
+      ratio_t   = ratio_p*pow((gamma+1)*pow(mx,2)*pow(Math.sin(beta*pi/180),2)/((gamma-1)*pow(mx,2)*pow(Math.sin(beta*pi/180),2)+2),-1);
+      my	      = (1/Math.sin((beta-delta)*pi/180))*pow((1+0.5*(gamma-1)*pow(mx,2)*pow(Math.sin(beta*pi/180),2))/(gamma*pow(mx,2)*pow(Math.sin(beta*pi/180),2)-0.5*(gamma-1)),0.5);
+      ratio_px  = pow(1 + (gamma - 1)/2 * pow(mx, 2), -gamma/(gamma-1));
+      ratio_py  = pow(1 + (gamma - 1)/2 * pow(my, 2), -gamma/(gamma-1));
+      ratio_po  = ratio_px/ratio_py*ratio_p;
+      
+      result = {
+        my: my,
+        ratio_rho: ratio_rho,
+        beta: beta,
+        ratio_p: ratio_p,
+        ratio_t: ratio_t,
+        ratio_po: ratio_po
+      }
     end
-    def prandtl_compression(mx,gamma,turning_angle)
-      pi = Math::PI
-     	nux = Math.sqrt((gamma+1)/(gamma-1)) * Math.atan(Math.sqrt((gamma-1)/(gamma+1)*(pow(mx, 2)-1))) - Math.atan(Math.sqrt(pow(mx, 2)-1))
-     	turningAngle = turning_angle*pi/180
-     	nuy = nux - turningAngle
-     	my = 1
-     	e = 1
-     	while (e >= 0.00001)
-     		nuy_test = Math.sqrt((gamma+1)/(gamma-1)) * Math.atan(Math.sqrt((gamma-1)/(gamma+1)*(pow(my, 2)-1))) - Math.atan(Math.sqrt(pow(my, 2)-1))
-     		e = nuy - nuy_test
-     		my = my+0.00001
-     	end
-     	my = my-0.00001
-     	ty_tx = (1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2))
-     	py_px = pow((1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2)), gamma/(gamma-1))
-     	rhoy_rhox = pow((1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2)), 1/(gamma-1))
-     	mux = Math.asin(1/mx)
-     	muy = Math.asin(1/my)
-     	result = {
-     	  :ty_tx => ty_tx,
-     	  :py_px => py_px,
-     	  :rhoy_rhox => rhoy_rhox,
-     	  :my => my,
-     	  :nux => nux*180/pi,
-     	  :nuy => nuy*180/pi,
-     	  :mux => mux*180/pi,
-     	  :muy => muy*180/pi,
-     	}
-     	return result
+
+    def self.prandtl_compression(mx,gamma,turning_angle)
+
+      pi            = Math::PI
+      nux           = Math.sqrt((gamma+1)/(gamma-1)) * Math.atan(Math.sqrt((gamma-1)/(gamma+1)*(pow(mx, 2)-1))) - Math.atan(Math.sqrt(pow(mx, 2)-1))
+      turningAngle  = turning_angle*pi/180
+      nuy           = nux - turningAngle
+      my            = 1
+      e             = 1
+
+      while (e >= 0.00001)
+        nuy_test  = Math.sqrt((gamma+1)/(gamma-1)) * Math.atan(Math.sqrt((gamma-1)/(gamma+1)*(pow(my, 2)-1))) - Math.atan(Math.sqrt(pow(my, 2)-1))
+        e         = nuy - nuy_test
+        my        = my+0.00001
+      end
+
+      my        = my-0.00001
+      ty_tx     = (1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2))
+      py_px     = pow((1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2)), gamma/(gamma-1))
+      rhoy_rhox = pow((1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2)), 1/(gamma-1))
+      mux       = Math.asin(1/mx)
+      muy       = Math.asin(1/my)
+
+      result = {
+        ty_tx:      ty_tx,
+        py_px:      py_px,
+        rhoy_rhox:  rhoy_rhox,
+        my:         my,
+        nux:        nux*180/pi,
+        nuy:        nuy*180/pi,
+        mux:        mux*180/pi,
+        muy:        muy*180/pi,
+      }
     end
-    def prandtl_expansion(mx,gamma,turning_angle)
-      pi = Math::PI
-     	nux = Math.sqrt((gamma+1)/(gamma-1)) * Math.atan(Math.sqrt((gamma-1)/(gamma+1)*(pow(mx, 2)-1))) - Math.atan(Math.sqrt(pow(mx, 2)-1))
-     	turningAngle = turning_angle*pi/180
-     	nuy = nux + turningAngle
-     	my = 1
-     	e = 1
-     	while (e >= 0.00001)
-     		nuy_test = Math.sqrt((gamma+1)/(gamma-1)) * Math.atan(Math.sqrt((gamma-1)/(gamma+1)*(pow(my, 2)-1))) - Math.atan(Math.sqrt(pow(my, 2)-1))
-     		e = nuy - nuy_test
-     		my = my+0.00001
-     	end
-     	my = my-0.00001
-     	ty_tx = (1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2))
-     	py_px = pow((1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2)), gamma/(gamma-1))
-     	rhoy_rhox = pow((1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2)), 1/(gamma-1))
-     	mux = Math.asin(1/mx)
-     	muy = Math.asin(1/my)
-     	result = {
-     	  :ty_tx => ty_tx,
-     	  :py_px => py_px,
-     	  :rhoy_rhox => rhoy_rhox,
-     	  :my => my,
-     	  :nux => nux*180/pi,
-     	  :nuy => nuy*180/pi,
-     	  :mux => mux*180/pi,
-     	  :muy => muy*180/pi,
-     	}
-     	return result
+
+    def self.prandtl_expansion(mx,gamma,turning_angle)
+
+      pi            = Math::PI
+      nux           = Math.sqrt((gamma+1)/(gamma-1)) * Math.atan(Math.sqrt((gamma-1)/(gamma+1)*(pow(mx, 2)-1))) - Math.atan(Math.sqrt(pow(mx, 2)-1))
+      turningAngle  = turning_angle*pi/180
+      nuy           = nux + turningAngle
+      my            = 1
+      e             = 1
+
+      while (e >= 0.00001)
+        nuy_test  = Math.sqrt((gamma+1)/(gamma-1)) * Math.atan(Math.sqrt((gamma-1)/(gamma+1)*(pow(my, 2)-1))) - Math.atan(Math.sqrt(pow(my, 2)-1))
+        e         = nuy - nuy_test
+        my        = my+0.00001
+      end
+
+      my        = my-0.00001
+      ty_tx     = (1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2))
+      py_px     = pow((1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2)), gamma/(gamma-1))
+      rhoy_rhox = pow((1+(gamma-1)/2*pow(mx, 2))/(1+(gamma-1)/2*pow(my, 2)), 1/(gamma-1))
+      mux       = Math.asin(1/mx)
+      muy       = Math.asin(1/my)
+
+      result = {
+        ty_tx:      ty_tx,
+        py_px:      py_px,
+        rhoy_rhox:  rhoy_rhox,
+        my:         my,
+        nux:        nux*180/pi,
+        nuy:        nuy*180/pi,
+        mux:        mux*180/pi,
+        muy:        muy*180/pi,
+      }
     end
-    def rayleigh(m,gamma)
-     	p_ratio = (gamma+1)/(1+gamma*pow(m, 2));
-     	rho_ratio = (1+gamma*pow(m,2))/((1+gamma)*pow(m,2));
-     	t_ratio = pow(gamma+1, 2)*pow(m, 2)/pow(1+gamma*pow(m, 2), 2);
-     	u_ratio = (gamma+1)*pow(m, 2)/(1+gamma*pow(m, 2));
-     	po_ratio = (gamma+1)/(1+gamma*pow(m, 2)) * pow(2/(gamma+1)*(1+(gamma-1)/2*pow(m, 2)), gamma/(gamma-1));
-     	to_ratio= 2*(gamma+1)*pow(m, 2)/pow(1+gamma*pow(m, 2),2) * (1+(gamma-1)/2*pow(m, 2));
+	
+    def self.rayleigh(m,gamma)
+      p_ratio   = (gamma+1)/(1+gamma*pow(m, 2));
+      rho_ratio = (1+gamma*pow(m,2))/((1+gamma)*pow(m,2));
+      t_ratio   = pow(gamma+1, 2)*pow(m, 2)/pow(1+gamma*pow(m, 2), 2);
+      u_ratio   = (gamma+1)*pow(m, 2)/(1+gamma*pow(m, 2));
+      po_ratio  = (gamma+1)/(1+gamma*pow(m, 2)) * pow(2/(gamma+1)*(1+(gamma-1)/2*pow(m, 2)), gamma/(gamma-1));
+      to_ratio  = 2*(gamma+1)*pow(m, 2)/pow(1+gamma*pow(m, 2),2) * (1+(gamma-1)/2*pow(m, 2));
+
       result = {
-        :p_ratio => p_ratio,
-        :rho_ratio => rho_ratio,
-        :t_ratio => t_ratio,
-        :u_ratio => u_ratio,
-        :po_ratio => po_ratio,
-        :to_ratio => to_ratio
+        p_ratio:    p_ratio,
+        rho_ratio:  rho_ratio,
+        t_ratio:    t_ratio,
+        u_ratio:    u_ratio,
+        po_ratio:   po_ratio,
+        to_ratio:   to_ratio
       }
-      return result
     end
+
   end
 end

data/lib/engineering_calculator/version.rb

@@ -1,3 +1,3 @@
 module EngineeringCalculator
-    VERSION = "1.0.0"
+    VERSION = "2.0.0"
 end

data/lib/engineering_calculator.rb

@@ -1,6 +1,13 @@
-require "engineering_calculator/version"
-require "engineering_calculator/gas_dynamics"
+APP_ROOT = File.dirname(__FILE__)
+$:.unshift( File.join( APP_ROOT, 'engineering_calculator'))
 
-module EngineeringCalculator
+require "version"
+require "gas_dynamics"
+require "calculator"
 
+module EngineeringCalculator
+  def self.init
+    calculator = Calculator.new
+    calculator.launch
+  end
 end

data/spec/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem "rspec"
+gem "engineering_calculator"

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'engineering_calculator'
+
+RSpec.configure do |config|
+  
+end

data/spec/tests/action_test.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+require "engineering_calculator/calculator/support/action_manager"
+
+describe "actions" do
+
+  it "should return true for a valid action" do
+    EngineeringCalculator::ActionManager.action?("calculators").should be_true
+  end
+
+  it "should not return true for an invalid actio" do
+    EngineeringCalculator::ActionManager.action?("sdfsdfsdf").should be_false
+  end
+
+  it "should perform a valid action" do
+    EngineeringCalculator::ActionManager.perform("calculators").should be_true
+  end
+
+  it "should not perform an invalid action" do
+    EngineeringCalculator::ActionManager.perform("calculatorssdfsdf").should be_false
+  end
+end

data/spec/tests/calculator_test.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "engineering_calculator/calculator"
+
+describe "calculator" do
+
+  it "should make a calculator list" do
+    EngineeringCalculator::Calculator.calculator_list.should be_true
+  end
+
+  describe "calculator activation" do
+    it "should be able to use calculator for valid calculator number" do
+      EngineeringCalculator::Calculator.use_calculator(1)
+    end
+
+    it "should be not able to use calculator for string calculator number" do
+      EngineeringCalculator::Calculator.use_calculator("")
+    end
+
+    it "should be not able to use calculator for zero as a calculator number" do
+      EngineeringCalculator::Calculator.use_calculator(0)
+    end
+
+    it "should be not able to use calculator for a calculator number of calculators" do
+      EngineeringCalculator::Calculator.use_calculator(50000)
+    end
+  end
+end

data/spec/tests/gas_dynamics_test.rb

@@ -0,0 +1,292 @@
+require "spec_helper"
+require "gas_dynamics"
+require "engineering_calculator/calculator/support/float_extend"
+
+describe "gas dynamics" do
+
+  describe "fanno" do
+    it "should give correct value for m=1 and gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.fanno(1,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        p_ratio:      1.0,
+        rho_ratio:    1.0,
+        t_ratio:      1.0,
+        u_ratio:      1.0,
+        po_ratio:     1.0,
+        fanno_param:  0.0
+      }) 
+    end
+
+    it "should give correct value for m=1.1 and gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.fanno(1.1,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        p_ratio:      0.8936,
+        rho_ratio:    0.9249,
+        t_ratio:      0.9662,
+        u_ratio:      1.0812,
+        po_ratio:     1.0079,
+        fanno_param:  0.0099
+      }) 
+    end
+
+    it "should give correct value for m=20 and gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.fanno(20,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        p_ratio:      0.0061,
+        rho_ratio:    0.4108,
+        t_ratio:      0.0148,
+        u_ratio:      2.4343,
+        po_ratio:     15377.3438,
+        fanno_param:  0.8126
+      }) 
+    end
+  end
+
+  describe "isentropic" do
+    it "should give correct value for m=1 and gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.isentropic(1,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        ratio_t:    0.8333,
+        ratio_p:    0.5283,
+        ratio_rho:  0.6339,
+        ratio_a:    1.0
+      }) 
+    end
+
+    it "should give correct value for m=.1 and gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.isentropic(0.1,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        ratio_t:    0.998,
+        ratio_p:    0.993,
+        ratio_rho:  0.995,
+        ratio_a:    5.8218
+      }) 
+    end
+
+    it "should give correct value for m=.5 and gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.isentropic(0.5,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        ratio_t:    0.9524,
+        ratio_p:    0.843,
+        ratio_rho:  0.8852,
+        ratio_a:    1.3398
+      }) 
+    end
+  end
+
+  describe "normal_shock" do
+    it "should give correct value for m=1 and gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.normal_shock(1,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        my:         1.0,
+        py_px:      1.0,
+        rhoy_rhox:  1.0,
+        ty_tx:      1.0,
+        poy_pox:    1.0
+      }) 
+    end
+
+    it "should give correct value for m=1.4 and gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.normal_shock(1.4,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        my:         0.7397,
+        py_px:      2.12,
+        rhoy_rhox:  1.6897,
+        ty_tx:      1.2547,
+        poy_pox:    0.9582 
+      }) 
+    end
+  end
+
+  describe "oblique" do
+    it "should give correct value for m=1, gamma=1.4, delta=0" do
+      results = EngineeringCalculator::GasDynamics.oblique(1,1.4,0)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        my:         1.0005,
+        ratio_rho:  0.9996,
+        beta:       88.6887,
+        ratio_p:    0.9994,
+        ratio_t:    0.9998,
+        ratio_po:   1.0
+      }) 
+    end
+
+    it "should give correct value for m=1, gamma=1.4, delta=20" do
+      results = EngineeringCalculator::GasDynamics.oblique(1.4,1.4,20)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        my:         2.1961,
+        ratio_rho:  0.4789,
+        beta:       151.9384,
+        ratio_p:    0.3394,
+        ratio_t:    0.7086,
+        ratio_po:   1.1333
+      }) 
+    end
+  end
+
+  describe "prandtl-compression" do
+    it "should give correct value for m=1, gamma=1.4,delta=0" do
+      results = EngineeringCalculator::GasDynamics.prandtl_compression(1,1.4,0)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        ty_tx:      1.0,
+        py_px:      1.0,
+        rhoy_rhox:  1.0,
+        my:         1.0,
+        nux:        0.0,
+        nuy:        0.0,
+        mux:        90.0,
+        muy:        90.0
+      }) 
+    end
+
+    it "should give correct value for m=1.4, gamma=1.4,delta=20" do
+      results = EngineeringCalculator::GasDynamics.prandtl_compression(1.4,1.4,20)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        ty_tx:      1.16,
+        py_px:      1.6811,
+        rhoy_rhox:  1.4493,
+        my:         1.0,
+        nux:        8.987,
+        nuy:        -11.013,
+        mux:        45.5847,
+        muy:        90.0
+      }) 
+    end
+  end
+
+  describe "prandtl-expansion" do
+    it "should give correct value for m=1, gamma=1.4,delta=0" do
+      results = EngineeringCalculator::GasDynamics.prandtl_expansion(1,1.4,0)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        ty_tx:      1.0,
+        py_px:      1.0,
+        rhoy_rhox:  1.0,
+        my:         1.0,
+        nux:        0.0,
+        nuy:        0.0,
+        mux:        90.0,
+        muy:        90.0
+      }) 
+    end
+
+    it "should give correct value for m=1, gamma=1.4,delta=20" do
+      results = EngineeringCalculator::GasDynamics.prandtl_expansion(1,1.4,20)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        ty_tx:      0.7362,
+        py_px:      0.3423,
+        rhoy_rhox:  0.465,
+        my:         1.775,
+        nux:        0.0,
+        nuy:        20.0,
+        mux:        90.0,
+        muy:        34.2908
+      }) 
+    end
+  end
+
+  describe "rayleigh" do
+    it "should give correct value for m=1, gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.rayleigh(1,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        p_ratio:    1.0,
+        rho_ratio:  1.0,
+        t_ratio:    1.0,
+        u_ratio:    1.0,
+        po_ratio:   1.0,
+        to_ratio:   1.0
+      }) 
+    end
+
+    it "should give correct value for m=1.4, gamma=1.4" do
+      results = EngineeringCalculator::GasDynamics.rayleigh(1.4,1.4)
+
+      results.each do |key,value|
+        results[key] = value.precision(4)
+      end
+
+      results.should eq({
+        p_ratio:    0.641,
+        rho_ratio:  0.7959,
+        t_ratio:    0.8054,
+        u_ratio:    1.2564,
+        po_ratio:   1.0777,
+        to_ratio:   0.9343
+      }) 
+    end
+  end
+end

data/spec/tests/output_test.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "engineering_calculator/calculator/support/output_manager"
+
+describe "output" do
+
+  it "should be able to use message" do
+    EngineeringCalculator::OutputManager.message("text").should be_nil
+  end
+
+  it "should be able to use title" do
+    EngineeringCalculator::OutputManager.title("text").should be_nil
+  end
+
+  it "should be able to use prompt" do
+    EngineeringCalculator::OutputManager.message("prompt").should be_nil
+  end
+
+  it "should be able to use display_actions" do
+    EngineeringCalculator::OutputManager.display_actions.should be_nil
+  end
+
+  it "should be able to use display_welcome" do
+    EngineeringCalculator::OutputManager.display_welcome.should be_nil
+  end
+  
+  it "should be able to use display_goodbye" do
+    EngineeringCalculator::OutputManager.display_goodbye.should be_nil
+  end
+
+  describe "output list" do
+    it "should be able to use output_list with empty array and no title" do
+      EngineeringCalculator::OutputManager.output_list([]).should be_nil
+    end
+    it "should be able to use output_list with array and no title" do
+      EngineeringCalculator::OutputManager.output_list(["sdfsdf"]).should be_nil
+    end
+    it "should be able to use output_list with array and title" do
+      EngineeringCalculator::OutputManager.output_list(["sdfsdf"], "title").should be_nil
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: engineering_calculator
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,13 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-24 00:00:00.000000000 Z
+date: 2012-11-26 00:00:00.000000000 Z
 dependencies: []
-description: Provides engineering functions for ruby
+description: Engineering calculator for ruby
 email:
 - thomas.muntaner@gmail.com
-executables: []
+executables:
+- engineering_calculator
 extensions: []
 extra_rdoc_files: []
 files:
@@ -23,12 +24,24 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/engineering_calculator
 - engineering-calculator.gemspec
 - lib/engineering_calculator.rb
+- lib/engineering_calculator/calculator.rb
+- lib/engineering_calculator/calculator/gas_dynamics_calculator.rb
+- lib/engineering_calculator/calculator/support/action_manager.rb
+- lib/engineering_calculator/calculator/support/float_extend.rb
+- lib/engineering_calculator/calculator/support/output_manager.rb
 - lib/engineering_calculator/gas_dynamics.rb
 - lib/engineering_calculator/version.rb
 - lib/helpers.rb
-homepage: http://www.engineering-calculator.com
+- spec/Gemfile
+- spec/spec_helper.rb
+- spec/tests/action_test.rb
+- spec/tests/calculator_test.rb
+- spec/tests/gas_dynamics_test.rb
+- spec/tests/output_test.rb
+homepage: http://engineering-calculator.herokuapp.com
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -48,8 +61,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Engineering Calculator
-test_files: []
+test_files:
+- spec/Gemfile
+- spec/spec_helper.rb
+- spec/tests/action_test.rb
+- spec/tests/calculator_test.rb
+- spec/tests/gas_dynamics_test.rb
+- spec/tests/output_test.rb