mll 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b28b0ef583cd90f87454f37cebdc8a3088ba42a
-  data.tar.gz: 05757c078b5eade518f1895e71c9bf3e0af97f5f
+  metadata.gz: 1826ae5ecd9c663432d75b8d35387762e7d3ce85
+  data.tar.gz: 1387511b30a66d4331ab6fe978682dfc0e4607af
 SHA512:
-  metadata.gz: cf8caa79c3a7cc275b234c1dcb1d1bc6a0bc9a772f585bddc171cc8d4bd2dacff587cc37c963df7fbab53880c48ca62579ba5c63e109235836288611b6011f8a
-  data.tar.gz: 8c3053016c69c2ead9e8fd965a661167332e45b00841e15fbdd570325888e5c74e03c5ee89b339bcd665ae75d24bf37574e201686ae0bf3a3b9f3127a1ea9331
+  metadata.gz: 3e791cfab9e6f9e979b3c68a6364a2e8fd362696ae7592083f934165a543a525828f9b7504d137a32984988490c22b9e2bc891df7542f94bbcc1c3241b9c3e94
+  data.tar.gz: 71d9d47ec39472b8666db934b34fb33042a18b64e5543f0e8c19c1a39982e035335bf1075521069732014529b49ae59f298cb88f6ed10daea28c3f1dd13b255a

data/README.md

@@ -6,7 +6,7 @@
 
 ## Why
 
-1. Важной является реализация https://reference.wolfram.com/language/ref/Listable.html: автоматическое применение функции ко всем элементам аргумента, если тот является List-ом (Array-ем в среде Ruby).  
+1. Важной является реализация https://reference.wolfram.com/language/ref/Listable.html: автоматическое применение функции ко всем элементам аргумента, если тот является List-ом (Array-ем в среде Ruby).
 2. `::range`, в отличие от рубишного, может иметь отрицательный step.
 3. `::table`, в отличие от рубишного `.map`, может создавать многомерные массивы одним вызовом, а не только вложенными.
 
@@ -24,6 +24,18 @@
     # => [[[111, 112, 113, 114], [121, 122, 123, 124], [131, 132, 133, 134]],
           [[211, 212, 213, 214], [221, 222, 223, 224], [231, 232, 233, 234]]]
 
+    MLL::table MLL.method(:times), 9, 9
+    # => [[1,  2,  3,  4,  5,  6,  7,  8,  9],
+          [2,  4,  6,  8, 10, 12, 14, 16, 18],
+          [3,  6,  9, 12, 15, 18, 21, 24, 27],
+          [4,  8, 12, 16, 20, 24, 28, 32, 36],
+          [5, 10, 15, 20, 25, 30, 35, 40, 45],
+          [6, 12, 18, 24, 30, 36, 42, 48, 54],
+          [7, 14, 21, 28, 35, 42, 49, 56, 63],
+          [8, 16, 24, 32, 40, 48, 56, 64, 72],
+          [9, 18, 27, 36, 45, 54, 63, 72, 81]]
+
+
 ## Installation
 
     $ gem install mll

data/lib/mll.rb

@@ -1,14 +1,67 @@
 module MLL
 
-  # https://reference.wolfram.com/language/ref/Listable.html
+  def self.nest_list f, expr, n
+    Enumerator.new do |e|
+      e << expr
+      n.times do
+        e << expr = f.call(expr)
+      end
+    end
+  end
+  # def self.nest *args
+  #   nest_list(*args).last
+  # end
+  def self.nest f, expr, n
+    n.times{ expr = f.call expr }
+    expr
+  end
+
+  def self.fold_list f, x, list = nil
+    # TODO teach it to accept Range ?
+    x, *list = x unless list
+    # use Ruby#inject ?
+    Enumerator.new do |e|
+      e << x
+      list.each do |i|
+        e << x = f.call(x, i)
+      end
+    end
+  end
+
+  def self.table f, *args
+    [].tap do |result|
+      [[result, args.map{ |r| # add lazy?
+        r.respond_to?(:map) && r.first.respond_to?(:map) ?
+          r.first : range(*r)
+      }]].tap do |stack|
+        stack.each do |ai, ri|
+          # TODO try to make #table lazy (Enumerator instead of Array)
+          # "no implicit conversion of Enumerator::Lazy into Array"
+          # "undefined method `replace' for #<Enumerator::Lazy: []>"
+          ai.replace ri.first.map{ |i|
+            if ri.size == 1
+              f.call(*ai, i)
+            else
+              [*ai.dup, i].tap{ |t| stack << [t, ri.drop(1)] }
+            end
+          }#.to_a # WTF
+        end
+      end
+    end
+  end
+
+  # http://reference.wolfram.com/language/ref/Listable.html
   def self.define_listable_function name, &block
     (class << self; self end).class_eval do # http://stackoverflow.com/a/12792313/322020
       define_method name do |*args|
