dimus-taxamatch_rb 0.5.0 → 0.5.1

data/README.rdoc

@@ -1,6 +1,59 @@
 = taxamatch_rb
 
-Description goes here.
+Taxamatch_Rb is a ruby implementation of Taxamatch algorithms developed by Tony Rees: http://www.cmar.csiro.au/datacentre/taxamatch.htm
+
+The purpose of Taxamatch gem is to facilitate fuzzy comparison of two scientific name renderings to find out if they actually point to the same scientific name.
+
+    tm = Taxamatch::Base.new
+    tm.taxamatch('Homo sapien', 'Homo sapiens') #returns true
+    tm.taxamatch('Homo sapiens Linnaeus', 'Hommo sapens (Linn. 1758)') #returns true
+    tm.taxamatch('Homo sapiens Mozzherin', 'Homo sapiens Linnaeus') #returns false 
+
+Taxamatch_Rb is compatible with ruby versions 1.8.7 and 1.9.1 and higher
+
+== Installation
+
+    sudo gem install dimus-taxamatch_rb --source http://gems.github.com
+
+or
+    sudo gem sources -a http://gems.github.com #(you only have to do this once)
+    sudo gem install dimus-taxamatch_rb
+
+== Usage
+
+    require 'rubygems' #not needed for ruby > 1.9.1
+    require 'taxamatch_rb'
+
+    tm = Taxamatch::Base.new
+    
+* compare full scientific names
+
+    tm.taxamatch('Hommo sapiens L.', 'Homo sapiens Linnaeus')
+
+* preparse names for the matching (necessary for large databases of scientific names)
+
+    p = Taxamatch::Parser.new
+    parsed_name1 = p.parse('Monacanthus fronticinctus Günther 1867 sec. Eschmeyer 2004')
+    parsed_name2 = p.parse('Monacanthus fronticinctus (Gunther, 1867)')
+
+* compare preparsed names
+
+    tm.taxamatch_preparsed(parsed_name1, parsed_name2)
+
+* compare genera
+    
+    tm.match_genera('Monacanthus', 'MONOCANTUS')
+
+* compare species
+    
+    tm.match_species('fronticinctus', 'frontecinctus')
+
+* compare authors and years
+
+    Taxamatch::Authmatch.authmatch(['Linnaeus'], ['L','Muller'], [1786], [1787])
+
+
+You can find more examples in spec section of the code
 
 == Copyright
 

data/lib/taxamatch_rb.rb

@@ -22,32 +22,32 @@ module Taxamatch
    
     #takes two scientific names and returns true if names match and false if they don't
     def taxamatch(str1, str2) 
-      parsed_data_1 = @parser.parse(str1)
-      parsed_data_2 = @parser.parse(str2)
-      taxamatch_parsed_data(parsed_data_1, parsed_data_2)[:match]
+      preparsed_1 = @parser.parse(str1)
+      preparsed_2 = @parser.parse(str2)
+      taxamatch_preparsed(preparsed_1, preparsed_2)[:match]
     end
   
     #takes two hashes of parsed scientific names, analyses them and returns back 
     #this function is useful when species strings are preparsed.
-    def taxamatch_parsed_data(parsed_data_1, parsed_data_2)
+    def taxamatch_preparsed(preparsed_1, preparsed_2)
       result = nil
-      result =  match_uninomial(parsed_data_1, parsed_data_2) if parsed_data_1[:uninomial] && parsed_data_2[:uninomial] 
-      result =  match_multinomial(parsed_data_1, parsed_data_2) if parsed_data_1[:genus] && parsed_data_2[:genus]
+      result =  match_uninomial(preparsed_1, preparsed_2) if preparsed_1[:uninomial] && preparsed_2[:uninomial] 
+      result =  match_multinomial(preparsed_1, preparsed_2) if preparsed_1[:genus] && preparsed_2[:genus]
       if result && result[:match]
-        result[:match] = false if match_authors(parsed_data_1, parsed_data_2) == 0 
+        result[:match] = false if match_authors(preparsed_1, preparsed_2) == 0 
       end
       return result
     end
   
