mll 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70676b9e4d6334e3e8391c256aa11c3ea5e9c033
-  data.tar.gz: 7e8b55eb690a4ee783358750fd25ca1045475508
+  metadata.gz: 0b28b0ef583cd90f87454f37cebdc8a3088ba42a
+  data.tar.gz: 05757c078b5eade518f1895e71c9bf3e0af97f5f
 SHA512:
-  metadata.gz: 449a0ca50feab9413c62cc1a67d37bb4a349ab97f0c842f676cea2ddea06ba03b29d96d8200bd846c9700d3388f60112ab3b900408f5a47aa7aa4b38d78342fd
-  data.tar.gz: 8f5f8a226918468f4e3f636df329f4520c686181fccca13c26b04bd493018156da4f79101b07a27dfbbfab32de5306b223505dbc52f914d5a8a44bad8b9dd780
+  metadata.gz: cf8caa79c3a7cc275b234c1dcb1d1bc6a0bc9a772f585bddc171cc8d4bd2dacff587cc37c963df7fbab53880c48ca62579ba5c63e109235836288611b6011f8a
+  data.tar.gz: 8c3053016c69c2ead9e8fd965a661167332e45b00841e15fbdd570325888e5c74e03c5ee89b339bcd665ae75d24bf37574e201686ae0bf3a3b9f3127a1ea9331

data/README.md

@@ -1,29 +1,34 @@
 # MLL (Mathematica Language Library)
 
-Этот гем не ставит перед собой цель полностью имитировать типы данных, синтаксис Wolfram Mathematica Language, или научить Ruby крутым визуализациям. Целью является вложить в Ruby мощь стандартной библиотеки. Прежде всего, List Manipulation. В перспективе визуализация возможна при помощи других гемов.
+## What
 
-## Usage
+Этот гем не ставит перед собой цель полностью имитировать типы данных, синтаксис Wolfram Mathematica Language, или научить Ruby крутым визуализациям. Целью является вложить в Ruby мощь стандартной библиотеки. В перспективе визуализация возможна при помощи других гемов.
 
-~~Планируется несколько способов использования этой библиотеки -- как доступ к ней через `MLL::`, так и манкипатчинг стандартных типов, таких как Numeric и Array.~~
+## Why
 
-### Examples:
+1. Важной является реализация https://reference.wolfram.com/language/ref/Listable.html: автоматическое применение функции ко всем элементам аргумента, если тот является List-ом (Array-ем в среде Ruby).  
+2. `::range`, в отличие от рубишного, может иметь отрицательный step.
+3. `::table`, в отличие от рубишного `.map`, может создавать многомерные массивы одним вызовом, а не только вложенными.
 
-    MLL::range(3).to_a    #=> [1, 2, 3]
-    MLL::range(2, 3).to_a #=> [
-                               #<Enumerator: 1..2:step(1)>,
-                               #<Enumerator: 1..3:step(1)>,
-                              ]
-    MLL::range(1..3)      #=> [
-                               #<Enumerator: 1..1:step(1)>,
-                               #<Enumerator: 1..2:step(1)>,
-                               #<Enumerator: 1..3:step(1)>
-                              ]
+## How
+
+    MLL::range(2, 3)   #=> 2..3
+    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]]
+    #=> [[1, 3, 1],
+         [0, 2, 0],
+         [1, 3, 1]]
+    MLL::table ->(i,j,k){ 100*i + 10*j + k }, 2, 3, 4
+    # => [[[111, 112, 113, 114], [121, 122, 123, 124], [131, 132, 133, 134]],
+          [[211, 212, 213, 214], [221, 222, 223, 224], [231, 232, 233, 234]]]
 
 ## Installation
 
     $ gem install mll
 
-### Testing with RSpec before contributing
+## Testing with RSpec before contributing
 
     rspec
 

data/lib/mll.rb

@@ -1,22 +1,22 @@
 module MLL
 
-  def self.define_function_that_can_enumerate name, &block
-    # http://stackoverflow.com/a/12792313/322020
-    (class << self; self end).class_eval do
+  # https://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|
-        if args.size == 1 && args.first.respond_to?(:map)
-          args.first.lazy.map &method(name)
-        else
-          block.call *args
-        end
+# 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) }
       end
     end
   end
 
-  define_function_that_can_enumerate :range do |*args|
+  define_listable_function :range do |*args|
     case args.size
     when 1 ; range 1, args[0] # TODO do smth with #table(-n)
-    when 2 ; Range.new(args[0], args[1])
+    when 2 ; Range.new(args[0], args[1]).step
     when 3
       case args[2] <=> 0
       when 0 ; raise ArgumentError.new("step can't be zero")
@@ -24,34 +24,52 @@ module MLL
       else
         Enumerator.new do |e|
           from, to, step = *args
-          while (step > 0) ? from <= to : from >= to
+          # while (step > 0) ? from <= to : from >= to
+          while from >= to
             e << from
             from += step
           end
         end
       end
     else
-      raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..3)") # unless (1..3).include? args.size
+      raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..3)")
     end
   end
 
   def self.table f, *args
-    # TODO make it lazy?
-
     [].tap do |result|