-# p [name, args]
-        next block.call *args unless args[0].respond_to? :map
-        next args[0].lazy.map{ |i| send name, i, *args.drop(1) } unless args[1].respond_to? :map
-        # raise "idk how to list this function" if args.size > 2
-        next args[0].lazy.zip(args[1]).map{ |i,j| send name, i, j, *args.drop(2) }
+        case args.map{ |i| i.respond_to? :map }
+          when [true] ; args.first.lazy.map &method(name)
+          when [true, true] ; args.first.lazy.zip(args.last).map{ |i, j| send name, i, j }
+          when [true, false] ; args.first.lazy.map{ |i| send name, i, args.last }
+          when [false, true] ; args.last.lazy.map{ |i| send name, args.first, i }
+        else
+          block.call *args
+        end
       end
     end
   end
@@ -36,37 +89,32 @@ module MLL
     end
   end
 
-  def self.table f, *args
-    [].tap do |result|
-      [[result, args.map{ |r| # add lazy?
-        r.respond_to?(:map) && r.first.respond_to?(:map) ?
-          r.first : range(*r)
-      }]].tap do |stack|
-        stack.each do |ai, ri|
-          # TODO try to make #table lazy (Enumerator instead of Array)
-          # "no implicit conversion of Enumerator::Lazy into Array"
-          # "undefined method `replace' for #<Enumerator::Lazy: []>"
-          ai.replace ri.first.map{ |i|
-            if ri.size == 1
-              f.call(*ai, i)
-            else
-              [*ai.dup, i].tap{ |t| stack << [t, ri.drop(1)] }
-            end
-          }#.to_a # WTF
+  define_listable_function (:subtract) { |a, b| a - b }
+  define_listable_function (:divide) { |a, b| a / b }
+  define_listable_function (:_plus) { |a, b| a + b }
+  define_listable_function (:_times) { |a, b| a * b }
+
+  # http://reference.wolfram.com/language/ref/Orderless.html
+  def self.define_orderless_function name, &block
+    (class << self; self end).class_eval do # http://stackoverflow.com/a/12792313/322020
+      define_method name do |*args|
+        args.inject do |memo, obj|
+          block.call memo, obj
         end
       end
     end
   end
 
-  define_listable_function :divide do |a, b|
-    a / b
-  end
+  define_orderless_function (:plus) { |a, b| _plus a, b }
+  define_orderless_function (:times) { |a, b| _times a, b }
 
   def self.subdivide *args
     case args.size
-    when 1 ; subdivide 1, args[0]
-    when 2 ; subdivide 0, args[0], args[1]
-    when 3 ; range(args[0], args[1], (args[1] - args[0]) * 1.0 / args[2])
+      when 1 ; subdivide 1, args[0]
+      when 2 ; subdivide 0, args[0], args[1]
+      when 3 ; range(args[0], args[1], (args[1] - args[0]) * 1.0 / args[2])
+      ## using only pure Ruby methods makes unittests more reliable
+      # when 3 ; plus args[0], divide(times(1.0, args[1] - args[0], range(0, args[2])), args[2])
     else
       raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..3)")
     end

data/mll.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "mll"
-  spec.version       = "0.3.0"
+  spec.version       = "0.4.0"
   spec.authors       = ["Victor Maslov"]
   spec.email         = ["nakilon@gmail.com"]
   spec.summary       = "Mathematica Language Library in Ruby"

data/spec/_spec.rb

@@ -1,9 +1,26 @@
 require_relative File.join "..", "lib", "mll"
 
 
