mspire 0.4.9 → 0.5.0

data/specs/validator/bias_spec.rb

@@ -1,122 +0,0 @@
-require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
-require File.expand_path( File.dirname(__FILE__) + '/../validator_helper' )
-
-require 'validator/bias'
-
-require File.dirname(__FILE__) + '/fasta_helper'
-require 'spec_id'
-
-klass = Validator::Bias
-
-describe klass, "on small mock set" do
-  before(:each) do
-    @peps =  (0..6).to_a.map {|n| v = SpecID::GenericPep.new; v.aaseq = n.to_s ; v }
-    references = %w(YAL002W  YAL001C YAL003W YAL004W YAL007C NOT_EXISTING1 NOT_EXISTING2 NOT_EXISTING3 NOT_EXISTING4)
-    # index:        0        1       2       3       4       5             6             7
-    # index: 8       
-    @prots = references.map do |ref|
-      v = SpecID::GenericProt.new
-      v.reference = ref + " something else that we don't care about"
-      v
-    end
-
-    # e=t  we expect to see the fasta proteins in our hit list
-    # cw=t a single peptide hit from one of these proteins constitutes a true
-    # positive
-    # cw=f all peptide hits must come from one of these proteins to be a true
-    # positive
-    #
-    # e=f  we do not expect to see the fasta obj proteins in our hit list
-    # cw=t a single peptide hit from *outside* this list constitues a true
-    # positive
-    # cw=f a single peptide hit from our fasta object constitutes a false
-    # positive
-    #
-
-    @peps[0].prots = [@prots[0], @prots[5], @prots[8]]  
-    @peps[1].prots = [@prots[1], @prots[5], @prots[8]]  
-    @peps[2].prots = [@prots[3], @prots[4], @prots[1]]  
-    @peps[3].prots = [@prots[7], @prots[8]]             
-    @peps[4].prots = [@prots[5], @prots[8]]             
-    @peps[5].prots = [@prots[8]]                        
-    @peps[6].prots = [@prots[5], @prots[6]]             
-
-    #################################################
-    # REFERENCE for small mock set:
-    #################################################
-    # pep 1inFst? allinFst? cw=t,e=t cw=t,e=f cw=f,e=f cw=f,e=t
-    # 0   y       n         t        t        f        f
-    # 1   y       n         t        t        f        f
-    # 2   y       y         t        f        f        t
-    # 3   n       n         f        t        t        f
-    # 4   n       n         f        t        t        f
-    # 5   n       n         f        t        t        f
-    # 6   n       n         f        t        t        f
-    # PR:                   3/7      6/7      4/7      1/7
-    # tp:fp                 3:4      6:1      4:3      1:6
-
-    @fasta_obj = FastaHelper::FastaObj
-    @validator = klass.new(@fasta_obj)
-    @validator.false_to_total_ratio = 0.22  # arbitrary
-  end
-
-  it_should_behave_like 'a validator'
-
-  it 'creates correct reference hash' do
-    expected = {"YAL001C"=>true, "YAL011W"=>true, "YAL010C"=>true,
-    "YAL009W"=>true, "YAL008W"=>true, "YAL007C"=>true, "YAL005C"=>true,
-    "YAL004W"=>true, "YAL003W"=>true, "YAL014C"=>true, "YAL013W"=>true,
-    "YAL002W"=>true, "YAL012W"=>true
-    }
-    val = klass.new(@fasta_obj)
-    val.short_reference_hash.should == expected
-  end
-
-  it 'gives correct precision and partitions (across all option combinations)' do
-    answ = [[3,4], [6,1], [1,6], [4,3]]
-    # cw=t,e=t; cw=t,e=f; cw=f,e=t; cw=f,e=f
-    [true, false].each do |correct_wins|
-      [true, false].each do |fasta_expected|
-        val = klass.new(@fasta_obj, :proteins_expected => fasta_expected, :correct_wins => correct_wins, :false_to_total_ratio => 1.0)
-        tp, fp = answ.shift
-        exp = calc_precision(tp, fp)
-        val.pephit_precision(@peps).should == exp
-        act_tp, act_fp = val.partition(@peps)
-        act_tp.size.should == tp
-        act_fp.size.should == fp
-      end
-    end
-  end
-
-  it 'correctly incorporates background' do
-    answ = [[3,4], [6,1], [1,6], [4,3]]
-    # cw=t,e=t; cw=t,e=f; cw=f,e=t; cw=f,e=f
-    background = 0.24
-    [true, false].each do |correct_wins|
-      [true, false].each do |fasta_expected|
-        val = klass.new(@fasta_obj, :proteins_expected => fasta_expected, :correct_wins => correct_wins, :background => background, :false_to_total_ratio => 1.0)
-        peps_size = @peps.size
-        exp_tp, exp_fp = answ.shift
-        exp = calc_precision(exp_tp, exp_fp)
-        val.pephit_precision(@peps).should_not == exp
-        actual_precision = val.pephit_precision(@peps)
-        act_tp, act_fp = val.partition(@peps)
-        act_tp.size.should == exp_tp
-        act_fp.size.should == exp_fp
-        exp_fp_correctd = exp_fp.to_f - (peps_size.to_f * background)
-        expected_precision = calc_precision(peps_size.to_f - exp_fp_correctd, exp_fp_correctd)
-        # internally, the num of false hits is controlled so as not to bottom
-        # out below zero, here we control the precision (same effect)
-        expected_precision = 1.0 if expected_precision > 1.0
-        actual_precision.should == expected_precision
-      end
-    end
-  end
-
-  it_should 'work with false_to_total_ratio!'
-
-  def calc_precision(tp, fp)
-    prec = tp.to_f / (tp + fp)
-  end
-end
-

