graph-function 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3928a98f9b9e14464ba42f12d15c1ed57c94e69
-  data.tar.gz: 09922b5d7483db4c3331124add4a25b5e07365ac
+  metadata.gz: 37ae0974e3de2c259a00c03fc0e56aa763f4f228
+  data.tar.gz: 37c8a47098d1ff10dff34e64bd975fbdccbd4628
 SHA512:
-  metadata.gz: 5b6adec137335e29db10683a1e56efda5b074e9679647a2e33282e3d7b52e820361655ead33e9ab311999e08baecccaf347a66a0c508372a1ebfcc2797eff9a7
-  data.tar.gz: 530020596f1973d34a64e8253de722268a39b9cb3031d7b16e53fe3e2f22c1d5662cbfabd3459a9d258f4de9dae484f2187be0ca5fe0e650d296454bea7b3901
+  metadata.gz: 9550e10b5441a39289e5a0e07be6cee2a4267d341836cedb6fed37b6acb477e28f23c07775cdd4d63cb6ee2c92ce1c0b71811fdc2aa19c0352fdae266d9a11e4
+  data.tar.gz: e08f0b2f4c35cd9d235e27bb5312f16bc7c8c676f3c037e336a26f4e023283ca32b047a44078a0d826173268d3e6443fa89048daebb72e9416db6b920020301c

data/README.md

@@ -1,10 +1,12 @@
 # Graph::Function
 
-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.
+This gem's goal is to make it easy to compare the [asymptotic performance](https://en.wikipedia.org/wiki/Asymptotic_analysis) of two or more functions via graphing.
+
+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 because of use of `send(:func)`. The latter won't corrupt comparisons, but means you don't want to use this to benchmark functions individually except through `Graph::Function::Only`.
+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
 
@@ -47,10 +49,11 @@ If you don't want to output to x11, just set `config.terminal` to a different op
 Graph::Function.configure do |config|
   config.terminal = 'gif'
   config.output = File.expand_path('../your_graph_name.gif', __FILE__)
+  config.step = (0..10_000).step(1000).to_a # default value
 end
 ```
 
-For most use cases, you'll be creating a `Graph::Function::Comparison` and executing `#of` on it to provide it with `Method` objects that operate on the same parameter types<sup id="a1">[1](#f1)</sup>. `Comparison` and `Only` take a generator when initialized, but because `IntsComparison` does not, `.of` is a class method instead.
+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.
 
 The simplest usage (suitable for a large class of exercises, in my experience) is if you're comparing two functions that take a single argument of `Array[Int]` type:
 