-      [[result, args.map{ |r| range(*r).to_a }]].tap do |stack|
+      [[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
+
+  define_listable_function :divide do |a, b|
+    a / b
+  end
 
+  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])
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..3)")
+    end
   end
 
 end

data/mll.gemspec

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

data/spec/_spec.rb

@@ -1,9 +1,74 @@
 require_relative File.join "..", "lib", "mll"
 
 
+# PERMANENT TODO test all implemented exceptions
+# PERMANENT TODO test all types returned
+
+
 # http://reference.wolfram.com/language/guide/LanguageOverview.html
 describe MLL do
 
+  # http://reference.wolfram.com/language/guide/Syntax.html
+  describe "Syntax" do
+
+    # NO URL
+    describe "Mathematics & Operators" do
+
+      # 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
+            expect(MLL::divide(77,11)).to eq 7
+          end
+
+        end
+
+        describe "Scope" do
+
+          example "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
+            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
+
+        end
+
+        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
+
+        describe "Neat Examples" do
+
+          example "nest_list(lambda_with_divide), n" do
+            pending "#nestlist is yet to be implemented"
+            fail
+          end
+          example "table(divide, 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
+
+        end
+
+      end
+
+    end
+
+  end
+
   # http://reference.wolfram.com/language/guide/ListManipulation.html
   describe "List Manipulation" do
 
@@ -13,7 +78,7 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/Range.html
       describe "#range" do
 
-        # TODO negative step and add it to README.rb
+        # TODO take from docs more examples that involve other functions
 
         example "range( >3 args )" do
           expect{ MLL::range(1,2,3,4) }.to raise_error ArgumentError
@@ -22,22 +87,24 @@ describe MLL do
         describe "Basic Examples" do
 
           example "range(n)" do
-            expect(MLL::range(4)).to be_a Range
+            expect(MLL::range(4)).to be_a Enumerator
             expect(MLL::range(4).to_a).to eq [1,2,3,4]
           end
-          example "range(imin, imax)" do
-            expect(MLL::range(2,5)).to be_a Range
+          example "range(min, max)" do
+            expect(MLL::range(2,5)).to be_a Enumerator
             expect(MLL::range(2,5).to_a).to eq [2,3,4,5]
           end
-          example "range(imin, imax, id)" do
+          example "range(min, max, step)" do
             expect(MLL::range(1,2,3)).to be_a Enumerator
             expect(MLL::range(1,2,0.5).to_a).to eq [1,1.5,2] # can be precision problems
             expect(MLL::range(2,6,2).to_a).to eq [2,4,6]
             expect(MLL::range(-4,9,3).to_a).to eq [-4,-1,2,5,8]
-            # Ruby can't negative Range#step, haha!
+          end
+          example "range(max, min, -step)" do
             expect(MLL::range(10,-5,-2).to_a).to eq [10,8,6,4,2,0,-2,-4]
             expect(MLL::range(3,1,-1).to_a).to eq [3,2,1]
           end
+
         end
 
         describe "Generalizations & Extensions" do
@@ -45,7 +112,7 @@ describe MLL do
           example "range([n1, n2, n3, n4])" do
             expect(MLL::range([5,2,6,3])).to be_a Enumerator
             MLL::range([5,2,6,3]).each do |i|
-              expect(i).to be_a Range
+              expect(i).to be_a Enumerator
             end
             expect(MLL::range([5,2,6,3]).to_a.map(&:to_a)).to eq [[1,2,3,4,5],[1,2],[1,2,3,4,5,6],[1,2,3]]
           end
@@ -63,10 +130,10 @@ describe MLL do
 
         describe "Neat Examples" do
 
-          example "range(imin..imax)" do
-            expect(MLL::range(MLL::range(3))).to be_a Enumerator
-            MLL::range(MLL::range(3)).each do |i|
-              expect(i).to be_a Range
+          example "range(min..max)" do
+            expect(MLL::range(1..3)).to be_a Enumerator
+            MLL::range(1..3).each do |i|
+              expect(i).to be_a Enumerator
             end
             expect(MLL::range(1..3).to_a.map(&:to_a)).to eq [[1],[1,2],[1,2,3]]
           end
@@ -77,7 +144,7 @@ describe MLL do
               o.each do |i|
                 expect(i).to be_a Enumerator
                 i.each do |j|
-                  expect(j).to be_a Range
+                  expect(j).to be_a Enumerator
                 end
               end
             end
@@ -95,27 +162,85 @@ describe MLL do
 
       # http://reference.wolfram.com/language/ref/Table.html
       describe "#table" do
+        # TODO type checks
 
         describe "Basic Examples" do
 
-          example "table(lambda, [n])" do
-            expect(MLL::table(->(i){ i**2 }, [10])).to eq [1,4,9,16,25,36,49,64,81,100]
+          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, [imin, imax, id])" do
+          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
-            expect(MLL::table(->(i, j){ 10*i + j }, [4], [3])).to eq [[11,12,13],[21,22,23],[31,32,33],[41,42,43]]
+          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
+          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 "
+            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(->(i,j){ i+j }, [[1]], [[2]])).to be_a Array
+            expect(MLL::table(->(i,j){ i+j }, [[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/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
 
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mll
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Victor Maslov