-# PERMANENT TODO test all implemented exceptions
-# PERMANENT TODO test all types returned
-
+# PERMATODO test all implemented exceptions
+# PERMATODO test all types returned (not actually all but about lazyness)
+# PERMATODO check for "Details" paragraphs to make more trivial examples
+# PERMATODO leave here only useful tests, not demostrations -- move them to README.rb
+# PERMATODO single element Arrays tests
+# PERMATODO move Properties & Relations to some separate contexts maybe
+
+# TODO test all implemented exceptions
+# TODO test all types returned (not actually all but about lazyness)
+# TODO check for "Details" paragraphs to make more trivial examples
+# TODO leave here only useful tests, not demostrations -- move them to README.rb
+# TODO single element Arrays tests
+# TODO move Properties & Relations to some separate contexts maybe
+
+# TODO @fraggedICE wishes using Rational -- would also allow implementing more examples
+# TODO rake task for appending TODOs and pendings to README.rb
+# TODO rename examples according to their description not content
+# TODO elegantly get rid of repetitive type checks
+# TODO implement #power for use in unittests
+# TODO let(:fake_lambda){ ->(*args){fail} } ?
 
 # http://reference.wolfram.com/language/guide/LanguageOverview.html
 describe MLL do
@@ -14,13 +31,35 @@ describe MLL do
     # NO URL
     describe "Mathematics & Operators" do
 
+      # http://reference.wolfram.com/language/ref/Subtract.html
+      describe "#subtract" do
+
+        describe "Basic Examples" do
+
+          example "subtract(n1, n2)" do
+            expect(MLL::subtract(10,3)).to eq 7
+          end
+
+        end
+
+        describe "Scope" do
+
+          example "subtract(list, n)" do
+            expect(MLL::subtract([1,2,3,4],0.5)).to be_a Enumerator
+            expect(MLL::subtract([1,2,3,4],0.5).to_a).to eq [0.5,1.5,2.5,3.5]
+          end
+
+        end
+
+      end
+
       # http://reference.wolfram.com/language/ref/Divide.html
       describe "#divide" do
 
         describe "Basic Examples" do
 
-          example "n1 / n2" do
-            expect(MLL::divide(77,11)).to be_a Fixnum
+          example "divide(n1, n2)" do
+            # expect(MLL::divide(77,11)).to be_a Fixnum
             expect(MLL::divide(77,11)).to eq 7
           end
 
@@ -28,11 +67,11 @@ describe MLL do
 
         describe "Scope" do
 
-          example "list / n" do
+          example "divide(list, n)" do
             expect(MLL::divide([2,3,4,5],2.0)).to be_a Enumerator
             expect(MLL::divide([2,3,4,5],2.0).to_a).to eq [1,1.5,2,2.5]
           end
-          example "list / list" do
+          example "divide(list, list)" do
             expect(MLL::divide([2,3,4],[2,1,4])).to be_a Enumerator
             expect(MLL::divide([2,3,4],[2,1,4]).to_a).to eq [1,3,1]
           end
@@ -41,11 +80,6 @@ describe MLL do
 
         describe "Applications" do
 
-          example "foldlist(divide, 1, range(10))" do
-            pending "#foldlist is yet to be implemented"
-            fail
-          end
-
           # TODO: "Successive ratios in a list:"
 
         end
@@ -56,7 +90,7 @@ describe MLL do
             pending "#nestlist is yet to be implemented"
             fail
           end
-          example "table(divide, n1, n2)" do
+          example "table(function, n1, n2)" do
             expect(MLL::table(MLL.method(:divide), [[3,6]], 4.0)).to be_a Array
             expect(MLL::table(MLL.method(:divide), [[6]], 4.0)).to eq [[6.0,3.0,2.0,1.5]]
           end
@@ -65,6 +99,73 @@ describe MLL do
 
       end
 
