cassiopee 0.1.1 → 0.1.2

data/Changelog

@@ -1,3 +1,10 @@
+v0.1.2 : 09/11 Olivier Sallou
+ add possibility to reload an "index" instead of using index method again
+ fix comment mngt (comments attribute)
+ add filter methods
+ add to_pos method to display results per position
+ add optimal methods
+ add ambiguity support
 v0.1.1 : fix #1, add filter option
   08/09/11 Olivier Sallou
 v0.1.0 : First version

data/lib/cassiopee.rb

@@ -3,6 +3,7 @@ require 'logger'
 require 'zlib'
 require 'rubygems'
 require 'text'
+require 'text/util'
 
 module Cassiopee
 
@@ -17,8 +18,36 @@ module Cassiopee
        return computeLevenshtein(pattern,edit)
       end
     end
+	
+	# Calculate the edit or hamming distance between String and pattern
+    # Extend a String
+    # Return -1 if max is reached
+    
+    def computeAmbiguousDistance(pattern,hamming,edit,ambiguous)
+      if(edit==0)
+      	return computeHammingAmbiguous(pattern,hamming,ambiguous)
+      else
+       return computeLevenshteinAmbiguous(pattern,edit,ambiguous)
+      end
+    end
     
-    # Calculate number of substitution between string and pattern
+    # Compute Hamming distance but using a mapping matrix of alphabet ambiguity
+    
+    def computeHammingAmbiguous(pattern,hamming,ambiguous)
+    	pattern = pattern.downcase
+    	nberr = 0
+    	(0..(self.length-1)).each do |c|
+    		if(!isAmbiguousEqual(pattern[c],self[c],ambiguous))
+    			nberr = nberr+1
+    			if(nberr>hamming.to_i)
+    				return -1		
+    			end
+    		end
+    	end
+    	return nberr
+    end
+
+     # Calculate number of substitution between string and pattern
     # Extend a String
     # Return -1 if max is reached
     
@@ -35,8 +64,9 @@ module Cassiopee
     	end
     	return nberr
     end
-
-    
+	
+	   
+		     
     # Calculate the edit distance between string and pattern
     # Extend a String
     # Return -1 if max is reached
@@ -53,12 +83,79 @@ module Cassiopee
     	return distance
     	
     end
+	
+	private
+	
+	# Compute Levenshtein distance but using a mapping matrix of alphabet ambiguity
+	# Code comes from Text gem, Text::Levenshtein.distance, adapted for ambiguity comparison
+	
+    def computeLevenshteinAmbiguous(pattern, edit, ambiguous)
+	
+	  pattern = pattern.downcase
+      encoding = defined?(Encoding) ? self.encoding.to_s : $KCODE
+
+    if Text.encoding_of(self) =~ /^U/i
+      unpack_rule = 'U*'
+    else
+      unpack_rule = 'C*'
+    end
+
+    s = self.unpack(unpack_rule)
+    t = pattern.unpack(unpack_rule)
+    n = s.length
+    m = t.length
+    return m if (0 == n)
+    return n if (0 == m)
+
+    d = (0..m).to_a
+    x = nil
+
+    (0...n).each do |i|
+      e = i+1
+      (0...m).each do |j|
+        cost = (isAmbiguousEqual(s[i],t[j],ambiguous)) ? 0 : 1
+        x = [
+          d[j+1] + 1, # insertion
+          e + 1,      # deletion
+          d[j] + cost # substitution
+        ].min
+        d[j] = e
+        e = x
+      end
+      d[m] = x
+    end
+    if(x>edit)
+    return -1
+	end
+	
+	return x
+  end
+  
+  
+  # checks if 2 chars are equal with ambiguity rules
+  # * ambigous is a Hash of char/Array of char mapping
+  
+  def isAmbiguousEqual(a,b,ambiguous)
+	if(ambiguous==nil || ambiguous[a.chr]==nil)
+	  if(a==b)
+	    return true
+	  else
+	    return false
+	  end
+	end
+	vin = "" << a.chr
+	if(ambiguous[a.chr].index(b.chr)!=nil)
+	   return true
+    else
+	   return false
+	end
+  end
  
  	# Base class to index and search through a string 
  
     class Crawler
  
- 	# Use alphabet ambiguity (dna/rna) in search
+ 	# Use alphabet ambiguity (dna/rna) in search, automatically set with loadAmbiguityFile
     attr_accessor  :useAmbiguity
     # Suffix files name/path
     attr_accessor  :file_suffix
@@ -66,9 +163,13 @@ module Cassiopee
     attr_accessor  :maxthread
     # Use persistent suffix file ?
     attr_accessor  :use_store
+	# Array of comment characters to skip lines in input sequence file
+	attr_accessor  :comments
     
     @min_position = 0
     @max_position = 0
+	
+	@ambiguous = nil
     
     FILE_SUFFIX_EXT = ".sfx"
     FILE_SUFFIX_POS = ".sfp"
@@ -76,9 +177,10 @@ module Cassiopee
     SUFFIXLEN = 'suffix_length'
 
     $maxthread = 1
+	
     
     $log = Logger.new(STDOUT)
-    $log.level = Logger::DEBUG
+    $log.level = Logger::INFO
     
         def initialize
             @useAmbiguity = false
@@ -95,7 +197,17 @@ module Cassiopee
             @use_store = false
             
             @sequence = nil
+			
+			@comments = Array["#"]
         end
+		
+		def filterLength
+		  filterOptimal(0)
+		end
+		
+		def filterCost
+		  filterOptimal(1)
+		end
         
         # Clear suffixes in memory
         # If using use_store, clear the store too
@@ -137,6 +249,53 @@ module Cassiopee
             @min_position = 0
     		@max_position = 0
         end
+		
+		
+		# Load ambiguity rules from a file
+		# File format should be:
+		# * A=B,C
+		#   D=E,F
+		#   ...
+		
+		def loadAmbiguityFile(f)
+		  if(!File.exists?(f))
+		     $log.error("File "<< f << "does not exists")
+			 exit(1)
+		  end
+		  @ambiguous = Hash.new
+		  file = File.new(f, "r")
+		  while (line = file.gets)
+		    definition = line.downcase.chomp
+			ambdef = definition.split('=')
+			ambequal = ambdef[1].split(',')
+			@ambiguous[ambdef[0]] = ambequal
+		  end
+		  @useAmbiguity = true
+		  $log.debug("loaded ambiguity rules: " << @ambiguous.inspect())
+		  file.close
+		
+		end
+		
+		# Load sequence from a previous index command
+		
+		def loadIndex
+			seq = ''
+			begin
+				file = File.new(@file_suffix+FILE_SUFFIX_EXT, "r")
+				while (line = file.gets)
+					input = line.downcase.chomp
+					seq << input
+				end
+				file.close
+			rescue => err
+				$log.error("Exception: #{err}")
+				exit()
+			end
+			@sequence = seq
+			clear()
+            @min_position = 0
+    		@max_position = 0
+		end
         
         # Filter matches to be between min and max start position
         # If not using use_store, search speed is improved but existing indexes are cleared
@@ -153,6 +312,9 @@ module Cassiopee
         # Search exact match
         
         def searchExact(pattern)
+		if(@useAmbiguity)
+		  return searchApproximate(pattern,0)
+		end
         pattern = pattern.downcase
         parseSuffixes(@sequence,pattern.length,pattern.length)
         
@@ -180,11 +342,11 @@ module Cassiopee
         
         
         def searchApproximate(s,edit)
-        	if(edit==0) 
+        	if(edit==0 && !@useAmbiguity) 
         		return searchExact(s)
         	end
         
-        	if(edit>0)
+        	if(edit>=0)
         	  useHamming = true
         	  minmatchsize = s.length
         	  maxmatchsize = s.length
@@ -216,9 +378,17 @@ module Cassiopee
 		    			seq = extractSuffix(posArray[1],posArray[0])
 		    			seq.extend(Cassiopee)
 		    			if(useHamming)
-		    			  errors = seq.computeHamming(s,edit)
+						  if(@useAmbiguity && @ambiguous!=nil)
+						    errors = seq.computeHammingAmbiguous(s,edit,@ambiguous)
+						  else
+		    			    errors = seq.computeHamming(s,edit)
+						  end
 		    			else
-		    			  errors = seq.computeLevenshtein(s,edit)
+						  if(@useAmbiguity && @ambigous!=nil)
+						    errors = seq.computeLevenshteinAmbiguous(s,edit,@ambigous)
+						  else
+		    			    errors = seq.computeLevenshtein(s,edit)
+						  end						
 		    			end
 		    			if(errors>=0)
 		    				filteredPosArray = filter(posArray)
@@ -285,6 +455,34 @@ module Cassiopee
         	end
         end
         
+        def to_pos
+        	positions = Hash.new
+        	@matches.each do |match|
+        	  # match = Array[md5val, errors, posArray]
+        	  i=0
+			  len = 0
+        	  match[2].each do |pos|
+        	    if(i==0)
+        	      len = pos
+        	    else
+        	      if(positions.has_key?(pos))
+        	       posmatch = positions[pos]
+        	       posmatch << Array[len,match[1]]
+
+        	      
+        	      else
+        	        posmatch = Array.new
+        	        posmatch << Array[len,match[1]]
+        	        positions[pos] = posmatch
+        	      end
+        	    end
+        	    i += 1
+        	  end
+        	 
+        	end
+            return positions.sort
+        end
+        
         def to_s
         	puts '{ matches: "' << @matches.length << '" }'
         end
@@ -415,8 +613,20 @@ module Cassiopee
                     	  while (line = file.gets)
                     			counter = counter + 1
                             	input = line.downcase.chomp
-								sequence << input
-								data.puts input
+								skip = false
+								comments.each do |c|
+								$log.debug("skip line ?" << c << " == " << input[0])
+									if(input[0] == c[0])
+										# Line start with a comment char, skip it
+										$log.debug("skip line")
+										skip = true
+										break
+									end
+								end
+								if(!skip)
+									sequence << input
+									data.puts input
+								end
                     	  end
                     	
 						end
@@ -443,7 +653,105 @@ module Cassiopee
                     return obj
                 end
             end
+			
+			# Filter @matches to keep only the longest or the error less matches for a same start position
+			
+			def filterOptimal(type)
+	
+        	positions = Hash.new
+        	@matches.each do |match|
+        	  # match = Array[md5val, errors, posArray]
+        	  i=0
+			  len = 0
+        	  match[2].each do |pos|
+        	    if(i==0)
+        	      len = pos
+        	    else
+        	      if(positions.has_key?(pos))
+        	       posmatch = positions[pos]
+        	       posmatch << Array[len,match[1],match[0]]
+        	       #positions[pos] << posmatch
+        	      
+        	      else
+        	        posmatch = Array.new
+        	        posmatch << Array[len,match[1],match[0]]
+        	        positions[pos] = posmatch
+        	      end
+        	    end
+        	    i += 1
+        	  end
+        	end
+			
+            matchtoremove = Array.new
+			positions.each do |pos,posmatch|
+			 
+			    optimal = nil
+				match = nil
+			    count = 0
+				newoptimal = nil
+				newmatch = nil
+				
+			    (0..posmatch.length-1).each do |i|
+				solution = posmatch[i]				  
+				  if(i==0)
+				    if(type==0)
+			        # length
+			          optimal = solution[0]
+			        else
+			        # cost
+			          optimal = solution[1]	
+			        end				
+			        match = solution[2].to_s
+					#count += 1
+					next
+				  end
+				  
+			      newmatch = solution[2].to_s
+				  if(type==0)
+			      # length
+			        newoptimal = solution[0]
+				    if(newoptimal.to_i>optimal.to_i)
+				      optimal = newoptimal
+					  matchtoremove << match
+				  	  match = newmatch
+					else
+					  matchtoremove << newmatch
+				    end
+			      else
+			      # cost
+				    newoptimal = solution[1]
+				    if(newoptimal<optimal)
+				      optimal = newoptimal
+					  matchtoremove << match
+			  		  match = newmatch
+					else
+					  matchtoremove << newmatch
+				    end		
+			      end
+				  count += 1
+					
+				end			
+			  
+			end
+			
+			newmatches = Array.new
+			@matches.each do |match|
+			  found = false
+			  matchtoremove.each do |item|
+			    if(match[0]==item)
+				  found = true
+				  break
+				end
+			  end
+			  if(!found)
+			   newmatches << match
+			  end
+			end
+			@matches = newmatches
+			
+			end
              
     end
 
+
 end

data/tests/amb.map

@@ -0,0 +1,2 @@
+u=a,c
+v=c,g

data/tests/test-suite.rb

@@ -17,6 +17,14 @@ class TestCrawler < Test::Unit::TestCase
     assert_equal(2,match[2].length-1)
   end
 
+  def test_ambiguous 
+    crawler = Cassiopee::Crawler.new
+    crawler.loadAmbiguityFile(File.join(File.dirname(__FILE__), 'amb.map'))
+    crawler.indexString('aaaaaaaaaaacgttttttt')
+    matches = crawler.searchExact('aucgt')
+    assert_equal(1,matches.length)
+  end
+
 
   def test_hammingsearch
     crawler = Cassiopee::Crawler.new

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cassiopee
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Olivier Sallou
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-04 00:00:00 +02:00
+date: 2011-09-09 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,7 @@ files:
 - lib/cassiopee.rb
 - bin/cassie.rb
 - tests/test-suite.rb
+- tests/amb.map
 has_rdoc: true
 homepage: https://github.com/osallou/cassiopee
 licenses: