rubychem 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.log
+tmp/**/*
+pkg
+doc
+Manifest
+.DS_Store

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Justin Zollars
+
+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.markdown

@@ -0,0 +1,18 @@
+# RubyChem is a Rails Plugin that allows you to calculate molecular mass from the chemical formula. The script iterates through the chemical formula and breaks the formula down into species. Then calculates molar mass.
+
+Example:
+
+* H2SO4 -> ["H2", "S", "O4"]
+* -> 97.99
+
+***************************************************************************
+
+# Installation
+
+* cd vendor/plugins
+* git clone
+* git://github.com/fogonthedowns/rubychem.git
+* ruby script/generate scaffold chem formula:string
+* rake db:migrate
+* Add "include RubyChem" in the application_controller.rb
+* in views/chems/show.html.erb add the following code: Molecular Mass: <%= RubyChem::Chemical.new(@chem.formula.to_s).fw %>

data/lib/benchmark.rb

@@ -0,0 +1,36 @@
+# The goal is for beta.rb to run faster
+
+load 'benchmark'
+load 'ruby_chem.rb'
+load 'rubychem.rb'
+
+iterations = 10000
+
+a = Benchmark.measure do
+   for i in 1..iterations do
+      RubyChem::Chemical.new("H2O").fw
+   end
+end
+
+b = Benchmark.measure do
+   for i in 1..iterations do
+      RubyChemBeta::Chemical.new("H2O")
+   end
+end
+
+c = Benchmark.measure do
+   for i in 1..iterations do
+      RubyChem::Chemical.new("H2SO4").fw
+   end
+end
+
+d = Benchmark.measure do
+   for i in 1..iterations do
+      RubyChemBeta::Chemical.new("H2SO4")
+   end
+end
+
+puts a
+puts b
+puts c
+puts d

data/lib/beta.rb

@@ -0,0 +1,62 @@
+module RubyChem
+  class Chemical
+  
+    MASSES = { :H => 1.01, :He => 4.00, :Li => 6.94, :Be => 9.01, :B => 10.81, :C => 12.01, :N => 14.01, :F => 19.00, :Ne => 20.18, :S => 32.01, :O => 15.99, 
+      :Na => 22.99, :Mg => 24.31, :Al => 26.98, :Si => 28.09, :P => 30.97, :Cl => 35.45, :Ar => 39.95, :K => 39.1, :Ca => 40.08, :Sc => 44.96, :Ti => 47.88, :V => 50.94,
+      :Cr => 52.00, :Mn => 54.94, :Fe => 55.85, :Co => 58.93, :Ni => 58.69, :Cu => 63.55, :Zn => 65.39, :Ga => 69.72, :Ge=> 72.61, :As => 74.92, :Se => 78.96, 
+      :Br => 79.90, :Kr => 83.80, :Rb => 85.47, :Sr => 87.62, :Y => 88.91, :Zr => 91.22, :Nb => 92.91, :Mo => 95.94, :Te => 98, :Ru => 101.07, :Rh => 102.91, 
+      :Pd => 106.42, :Ag => 107.87, :Cd => 112.41, :In => 114.82, :Sn => 118.71, :Sb => 121.76, :Te => 127.6, :I => 126.9, :Xe => 131.29, :Cs => 132.9, :Ba => 137.3, 
+      :La => 138.9, :Hf => 178.5, :Ta => 180.9, :W => 183.9, :Re => 186.2, :Os => 190.2, :Ir =>  192.2, :Pt => 195.1, :Au => 197.0, :Hg => 200.6, :Ti => 204.4, 
+      :Pb => 207.2, :Bi => 209, :Po => 209, :At => 210, :Rn => 222, :Fr => 223, :Ra => 226, :Ac => 227, :Rf => 261, :Db => 262, :Sg => 263, :Bh => 264, :Hs => 265,
+      :Mt => 268, :Ds => 271, :Rg => 272 }
+  
+  attr_accessor :chem_species, :mm
+
+  def initialize(formula)
+   if formula.scan(/\d+$/) == [] 
+     x = formula.gsub(/$/, '1').scan(/[A-za-z]*\d+/)  
+     speciate(x)
+    else      
+     x = formula.scan(/[A-za-z]*\d+/)
+     speciate(x)
+    end
+  end
+  
+  private
+  
+  def speciate(x)
+     @chem_species = x.map { |chem| chem.scan(/[A-Z][^A-Z]*/) }.flatten
+     @chem_species.map! {|chem| chem.scan /[A-Z]+|\d+/i }
+     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 }
+  end
+end
+
+class BalanceChem
+  attr_accessor :balanced, :lefteq, :righteq, :leftfw, :rightfw, :count
+  
+##
+# Checks if two formulas are balanced.
+#  
+  def initialize(lefteq, righteq)
+     @lefteq = lefteq
+     @righteq = righteq
+     @balanced = ( RubyChem::Chemical.new(@lefteq).mm - RubyChem::Chemical.new(@righteq).mm ).abs < 0.00001
+  end
+  
+  def balanceit
+         @count = 0
+         @leftfw = @leftfw.fw
+         @rightfw = @rightfw.fw
+     until @balanced == true
+         @rightfw = @rightfw * 2
+         @balanced = (@leftfw - @rightfw).abs < 0.00001
+         @count += 1
+       end 
+       puts "#{@lefteq} (#{@leftfw}) -> #{@righteq} (#{@rightfw}) is a balanced equation; #{@count} iterations"
+  end
+  
+  
+end
+end

