scbi_cominer 0.0.2

data/History.txt

@@ -0,0 +1,8 @@
+=== 0.0.2 2012-07-25
+
+Added SNPs y single_points
+
+=== 0.0.1 2012-07-23
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+lib/scbi_cominer/classes/base_function.rb
+lib/scbi_cominer/classes/entropy_function.rb
+lib/scbi_cominer/classes/frequency_table.rb
+lib/scbi_cominer/classes/low_pass_filter.rb
+lib/scbi_cominer/cominer.rb
+lib/scbi_cominer.rb
+Manifest.txt
+PostInstall.txt
+Rakefile
+README.rdoc
+script/console
+script/destroy
+script/generate
+test/test_helper.rb
+test/test_scbi_cominer.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on scbi_cominer, see http://scbi_cominer.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,92 @@
+= scbi_ace
+
+* http://www.scbi.uma.es/downloads
+
+== DESCRIPTION:
+
+scbi_cominer is a ruby gem to calculate some interesting regions and statistics from contigs
+
+== FEATURES/PROBLEMS:
+
+* Find low covered regions in contigs 
+* Find putative snps in contigs
+* Calculates a frequency and position table for each nucleotide
+
+== SYNOPSIS:
+
+
+  require 'scbi_ace'
+  require 'scbi_cominer'
+  
+  filename=File.join(File.dirname(__FILE__),'test.ace')
+
+  # open ace file with parser
+  ace=AceParser.new(filename)
+
+  # iterate over all contigs in ace file
+  ace.each_contig do |contig|
+    
+    # puts contig name
+    puts contig.name
+    
+    # calculate cominer stats with this contig
+    cominer_stats=Cominer.new(contig)
+    
+    
+    # get all reads with orientation and align clips
+    contig.reads.each do |name,read|
+  	  puts ">#{read.name} #{read.orientation} #{read.align_clip_start} #{read.align_clip_end}"
+  	  puts read.fasta
+  	end
+
+    # get position_table
+    puts cominer_stats.position_table.to_json
+    
+    # get regions
+    puts cominer_stats.regions.to_json
+    
+    # get snps
+    puts cominer_stats.snps.to_json
+    
+    puts cominer_stats.single_points.to_json
+  	
+  end
+
+  ace.close
+  
+  
+== REQUIREMENTS:
+
+* Needs fftw3 library installed on your operating system.
+* Uses gems scbi_ace, narray , ruby-fftw3, gnuplot. They are installed automatically.
+
+== INSTALL: 
+
+NOTE: You may need to install fftw3 library for your operating system prior to installing scbi_cominer.
+
+* gem install scbi_cominer
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Dario Guerrero
+
+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/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/scbi_cominer'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'scbi_cominer' do
+  self.developer 'Dario Guerrero', 'dariogf@gmail.com'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  self.extra_deps         = [['scbi_ace','>= 0.0.5'],
+                             ['narray','>= 0.5.9.8'],
+                             ['ruby-fftw3', '>= 0.4'],
+                             ['gnuplot', '>= 2.3.4']
+                            ]
+  
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/lib/scbi_cominer/classes/base_function.rb