data/specs/validator/decoy_spec.rb

@@ -1,51 +0,0 @@
-
-require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
-require File.expand_path( File.dirname(__FILE__) + '/../validator_helper' )
-
-require 'validator/decoy'
-require 'spec_id'
-
-klass = Validator::Decoy
-
-describe klass, 'reporting precision on peptides from cat prots' do
-
-  before(:each) do
-    peps =  (0..5).to_a.map {|n| v = SpecID::GenericPep.new; v.aaseq = n.to_s ; v }
-    prots = %w(gi|1245235|ProteinX gi|987654|ProteinY gi|1111111|ProteinZ FALSE_someOthergi FALSE_AnotherGi FALSE_YetAnotherReference).map do |ref|
-      v = SpecID::GenericProt.new
-      v.reference = ref
-      v
-    end
-    peps[0].prots = [prots[0], prots[5]]  # TP (only in tp wins)
-    peps[1].prots = [prots[1], prots[2]]  # TP always
-    peps[2].prots = [prots[3], prots[4]]  # FP 
-    peps[3].prots = [prots[2]]            # TP
-    peps[4].prots = [prots[5]]            # FP
-    peps[5].prots = [prots[4]]            # FP
-    @peps = peps
-    @validator = klass.new(:constraint => /FAKE/)
-  end
-
-  it_should_behave_like 'a validator'
-
-  it 'gives correct precision (across all option combinations)' do 
-    answ_arr = [
-      [[@peps[0], @peps[1], @peps[3]], [@peps[2], @peps[4], @peps[5]]],
-      [[@peps[1], @peps[3]], [@peps[0], @peps[2], @peps[4], @peps[5]]],
-      [[@peps[0], @peps[1], @peps[3]], [@peps[2], @peps[4], @peps[5]]],
-      [[@peps[1], @peps[3]], [@peps[0], @peps[2], @peps[4], @peps[5]]]
-    ]
-    protein_matches = [/^FALSE_/, /^FALSE_/, 'Protein', 'Protein']
-
-    [true, false].each do |incorrect_on_match|
-      [true, false].each do |correct_wins|
-        val = klass.new(:constraint => protein_matches.shift, :decoy_on_match => incorrect_on_match, :correct_wins => correct_wins)
-        answ = val.pephit_precision(@peps)
-        exp = ValidatorHelper::Decoy.precision_from_partition_array(answ_arr.shift)
-        answ.should == exp
-      end
-    end
-  end
-
-end
-

data/specs/validator/fasta_helper.rb

