chemruby 0.9.3

data/lib/chem/utils/math.rb

@@ -0,0 +1,17 @@
+
+require 'matrix'
+
+class Vector
+
+  def []=(i,x) ; @elements[i]=x  ;  end
+
+  def x        ; @elements[0]    ; end
+  def y        ; @elements[1]    ; end
+  def z        ; @elements[2]    ; end
+
+  def x= x_val ; @elements[0] = x_val ; end
+  def y= y_val ; @elements[1] = y_val ; end
+  def z= z_val ; @elements[2] = z_val ; end
+
+end
+

data/lib/chem/utils/prop.rb

@@ -0,0 +1,123 @@
+#
+# module for calculating properties
+#
+
+module Chem
+
+  module Atom
+
+    # Returns electro negativity
+    # see chem/data/electronegativity.rb
+    def electro_negativity
+      ElectroNegativity[self.element]
+    end
+
+    # Returns Natural Bond Order of this atom
+    # :C => 4, :H => 1...
+    # see chem/data/character.rb
+    def natural_bond_order
+      NaturalBondOrder[self.element]
+    end
+
+    # Returns Atomic weight
+    # see chem/data/atomic_weight.rb
+    def weight
+      AtomicWeight[self.element]
+    end
+
+  end
+
+  module Molecule
+
+    # Returns number of hydrogen
+    # this method may be overrided
+    def n_hydrogen node
+      n_h = node.natural_bond_order
+      adjacent_to(node).each do |bond, atom|
+        n_h -= bond.v
+      end
+      n_h
+    end
+
+    # Returns molecular weight
+    # mol.molecular_weight :unknown_atom => true
+    def molecular_weight prop = {}
+      comp = self.composition()
+      comp.inject(0.0){|ret, (el, n)|
+        if AtomicWeight[el]
+          ret + AtomicWeight[el] * n
+        elsif prop[:neglect_unknown_atom]
+          ret
+        else
+          return nil
+        end
+      }
+    end
+
+    alias mw molecular_weight
+
+    # Returns oxidation number of node
+    # this method can be moved to Atom module
+    def oxidation_number node
+      en = 0
+      adjacent_to(node).each do |bond, atom|
+        case node.electro_negativity <=> atom.electro_negativity
+        when -1
+          en += bond.v
+        when 1
+          en -= bond.v
+        end
+      end
+      # implicit hydrogen
+      if ElectroNegativity[:H] < node.electro_negativity
+        en -= n_hydrogen(node)
+      else
+        en += n_hydrogen(node)
+      end
+      en
+    end
+
+    # Returns composition
+    # Chem.open_mol("benzene").composition # {:C => 6, :H => 6}
+    def composition
+
+      composition = {}
+      @nodes.each do |atom|
+        composition[atom.element] ||= 0
+        composition[atom.element] += 1
+      end
+      composition
+    end
+
+    # return     1 if self.composition >  to.composition
+    # return     0 if self.composition == to.composition
+    # return    -1 if self.composition <  to.composition
+    # return false if self.composition <> to.composition
+    def subset_in_composition?(to)
+      self_is_sub = false
+      to_is_sub   = false
+      all = (to.composition.keys + composition.keys).uniq
+      return false if all.length == 0
+      if (all - composition.keys).length > 0 && (all - to.composition.keys).length > 0
+        return false
+      elsif (all - composition.keys).length > 0
+        return -1 if composition.all?{|k, v| v <= to.composition[k]}
+        return false
+      elsif (all - to.composition.keys).length > 0
+        return 1 if to.composition.all?{|k, v| v <= composition[k]}
+        return false
+      elsif all.length == composition.keys.length && all.length == to.composition.length
+        # then compare number of nodes ?
+        if all.all? { |node| composition[node] == to.composition[node]}
+          return 0
+        elsif all.all?{ |node| composition[node] >= to.composition[node]}
+          return 1
+        elsif all.all?{ |node| composition[node] <= to.composition[node]}
+          return -1
+        end
+      end
+      return false
+    end
+
+  end
+end