@@ -0,0 +1,521 @@
+require 'json'
+require 'narray'
+
+require "numru/fftw3"
+include NumRu
+require "gnuplot"
+
+require 'low_pass_filter'
+
+
+class BaseFunction
+
+  attr_accessor :regions,:single_points, :freq_table, :values, :fft, :snps
+
+  def initialize(freq_table)
+    @freq_table = freq_table
+
+    @values = []
+    @fft = nil
+    @lim1 = 0
+    @lim2 = 0
+
+    calculate
+
+    #puts @freq_table.inspect_pos(86,100)
+    #puts @fft.original_data[86].to_json
+    over_lim2 = lambda {|v| v > @lim2}
+    below_lim1 = lambda {|v| v < @lim1}
+
+    #puts @lim1,@lim2
+
+    single_points = filter_regions(@fft.original_data, over_lim2, true)
+    #puts single_points.to_json
+    #		@regions=filter_regions(@fft.filtered_data, over_lim2, false , @values)
+    #		@regions=filter_regions(@values, over_lim2, false , @values)
+
+    @regions=group_regions(single_points)
+    #@regions_below=filter_regions(@fft.filtered_data, below_lim1, false, @values)
+
+    @single_points = purge_regions(single_points,@regions)
+
+    # repeat snps that are already in a region
+    @snps = purge_snps(single_points)
+
+    # do not repeat snps that are in a region
+    #				@snps = purge_snps(@single_points)
+    #puts @snps.to_json
+    #puts @regions.to_json
+    #puts @single_points.to_json
+    #		puts @single_points.join(',')
+    #graph
+
+    #	puts @values.to_json
+  end
+
+  def calculate
+    values = []
+    length = @freq_table.max_length
+
+    # evaluate freq table
+    length.times do |i|
+
+      val = evaluate_pos(i)
+
+      values.push val
+
+    end
+
+    @values = values
+
+    @fft = LowPassFilter.new(@values)
+
+    @lim1,@lim2 = @fft.limits
+
+  end
+
+  def evaluate_pos(i)
+    raise "You must create a child class to override this method"
+  end
+
+  def purge_regions(regions1, regions2)
+    res = []
+
+    #puts "to purge: #{regions1.length}"
+
+    regions1.each do |r1|
+      if !((regions2.find{	|r2|
+              ((r1['start']<=r2['end']) and (r2['start']<=r1['end']))
+        }))
+
+        res.push(r1)
+      end
+
+    end
+
+    #puts "purged: #{res.length}"
+
+    return res
+
+  end
+
+  def purge_snps(regions)
+    res = []
+
+    #puts "to purge: #{regions1.length}"
+
+    regions.each do |r1|
+      # is a one point region
+      if r1['start']==r1['end']
+        pos =r1['start']
+
+        if @freq_table.valid_snp(pos)
+          res.push(r1)
+        end
+      end
+
+    end
+
+    #puts "purged SNPS: #{res.length} from #{regions.length}\n #{res.to_yaml}"
+
+    return res
+
+  end
+
+
+  def valid_region(region, comp, only_single_points, mandatory_data)
+
+    region_start = region['start']
+    region_end = region['end']
+
+    res = false
+
+
+    if only_single_points
+      # only get SNPs
+      #print "check: #{region_start} - #{region_end}"
+      res = ((region_end - region_start) >= 0)
+
+    else
+
+      if mandatory_data.nil?
+        # if no mandatory data, add all regions
+        res = ((region_end - region_start) >=0)
+
+      else # there is mandatory data
+
+        # region must have al least one base
+        res = ((region_end - region_start) >0)
+
+        # negar la siguiente linea para no tener en cuenta regiones anchas sin snps dentro
+        if res
+          # check for inner regions in this range of the mandatory_data
+          data = mandatory_data[region_start,region_end-region_start+1]
+          regions = filter_regions(data,comp,nil)
+
+          # if there is more than one region, then is valid
+          if regions.empty? or regions.count<=1
+            res = false
+          end
+        end
+
+      end
+    end
+
+    return res
+  end
+
+  def group_regions(data)
+
+    max_separation = 15
+    last_end = 0
+
+    group_start = 0
+    group_end = 0
+    group_score = 0
+    group_size = 0
+
+
+    regions = []
+
+    if !data.empty?
+      region = {}
+      region['start'] = data[0]['start']
+      region['end'] = data[0]['end']
+      region['score'] = data[0]['score']
+
+      # filter regions
+      data.each do |r|
+
+        if r['start'] < last_end+max_separation
+          # group
+          group_score += r['score']
+          group_end = r['end']
+          group_size += 1
+        else
+          #close previous group, start new one
+          region = {}
+          region['start'] = group_start
+          region['end'] = group_end
+          region['score'] = group_score.to_f/group_size.to_f
+
+          #save region
+          if region['start']<region['end']
+            regions.push region
+          end
+
+          # init new one
+          group_start = r['start']
+          group_end = r['end']
+          group_score = r['score']
+          group_size = 1
+
+        end
+
+        last_end = r['end']
+
+      end
+    end
+
+    return regions
+
+  end
+
+  def filter_regions(data, comp, only_single_points = false, mandatory_data = nil)
+    # ===========
+    pos = 0
+
+    regions = []
+
+    region = {}
+    region['start'] = 0
+    region['end'] = 0
+    region['score'] = 0
+
+    anotate = false
+
+    # filter regions
+    data.each do |v|
+
+      if not anotate
+
+        if comp.call(v)
+          # is out
+          anotate = true
+          region['start'] = pos
+          region['end'] = 0
+          region['score'] = v
+          #else
+          # is inside limits
+        end
+
+      else # we are anotating a region, outside limits
+
+        if comp.call(v)
+          # is ok
+          region['score'] += v
+        else
+          # finish region
+          anotate = false
+
+          # actually it finished at previos pos
+          region['end'] = pos - 1
+
+          if (valid_region(region, comp, only_single_points, mandatory_data))
+            add_region(regions,region)
+          end
+
+          region = {}
+
+        end
+
+      end
+
+      pos = pos + 1
+
+    end
+
+    # anotate last region if any
+    if anotate
+      # finish region
+      anotate = false
+
+      # actually it finished at previos pos
+      region['end'] = pos
+
+      if valid_region(region,comp,only_single_points,mandatory_data)
+        add_region(regions,region)
+      end
+
+      region = {}
+    end
+
+    return regions
+  end
+
+  def add_region(regions,r)
+    w=(r['end']-r['start'])+1
+
+    if w>0 then
+      r['score'] = r['score'].to_f/w.to_f
+      regions.push r
+    end
+
+  end
+
+  def graph(file_name=nil)
+
+    Gnuplot.open do |gp|
+      Gnuplot::Plot.new( gp ) do |plot|
+
+        if !file_name.nil?
+          plot.terminal "png size #{@fft.filtered_data.length},600"
+          plot.output "#{file_name}"
+        end
+
+        plot.set "multiplot layout 2,1 upwards"
+
+        plot.xrange("[0:#{@fft.original_data.length-1}]")
+        #plot.yrange("[#{@fft.original_data.min}:#{@fft.original_data.max}]")
+        #		  plot.ytics("#{@fft.original_data.min},10,#{@fft.original_data.max}]")
+
+        #plot.ylabel "f"
+        #plot.xlabel "x"
+
+        #plot.set "bmargin #{dx+1}"
+        plot.set "tmargin 0.0"
+        #plot.set "lmargin #{dy}"
+
+        # graph fft data
+
+        plot.title ""
+        plot.ylabel "Region"
+        plot.xlabel "Nucleotide"
+
+        # =====================
+
+        if !@regions.empty?
+          x, y = regions_to_graph_data(@regions, @fft.original_data.length-1)
+
+          plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+            ds.with = "lines  lt rgb \"red\" ti \"Regions #{x.length}\""
+            #ds.notitle
+          end
+        end
+        # =====================
+
+        if !@single_points.empty?
+          x, y = regions_to_graph_data(@single_points, @fft.original_data.length-1)
+
+          plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+            ds.with = "lines  lt rgb \"blue\" ti \"Points #{x.length}\""
+            #ds.notitle
+          end
+        end
+        # =====================
+
+
+      end
+
+      Gnuplot::Plot.new( gp ) do |plot|
+        plot.title  "Filter Base: #{fft.filter_base} , skip: #{fft.skip}"
+
+        plot.set "bmargin 0.0"
+        plot.set "tmargin 2"
+
+        #plot.set "xtics"
+        plot.xrange("[0:#{@fft.original_data.length-1}]")
+
+        #plot.set "origin #{DX},#{DY+SY};"
+        plot.ylabel "f"
+        plot.xlabel ''
+        plot.noxtics
+
+        x = (0..@fft.original_data.length-1).collect
+        y = @fft.original_data.to_a
+
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "lines  lt rgb \"green\" ti \"Original data\""
+          #ds.notitle
+        end
+
+        x = (0..@fft.filtered_data.length-1).collect
+        y = @fft.filtered_data.to_a
+
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "lines lt rgb \"blue\" ti \"Filtered data\""
+          #ds.notitle
+        end
+
+
+
+        x=[0]
+        y=[@lim1]
+
+        x.push(@fft.filtered_data.length-1)
+        y.push(@lim1)
+
+
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "lines lt rgb \"red\" ti \"Lim1 [#{@lim1}]\""
+          #ds.notitle
+        end
+
+        x=[0]
+        y=[@lim2]
+
+        x.push(@fft.filtered_data.length-1)
+        y.push(@lim2)
+
+        #puts @lim1, @lim2
+
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "lines lt rgb \"red\" ti \"Lim2 [ #{@lim2}]\""
+          #ds.notitle
+        end
+
+      end
+
+    end
+
+
+  end
+
+
+  def regions_to_graph_data(regions,total_length)
+
+    x = []
+    y = []
+    #		  x = [0]
+    #		  y = [0]
+
+    regions.each do |r|
+
+      x.push r['start']-1
+      y.push 0
+
+      x.push r['start']
+      y.push r['score']
+
+
+
+      x.push r['end']
+      y.push r['score']
+
+      x.push r['end']+1
+      y.push 0
+
+    end
+
+    #		x.push total_length
+    #		y.push 0
+
+    if x.empty?
+      x.push 0
+    end
+
+    if y.empty?
+      y.push 0
+    end
+
+
+
+    return [x,y]
+
+  end
+
+  def graph2(file_name = nil)
+
+    Gnuplot.open do |gp|
+      Gnuplot::Plot.new( gp ) do |plot|
+
+        if !file_name.nil?
+          plot.terminal "png size #{@fft.filtered_data.length},600"
+          plot.output "#{file_name}"
+        end
+
+        plot.title  "Filter Base: #{@fft.filter_base} , skip: #{@fft.skip}"
+        plot.ylabel "f"
+        plot.xlabel "x"
+
+        x = (0..@fft.original_data.length-1).collect
+
+        y = @fft.original_data.to_a
+
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "lines  lt rgb \"green\""
+          ds.notitle
+        end
+
+        x = (0..@fft.filtered_data.length-1).collect
+        y = @fft.filtered_data.to_a
+
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "lines lt rgb \"blue\""
+          ds.notitle
+        end
+
+        x = (0..@fft.filtered_data.length-1).collect
+        y = [@lim1]
+        @fft.filtered_data.length.times  { y.push(@lim1) }
+
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "lines lt rgb \"red\""
+          ds.notitle
+        end
+
+        x = (0..@fft.filtered_data.length-1).collect
+        y = [@lim2]
+        @fft.filtered_data.length.times  { y.push(@lim2) }
+
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "lines lt rgb \"red\""
+          ds.notitle
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/scbi_cominer/classes/entropy_function.rb

