plot_statistics 1.3.0 → 1.4.0

data/VERSION

@@ -1 +1 @@
-1.3.0
+1.4.0

data/bin/bivariate_ripleys_k

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'plot_statistics'
+rescue LoadError
+  require 'rubygems'
+  gem     'plot_statistics'
+  require 'plot_statistics'
+end
+
+ARGV.each do |filename|
+  filename = "../High Aggregated Plot 1.txt"
+  file = File.new(filename)
+  lines = file.readlines
+  file.close
+
+  puts "Analyzing #{filename}"
+  printf "Importing Clams"
+  live_clams = []
+  dead_clams = []
+  lines.each do |line|
+    line = line.strip.split("\t")
+    next if line.empty?
+    x, y, number_eaten = line
+    (5 - number_eaten).times { printf "."; live_clams << PlotStatistics::Clam.new(:x => x, :y => y) }
+    number_eaten.to_i.times { printf "."; dead_clams << PlotStatistics::Clam.new(:x => x, :y => y) }
+  end.compact
+
+  puts "Running Ripley's K analysis of plot"
+  actual_plot = PlotStatistics::ClamPlot.new(live_clams, dead_clams).bivariate_analysis
+
+  puts "Running Monte Carlo Simulations of plot"
+  monte_carlo = PlotStatistics::MonteCarlo.new_bivariate(actual_plot).bivariate_analysis
+
+  output_filename = filename + '.ripleys_k.csv'
+  PlotStatistics::Output.new(:clam_plot => actual_plot, :monte_carlo => monte_carlo).to_bivariate_file(output_filename)
+
+  puts "Done™"
+end

data/bin/{plot_statistics → univariate_ripleys_k}

@@ -9,6 +9,7 @@ rescue LoadError
 end
 
 ARGV.each do |filename|
+  filename = "../Clam distributions/Cabbage/Cabbage_3.txt"
   file = File.new(filename)
   lines = file.readlines
   file.close
@@ -24,13 +25,13 @@ ARGV.each do |filename|
   end.compact
 
   puts "Running Ripley's K analysis of plot"
-  actual_plot = PlotStatistics::ClamPlot.new(clams)
+  actual_plot = PlotStatistics::ClamPlot.new(clams).univariate_analysis
 
   puts "Running Monte Carlo Simulations of plot"
-  monte_carlo = PlotStatistics::MonteCarlo.new(actual_plot.number_of_clams)
+  monte_carlo = PlotStatistics::MonteCarlo.new_univariate(actual_plot.number_of_clams).univariate_analysis
 
   output_filename = filename + '.ripleys_k.csv'
-  PlotStatistics::Output.new(:clam_plot => actual_plot, :monte_carlo => monte_carlo).write_to_file(output_filename)
+  PlotStatistics::Output.new(:clam_plot => actual_plot, :monte_carlo => monte_carlo).to_univariate_file(output_filename)
 
   puts "Done™"
 end

data/lib/plot_statistics/clam.rb

@@ -16,5 +16,9 @@ class PlotStatistics
       return super(other) unless other.kind_of?(PlotStatistics::Clam)
       self.x == other.x && self.y == other.y
     end
+
+    def reset_distances
+      distances.clear
+    end
   end
 end

data/lib/plot_statistics/clam_plot.rb

@@ -1,16 +1,29 @@
 class PlotStatistics
   class ClamPlot
-    attr_accessor :clams, :stats
+    attr_accessor :clams, :dead_clams, :stats
 
     AREA_OF_PLOT  = 10_000
     MAX_RADIUS    = 50
     PLOT_CORNERS = [[0,0], [0,100], [100,0], [100,100]]
 
-    def initialize(clams)
+    def initialize(clams, dead_clams=[])
       @clams = clams
-      setup_clam_distances(@clams)
-      @stats = OpenStruct.new(:k_ts => [], :l_ts => [])
-      calculate_stats
+      @dead_clams = dead_clams
+    end
+
+    def univariate_analysis
+      self.stats = OpenStruct.new(:k_ts => [], :l_ts => [])
+      setup_clam_distances
+      calculate_univariate_stats
+      self
+    end
+
+    def bivariate_analysis
+      self.stats = OpenStruct.new(:k_ts => [], :dead_k_ts => [], :l_ts => [])
+      setup_clam_distances
+      setup_clam_distances(:dead_clams)
+      calculate_bivariate_stats
+      self
     end
 
     def self.create_random(number_of_clams)
@@ -29,20 +42,29 @@ class PlotStatistics
       (0..100).each do |x|
         (0..100).each do |y|
           mod_x = x % distance
-          mod_y = x % distance
+          mod_y = y % distance
           clams << Clam.new(:x => x, :y => y) if mod_x == 0 && mod_y == 0
         end
       end
       new(clams)
     end
 
+    def self.create_random_from(clam_plot)
+      number_dead = clam_plot.dead_clams.size
+      all_clams = clam_plot.dead_clams | clam_plot.clams
+      dead_clams = all_clams.shuffle.slice(0...number_dead)
+      live_clams = all_clams - dead_clams
+      new(live_clams, dead_clams)
+    end
+
     def number_of_clams
       clams.size.to_f
     end
 
-    def setup_clam_distances(clams)
-      clams.each_with_index do |reference_clam, i|
-        clams[(i + 1)..-1].each do |other_clam|
+    def setup_clam_distances(clam_type='clams')
+      reset_clam_distances
+      send(clam_type).each_with_index do |reference_clam, i|
+        send(clam_type)[(i + 1)..-1].each do |other_clam|
           distance = distance_between_clams(reference_clam, other_clam)
           reference_clam.distances << distance
           other_clam.distances << distance
@@ -54,19 +76,32 @@ class PlotStatistics
       Math.sqrt((clam1.x - clam2.x) ** 2 + (clam1.y - clam2.y) ** 2)
     end
 
-    def calculate_stats
+    def calculate_bivariate_stats
+      (1..MAX_RADIUS).each do |radius|
+
+        live_k_t = calculate_k_t(radius)
+        dead_k_t = calculate_k_t(radius, :dead_clams)
+        l_t      = calculate_bivariate_l_t(live_k_t, dead_k_t, radius)
+
+        stats.k_ts << live_k_t
+        stats.dead_k_ts << dead_k_t
+        stats.l_ts << l_t
+      end
+    end
+
+    def calculate_univariate_stats
       (1..MAX_RADIUS).each do |radius|
 
         k_t = calculate_k_t(radius)
-        l_t = calculate_l_t(k_t, radius)
+        l_t = calculate_univariate_l_t(k_t, radius)
 
         stats.k_ts << k_t
         stats.l_ts << l_t
       end
     end
 
-    def calculate_k_t(radius)
-      sums = clams.inject(0.0) do |sum, clam|
+    def calculate_k_t(radius, clam_type='clams')
+      sums = send(clam_type).inject(0.0) do |sum, clam|
         clams_inside_circle = clam.distances.select { |distance| distance <= radius }
 
         circle_proportion = Circle.new(:clam => clam, :radius => radius).proportion_inside_plot
@@ -79,8 +114,16 @@ class PlotStatistics
       AREA_OF_PLOT * sums / (number_of_clams ** 2)
     end
 
-    def calculate_l_t(k_t, radius)
+    def calculate_univariate_l_t(k_t, radius)
       radius - Math.sqrt( k_t / Math::PI)
     end
+
+    def calculate_bivariate_l_t(live_k_t, dead_k_t, radius)
+      radius - Math.sqrt( (live_k_t - dead_k_t).abs / Math::PI)
+    end
+
+    def reset_clam_distances
+      (clams | dead_clams).each { |clam| clam.reset_distances }
+    end
   end
 end

data/lib/plot_statistics/monte_carlo.rb

@@ -2,68 +2,75 @@ class PlotStatistics
   class MonteCarlo
     attr_accessor :plots, :stats
 
-    def initialize(number_of_clams, number_of_plots=100.0)
-      @plots = (1..number_of_plots).map { ClamPlot.create_random number_of_clams }
-      @stats = OpenStruct.new(:mean        => OpenStruct.new(:k_ts => [], :l_ts => []),
-                              :upper_limit => OpenStruct.new(:k_ts => [], :l_ts => []),
-                              :lower_limit => OpenStruct.new(:k_ts => [], :l_ts => []))
-      calculate_means
-      calculate_limits
+    def initialize(params={})
+      @plots = params[:plots]
     end
 
