mll 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 812325964160837ba11226c5585e372463dd9fd7
-  data.tar.gz: fb060b7f5a405a230b21a20c9cc8426e5bd7e19b
+  metadata.gz: ce709bc99f6cbd85ca763a4752346b0b5e4112cb
+  data.tar.gz: 0e6ba411ce044ecffbc476fcbefcb61a8cf18926
 SHA512:
-  metadata.gz: 5fe15ad50531a0b9740847b01c27ed76e598d0345a0158b22474715a7fbb8bc917479c406ef1cac3580b167dd19b30bca820665888792657e8be6bc2a1f67b81
-  data.tar.gz: dd3547ff6b62c5ecd29d91529aee42e1552cb0d90bde926e7d8e090cdcf1df7ca1792aa110835a82133127f2f33d2c56a6421ab2ca56e778acbead64537c7380
+  metadata.gz: 6464f5860f02778245155c5f7ec98b61bde188482ef2fb90593baf1cf72fbede13ddd47654288745684d0fdc314cbe3e2609284fcb53cd329c6175b288686845
+  data.tar.gz: 00014f6f4d963c1512f844703b39888f084ebe1495e2fedffc3abe0bc29db2af3f78b40618c3280560414b6729c6d490cd2923faf6397fb26645a891f7f7b657

data/README.md

@@ -1,5 +1,7 @@
 # MLL (Mathematica Language Library)
 
+[![Gem Version](https://badge.fury.io/rb/mll.svg)](http://badge.fury.io/rb/mll)
+
 ## What
 
 This gem isn't supposed to mimic all data types, exact syntax of Wolfram Mathematica or make Ruby able to make the same visualisations.
@@ -8,11 +10,13 @@ The main goal is to make Ruby more powerful by including the most used functions
 
 ## Why
 
+0. `::map` can map Arrays at specified depth!
 1. One of the most useful things is automatic zipping vectors (`Array`s) when you apply scalar functions to them. https://reference.wolfram.com/language/ref/Listable.html
 2. unlike Ruby's `Range` class, `::range` can handle negative `step` and even have `float` starting value
-3. unlike Ruby's `Array#map`, `::table` can create multidimensional arrays with a single call, not nested
-4. `#fold_list` was wanted [here](http://stackoverflow.com/q/1475808/322020) in Ruby while being already implemented as [FoldList[]](http://reference.wolfram.com/language/ref/FoldList.html) in Mathematica and [scanl](http://hackage.haskell.org/package/base-4.8.0.0/docs/Prelude.html#v:scanl) in Haskell
-5. `#nest` (n times) and `#nest_list` for repetitive applying the same function -- `#nest_while` and `#nest_while_list` are going to be implemented later
+3. unlike Ruby's `Array.new`, `::table` can create multidimensional arrays with a single call, not nested
+4. `::fold_list` was wanted [here](http://stackoverflow.com/q/1475808/322020) in Ruby while being already implemented as [FoldList[]](http://reference.wolfram.com/language/ref/FoldList.html) in Mathematica and [scanl](http://hackage.haskell.org/package/base-4.8.0.0/docs/Prelude.html#v:scanl) in Haskell
+5. `::nest` (n times) and `::nest_list` for repetitive applying the same function -- `::nest_while` and `::nest_while_list` are going to be implemented later
+6. `::tally` -- shortcut to a probably the most common usage of `#group_by` -- calculating total occurences.
 
 ## How
 
@@ -20,11 +24,20 @@ The main goal is to make Ruby more powerful by including the most used functions
     MLL::range[[2, 3]] # => [1..2, 1..3]
     MLL::range[ 1..3 ] # => [1..1, 1..2, 1..3]
 
-    MLL::table[ ->(i,j){ i+j }, [[1, 0, 1]], [[0, 2, 0]] ]
+    t = MLL::table[ ->(i,j){ i+j }, [[1, 0, 1]], [[0, 2, 0]] ]
                        # => [[1, 3, 1],
                              [0, 2, 0],
                              [1, 3, 1]]
-    MLL::table[ MLL.method(:times), 9, 9 ]
+    t = MLL::map[ ->(i){ [i] }, t, [2] ]
+                       # => [[ [1], [3], [1] ],
+                             [ [0], [2], [0] ],
+                             [ [1], [3], [1] ]]
+    MLL::map[ ->(i){ -i }, t, [3] ]
+                       # => [[ [-1], [-3], [-1] ],
+                             [ [ 0], [-2], [ 0] ],
+                             [ [-1], [-3], [-1] ]]
+
+    MLL::table[ MLL::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],
@@ -34,6 +47,10 @@ The main goal is to make Ruby more powerful by including the most used functions
                              [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]]
+    # ::times     means  *
+    # ::divide    means  /
+    # ::subtract  means  -
+    # ::plus      means  +
 
     MLL::fold_list[ MLL::times, MLL::range[10] ]
                        # => [1,2,6,24,120,720,5040,40320,362880,3628800]
@@ -42,10 +59,6 @@ The main goal is to make Ruby more powerful by including the most used functions
     #   even of different dimensions with basic operations
     MLL::times[ [[1,2],[3,4]], [5,6] ]
                        # => [[5,10], [18,24]]
-    # ::times     means  *
-    # ::divide    means  /
-    # ::subtract  means  -
-    # ::plus      means  +
     
     # http://en.wikipedia.org/wiki/Collatz_conjecture
     MLL::nest_list[ ->(i){ i.even? ? i/2 : (i*3+1)/2 }, 20, 10 ]
@@ -57,7 +70,12 @@ The main goal is to make Ruby more powerful by including the most used functions
     MLL::subdivide[ 5, 10, 4 ]
                        # => [5.0, 6.25, 7.5, 8.75, 10.0]
     
-Note that to see some of above examples working you need `.to_a`, `.map(&:to_a)` or even `.to_a.map(&:to_a)` since lazyness is intensively used.
+    MLL::tally[ "the quick brown fox jumps over the lazy dog".chars ]
+    # => {"t"=>2, "h"=>2, "e"=>3, " "=>8, "q"=>1, "u"=>2, "i"=>1, "c"=>1, "k"=>1,
+          "b"=>1, "r"=>2, "o"=>4, "w"=>1, "n"=>1, "f"=>1, "x"=>1, "j"=>1, "m"=>1,
+          "p"=>1, "s"=>1, "v"=>1, "l"=>1, "a"=>1, "z"=>1, "y"=>1, "d"=>1, "g"=>1}
+
+Note that to see some of above examples working in the same way you need `.to_a`, `.map(&:to_a)` or even `.to_a.map(&:to_a)` since lazyness is intensively used.
 
 ## Installation
 
@@ -77,15 +95,19 @@ or
 
 ```
 module MLL
-  def self.fold_list
-    lambda do |f, x, list = nil|
-      # TODO use Ruby#inject ?
-  def self.table
-    lambda do |f, *args|
-      [].tap do |result|
-        }]].tap do |stack|
-          stack.each do |ai, ri|
-            # TODO try to make #table lazy (Enumerator instead of Array)
+  class << self
+    def fold_list
+      lambda do |f, x, list = nil|
+        # TODO use Ruby#inject ?
+    def map
+      # TODO validate depths
+      # TODO break on passing all depths
+    def table
+      lambda do |f, *args|
+        [].tap do |result|
+          }]].tap do |stack|
+            stack.each do |ai, ri|
+              # TODO try to make #table lazy (Enumerator instead of Array)
   # TODO not sure if we need any other kind of Listability except of #range[[Array]]
 ```
 
@@ -100,14 +122,29 @@ describe MLL do
   describe "List Manipulation" do
     describe "Constructing Lists" do
       describe "#table" do
-        describe "Scope" do
+        describe "Scope:" do
           # TODO: "Make a triangular array:"
       describe "#range" do
         # TODO take from docs more examples that involve other functions
     describe "Applying Functions to Lists" do
       describe "#fold_list" do
-        describe "Applications" do
+        describe "Applications:" do
           # TODO maybe move it to README.md
+      describe "#map" do
+        # TODO we'll need less nested mappings when we implement stop on depths depletion
+        describe "Details and Options:" do
+          example "levels n1 though n2" do
+            expect(map[->(i){ [i] }, [1,[2,[3,[4,[5,6]]]]], [2,4]].
+              # TODO smth _<>
+          # TODO "Level corresponds to the whole expression"
+          # TODO currying "Map[f][expr] is equivalent to Map[f,expr]"
+        describe "Scope:" do
+          # TODO "Map on all levels, starting at level" ant other about Infinity
+        describe "Properties & Relations:" do
+          # TODO #mapall
+          # TODO #mapthread ?
+          # TODO #mapindexed ?
+          # TODO "negative levels"
     # 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

data/Rakefile

@@ -26,6 +26,7 @@ task :todo do |t|
       end
       readme_file.puts "```"
     end
+    readme_file.truncate readme_file.pos
   end
 end
 

data/lib/mll.rb

@@ -1,77 +1,114 @@
 module MLL
 
-  def self.nest_list
-    lambda do |f, expr, n|
-      Enumerator.new do |e|
-        e << expr
-        n.times do
-          e << expr = f.call(expr)
+  class << self
+
+    def tally
+      lambda do |list, test = ->(i,j){ i == j } | # TODO implement #sameq ?
+        h = Hash.new{ 0 }
+        keys = []
+        list.each do |item|
+          h[item] += 1 if keys.each do |key|
+            if test[key, item]
+              h[key] += 1
+              break
+            end
+          end
+          keys << item
         end
+        h
       end
     end
-  end
-  # def self.nest *args
-  #   nest_list(*args).last
-  # end
-  def self.nest
-    lambda do |f, expr, n|
-      n.times{ expr = f.call expr }
-      expr
+
+    def nest_list
+      lambda do |f, expr, n|
+        Enumerator.new do |e|
+          e << expr
+          n.times do
+            e << expr = f.call(expr)
+          end
+        end
+      end
+    end
+    # def self.nest *args
+    #   nest_list(*args).last
+    # end
+    def nest
+      lambda do |f, expr, n|
+        n.times{ expr = f.call expr }
+        expr
+      end
     end
-  end
 
-  def self.fold_list
-    lambda do |f, x, list = nil|
-      x, *list = x.to_a unless list
-      # TODO use Ruby#inject ?
-      Enumerator.new do |e|
-        e << x
-        list.each do |i|
-          e << x = f.call(x, i)
+    def fold_list
+      lambda do |f, x, list = nil|
+        x, *list = x.to_a unless list
+        # TODO use Ruby#inject ?
+        Enumerator.new do |e|
+          e << x
+          list.each do |i|
+            e << x = f.call(x, i)
+          end
         end
       end
     end
-  end
 
-  def self.table
-    lambda do |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
-            }
+    def map
+      # TODO validate depths
+      # TODO break on passing all depths
+      lambda do |f, list, depths = [1]|
+        depths = Range.new(*depths) if depths.size == 2
+        depths = Range.new(1,depths) if depths.is_a? Integer
+        g = lambda do |list, depth|
+          next list unless list.respond_to? :map
+          temp = list.lazy.map{ |i| g[i, depth + 1] }
+          temp = temp.map &f if depths.include? depth
+          temp
+        end
+        g[list, 1]
+      end
+    end
+
+    def table
+      lambda do |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
+              }
+            end
           end
         end
       end
     end
-  end
 
-  def self.define_listable_function name, &block
-    (class << self; self end).class_eval do
-      define_method name do
-        lambda do |*args|
-          case args.map{ |i| i.respond_to? :map }
-            when [true] ; args.first.lazy.map &method(name).call
-            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
+    def define_listable_function name, &block
+      (class << self; self end).class_eval do
+        define_method name do
+          lambda do |*args|
+            case args.map{ |i| i.respond_to? :map }
+              when [true] ; args.first.lazy.map &method(name).call
+              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
     end
+
   end
 
   # TODO not sure if we need any other kind of Listability except of #range[[Array]]
@@ -98,6 +135,20 @@ module MLL
     end
   end
 
+  def self.subdivide
+    lambda do |*args|
+      case args.size
+        when 1 ; subdivide[1, args[0]]
+        when 2 ; subdivide[0, args[0], args[1]]
+        when 3
+          # raise ArgumentError.new("can't divide into 0 parts") if args[2].zero?
+          range[args[0], args[1], (args[1] - args[0]) * 1.0 / args[2]]
+      else
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..3)")
+      end
+    end
+  end
+
   define_listable_function(:subtract) { |*args| raise ArgumentError.new("need two arguments") unless args.size == 2 ; args[0] - args[1] }
   define_listable_function(:divide)   { |*args| raise ArgumentError.new("need two arguments") unless args.size == 2 ; args[0] / args[1] }
   define_listable_function(:_plus)    { |*args| raise ArgumentError.new("need two arguments") unless args.size == 2 ; args[0] + args[1] }