@@ -0,0 +1,33 @@
+require 'base_function'
+
+class EntropyFunction < BaseFunction
+
+  def log2(v)
+    return (Math.log10(v)/Math.log10(2))
+  end
+
+  def evaluate_pos(i)
+    res = 0
+
+    nseq = @freq_table.nseq(i) || 0
+
+    if nseq>0 
+      @freq_table.frequency_table.keys.each do |k|
+
+        if k!='-'
+          freq = @freq_table.frequency_table[k][i] || 0 
+
+          co = freq.to_f/nseq.to_f
+          if (co > 0)
+            res += ((-1*co*log2(co)));
+          end
+        end
+      end
+
+    end
+
+    return res
+
+  end
+
+end

data/lib/scbi_cominer/classes/frequency_table.rb

@@ -0,0 +1,258 @@
+class FrequencyTable
+
+  attr_accessor :frequency_table,:position_table, :sequences
+
+  def initialize
+    @frequency_table = {}
+    @position_table = {}
+    @sequences =[]
+  end
+
+  def max_length_key
+    m = 0
+    mk = nil
+
+    @frequency_table.each { |k,v|
+
+      if v.length>m
+        m = v.length
+        mk = k
+      end
+
+    }
+
+    return mk
+  end
+
+  # cuenta las secuencias efectivas de la posicion pos
+  def nseq(pos)
+    m = 0
+
+    @frequency_table.each { |k,v|
+
+      if (!v[pos].nil?) && (k!='-')
+        #puts v[pos].to_s + k if pos==0
+        m += v[pos]
+      end
+
+    }
+
+    return m
+    #return @sequences.count
+  end
+
+  # cuenta las secuencias efectivas de la posicion pos
+  def nseq_valid(pos)
+    m = 0
+
+    @frequency_table.each { |k,v|
+
+      if (!v[pos].nil?) && (k!='-') && (k!='*')
+        #puts v[pos].to_s + k if pos==0
+        m += v[pos]
+      end
+
+    }
+
+    return m
+    #return @sequences.count
+  end
+
+  # cuenta las secuencias efectivas de la posicion pos
+  def consensus_freq(pos)
+    ke=nil
+    m = 0
+
+    @frequency_table.each { |k,v|
+
+      if (!v[pos].nil?) && (k!='-') && (k!='*')
+        if v[pos] >= m
+          m = v[pos]
+          ke=k
+        end
+
+      end
+
+    }
+
+    return [ke,m]
+    #return @sequences.count
+  end
+
+
+  def max_length
+    m = 0
+    mk = nil
+
+    @frequency_table.each { |k,v|
+
+      if v.length>m
+        m = v.length
+        mk = k
+      end
+
+    }
+
+    return m
+  end
+
+  def add_read(read)
+    add_fasta(read.name, read.fasta)
+  end
+
+  def add_sequence(seq)
+    add_fasta(seq.seq_name,seq.seq_fasta)
+  end
+
+  def add_fasta(name,fasta)
+
+    @sequences.push({:name=>name,:fasta=>fasta})
+    index = @sequences.length
+
+    i = 0
+    fasta.each_char do |c|
+
+      #get current freq
+      freq = @frequency_table[c]
+      if freq.nil?
+        @frequency_table[c] = []
+        freq = @frequency_table[c]
+      end
+
+      #increment current freq
+      if freq[i].nil?
+        freq[i] = 1
+      else
+        freq[i]+=1
+      end
+
+      #get current pos
+      pos = @position_table[c]
+      if pos.nil?
+        @position_table[c] = []
+        pos = @position_table[c]
+      end
+
+      #increment current freq
+      if pos[i].nil?
+        pos[i] = [index]
+      else
+        pos[i].push index
+      end
+
+      #increment pos
+      i +=1
+    end
+
+    #	puts "  "+fasta[0..30]
+  end
+
+  def extract_col(pos)
+
+    h={}
+
+    @frequency_table.each do |k,v|
+
+      if (!v[pos].nil?) && (k!='-') && (k!='*')
+        if v[pos]>0
+          h[k]=v[pos]
+        end
+      end
+
+    end
+
+    return h
+
+  end
+
+  def valid_snp(pos)
+    res = false
+
+    # a valid SNP is a change in at least two valid sequences.
+
+    total_seqs = nseq_valid(pos)
+    consensus_base, consensus_frequency = consensus_freq(pos)
+    #	puts h.to_json
+    # change a pos
+
+    #if pos = 128
+    #			@frequency_table['A'][pos]=1
+    #			@frequency_table['C'][pos]=2
+    #			@frequency_table['T'][pos]=0
+    #			@frequency_table['G'][pos]=4
+    #	end
+    #
+    if consensus_frequency <= total_seqs - 2
+
+      h = extract_col(pos)
+
+
+
+      h.each do |k,v|
+        if (k!=consensus_base) && (v>=2)
+          res = true
+          #					puts "#{k} is #{v}>=2"
+          break
+        end
+      end
+
+
+    end
+
+    #	puts inspect_pos(pos,pos)
+    #	puts "POS: #{pos}"
+    #	puts res.to_s
+    #  puts "base #{consensus_base}, freq #{consensus_frequency}, tot: #{total_seqs}"
+    #	puts '-' * 20
+
+    #puts "nseq[#{pos}] =  #{total_seqs} => #{consensus_base}: #{consensus_frequency}"
+
+    #	@frequency_table.each { |k,v|
+    #
+    #  		puts "#{k}:#{v[pos] ||= '0'}"
+    #
+    #
+    #	}
+    #
+    #	puts res.to_s
+
+    return res
+  end
+
+  def inspect
+
+    res = ''
+
+    @frequency_table.each do |c,v|
+
+      res += c+':'+(v[0..30].map{|c1|  c1 ||= 0 }).join("")+"...more.\n"
+
+    end
+
+    @position_table.each do |c,v|
+
+      #			res += c+':'+(v[0..10].map{|c1|  (c1 && ('['+c1.map{|c2| @sequences[c2-1].seq_name}.join(","))+']') || "[]" }).join(" - ")+"...more.\n"
+      res += c+':'+(v[0..10].map{|c1|  (c1 && ('['+c1.map{|c2| @sequences[c2-1][:name]}.join(","))+']') || "[]" }).join(" - ")+"...more.\n"
+
+    end
+
+    return res
+
+  end
+
+  def inspect_pos(pos_start,pos_end)
+
+
+    res = ''
+
+    @frequency_table.each do |c,v|
+
+      res += c+':'+(v[pos_start..pos_end].map{|c1|  c1 ||= 0 }).join("")+"...more.\n"
+
+    end
+
+    return res
+  end
+
+
+end

data/lib/scbi_cominer/classes/low_pass_filter.rb

@@ -0,0 +1,84 @@
+require "narray"
+require "numru/fftw3"
+include NumRu
+require "gnuplot"
+
+class NArray
+
+  def mad_mean
+    me = self.mean
+    mad = ((self - me ).abs).mean
+
+    return [mad,me]
+
+  end
+
+  def mad_median
+    me = self.median
+    mad = ((self - me).abs).median
+
+    return [mad,me]
+  end
+
+end
+
+class LowPassFilter
+
+  attr_accessor :original_data, :filtered_data, :skip, :filter_base
+
+  def initialize(data)
+    @original_data = NArray.to_na(data)
+    @filtered_data = nil
+    @skip = nil
+    @filter_base = 8
+
+    run
+  end
+
+  def run
+    coef = FFTW3.fft(@original_data, -1,0)/@original_data.length
+
+    if @skip.nil?
+      @skip = (coef.length/4)
+    end
+
+    inc = (2.0 / (coef.length - @skip));
+
+    x = 1;
+
+    # keep intact first components of coefs
+    i=@skip
+    while i<coef.length
+      # el filtro reduce los componentes de alta frecuencia
+      f = x ** @filter_base
+
+      coef[i]=coef[i]*f
+
+      x = x - inc;
+      i +=1# era 2 porque en perl no usa num complejos
+    end
+
+    filtered = FFTW3.fft(coef, 1,0)
+
+    @filtered_data=filtered.real
+
+    @filtered_data[0] = @original_data[0]
+    @filtered_data[@filtered_data.length-1] = @original_data[@original_data.length-1]
+
+  end
+
+  def limits
+
+    mad,median =  @filtered_data.mad_median
+
+    if mad == 0
+      mad,mean =  @filtered_data.mad_mean
+    end
+
+    desv = 1.4826 * mad
+
+    return [median - desv, median + desv].sort
+
+  end
+
+end

