mspire 0.4.9 → 0.5.0

data/lib/sample_enzyme.rb

@@ -1,160 +0,0 @@
-
-module SpecIDXML; end
-
-require 'strscan'
-
-require 'spec_id_xml'
-require 'spec_id'
-
-
-class SampleEnzyme
-  include SpecIDXML
-
-  attr_accessor :name
-  # amino acids after which to cleave
-  attr_accessor :cut
-  # cleave at 'cut' amino acids UNLESS it is followed by 'no_cut'
-  attr_accessor :no_cut
-  # 'C' or 'N'
-  attr_accessor :sense
-
-  # Currently, recognize: 
-  #   trypsin
-  # For other enzymes, you must set :cut, :no_cut, :name, and :sense
-  # will yield the object if you want to set the values that way
-  def initialize(name=nil)
-    @num_missed_cleavages_regex = nil
-    @sense = nil
-    @cut = nil
-    @no_cut = nil
-    @name = name
-    if @name
-      # set the values if we recognize this name
-      send("set_#{@name}".to_sym)
-    end
-    if block_given?
-      yield(self)
-    end
-  end
-
-  def set_trypsin
-    @sense = 'C'
-    @cut = 'KR'
-    @no_cut = 'P'
-  end
-
-  def to_pepxml
-    element_xml(:sample_enzyme, [:name]) do
-      short_element_xml(:specificity, [:cut, :no_cut, :sense])
-    end
-  end
-
-  # returns self
-  def from_pepxml_node(node)
-    self.name = node['name']
-    ch = node.child
-    self.cut = ch['cut']
-    self.no_cut= ch['no_cut']
-    self.sense = ch['sense']
-    self
-  end
-
-  def self.from_pepxml_node(node)
-    self.new.from_pepxml_node(node)
-  end
-
-  # takes an amino acid sequence (e.g., -.PEPTIDK.L)
-  # returns the number of missed cleavages
-  def num_missed_cleavages(aaseq)
-    raise NotImplementedError, 'need to implement for N terminal sense'  if sense == 'N'
-    @num_missed_cleavages_regex = 
-      if @num_missed_cleavages_regex ; @num_missed_cleavages_regex
-      else
-        regex_string = "[#{@cut}]"
-        if @no_cut and @no_cut != ''
-          regex_string << "[^#{@no_cut}]"
-        end
-        /#{regex_string}/
-      end
-    arr = aaseq.scan(@num_missed_cleavages_regex)
-    num = arr.size
-    if aaseq[-1,1] =~ @num_missed_cleavages_regex
-      num -= 1
-    end
-    num
-  end
-
-  # requires full sequence (with heads and tails)
-  def num_tol_term(sequence)
-    raise NotImplementedError, 'need to implement for N terminal sense'  if sense == 'N'
-    no_cut = @no_cut || ''
-    num_tol = 0
-    first, middle, last = SpecID::Pep.split_sequence(sequence)
-    last_of_middle = middle[-1,1]
-    first_of_middle = middle[0,1]
-    if ( @cut.include?(first) && !no_cut.include?(first_of_middle) ) || first == '-'
-      num_tol += 1
-    end
-    if @cut.include?(last_of_middle) && !no_cut.include?(last) || last == '-'
-      num_tol += 1
-    end
-    num_tol
-  end
-
-  # returns all peptides of missed cleavages <= 'missed_cleavages'
-  # so 2 missed cleavages will return all no missed cleavage peptides
-  # all 1 missed cleavages and all 2 missed cleavages.
-  # options:
-  def digest(string, missed_cleavages=0, options={})
-    raise NotImplementedError if @sense == 'N'
-    s = StringScanner.new(string)
-    no_cut_regex = Regexp.new("[#{@no_cut}]")
-    regex = Regexp.new("[#{@cut}]")
-    peps = []
-    last_pos = 0
-    current_pep = ''
-    loop do
-      if s.eos?
-        break
-      end
-      m = s.scan_until(regex)
-      if m  ## found a cut point
-        last_pos = s.pos
-        # is the next amino acid a no_cut?
-        if string[s.pos,1] =~ no_cut_regex 
-          current_pep << m
-        else
-          # cut it 
-          current_pep << m
-          peps << current_pep
-          current_pep = ''
-        end
-      else  ## didn't find a cut point
-        current_pep << string[last_pos..-1]
-        peps << current_pep 
-        break
-      end
-    end
-    ## LOOP through and grab each set of missed cleavages from num down to 0
-    all_sets_of_peps = []
-    (0..missed_cleavages).to_a.reverse.each do |num_mc|
-      all_sets_of_peps.push( *(get_missed_cleavages(peps, num_mc)) )
-    end
-    all_sets_of_peps 
-  end
-
-  # takes an array of peptides and returns an array containing 'num' missed
-  # cleavages
-  # DOES NOT contain peptides that contain < num of missed cleavages
-  # (i.e., will not return missed cleaveages of 1 or 2 if num == 3
-  def get_missed_cleavages(ar_of_peptide_seqs, num)
-    (0...(ar_of_peptide_seqs.size - num)).to_a.map do |i|
-      ar_of_peptide_seqs[i,num+1].join
-    end
-  end
-
-  def self.tryptic(string, missed_cleavages=0)
-    self.new("trypsin").digest(string, missed_cleavages)
-  end
-
-end

data/lib/scan_i.rb

@@ -1,21 +0,0 @@
-
-# http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/7370f94e852c0fae/4068c8c1c1c158ee
-class String
-  def scan_i seq
-    pos=0
-    ndx=[]
-    slen = seq.length
-    while i=index(seq,pos)
-      ndx << i
-      pos = i + slen
-    end
-    ndx
-  end
-
-  #def scan_enum seq
-  #  self.enum_for(:scan, seq).map do 
-  #    $~.offset(0)[0]
-  #  end
-  #end
-end
-

data/lib/spec_id/aa_freqs.rb

@@ -1,170 +0,0 @@
-require 'fasta'
-
-module SpecID ; end
-
-class SpecID::AAFreqs
-  # hash by capital one-letter amino acid symbols giving the frequency of
-  # seeing that amino acid.  Frequencies should add to 1.
-  attr_accessor :aafreqs
-
-  # fasta is fasta object!
-  def initialize(fasta=nil)
-    if fasta
-      @aafreqs = calculate_frequencies(fasta.prots)
-    end
-  end
-
-  # takes an enumerable of objects responding to :aaseq and creates an aafreqs hash 
-  def calculate_frequencies(objs)
-    hash = {}
-    total_aas = 0
-    ('A'..'Z').each do |x|
-      hash[x] = 0
-    end
-    hash['*'] = 0
-    objs.each do |obj|
-      aaseq = obj.aaseq
-      total_aas += aaseq.size
-      aaseq.split('').each do |x|
-        hash[x] += 1
-      end
-    end
-    # normalize by total amount:
-    hash.each do |k,v|
-      hash[k] = hash[k].to_f / total_aas
-    end
-    # convert all strings to symbols:
-    hash.each do |k,v|
-      hash[k.to_sym] = hash.delete(k)
-    end
-    hash
-  end
-
-  # The expected probability for seeing that amino acid in a given length.
-  # This calculates a lookup table (array) from 0 to highest_length of the
-  # probability of seeing at least one amino acid (given its frequency, where
-  # frequency is from 0 to 1)
-  def self.probability_of_length_table(frequency, max_length)
-    one_minus_freq = 1.0 - frequency.to_f
-    lookup = Array.new(max_length + 1)
-    (0..max_length).each do |len|
-      lookup[len] =  1.0 - (one_minus_freq**len);
-    end
-    lookup
-  end
-
-  # takes an array of peptide strings
-  # gives the actual number of peptides with at least one
-  # gives the expected number of peptides given the probabilities in the
-  # length lookup table.
-  # currently ONLY takes at_least = 1
-  # depends on @aafreqs
-  # returns two numbers in array [actual, expected]
-  # expected is a Float!!!
-  def actual_and_expected_number(peptide_aaseqs, amino_acid=:C, at_least=1)
-    if at_least > 1
-      raise NotImplementedError, "can only do at_least=1 right now!"
-    end
-    one_minus_freq = 1.0 - @aafreqs[amino_acid.to_sym]
-    amino_acid_as_st = amino_acid.to_s
-    probs = []
-    actual = 0
-    expected = 0.0
-    peptide_aaseqs.each do |pep|
-      expected += (1.0 - (one_minus_freq**pep.size))
-      if pep.include?(amino_acid_as_st)
-        actual += 1
-      end
-    end
-    [actual, expected] 
-  end
-
-  # pep_objs respond to sequence?
-  # also takes a hash of peptides keyed on :aaseq
-  def actual_and_expected_number_containing_cysteines(pep_objs, cyst_freq)
-    if pep_objs.is_a? Hash
-      seqs = pep_objs.keys
-    else
-      seqs = pep_objs.map do |v|
-        v.aaseq
-      end
-    end
-    @aafreqs ||= {}
-    @aafreqs[:C] = cyst_freq
-    actual_and_expected_number(seqs, :C, 1)
-  end
-
-  ##
-=begin
-
-  foreach my $pep (@$peps) {
-        unless ($pep->prob() >= $prob_cutoff) {next;}
-        my %freq = ();
-        my $aa = $pep->AA_sequence();
-        my $len = length($aa);
-
-        ## EXPECTED probability for each length
-        for (my $i = 0; $i < 20; $i++) {
-            ## rolling at least one 6 in n rolls is 1 - (5/6)^n.
-            $expected[$cnt][$i] = 1 - (($freqs_inv[$i])**$len);
-        }
-        ## FILTER any peptides we've already seen
-        if ($seen{$aa}) { next; } 
-        else { $seen{$aa}++; }
-
-        ## Fill in these values with zeroes:
-        for (my $a = 0; $a < 20; $a++) { $pepc[$cnt][$a] = 0; }
-
-        ## get the frequencies for each AA in each peptide:
-        for (my $i = 0; $i < $len; $i++) {
-            my $let = substr($aa, $i, 1);
-            $tot_freq{$let}++;
-            $pepc[$cnt][$an{$let}]++;
-        }
-        $cnt++;
-    }
-
-##############################################################
-# ANALYSIS 2: Fraction of Peptides containing X Amino Acid
-##############################################################
-
-## What is the percentage of peptides containing at least 1 cysteine?
-    my $atleast = 1;
-
-    my @has;
-## initialize
-    for (my $i = 0; $i < 20; $i++) { $has[$i] = 0; }
-    my $tot = scalar(@pepc);
-    foreach my $pep (@pepc) {
-        for (my $index = 0; $index < 20; $index++) {
-            if ($pep->[$index] >= $atleast) {
-                $has[$index]++;
-            }
-        }
-    }
-
-
-    my @exp_sum = ();  ## The total number of peptides I'd expect 
-## WE simply add up the peptides' probabilities
-## can think of it like this avg(peptide_prob) * #peptides = sum(pep_prob)
-    foreach my $pep (@expected) {
-        for (my $i = 0; $i < 20; $i++) {
-            $exp_sum[$i] += $pep->[$i];
-        } 
-    }
-
-    my @obs = map { $_/$tot } @has;
-    my @exp = map { $_/$tot } @exp_sum;
-    print STDERR "*********************************************\n";
-    print "Fraction of peptides (obs and expected)\nwith at least one of the AA:\n";
-    print "[AA] [Observed] [Predicted]\n";
-    for (my $i = 0; $i < 20; $i++) {
-        print "$AA[$i] $obs[$i] $exp[$i]\n";
-    }
-    print STDERR "*********************************************\n";
-
-
-
-=end
-
-end