rubychem 1.0.4 → 1.0.5

data/README.md

@@ -0,0 +1,38 @@
+Rubychem
+===
+Rubychem (<a href="http://github.com/fogonthedowns/rubychem" target="_blank">http://github.com/fogonthedowns/rubychem</a>) is a new Chemistry library for Ruby, supporting the calculation of moles, balancing chemical equations and valence orbital calculations. We wrote Rubychem with three goals:
+
+* Lightweight: Rubychem should be a light simple library, providing a chemistry API and returning simple Ruby.
+* Fast: Rubychem should, out of the box, be quick. 
+* Accurate: Rubychem should have complete test coverage, so you can rely on it.
+
+
+1.0.4 beta
+---
+Version 1.0.4 is currently in beta, filled with features you'll love.  To download the beta:
+
+    gem install rubychem
+
+
+Chemistry Calculations
+---
+Using rubychem is quite straightforward:
+
+    valence = RubyChem::Valence.new(10).calc_valence
+    {"1s"=>2, "2s"=>2, "2p"=>6}
+    chemical_species = RubyChem::Chemical.new("H2O").chem_species
+    moles = RubyChem::Chemical.new("H2O",2).moles
+
+    
+You can use rubychem to parse chemical equations
+
+    equation = RubyChem::Equation.new("NaCl = Na + Cl")
+    equation.left 
+    [#<RubyChem::Chemical:0x007f842313dae0 @chem_species=[["Na", "1"]], @mm=22.99, @moles=0.04349717268377556>, #<RubyChem::Chemical:0x007f842313d2e8 @chem_species=[["Cl", "1"]], @mm=35.45, @moles=0.028208744710860365>] 
+
+
+You can enter an unbalanced chemical equation and have rubychem take care of the dirty work
+
+     chemical = RubyChem::Equation.new("C12H26+O2=CO2+H2O")
+     chemical.balance
+     "2C12H26 + 37O2 = 24C1O2 + 26H2O1" 

data/lib/rubychem.rb

@@ -1,3 +1,3 @@
 load 'rubychem/molecule.rb'
 load 'rubychem/valence.rb'
-load 'rubychem/equation.rb'
+load 'rubychem/equation.rb'

data/lib/rubychem/equation.rb

@@ -1,24 +1,26 @@
 module RubyChem
   class Equation
-    attr_accessor :left, :right
+    require 'rational'
+    attr_accessor :left, :right, :right_system_of_equations, :left_system_of_equations, :left_total, :right_total, :array, :search_order, :balanced
 
     # Checks if two formulas are balanced.
-    # Parse string... so that x + y + z = a + b
+    # Takes user input.. such as x + y + z = a + b
     # yields @left[Chemical1, Chemical2, Chemical3], @right[Chemical1,Chemical2]
 
     def initialize(equation)
     	@left = Array.new
     	@right = Array.new
+      
       left_and_right = equation.split(/\=/)
-      process_sides(left_and_right)
+      process_equation_string(left_and_right)
     end
 
-    def process_sides(left_and_right)
-      process(left_and_right[0], "left")
-      process(left_and_right[1], "right")
+    def process_equation_string(left_and_right)
+      instantiate_chemical_object_from_string(left_and_right[0], "left")
+      instantiate_chemical_object_from_string(left_and_right[1], "right")
     end
 
-    def process(equation, side)	
+    def instantiate_chemical_object_from_string(equation, side)	
      if side == "left"
        equation.split(/\+/).each do |chemical|
          @left << RubyChem::Chemical.new(chemical.strip)     
@@ -29,7 +31,235 @@ module RubyChem
         end
       end  
     end
-  
+
+
+    # add up all atoms, on each side
+    # left = {Na:1,Cl:2}
+    # right = {Na:2,Cl:4} 
+    def list_atoms
+      @left_total = Hash.new
+      @right_total = Hash.new
+      list_part(@left, @left_total)
+      list_part(@right, @right_total)
+    end
+
+    def list_part(part, total)
+      part.each do |chemical|
+        chemical.chem_species.each do |atom|
+          if total[atom[0]].nil?
+            total[atom[0]] = atom[1]
+          else
+            total[atom[0]] += atom[1]
+          end
+        end
+      end
+    end
+
+    def is_balanced?
+       @right_total.each_key do |key|
+        @balanced = @right_total[key] == @left_total[key]
+       end
+       @balanced
+    end
+
+    # linear algebra
+    # http://www.saintjoe.edu/~karend/m244/ChemicalEquations.pdf
+    # Set up a system of equations from unbalanced chemical
+    # rearrange the system of equations to form an augmented matrix
+    # transform a matrix to the reduced row echelon form
+    
+    # System of Equations setup
+    # 1. Assign unknown coeficients 
+    # C12H26 + O2 = CO2 + H2O
+    # aC12H26 + bO2 = cCO2 + dH2O
+
+    def set_up_system_of_equations
+      @right_system_of_equations = Hash.new
+      @left_system_of_equations = Hash.new
+      part_set_up_system_of_equations(@right,@right_system_of_equations)
+      part_set_up_system_of_equations(@left,@left_system_of_equations)
+    end
+
+    def part_set_up_system_of_equations(part,total)
+      part.each do |key|
+        total[key] = 0
+      end
+    end
+
+    # 2. determnie instances on left and right of each atom, and assign those to coeficients
+    # C12H26 + O2 = CO2 + H2O
+    # O = {left:"2b",right:"2c + 1d"}
+    # O = "2b=2c+1d"
+
+    def assign_coeficients_to_system_of_equations
+      self.list_atoms
+      atom_list = self.left_total.merge(self.right_total)
+      # Get the Chemical list
+      atom_list.keys.each do |atom|
+
+        self.set_up_system_of_equations
+        assign_coeficients_to_part_system_of_equations(@right_system_of_equations,atom)
+        assign_coeficients_to_part_system_of_equations(@left_system_of_equations,atom)
+        subtract_right_side
+        write_matrix
+      end
+    end 
+    
+    def assign_coeficients_to_part_system_of_equations(part,atom_to_search)
+        chemicals =  part.keys
+        chemicals.each do |chemical|
+          @search_order << chemical
+          # look at the Chemical
+          chemical.chem_species.each do |atom|
+          # Does the chemical have the atom we are looking for?
+          if atom_to_search == atom[0] 
+            part[chemical] = atom[1]
+          end
+        end
+      end
+    end
+
+    def subtract_right_side
+      self.right_system_of_equations.each do |k,v|
+        self.right_system_of_equations[k] = v *= -1
+      end
+    end
+
+    # 3. Rearrange the system of equations and write it in a matrix
+    #   a   b   c  d
+    #O  0   2  -2  -1
+    # [[0,2,-2,-1]]
+
+    def write_matrix
+      array = Array.new
+      @left_system_of_equations.keys.each do |key|
+        array << @left_system_of_equations[key]
+      end
+      @right_system_of_equations.keys.each do |key|
+        array  <<  @right_system_of_equations[key]
+      end
+       @array << array
+    end
+
+
+    def balance
+      @search_order = Array.new
+      @array = Array.new
+      @reduced_row_echelon_form = Array.new
+      self.assign_coeficients_to_system_of_equations
+      @reduced_row_echelon_form = self.reduced_row_echelon_form(@array)
+      self.apply_solved_equivalent_fractions_to_fraction
+    end
+    
+    # from the reduced row echelon form we are left with a set
+    # of equivalent fractions to transform into a whole number
+    # we do this by using the gcdlcm method
+
+    def solve_equivalent_fractions
+      last = 0
+      array = Array.new
+      @reduced_row_echelon_form.each do |x|
+         array = last.gcdlcm(x.last.denominator)
+         last = x.last.denominator
+      end
+      array.max
+    end
+
+    # Now that we have the whole number from solve_equivalent_fractions
+    # we must apply that to each of the fractions to solve for the 
+    # balanced equation
+
+    def apply_solved_equivalent_fractions_to_fraction
+      int = self.solve_equivalent_fractions
+      answer = []
+      @reduced_row_echelon_form.each do |row|
+        answer << row.last * int
+      end
+      answer << int
+      count = 0
+      @balanced = Hash.new
+      @left_system_of_equations.each do |x,v|
+        answer[count]
+        @left_system_of_equations[x] = answer[count].to_i.abs unless answer[count].nil?
+        count += 1
+      end
+      @right_system_of_equations.each do |x,v|
+        answer[count]
+        @right_system_of_equations[x] = answer[count].to_i.abs unless answer[count].nil?
+        count += 1
+      end
+      answer
+      @balanced = {left:@left_system_of_equations,right:@right_system_of_equations}
+      self.balanced_string
+    end
+
+    def balanced_string
+      array_of_strings = Array.new
+      @balanced[:left].each{|x,y|array_of_strings << (x.chem_species.unshift(y).join);x.chem_species.shift}
+      left = array_of_strings.join(" + ")
+      array_of_strings = []
+      @balanced[:right].each{|x,y|array_of_strings << (x.chem_species.unshift(y).join);x.chem_species.shift}
+      right = array_of_strings.join(" + ")
+      left + " = " + right
+    end
+ 
+    # returns an 2-D array where each element is a Rational
+    def reduced_row_echelon_form(ary)
+      lead = 0
+      rows = ary.size
+      cols = ary[0].size
+      rary = convert_to_rational(ary)  # use rational arithmetic
+      catch :done  do
+        rows.times do |r|
+        throw :done  if cols <= lead
+          i = r
+          while rary[i][lead] == 0
+            i += 1
+            if rows == i
+              i = r
+              lead += 1
+              throw :done  if cols == lead
+            end
+          end
+          # swap rows i and r 
+          rary[i], rary[r] = rary[r], rary[i]
+          # normalize row r
+          v = rary[r][lead]
+          rary[r].collect! {|x| x /= v}
+          # reduce other rows
+          rows.times do |i|
+            next if i == r
+            v = rary[i][lead]
+            rary[i].each_index {|j| rary[i][j] -= v * rary[r][j]}
+          end
+          lead += 1
+        end
+      end
+      rary
+    end
+   
+    def convert_to_rational(ary)
+      new = []
+      ary.each_index do |row|
+        new << ary[row].collect {|elem| Rational(elem)}
+      end
+      new
+    end  
+ 
+    # type should be one of :to_s, :to_i, :to_f, :to_r
+    def convert_to(ary, type)
+      new = []
+      ary.each_index do |row|
+        new << ary[row].collect {|elem| elem.send(type)}
+      end
+      new
+    end
+   
+    def print_matrix(m)
+      max = m[0].collect {-1}
+      m.each {|row| row.each_index {|i| max[i] = [max[i], row[i].to_s.length].max}}
+      m.each {|row| row.each_index {|i| print "%#{max[i]}s " % row[i].to_s}; puts ""}
+    end
 
   end
 end

data/lib/rubychem/molecule.rb

@@ -27,6 +27,7 @@ module RubyChem
     def speciate(x,grams=1)
       @chem_species = x.map { |chem| chem.scan(/[A-Z][^A-Z]*/) }.flatten
       @chem_species.map! {|chem| chem.scan /[A-Z]+|\d+/i }
+      @chem_species.map!{|s1, s2| [s1, *(s2.to_i if s2), *(1 if s2.nil?),]}
       atom_masses = @chem_species.map { |(elem, coeff)| MASSES[elem.to_sym] * (coeff || 1).to_f }
       x = atom_masses.map { |int| int.to_f } 
       @mm = x.inject(0) { |s,v| s+= v }

data/lib/rubychem/valence.rb

@@ -3,28 +3,27 @@ class Valence
     Fillorder = ["1s","2s","2p","3s","3p","4s","3d","4p","5s","4d","5p","6s","4f","5d","6p","7s","5f","6d","7p"]
 	attr_accessor :calc_valence
 
-	def initialize(k)
-		@mass = k
-		determine_valence(@mass)
-		@calc_valence = Hash.new
-		@calc_valence = calculate_electronic_config
-		identify_valence_electrons
-	end
-
+  def initialize(k)
+	  @mass = k
+    determine_valence(@mass)
+    @calc_valence = Hash.new
+    @calc_valence = calculate_electronic_config
+    identify_valence_electrons
+  end
 
-	def calculate_electronic_config
-		@shell_location = 0
-		1.upto(100) do |x|
-		  until @v <= 0
-            shell_electrons = determine_valence_electrons_in_shell(@shell_location)
-            @before_subtract = @v
-         	@v -= shell_electrons       	
-         	@calc_valence[Fillorder[@shell_location]] = shell_electrons
-         	move_on(@v)
-         end
-		 end
-	     @calc_valence
+  def calculate_electronic_config
+    @shell_location = 0
+    1.upto(100) do |x|
+      until @v <= 0
+        shell_electrons = determine_valence_electrons_in_shell(@shell_location)
+        @before_subtract = @v
+        @v -= shell_electrons       	
+        @calc_valence[Fillorder[@shell_location]] = shell_electrons
+        move_on(@v)
+      end
     end
+	  @calc_valence
+  end
 
 	private 
 

data/lib/rubychem/version.rb

@@ -1,3 +1,3 @@
 module Rubychem
-  VERSION = "1.0.4"
+  VERSION = "1.0.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubychem
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-12 00:00:00.000000000 Z
+date: 2013-02-18 00:00:00.000000000 Z
 dependencies: []
 description: This is an open source library of chemistry, goodies. I'm dedicating
   this code to my major professor Arthur Brecher and Graduate PI Dr. Rogers of Bowling
@@ -24,7 +24,7 @@ files:
 - Gemfile
 - Gemfile.lock
 - LICENSE
-- README.markdown
+- README.md
 - Rakefile
 - features/step_definitions/user_starts_program_steps.rb
 - features/step_definitions/user_submits_compound_steps.rb

data/README.markdown

@@ -1,18 +0,0 @@
-# RubyChem - scripting chemistry intelligence
-
-************************************************************************
-
-# Installation
-
-    gem install rubychem
-
-
-# Use
-    x = RubyChem::Valence.new(1).calc_valence
-    
-    x = RubyChem::Chemical.new("H2O")
-    => #<RubyChem::Chemical:0x00000101059540 @chem_species=[["H", "2"], ["O", "1"]], @mm=18.01, @moles=.0.010205122971731808>
-    x = RubyChem::Chemical.new("H2O").chem_species
-    => [["H", "2"], ["O", "1"]]
-    x = RubyChem::Chemical.new("H2O",1).moles
-    => 0.010205122971731808`