-    def match_uninomial(parsed_data_1, parsed_data_2)
+    def match_uninomial(preparsed_1, preparsed_2)
       return false
     end
 
-    def match_multinomial(parsed_data_1, parsed_data_2)
-      gen_match = match_genera(parsed_data_1[:genus], parsed_data_2[:genus])
-      sp_match = match_species(parsed_data_1[:species], parsed_data_2[:species])
-      au_match = match_authors(parsed_data_1, parsed_data_2)
-      total_length = parsed_data_1[:genus][:epitheton].size + parsed_data_2[:genus][:epitheton].size + parsed_data_1[:species][:epitheton].size + parsed_data_2[:species][:epitheton].size
+    def match_multinomial(preparsed_1, preparsed_2)
+      gen_match = match_genera(preparsed_1[:genus], preparsed_2[:genus])
+      sp_match = match_species(preparsed_1[:species], preparsed_2[:species])
+      au_match = match_authors(preparsed_1, preparsed_2)
+      total_length = preparsed_1[:genus][:epitheton].size + preparsed_2[:genus][:epitheton].size + preparsed_1[:species][:epitheton].size + preparsed_2[:species][:epitheton].size
       match = match_matches(gen_match, sp_match)
       match.merge({:score => (1- match[:edit_distance]/(total_length/2))})
     end
@@ -76,11 +76,11 @@ module Taxamatch
       {:edit_distance => ed, :match => match, :phonetic_match => false}
     end
   
-    def match_authors(parsed_data_1, parsed_data_2)
-      au1 = parsed_data_1[:all_authors]
-      au2 = parsed_data_2[:all_authors]
-      yr1 = parsed_data_1[:all_years]
-      yr2 = parsed_data_2[:all_years]
+    def match_authors(preparsed_1, preparsed_2)
+      au1 = preparsed_1[:all_authors]
+      au2 = preparsed_2[:all_authors]
+      yr1 = preparsed_1[:all_years]
+      yr2 = preparsed_2[:all_years]
       Taxamatch::Authmatch.authmatch(au1, au2, yr1, yr2)
     end
   

data/lib/taxamatch_rb/damerau_levenshtein_mod.rb

@@ -12,9 +12,11 @@ module Taxamatch
 
     inline do |builder|
       builder.c "
-      static VALUE distance_utf(VALUE _s, VALUE _t, long block_size, long max_distance){
-        long min, i, i1, j, j1, k, sl, half_sl, tl, half_tl, cost, *d, distance, del, ins, subs, transp, block, current_distance;
-        long stop_execution = 0;
+      static VALUE distance_utf(VALUE _s, VALUE _t, int block_size, int max_distance){
+        int i, i1, j, j1, k, sl, half_sl, tl, half_tl, cost, *d, distance, del, ins, subs, transp, block;
+        int stop_execution = 0;
+        int min = 0;
+        int current_distance = 0;
 
         VALUE *sv = RARRAY_PTR(_s);
         VALUE *tv = RARRAY_PTR(_t);
@@ -22,22 +24,22 @@ module Taxamatch
         sl = RARRAY_LEN(_s);
         tl = RARRAY_LEN(_t);
       
-        if (sl == 0) return LONG2NUM(tl);
-        if (tl == 0) return LONG2NUM(sl);
+        if (sl == 0) return INT2NUM(tl);
+        if (tl == 0) return INT2NUM(sl);
         //case of lengths 1 must present or it will break further in the code
-        if (sl == 1 && tl == 1 && sv[0] != tv[0]) return LONG2NUM(1);
+        if (sl == 1 && tl == 1 && sv[0] != tv[0]) return INT2NUM(1);
       
-        long s[sl];
-        long t[tl];
+        int s[sl];
+        int t[tl];
       
-        for (i=0; i < sl; i++) s[i] = NUM2LONG(sv[i]);
-        for (i=0; i < tl; i++) t[i] = NUM2LONG(tv[i]);
+        for (i=0; i < sl; i++) s[i] = NUM2INT(sv[i]);
+        for (i=0; i < tl; i++) t[i] = NUM2INT(tv[i]);
       
         sl++;
         tl++;
       
         //one-dimentional representation of 2 dimentional array len(s)+1 * len(t)+1
-        d = malloc((sizeof(long))*(sl)*(tl));
+        d = malloc((sizeof(int))*(sl)*(tl));
         //populate 'vertical' row starting from the 2nd position (first one is filled already)
         for(i = 0; i < tl; i++){
           d[i*sl] = i;
@@ -60,8 +62,8 @@ module Taxamatch
             block = block < half_tl ? block : half_tl;
           
             while (block >= 1){   
-              long swap1 = 1;
-              long swap2 = 1;
+              int swap1 = 1;
+              int swap2 = 1;
               i1 = i - (block * 2);
               j1 = j - (block * 2);
               for (k = i1; k < i1 + block; k++) {
@@ -81,7 +83,7 @@ module Taxamatch
               ins = d[(j-1)*sl + i] + 1;
               min = del;
               if (ins < min) min = ins;
-              //if (i == 2 && j==2) return LONG2NUM(swap2+5); 
+              //if (i == 2 && j==2) return INT2NUM(swap2+5); 
               if (i >= block && j >= block && swap1 == 1 && swap2 == 1){
                 transp = d[(j - block * 2) * sl + i - block * 2] + cost + block -1; 
                 if (transp < min) min = transp;
@@ -103,7 +105,7 @@ module Taxamatch
         if (stop_execution == 1) distance = current_distance;
       
         free(d);
-        return LONG2NUM(distance);
+        return INT2NUM(distance);
       }
      "
     end

data/lib/taxamatch_rb/normalizer.rb

@@ -8,7 +8,11 @@ module Taxamatch
     end
   
     def self.normalize_word(word)
-      self.normalize(word).gsub(/[^A-Z0-9\-]/, '')
+      self.normalize(word).gsub(/[^A-Z0-9\-]/, '').strip
+    end
+    
+    def self.normalize_author(string)
+      self.normalize(string).gsub(/[^A-Z]/, ' ').gsub(/[\s]{2,}/, ' ').strip
     end
 
   protected

data/lib/taxamatch_rb/parser.rb

@@ -71,8 +71,9 @@ module Taxamatch
         end
       end
       res[:authors].uniq!
+      res[:normalized_authors] = res[:authors].map {|a| Taxamatch::Normalizer.normalize_author(a)}
       res[:years].uniq!
-      @res[:all_authors] += res[:authors] if res[:authors].size > 0
+      @res[:all_authors] += res[:normalized_authors] if res[:normalized_authors].size > 0
       @res[:all_years] += res[:years] if res[:years].size > 0
     end
 

data/spec/taxamatch_rb_spec.rb

@@ -20,17 +20,16 @@ describe 'Parser' do
   end
   
   it 'should parse uninomials' do
-    @parser.parse('Betula').should == {:all_authors=>[], :all_years=>[], :uninomial=>{:epitheton=>"Betula", :normalized=>"BETULA", :phonetized=>"BITILA", :authors=>[], :years=>[]}}
-    @parser.parse('Ærenea Lacordaire, 1872').should == {:all_authors=>["LACORDAIRE"], :all_years=>["1872"], :uninomial=>{:epitheton=>"Aerenea", :authors=>["Lacordaire"], :normalized=>"AERENEA", :phonetized=>"ERINIA", :years=>["1872"]}}
-    @parser.parse('Ærenea (Lacordaire, 1872) Muller 2007').should == {:all_authors=>["LACORDAIRE", "MULLER"], :all_years=>["1872", "2007"], :uninomial=>{:epitheton=>"Aerenea", :authors=>["Lacordaire", "Muller"], :normalized=>"AERENEA", :phonetized=>"ERINIA", :years=>["1872", "2007"]}}
+    @parser.parse('Betula').should == {:all_authors=>[], :all_years=>[], :uninomial=>{:epitheton=>"Betula", :normalized=>"BETULA", :phonetized=>"BITILA", :authors=>[], :years=>[], :normalized_authors=>[]}}
+    @parser.parse('Ærenea Lacordaire, 1872').should == {:all_authors=>["LACORDAIRE"], :all_years=>["1872"], :uninomial=>{:epitheton=>"Aerenea", :normalized=>"AERENEA", :phonetized=>"ERINIA", :authors=>["Lacordaire"], :years=>["1872"], :normalized_authors=>["LACORDAIRE"]}}
   end
   
   it 'should parse binomials' do
-    @parser.parse('Leœptura laetifica Dow, 1913').should == {:species=>{:epitheton=>"laetifica", :authors=>["Dow"], :normalized=>"LAETIFICA", :phonetized=>"LITIFICA", :years=>["1913"]}, :all_authors=>["DOW"], :all_years=>["1913"], :genus=>{:epitheton=>"Leoeptura", :authors=>[], :normalized=>"LEOEPTURA", :phonetized=>"LIPTIRA", :years=>[]}}
+    @parser.parse('Leœptura laetifica Dow, 1913').should == {:all_authors=>["DOW"], :all_years=>["1913"], :genus=>{:epitheton=>"Leoeptura", :normalized=>"LEOEPTURA", :phonetized=>"LIPTIRA", :authors=>[], :years=>[], :normalized_authors=>[]}, :species=>{:epitheton=>"laetifica", :normalized=>"LAETIFICA", :phonetized=>"LITIFICA", :authors=>["Dow"], :years=>["1913"], :normalized_authors=>["DOW"]}}
   end
   
   it 'should parse trinomials' do 
-    @parser.parse('Hydnellum scrobiculatum zonatum (Banker) D. Hall et D.E. Stuntz 1972').should == {:genus=>{:epitheton=>"Hydnellum", :authors=>[], :normalized=>"HYDNELLUM", :phonetized=>"HIDNILIM", :years=>[]}, :infraspecies=>[{:epitheton=>"zonatum", :authors=>["Banker", "D. Hall", "D.E. Stuntz"], :normalized=>"ZONATUM", :phonetized=>"ZANATA", :years=>["1972"]}], :all_authors=>["BANKER", "D. HALL", "D.E. STUNTZ"], :all_years=>["1972"], :species=>{:epitheton=>"scrobiculatum", :authors=>[], :normalized=>"SCROBICULATUM", :phonetized=>"SCRABICILATA", :years=>[]}}
+    @parser.parse('Hydnellum scrobiculatum zonatum (Banker) D. Hall et D.E. Stuntz 1972').should == {:all_authors=>["BANKER", "D HALL", "D E STUNTZ"], :all_years=>["1972"], :genus=>{:epitheton=>"Hydnellum", :normalized=>"HYDNELLUM", :phonetized=>"HIDNILIM", :authors=>[], :years=>[], :normalized_authors=>[]}, :species=>{:epitheton=>"scrobiculatum", :normalized=>"SCROBICULATUM", :phonetized=>"SCRABICILATA", :authors=>[], :years=>[], :normalized_authors=>[]}, :infraspecies=>[{:epitheton=>"zonatum", :normalized=>"ZONATUM", :phonetized=>"ZANATA", :authors=>["Banker", "D. Hall", "D.E. Stuntz"], :years=>["1972"], :normalized_authors=>["BANKER", "D HALL", "D E STUNTZ"]}]}
   end
 end
 

data/spec/taxamatch_test.txt

@@ -16,4 +16,13 @@ Pomatomus saltator|Pomatomus saltatrix|true
 Loligo pealeii|Loligo plei|false
 
 # different authors should not match
-Puma concolor Linnaeus|Puma concolor Kurtz|false
+Puma concolor Linnaeus|Puma concolor Kurtz|false
+
+#real life examples
+Biatora borealis|Bactra borealis Diakonoff 1964|false
+
+Homo sapien|Homo sapiens|true
+Homo sapiens Linnaeus|Homo sapens (Linn. 1758) |true
+Homo sapiens Mozzherin|Homo sapiens Linneaus|false
+
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dimus-taxamatch_rb
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors: 
 - Dmitry Mozzherin
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-07 00:00:00 -07:00
+date: 2009-08-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency