lazy_stream 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa9d0377f7f4989c9dc30bc5c815a26a3aceec0a
-  data.tar.gz: a9442c1c658d99b5b79a90a8dad437481898cb45
+  metadata.gz: 55023408f0cd578d29bf48c769b001f29c3e70dc
+  data.tar.gz: 6de9083f43b08e1c0e448116f553c904c4ee2550
 SHA512:
-  metadata.gz: c16adf4696ca3bba83c9b6c42923eeb387e3ea0b63426d0a3fc88486fdda41be57d6029edff0b32d355aea81af295b21733f7514ba6fd92b3989ff2f8cec84e3
-  data.tar.gz: cafc007afb204107a4954b991b44e861e5172fe975b6c0bc95c8a1e4c93944d42144f707c679c1cdbbdae9a6993c3b7ab10b8afe12e138650ee9398f73ae8791
+  metadata.gz: ac332caa2e2b89a8d8818e511761a04d6e61aaa1e0021b34e483218c8ae1d5976f741db6d6e0fd99c6df40d196a8e1c9f302b998fe711aa71642e2f8f90fbc77
+  data.tar.gz: 5b309210ab23fc28c4a2eaf0878b6bca09df7e906768032b00f6e87ece306b103827723fdfb91396cb7adb1b7ed8867fc61f0c68ef76d9f79e5a6d8ba4a71442

data/README.md

@@ -0,0 +1,122 @@
+lazy_stream
+===========
+
+A Ruby class to represent lazy infinite stream.
+It is implemented in the same way as the streams in the book [SICP]
+(http://mitpress.mit.edu/sicp/full-text/sicp/book/node69.html).
+
+## Installation
+The library is distributed via [RubyGems](http://rubygems.org/gems/lazy_stream):
+
+    $ gem install lazy_stream
+
+## Usage
+
+A stream is just a delayed list. We do lazy evaluation in Ruby with code blocks.
+To create a stream:
+
+``` ruby
+require 'lazy_stream'
+
+s = lazy_stream(1) { lazy_stream(2) { lazy_stream(3) } }
+s.to_a       #=> [1, 2, 3]
+s.first      #=> 1
+s.rest       #=> A LazyStream object for the rest of the list [2, 3]
+lazy_stream  #=> An empty LazyStream object
+```
+
+lazy_stream is just a shortcut for LazyStream.new.
+Methods empty?, at, drop, each, map, reduce, select, take are also implemented
+like Array.
+
+It becomes powerful when we construct infinite streams like these:
+
+``` ruby
+def integers_starting_from(n)
+  lazy_stream(n) { integers_starting_from(n + 1) }
+end
+
+integers_starting_from(1).take(10).reduce(&:+)  #=> 55
+
+def fibgen(a, b)
+  lazy_stream(a) { fibgen(b, a + b) }
+end
+
+fibgen(0, 1).take(10).to_a  #=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+def sieve(stream)
+  lazy_stream(stream.first) do
+    sieve(stream.rest.select { |x| x % stream.first > 0 })
+  end
+end
+
+def primes
+  sieve(integers_starting_from(2))
+end
+
+primes.take(10).to_a  #=> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+```
+
+Or define streams implicitly:
+
+``` ruby
+ones = lazy_stream(1) { ones }
+ones.take(10).to_a  #=> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+
+integers = lazy_stream(1) { LazyStream.add(ones, integers) }
+integers.take(10).to_a  #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+# fibs is a stream beginning with 0 and 1, such that the rest of the stream can
+# be generated by adding fibs to itself shifted by one place:
+#     1 1 2 3 5  8 13 21 ... = fibs.rest
+#     0 1 1 2 3  5  8 13 ... = fibs
+# 0 1 1 2 3 5 8 13 21 34 ... = fibs
+fibs = lazy_stream(0) { lazy_stream(1) { LazyStream.add(fibs.rest, fibs) } }
+fibs.take(10).to_a  #=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+```
+
+More complicated example, approximating *π*, with Euler's transform and the
+tableau sequence accelerator:
+
+``` ruby
+def pi_summands(n)
+  lazy_stream(1.0 / n) { pi_summands(n + 2).map(&:-@) }
+end
+
+def pi_stream
+  pi_summands(1).partial_sums.scale(4)
+end
+
+def euler_transform(s)
+  lazy_stream(s[2] - ((s[2] - s[1])**2 / (s[0] - 2 * s[1] + s[2]))) do
+    euler_transform(s.rest)
+  end
+end
+
+def make_tableau(s, &transform)
+  lazy_stream(s) { make_tableau(transform.call(s), &transform) }
+end
+
+def accelerated_sequence(s, &transform)
+  make_tableau(s, &transform).map(&:first)
+end
+
+accelerated_sequence(pi_stream, &method(:euler_transform)).take(8).print
+# 4.0
+# 3.166666666666667
+# 3.142105263157895
+# 3.141599357319005
+# 3.1415927140337785
+# 3.1415926539752927
+# 3.1415926535911765
+# 3.141592653589778
+```
+
+Since the functions are all recursive here, to make them actually work for large
+data set, we need to enable the
+[tail call optimization](https://github.com/melvinxie/ruby/blob/master/tco.rb)
+in Ruby, otherwise you will hit the stack level too deep error soon.
+
+For more examples, see my
+[blog post](http://melvinxie.github.io/blog/2013/05/04/ruby-lazy-infinite-stream-in-the-sicp-way/)
+and [example spec](https://github.com/melvinxie/lazy_stream/blob/master/spec/example_spec.rb).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+
+desc "Run tests"
+task :default => :spec

data/lib/lazy_stream.rb

@@ -1,13 +1,13 @@
 #!/usr/bin/env ruby
 
 class LazyStream
+  attr_reader :first
+
   def initialize(first=nil, &proc)
     @first = first
     @proc = block_given? ? proc : lambda { LazyStream.new }
   end
 
-  attr_reader :first
-
   def rest
     @rest ||= @proc.call
   end
@@ -17,13 +17,8 @@ class LazyStream
   end
 
   def [](n)
-    if empty?
-      nil
-    elsif n == 0
-      first
-    else
-      rest[n - 1]
-    end
+    return nil if empty?
+    n == 0 ? first : rest[n - 1]
   end
 
   alias_method :at, :[]
@@ -106,6 +101,12 @@ class LazyStream
   def self.interleave(s1, s2)
     s1.empty? ? s2 : LazyStream.new(s1.first) { interleave(s2, s1.rest) }
   end
+
+  def ==(other)
+    return false if !other.is_a?(LazyStream)
+    return true if empty? && other.empty?
+    first == other.first && rest == other.rest
+  end
 end
 
 module Kernel

data/spec/example_spec.rb

@@ -0,0 +1,176 @@
+require_relative 'spec_helper'
+
+describe "Example" do
+  def integers_starting_from(n)
+    lazy_stream(n) { integers_starting_from(n + 1) }
+  end
+
+  it "defines integers stream explicitly" do
+    integers = integers_starting_from(1)
+    integers.take(10).to_a.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    integers.take(10).reduce(&:+).should == 55
+    no_sevens = integers.select { |i| i % 7 > 0 }
+    no_sevens.take(10).to_a.should == [1, 2, 3, 4, 5, 6, 8, 9, 10, 11]
+  end
+
+  def fibgen(a, b)
+    lazy_stream(a) { fibgen(b, a + b) }
+  end
+
+  it "defines fibonacci stream explicitly" do
+    fibgen(0, 1).take(10).to_a.should == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+  end
+
+  def sieve(stream)
+    lazy_stream(stream.first) do
+      sieve(stream.rest.select { |x| x % stream.first > 0 })
+    end
+  end
+
+  it "defines primes stream with sieve explicitly" do
+    primes = sieve(integers_starting_from(2))
+    primes.take(10).to_a.should == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+  end
+
+  it "defines integers stream implicitly" do
+    ones = lazy_stream(1) { ones }
+    ones.take(10).to_a.should == [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+    integers = lazy_stream(1) { LazyStream.add(ones, integers) }
+    integers.take(10).to_a.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  end
+
+  it "defines fibonacci stream implicitly" do
+    # fibs is a stream beginning with 0 and 1, such that the rest of the stream
+    # can be generated by adding fibs to itself shifted by one place:
+    #     1 1 2 3 5  8 13 21 ... = fibs.rest
+    #     0 1 1 2 3  5  8 13 ... = fibs
+    # 0 1 1 2 3 5 8 13 21 34 ... = fibs
+    fibs = lazy_stream(0) { lazy_stream(1) { LazyStream.add(fibs.rest, fibs) } }
+    fibs.take(10).to_a.should == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+  end
+
+  def prime?(n)
+    iter = -> ps do
+      if ps.first**2 > n
+        true
+      elsif n % ps.first == 0
+        false
+      else
+        iter.call(ps.rest)
+      end
+    end
+    iter.call(@primes)
+  end
+
+  it "defines primes stream implicitly" do
+    # The reason this definition works is that, at any point, enough of the
+    # primes stream has been generated to test the primality of the numbers we
+    # need to check next.
+    @primes = lazy_stream(2) do
+      integers_starting_from(3).select(&method(:prime?))
+    end
+    @primes.take(10).to_a.should == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+  end
+
+  def enumerate_interval(low, high)
+    low > high ? lazy_stream :
+                 lazy_stream(low) { enumerate_interval(low + 1, high) }
+  end
+
+  def prime_enumerate_interval(low, high)
+    enumerate_interval(low, high).select(&method(:prime?))
+  end
+
+  it "enumerates intervals of primes stream" do
+    @primes = lazy_stream(2) do
+      integers_starting_from(3).select(&method(:prime?))
+    end
+    prime_enumerate_interval(10, 30).to_a.should == [11, 13, 17, 19, 23, 29]
+    prime_enumerate_interval(10000, 40000).reduce(&:+).should == 73434270
+  end
+
+  def sqrt_improve(guess, x)
+    (guess + x / guess) / 2
+  end
+
+  def sqrt_stream(x)
+    guesses = lazy_stream(1.0) do
+      guesses.map { |guess| sqrt_improve(guess, x) }
+    end
+  end
+
+  it "defines sqrt approximation stream" do
+    sqrt_stream(2).take(5).to_a.should ==
+        [1.0, 1.5, 1.4166666666666665, 1.4142156862745097, 1.4142135623746899]
+  end
+
+  def pi_summands(n)
+    lazy_stream(1.0 / n) { pi_summands(n + 2).map(&:-@) }
+  end
+
+  def pi_stream
+    pi_summands(1).partial_sums.scale(4)
+  end
+
+  it "defines pi approximation stream" do
+    pi_stream.take(8).to_a.should ==
+        [4.0, 2.666666666666667, 3.466666666666667, 2.8952380952380956,
+         3.3396825396825403, 2.9760461760461765, 3.2837384837384844,
+         3.017071817071818]
+  end
+
+  def euler_transform(s)
+    lazy_stream(s[2] - ((s[2] - s[1])**2 / (s[0] - 2 * s[1] + s[2]))) do
+      euler_transform(s.rest)
+    end
+  end
+
+  it "defines pi approximation stream with euler transform" do
+    euler_transform(pi_stream).take(8).to_a.should ==
+        [3.166666666666667, 3.1333333333333337, 3.1452380952380956,
+         3.13968253968254, 3.1427128427128435, 3.1408813408813416,
+         3.142071817071818, 3.1412548236077655]
+  end
+
+  def make_tableau(s, &transform)
+    lazy_stream(s) { make_tableau(transform.call(s), &transform) }
+  end
+
+  def accelerated_sequence(s, &transform)
+    make_tableau(s, &transform).map(&:first)
+  end
+
+  it "defines pi approximation stream with accelerated sequence" do
+    accelerated_sequence(pi_stream, &method(:euler_transform)).take(8).to_a.
+        should == [4.0, 3.166666666666667, 3.142105263157895, 3.141599357319005,
+                   3.1415927140337785, 3.1415926539752927, 3.1415926535911765,
+                   3.141592653589778]
+  end
+
+  def pairs(s, t)
+    lazy_stream([s.first, t.first]) do
+      LazyStream.interleave(t.rest.map { |x| [s.first, x] },
+                        pairs(s.rest, t.rest))
+    end
+  end
+
+  it "defines pairs stream" do
+    integers = integers_starting_from(1)
+    pairs(integers, integers).take(5).to_a.should ==
+        [[1, 1], [1, 2], [2, 2], [1, 3], [2, 3]]
+  end
+
+  # integrand is a delayed argument that promises to give result after a loop
+  def integral(integrand, initial, dt)
+    int = lazy_stream(initial) { LazyStream.add(integrand.call.scale(dt), int) }
+  end
+
+  # sets up the delayed integrand with lambda
+  def solve(f, y0, dt)
+    y = integral(lambda { y.map(&f) }, y0, dt)
+  end
+
+  it "solves the differential equation dy / dt = f(y)" do
+    solve(lambda { |y| y }, 1, 0.001)[1000].should == 2.716923932235896
+  end
+end

data/spec/lazy_stream_spec.rb

@@ -0,0 +1,163 @@
+require_relative 'spec_helper'
+
+describe LazyStream do
+  it "initializes an empty stream" do
+    empty_stream = LazyStream.new
+    empty_stream.should be_empty
+  end
+
+  it "returns the first element" do
+    stream = LazyStream.new(1)
+    stream.first.should == 1
+  end
+
+  it "has the rest as another lazy stream itself" do
+    stream = LazyStream.new(1) { LazyStream.new(2) }
+    stream.rest.first.should == 2
+  end
+
+  it "caches the rest" do
+    cached = false
+    rest = lambda do
+      if !cached
+        cached = true
+        LazyStream.new(2)
+      else
+        raise Exception, "Did not cache"
+      end
+    end
+    stream = LazyStream.new(1, &rest)
+    stream.rest.first.should == 2
+    stream.rest.first.should == 2
+  end
+
+  it "knows when it's not empty" do
+    LazyStream.new(1).should_not be_empty
+  end
+
+  context "#[]" do
+    it "returns nil when is empty" do
+      LazyStream.new[0].should == nil
+    end
+
+    it "returns first for zero index" do
+      LazyStream.new(1)[0].should == 1
+    end
+
+    it "returns from the rest for greater than zero indices" do
+      stream = LazyStream.new(1) { LazyStream.new(2) }
+      stream[1].should == 2
+    end
+
+    it "aliases to [] from at" do
+      stream = LazyStream.new(1) { LazyStream.new(2) }
+      stream.at(1).should == 2
+    end
+  end
+
+  context "#drop" do
+    it "returns the stream when it's empty" do
+      stream = LazyStream.new
+      stream.drop(10).should == stream
+    end
+
+    it "returns itself when nothing has been dropped" do
+      stream = LazyStream.new(1)
+      stream.drop(0).should == stream
+    end
+
+    it "returns the rest after dropping the first element" do
+      stream = LazyStream.new(1) { LazyStream.new(2) }
+      stream.drop(1).should == LazyStream.new(2)
+    end
+  end
+
+  context "#each" do
+    it "iterates through all elements in stream" do
+      stream = LazyStream.new(1) { LazyStream.new(2) }
+      elements = []
+      stream.each { |element| elements << element }
+      elements.should == [1, 2]
+    end
+  end
+
+  context "#map" do
+    it "maps the elements one at a time" do
+      stream = LazyStream.new(1) { LazyStream.new(2) }
+      mapped = stream.map do |item|
+        item * 2
+      end
+      mapped.should == LazyStream.new(2) { LazyStream.new(4) }
+    end
+  end
+
+  context "#select" do
+    it "returns self if stream is empty" do
+      stream = LazyStream.new
+      selected = stream.select { |element| element % 2 == 0 }
+      selected.should == stream
+    end
+
+    it "selects first when it only applies to it" do
+      stream = LazyStream.new(2) { LazyStream.new(1) }
+      selected = stream.select { |element| element % 2 == 0 }
+      selected == LazyStream.new(2)
+    end
+
+    it "selects as longs as predicate applies" do
+      stream = LazyStream.new(2) { LazyStream.new(4) }
+      selected = stream.select { |element| element % 2 == 0 }
+      selected.should == stream
+    end
+  end
+
+  context "#take" do
+    it "returns an empty steam if stream is empty" do
+      stream = LazyStream.new
+      stream.take(10).should be_empty
+    end
+
+    it "returns empty stream if n is less than one" do
+      stream = LazyStream.new(1)
+      stream.take(0).should == LazyStream.new
+    end
+
+    it "returns the first element for n equals 1" do
+      stream = LazyStream.new(2)
+      stream.take(1).should == stream
+    end
+
+    it "returns first & rest from rest when n is greater than 1" do
+      stream = LazyStream.new(1) { LazyStream.new(2) }
+      stream.take(2).should == stream
+    end
+  end
+
+  context "#==" do
+    it "is not equal with something other than LazyStream" do
+      LazyStream.new.should_not == 2
+    end
+
+    it "is equal when both empty" do
+      LazyStream.new.should == LazyStream.new
+    end
+
+    it "is equal when they both have single same element" do
+      LazyStream.new(1).should == LazyStream.new(1)
+    end
+
+    it "is not equal when they have different first" do
+      LazyStream.new(1).should_not == LazyStream.new(2)
+    end
+
+    it "is equal when first and rest are equal" do
+      stream = LazyStream.new(1) { LazyStream.new(2) }
+      stream.should == LazyStream.new(1) { LazyStream.new(2) }
+    end
+
+    it "is not equal when rests are not equal" do
+      stream = LazyStream.new(1) { LazyStream.new(2) }
+      stream.should_not == LazyStream.new(1) { LazyStream.new(3) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require_relative '../lib/lazy_stream'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lazy_stream
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Mingmin Xie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-06 00:00:00.000000000 Z
-dependencies: []
+date: 2013-05-21 00:00:00.000000000 Z
+dependencies:
+- !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: Ruby infinite lazy stream
 email: melvinxie@gmail.com
 executables: []
@@ -17,6 +31,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/lazy_stream.rb
+- Rakefile
+- README.md
+- spec/example_spec.rb
+- spec/lazy_stream_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/melvinxie/lazy_stream
 licenses:
 - MIT
@@ -37,8 +56,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: lazy_stream
-test_files: []
+test_files:
+- spec/example_spec.rb
+- spec/lazy_stream_spec.rb
+- spec/spec_helper.rb