+      # TODO common tests for threading functions like times, plus, etc.
+
+      # http://reference.wolfram.com/language/ref/Plus.html
+      describe "#plus" do
+
+        describe "Basic Examples" do
+
+          example "plus(n1, n2, n3)" do
+            expect(MLL::plus(2,3,4)).to eq 9
+          end
+          example "plus([n1, n2, n3], n)" do
+            expect(MLL::plus([3,4,5],2)).to be_a Enumerator
+            expect(MLL::plus([3,4,5],2).to_a).to eq [5,6,7]
+          end
+          example "plus(n1, n2, [n3, n4])" do
+            expect(MLL::plus(2,3,[4,5])).to be_a Enumerator
+            expect(MLL::plus(2,3,[4,5]).to_a).to eq [9,10]
+          end
+          example "plus(list, list)" do
+            expect(MLL::plus([10,20,30],[1,2,3])).to be_a Enumerator
+            expect(MLL::plus([10,20,30],[1,2,3]).to_a).to eq [11,22,33]
+          end
+          example "plus(list_of_lists, n)" do
+            expect(MLL::plus([[1,2],[3,4]],5)).to be_a Enumerator
+            expect(MLL::plus([[1,2],[3,4]],5).to_a.map(&:to_a)).to eq [[6,7],[8,9]]
+          end
+          example "plus(list_of_lists, list_of_lists)" do
+            expect(MLL::plus([[1,2],[3,4]],[[5,6],[7,8]])).to be_a Enumerator
+            expect(MLL::plus([[1,2],[3,4]],[[5,6],[7,8]]).to_a.map(&:to_a)).to eq [[6,8],[10,12]]
+          end
+          example "plus([[n1, n2], [n3, n4]], [n5, n6])" do
+            expect(MLL::plus([[1,2],[3,4]],[5,6])).to be_a Enumerator
+            expect(MLL::plus([[1,2],[3,4]],[5,6]).to_a.map(&:to_a)).to eq [[6,7],[9,10]]
+          end
+
+        end
+
+        # TODO "Accumulate makes a cumulative sum:"
+
+      end
+
+      # http://reference.wolfram.com/language/ref/Times.html
+      describe "#times" do
+
+        describe "Basic Examples" do
+
+          example "times(n1, n2, n3)" do
+            # expect(MLL::times(2,3,4)).to be_a Fixnum
+            expect(MLL::times(2,3,4)).to eq 24
+          end
+          example "times(n, [n1, n2, n3])" do
+            expect(MLL::times(2,[3,4,5])).to be_a Enumerator
+            expect(MLL::times(2,[3,4,5]).to_a).to eq [6,8,10]
+          end
+          example "times(n1, n2, [n3, n4])" do
+            expect(MLL::times(2,3,[4,5])).to be_a Enumerator
+            expect(MLL::times(2,3,[4,5]).to_a).to eq [24,30]
+          end
+          example "times([[n1, n2], [n3, n4]], [n5, n6])" do
+            expect(MLL::times([[1,2],[3,4]],[5,6])).to be_a Enumerator
+            expect(MLL::times([[1,2],[3,4]],[5,6]).to_a.map(&:to_a)).to eq [[5,10],[18,24]]
+          end
+
+        end
+
+      end
+
     end
 
   end
@@ -75,6 +176,66 @@ describe MLL do
     # http://reference.wolfram.com/language/guide/ConstructingLists.html
     describe "Constructing Lists" do
 