-    def calculate_means
+    def self.new_univariate(number_of_clams, number_of_plots=500.0)
+      plots = (1..number_of_plots).map { ClamPlot.create_random(number_of_clams).univariate_analysis }
+      new(:plots => plots)
+    end
+
+    def self.new_bivariate(actual_plot, number_of_plots=500.0)
+      plots = (1..number_of_plots).map { ClamPlot.create_random_from(actual_plot).bivariate_analysis }
+      new(:plots => plots)
+    end
+
+    def bivariate_analysis
+      self.stats = OpenStruct.new(:mean        => OpenStruct.new(:k_ts => [], :dead_k_ts => [], :l_ts => []),
+                                  :upper_limit => OpenStruct.new(:k_ts => [], :dead_k_ts => [], :l_ts => []),
+                                  :lower_limit => OpenStruct.new(:k_ts => [], :dead_k_ts => [], :l_ts => []))
+      calculate_means([:k_ts, :dead_k_ts, :l_ts])
+      calculate_limits([:k_ts, :dead_k_ts, :l_ts])
+      self
+    end
+
+    def univariate_analysis
+      self.stats = OpenStruct.new(:mean        => OpenStruct.new(:k_ts => [], :l_ts => []),
+                                  :upper_limit => OpenStruct.new(:k_ts => [], :l_ts => []),
+                                  :lower_limit => OpenStruct.new(:k_ts => [], :l_ts => []))
+      calculate_means([:k_ts, :l_ts])
+      calculate_limits([:k_ts, :l_ts])
+      self
+    end
+
+    def calculate_means(means_for)
       (0...ClamPlot::MAX_RADIUS).each do |radius|
-        stats.mean.k_ts << average_k(radius)
-        stats.mean.l_ts << average_l(radius)
+        means_for.each do |stat|
+          stats.mean.send(stat) << average_stat(radius, stat)
+        end
       end
     end
 
-    def calculate_limits
+    def calculate_limits(limits_for)
       (0...ClamPlot::MAX_RADIUS).each do |radius|
-        threshold_k = standard_deviation_k(radius) * 2.0
-        threshold_l = standard_deviation_l(radius) * 2.0
+        limits_for.each do |stat|
+          threshold = standard_deviation_stat(radius, stat) * 2.0
 
-        stats.upper_limit.k_ts << (stats.mean.k_ts[radius] + threshold_k)
-        stats.upper_limit.l_ts << (stats.mean.l_ts[radius] + threshold_l)
-        stats.lower_limit.k_ts << (stats.mean.k_ts[radius] - threshold_k)
-        stats.lower_limit.l_ts << (stats.mean.l_ts[radius] - threshold_l)
+          stats.upper_limit.send(stat) << (stats.mean.send(stat)[radius] + threshold)
+          stats.lower_limit.send(stat) << (stats.mean.send(stat)[radius] - threshold)
+        end
       end
     end
 
-    def standard_deviation_k(radius)
+    def standard_deviation_stat(radius, stat)
       sum = plots.inject(0.0) do |sum, plot|
-        (plot.stats.k_ts[radius] - stats.mean.k_ts[radius]) ** 2
+        (plot.stats.send(stat)[radius] - stats.mean.send(stat)[radius]) ** 2
       end
 
       Math.sqrt(sum / number_of_plots)
     end
 
-    def standard_deviation_l(radius)
+    def average_stat(radius, stat)
       sum = plots.inject(0.0) do |sum, plot|
-        (plot.stats.l_ts[radius] - stats.mean.l_ts[radius]) ** 2
+        plot.stats.send(stat)[radius]
       end
 
-      Math.sqrt(sum / number_of_plots)
+      sum / number_of_plots
     end
 
     def number_of_plots
       plots.size
     end
-
-    def average_k(radius)
-      sum = plots.inject(0.0) do |sum, plot|
-        plot.stats.k_ts[radius]
-      end
-
-      sum / number_of_plots
-    end
-
-    def average_l(radius)
-      sum = plots.inject(0.0) do |sum, plot|
-        plot.stats.l_ts[radius]
-      end
-
-      sum / number_of_plots
-    end
   end
 end

data/lib/plot_statistics/output.rb

@@ -7,7 +7,7 @@ class PlotStatistics
       @monte_carlo = params[:monte_carlo]
     end
 
-    def write_to_file(filename)
+    def to_univariate_file(filename)
       FasterCSV.open(filename, 'w') do |csv|
         csv << ['Radius', 'K(t)', 'L(t)', 'Mean K(t)', 'Mean L(t)', 'Upper K(t)', 'Lower K(t)', 'Upper L(t)', 'Lower L(t)']
 
@@ -23,5 +23,25 @@ class PlotStatistics
         end
       end
     end
+
+    def to_bivariate_file(filename)
+      FasterCSV.open(filename, 'w') do |csv|
+        csv << ['Radius', 'Live K(t)', 'Dead K(t)', 'L(t)', 'Mean Live K(t)', 'Mean Dead K(t)', 'Mean L(t)', 'Upper Live K(t)', 'Lower Live K(t)', 'Upper Dead K(t)', 'Lower Dead K(t)', 'Upper L(t)', 'Lower L(t)']
+
+        (0...ClamPlot::MAX_RADIUS).each do |position|
+          radius = position + 1
+          csv << [
+            radius,
+            clam_plot.stats.k_ts[position],                    clam_plot.stats.dead_k_ts[position],
+            clam_plot.stats.l_ts[position],
+            monte_carlo.stats.mean.k_ts[position],             monte_carlo.stats.mean.dead_k_ts[position],
+            monte_carlo.stats.mean.l_ts[position],
+            monte_carlo.stats.upper_limit.k_ts[position],      monte_carlo.stats.lower_limit.k_ts[position],
+            monte_carlo.stats.upper_limit.dead_k_ts[position], monte_carlo.stats.lower_limit.dead_k_ts[position],
+            monte_carlo.stats.upper_limit.l_ts[position],      monte_carlo.stats.lower_limit.l_ts[position]
+          ]
+        end
+      end
+    end
   end
 end

data/plot_statistics.gemspec

@@ -5,15 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{plot_statistics}
-  s.version = "1.3.0"
+  s.version = "1.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Asa Wilson"]
-  s.date = %q{2010-03-19}
-  s.default_executable = %q{plot_statistics}
+  s.date = %q{2010-09-27}
   s.description = %q{This is a gem to do a Ripley's K analysis}
   s.email = %q{acvwilson@gmail.com}
-  s.executables = ["plot_statistics"]
+  s.executables = ["bivariate_ripleys_k", "univariate_ripleys_k"]
   s.extra_rdoc_files = [
     "LICENSE",
      "README.markdown"
@@ -25,7 +24,8 @@ Gem::Specification.new do |s|
      "README.markdown",
      "Rakefile",
      "VERSION",
-     "bin/plot_statistics",
+     "bin/bivariate_ripleys_k",
+     "bin/univariate_ripleys_k",
      "lib/plot_statistics.rb",
      "lib/plot_statistics/circle.rb",
      "lib/plot_statistics/clam.rb",

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 3
+  - 4
   - 0
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Asa Wilson
@@ -14,8 +14,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-19 00:00:00 -04:00
-default_executable: plot_statistics
+date: 2010-09-27 00:00:00 -04:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -48,7 +48,8 @@ dependencies:
 description: This is a gem to do a Ripley's K analysis
 email: acvwilson@gmail.com
 executables: 
-- plot_statistics
+- bivariate_ripleys_k
+- univariate_ripleys_k
 extensions: []
 
 extra_rdoc_files: 
@@ -61,7 +62,8 @@ files:
 - README.markdown
 - Rakefile
 - VERSION
-- bin/plot_statistics
+- bin/bivariate_ripleys_k
+- bin/univariate_ripleys_k
 - lib/plot_statistics.rb
 - lib/plot_statistics/circle.rb
 - lib/plot_statistics/clam.rb