@@ -62,21 +65,25 @@ Graph::Function::IntsComparison.of(c.method(:function_name_one), c.method(:funct
 
 ![comparison](spec/graph/two_func.gif)
 
-If your functions need to operate on other types, then you need to generate values of those types. For this, I use [Rantly](https://github.com/hayeah/rantly). Here's an example of comparing two functions that take `Hash{String => Integer}`:
+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.)
+
+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
+# you must put it in a proc taking size so Graph::Function can increase it
 generator = proc {|size| Rantly { dict(size) { [string, integer] } }
 dict_comparison = Graph::Function::Comparison.new(generator)
-# Comparison can take any number of Methods
+# Comparison can take any number of Methods, but for now, 2
 dict_comparison.of(method(:hash_func_one), method(:hash_func_two))
 # => will output an xquartz graph
 ```
 
 ![comparison](spec/graph/comparison.gif)
 
-If you want to make use of more "real" fake data, [Faker](https://github.com/stympy/faker) is included, and can be used like so:
+If you want to make use of more "real" fake data, [Faker](https://github.com/stympy/faker) is also included, and can be used like so in your generators:
 
 ```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)
@@ -88,7 +95,7 @@ graph.of(method(:custom_types))
 
 The only downside here is that you can't parameterize `Faker`, but you could use random generators to mix it up. Using the above example, `graph-function` won't pass anything into the `faker_generator` but the `size`, so if we want the value to change, we could use `Faker::Date.backward(proc { rand(10) }.call)`.
 
-Check out the [spec file](spec/graph/function_spec.rb) to see all of these and more examples.
+Check out the [spec file](spec/graph/function_spec.rb) to see all of these or see [examples](examples/).
 
 ## Development
 

data/examples/comparing.html

@@ -224,28 +224,28 @@ M(5179,589);
 L(5599,589);
 M(540,3680);
 L(1062,3649);
-L(1584,3559);
-L(2106,3411);
-L(2628,3192);
-L(3150,2941);
-L(3671,2601);
-L(4193,2207);
-L(4715,1772);
-L(5237,1243);
-L(5759,696);
+L(1584,3555);
+L(2106,3406);
+L(2628,3180);
+L(3150,2902);
+L(3671,2556);
+L(4193,2166);
+L(4715,1690);
+L(5237,1168);
+L(5759,587);
 ctx.stroke();
 ctx.closePath();
 Pt(1,540,3680,60.0);
 Pt(1,1062,3649,60.0);
-Pt(1,1584,3559,60.0);
-Pt(1,2106,3411,60.0);
-Pt(1,2628,3192,60.0);
-Pt(1,3150,2941,60.0);
-Pt(1,3671,2601,60.0);
-Pt(1,4193,2207,60.0);
-Pt(1,4715,1772,60.0);
-Pt(1,5237,1243,60.0);
-Pt(1,5759,696,60.0);
+Pt(1,1584,3555,60.0);
+Pt(1,2106,3406,60.0);
+Pt(1,2628,3180,60.0);
+Pt(1,3150,2902,60.0);
+Pt(1,3671,2556,60.0);
+Pt(1,4193,2166,60.0);
+Pt(1,4715,1690,60.0);
+Pt(1,5237,1168,60.0);
+Pt(1,5759,587,60.0);
 Pt(1,5389,589,60.0);
 } // End gp_plot_2 
 ctx.lineWidth = 2;

data/examples/comparing_canvas.rb

@@ -1,28 +1,29 @@
 require 'graph/function'
 
+file = File.expand_path('../comparing.html', __FILE__)
 Graph::Function.configure do |config|
-	config.terminal = 'canvas'
-	config.output = File.expand_path('../comparing.html', __FILE__)
+  config.terminal = 'canvas'
+  config.output = file
 end
 
 def bubble_sort(array)
-	n = array.length
-	loop do
-		swapped = false
-		(n-1).times do |i|
-			if array[i] > array[i+1]
-				array[i], array[i+1] = array[i+1], array[i]
-				swapped = true
-			end
-		end
-		break if not swapped
-	end
-	array
+  n = array.length
+  loop do
+    swapped = false
+    (n-1).times do |i|
+      if array[i] > array[i+1]
+        array[i], array[i+1] = array[i+1], array[i]
+        swapped = true
+      end
+    end
+    break if not swapped
+  end
+  array
 end
 
 def sort(array)
-	array.sort
+  array.sort
 end
 
-puts 'comparing sort and bubble_sort'
+puts "output: #{file}"
 Graph::Function::IntsComparison.of(method(:sort), method(:bubble_sort))

data/lib/graph/function/comparison.rb

@@ -22,7 +22,7 @@ module Graph
             plot.title  "#{title = methods.map {|m| camel_title(m.name) }.join(', ') }"
 						set_up(plot)
 
-            x = (0..10000).step(1000).to_a
+            x = Graph::Function.configuration.step
             pb = ProgressBar.create(title: title, total: x.size)
 
             methods.each do |m|

data/lib/graph/function/ints_comparison.rb

@@ -15,7 +15,7 @@ module Graph
             plot.title  (title = "#{camel_title(method_one.name)} vs #{camel_title(method_two.name)}")
             set_up(plot)
 
-            x = (0..10000).step(1000).to_a
+            x = Graph::Function.configuration.step
             pb = ProgressBar.create(title: title, total: x.size)
 
             y = x.collect do |v|

data/lib/graph/function/only.rb

@@ -20,7 +20,7 @@ module Graph
             plot.title  "#{title = camel_title(method_obj.name)}"
             set_up(plot)
 
-            x = (0..10000).step(1000).to_a
+            x = Graph::Function.configuration.step
             pb = ProgressBar.create(title: title, total: x.size)
 
             y = x.collect do |v|

data/lib/graph/function/version.rb

@@ -1,5 +1,5 @@
 module Graph
   module Function
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   end
 end

data/lib/graph/function.rb

@@ -25,6 +25,7 @@ module Graph
 
     class Configuration
       attr_accessor :terminal, :output
+      attr_accessor :step
 
       # defaults
       # see https://github.com/rdp/ruby_gnuplot/blob/master/examples/output_image_file.rb
@@ -32,6 +33,7 @@ module Graph
       def initialize
         @terminal = 'x11'
         @output = '.'
+        @step = (0..10_000).step(1000).to_a
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph-function
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Alex Moore-Niemi