+      # http://reference.wolfram.com/language/ref/Table.html
+      describe "#table" do
+
+        describe "Basic Examples" do
+
+          example "table(lambda, n)" do
+            expect(MLL::table(->(i){ i**2 }, 10)).to be_a Array
+            expect(MLL::table(->(i){ i**2 }, 10)).to eq [1,4,9,16,25,36,49,64,81,100]
+          end
+          example "table(lambda, [min, max, step])" do
+            expect(MLL::table(->(i){ i+2 }, [0, 20, 2])).to be_a Array
+            expect(MLL::table(->(i){ i+2 }, [0, 20, 2])).to eq [2,4,6,8,10,12,14,16,18,20,22]
+          end
+          example "table(lambda, n1, n2)" do
+            # TODO example to README.rb about multiplication table
+            expect(MLL::table(->(i,j){ 10*i + j }, 4, 3)).to be_a Array
+            expect(MLL::table(->(i,j){ 10*i + j }, 4, 3)).to eq [[11,12,13],[21,22,23],[31,32,33],[41,42,43]]
+          end
+          example "table(lambda, n1, min..max, [max, min, -step])" do
+            expect(MLL::table(->(i,j,k){ [i,j,k] }, 3, 2..3, [5, 1, -2])).to be_a Array
+            expect(MLL::table(->(i,j,k){ [i,j,k] }, 3, 2..3, [5, 1, -2])).to eq \
+            [
+             [[[1, 2, 5], [1, 2, 3], [1, 2, 1]], [[1, 3, 5], [1, 3, 3], [1, 3, 1]]],
+             [[[2, 2, 5], [2, 2, 3], [2, 2, 1]], [[2, 3, 5], [2, 3, 3], [2, 3, 1]]],
+             [[[3, 2, 5], [3, 2, 3], [3, 2, 1]], [[3, 3, 5], [3, 3, 3], [3, 3, 1]]]
+            ]
+          end
+
+          example "matrix_form table(lambda, n1, n2)" do
+            pending "#matrix_form is yet to be implemented"
+            expect(MLL::matrix_form MLL::table(->(i,j){ 10*i + j }, 4, 3)).to eq "
+            "
+          end
+
+        end
+
+        describe "Scope" do
+
+          # TODO: "Make a triangular array:"
+
+          example "table(lambda, [list1], [list2])" do
+            expect(MLL::table(->(base, power){ base ** power }, [[1,2,4]], [[1,3,4]])).to be_a Array
+            expect(MLL::table(->(base, power){ base ** power }, [[1,2,4]], [[1,3,4]])).to eq [[1,1,1],[2,8,16],[4,64,256]]
+            expect(MLL::table(MLL::method(:plus), [[1]], [[2]])).to be_a Array
+            expect(MLL::table(MLL::method(:plus), [[1]], [[2]])).to eq [[3]]
+          end
+
+        end
+
+        describe "Applications" do
+
+          example "column table(binomial, )" do
+            pending "#binomial and #column are yet to be implemented"
+            fail
+          end
+
+        end
+
+      end
+
       # http://reference.wolfram.com/language/ref/Range.html
       describe "#range" do
 
@@ -160,60 +321,163 @@ describe MLL do
 
       end
 
-      # http://reference.wolfram.com/language/ref/Table.html
-      describe "#table" do
-        # TODO type checks
+      # http://reference.wolfram.com/language/ref/Subdivide.html
+      describe "#subdivide" do
+
+        example "subdivide(n)" do
+          expect(MLL::subdivide(4)).to be_a Enumerator
+          expect(MLL::subdivide(4).to_a).to eq [0,0.25,0.5,0.75,1]
+        end
+        example "subdivide(max, n)" do
+          expect(MLL::subdivide(10,5)).to be_a Enumerator
+          expect(MLL::subdivide(10,5).to_a).to eq [0,2,4,6,8,10]
+        end
+        example "subdivide(min, max, n)" do
+          expect(MLL::subdivide(-1,1,8)).to be_a Enumerator
+          expect(MLL::subdivide(-1,1,8).to_a).to eq [-1,-0.75,-0.5,-0.25,0,0.25,0.5,0.75,1]
+        end
+        example "subdivide(max, min, n)" do
+          expect(MLL::subdivide(1,-1,8)).to be_a Enumerator
+          expect(MLL::subdivide(1,-1,8).to_a).to eq [1,0.75,0.5,0.25,0,-0.25,-0.5,-0.75,-1]
+        end
+
+      end
+
+      # http://reference.wolfram.com/language/ref/NestList.html
+      describe "#nest_list" do
+
+        example "#nest_list  gives a list of length n+1" do
+          expect(MLL::nest_list(->{}, 0, 5)).to be_a Enumerator
+          expect(MLL::nest_list(->(*args){}, 0, 5).to_a.size).to eq 6
+        end
 
         describe "Basic Examples" do
 
-          example "table(lambda, n)" do
-            expect(MLL::table(->(i){ i**2 }, 10)).to be_a Array
-            expect(MLL::table(->(i){ i**2 }, 10)).to eq [1,4,9,16,25,36,49,64,81,100]
+          example "'nest_list with #cos starting with 1.0)'" do
+            pending "#cos is yet to be implemented"
+            fail
           end
-          example "table(lambda, [min, max, step])" do
-            expect(MLL::table(->(i){ i+2 }, [0, 20, 2])).to be_a Array
-            expect(MLL::table(->(i){ i+2 }, [0, 20, 2])).to eq [2,4,6,8,10,12,14,16,18,20,22]
+
+        end
+
+        describe "Scope" do
+
+          example "nesting can return a single number" do
+            pending "#sqrt is yet to be implemented"
+            fail
           end
-          example "table(lambda, n1, n2)" do
-            # TODO example to README.rb about multiplication table
-            expect(MLL::table(->(i, j){ 10*i + j }, 4, 3)).to be_a Array
-            expect(MLL::table(->(i, j){ 10*i + j }, 4, 3)).to eq [[11,12,13],[21,22,23],[31,32,33],[41,42,43]]
+
+        end
+
+        describe "Applications" do
+
+          example "powers of 2" do
+            expect(MLL::nest_list(->(i){ 2*i }, 1, 10)).to be_a Enumerator
+            expect(MLL::nest_list(->(i){ 2*i }, 1, 10).to_a).to eq [1,2,4,8,16,32,64,128,256,512,1024]
           end
-          example "table(lambda, n1, min..max, [max, min, -step])" do
-            expect(MLL::table(->(i,j,k){ [i,j,k] }, 3, 2..3, [5, 1, -2])).to be_a Array
-            expect(MLL::table(->(i,j,k){ [i,j,k] }, 3, 2..3, [5, 1, -2])).to eq \
-            [
-             [[[1, 2, 5], [1, 2, 3], [1, 2, 1]], [[1, 3, 5], [1, 3, 3], [1, 3, 1]]],
-             [[[2, 2, 5], [2, 2, 3], [2, 2, 1]], [[2, 3, 5], [2, 3, 3], [2, 3, 1]]],
-             [[[3, 2, 5], [3, 2, 3], [3, 2, 1]], [[3, 3, 5], [3, 3, 3], [3, 3, 1]]]
-            ]
+          example "iterates in the  problem" do
+            expect(MLL::nest_list(->(i){ i.even? ? i/2 : (i*3+1)/2 }, 100, 20)).to be_a Enumerator
+            expect(MLL::nest_list(->(i){ i.even? ? i/2 : (i*3+1)/2 }, 100, 20).to_a).to eq [100,50,25,38,19,29,44,22,11,17,26,13,20,10,5,8,4,2,1,2,1]
+          end
+          example "linear congruential pseudorandom generator" do
+            expect(MLL::nest_list(->(i){ (i*59)%101 }, 1, 15)).to be_a Enumerator
+            expect(MLL::nest_list(->(i){ (i*59)%101 }, 1, 15).to_a).to eq [1,59,47,46,88,41,96,8,68,73,65,98,25,61,64,39]
+          end
+          example "random walk" do
+            expect(( r = Random.new(0); MLL::nest_list(->(i){ i+[-1,1][r.rand(2)] }, 0, 20) )).to be_a Enumerator
+            expect(( r = Random.new(0); MLL::nest_list(->(i){ i+[-1,1][r.rand(2)] }, 0, 20).to_a )).to eq [0,-1,0,1,0,1,2,3,4,5,6,7,6,5,6,5,4,3,2,1,2]
+          end
+          example "successively rotate a list" do
+            expect(MLL::nest_list(->(i){ i.rotate 1 }, [1,2,3,4], 4)).to be_a Enumerator
+            expect(MLL::nest_list(->(i){ i.rotate 1 }, [1,2,3,4], 4).to_a).to eq [[1,2,3,4],[2,3,4,1],[3,4,1,2],[4,1,2,3],[1,2,3,4]]
           end
 
-          example "matrix_form table(lambda, n1, n2)" do
-            pending "#matrix_form is yet to be implemented"
-            expect(MLL::matrix_form MLL::table(->(i, j){ 10*i + j }, 4, 3)).to eq "
-            "
+        end
+
+        describe "Properties & Relations" do
+
+          # TODO "Nest gives the last element of NestList:"
+
+          example "nesting zero times simply returns to the original argument" do
+            expect(MLL::nest_list(->{fail}, 5, 0)).to be_a Enumerator
+            expect(MLL::nest_list(->(*args){fail}, 5, 0).to_a).to eq [5]
+          end
+          example "#fold_list automatically inserts second arguments from a list" do
+            expect(MLL::nest_list(->(i  ){ i*2 }, 3,     4).to_a).to eq \
+                   MLL::fold_list(->(i,j){ i*j }, 3, [2]*4).to_a
           end
 
         end
 
