graph-function 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 421167ce11bda065293d3e2d411366c005f6dac8
-  data.tar.gz: 611fa94c29782e68e69a9c40e643caa7ab4fb9be
+  metadata.gz: b8156ac336aa21fcec58bb48b1a126a56858ef0a
+  data.tar.gz: d3cac5ba48aa74d4454e93c0155713543052a33a
 SHA512:
-  metadata.gz: ee22e9f5c505376d33b136582a4afd7ab3a5f0d8a2902a80e18372fcf8f82623f8a11648b8642dad3b0cdaceaa1c1ee2c5160e16394c03a1946ae5f275dd3eb1
-  data.tar.gz: daa1821d691bc300454e8e683f0f2667f2392938db475ac2a6b6057383e98870a8d572b58010c6267fab0da94b2780993cab1f59a610601cd8c7929375bde4a4
+  metadata.gz: b3eee5a95f3524c98b31e2e563ab2d59ce3c525ce7a2ca95e0d21a0cecc42259122bd2b23be6365c741f6534a636d6722b9bb716db56b66d5e7c3258d518bdfe
+  data.tar.gz: 8dd2d7be6cbbdaf401772dbbe293aa78a97952bf63da5ef69b1a382ded1f232a4d4e0b5143123b8adfcff1d68eec602c58eb327788be73ab5299586ba9ff0133

data/README.md

@@ -22,10 +22,6 @@ This gem's goal is to make it easy to compare the [asymptotic performance](https
 
 When I work on katas and exercises I found I often wanted to compare my implementations. After doing so a half dozen times I noticed some patterns, and figured it'd be valuable to capture those into an easier API to work with. While working on a kata I like the immediacy of replotting back on x11, but because of gnuplot's structure it is just as easy to get images or html canvas graphs.
 
-## Disclaimer
-
-Because of the current implementation details: Ruby methods which operate on `self` **will not work**, and there is a negligible constant slow down on all functions tested by `Comparison` because of the use of `send(:func)`. The latter won't corrupt comparisons, but means you don't want to use this gem to benchmark functions individually **except** through `Graph::Function::Only`.
-
 ## Installation
 
 Because this gem depends on `gnuplot` and `xquartz`, we need to follow their [prereq steps](https://github.com/rdp/ruby_gnuplot#pre-requisites-and-installation):
@@ -64,6 +60,10 @@ Graph::Function.as_gif
 Graph::Function::IntsComparison.of(method(:sort), method(:bubble_sort))
 ```
 
+Produces:
+
+![comparing ints](examples/comparing_ints.gif)
+
 ### Setup
 
 To set up, you only need the following:
@@ -73,9 +73,11 @@ require 'graph/function'
 Graph::Function.as_x11
 ```
 
-If you don't want to output to [x11](https://www.xquartz.org/), just set `config.terminal` to a different option. Two convenience methods exist for `gif` and `canvas`, you just need to provide them with a file to output to:
+If you don't want to output to [x11](https://www.xquartz.org/), just set `config.terminal` to a different option. Two convenience methods exist for `gif` and `canvas`:
 
 ```ruby
+# by default file will be set to name of the executing file and dumped in its dir
+# or you can set file yourself like so:
 Graph::Function.as_gif(File.expand_path('../comparing_ints.gif', __FILE__))
 Graph::Function.as_canvas(File.expand_path('../comparing_ints.html', __FILE__))
 ```
@@ -87,10 +89,13 @@ Graph::Function.configure do |config|
   config.terminal = 'dumb'
   config.output = File.expand_path('../your_graph_name.txt', __FILE__)
   config.step = (0..10_000).step(1000).to_a # default value
+  config.trials = 1
 end
 ```
 
-In configuration, you can also control the "step" size of `x` in the plot. Its default value is `(0..10_000).step(1000).to_a` (`[0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000]`) but you can make it as fine or rough grained as you need up to any size.
+In configuration, you can control the "step" size of `x` in the plot. Its default value is `(0..10_000).step(1000).to_a` (`[0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000]`) but you can make it as fine or rough grained as you need up to any size.
+
+You can also set a number of trials over which to average execution times.
 
 ### Graphing
 
@@ -104,9 +109,24 @@ Graph::Function::IntsComparison.of(c.method(:function_name_one), c.method(:funct
 
 ![comparison](spec/graph/two_func.gif)
 
-For more complex use cases, you'll be creating a `Graph::Function::Comparison` (or `Graph::Function::Only` if you want to graph a single function) with some generator of data, and executing `#of` with `Method` objects that operate on the same parameter types<sup id="a1">[1](#f1)</sup>. (Note because `IntsComparison` *does not need a generator*, `.of` is a class method instead.)
+For more complex use cases, you'll be creating a `Graph::Function::Comparison` with some generator of data, and executing `#of` with `Method` objects or `Proc`s that operate on the same parameter types<sup id="a1">[1](#f1)</sup>. (Note because `IntsComparison` *does not need a generator*, `.of` is a class method instead.)
+
+### Generators
+
+To generate values of the type needed by your function, you can write
+a generator in Ruby or use the provided dependency
+[Rantly](https://github.com/hayeah/rantly).
+
+Here's an example of a simple Ruby generator, it's just a `Proc` parameterized on `size`:
 
-To generate values of the type needed by your function, use the provided dependency [Rantly](https://github.com/hayeah/rantly). There's great documentation on generating many different kinds of data in their documentation, but here's an example of comparing two functions that take `Hash{String => Integer}`:
+```ruby
+tiny_int_generator = proc {|size| Array.new(size) { rand(-9...9) } }
+comparison = Graph::Function::Comparison.new(tiny_int_generator)
+```
+
+For Rantly usage, there's great documentation on generating many different kinds of data in
+their documentation, but here's an example of comparing two functions that
+take `Hash{String => Integer}`:
 
 ```ruby
 # you must put it in a proc taking size so Graph::Function can increase it
@@ -124,8 +144,7 @@ If you want to make use of more "real" fake data, [Faker](https://github.com/sty
 ```ruby
 # again, we need to parameterize our generator with size
 faker_generator = proc {|size| Rantly(size) { call(Proc.new { Faker::Date.backward(14) }) }
-# using Only here, but anything that takes a generator can take one with Faker
-graph = Graph::Function::Only.new(faker_generator)
+graph = Graph::Function::Comparison.new(faker_generator)
 graph.of(method(:custom_types))
 # => will output an xquartz graph
 ```
@@ -136,6 +155,18 @@ The only downside here is that you can't parameterize `Faker`, but you could use
 
 Check out the [spec file](spec/graph/function_spec.rb) to see all of these or see [examples](examples/).
 
+### Functions that use `self`
+
+For graphing functions that operate on `self`, such as `String#upcase`, you must provide a `Method` or `Proc` that wraps the method call. For instance:
+
+```ruby
+generator = proc {|size| Rantly { sized(size) { string } } }
+# wrap the call to upcase
+test_upcase = proc {|s| s.upcase }
+graph = Graph::Function::Comparison.new(generator)
+graph.of(test_upcase)
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/examples/comparing_ints.html

@@ -168,7 +168,7 @@ L(5759,301);
 L(540,301);
 ctx.closePath();
 ctx.stroke();
-TR(90,2041,270,10.0,"Center","execution time");
+TR(90,2041,270,10.0,"Center","execution time (seconds)");
 T(3149,3980,10.0,"Center","input size");
 T(3149,201,10.0,"Center","Sort vs BubbleSort");
 if (typeof(gnuplot.hide_gp_plot_1) == "undefined"|| !gnuplot.hide_gp_plot_1) {
@@ -223,29 +223,29 @@ ctx.beginPath();
 M(5179,589);
 L(5599,589);
 M(540,3680);
-L(1062,3650);
-L(1584,3558);
-L(2106,3406);
-L(2628,3187);
-L(3150,2903);
-L(3671,2555);
-L(4193,2170);
-L(4715,1722);
-L(5237,1168);
-L(5759,453);
+L(1062,3648);
+L(1584,3554);
+L(2106,3390);
+L(2628,3172);
+L(3150,2885);
+L(3671,2518);
+L(4193,2108);
+L(4715,1616);
+L(5237,1078);
+L(5759,439);
 ctx.stroke();
 ctx.closePath();
 Pt(1,540,3680,60.0);
-Pt(1,1062,3650,60.0);
-Pt(1,1584,3558,60.0);
-Pt(1,2106,3406,60.0);
-Pt(1,2628,3187,60.0);
-Pt(1,3150,2903,60.0);
-Pt(1,3671,2555,60.0);
-Pt(1,4193,2170,60.0);
-Pt(1,4715,1722,60.0);
-Pt(1,5237,1168,60.0);
-Pt(1,5759,453,60.0);
+Pt(1,1062,3648,60.0);
+Pt(1,1584,3554,60.0);
+Pt(1,2106,3390,60.0);
+Pt(1,2628,3172,60.0);
+Pt(1,3150,2885,60.0);
+Pt(1,3671,2518,60.0);
+Pt(1,4193,2108,60.0);
+Pt(1,4715,1616,60.0);
+Pt(1,5237,1078,60.0);
+Pt(1,5759,439,60.0);
 Pt(1,5389,589,60.0);
 } // End gp_plot_2 
 ctx.lineWidth = 2;

data/graph-function.gemspec

@@ -6,7 +6,7 @@ require 'graph/function/version'
 Gem::Specification.new do |spec|
   spec.name          = 'graph-function'
   spec.version       = Graph::Function::VERSION
-  spec.authors       = ['Alex Moore-Niemi']
+  spec.authors       = ['Alex Moore-Niemi', 'Cora Johnson-Roberson']
   spec.email         = ['moore.niemi@gmail.com']
 
   spec.summary       = %q{Graph function performance.}

data/lib/graph/function/comparison.rb

@@ -9,38 +9,61 @@ module Graph
         @data_generator = generator
       end
 
-      def of(*methods)
-        fail unless methods.all? {|m| m.is_a?(Method) }
+      def of(*functions)
+        fail unless functions.all? {|f| f.respond_to?(:call) }
 
-        methods.each do |m|
-          self.class.send(:define_method, m.name, proc(&m))
-        end
+        results = {}
 
         Gnuplot.open do |gp|
           Gnuplot::Plot.new(gp) do |plot|
-
-            plot.title  "#{title = methods.map {|m| camel_title(m.name) }.join(', ') }"
-						set_up(plot)
+            title = functions_to_title(functions)
+            plot.title title
+            set_up(plot)
 
             x = Graph::Function.configuration.step
+            trials = Graph::Function.configuration.trials
             pb = ProgressBar.create(title: title, total: x.size)
 
-            methods.each do |m|
+            functions.each do |f|
               pb.reset
+
+              name = fname(f)
+              results[name] = {}
+
               y = x.collect do |v|
                 pb.increment
                 data = data_generator.call(v)
-                # FIXME can i get ride of the cost of `send`?
-                Benchmark.measure { self.send(m.name, data) }.real
+                current_trials = (1..trials).collect do |_|
+                  Benchmark.measure { f.call(data) }.real
+                end
+                results[name][v] = current_trials
+                current_trials.reduce(0.0, :+) / trials
               end
 
               plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
                 ds.with = "linespoints"
-                ds.title = "#{escape_underscores(m.name)}"
+                ds.title = "#{escape_underscores(name)}"
               end
             end
           end
         end
+        results
+      end
+
+      private
+      def fname(function)
+        function.respond_to?(:name) ? function.name : extract_filename(function.to_s)
+      end
+
+      def functions_to_title(functions)
+        case functions.size
+        when 1
+          "#{camel_title(fname(functions[0]))}"
+        when 2
+          "#{camel_title(fname(functions[0]))} vs #{camel_title(fname(functions[1]))}"
+        else
+          "#{functions.map {|f| camel_title(fname(f)) }.join(', ') }"
+        end
       end
     end
   end

data/lib/graph/function/ints_comparison.rb

@@ -1,48 +1,13 @@
 module Graph
   module Function
-    class IntsComparison
-      extend ReformatString
-      extend PlotConfig
-
-      def self.of(method_one, method_two)
-        fail unless method_one.is_a?(Method) && method_two.is_a?(Method)
-
-        Gnuplot.open do |gp|
-          Gnuplot::Plot.new(gp) do |plot|
-            self.class.send(:define_method, :a, proc(&method_one))
-            self.class.send(:define_method, :b, proc(&method_two))
-
-            plot.title  (title = "#{camel_title(method_one.name)} vs #{camel_title(method_two.name)}")
-            set_up(plot)
-
-            x = Graph::Function.configuration.step
-            pb = ProgressBar.create(title: title, total: x.size)
-
-            y = x.collect do |v|
-              pb.increment
-              array = (0..v - 1).to_a.shuffle
-              Benchmark.measure { a(array) }.real
-            end
-
-            plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
-              ds.with = "linespoints"
-              ds.title = "#{escape_underscores(method_one.name)}"
-            end
-
-            pb.reset
-
-            z = x.collect do |v|
-              pb.increment
-              array = (0..v - 1).to_a.shuffle
-              Benchmark.measure { b(array) }.real
-            end
+    class IntsComparison < Comparison
+      def initialize
+        @data_generator = Proc.new {|v| (-v/2 + 1 .. v/2).to_a.shuffle }
+      end
 
-            plot.data << Gnuplot::DataSet.new( [x, z] ) do |ds|
-              ds.with = "linespoints"
-              ds.title = "#{escape_underscores(method_two.name)}"
-            end
-          end
-        end
+      def self.of(*methods)
+        comparison = self.new
+        comparison.of(*methods)
       end
     end
   end

data/lib/graph/function/plot_config.rb

@@ -2,7 +2,7 @@ module Graph
   module Function
     module PlotConfig
       def set_up(plot)
-        plot.ylabel 'execution time (seconds)'
+        plot.ylabel (Graph::Function.configuration.trials == 1 ? 'execution time (seconds)' : 'average execution time (seconds)')
         plot.xlabel 'input size'
         plot.terminal (t = Graph::Function.configuration.terminal)
         plot.output Graph::Function.configuration.output unless t == 'x11'

data/lib/graph/function/reformat_string.rb

@@ -7,6 +7,10 @@ module Graph
       def camel_title(s)
         s.to_s.split('_').collect(&:capitalize).join
       end
+      def extract_filename(s)
+        matches = /([^\/]+:\d+)\>$/.match(s)
+        !matches.nil? ? matches[1] : s
+      end
     end
   end
 end

data/lib/graph/function/version.rb

@@ -1,5 +1,5 @@
 module Graph
   module Function
-    VERSION = '0.1.5'
+    VERSION = '0.1.7'
   end
 end

data/lib/graph/function.rb

@@ -7,7 +7,6 @@ require 'ruby-progressbar'
 require 'graph/function/version'
 require 'graph/function/reformat_string'
 require 'graph/function/plot_config'
-require 'graph/function/only'
 require 'graph/function/comparison'
 require 'graph/function/ints_comparison'
 
@@ -25,14 +24,18 @@ module Graph
 
     singleton_class.send(:alias_method, :as_x11, :configure)
 
-    def self.as_gif(file = File.expand_path("../#{$0.slice(0..-4)}.gif", __FILE__))
+    def self.file_location(ext)
+      File.new("#{$0.slice(0..-4)}.#{ext}", 'w').path
+    end
+
+    def self.as_gif(file = file_location('gif'))
       self.configure do |config|
         config.terminal = 'gif'
         config.output = file
       end
     end
 
-    def self.as_canvas(file = File.expand_path("../#{$0.slice(0..-4)}.html", __FILE__))
+    def self.as_canvas(file = file_location('html'))
       self.configure do |config|
         config.terminal = 'canvas'
         config.output = file
@@ -42,6 +45,7 @@ module Graph
     class Configuration
       attr_accessor :terminal, :output
       attr_accessor :step
+      attr_accessor :trials
 
       # defaults
       # see https://github.com/rdp/ruby_gnuplot/blob/master/examples/output_image_file.rb
@@ -50,6 +54,7 @@ module Graph
         @terminal = 'x11'
         @output = '.'
         @step = (0..10_000).step(1000).to_a
+        @trials = 1
       end
     end
   end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: graph-function
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Alex Moore-Niemi
+- Cora Johnson-Roberson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-02 00:00:00.000000000 Z
+date: 2016-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gnuplot
@@ -162,7 +163,6 @@ files:
 - lib/graph/function.rb
 - lib/graph/function/comparison.rb
 - lib/graph/function/ints_comparison.rb
-- lib/graph/function/only.rb
 - lib/graph/function/plot_config.rb
 - lib/graph/function/reformat_string.rb
 - lib/graph/function/version.rb

data/lib/graph/function/only.rb

@@ -1,41 +0,0 @@
-module Graph
-  module Function
-    class Only
-      include ReformatString
-      include PlotConfig
-      attr_accessor :data_generator
-
-      def initialize(generator)
-        @data_generator = generator
-      end
-
-      def of(method_obj)
-        fail unless method_obj.is_a?(Method)
-
-        self.class.send(:define_method, :a, proc(&method_obj))
-
-        Gnuplot.open do |gp|
-          Gnuplot::Plot.new(gp) do |plot|
-
-            plot.title  "#{title = camel_title(method_obj.name)}"
-            set_up(plot)
-
-            x = Graph::Function.configuration.step
-            pb = ProgressBar.create(title: title, total: x.size)
-
-            y = x.collect do |v|
-              pb.increment
-              data = data_generator.call(v)
-              Benchmark.measure { a(data) }.real
-            end
-
-            plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
-              ds.with = "linespoints"
-              ds.title = "#{escape_underscores(method_obj.name)}"
-            end
-          end
-        end
-      end
-    end
-  end
-end