@@ -120,18 +171,4 @@ module MLL
   define_orderless_function(:plus,  0) { |a, b| _plus.call  a, b }
   define_orderless_function(:times, 1) { |a, b| _times.call a, b }
 
-  def self.subdivide
-    lambda do |*args|
-      case args.size
-        when 1 ; subdivide[1, args[0]]
-        when 2 ; subdivide[0, args[0], args[1]]
-        when 3
-          # raise ArgumentError.new("can't divide into 0 parts") if args[2].zero?
-          range[args[0], args[1], (args[1] - args[0]) * 1.0 / args[2]]
-      else
-        raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..3)")
-      end
-    end
-  end
-
 end

data/mll.gemspec

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

data/spec/_spec.rb

@@ -38,7 +38,7 @@ describe MLL do
           expect{ subtract[0,0,0] }.to raise_error ArgumentError
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "subtract numbers" do
             expect(subtract[10,3]).to eq 7
@@ -46,7 +46,7 @@ describe MLL do
 
         end
 
-        describe "Scope" do
+        describe "Scope:" do
 
           example "threads element‐wise over lists" do
             expect(subtract[[1,2,3,4],0.5]).to be_a Enumerator
@@ -79,7 +79,7 @@ describe MLL do
           expect{ divide[0,0,0] }.to raise_error ArgumentError
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "divide numbers" do
             expect(divide[77,11]).to eq 7
@@ -87,7 +87,7 @@ describe MLL do
 
         end
 
-        describe "Scope" do
+        describe "Scope:" do
 
           example "threads element‐wise over lists" do
             expect(divide[[2,3,4,5],2.0]).to be_a Enumerator
@@ -108,7 +108,7 @@ describe MLL do
 
         end
 
-        describe "Applications" do
+        describe "Applications:" do
 
           example "successive ratios in a list" do
             skip "waiting for Rationals to be used"
@@ -121,7 +121,7 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/Plus.html
       describe "#plus" do
 
-        describe "Details" do
+        describe "Details:" do
 
           example "#plus[] is taken to be 0" do
             expect(plus[]).to eq 0
@@ -132,7 +132,7 @@ describe MLL do
 
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "sums numbers" do
             expect(plus[2,3,4]).to eq 9
@@ -149,7 +149,7 @@ describe MLL do
 
         end
 
-        describe "Scope" do
+        describe "Scope:" do
 
           example "threads element‐wise over lists" do
             expect(plus[[10,20,30],[1,2,3]]).to be_a Enumerator
@@ -164,7 +164,7 @@ describe MLL do
 
         end
 
-        describe "Possible Issues" do
+        describe "Possible Issues:" do
 
           # idk why not in 'Properties & Relations'
           example "accumulate makes a cumulative sum" do
@@ -179,7 +179,7 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/Times.html
       describe "#times" do
 
-        describe "Details" do
+        describe "Details:" do
 
           example "#times[] is taken to be 1" do
             expect(times[]).to eq 1
@@ -190,7 +190,7 @@ describe MLL do
 
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "multiplies numbers" do
             expect(times[2,3,4]).to eq 24
@@ -206,7 +206,7 @@ describe MLL do
 
         end
 
-        describe "Scope" do
+        describe "Scope:" do
 
           example "threads element‐wise over lists" do
             expect(times[[2,3],[4,5]]).to be_a Enumerator
@@ -236,7 +236,7 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/Table.html
       describe "#table" do
 
-        describe "Details" do
+        describe "Details:" do
 
           example "#table[expr,spec1,spec2] is effectively equivalent to #table[#table[expr,spec2],spec1]" do
             expect(table[->(i,j){ [i,j] }, 2, 3]).to eq table[->(i){ table[->(j){ [i,j] }, 3] }, 2]
@@ -244,7 +244,7 @@ describe MLL do
 
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "a table of the first 10 squares" do
             expect(table[->(i){ i**2 }, 10]).to be_a Array
@@ -271,7 +271,7 @@ describe MLL do
           ]
         end
 
-        describe "Scope" do
+        describe "Scope:" do
 
           # TODO: "Make a triangular array:"
 
@@ -284,7 +284,7 @@ describe MLL do
 
         end
 