@@ -1,26 +0,0 @@
-
-
-module FastaHelper 
-  FastaObj = Fasta.new
-  data = {
-    '>YAL011W otherstuff' => 'MPAVLRTRSKESSIEQKPASRTRTRSRRGKRGRDDDDDDDDEESDDAYDEVGNDYDEYASRAKLATNRPFEIVAGLPASVELPNYNSSLTHPQSIKNSGVLYDSLVSSRRTWVQGEMFELYWRRPKKIVSESTPAATESPTSGTIPLIRDKMQKMCDCVMSGGPHTFKVRLFILKNDKIEQKWQDEQELKKKEKELKRKNDAEAKRLRMEERKRQQMQKKIAKEQKLQLQKENKAKQKLEQEALKLKRKEEMKKLKEQNKNKQGSPSSSMHDPRMIMNLNLMAQEDPKLNTLMETVAKGLANNSQLEEFKKFIEIAKKRSLEENPVNKRPSVTTTRPAPPSKAKDVAEDHRLNSITLVKSSKTAATEPEPKKADDENAEKQQSKEAKTTAESTQVDVKKEEEDVKEKGVKSEDTQKKEDNQVVPKRKRRKNAIKEDKDMQLTAFQQKYVQGAEIILEYLEFTHSRYYLPKKSVVEFLEDTDEIIISWIVIHNSKEIEKFKTKKIKAKLKADQKLNKEDAKPGSDVEKEVSFNPLFEADCPTPLYTPMTMKLSGIHKRFNQIIRNSVSPMEEVVKEMEKILQIGTRLSGYNLWYQLDGYDDEALSESLRFELNEWEHAMRSRRHKR',
-'>YAL001C otherstuff' => 'MVLTIYPDELVQIVSDKIASNKGKITLNQLWDISGKYFDLSDKKVKQFVLSCVILKKDIEVYCDGAITTKNVTDIIGDANHSYSVGITEDSLWTLLTGYTKKESTIGNSAFELLLEVAKSGEKGINTMDLAQVTGQDPRSVTGRIKKINHLLTSSQLIYKGHVVKQLKLKKFSHDGVDSNPYINIRDHLATIVEVVKRSKNGIRQIIDLKRELKFDKEKRLSKAFIAAIAWLDEKEYLKKVLVVSPKNPAIKIRCVKYVKDIPDSKGSPSFEYDSNSADEDSVSDSKAAFEDEDLVEGLDNFNATDLLQNQGLVMEEKEDAVKNEVLLNRFYPLQNQTYDIADKSGLKGISTMDVVNRITGKEFQRAFTKSSEYYLESVDKQKENTGGYRLFRIYDFEGKKKFFRLFTAQNFQKLTNAEDEISVPKGFDELGKSRTDLKTLNEDNFVALNNTVRFTTDSDGQDIFFWHGELKIPPNSKKTPNKNKRKRQVKNSTNASVAGNISNPKRIKLEQHVSTAQEPKSAEDSPSSNGGTVVKGKVVNFGGFSARSLRSLQRQRAILKVMNTIGGVAYLREQFYESVSKYMGSTTTLDKKTVRGDVDLMVESEKLGARTEPVSGRKIIFLPTVGEDAIQRYILKEKDSKKATFTDVIHDTEIYFFDQTEKNRFHRGKKSVERIRKFQNRQKNAKIKASDDAISKKSTSVNVSDGKIKRRDKKVSAGRTTVVVENTKEDKTVYHAGTKDGVQALIRAVVVTKSIKNEIMWDKITKLFPNNSLDNLKKKWTARRVRMGHSGWRAYVDKWKKMLVLAIKSEKISLRDVEELDLIKLLDIWTSFDEKEIKRPLFLYKNYEENRKKFTLVRDDTLTHSGNDLAMSSMIQREISSLKKTYTRKISASTKDLSKSQSDDYIRTVIRSILIESPSTTRNEIEALKNVGNESIDNVIMDMAKEKQIYLHGSKLECTDTLPDILENRGNYKDFGVAFQYRCKVNELLEAGNAIVINQEPSDISSWVLIDLISGELLNMDVIPMVRNVRPLTYTSRRFEIRTLTPPLIIYANSQTKLNTARKSAVKVPLGKPFSRLWVNGSGSIRPNIWKQVVTMVVNEIIFHPGITLSRLQSRCREVLSLHEISEICKWLLERQVLITTDFDGYWVNHNWYSIYEST',
-'>YAL010C otherstuff' => 'MLPYMDQVLRAFYQSTHWSTQNSYEDITATSRTLLDFRIPSAIHLQISNKSTPNTFNSLDFSTRSRINGSLSYLYSDAQQLEKFMRNSTDIPLQDATETYRQLQPNLNFSVSSANTLSSDNTTVDNDKKLLHDSKFVKKSLYYGRMYYPSSDLEAMIIKRLSPQTQFMLKGVSSFKESLNVLTCYFQRDSHRNLQEWIFSTSDLLCGYRVLHNFLTTPSKFNTSLYNNSSLSLGAEFWLGLVSLSPGCSTTLRYYTHSTNTGRPLTLTLSWQPLFGHISSTYSAKTGTNSTFCAKYDFNLYSIESNLSFGCEFWQKKHHLLETNKNNNDKLEPISDELVDINPNSRATKLLHENVPDLNSAVNDIPSTLDIPVHKQKLLNDLTYAFSSSLRKIDEERSTIEKFDNKINSSIFTSVWKLSTSLRDKTLKLLWEGKWRGFLISAGTELVFTRGFQESLSDDEKNDNAISISATDTENGNIPVFPAKFGIQFQYST',
-'>YAL009W otherstuff' => 'MEPESIGDVGNHAQDDSASIVSGPRRRSTSKTSSAKNIRNSSNISPASMIFRNLLILEDDLRRQAHEQKILKWQFTLFLASMAGVGAFTFYELYFTSDYVKGLHRVILQFTLSFISITVVLFHISGQYRRTIVIPRRFFTSTNKGIRQFNVKLVKVQSTWDEKYTDSVRFVSRTIAYCNIYCLKKFLWLKDDNAIVKFWKSVTIQSQPRIGAVDVKLVLNPRAFSAEIREGWEIYRDEFWAREGARRRKQAHELRPKSE',
-'>YAL008W otherstuff' => 'MTLAFNMQRLVFRNLNVGKRMFKNVPLWRFNVANKLGKPLTRSVGLGGAGIVAGGFYLMNRQPSKLIFNDSLGAAVKQQGPLEPTVGNSTAITEERRNKISSHKQMFLGSLFGVVLGVTVAKISILFMYVGITSMLLCEWLRYKGWIRINLKNIKSVIVLKDVDLKKLLIDGLLGTEYMGFKVFFTLSFVLASLNANK',
-'>YAL007C otherstuff' => 'MIKSTIALPSFFIVLILALVNSVAASSSYAPVAISLPAFSKECLYYDMVTEDDSLAVGYQVLTGGNFEIDFDITAPDGSVITSEKQKKYSDFLLKSFGVGKYTFCFSNNYGTALKKVEITLEKEKTLTDEHEADVNNDDIIANNAVEEIDRNLNKITKTLNYLRAREWRNMSTVNSTESRLTWLSILIIIIIAVISIAQVLLIQFLFTGRQKNYV',
-'>YAL005C otherstuff' => 'MSKAVGIDLGTTYSCVAHFANDRVDIIANDQGNRTTPSFVAFTDTERLIGDAAKNQAAMNPSNTVFDAKRLIGRNFNDPEVQADMKHFPFKLIDVDGKPQIQVEFKGETKNFTPEQISSMVLGKMKETAESYLGAKVNDAVVTVPAYFNDSQRQATKDAGTIAGLNVLRIINEPTAAAIAYGLDKKGKEEHVLIFDLGGGTFDVSLLFIEDGIFEVKATAGDTHLGGEDFDNRLVNHFIQEFKRKNKKDLSTNQRALRRLRTACERAKRTLSSSAQTSVEIDSLFEGIDFYTSITRARFEELCADLFRSTLDPVEKVLRDAKLDKSQVDEIVLVGGSTRIPKVQKLVTDYFNGKEPNRSINPDEAVAYGAAVQAAILTGDESSKTQDLLLLDVAPLSLGIETAGGVMTKLIPRNSTISTKKFEIFSTYADNQPGVLIQVFEGERAKTKDNNLLGKFELSGIPPAPRGVPQIEVTFDVDSNGILNVSAVEKGTGKSNKITITNDKGRLSKEDIEKMVAEAEKFKEEDEKESQRIASKNQLESIAYSLKNTISEAGDKLEQADKDTVTKKAEETISWLDSNTTASKEEFDDKLKELQDIANPIMSKLYQAGGAPGGAAGGAPGGFPGGAPPAPEAEGPTVEEVD',
-'>YAL004W otherstuff' => 'MGVTSGGLNFKDTVFNEQQRDIESTTTQVENQDVFFLTLLVQTVSNGSGGRFVNNTQDIQTSNGTSILGSLSLRIVEVSWDSDDSVIDLGSQVRFGSFLHLTQDHGGDLFWGKVLGFTLKFNLNLRLTVNIDQLEWEVLHVSLHFWVVEVSTDQTLSVENGIRRIHSSLILSSITNQSFSVSESDKRWSGSVTLIVGNNVHTIISKVSNTRVCCT',
-'>YAL003W otherstuff' => 'MASTDFSKIETLKQLNASLADKSYIEGTAVSQADVTVFKAFQSAYPEFSRWFNHIASKADEFDSFPAASAAAAEEEEDDDVDLFGSDDEEADAEAEKLKAERIAAYNAKKAAKPAKPAAKSIVTLDVKPWDDETNLEEMVANVKAIEMEGLTWGAHQFIPIGFGIKKLQINCVVEDDKVSLDDLQQSIEEDEDHVQSTDIAAMQKL',
-'>YAL014C otherstuff' => 'MDVLKLGYELDQLSDLVEERTRLVSVLKLAPTSNDNVTLKRQLGSILELLQKCAPNDELISRYNTILDKIPDTAVDKELYRFQQQVARNTDEVSKESLKKVRFKNDDELTVMYKDDDEQDEESPLPSTHTPYKDEPLQSQLQSQSQPQPPQPMVSNQELFINQQQQLLEQDSHLGALSQSIGRTHDISLDLNNEIVSQNDSLLVDLENLIDNNGRNLNRASRSMHGFNNSRFKDNGNCVIILVLIVVLLLLLLVL',
-'>YAL013W otherstuff' => 'MSQQTPQESEQTTAKEQDLDQESVLSNIDFNTDLNHNLNLSEYCISSDAGTEKMDSDEEKSLANLPELKYAPKLSSLVKQETLTESLKRPHEDEKEAIDEAKKMKVPGENEDESKEEEKSQELEEAIDSKEKSTDARDEQGDEGDNEEENNEEDNENENEHTAPPALVMPSPIEMEEQRMTALKEITDIEYKFAQLRQKLYDNQLVRLQTELQMCLEGSHPELQVYYSKIAAIRDYKLHRAYQRQKYELSCINTETIATRTFIHQDFHKKVTDLRARLLNRTTQTWYDINKERRDMDIVIPDVNYHVPIKLDNKTLSCITGYASAAQLCYPGEPVAEDLACESIEYRYRANPVDKLEVIVDRMRLNNEISDLEGLRKYFHSFPGAPELNPLRDSEINDDFHQWAQCDRHTGPHTTSFCYS',
-'>YAL002W otherstuff' => 'MEQNGLDHDSRSSIDTTINDTQKTFLEFRSYTQLSEKLASSSSYTAPPLNEDGPKGVASAVSQGSESVVSWTTLTHVYSILGAYGGPTCLYPTATYFLMGTSKGCVLIFNYNEHLQTILVPTLSEDPSIHSIRSPVKSIVICSDGTHVAASYETGNICIWNLNVGYRVKPTSEPTNGMTPTPALPAVLHIDDHVNKEITGLDFFGARHTALIVSDRTGKVSLYNGYRRGFWQLVYNSKKILDVNSSKEKLIRSKLSPLISREKISTNLLSVLTTTHFALILLSPHVSLMFQETVEPSVQNSLVVNSSISWTQNCSRVAYSVNNKISVISISSSDFNVQSASHSPEFAESILSIQWIDQLLLGVLTISHQFLVLHPQHDFKILLRLDFLIHDLMIPPNKYFVISRRSFYLLTNYSFKIGKFVSWSDITLRHILKGDYLGALEFIESLLQPYCPLANLLKLDNNTEERTKQLMEPFYNLSLAALRFLIKKDNADYNRVYQLLMVVVRVLQQSSKKLDSIPSLDVFLEQGLEFFELKDNAVYFEVVANIVAQGSVTSISPVLFRSIIDYYAKEENLKVIEDLIIMLNPTTLDVDLAVKLCQKYNLFDLLIYIWNKIFDDYQTPVVDLIYRISNQSEKCVIFNGPQVPPETTIFDYVTYILTGRQYPQNLSISPSDKCSKIQRELSAFIFSGFSIKWPSNSNHKLYICENPEEEPAFPYFHLLLKSNPSRFLAMLNEVFEASLFNDDNDMVASVGEAELVSRQYVIDLLLDAMKDTGNSDNIRVLVAIFIATSISKYPQFIKVSNQALDCVVNTICSSRVQGIYEISQIALESLLPYYHSRTTENFILELKEKNFNKVLFHIYKSENKYASALSLILETKDIEKEYNTDIVSITDYILKKCPPGSLECGKVTEVIETNFDLLLSRIGIEKCVTIFSDFDYNLHQEILEVKNEETQQKYLDKLFSTPNINNKVDKRLRNLHIELNCKYKSKREMILWLNGTVLSNAESLQILDLLNQDSNFEAAAIIHERLESFNLAVRDLLSFIEQCLNEGKTNISTLLESLRRAFDDCNSAGTEKKSCWILLITFLITLYGKYPSHDERKDLCNKLLQEAFLGLVRSKSSSQKDSGGEFWEIMSSVLEHQDVILMKVQDLKQLLLNVFNTYKLERSLSELIQKIIEDSSQDLVQQYRKFLSEGWSIHTDDCEICGKKIWGAGLDPLLFLAWENVQRHQDMISVDLKTPLVIFKCHHGFHQTCLENLAQKPDEYSCLICQTESNPKIV',
-'>YAL012W otherstuff' => 'MTLQESDKFATKAIHAGEHVDVHGSVIEPISLSTTFKQSSPANPIGTYEYSRSQNPNRENLERAVAALENAQYGLAFSSGSATTATILQSLPQGSHAVSIGDVYGGTHRYFTKVANAHGVETSFTNDLLNDLPQLIKENTKLVWIETPTNPTLKVTDIQKVADLIKKHAAGQDVILVVDNTFLSPYISNPLNFGADIVVHSATKYINGHSDVVLGVLATNNKPLYERLQFLQNAIGAIPSPFDAWLTHRGLKTLHLRVRQAALSANKIAEFLAADKENVVAVNYPGLKTHPNYDVVLKQHRDALGGGMISFRIKGGAEAASKFASSTRLFTLAESLGGIESLLEVPAVMTHGGIPKEAREASGVFDDLVRISVGIEDTDDLLEDIKQALKQATN',
-  }
-  data.map do |header,aaseq|
-    FastaObj << Fasta::Prot.new(header, aaseq)
-  end
-
-end
-
-

data/specs/validator/prot_from_pep_spec.rb

@@ -1,141 +0,0 @@
-
-
-
-require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
-
-require 'validator/prot_from_pep'
-
-klass = Validator::ProtFromPep
-
-describe klass, "on fake, simple prots and peps" do
-  before(:each) do
-    # create some proteins and peptides linked up
-    prots = ('a'..'g').to_a.inject( { } ) do |hash,let|
-      prot = OpenStruct.new
-      prot.peps = []
-      hash[let.to_sym] = prot
-      hash
-    end
-    # prots: a.peps = 0,1,4
-    #        b.peps = 1
-    #        c.peps = 2
-    #        d.peps = 2,5,6
-    #        e.peps = 2
-    #        f.peps = 3,4
-    #        g.peps = 3,4,8,9,10
-
-    #        0    1         2            3        4          5     6     7   
-    peps = [[:a], [:a,:b], [:c,:d,:e], [:f,:g], [:a,:f,:g], [:c], [:c], [:d], 
-      # 8    9     10
-      [:g], [:g], [:g]].map do |belongs_to|
-      pep = OpenStruct.new 
-      pep.prots = belongs_to.map {|v| prots[v].peps << pep ; prots[v]}
-      pep
-    end
-    @peps = peps
-    @prots = prots
-
-    @normal_frozen = [[0.971428571428572, 0.0586273344048647], [0.95, 0.0838775640874857], [0.907142857142857, 0.116103957269609], [0.878571428571428, 0.133328857783819], [0.814285714285714, 0.147299354691691], [0.735714285714286, 0.186982368192933], [0.65, 0.18812775328873], [0.535714285714286, 0.206630166671598], [0.414285714285714, 0.178909454503803], [0.228571428571429, 0.117254668809732]]
-    @worstcase_frozen = [0.857142857142857, 0.714285714285714, 0.571428571428571, 0.571428571428571, 0.428571428571429, 0.285714285714286, 0.285714285714286, 0.142857142857143, 0.142857142857143, 0.142857142857143]
-  end
-
-  it 'calculates normal precision edge cases' do
-    val = klass.new
-    all_wrong = @peps.size
-    val.normal_prothit_precision( @peps, all_wrong, :num_its => 10 ).should == [0.0,0.0]
-    val.normal_prothit_precision( @peps, all_wrong, :num_its => 1).should == 0.0
-
-    val.normal_prothit_precision( @peps, all_wrong+10, :num_its => 10).should == [0.0,0.0]
-    val.normal_prothit_precision( @peps, all_wrong+10, :num_its => 1).should == 0.0
-
-    all_right = 0
-    val.normal_prothit_precision( @peps, all_right, :num_its => 10).should == [1.0,0.0]
-    val.normal_prothit_precision( @peps, all_right, :num_its => 1).should == 1.0
-  end
-
-  it 'calculates normal precision that behaves properly' do
-    val = klass.new
-    prev_mean = 1.0
-    (1...(@peps.size)).to_a.zip( @normal_frozen ) do |num_false, expected|
-      (mean, stdev) = val.normal_prothit_precision( @peps, num_false, :num_its => 20)
-      (mean < prev_mean).should be_true
-      (stdev < 0.4 and stdev > 0.0001).should be_true
-      mean.should be_close(expected[0], 0.000000001)
-      stdev.should be_close(expected[1], 0.000000001)
-      val.normal_prothit_precision( @peps, num_false, :num_its => 1).should be_close(mean, 0.25)
-    end
-  end
-
-  it 'calculates worstcase edge cases' do
-    val = klass.new
-    all_wrong = @peps.size
-    val.worstcase_prothit_precision( @peps, all_wrong, :num_its => 10 ).should == 0.0
-    val.worstcase_prothit_precision( @peps, all_wrong, :num_its => 1).should == 0.0
-
-    val.worstcase_prothit_precision( @peps, all_wrong+10, :num_its => 10).should == 0.0
-    val.worstcase_prothit_precision( @peps, all_wrong+10, :num_its => 1).should == 0.0
-
-    all_right = 0
-    val.worstcase_prothit_precision( @peps, all_right, :num_its => 10).should == 1.0
-    val.worstcase_prothit_precision( @peps, all_right, :num_its => 1).should == 1.0
-  end
-
-  it 'calculates worstcase precision that behaves properly' do
-
-    val = klass.new
-    prev_worst = 1.0
-    worsts = []
-    (1...(@peps.size)).to_a.zip( @worstcase_frozen ) do |num_false, expected|
-      worst = val.worstcase_prothit_precision( @peps, num_false, :num_its => 20)
-      (worst <= prev_worst).should be_true
-      worst.should be_close(expected, 0.0000000001)
-    end
-
-  end
-
-  it 'calculates prothit precision (worstcase + normal)' do
-    val = klass.new
-    (1...(@peps.size)).to_a.zip( @normal_frozen, @worstcase_frozen ) do |num_false, normal_expected, worstcase_expected|
-      (worst, norm_mean, norm_stdev) = val.prothit_precision( @peps, num_false, :num_its_normal => 20, :num_its_worstcase => 10)
-      worst.should be_close(worstcase_expected, 0.0000000001)
-      norm_mean.should be_close(normal_expected[0], 0.0000000001)
-      norm_stdev.should be_close(normal_expected[1], 0.0000000001)
-    end
-  end
-
-  it 'gives 1.0 precision for no pephits' do
-    val = klass.new
-    val.prothit_precision( [], 0).should == [1.0, 1.0, 0.0]
-  end
-
-end
-
-describe klass, "calculating worstcase prothit precision by numbers" do
-  it "calculates precision correctly in easy cases" do
-    peps_per_prot = [4,4,3,2,2]
-    # no prots completely wrong
-    precision = klass.new.worstcase_prothit_precision_by_numbers(peps_per_prot, 1)
-    precision.should == 1
-
-    # only one protein partially correct
-    precision = klass.new.worstcase_prothit_precision_by_numbers(peps_per_prot, 14)
-    precision.should == 0.2
-  end
-
-  it 'works correctly on other cases' do
-    #      0    1      2      3      4      5      6      7      8     
-    expected = [1.0, 5.0/6, 5.0/6, 4.0/6, 4.0/6, 3.0/6, 3.0/6, 3.0/6, 2.0/6, 
-    #      9      10     11     12     13     14     15     16     17
-           2.0/6, 2.0/6, 2.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, 0.0]
-    num_peps_per_prot = [5,4,3,2,2,1].sort_by { rand }
-    total_peps = num_peps_per_prot.inject(0) {|memo,obj| obj + memo }
-    val = klass.new
-    (0..total_peps).to_a.zip(expected) do |num_wrong, exp|
-      val.worstcase_prothit_precision_by_numbers(num_peps_per_prot, num_wrong).should == exp
-    end
-  end
-
-
-end
-
-

data/specs/validator/transmem_spec.rb

@@ -1,146 +0,0 @@
-require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
-require File.expand_path( File.dirname(__FILE__) + '/../validator_helper' )
-
-require 'validator/transmem'
-require 'spec_id/digestor'
-require File.dirname(__FILE__) + '/fasta_helper'
-require 'spec_id'
-
-klass = Validator::Transmem::Protein
-
-describe klass, "on small mock set" do
-  before(:each) do
-    @toppred_file = Tfiles + '/toppred.small.out'
-    @peps =  (0..7).to_a.map {|n| v = SpecID::GenericPep.new; v.aaseq = n.to_s ; v }
-    # certain:      3        0       0       0       2       3       2       1
-    references = %w(YAL002W  YAL001C YAL003W YAL004W YAL007C YAL008W YAL009W YAL010C NOTEXISTING1 NOTEXISTING2)
-    # index:        0        1       2       3       4       5       6       7
-    @prots = references.map do |ref|
-      v = SpecID::GenericProt.new
-      v.reference = ref
-      v
-    end
-
-    # TM (? = both)
-    # @prots[8] doesn't have a key in the guy (nil)
-    # SHOULD NOT change the results
-    @peps[0].prots = [@prots[0], @prots[5], @prots[8]]   # y
-    @peps[1].prots = [@prots[1], @prots[5], @prots[8]]   # ?
-    @peps[2].prots = [@prots[3], @prots[4], @prots[8]]   # ?
-    @peps[3].prots = [@prots[2], @prots[8]]             # n
-    @peps[4].prots = [@prots[5], @prots[8]]             # y
-    @peps[5].prots = [@prots[4], @prots[8]]             # y
-    @peps[6].prots = [@prots[8]]            # nil pep
-    @peps[7].prots = [@prots[8], @prots[9]] # nil pep
-
-    @validator = klass.new(@toppred_file)
-    @validator.false_to_total_ratio = 1.0
-  end
-
-  it_should_behave_like 'a validator'
-
-  it 'gives correct precision with false ratio (across all option combinations)' do
-    answ = [[2,4], [0,6], [0,6], [-2,8]].map {|v| calc_precision(*v) }
-    [true, false].each do |correct_wins|
-      [true, false].each do |soluble_fraction|
-        val = klass.new(@toppred_file, :min_num_tms => 3, :soluble_fraction => soluble_fraction, :correct_wins => correct_wins)
-        val.false_to_total_ratio = 0.5
-        val.pephit_precision(@peps).should == answ.shift
-        #p val.pephit_precision(@peps)
-      end
-    end
-  end
-  
-  it 'calculates a correct false to total ratio' do
-    val = klass.new(@toppred_file)
-    fasta_obj = FastaHelper::FastaObj
-    sequest_params_obj = Sequest::Params.new(Tfiles + '/bioworks32.params')
-    sequest_params_obj.opts['first_database_name'] = 'not_real'
-    val.set_false_to_total_ratio( Digestor.digest(fasta_obj, sequest_params_obj) )
-    ratio = val.false_to_total_ratio
-    num_tps_soluble_peps = 777
-    num_fps_insoluble_peps = 741
-    expected_ratio = num_tps_soluble_peps.to_f / (num_tps_soluble_peps + num_fps_insoluble_peps)
-    ratio.should == expected_ratio
-  end
-
-  it 'can grant transmem status to proteins for speed' do
-    val = klass.new(@toppred_file)
-    fasta_obj = FastaHelper::FastaObj
-    sequest_params_obj = Sequest::Params.new(Tfiles + '/bioworks32.params')
-    hash = val.create_transmem_status_hash( Digestor.digest(fasta_obj.prots, sequest_params_obj))
-    fasta_obj.prots.each do |prot|
-      hash.key?(prot).should be_true
-    end
-    frozen = [true, true, false, true, false, false, true, false, true, false, true, true, true]
-    fasta_obj.prots.map {|prot| hash[prot] }.should == frozen
-  end
-
-  def calc_precision(norm, trans)
-    prec = norm.to_f / (norm + trans)
-  end
-
-  it 'can calculate precision incrementally' do
-    val = klass.new(@toppred_file, :min_num_tms => 2, :false_to_total_ratio => 1.0)
-    # usually we'd update the false_to_total_ratio, but not bothering for test
-    # here we HAVE to set the status hash before hand... (we could redo this
-    # section)
-    val.transmem_status_hash = val.create_transmem_status_hash(@peps)
-
-    # manually done:
-    precisions = [0.0, 1.0/2, 2.0/3, 3.0/4, 3.0/5, 3.0/6, 3.0/6, 3.0/6]
-
-    #frozen:
-    calc_bkgs = [1.0, 0.5, 0.333333333333333, 0.25, 0.4, 0.5, 0.5, 0.5]
-    #frozen:
-    false_to_total_ratios = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
-
-    @peps.zip(precisions, calc_bkgs, false_to_total_ratios) do |pep, exp_prec, calc_bkg, false_to_total_ratio|
-      val.increment_pephits_precision(pep).should == exp_prec
-      val.calculated_background.should be_close(calc_bkg, 0.00000000000001)
-      val.false_to_total_ratio.should == false_to_total_ratio
-    end
-  end
-
-  it 'creates correct reference hash' do
-    val = klass.new(@toppred_file, :min_num_tms => 3, :soluble_fraction => true, :correct_wins => true)
-    val.transmem_by_ti_key.should == {"YAL001C"=>false, "YAL011W"=>false, "YAL009W"=>false, "YAL010C"=>false, "YAL008W"=>true, "YAL007C"=>false, "YAL004W"=>false, "YAL005C"=>false, "YAL003W"=>false, "YAL002W"=>true, "YAL013W"=>false, "YAL014C"=>false, "YAL012W"=>false}
-  end
-
-
-end
-
-
-#################################################
-# REFERENCE for small mock set:
-#################################################
-    #    for mintm >= 3 (T = TP, F = FP, sf = soluble_fraction)
-    #        sf=false sf=true
-    #    TM  cw fw    cw fw
-    # 0  y   T  T     F  F
-    # 1  ?   T  F     T  F
-    # 2  n   F  F     T  T
-    # 3  n   F  F     T  T
-    # 4  y   T  T     F  F
-    # 5  n   F  F     T  T
-    #
-    # [tps, fps]
-    # cw=true(  sf=true [4,2],  sf=false [3,3] )
-    # cw=false( sf=true [3,3],  sf=false [2,4] )
-   
-    #    for mintm >= 2 (T = TP, F = FP, sf = soluble_fraction)
-    #        sf=false sf=true
-    #    TM  cw fw    cw fw
-    # 0  y   T  T     F  F
-    # 1  ?   T  F     T  F
-    # 2  ?   T  F     T  F
-    # 3  n   F  F     T  T
-    # 4  y   T  T     F  F
-    # 5  y   T  T     F  F
-    #
-    # [tps, fps]
-    # cw=true(  sf=true [3,3],  sf=false [5,1] )
-    # cw=false( sf=true [1,5],  sf=false [3,3] )
-    #
-    # sf=true(  cw=true [3,3],  cw=false[1,5] )
-    # sf=false( cw=true [5,1],  cw=false[3,3] )

data/specs/validator/true_pos_spec.rb

@@ -1,58 +0,0 @@
-require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
-require File.expand_path(File.dirname(__FILE__) + '/../validator_helper')
-
-require 'validator/true_pos'
-require 'fasta'
-require 'spec_id'
-
-klass = Validator::TruePos
-describe klass, 'reporting precision on peptides' do
-
-  before(:each) do
-    @myfasta_string =<<END
->gi|1245235|ProteinX
-ABCDEFGHIJKLMNOP
->gi|987654|ProteinY
-AAAAAABBBBBBBBBBBB
->gi|1111111|ProteinZ
-FFFFFFFFFGGGGGGZZZZ
-END
-
-    @peps =  (0..5).to_a.map {|n| v = SpecID::GenericPep.new; v.aaseq = n.to_s ; v }
-    prots = %w(gi|1245235|ProteinX gi|987654|ProteinY gi|1111111|ProteinZ someOthergi AnotherGi YetAnotherReference).map do |ref|
-      v = SpecID::GenericProt.new
-      v.reference = ref
-      v
-    end
-    @peps[0].prots = [prots[0], prots[5]]  # TP (only in tp wins)
-    @peps[1].prots = [prots[1], prots[2]]  # TP always
-    @peps[2].prots = [prots[3], prots[4]]  # FP 
-    @peps[3].prots = [prots[2]]            # TP
-    @peps[4].prots = [prots[5]]            # FP
-    @peps[5].prots = [prots[4]]            # FP
-    @myfasta_obj = Fasta.new.load(StringIO.new(@myfasta_string))
-
-    @validator = klass.new(@myfasta_obj)
-  end
-
-  it_should_behave_like 'a validator'
-
-  it 'gives correct precision (across all options)' do
-    answ_ar = [
-      [[@peps[0], @peps[1], @peps[3]], [@peps[2], @peps[4], @peps[5]]],
-      [[@peps[1], @peps[3]], [@peps[0], @peps[2], @peps[4], @peps[5]]]
-    ]
-
-    [true, false].each do |correct_wins|
-      val = klass.new(@myfasta_obj, correct_wins)
-      answ = val.pephit_precision(@peps)
-      exp = ValidatorHelper.precision_from_partition_array(answ_ar.shift)
-      answ.should == exp
-    end
-
-  end
-
-end
-
-
-

data/specs/validator_helper.rb

@@ -1,33 +0,0 @@
-require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
-
-class ValidatorHelper
-  def self.precision_from_partition_array(ar)
-    (num_tp, num_fp) = ar.map {|v| v.size}
-    num_tp.to_f / (num_tp + num_fp)
-  end
-end
-
-module ValidatorHelper::Decoy
-  def self.precision_from_partition_array(ar)
-    (num_maybe_true, num_decoy) = ar.map {|v| v.size}
-    num_tp = num_maybe_true - num_decoy
-    num_fp = num_maybe_true - num_tp
-    num_tp.to_f / (num_tp + num_fp)
-  end
-end
-
-describe 'a validator', :shared => true do
-  before(:each) do
-    @empty_peps = []
-  end
-  it 'gives 1.0 for zero peptides (w/ pephit_precision)' do 
-    @validator.pephit_precision(@empty_peps).should == 1.0
-    
-  end
-  it 'gives 1.0 for zero peptides (w/ increment_pephits_precision)' do
-    @validator.increment_pephits_precision(@empty_peps).should == 1.0
-  end
-
-end
-
-

data/specs/xml_spec.rb

@@ -1,12 +0,0 @@
-require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
-
-require 'xml'
-
-describe XML, 'converting duration to seconds' do
-  it 'converts hours/mins/seconds in combinations' do
-    answ = [0.234, 624, 7392.2]
-    %w(PT0.234S PT10M24S PT2H3M12.2S).zip(answ) do |string, answ|
-      XML.duration_to_seconds(string).should == answ
-    end
-  end
-end