ml_ratiosolve 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c76acec151175240892ce4280bbdb360af79d268
+  data.tar.gz: 50e5f40213dec0644ad76c57672c031139f516a7
+SHA512:
+  metadata.gz: df72bc79f9019b6fd6142da383d79492dbff2157fa0ff0db22677b7c4727886f2f1dfb31b15f8df12bde9d290b542266ebb8f48be64c9335f82f36ca615fe2d7
+  data.tar.gz: 23619b6eea6159c3535bf44f06065b7efad19e20c3b8e6a67e6ed393e8f55ead1f1ed627e7ec719e62aaabbc3cfe07a614d24d9406f3a7f2ed7b498fbd7c1801

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ml_ratiosolve.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Colin J. Fuller
+
+MIT License
+
+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/README.md

@@ -0,0 +1,32 @@
+# MlRatiosolve
+
+A tool for parameter estimations for (not-quite-)ratio problems.  
+
+In scientific data, frequently there is uncontrolled experiment-to-experiment variability such that quantitiative comparison between experiments is only meaningful when data are expressed as a ratio to an internal control that is part of each experiment.  However, even if the values of the control and other treatments would be Gaussian distributed, this ratio is not, making accurate estimates of means and errors difficult.
+
+MLRatiosolve uses the fact that this problem contains more information than just the ratios to obtain better estimates of distribution parameters than is possible for a ratio problem.
+
+
+## Installation
+
+  Dependencies:
+
+  MLRatioSolve requires the [NMatrix linear algebra library](https://github.com/SciRuby/nmatrix), which will be installed automatically.  NMatrix, however, requires that you first install ATLAS.  If you don't have this installed already, see the instructions at https://github.com/SciRuby/nmatrix/wiki/Installation
+
+  `$ gem install ml_ratiosolve`
+
+  Or, if you have ruby installed globally on your computer:
+
+  `$ sudo gem install ml_ratiosolve`
+
+## Usage
+
+MLRatiosolve takes a CSV file of data as input.  Run `ml_ratiosolve --help` from the command line for further information and additional options.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'rspec/core/rake_task'
+
+task default: [:spec]
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--tty --color --format documentation'
+end

data/bin/ml_ratiosolve

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'ml_ratiosolve'
+
+require 'trollop'
+
+opts = Trollop::options do 
+  opt :file, "Input file, containing CSV-formatted data with columns corresponding to independent experiments and rows as treatments.", type: :string
+  opt :n_starts, "Number of distinct starting guesses to try for parameter estimation", type: :integer, default: 1000
+  opt :n_iter, "Maximum number of iterations to run per starting guess", type: :integer, default: 1500
+  opt :n_bootstrap, "Number of samples to calculate for parametric bootstrapping of the confidence intervals", type: :integer, default: 1000
+  opt :tol, "If the absolute change in log likelihood of an estimate is less than this, iteration will terminate.", type: :float, default: 1.0e-6
+  opt :ci_level, "Float in the range 0-1 specifiying the level of confidence interval to calculate.  E.g. 0.95 will calculate a 95% confidence interval", type: :float, default: 0.95
+  opt :skip, "If some experiments are missing datapoints, specifiy which ones here.  These should be specified as (0-indexed) treatment,experiment pairs, with a comma separating treatment and experiment and a colon separating successive pairs.  E.g. to skip the first and second treatments in the first experiment: '0,0:1,0'", type: :string, default: ""
+  opt :norm_index, "Normalize so that the mean value of the specified treatment is set to 1.", type: :integer, default: 0
+end
+
+MLRatioSolveBin.go(opts)

data/lib/ml_ratiosolve/error_bootstrapping.rb

@@ -0,0 +1,133 @@
+#--
+# error_bootstrapping.rb
+# Copyright (c) 2013 Colin J. Fuller
+# 
+# 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.
+#++
+
+# 
+# Methods for using parametric bootstrapping to estimate confidence intervals
+# for the ML ratio estimation.
+# 
+# @author Colin J. Fuller
+# 
+module ErrorBootstrapping
+  class << self
+
+    # 
+    # Generate a random normal variate using the Box-Muller transform
+    # @param  mu [Numeric] The desired mean
+    # @param  s2 [Numeric] The desired variance
+    # 
+    # @return [Float] A random variate from the normal distribution with 
+    #   supplied parameters
+    def randnorm(mu, s2)
+      ru0 = rand
+      ru1 = rand
+      ([Math.sqrt(-2.0 * Math.log(ru0)) * Math.cos(2*Math::PI*ru1), Math.sqrt(-2.0 * Math.log(ru0)) * Math.sin(2*Math::PI*ru1)].sample)*Math.sqrt(s2) + mu
+    end
+
+
+    # 
+    # Generate a set of simulated data consisting of random numbers drawn from 
+    # the distributions with the supplied parameters
+    # @param  parameters [Hash] A hash containing the mean, variance, and scale
+    #   parameters formatted like the output from 
+    #   MLRatioSolve::do_iters_with_start
+    # @param  x [NMatrix] The original experimental data
+    # 
+    # @return [NMatrix] A matrix of simulated data with the same dimensions as 
+    # x.  Any skipped data points (as returned by MLRatioSolve::skip_indices) 
+    # will be set to 0 here.
+    def gen_data(parameters, x)
+      mu = parameters[:mu]
+      sig2 = parameters[:sig2]
+      gamma = parameters[:gamma]
+      size_i = x.shape[0]
+      size_n = x.shape[1]
+
+      sim_data_out = N.zeros_like(x)
+
+      size_i.times do |i|
+        size_n.times do |n|
+          next if MLRatioSolve.skip_indices.include?([i,n])
+          sim_data_out[i,n] = randnorm(mu[i]/gamma[n], sig2[i]/gamma[n]**2)
+        end
+      end
+
+      sim_data_out
+    end
+
+
+    # 
+    # Re-estimate distribution parameters by generating simulated data a number 
+    # of times and performing the iterative estimation in MLRatioSolve
+    # @param  n_gen [Numeric] number of datasets to simulate
+    # @param  parameters [Hash] A hash containing the parameters from the estimation run on the simulated data.
+    # @param  x [NMatrix] The original experimental data
+    # @param  n_iter [Numeric] max number of iterations per estimate
+    # @param  tol=nil [Numeric] if non-nil, the iterations will terminate early 
+    #   if the absolute change in the likelihood between two successive 
+    #   iterations is less than this
+    # 
+    # @return [Array] An array containing n_gen hashes, each of which is the 
+    #   result of the estimation run on one simulated dataset.
+    def estimate_with_gen_data(n_gen, parameters, x, n_iter, tol=nil)
+      result = Array.new(n_gen) { nil }
+      n_gen.times do |i|
+        xi = gen_data(parameters, x)
+        result[i] = MLRatioSolve.do_iters_with_start(n_iter, xi, parameters[:gamma], tol)
+      end
+      result
+    end
+
+
+    # 
+    # Calculate a bootstrapped confidence interval from the output of 
+    # #estimate_with_gen_data.
+    # @param  results [Array] An array of hashes as output from 
+    #   #estimate_with_gen_data
+    # @param  level [Float] A number between 0 and 1 that is the level of the 
+    #   confidence interval.  For instance, a value of 0.95 will lead to 
+    #   calculation of the bounds on the central 95% of values.
+    # 
+    # @return [Array] an array of two NMatrix objects, the lower bound on the   
+    #   CI and the upper bound on the CI
+    def bootstrap_ci(results, level)
+      means = results.map { |e| e[:mu].to_a }
+      means = N[*means]
+      size_i = means.shape[1]
+      size_sim = means.shape[0]
+      ci_lower = N.new([size_i], 0.0)
+      ci_upper = N.zeros_like(ci_lower)
+      size_i.times do |i|
+        means_i = means[0...size_sim, i].to_a
+        means_i.flatten!
+        means_i = means_i.select { |e| e.finite? }
+        means_i.sort!
+        lower_ci_index = ((1.0-level)/2.0 * means_i.length).ceil
+        upper_ci_index = ((1.0 - (1.0-level)/2.0) * means_i.length).floor
+        ci_lower[i] = means_i[lower_ci_index]
+        ci_upper[i] = means_i[upper_ci_index]
+      end
+      [ci_lower, ci_upper]
+    end
+
+  end
+end

data/lib/ml_ratiosolve/ml_ratiosolve.rb

@@ -0,0 +1,563 @@
+#--
+# ml_ratiosolve.rb
+# Copyright (c) 2013 Colin J. Fuller
+# 
+# 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.
+#++
+
+require 'csv'
+
+require 'nmatrix'
+# 
+# Functions for ML estimates of distribution parameters for ratios of Gaussian
+# measurements.
+# 
+# This module aims to deal with the case where one needs to average 
+# measurements that are made relative to an internal control, such that each 
+# measurement to be averaged is the ratio of two Gaussian-distributed 
+# variables, which is not itself Gaussian-distributed.
+# 
+# Each independent experiment is assumed to consist of I treatments, and there
+# are N total experiments.  Each measurement x_{i,n} is assumed to be a Gaussian
+# random variable with mean mu_i/gamma_n and variance s2_i/gamma_n. Each mu and
+# s2 parameter depends only on the treatment and not the experiment number,
+# whereas the scale factors gamma depend only on the experiment and not the
+# treatment.
+# 
+# This is a more general case of the ratio-to-internal-control problem, and the
+# latter is simply the case where the gamma_n are each set to the value of the
+# internal control for experiment n.
+# 
+# @author Colin J. Fuller
+# 
+module MLRatioSolve
+  class << self
+
+    # 
+    # The normal probability distribution.
+    # @param  x [Numeric] The point at which to calculate the probability density
+    # @param  m [Numeric] The mean of the distribution
+    # @param  s2 [Numeric] The variance of the distribution
+    # 
+    # @return [Float] The probability density at the specified point
+    def normpdf(x, m, s2)
+      1.0/Math.sqrt(2*Math::PI*s2)*Math.exp(-(x-m)**2/(2.0*s2))
+    end
+
+    # 
+    # Sets up the array of indices to skip from a string.
+    # @param  skip_str [String] A string containing treatment, experiment index 
+    #   pairs.  Pairs should have a comma internally and a colon between 
+    #   successive pairs.  E.g. '1,2;0,1'
+    # 
+    # @return [void]
+    def set_skip_indices(skip_str)
+      if skip_str.empty?
+        @skip_indices = []
+      else
+        skip_pairs = skip_str.split(":")
+        skip_pairs.map! { |e| e.split(',').map { |ee| ee.to_i } }
+        @skip_indices = skip_pairs
+      end
+    end
+
+    # 
+    # Gets and returns the list of (treatment, experiment) pairs to skip due to
+    # missing data
+    # 
+    # @return [Array] An array of two element arrays containing treatment index,
+    #     experiment index ordered pairs
+    def skip_indices
+      @skip_indices
+    end
+
+    # 
+    # The log likelihood function for the datapoints given a set of distribution
+    # parameters.
+    # @param  gamma [NMatrix] The per-experiment scale factors (column vector 
+    #   with N elements)
+    # @param  x [NMatrix] The data points, an IxN matrix.
+    # @param  mu [NMatrix] The mean parameters for each treatment (column 
+    #   vector with I elements)
+    # @param  sig2 [NMatrix] The variance parameters for each treatment (column 
+    #   vector with I elements)
+    # 
+    # @return [Float] The log likelihood of the data given the parameters
+    def log_l_fct(gamma, x, mu, sig2)
+      ltot = 0
+      i = mu.size
+      n = gamma.size
+      i.times do |ii|
+        n.times do |nn|
+          next if skip_indices.include? [ii,nn]
+          ltot += Math.log(normpdf(x[ii,nn], mu[ii]/gamma[nn], sig2[ii]/gamma[nn]**2))
+        end
+      end
+      ltot
+    end
+
+
+    #
+    # Given the per-experiment scale factors, calculate the ML estimate of the 
+    # mean parameters
+    # @param  gamma [NMatrix] The per-experiment scale factors (column vector 
+    #   with N elements)
+    # @param  x [NMatrix] The data points, an IxN matrix.
+    # 
+    # @return [NMatrix] The ML estimates of the mean parameters (column vector
+    #   with I elements)
+    def calculate_mu_i(gamma, x)
+      n = gamma.size
+      i = x.shape[0]
+      mu = NMatrix.zeros([i,1], stype: :dense)
+      if skip_indices.empty? then
+        mu = x.dot(gamma) / n
+      else
+        i.times do |ii|
+          count = 0
+          n.times do |nn|
+            next if skip_indices.include? [ii,nn]
+            mu[ii] += gamma[nn]*x[ii,nn]
+            count += 1
+          end
+          mu[ii] /= count
+        end
+      end
+
+      mu
+    end
+
+
+    # 
+    # Given the per-experiment scale factors, calculate the ML estimate of the 
+    # variance parameters
+    # @param  gamma [NMatrix] The per-experiment scale factors (column vector 
+    #   with N elements)
+    # @param  x [NMatrix] The data points, an IxN matrix.
+    # @param  mu [NMatrix] The precalculated ML estimates of the mean 
+    #   parameters for the provided gamma (column vector with I elements)
+    # 
+    # @return [NMatrix] The ML estimates of the variance parameters (column 
+    #   vector with I elements)
+    def calculate_sig2_i(gamma, x, mu)
+      n = gamma.size
+      i = mu.size
+      sig2 = NMatrix.zeros([i,1], stype: :dense)
+      
+      i.times do |ii|
+        count = 0
+        n.times do |nn|
+          next if skip_indices.include? [ii,nn]
+          sig2[ii] += (gamma[nn]*x[ii,nn] - mu[ii])**2
+          count += 1
+        end
+        sig2[ii] /= count
+        if sig2[ii] < Float::EPSILON**2 then
+          sig2[ii] = Float::EPSILON**2
+        end
+      end
+
+      sig2
+    end
+
+    #
+    # Given the mean and variance parameters, calculate the ML estimate of a
+    # single experimental scale factor.
+    # 
+    # @param nn [Integer] the index of the scale factor to calculate.
+    # @see #calculate_gamma_n
+    # 
+    # @return [Numeric] The ML estimate for the scale factor.
+    # 
+    def calculate_single_gamma(nn, x, mu, sig2)
+      xm_over_s2 = 0
+      x2_over_s2 = 0
+      i = x.shape[0]
+      i.times do |ii|
+        next if skip_indices.include? [ii,nn]
+        xm_over_s2 += x[ii,nn]*mu[ii]/sig2[ii]
+        x2_over_s2 += x[ii,nn]**2/sig2[ii]
+      end
+      (xm_over_s2 + Math.sqrt(xm_over_s2**2 + 4*i*x2_over_s2))/(2*x2_over_s2)
+    end
+
+    # 
+    # Given the mean and variance parameters, calculate the ML estimate of the 
+    # experimental scale factors
+    # @param  x [NMatrix] The data points, an IxN matrix.
+    # @param  mu [NMatrix] The mean parameters (column vector with I elements)
+    # @param  sig2 [NMatrix] The variance parameters (column vector with I 
+    #   elements)
+    # 
+    # @return [NMatrix] The ML estimates of the per-expeirment scale factors (  
+    #   column vector with N elements)
+    def calculate_gamma_n(x, mu, sig2)
+      n = x.shape[1]
+      i = mu.size
+      gamma = NMatrix.zeros([n,1], stype: :dense)
+      0.upto(n-1) do |nn|
+        gamma[nn] = calculate_single_gamma(nn, x, mu, sig2)
+      end
+      gamma = gamma/gamma[0] #effectively set the units to be those of the first experiment
+      gamma
+    end
+
+
+    # 
+    # Nicely prints the supplied distribution parameters
+    # @param  mu [NMatrix] the mean parameters (column vector with I elements)
+    # @param  sig2 [NMatrix] the variance parameters (column vector with I 
+    #   elements)
+    # @param  gamma [NMatrix] the per-experiment scale factors (column vector 
+    #   with N elements)
+    # @param  x [NMatrix] the experimental data (IxN matrix)
+    # @param  iternum [NMatrix] the index of the current iteration
+    # 
+    # @return [void]
+    def print_parameters(mu, sig2, gamma, x, iternum)
+      puts "="*10
+      puts "At iteration number #{iternum}:"
+      puts "mu = #{mu.to_s}"
+      puts "sig = #{sig2.map{ |e| Math.sqrt e }.to_s}"
+      puts "gamma = #{gamma.to_s}"
+      puts "Log likelihood = #{log_l_fct(gamma, x, mu, sig2)}"
+      nil
+    end
+
+
+    # 
+    # Does one iteration of estimation, taking a starting gamma, calculating mu 
+    # and s2, and then recalculating gamma from these
+    # @param  gamma_in [NMatrix] the per-experiment scale factors (column 
+    #   vector with N elements)
+    # @param  x [NMatrix] the experimental data (IxN matrix)
+    # @param  iternum [NMatrix] the index of the current iteration
+    # 
+    # @return [NMatrix] the new estimates of the per-experiment scale factors (
+    #   column vector with N elements)
+    def do_single_iteration(gamma_in, x, iternum)
+      mu = calculate_mu_i(gamma_in, x)
+      sig2 = calculate_sig2_i(gamma_in,x,mu)
+      gamma_out = calculate_gamma_n(x, mu, sig2)
+      #print_parameters(mu, sig2, gamma_out, x, iternum)
+      gamma_out
+    end
+
+    # 
+    # Do a series of iterations of estimation from a supplied starting estimate.
+    # @param  n_iter [Numeric] The maximum number of iterations to perform.
+    # @param  x [NMatrix] the experimental data (IxN matrix)
+    # @param  gamma_start [NMatrix] the initial guess for the gamma 
+    #   experimental scale factors (column vector with N elements)
+    # @param  tol=nil [Numeric] if non-nil, the iterations will terminate early 
+    #   if the absolute change in the likelihood between two successive 
+    #   iterations is less than this
+    # 
+    # @return [Hash] the results of the iteration, containing keys for mu, sig2,
+    #   gamma, and l, which are the mean, variance, scale factors, and
+    #   likelihood, respectively, after iteration completed
+    def do_iters_with_start(n_iter, x, gamma_start, tol=nil, debug=false)
+      gamma = gamma_start
+      last_L = -1.0*Float::MAX
+      n_iter.times do |it|
+        gamma_candidate = do_single_iteration(gamma, x, it)
+        m = calculate_mu_i(gamma_candidate,x)
+        l = log_l_fct(gamma_candidate, x, m, calculate_sig2_i(gamma_candidate, x, m))
+        if (tol and (l-last_L).abs < tol) or gamma_candidate.to_a.flatten.any?{ |e| not e.finite? } then
+          break
+        end
+        gamma = gamma_candidate
+        last_L = l
+      end
+      {mu: calculate_mu_i(gamma, x), sig2: calculate_sig2_i(gamma, x, calculate_mu_i(gamma, x)),
+        gamma: gamma, l: log_l_fct(gamma, x, calculate_mu_i(gamma,x), calculate_sig2_i(gamma, x, calculate_mu_i(gamma,x)))}
+    end
+
+    #
+    # Estimates the mean given that one treatment is fixed at ~ zero variance.
+    # 
+    # @param x [NMatrix] the experimental data (IxN matrix)
+    # @param i_zero [Integer] the index of the zero variance treatment
+    # @param mi [Numeric] the mean for the zero variance treatment
+    # @param perm [Array] a permutation array mapping the permuted data
+    #   indices to their original indices (non-lapack format, see
+    #   #invert_permutation_matrix)
+    #
+    # @return [NMatrix] the estimate of the means (Ix1)
+    #
+    def m_est_zerovar(x,i_zero,mi,perm)
+      n = x.shape[1]
+      i = x.shape[0]
+      m = N.zeros([i,1], dtype: x.dtype, stype: :dense)
+      i.times do |ii|
+        count = 0
+        n.times do |nn|
+          next if skip_indices.include? [ii,perm[nn]] or skip_indices.include? [i_zero, perm[nn]]
+          m[ii] += mi*x[ii,nn]/x[i_zero,nn]
+          count += 1
+        end
+        m[ii] /= count
+      end
+      m
+    end
+
+    #
+    # Estimates the variances given that one treatment is fixed at ~ zero
+    # variance.
+    #
+    # @param x [NMatrix] the experimental data (IxN matrix)
+    # @param i_zero [Integer] the index of the zero variance treatment
+    # @param m [NMatrix] the mean estimates (as output by #m_est_zerovar)
+    # @param perm [Array] a permutation array mapping the permuted data indices
+    #   to their original indices (non-lapack format, see
+    #   #invert_permutation_matrix)
+    # 
+    # @return [NMatrix] the estimate of the variances (Ix1)
+    #
+    def s2_est_zerovar(x, i_zero, m, perm)
+      n = x.shape[1]
+      i = x.shape[0]
+      s2_est = N.zeros([i,1], dtype: x.dtype, stype: :dense)
+      i.times do |ii|
+        count = 0
+        n.times do |nn|
+          next if skip_indices.include? [ii,perm[nn]] or skip_indices.include? [i_zero, perm[nn]]
+          s2_est[ii] += (x[ii,nn]*m[i_zero]/x[i_zero,nn]-m[ii])**2
+          count += 1
+        end
+        s2_est[ii]/= count
+      end
+      s2_est
+    end
+
+    #
+    # Inverts a permutation so that it maps permuted data back to the original
+    # data.
+    #
+    # @param perm [Array] the permutation to invert. (Not lapack format but
+    # where perm[i] = j indicates that in the final permuted matrix column j is
+    # the original column i.
+    #
+    # @return [Array] the inverted permutation.
+    #
+    def invert_permutation_matrix(perm)
+      inv_perm = Array.new(perm.size, 0)
+      perm.each_with_index do |e, i|
+        inv_perm[e] = i
+      end
+      inv_perm
+    end
+
+    #
+    # Permute the rows of a matrix (using a transpose and permute_columns
+    # method).
+    #
+    # @param m [NMatrix] the matrix to permute
+    # @param perm [Array] the permutation (in lapack format)
+    #
+    # @return [NMatrix] the permuted data matrix
+    #
+    def permute_rows(m, perm)
+      m.transpose.permute_columns(perm).transpose
+    end
+
+    #
+    # Find a permutation of experiments such that the ith treatment is not skipped in the
+    # first experiment after the permutation.
+    #
+    # @param x [NMatrix] the experimental data
+    # @param i [Integer] the index of the treatment to make sure is not skipped
+    #   in the first experiment
+    #
+    # @return [Array] an array containing two elements: a permuation array in
+    # each of lapack and non-lapack formats.  (See #invert_permutation_matrix
+    # for non-lapack format.)
+    #
+    def find_permutation_nonskip(x, i)
+      n = x.shape[1]
+      lapack_perm = Array.new(n) { |nn| nn }
+      full_perm = Array.new(n) { |nn| nn }
+      first = 0
+      n.times do |nn|
+        first = nn
+        break unless skip_indices.include? [i,nn]
+      end
+      lapack_perm[0] = first
+      full_perm[0] = first
+      full_perm[first] = 0
+      [lapack_perm, full_perm]
+    end
+
+    #
+    # Test a single low variance solution.
+    # 
+    # @param ii [Integer] the index of the low variance treatment.
+    # @see #test_all_low_variance_solutions
+    # 
+    def test_single_low_variance_solution(ii, n_iter, x, tol=nil)
+      lapack_perm, full_perm = find_permutation_nonskip(x, ii)
+      inv_perm = invert_permutation_matrix(full_perm)
+      x_old = x
+      x = x.permute_columns(lapack_perm)
+
+      m_est = m_est_zerovar(x, ii, x[ii,0], inv_perm)
+      s2_est = s2_est_zerovar(x, ii, m_est, inv_perm)
+      s2_est[ii] = 1.0e-16
+      
+      x = x_old
+
+      gamma_start = calculate_gamma_n(x, m_est, s2_est)
+      do_iters_with_start(n_iter, x, gamma_start, tol)
+    end
+
+
+    #
+    # Test all solutions where the variance of one treatment is ~ zero.
+    #
+    # @param n_iter [Integer] the number of iterations to run starting from the
+    #   low variance solution.
+    # @param x [NMatrix] the experimental data (IxN)
+    # @param tol [Numeric] if non-nil, the iterations will terminate early 
+    #   if the absolute change in the likelihood between two successive 
+    #   iterations is less than this
+    # 
+    # @return [Hash] the maximum likelihood solution from those tested. 
+    #   (see #do_iters_with_start for format)
+    #
+    def test_all_low_variance_solutions(n_iter, x, tol=nil)
+      n = x.shape[1]
+      i = x.shape[0]
+      best = {l: -1.0*Float::MAX}
+      i.times do |ii|
+        result = test_single_low_variance_solution(ii, n_iter, x, tol)
+        if result[:l] > best[:l] then
+          best = result
+        end
+      end
+      best
+    end
+
+    # 
+    # Successively yields points on an n-dimensional grid.
+    # @param  max_depth [Integer] The number of dimensions.
+    # @param  n_per [Integer] The number of points on the grid in each dimension.
+    # @param  min [Float] The minimum value of gridded points.
+    # @param  max [Float] The maximum value of gridded points.
+    # @param  curr [Array] The current points in progress of being built.  
+    #   This should be an array of max_depth elements.  Contents will be  
+    #   overwritten.
+    # @param  i [Integer] The current dimension.  Supply 0 initially.
+    # 
+    # @return [void]
+    def grid_recursive(max_depth, n_per, min, max, curr, i, &b)
+      if i == max_depth then
+        yield curr
+        return
+      end
+      step = (max-min)/(n_per-1)
+      min.step(max, step) do |val|
+        curr[i] = val
+        grid_recursive(max_depth, n_per, min, max, curr, i+1, &b)
+      end
+      nil
+    end
+
+    # 
+    # Runs iterations of estimation from starting guesses arrayed on a grid.
+    # @param  n_starts [Numeric] Total number of guesses to generate
+    # @param  n_gen [Integer] Number of dimensions
+    # @param  n_iter [Integer] Maximum number of iterations to run per guess
+    # @param  x [NMatrix] The datapoints (IxN matrix)
+    # @param  tol=nil [Numeric] if non-nil, the iterations will terminate early 
+    #   if the absolute change in the likelihood between two successive 
+    #   iterations is less than this
+    # 
+    # @return [Hash] The result with the maximum likelihood among those found (
+    #   see #do_iters_with_start for format)
+    def grid_multiple_iters(n_starts, n_gen, n_iter, x, tol=nil)
+      n_per = (n_starts**(1.0/n_gen)).floor
+      min_range = 0.01
+      max_range = 5.0
+
+      best = {l: -1.0*Float::MAX}
+      counter = 0
+
+      grid_recursive(n_gen, n_per, min_range, max_range, Array.new(n_gen, 0.0), 0) do |gamma|
+        result = do_iters_with_start(n_iter, x, N.new([gamma.size + 1,1],([1.0].concat(gamma))), tol)
+        if result[:l] > best[:l] then
+          best = result
+        end
+        counter += 1
+        if best[:mu] then
+          puts "Best solution found so far:"
+          print_parameters(best[:mu], best[:sig2], best[:gamma], x, counter)
+        end
+      end
+      best_lv = test_all_low_variance_solutions(n_iter, x, tol)
+      if best_lv[:l] > best[:l] then
+        best = best_lv
+      end
+      best
+    end
+
+
+    # 
+    # Estimates the SEM for each treatment after normalization.
+    # @param  result [Hash] The results hash as output by #do_iters_with_start
+    # @param  norm_index [Integer] the index of the treatment to which to normalize
+    # 
+    # @return [NMatrix] The SEM estimates for each treatment (vector with I components)
+    def ml_sem_estimate(result, norm_index)
+      ni_skip_count = 0
+      n = result[:gamma].size
+      skip_indices.each do |si|
+        if si[0] == norm_index then
+          ni_skip_count += 1
+        end
+      end   
+      prop_errors = result[:sig2].map.with_index do |e,i| 
+        skip_count = 0
+        skip_indices.each do |si|
+          if si[0] == i then
+            skip_count += 1
+          end
+        end
+        sem2_i = e/(n-skip_count-1)
+        sem2_norm = result[:sig2][norm_index]/(n-ni_skip_count-1)   
+        sem2_i*1.0/result[:mu][norm_index]**2 + sem2_norm*(result[:mu][i]/result[:mu][norm_index]**2)**2
+      end
+      prop_errors.map { |e| Math.sqrt(e) }
+    end
+
+
+    # 
+    # Reads the datapoints from a csv file.  Data should be arranged with 
+    # columns as independent experiments and rows as treatments.
+    # @param  fn [String] The filename from which to read the data.
+    # 
+    # @return [NMatrix] an IxN nmatrix containing the experimental data
+    def read_data_from_file(fn)
+      N[*(CSV.read(fn).map{ |e| e.map{ |i| i.to_f } })]
+    end
+  end
+end
+
+
+
+

data/lib/ml_ratiosolve/version.rb

@@ -0,0 +1,3 @@
+module MlRatiosolve
+  VERSION = "1.0.0"
+end

data/lib/ml_ratiosolve.rb

@@ -0,0 +1,62 @@
+#--
+# ml_ratiosolve.rb
+# Copyright (c) 2013 Colin J. Fuller
+# 
+# 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.
+#++
+
+require "ml_ratiosolve/version"
+require 'ml_ratiosolve/ml_ratiosolve'
+require 'ml_ratiosolve/error_bootstrapping'
+
+module MLRatioSolveBin
+
+  def self.go(opts)
+    n_starts = opts[:n_starts]
+    n_iter = opts[:n_iter]
+    n_for_bootstrap = opts[:n_bootstrap]
+    tol = opts[:tol]
+    ci_level = opts[:ci_level]
+    norm_index = opts[:norm_index]
+
+    MLRatioSolve.set_skip_indices(opts[:skip])
+
+    x = MLRatioSolve.read_data_from_file(opts[:file])
+
+    n_gammas_to_fit = x.shape[1] - 1
+
+    best = MLRatioSolve.grid_multiple_iters(n_starts, n_gammas_to_fit, n_iter, x, tol)
+
+    puts "Best solution found: "
+    puts "mu: #{best[:mu]/best[:mu][norm_index]}"
+    puts "sig: #{best[:sig2].map{ |e| Math.sqrt(e)/best[:mu][norm_index] }.to_s}"
+    puts "gamma: #{best[:gamma]}"
+    puts "log l: #{best[:l]}"
+
+    puts "Error estimate:"
+    puts MLRatioSolve.ml_sem_estimate(best, norm_index)
+
+    #sim_results = ErrorBootstrapping.estimate_with_gen_data(n_for_bootstrap, best, x, n_iter, tol)
+    #ci_lower, ci_upper = ErrorBootstrapping.bootstrap_ci(sim_results, ci_level)
+    # puts "boostrapped #{ci_level*100}% confidence interval: "
+    # puts ci_lower.to_a.join(", ")
+    # puts ci_upper.to_a.join(", ")
+  end
+
+end

data/ml_ratiosolve.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ml_ratiosolve/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ml_ratiosolve"
+  spec.version       = MlRatiosolve::VERSION
+  spec.authors       = ["Colin J. Fuller"]
+  spec.email         = ["cjfuller@gmail.com"]
+  spec.description   = %q{Methods for using maximum likelihood calculations to estimate parmeters of ratios of gaussian variates}
+  spec.summary       = %q{Methods for using maximum likelihood calculations to estimate parmeters of ratios of gaussian variates}
+  spec.homepage      = "https://github.com/cjfuller/ml_ratiosolve"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "trollop", "~> 2.0"
+  spec.add_dependency "nmatrix", "~> 0.1"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/error_bootstrapping_spec.rb

@@ -0,0 +1,51 @@
+#--
+# error_bootstrapping_spec.rb
+# Copyright (c) 2013 Colin J. Fuller
+# 
+# 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.
+#++
+
+require 'ml_ratiosolve'
+
+describe ErrorBootstrapping do 
+
+  it "should generate random variables with the correct mean" do 
+    ErrorBootstrapping.randnorm(10, 0).should eq 10.0
+  end
+
+  it "should generate random variables with reasonable statitstics" do
+    vars = Array.new(100) { ErrorBootstrapping.randnorm(0, 1) }
+    N[*vars].mean.to_f.abs.should < 0.4
+    (N[*vars].std.to_f - 1).abs.should < 0.4
+  end
+
+  context "data generation" do
+    it "should generate a data matrix of the correct shape" do
+      MLRatioSolve.set_skip_indices ""
+      gamma = N.new([2,1],[1.0, 0.5])
+      mu = N.new([2,1], [0.0, 2.0])
+      sig2 = N.new([2,1], [1.0, 16.0])
+      x = N.new([2,2], [0.0, 0.0, 2.0, 2.0])
+
+      x_gen = ErrorBootstrapping.gen_data({mu: mu, sig2: sig2, gamma: gamma}, x)
+      x_gen.shape.should eq [2,2]
+    end
+  end
+end
+

data/spec/ml_ratiosolve_spec.rb

@@ -0,0 +1,147 @@
+#--
+# ml_ratiosolve_spec.rb
+# Copyright (c) 2013 Colin J. Fuller
+# 
+# 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.
+#++
+
+require 'ml_ratiosolve'
+
+describe MLRatioSolve do
+
+  before :each do
+    MLRatioSolve.set_skip_indices ""
+  end
+
+  it "should calculate a normal PDF" do
+    MLRatioSolve.normpdf(0, 0, 1).should be_within(1.0e-6).of 0.3989423
+  end
+
+  it "should set and retrieve skip indices" do
+    MLRatioSolve.set_skip_indices("0,1:0,2")
+    MLRatioSolve.skip_indices.should eq [[0,1],[0,2]]
+  end
+
+  it "should calculate the log likelihood" do
+    gamma = N.new([2,1],[1.0, 0.5])
+    mu = N.new([2,1], [0.0, 2.0])
+    sig2 = N.new([2,1], [1.0, 16.0])
+    x = N.new([2,2], [0.0, 0.0, 2.0, 2.0])
+    expected = N[Math.log(0.199471140200716),
+                Math.log(0.398942280401433),
+                Math.log(0.0997355701003582),
+                Math.log(0.0483335146003562)].sum.to_f
+    MLRatioSolve.log_l_fct(gamma, x, mu, sig2).should be_within(1.0e-6).of expected
+  
+  end
+
+  it "should calculate the ML mean estimate with uniform gamma" do
+    x = N.new([1,3], [0,3,6], dtype: :float64)
+    g = N.new([3,1], [1,1,1], dtype: :float64)
+    result = MLRatioSolve.calculate_mu_i(g,x)
+    result.shape.should eq [1,1]
+    result[0].should eq 3.0
+  end
+
+  it "should calculate the ML mean estimate with nonuniform gamma" do
+    x = N.new([1,2], [1,2], dtype: :float64)
+    g = N.new([2,1], [4,1], dtype: :float64)
+    result = MLRatioSolve.calculate_mu_i(g,x)
+    result.shape.should eq [1,1]
+    result[0].should eq 3.0
+  end
+
+  it "should calculate the ML variance estimate" do
+    x = N.new([1,3], [0,3,6], dtype: :float64)
+    g = N.new([3,1], [1,2,1], dtype: :float64)
+    result = MLRatioSolve.calculate_sig2_i(g,x, MLRatioSolve.calculate_mu_i(g,x))
+    result.shape.should eq [1,1]
+    result[0].should eq N[0,6,6].variance.to_f*(2.0/3.0) #final fraction is to correct sample vs. population
+  end
+
+  it "should calculate a single gamma for fixed mean and standard deviation parameters" do
+    mu = N.new([2,1], [0.0, 2.0])
+    sig2 = N.new([2,1], [1.0, 16.0])
+    x = N.new([2,2], [0.0, 0.0, 2.0, 2.0])
+    MLRatioSolve.calculate_single_gamma(0, x, mu, sig2).should be_within(1.0e-6).of 3.3722813
+  end
+
+  it "should correctly normalize the set of gammas" do
+    mu = N.new([2,1], [0.0, 2.0])
+    sig2 = N.new([2,1], [1.0, 16.0])
+    x = N.new([2,2], [0.0, 0.0, 2.0, 2.0])
+    result = MLRatioSolve.calculate_gamma_n(x, mu, sig2)
+    g0 = MLRatioSolve.calculate_single_gamma(0,x,mu,sig2)
+    g1 = MLRatioSolve.calculate_single_gamma(1,x,mu,sig2)
+
+    result.should eq N[[g0],[g1]]/g0
+  end
+
+  it "should perform a single iteration" do
+    gamma = N.new([3,1], [1,2,1], dtype: :float64)
+    x = N.new([2,3], [0,3,6,1,4,7], dtype: :float64)
+    m = MLRatioSolve.calculate_mu_i(gamma,x)
+    s2= MLRatioSolve.calculate_sig2_i(gamma, x, m)
+    gamma_new = MLRatioSolve.calculate_gamma_n(x, m, s2)
+    MLRatioSolve.do_single_iteration(gamma, x, 0).should eq gamma_new  
+  end
+
+  context "grid search" do
+    it "should grid the correct number of iterations" do
+      count = 0
+      MLRatioSolve.grid_recursive(4, 5, 0.0, 1.0, [0.0, 0.0, 0.0, 0.0], 0) do 
+        count += 1
+      end
+      count.should eq 5**4
+    end
+
+  end
+
+  context "low variance solution search" do
+
+    it "should calculate the starting means for the low variance case" do
+      x = N.new([2,2], [5.0, 1.0, 2.0, 3.0])
+      me = MLRatioSolve.m_est_zerovar(x, 0, x[0,0], [0,1])
+      me.should eq N.new([2,1], [5.0, 8.5])
+    end
+
+    it "should calculate the starting variances for the low variance case" do
+      x = N.new([2,2], [5.0, 1.0, 2.0, 3.0])
+      se = MLRatioSolve.s2_est_zerovar(x, 0, MLRatioSolve.m_est_zerovar(x, 0, x[0,0], [0,1]), [0,1])
+      se.should eq N.new([2,1], [0.0, 42.25])
+    end
+
+    it "should find a permutation such that the 0th entry of a given low variance treatment is not skipped" do
+      x = N.new([2,2], [0,1,2,3])
+      MLRatioSolve.set_skip_indices "0,0"
+      MLRatioSolve.find_permutation_nonskip(x, 0).should eq [[1,1], [1,0]]
+    end
+
+    it "should be able to invert a permutation matrix" do
+      MLRatioSolve.invert_permutation_matrix([0,2,3,1]).should eq [0,3,1,2]
+    end
+
+    it "should be able to permute rows of a matrix" do
+      m = N.new([2,2], [0,1,2,3])
+      MLRatioSolve.permute_rows(m, [1,1]).should eq N.new([2,2], [2,3,0,1])
+    end
+
+  end
+end
+

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: ml_ratiosolve
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Colin J. Fuller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: nmatrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Methods for using maximum likelihood calculations to estimate parmeters
+  of ratios of gaussian variates
+email:
+- cjfuller@gmail.com
+executables:
+- ml_ratiosolve
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/ml_ratiosolve
+- lib/ml_ratiosolve.rb
+- lib/ml_ratiosolve/error_bootstrapping.rb
+- lib/ml_ratiosolve/ml_ratiosolve.rb
+- lib/ml_ratiosolve/version.rb
+- ml_ratiosolve.gemspec
+- spec/error_bootstrapping_spec.rb
+- spec/ml_ratiosolve_spec.rb
+homepage: https://github.com/cjfuller/ml_ratiosolve
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Methods for using maximum likelihood calculations to estimate parmeters of
+  ratios of gaussian variates
+test_files:
+- spec/error_bootstrapping_spec.rb
+- spec/ml_ratiosolve_spec.rb