-        describe "Applications" do
+        describe "Applications:" do
 
           example "column table(binomial, )" do
             skip "#binomial and #column are yet to be implemented"
@@ -309,7 +309,7 @@ describe MLL do
           expect{ range[1,2,0] }.to raise_error ArgumentError
         end
 
-        describe "Details" do
+        describe "Details:" do
 
           example "the arguments need not be integers" do
             expect(range[0.25,2.9,1.25]).to be_a Enumerator
@@ -318,7 +318,7 @@ describe MLL do
 
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "range(n)" do
             expect(range[4]).to be_a Enumerator
@@ -344,7 +344,7 @@ describe MLL do
           expect(range[3,1,-1].to_a).to eq [3,2,1]
         end
 
-        describe "Generalizations & Extensions" do
+        describe "Generalizations & Extensions:" do
 
           example "use a list of range specifications" do
             expect(range[[5,2,6,3]]).to be_a Enumerator
@@ -356,7 +356,7 @@ describe MLL do
 
         end
 
-        describe "Applications" do
+        describe "Applications:" do
 
           example "produce a geometric sequence" do
             skip "#power is yet to be implemented"
@@ -366,7 +366,7 @@ describe MLL do
 
         end
 
-        describe "Properties & Relations" do
+        describe "Properties & Relations:" do
 
           example "#range[imin,imax,di] is equivalent to #table[i,[imin,imax,di]]" do
             expect(range[2,8,3].to_a).to eq table[->(i){ i }, [2,8,3]]
@@ -386,7 +386,7 @@ describe MLL do
           expect(range[1..3].to_a.map(&:to_a)).to eq [[1],[1,2],[1,2,3]]
         end
 
-        describe "Neat Examples" do
+        describe "Neat Examples:" do
 
           example "make nested ranges" do
             range[range[range[3]]].tap do |o|
@@ -418,7 +418,7 @@ describe MLL do
         #   expect{ subdivide[0] }.to raise_error ArgumentError
         # end
 
-        describe "Details" do
+        describe "Details:" do
 
           example "generates a list of length n+1" do
             expect(subdivide[5]).to be_a Enumerator
@@ -427,7 +427,7 @@ describe MLL do
 
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "subdivide the unit interval into 4 equal parts" do
             expect(subdivide[4]).to be_a Enumerator
@@ -450,7 +450,7 @@ describe MLL do
 
         end
 
-        describe "Properties & Relations" do
+        describe "Properties & Relations:" do
 
           example "subdivide[xmin,xmax,n] is equivalent to xmin+(xmax-xmin)Range[0,n]/n" do
             expect(subdivide[2,10,4].to_a).to eq plus[2,divide[times[10-2,range[0,4]],4]].to_a
@@ -468,7 +468,7 @@ describe MLL do
           expect(nest_list[->(*args){}, 0, 5].to_a.size).to eq 6
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "???" do
             skip "#cos (or #sqrt or anything unar is yet to be implemented"
@@ -476,7 +476,7 @@ describe MLL do
 
         end
 
-        describe "Scope" do
+        describe "Scope:" do
 
           example "nesting can return a single number" do
             skip "#sqrt is yet to be implemented"
@@ -484,7 +484,7 @@ describe MLL do
 
         end
 
-        describe "Applications" do
+        describe "Applications:" do
 
           example "powers of 2" do
             expect(nest_list[->(i){ 2*i }, 1, 10]).to be_a Enumerator
@@ -500,7 +500,7 @@ describe MLL do
           end
           example "random walk" do
             expect(( r = Random.new(0); nest_list[->(i){ i+[-1,1][r.rand(2)] }, 0, 20] )).to be_a Enumerator
-            expect(( r = Random.new(0); 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]
+            expect(( r = Random.new(0); 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(nest_list[->(i){ i.rotate 1 }, [1,2,3,4], 4]).to be_a Enumerator
@@ -509,7 +509,7 @@ describe MLL do
 
         end
 
-        describe "Properties & Relations" do
+        describe "Properties & Relations:" do
 
           example "#nest gives the last element of #nest_list" do
             expect(nest_list[->(i){ i*2 }, 3, 4].to_a.last).to eq nest[->(i){ i*2 }, 3, 4]
@@ -536,7 +536,7 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/FoldList.html
       describe "#fold_list" do
 
-        describe "Details" do
+        describe "Details:" do
 
           example "with a length n list, #fold_list generates a list of length n+1" do
             skip "waiting got Wolfram team to fix the reported bug"
@@ -548,7 +548,7 @@ describe MLL do
 
         end
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "cumulative sums of the elements of the list" do
             expect(fold_list[plus,5,[1,2,3,4]]).to be_a Enumerator
@@ -565,12 +565,12 @@ describe MLL do
 
         end
 
-        describe "Applications" do
+        describe "Applications:" do
 
           # TODO maybe move it to README.md
           example "generate a random walk" do
             expect(( r = Random.new(0); fold_list[plus, 0, Array.new(20){ [-1,1][r.rand(2)] }] )).to be_a Enumerator
-            expect(( r = Random.new(0); fold_list[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]
+            expect(( r = Random.new(0); fold_list[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
 
           example "find successively deeper parts in an expression" do
@@ -580,7 +580,7 @@ describe MLL do
 
         end
 
-        describe "Properties & Relations" do
+        describe "Properties & Relations:" do
 
           example "makes a list of length n+1" do
             expect(fold_list[->{}, 0, [*1..10]]).to be_a Enumerator
@@ -601,7 +601,7 @@ describe MLL do
 
         end
 
-        describe "Neat Examples" do
+        describe "Neat Examples:" do
 
           example "compute the minimum number of coins of different value needed to make up an amount" do
             skip "at least #mod is yet to be implemented"
@@ -611,6 +611,85 @@ describe MLL do
 
       end
 
+      # http://reference.wolfram.com/language/ref/Map.html
+      describe "#map" do
+
+        # TODO we'll need less nested mappings when we implement stop on depths depletion
+
+        describe "Details and Options:" do
+
+          example "levels n1 though n2" do
+            expect(map[->(i){ [i] }, [1,[2,[3,[4,[5,6]]]]], [2,4]]).to be_a Enumerator
+            expect(map[->(i){ [i] }, [1,[2,[3,[4,[5,6]]]]], [2,4]].
+              to_a.map{ |i| i.respond_to?(:to_a) ? i.
+              to_a.map{ |i| i.respond_to?(:to_a) ? i.
+              to_a.map{ |i| i.respond_to?(:to_a) ? i.
+              to_a.map{ |i| i.respond_to?(:to_a) ? i.
+              to_a.map{ |i| i.respond_to?(:to_a) ? i.
+              to_a.map{ |i| i.respond_to?(:to_a) ? i.
+              to_a.map{ |i| i.respond_to?(:to_a) ? i.to_a : i } : i } : i } : i } : i } : i } : i }
+              # TODO smth _<>
+            ).to eq [1,[[2],[[[3],[[[4],[[5,6]]]]]]]]
+          end
+
+          # TODO "Level corresponds to the whole expression"
+          # TODO currying "Map[f][expr] is equivalent to Map[f,expr]"
+
+        end
+
+        describe "Basic Examples:" do
+
+          example "???" do
+            expect(map[range, [1,2,3]]).to be_a Enumerator
+            expect(map[range, [1,2,3]].to_a.map(&:to_a)).to eq [[1],[1,2],[1,2,3]]
+          end
+          example "use explicit pure functions" do
+            expect(map[->(i){ i**2 }, [1,2,3,4]]).to be_a Enumerator
+            expect(map[->(i){ i**2 }, [1,2,3,4]].to_a).to eq [1,4,9,16]
+          end
+          example "map at top level" do
+            expect(map[->(i){ [i] }, [[1,2],[3,4,5]]]).to be_a Enumerator
+            expect(map[->(i){ [i] }, [[1,2],[3,4,5]]].to_a.map{ |i| i.to_a.map &:to_a }).to eq [[[1,2]],[[3,4,5]]]
+          end
+          example "map at level 2" do
+            expect(map[->(i){ [i] }, [[1,2],[3,4,5]], [2]]).to be_a Enumerator
+            expect(map[->(i){ [i] }, [[1,2],[3,4,5]], [2]].to_a.map(&:to_a)).to eq [[[1],[2]],[[3],[4],[5]]]
+          end
+          example "map at levels 1 and 2" do
+            expect(map[->(i){ [i] }, [[1,2],[3,4,5]], 2]).to be_a Enumerator
+            expect(map[->(i){ [i] }, [[1,2],[3,4,5]], 2].to_a.map{ |i| i.to_a.map(&:to_a) }).to eq [[[[1],[2]]],[[[3],[4],[5]]]]
+          end
+
+        end
+
+        describe "Scope:" do
+          # TODO "Map on all levels, starting at level" ant other about Infinity
+        end
+
+        describe "Properties & Relations:" do
+
+          example "leaves are visited before roots" do
+            skip "waiting for infinite map to be implemented"
+            log = []
+            map[log.method(:<<), [[1,2],[3,4,5]]]
+            expect(log).to eq [1,2,[1,2],3,4,5,[3,4,5],[[1,2],[3,4,5]]]
+          end
+
+          # TODO #mapall
+
+          # TODO #mapthread ?
+          # TODO #mapindexed ?
+
+          # TODO "negative levels"
+
+          example "#scan does the same as #map, but without returning a result" do
+            skip "#scan is yet to be implemented"
+          end
+
+        end
+
+      end
+
     end
 
     # TODO http://reference.wolfram.com/language/guide/ElementsOfLists.html
@@ -630,7 +709,7 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/Nest.html
       describe "#nest" do
 
-        describe "Basic Examples" do
+        describe "Basic Examples:" do
 
           example "the function to nest can be a pure function" do
             expect(nest[->(i){ (1+i)**2 }, 1, 3]).to eq 676
@@ -638,7 +717,7 @@ describe MLL do
 
         end
 
-        describe "Scope" do
+        describe "Scope:" do
 
           example "nesting can return a single number" do
             skip "#sqrt is yet to be implemented"
@@ -646,7 +725,7 @@ describe MLL do
 
         end
 
-        describe "Applications" do
+        describe "Applications:" do
 
           example "newton iterations for" do
             skip "waiting for Rationals to be used"
@@ -657,7 +736,7 @@ describe MLL do
 
         end
 
-        describe "Properties & Relations" do
+        describe "Properties & Relations:" do
 
           example "Ruby#inject automatically inserts second arguments from a list" do
             expect(nest[->(i){ i*2 }, 3, 4]).to eq ([2]*4).inject(3){ |i,j| i*j }
@@ -673,6 +752,55 @@ describe MLL do
 
   end
 
+  # http://reference.wolfram.com/language/guide/NumericalData.html
+  describe "Numerical Data" do
+
+    # http://reference.wolfram.com/language/ref/Tally.html
+    describe "#tally" do
+
+      describe "Details:" do
+        
+        example "#tally[list] is equivalent to #tally[list,#sameq]" do
+          skip "#sameq is yet to be implemented"
+        end
+
+      end
+
+      describe "Basic Examples:" do
+
+        example "obtain tallies for a list" do
+          expect(tally[[1, 1, 2, 1, 3, 2, 1]]).to be_a Hash
+          expect(tally[[1, 1, 2, 1, 3, 2, 1]]).to eq({1=>4, 2=>2, 3=>1})
+        end
+
+        example "use test argument to count elements with the same class" do
+          expect(tally[[[1,2], [1,2,3,4], 1, [1,2,3,4], 1], ->(i,j){ i.class == j.class }]).to be_a Hash
+          expect(tally[[[1,2], [1,2,3,4], 1, [1,2,3,4], 1], ->(i,j){ i.class == j.class }]).to eq({[1,2]=>3, 1=>2})
+        end
+
+        example "count the instances of randomly generated integers" do
+          expect(( r = Random.new(0); tally[Array.new(50){ r.rand 10 }] )).to be_a Hash
+          expect(( r = Random.new(0); tally[Array.new(50){ r.rand 10 }] )).to eq({5=>4, 0=>6, 3=>10, 7=>7, 9=>5, 2=>4, 4=>3, 6=>2, 8=>5, 1=>4})
+        end
+
+      end
+
+      describe "Properties & Relations:" do
+
+        example "elements with highest frequencies are given by #commonest" do
+          skip "#commonest is yet to be implemented"
+        end
+
+        example "#tally is a discrete analog of #bincounts" do
+          skip "#bincounts is yet to be implemented"
+        end
+
+      end
+
+    end
+
+  end
+
 end
 
 # TODO http://reference.wolfram.com/language/guide/HandlingArraysOfData.html

metadata

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