data/lib/ruby_chem.rb

@@ -0,0 +1,98 @@
+module RubyChemOld
+  class Chemical
+  
+    MASSES = { :H => 1.01, :He => 4.00, :Li => 6.94, :Be => 9.01, :B => 10.81, :C => 12.01, :N => 14.01, :F => 19.00, :Ne => 20.18, :S => 32.01, :O => 15.99, 
+      :Na => 22.99, :Mg => 24.31, :Al => 26.98, :Si => 28.09, :P => 30.97, :Cl => 35.45, :Ar => 39.95, :K => 39.1, :Ca => 40.08, :Sc => 44.96, :Ti => 47.88, :V => 50.94,
+      :Cr => 52.00, :Mn => 54.94, :Fe => 55.85, :Co => 58.93, :Ni => 58.69, :Cu => 63.55, :Zn => 65.39, :Ga => 69.72, :Ge=> 72.61, :As => 74.92, :Se => 78.96, 
+      :Br => 79.90, :Kr => 83.80, :Rb => 85.47, :Sr => 87.62, :Y => 88.91, :Zr => 91.22, :Nb => 92.91, :Mo => 95.94, :Te => 98, :Ru => 101.07, :Rh => 102.91, 
+      :Pd => 106.42, :Ag => 107.87, :Cd => 112.41, :In => 114.82, :Sn => 118.71, :Sb => 121.76, :Te => 127.6, :I => 126.9, :Xe => 131.29, :Cs => 132.9, :Ba => 137.3, 
+      :La => 138.9, :Hf => 178.5, :Ta => 180.9, :W => 183.9, :Re => 186.2, :Os => 190.2, :Ir =>  192.2, :Pt => 195.1, :Au => 197.0, :Hg => 200.6, :Ti => 204.4, 
+      :Pb => 207.2, :Bi => 209, :Po => 209, :At => 210, :Rn => 222, :Fr => 223, :Ra => 226, :Ac => 227, :Rf => 261, :Db => 262, :Sg => 263, :Bh => 264, :Hs => 265,
+      :Mt => 268, :Ds => 271, :Rg => 272 }
+  
+  attr_accessor :chem_species, :mm, :fw
+
+  def initialize(formula)
+# Checks if the last element is monatomic; adds '1' if it is.
+# This is a comparison, true or false, is there no trailing digit?
+# the scan method is used to iterate through text, scan accepts 1 argument, 
+# in this case "match any digit \d, Match one or more occurrences of the preceding character +,
+# anchor for the end of line $"
+   if formula.scan(/\d+$/) == []
+# if there is no digit, .gsub adds the trailing digit, 1)     
+    
+# This method scans for the range [A-za-z] and any digit \d, Matching one or more 
+# occurrences of the preceding character +
+# so H2SO4 => ["H2, "SO4""]    
+     x = formula.gsub(/$/, '1').scan(/[A-za-z]*\d+/)
+# Calls the speciate private method, passes the variable x as the argument     
+     speciate(x)
+    else      
+     x = formula.scan(/[A-za-z]*\d+/)
+     speciate(x)
+    end
+  end
+
+##
+# Calculates the molecular mass.
+#  
+  def fw
+# .map allows iteration and conversion of elements of an array. .scan will split the array elements between a letter(range A-Z) that matches, and a digit that matches
+# /i makes the whole regex case insensative. ! saves it immediately, from ["H2", "S", "O4"]  the result => [["H", "2"], ["S"], ["O", "4"]]     
+    @chem_species.map! {|chem| chem.scan /[A-Z]+|\d+/i }
+# .map allows iteration and conversion of elements of an array. The current array [["H", "2"], ["S"], ["O", "4"]]
+# is iterated through elem, and coeff. The element is converted to a symbol and is multiplied by the coeff floating point
+# if there is no coefficient 1 is substituted, using (coeff || 1). Result => [2.02, 32.01, 63.96] 
+     atom_masses = @chem_species.map { |(elem, coeff)| MASSES[elem.to_sym] * (coeff || 1).to_f }
+# Converts all elements within the array to floating point, althought I'm not sure if this is needed.
+     x = atom_masses.map { |int| int.to_f }
+# the .inject combines the elements of enum, s = s + v     
+     @mm = x.inject(0) { |s,v| s+= v }
+  end
+  
+##
+# Places formula species into an array.
+#
+  
+  private
+  
+  def speciate(x)
+# This method breaks apart chemical compounds into species. It does so by
+# first using the .map method, which allows iteratation and conversion of elements of an array.
+# The elemeonts of the array are modified using the .scan method. Each element of the     
+# array is scanned for two consecutive letters, for instance ["H2", "SO4"] is scanned for the range of [A-Z] and an 
+# anchor at the beginning of the second character (range [A-Z]) ^. Returns => [["H2"], ["S", "O4"]] 
+# The .flatten method returns ["H2", "S", "O4"]   
+   @chem_species = x.map { |chem| chem.scan(/[A-Z][^A-Z]*/) }.flatten
+  end
+end
+
+class BalanceChem
+  attr_accessor :balanced, :lefteq, :righteq, :leftfw, :rightfw, :count
+  
+##
+# Checks if two formulas are balanced.
+#  
+  def initialize(lefteq, righteq)
+     @lefteq = lefteq
+     @righteq = righteq
+     @leftfw = RubyChem::Chemical.new(@lefteq)
+     @rightfw = RubyChem::Chemical.new(@righteq)
+     @balanced = ( RubyChem::Chemical.new(@lefteq).fw - RubyChem::Chemical.new(@righteq).fw ).abs < 0.00001
+  end
+  
+  def balanceit
+         @count = 0
+         @leftfw = @leftfw.fw
+         @rightfw = @rightfw.fw
+     until @balanced == true
+         @rightfw = @rightfw * 2
+         @balanced = (@leftfw - @rightfw).abs < 0.00001
+         @count += 1
+       end 
+       puts "#{@lefteq} (#{@leftfw}) -> #{@righteq} (#{@rightfw}) is a balanced equation; #{@count} iterations"
+  end
+  
+  
+end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: rubychem
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Justin Zollars
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-05 00:00:00 -07:00
+default_executable: 
+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 Green State University'
+email: 
+- justin.zollars@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .DS_Store
+- .gitignore
+- LICENSE
+- README.markdown
+- lib/.DS_Store
+- lib/benchmark.rb
+- lib/beta.rb
+- lib/ruby_chem.rb
+has_rdoc: true
+homepage: http://www.justinzollars.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rubychem
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A ruby chemistry library
+test_files: []
+