data/lib/chem/utils/sssr.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/ruby
+
+module Chem
+  class Ring
+  end
+
+  module Molecule
+    # J. Chem. Inf. Comput. Sci. 1996, 36, 986-991
+    # John Figueras
+    # Ring Perception Using Breadth-First Search
+
+    # J. Chem. Inf. Comput. Sci. 1994, 34, 822-831
+    # Renzo Balducci and Robert S. Pearlman
+    # Efficient Exact Solution of the Ring Perception Problem
+    #
+
+    def find_smallest_ring root
+      path = {}
+      path[root] = [root]
+
+      bfs(root) do |from, to|
+	if visit = !path.keys.include?(to)
+	  path[to] = path[from].clone
+	  path[to].push(to)
+	elsif path[from][-2] != to
+	  if 1 == (path[from] & path[to]).length
+	    return path[from] + path[to][1..-1].reverse
+	  end
+	end
+	visit
+      end
+    end
+
+    def canonical_ring ring
+#      ring.sort # Fix me! This is not sufficient
+      ring.sort{|a, b| @atoms.index(a) <=> @atoms.index(b)}
+    end
+
+    def find_sssr
+      return @sssr if @sssr
+      fullSet = []
+      trimSet = []
+      rings = []
+      @mol = {}
+#     mol = {1=>[2, 5], 2=> [1, 3], 3=> [2, 4], 4=>[3, 5], 5=>[4,1]}
+#       @nodes.each do |k, atom|
+# 	atom.set_neighbor
+# 	@mol[atom] = atom.neighbor
+#       end
+
+      loop do
+	nodesN2 = []
+	smallest_degree = 10
+	smallest = nil
+	@mol.each do |k, a|
+	  case a.length
+	  when 0
+	    @mol.delete(k)# Is this OK?
+	    trimSet.push(k)
+	  when 2
+	    nodesN2.push(k)
+	  end
+	  if a.length > 0 && a.length < smallest_degree
+	    smallest = k
+	    smallest_degree = a.length
+	  end
+	end
+	case smallest_degree
+	when 1
+	  trim(smallest)
+	when 2
+	  nodesN2.each do |k|
+	    ring = find_smallest_ring(k)
+#	    rings.push(canonical_ring(ring)) if !rings.include?(canonical_ring(ring))
+	    rings.push(canonical_ring(ring)) if ring && !rings.include?(canonical_ring(ring))
+	  end
+	  nodesN2.each do |k|
+	    trim(k)
+	  end
+	when 3
+	  ring = find_smallest_ring(smallest)
+	  trim(smallest)
+	end
+	break if @mol.length  == 0
+      end
+      @sssr = rings
+    end
+
+    def trim smallest
+      if @mol.length > 0 && @mol.include?(smallest)
+	@mol[smallest].each do |n|
+	  @mol[n] = @mol[n] - [smallest]
+	  @mol.delete(smallest)
+	  @mol.delete(n) if @mol[n].length == 0
+	end
+      end
+    end
+
+  end
+end
+

data/lib/chem/utils/sub.rb

@@ -0,0 +1,78 @@
+
+module Chem
+  module Molecule
+
+    def induced_sub ary
+      sub = deep_dup
+      (sub.nodes - ary).each do |node|
+        sub.delete(node)
+      end
+      sub
+    end
+
+    def connected?
+      traversed = []
+      start = @nodes[0]
+      traversed << start
+      dfs(start) do |from, to|
+        traversed << to
+      end
+      traversed.length == @nodes.length
+    end
+
+    # divide compounds by connectivity
+    # e.g. washing salts.
+    def divide
+      traversed = []
+      start = @nodes[0]
+      divided_compound = []
+
+      while traversed.length != @nodes.length
+        part = []
+        traversed << start
+        part << start
+        dfs(start) do |from, to, bond|
+          unless part.include?(to)
+            traversed << to
+            part << to
+          end
+        end
+
+        start = @nodes.find{|node| !traversed.include?(node)}
+        divided_compound << induced_sub(part)
+      end
+      divided_compound
+    end
+
+    def delete_bond(bond)
+      @edges.delete(bond)
+      @adjacencies.each do |v, k|
+        k.delete_if{ |b, atom_a, atom_b| bond == b}
+      end
+    end
+
+    def delete(atom)
+      @nodes.delete(atom)
+      adjacent_to(atom).each do |adj_edge, adj_node|
+        @edges.delete_if{|bond, atom_a, atom_b| bond == adj_edge}
+      end
+    end
+
+    def deep_dup
+      ret = dup
+      ret.nodes = @nodes.dup
+      #ret.adjacencies = @adjacencies.dup if @adjacencies
+      ret.edges = @edges.dup
+      ret
+    end
+
+    def - (other)
+      if other.instance_of?(Array)
+        induced_sub(@nodes - other)
+      else
+        induced_sub(@nodes - other.nodes)
+      end
+    end
+
+  end
+end

data/lib/chem/utils/transform.rb

@@ -0,0 +1,110 @@
+#!/usr/local/bin/ruby
+
+require 'matrix'
+
+module Chem
+
+  module Transform
+
+    module TwoDimension
+
+      def initialize
+        super
+        @pos = Vector[0.0, 0.0]
+      end
+
+      def pos ; @pos ||= Vector[@x, @y, @z] ; end
+      def x ; pos[0] ; end
+      def y ; pos[1] ; end
+      def x=(x_val) ; pos[0] = x_val ; end
+      def y=(y_val) ; pos[1] = y_val ; end
+    end
+
+    module ThreeDimension
+      include TwoDimension
+      
+      def initialize
+        super
+        @pos = Vector[0.0, 0.0]
+      end
+
+      def z ; pos[2] ; end
+      def z=(z_val) ; pos[2] = z_val ; end
+
+    end
+
+  end
+end
+
+class Transform
+
+  def initialize m = Matrix.new
+    @m = m
+  end
+
+  def * (t)
+    @m * t
+  end
+
+  def transform(v)
+    v * @m
+  end
+
+  def Transform::translate(x, y, z)
+    Matrix[[1, 0, 0, 0],
+           [0, 1, 0, 0],
+           [0, 0, 1, 0],
+           [x, y, z, 1]].transpose
+  end
+
+  def Transform::scale(x, y, z)
+    Matrix[[x, 0, 0, 0],
+           [0, y, 0, 0],
+           [0, 0, z, 0],
+           [0, 0, 0, 1]].transpose
+  end
+
+  def Transform::rotate_x(theta)
+    Matrix[[1.0,               0.0,             0.0, 0.0],
+           [0.0,   Math.cos(theta), Math.sin(theta), 0.0],
+           [0.0, - Math.sin(theta), Math.cos(theta), 0.0],
+           [0.0,               0.0,             0.0, 1.0]].transpose
+  end
+
+  def Transform::rotate_y(theta)
+    Matrix[[Math.cos(theta),   0.0, - Math.sin(theta), 0.0],
+           [0.0,               1.0,               0.0, 0.0],
+           [Math.sin(theta),   0.0,   Math.cos(theta), 0.0],
+           [0.0,               0.0,               0.0, 1.0]].transpose
+  end
+
+  def Transform::rotate_z(theta)
+    Matrix[[  Math.cos(theta),   Math.sin(theta),   0.0, 0.0],
+           [- Math.sin(theta),   Math.cos(theta),   0.0, 0.0],
+           [  0.0,               0.0,               1.0, 0.0],
+           [  0.0,               0.0,               0.0, 1.0]].transpose
+  end
+
+  def Transform::inverse_x
+    Matrix[[ -1,  0,  0,  0],
+           [  0,  1,  0,  0],
+           [  0,  0, -1,  0],
+           [  0,  0,  0,  1]].transpose
+  end
+
+  def Transform::inverse_y
+    Matrix[[  1,  0,  0,  0],
+           [  0, -1,  0,  0],
+           [  0,  0,  1,  0],
+           [  0,  0,  0,  1]].transpose
+  end
+
+  def Transform::inverse_z
+    Matrix[[  1,  0,  0,  0],
+           [  0,  1,  0,  0],
+           [  0,  0, -1,  0],
+           [  0,  0,  0,  1]].transpose
+  end
+
+end
+

data/lib/chem/utils/traverse.rb

@@ -0,0 +1,37 @@
+
+module Chem
+  module Molecule
+    # Breadth first search solves steps and path to the each node and forms
+    # a tree contains all reachable vertices from the root node.
+
+    def breadth_first_search(root = @nodes[0])
+
+      queue = [ root ]
+
+      traversed = []
+
+      while from = queue.shift
+	adjacent_to(from).each do |bond, to|
+          next if traversed.include?(bond)
+          traversed.push(bond)
+          queue.push(to) if yield(from, to)
+	end
+      end
+    end
+
+    alias :bfs :breadth_first_search
+
+    def depth_first_search(from = @nodes[0], traversed = [], &block)
+      adjacent_to(from).each do |bond, to|
+        next if traversed.include?(bond)
+        traversed.push(bond)
+        yield(from, to, bond)
+        depth_first_search(to, traversed, &block)
+      end
+    end
+
+    alias :dfs :depth_first_search
+
+  end
+end
+