data/lib/scbi_cominer/cominer.rb

@@ -0,0 +1,36 @@
+
+require 'frequency_table.rb'
+require 'entropy_function'
+
+
+class Cominer
+  
+  attr_accessor :regions,:snps,:position_table, :freq_table, :single_points
+  
+  def initialize(contig)
+    
+    @freq_table = FrequencyTable.new
+  
+  	contig.reads.each do |name,read|
+      # puts ">#{read.name} #{read.orientation} #{read.align_clip_start} #{read.align_clip_end}"
+      # puts read.fasta
+  		@freq_table.add_read(read)
+  	end
+  	
+    # puts freq_table.inspect
+  	
+  	ef = EntropyFunction.new(@freq_table)
+   
+    @regions=ef.regions
+    @snps=ef.snps
+    @single_points=ef.single_points
+    
+    @freq_table.position_table.delete('-')
+    
+		@position_table = @freq_table.position_table
+    
+  end
+  
+  
+  
+end

data/lib/scbi_cominer.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+$: << File.join(File.dirname(__FILE__),File.basename(__FILE__,File.extname(__FILE__)))
+$: << File.join(File.dirname(__FILE__),File.basename(__FILE__,File.extname(__FILE__)),'classes')
+
+# puts $:
+require 'cominer.rb'
+
+module ScbiCominer
+   VERSION = '0.0.2'
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/scbi_cominer.rb'}"
+puts "Loading scbi_cominer gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/scbi_cominer'

data/test/test_scbi_cominer.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+require 'scbi_ace'
+
+class TestScbiCominer < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_truth
+    filename=File.join(File.dirname(__FILE__),'test.ace')
+
+    # open ace file with parser
+    ace=AceParser.new(filename)
+
+    # iterate over all contigs in ace file
+    ace.each_contig do |contig|
+      
+      # puts contig name
+      puts contig.name
+      
+      # calculate cominer stats with this contig
+      cominer_stats=Cominer.new(contig)
+      
+      
+      # get all reads with orientation and align clips
+      contig.reads.each do |name,read|
+    	  puts ">#{read.name} #{read.orientation} #{read.align_clip_start} #{read.align_clip_end}"
+    	  puts read.fasta
+    	end
+
+      # get position_table
+      puts cominer_stats.position_table.to_json
+      
+      # get regions
+      puts cominer_stats.regions.to_json
+      
+      # get snps
+      puts cominer_stats.snps.to_json
+      
+      puts cominer_stats.single_points.to_json
+    	
+    end
+
+    ace.close
+    
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: scbi_cominer
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Dario Guerrero
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-25 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: scbi_ace
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: narray
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.9.8
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-fftw3
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: gnuplot
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.4
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.8.0
+  type: :development
+  version_requirements: *id005
+description: scbi_cominer is a ruby gem to calculate some interesting regions and statistics from contigs
+email: 
+- dariogf@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+files: 
+- History.txt
+- lib/scbi_cominer/classes/base_function.rb
+- lib/scbi_cominer/classes/entropy_function.rb
+- lib/scbi_cominer/classes/frequency_table.rb
+- lib/scbi_cominer/classes/low_pass_filter.rb
+- lib/scbi_cominer/cominer.rb
+- lib/scbi_cominer.rb
+- Manifest.txt
+- PostInstall.txt
+- Rakefile
+- README.rdoc
+- script/console
+- script/destroy
+- script/generate
+- test/test_helper.rb
+- test/test_scbi_cominer.rb
+homepage: http://www.scbi.uma.es/downloads
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: scbi_cominer
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: scbi_cominer is a ruby gem to calculate some interesting regions and statistics from contigs
+test_files: 
+- test/test_helper.rb
+- test/test_scbi_cominer.rb