viral_seq 0.3.0

data/lib/viral_seq/hcv_dr.rb

@@ -0,0 +1,54 @@
+# viral_seq/hcv_dr
+# HCV resistant mutation interpretation
+# ViralSeq::hcv_ns5a
+
+# ViralSeq.hcv_ns5a(amino_acid_sequence_array, start_aa_position)
+#   # amino_acid_sequence_array is Array object of the amino acid sequence.
+#   # can use ViralSeq::Sequence#aa_array to obtain the aa array sequence
+#   # start_aa_position is the starting aa number of the input sequence as Integer
+
+module ViralSeq
+  def self.hcv_ns5a(aa_array,start_aa=1)
+    out_hash = {}
+    sdrm = {}
+    sdrm[28] = ['M',['T']]
+    sdrm[30] = ['L',['H','K','R','Q','A','S','D']]
+    sdrm[31] = ['L',['M','V','F']]
+    sdrm[32] = ['P',['L']]
+    sdrm[44] = ['K',['R']]
+    sdrm[58] = ['H',['D','P','S']]
+    sdrm[64] = ['T',['A','S']]
+    sdrm[77] = ['P',['A','S']]
+    sdrm[78] = ['R',['K']]
+    sdrm[79] = ['T',['A']]
+    sdrm[83] = ['T',['M']]
+    sdrm[85] = ['S',['N','H','Y']]
+    sdrm[92] = ['A',['P','T','K','E']]
+    sdrm[93] = ['Y',['C','F','H','N']]
+    sdrm[107] = ['K',['T','S']]
+    sdrm[121] = ['I',['V']]
+    sdrm[135] = ['T',['A']]
+    aa_length = aa_array.size
+    end_aa = start_aa + aa_length - 1
+    (start_aa..end_aa).each do |position|
+      array_position = position - start_aa
+      if sdrm.keys.include?(position)
+        wt_aa = sdrm[position][0]
+        test_aa = aa_array[array_position]
+        if test_aa.size == 1
+          unless wt_aa == test_aa
+            if sdrm[position][1].include?(test_aa)
+              out_hash[position] = [wt_aa,test_aa]
+            end
+          end
+        else
+          test_aa_array = test_aa.split("/")
+          if (test_aa_array & sdrm[position][1])
+            out_hash[position] = [wt_aa,test_aa]
+          end
+        end
+      end
+    end
+    return out_hash
+  end
+end

data/lib/viral_seq/locator.rb

@@ -0,0 +1,299 @@
+# viral_seq/locator.rb
+
+# Including following methods:
+#   ViralSeq::sequence_locator
+#   ViralSeq::sequence_clip
+#   ViralSeq::qc_hiv_seq_check
+
+#   HIV sequence locator function
+#   resembling HIV Sequence Locator from LANL
+#   https://www.hiv.lanl.gov/content/sequence/LOCATE/locate.html
+#   require MUSCLE (http://www.drive5.com/muscle) installed
+#   current version only supports nucleotide sequence, not for amino acid sequence.
+
+# =USAGE1
+#   # Find the location of a sequence
+#   ViralSeq.sequence_locator(input_sequence, reference_options, path_to_muscle)
+#   # input_sequence: String of nucleotide sequence
+#   # reference_options: choose a reference genome from :HXB2 (default), :NL43, or :MAC239
+#   # path_to_muscle: path to the muscle executable.
+#   # Default as :false, will call MuscleBio to run Muscle
+#   # specify path_to_muscle if other source of muscle needed
+#   # function returns an array of
+#   #   start_location (Integer)
+#   #   end_location (Integer)
+#   #   percentage_of_similarity_to_reference_sequence (Float)
+#   #   containing_indel? (Boolean)
+#   #   aligned_input_sequence (String)
+#   #   aligned_reference_sequence (String)
+#   # example code
+#   sequence = 'AGCAGATGATACAGTATTAGAAGAAATAAATTTGCCAGGAAGATGGAAACCAAAAATGATAGGGGGAATTGGAGGTTTTATCAAAGTAAGACAATATGATC'
+#   p ViralSeq.sequence_locator(sequence, :NL43, 'muscle')
+#   => [2333, 2433, 98.0, false, "AGCAGATGATACAGTATTAGAAGAAATAAATTTGCCAGGAAGATGGAAACCAAAAATGATAGGGGGAATTGGAGGTTTTATCAAAGTAAGACAATATGATC", "AGCAGATGATACAGTATTAGAAGAAATGAATTTGCCAGGAAGATGGAAACCAAAAATGATAGGGGGAATTGGAGGTTTTATCAAAGTAAGACAGTATGATC"]
+
+# =USAGE2
+#   ViralSeq.sequence_clip(input_sequence, start_position, end_position, reference_options, path_to_muscle)
+#   # Given a pair of specific start and end positions, and an input sequence, return a sub-sequence of that range
+#   # return nil if the input sequence is not in the range
+#   # input_sequence: String of nucleotide sequence
+#   # start_position and end_position: Integer of the start and end reference number of the sub-sequence
+#   # reference_options and path_to_muscle are same as in ViralSeq.sequence_locator
+#   # path_to_muscle: path to the muscle executable.
+#   # Default as :false, will call MuscleBio to run Muscle
+#   # specify path_to_muscle if other source of muscle needed
+#   # example code
+#   seq = "CCTCAGATCACTCTTTGGCAACGACCCCTAGTTACAATAAGGGTAGGGGGGCAACTAAAGGAAGCCCTATTAGATACAGGAGCAGATGATACAGTATTAGAAGAAATAAATTTGCCAGGAAGATGGAAACCAAAAATGATAGGGGGAATTGGAGGTTTTATCAAAGTAAGACAATATGATCAGATACCCATAGAAATTTGTGGACATGAAGCTATAGGTACAGTATTAGTGGGACCTACACCTGTCAACATAATTGGGAGAAATCTGTTGACTCAGATTGGTTGCACTCTAAATTTT"
+#   p ViralSeq.sequence_clip(seq, 2333, 2433, :HXB2, 'muscle')
+#   => "AGCAGATGATACAGTATTAGAAGAAATAAATTTGCCAGGAAGATGGAAACCAAAAATGATAGGGGGAATTGGAGGTTTTATCAAAGTAAGACAATATGATC"
+
+# =USAGE3
+#   ViralSeq.qc_hiv_seq_check(seq_hash, start_nt, end_nt, allow_indel?, reference_options, path_to_muscle)
+#   # Given a sequence hash, start and end nt positions to a chosen reference genome (default :HXB2),
+#   # and a boolean value for allowing indels,
+#   # path_to_muscle: path to the muscle executable.
+#   # Default as :false, will call MuscleBio to run Muscle
+#   # specify path_to_muscle if other source of muscle needed
+#   # return a sequence sub-hash that meets the the criteria
+#   # example code
+#   sequence_hash = ViralSeq.fasta_to_hash('sample/sample_seq.fasta') # load the .fasta file as a sequence hash
+#   filtered_sequence_hash = ViralSeq.qc_hiv_seq_check(sequence_hash, 4384, 4751, false, :HXB2, 'muscle')
+#   puts sequence_hash.size
+#   => 6
+#   puts filtered_sequence_hash.size
+#   => 4
+
+module ViralSeq
+
+  def self.sequence_locator(seq='', ref_option = :HXB2, path_to_muscle = false)
+
+    # ViralSeq.check_muscle(path_to_muscle)
+    ori_ref = ViralSeq.check_ref(ref_option)
+
+    begin
+      ori_ref_l = ori_ref.size
+      l1 = 0
+      l2 = 0
+
+      aln_seq = ViralSeq.muscle_align(ori_ref, seq, path_to_muscle)
+      aln_test = aln_seq[1]
+      aln_test =~ /^(\-*)(\w.*\w)(\-*)$/
+      gap_begin = $1.size
+      gap_end = $3.size
+      aln_test2 = $2
+      ref = aln_seq[0]
+      ref = ref[gap_begin..(-gap_end-1)]
+      ref_size = ref.size
+      if ref_size > 1.3*(seq.size)
+        l1 = l1 + gap_begin
+        l2 = l2 + gap_end
+        max_seq = aln_test2.scan(/[ACGT]+/).max_by(&:length)
+        aln_test2 =~ /#{max_seq}/
+        before_aln_seq = $`
+        before_aln = $`.size
+        post_aln_seq = $'
+        post_aln = $'.size
+        before_aln_seq_size = before_aln_seq.scan(/[ACGT]+/).join("").size
+        b1 = (1.3 * before_aln_seq_size).to_i
+        post_aln_seq_size = post_aln_seq.scan(/[ACGT]+/).join("").size
+        b2 = (1.3 * post_aln_seq_size).to_i
+        if (before_aln > seq.size) and (post_aln <= seq.size)
+          ref = ref[(before_aln - b1)..(ref_size - post_aln - 1)]
+          l1 = l1 + (before_aln - b1)
+        elsif (post_aln > seq.size) and (before_aln <= seq.size)
+          ref = ref[before_aln..(ref_size - post_aln - 1 + b2)]
+          l2 = l2 + post_aln - b2
+        elsif (post_aln > seq.size) and (before_aln > seq.size)
+          ref = ref[(before_aln - b1)..(ref_size - post_aln - 1 + b2)]
+          l1 = l1 + (before_aln - b1)
+          l2 = l2 + (post_aln - b2)
+        end
+
+        aln_seq = ViralSeq.muscle_align(ref, seq, path_to_muscle)
+        aln_test = aln_seq[1]
+        aln_test =~ /^(\-*)(\w.*\w)(\-*)$/
+        gap_begin = $1.size
+        gap_end = $3.size
+        ref = aln_seq[0]
+        ref = ref[gap_begin..(-gap_end-1)]
+      end
+
+      aln_test = aln_seq[1]
+      aln_test =~ /^(\-*)(\w.*\w)(\-*)$/
+      gap_begin = $1.size
+      gap_end = $3.size
+      aln_test = $2
+      aln_test =~ /^(\w+)(\-*)\w/
+      s1 = $1.size
+      g1 = $2.size
+      aln_test =~ /\w(\-*)(\w+)$/
+      s2 = $2.size
+      g2 = $1.size
+
+      l1 = l1 + gap_begin
+      l2 = l2 + gap_end
+      repeat = 0
+
+      if g1 == g2 and (s1 + g1 + s2) == ref.size
+        if s1 > s2 and g2 > 2*s2
+          ref = ref[0..(-g2-1)]
+          repeat = 1
+          l2 = l2 + g2
+        elsif s1 < s2 and g1 > 2*s1
+          ref = ref[g1..-1]
+          repeat = 1
+          l1 = l1 + g1
+        end
+      else
+        if g1 > 2*s1
+          ref = ref[g1..-1]
+          repeat = 1
+          l1 = l1 + g1
+        end
+        if g2 > 2*s2
+          ref = ref[0..(-g2 - 1)]
+          repeat = 1
+          l2 = l2 + g2
+        end
+      end
+
+      while repeat == 1
+        aln_seq = ViralSeq.muscle_align(ref, seq, path_to_muscle)
+        aln_test = aln_seq[1]
+        aln_test =~ /^(\-*)(\w.*\w)(\-*)$/
+        gap_begin = $1.size
+        gap_end = $3.size
+        aln_test = $2
+        aln_test =~ /^(\w+)(\-*)\w/
+        s1 = $1.size
+        g1 = $2.size
+        aln_test =~ /\w(\-*)(\w+)$/
+        s2 = $2.size
+        g2 = $1.size
+        ref = aln_seq[0]
+        ref = ref[gap_begin..(-gap_end-1)]
+        l1 = l1 + gap_begin
+        l2 = l2 + gap_end
+        repeat = 0
+        if g1 > 2*s1
+          ref = ref[g1..-1]
+          repeat = 1
+          l1 = l1 + g1
+        end
+        if g2 > 2*s2
+          ref = ref[0..(-g2 - 1)]
+          repeat = 1
+          l2 = l2 + g2
+        end
+      end
+      ref = ori_ref[l1..(ori_ref_l - l2 - 1)]
+
+
+      aln_seq = ViralSeq.muscle_align(ref, seq, path_to_muscle)
+      aln_test = aln_seq[1]
+      ref = aln_seq[0]
+
+      #refine alignment
+
+      if ref =~ /^(\-+)/
+        l1 = l1 - $1.size
+      elsif ref =~ /(\-+)$/
+        l2 = l2 + $1.size
+      end
+
+      if (ori_ref_l - l2 - 1) >= l1
+        ref = ori_ref[l1..(ori_ref_l - l2 - 1)]
+        aln_seq = ViralSeq.muscle_align(ref, seq, path_to_muscle)
+        aln_test = aln_seq[1]
+        ref = aln_seq[0]
+
+        ref_size = ref.size
+        sim_count = 0
+        (0..(ref_size-1)).each do |n|
+          ref_base = ref[n]
+          test_base = aln_test[n]
+          sim_count += 1 if ref_base == test_base
+        end
+        similarity = (sim_count/ref_size.to_f*100).round(1)
+
+        loc_p1 = l1 + 1
+        loc_p2 = ori_ref_l - l2
+        if seq.size != (loc_p2 - loc_p1 + 1)
+            indel = true
+        elsif aln_test.include?("-")
+            indel = true
+        else
+            indel = false
+        end
+        return [loc_p1,loc_p2,similarity,indel,aln_test,ref]
+      else
+        return [0,0,0,0,0,0,0]
+      end
+    rescue => e
+      puts "Unexpected error occured."
+      puts "Exception Class: #{ e.class.name }"
+      puts "Exception Message: #{ e.message }"
+      puts "Exception Backtrace: #{ e.backtrace[0] }"
+      puts "ViralSeq.sequence_locator returns nil"
+      return nil
+    end
+  end
+
+  # sequence clip function
+  def self.sequence_clip(seq='', p1 = 0, p2 = 0, ref_option = :HXB2, path_to_muscle = false)
+    loc = ViralSeq.sequence_locator(seq, ref_option, path_to_muscle)
+    l1 = loc[0]
+    l2 = loc[1]
+    if (p1 >= l1) & (p2 <= l2)
+        seq = loc[4]
+        ref = loc[5]
+        g1 = 0
+        ref.each_char do |char|
+            break if l1 == p1
+            g1 += 1
+            l1 += 1 unless char == "-"
+        end
+        g2 = 1
+        ref.reverse.each_char do |char|
+            break if l2 == p2
+            g2 += 1
+            l2 -= 1 unless char == "-"
+        end
+        return seq[g1..(-g2)].tr("-","")
+    else
+        return nil
+    end
+  end
+
+  # batch quality check of HIV sequences based on ViralSeq.sequence_locator
+  # input a sequence hash, start nt position(s) and end nt position(s) can be an Integer, Array or Range
+  # and allow the sequence to contain indels
+  # return a hash of filtered sequences
+
+  def self.qc_hiv_seq_check(seq_hash, start_nt, end_nt, indel=true, ref_option = :HXB2, path_to_muscle = false)
+    seq_hash_unique = seq_hash.values.uniq
+    seq_hash_unique_pass = []
+    start_nt = start_nt..start_nt if start_nt.is_a?(Integer)
+    end_nt = end_nt..end_nt if end_nt.is_a?(Integer)
+    seq_hash_unique.each do |seq|
+      loc = ViralSeq.sequence_locator(seq, ref_option, path_to_muscle)
+      if start_nt.include?(loc[0]) && end_nt.include?(loc[1])
+        if indel
+          seq_hash_unique_pass << seq
+        elsif loc[3] == false
+          seq_hash_unique_pass << seq
+        end
+      end
+    end
+    seq_pass = {}
+    seq_hash_unique_pass.each do |seq|
+      seq_hash.each do |seq_name, orginal_seq|
+        if orginal_seq == seq
+          seq_pass[seq_name] =  seq
+          seq_hash.delete(seq_name)
+        end
+      end
+    end
+    return seq_pass
+  end
+
+end

data/lib/viral_seq/math.rb

@@ -0,0 +1,401 @@
+# lib/math.rb
+
+# math and statistic functions
+# inlcuding the following methods
+#   ViralSeq::count
+#   ViralSeq::count_percentage
+#   ViralSeq::poisson_distribution
+#   ViralSeq::r_binom_CI
+#   Enumerable#median
+#   Enumerable#sum
+#   Enumerable#mean
+#   Enumerable#sample_variance
+#   Enumerable#stdev
+#   Enumerable#upper_quartile
+#   Enumerable#lower_quartile
+#   Integer#!
+#   Rubystats::FishersExactTest
+#   RandomGaussian::new
+#   RandomGaussian#rand
+
+module ViralSeq
+
+  # count elements in a array, return a hash of {:element1 => number1, :element2 => number2, ...}
+  # =Usage
+  #   array = %w{cat dog monkey cat cat cat monkey}
+  #   ViralSeq.count(array)
+  #   => {"cat"=>4, "dog"=>1, "monkey"=>2}
+
+  def self.count(array)
+    hash = Hash.new(0)
+    array.each do |element|
+      hash[element] +=1
+    end
+    return hash
+  end
+
+  # count elements in a array, return a hash of {:element1 => frequency1, :element2 => frequency2, ...}
+  # default decimal as 2
+  # =Usage
+  #   array = %w{cat dog monkey cat cat cat monkey}
+  #   ViralSeq.count_percentage(array)
+  #   => {"cat"=>0.57, "dog"=>0.14, "monkey"=>0.29}
+
+  def self.count_percentage(array,decimal = 2)
+    hash1 = Hash.new(0)
+    array.each do |element|
+      hash1[element] += 1
+    end
+    total_elements = array.size
+    hash2 = Hash.new(0)
+    hash1.each do |key,value|
+      hash2[key] = (value/total_elements.to_f).round(decimal)
+    end
+    return hash2
+  end
+
+  # poisson distribution. input lambda and maximum k, return a hash with keys as k
+  # default k value is 5, meaning calculate up to 5 events.
+  #
+  # Poisson Distribution (https://en.wikipedia.org/wiki/Poisson_distribution)
+  #   An event can occur 0, 1, 2, … times in an interval.
+  #   The average number of events in an interval is designated λ (lambda).
+  #   λ is the event rate, also called the rate parameter.
+  #   The probability of observing k events in an interval is given by the equation
+  #
+  #   P(k events in interval) = e^(-λ) * λ^k / k!
+  #
+  #   λ is the average number of events per interval
+  #   e is the number 2.71828... (Euler's number) the base of the natural logarithms
+  #   k takes values 0, 1, 2, …
+  #   k! = k × (k − 1) × (k − 2) × … × 2 × 1 is the factorial of k.
+  #
+  # =USAGE
+  #   # We assume the mutaiton rate is 0.005 (event rate λ),
+  #   # we would like to calculate the probablity of 3 mutations on one sequence
+  #   prob_hash = ViralSeq::poisson_distribution(0.005)
+  #   => {0=>0.9950124791926823, 1=>0.004975062395963412, 2=>1.243765598990853e-05, 3=>2.072942664984755e-08, 4=>2.5911783312309436e-11, 5=>2.591178331230944e-14}
+  #   prob_hash[3]
+  #   => 2.072942664984755e-08
+
+  def self.poisson_distribution(rate,k = 5)
+    out_hash = {}
+    (0..k).each do |n|
+      p = (rate**n * Math::E**(-rate))/!n
+      out_hash[n] = p
+    end
+    return out_hash
+  end
+
+
+  # require R pre-installed
+  # calculate binomial 95% confidence intervals by R. refer to R function binom.test
+  # input number x and n, return an array as [lower_interval, upper_interval]
+  #
+  # =USAGE
+  #   # mutation M184V found in 3 out of 923 sequences, the 95% confidence interval is
+  #   ViralSeq.r_binom_CI(3, 923)
+  #   => [0.02223, 0.19234]
+  #
+  def self.r_binom_CI(x= 0, n= 0)
+    r_output = `Rscript -e 'binom.test(#{x},#{n})$conf.int[1];binom.test(#{x},#{n})$conf.int[2]'`
+    lines = r_output.split "\n"
+    low = lines[0].chomp[4..-1].to_f
+    high = lines[1].chomp[4..-1].to_f
+    return [low.round(5), high.round(5)]
+  end
+
+end
+
+# statistic methods
+# :median :sum :mean :sample_variance :stdev :upper_quartile :lower_quartile
+# =USAGE
+#   array = [1,2,3,4,5,6,7,8,9,10]
+#   array.median
+#   => 5.5
+#   array.sum
+#   => 55
+#   array.mean
+#   => 5.5
+#   array.sample_variance
+#   => 9.166666666666666
+#   array.stdev
+#   => 3.0276503540974917
+#   array.upper_quartile
+#   => 7.5
+#   array.lower_quartile
+#   => 3.5
+
+module Enumerable
+  def median
+    len = self.length
+    sorted = self.sort
+    len % 2 == 1 ? sorted[len/2] : (sorted[len/2 - 1] + sorted[len/2]).to_f / 2
+  end
+
+  def sum
+     self.inject(0){|accum, i| accum + i }
+  end
+
+  def mean
+    self.sum/self.length.to_f
+  end
+
+  def sample_variance
+    m = self.mean
+    sum = self.inject(0){|accum, i| accum + (i-m)**2 }
+    sum/(self.length - 1).to_f
+  end
+
+  def stdev
+    return Math.sqrt(self.sample_variance)
+  end
+
+  def upper_quartile
+    return nil if self.empty?
+    sorted_array = self.sort
+    u = (0.25*(3*sorted_array.length))
+    if (u-u.truncate).is_a?(Integer)
+      return sorted_array[(u-u.truncate)-1]
+    else
+      sample = sorted_array[u.truncate.abs-1]
+      sample1 = sorted_array[(u.truncate.abs)]
+      return sample+((sample1-sample)*(u-u.truncate))
+    end
+  end
+
+  def lower_quartile
+    return nil if self.empty?
+    sorted_array = self.sort
+    u = 0.25*sorted_array.length + 1
+    if (u-u.truncate).is_a?(Integer)
+      return sorted_array[(u-u.truncate)-1]
+    else
+      sample = sorted_array[u.truncate.abs-1]
+      sample1 = sorted_array[(u.truncate.abs)]
+      return sample+((sample1-sample)*(u-u.truncate))
+    end
+  end
+end
+
+# factorial method for an Integer
+# Integer.!
+class Integer
+  def !
+    if self == 0
+      return 1
+    else
+      (1..self).inject(:*)
+    end
+  end
+end
+
+
+# Fisher's Exact Test Function Library
+#
+# Based on JavaScript version created by: Oyvind Langsrud
+# Ported to Ruby by Bryan Donovan
+
+module Rubystats
+  class FishersExactTest
+
+    def initialize
+      @sn11    = 0.0
+      @sn1_    = 0.0
+      @sn_1    = 0.0
+      @sn      = 0.0
+      @sprob   = 0.0
+
+      @sleft   = 0.0
+      @sright  = 0.0
+      @sless   = 0.0
+      @slarg   = 0.0
+
+      @left    = 0.0
+      @right   = 0.0
+      @twotail = 0.0
+    end
+
+    # Reference: "Lanczos, C. 'A precision approximation
+    # of the gamma function', J. SIAM Numer. Anal., B, 1, 86-96, 1964."
+    # Translation of  Alan Miller's FORTRAN-implementation
+    # See http://lib.stat.cmu.edu/apstat/245
+    def lngamm(z)
+      x = 0
+      x += 0.0000001659470187408462 / (z+7)
+      x += 0.000009934937113930748  / (z+6)
+      x -= 0.1385710331296526       / (z+5)
+      x += 12.50734324009056        / (z+4)
+      x -= 176.6150291498386        / (z+3)
+      x += 771.3234287757674        / (z+2)
+      x -= 1259.139216722289        / (z+1)
+      x += 676.5203681218835        / (z)
+      x += 0.9999999999995183
+
+      return(Math.log(x)-5.58106146679532777-z+(z-0.5) * Math.log(z+6.5))
+    end
+
+    def lnfact(n)
+      if n <= 1
+        return 0
+      else
+        return lngamm(n+1)
+      end
+    end
+
+    def lnbico(n,k)
+      return lnfact(n) - lnfact(k) - lnfact(n-k)
+    end
+
+    def hyper_323(n11, n1_, n_1, n)
+      return Math.exp(lnbico(n1_, n11) + lnbico(n-n1_, n_1-n11) - lnbico(n, n_1))
+    end
+
+    def hyper(n11)
+      return hyper0(n11, 0, 0, 0)
+    end
+
+    def hyper0(n11i,n1_i,n_1i,ni)
+      if n1_i == 0 and n_1i ==0 and ni == 0
+        unless n11i % 10 == 0
+          if n11i == @sn11+1
+            @sprob *= ((@sn1_ - @sn11)/(n11i.to_f))*((@sn_1 - @sn11)/(n11i.to_f + @sn - @sn1_ - @sn_1))
+            @sn11 = n11i
+            return @sprob
+          end
+          if n11i == @sn11-1
+            @sprob *= ((@sn11)/(@sn1_-n11i.to_f))*((@sn11+@sn-@sn1_-@sn_1)/(@sn_1-n11i.to_f))
+            @sn11 = n11i
+            return @sprob
+          end
+        end
+        @sn11 = n11i
+      else
+        @sn11 = n11i
+        @sn1_ = n1_i
+        @sn_1 = n_1i
+        @sn   = ni
+      end
+      @sprob = hyper_323(@sn11,@sn1_,@sn_1,@sn)
+      return @sprob
+    end
+
+    def exact(n11,n1_,n_1,n)
+
+      p = i = j = prob = 0.0
+
+      max = n1_
+      max = n_1 if n_1 < max
+      min = n1_ + n_1 - n
+      min = 0 if min < 0
+
+      if min == max
+        @sless  = 1
+        @sright = 1
+        @sleft  = 1
+        @slarg  = 1
+        return 1
+      end
+
+      prob = hyper0(n11,n1_,n_1,n)
+      @sleft = 0
+
+      p = hyper(min)
+      i = min + 1
+      while p < (0.99999999 * prob)
+        @sleft += p
+        p = hyper(i)
+        i += 1
+      end
+
+      i -= 1
+
+      if p < (1.00000001*prob)
+        @sleft += p
+      else
+        i -= 1
+      end
+
+      @sright = 0
+
+      p = hyper(max)
+      j = max - 1
+      while p < (0.99999999 * prob)
+        @sright += p
+        p = hyper(j)
+        j -= 1
+      end
+      j += 1
+
+      if p < (1.00000001*prob)
+        @sright += p
+      else
+        j += 1
+      end
+
+      if (i - n11).abs < (j - n11).abs
+        @sless = @sleft
+        @slarg = 1 - @sleft + prob
+      else
+        @sless = 1 - @sright + prob
+        @slarg = @sright
+      end
+      return prob
+    end
+
+    def calculate(n11_,n12_,n21_,n22_)
+      n11_ *= -1 if n11_ < 0
+      n12_ *= -1 if n12_ < 0
+      n21_ *= -1 if n21_ < 0
+      n22_ *= -1 if n22_ < 0
+      n1_     = n11_ + n12_
+      n_1     = n11_ + n21_
+      n       = n11_ + n12_ + n21_ + n22_
+      exact(n11_,n1_,n_1,n)
+      left    = @sless
+      right   = @slarg
+      twotail = @sleft + @sright
+      twotail = 1 if twotail > 1
+      values_hash = { :left =>left, :right =>right, :twotail =>twotail }
+      return values_hash
+    end
+  end
+end
+
+
+# generate values from the standard normal distribution with given mean and standard deviation
+# See http://en.wikipedia.org/wiki/Box-Muller_transform
+#
+# RandomGaussian.new(mean, sd, rng)
+#   # generate RandomGaussian instance with given mean and standard deviation
+#   # default value: mean = 0.0, sd = 1.0
+#
+# RandomGaussian.rand
+#   # generate a random number that falls in the pre-defined gaussian distribution
+# =USAGE
+#   # example
+#   a = RandomGaussian.new
+#   a.rand
+#   numbers = []
+#   10.times {numbers << a.rand.round(5)}
+#   numbers
+#   [-1.83457, 1.24439, -0.30109, 0.13977, 0.61556, 1.3548, 1.72878, 2.46171, 0.97031, -0.29496] 
+
+
+class RandomGaussian
+  def initialize(mean = 0.0, sd = 1.0, rng = lambda { Kernel.rand })
+    @mean, @sd, @rng = mean, sd, rng
+    @compute_next_pair = false
+  end
+
+  def rand
+    if (@compute_next_pair = !@compute_next_pair)
+      theta = 2 * Math::PI * @rng.call
+      scale = @sd * Math.sqrt(-2 * Math.log(1 - @rng.call))
+      @g1 = @mean + scale * Math.sin(theta)
+      @g0 = @mean + scale * Math.cos(theta)
+    else
+      @g1
+    end
+  end
+end