-        describe "Scope" do
+      end
 
-          # TODO: "Make a triangular array:"
+    end
 
-          example "table(lambda, [list1], [list2])" do
-            expect(MLL::table(->(base, power){ base ** power }, [[1,2,4]], [[1,3,4]])).to be_a Array
-            expect(MLL::table(->(base, power){ base ** power }, [[1,2,4]], [[1,3,4]])).to eq [[1,1,1],[2,8,16],[4,64,256]]
-            expect(MLL::table(->(i,j){ i+j }, [[1]], [[2]])).to be_a Array
-            expect(MLL::table(->(i,j){ i+j }, [[1]], [[2]])).to eq [[3]]
+    # http://reference.wolfram.com/language/guide/ApplyingFunctionsToLists.html
+    describe "Applying Functions to Lists" do
+
+      describe "#fold_list" do
+
+        describe "Basic Examples" do
+
+          example "fold_list(function, list)" do
+            expect(MLL::fold_list(MLL.method(:plus),[1,2,3,4])).to be_a Enumerator
+            expect(MLL::fold_list(MLL.method(:plus),[1,2,3,4]).to_a).to eq [1,3,6,10]
+          end
+          example "fold_list(function, n, list)" do
+            expect(MLL::fold_list(MLL.method(:plus),5,[1,2,3,4])).to be_a Enumerator
+            expect(MLL::fold_list(MLL.method(:plus),5,[1,2,3,4]).to_a).to eq [5,6,8,11,15]
+          end
+          example "fold_list(lambda, n, list)" do
+            expect(MLL::fold_list(->(base, power){ base ** power },2,[3,2,1])).to be_a Enumerator
+            expect(MLL::fold_list(->(base, power){ base ** power },2,[3,2,1]).to_a).to eq [2,8,64,64]
           end
 
         end
 
         describe "Applications" do
 
-          example "column table(binomial, )" do
-            pending "#binomial and #column are yet to be implemented"
+          example "fold_list(function, n, list)" do
+            expect(MLL::fold_list(MLL.method(:times), [*1..10])).to be_a Enumerator
+            expect(MLL::fold_list(MLL.method(:times), [*1..10]).to_a).to eq [1,2,6,24,120,720,5040,40320,362880,3628800]
+          end
+          example "fold_list(lambda, n, list)" do
+            expect(MLL::fold_list(->(a,b){ 10*a + b }, 0, [4,5,1,6,7,8])).to be_a Enumerator
+            expect(MLL::fold_list(->(a,b){ 10*a + b }, 0, [4,5,1,6,7,8]).to_a).to eq [0,4,45,451,4516,45167,451678]
+          end
+          example "fold_list(lambda, n, list)" do
+            expect(( r = Random.new(0); MLL::fold_list(MLL.method(:plus), 0, Array.new(20){ [-1,1][r.rand(2)] }) )).to be_a Enumerator
+            expect(( r = Random.new(0); MLL::fold_list(MLL.method(:plus), 0, Array.new(20){ [-1,1][r.rand(2)] }).to_a )).to eq [0,-1,0,1,0,1,2,3,4,5,6,7,6,5,6,5,4,3,2,1,2]
+          end
+
+          # TODO "Find successively deeper parts in an expression:"
+
+        end
+
+        describe "Properties & Relations" do
+
+          example "#fold_list makes a list of length n+1" do
+            expect(MLL::fold_list(->{}, 0, [*1..10])).to be_a Enumerator
+            expect(MLL::fold_list(->(*args){}, 0, [*1..10]).to_a.size).to eq 11
+          end
+          example "folding with an empty list does not apply the function at all" do
+            expect(MLL::fold_list(->{}, 0, [])).to be_a Enumerator
+            expect(MLL::fold_list(->(*args){}, 0, []).to_a).to eq [0]
+          end
+          example "Ruby#inject gives the last element of #fold_list" do
+            f = ->(i,j){ i+j }
+            expect(MLL::fold_list(f, [1,2,3])).to be_a Enumerator
+            expect(MLL::fold_list(f, [1,2,3]).to_a.last).to eq [1,2,3].inject(&f)
+          end
+          # TODO "Functions that ignore their second argument give the same result as in NestList:"
+          # TODO "Accumulate is equivalent to FoldList with Plus:"
+
+        end
+
+        describe "Neat Examples" do
+
+          example "compute the minimum number of coins of different value needed to make up an amount" do
+            pending "at least #mod is yet to be implemented"
             fail
           end
 
@@ -221,40 +485,78 @@ describe MLL do
 
       end
 
-      # http://reference.wolfram.com/language/ref/Subdivide.html
-      describe "#subdivide" do
+    end
+
+    # TODO http://reference.wolfram.com/language/guide/ElementsOfLists.html
+    # TODO http://reference.wolfram.com/language/guide/RearrangingAndRestructuringLists.html
+    # TODO http://reference.wolfram.com/language/guide/MathematicalAndCountingOperationsOnLists.html
+
+  end
+
+  # http://reference.wolfram.com/language/guide/FunctionalProgramming.html
+  describe "Functional Programming" do
+
+    # http://reference.wolfram.com/language/guide/FunctionalIteration.html
+    describe "Iteratively Applying Functions" do
+
+      # TODO move #nest_list and #fold_list and others here?
+
+      describe "#nest" do
+
+        describe "Basic Examples" do
+
+          example "the function to nest can be a pure function" do
+            expect(MLL::nest(->(i){ (1+i)**2 }, 1, 3)).to eq 676
+          end
 
-        example "subdivide(n)" do
-          expect(MLL::subdivide(4)).to be_a Enumerator
-          expect(MLL::subdivide(4).to_a).to eq [0,0.25,0.5,0.75,1]
         end
-        example "subdivide(max, n)" do
-          expect(MLL::subdivide(10,5)).to be_a Enumerator
-          expect(MLL::subdivide(10,5).to_a).to eq [0,2,4,6,8,10]
+
+        describe "Scope" do
+
+          example "nesting can return a single number" do
+            pending "#sqrt is yet to be implemented"
+            fail
+          end
+
         end
-        example "subdivide(min, max, n)" do
-          expect(MLL::subdivide(-1,1,8)).to be_a Enumerator
-          expect(MLL::subdivide(-1,1,8).to_a).to eq [-1,-0.75,-0.5,-0.25,0,0.25,0.5,0.75,1]
+
+        describe "Applications" do
+
+          example "newton iterations for" do
+            pending "need to deal with Rationals first"
+            fail
+          end
+          example "consecutive pairs of Fibonacci numbers" do
+            pending "implement #dot ?"
+            fail
+          end
+
         end
-        example "subdivide(max, min, n)" do
-          expect(MLL::subdivide(1,-1,8)).to be_a Enumerator
-          expect(MLL::subdivide(1,-1,8).to_a).to eq [1,0.75,0.5,0.25,0,-0.25,-0.5,-0.75,-1]
+
+        describe "Properties & Relations" do
+
+          example "#fold automatically inserts second arguments from a list" do
+            expect(MLL::nest(->(i){       i*2 }, 3, 4)).to eq \
+                 ([2]*4).inject(3){ |i,j| i*j }
+          end
+
         end
 
+        # TODO neat graphic examples
+
       end
 
     end
 
-    # http://reference.wolfram.com/language/guide/ElementsOfLists.html
-    # http://reference.wolfram.com/language/guide/RearrangingAndRestructuringLists.html
-    # http://reference.wolfram.com/language/guide/ApplyingFunctionsToLists.html
-    # http://reference.wolfram.com/language/guide/MathematicalAndCountingOperationsOnLists.html
-
   end
 
-  # http://reference.wolfram.com/language/guide/FunctionalProgramming.html
-
 end
 
-      # http://reference.wolfram.com/language/guide/HandlingArraysOfData.html
-      # http://reference.wolfram.com/language/guide/ComputationWithStructuredDatasets.html
+# TODO http://reference.wolfram.com/language/guide/HandlingArraysOfData.html
+# TODO http://reference.wolfram.com/language/guide/ComputationWithStructuredDatasets.html
+
+__END__
+
+Table   Array
+Times   Product
+Plus    Total   Sum?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mll
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Victor Maslov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-08 00:00:00.000000000 Z
+date: 2015-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler