magick 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4826f852b57d6f69bbf1d1d1c4671174e3b3d68dae520b5fd09f43a7c2ba2bac
-  data.tar.gz: 0d56f6b3d4c9a6ec5fe45759695375700aacdedc28dcd9b1dccc23c06e9bff37
+  metadata.gz: b0239f6b8fc615275fa674559061c52c111913e971a49b3ab292630cca826b96
+  data.tar.gz: fa2a9c746508d7d10d89d883a84745509435e8ca2e931f8b862ef9a0409ec184
 SHA512:
-  metadata.gz: ebe917fea532e9cd78d94e247120278f9f155cb857ff0daaea8f9538342a33fefff6e8a3c813180763845fd822efababcfaa0d70a0101d5b665becded5815a46
-  data.tar.gz: 88573678ce6d983164280c784f14dd285f1136c0354cc1c40a3c92df1538637ea909b5f9ad4d1098a32eb067ec34a2b6a08a5058839d4d3a17aa0080115a09fb
+  metadata.gz: 16881788b5f302b8a6a06276351ec676e65cd97c21818347ce76910190e7068cce0cb52dc0338d28cbb1d5f747d64ab2129b3f71b19d482e917c00ae7497eeeb
+  data.tar.gz: 077b86c81e1e46d236fea5b4ed40492d9f646ae89da69c89987a5fdc1d0e7c6587b6c5a11a80a69e5b7797297ee5a12910537cb98278d5091ec38eee71172de2

data/lib/magick/loops.rb

@@ -31,6 +31,7 @@ module Magick
         }
       end
 
+      # sum and length both assume they will be given a list
       def sum = fold.(Magick::Maths::add).(0)
 
       def length = fold.(->(acc) { ->(elem) { acc + 1 }}).(0)

data/lib/magick/maths.rb

@@ -11,21 +11,30 @@ module Magick
       def subtract = ->(x){ ->(y) { add.(x).(negate.(y)) }}
 
       def multiply
-        power.(add)
+        power_2.(add)
       end
       alias :mult :multiply
 
+      # See note on `mod`
       def divide
         Smullyan::Birds::Y.(->(f){ 
           ->(n){ 
             ->(d){ 
-              n < d ? 0 : 1 + f.(n - d).(d)
+              n < d ? 0 : 1 + f.(subtract.(n).(d)).(d)
             }
           }
         })
       end
       alias :div :divide
 
+      def div
+        ->(n){
+          ->(d){
+            n/d
+          }
+        }
+      end
+
       def div_to_f
         ->(n){
           ->(d){
@@ -37,18 +46,23 @@ module Magick
         }
       end
 
+      # This implementation of mod _works_ but is mostly 
+      # provided as a curiousity: ie, how could we implement 
+      # modulus with the Y combinator and repeated subtraction?
+      # It isn't efficient, as you will find if you ever try, say,
+      # mod.(65536).(2)
       def mod
         Smullyan::Birds::Y.(->(f){
           ->(n){
             ->(d){
-              n < d ? n : f.(n - d).(d)
+              n < d ? n : f.(subtract.(n).(d)).(d)
             }
           }
         })
       end
 
       def exp
-        power.(multiply)
+        power_2.(multiply)
       end
 
       def power
@@ -63,8 +77,8 @@ module Magick
                 ->(b) {
                   ->(e) {
                     e == 1 ? b :
-                    mod.(e).(2) == 0 ? f.(op.(b).(b)).(divide.(e).(2)) :
-                    op.(f.(op.(b).(b)).(divide.(e).(2))).(b)
+                    mod.(e).(2) == 0 ? f.(op.(b).(b)).(div.(e).(2)) :
+                    op.(f.(op.(b).(b)).(div.(e).(2))).(b)
                   }
                 }
               }).(base).(exponent)
@@ -73,6 +87,62 @@ module Magick
         }
       end
 
+      # power, as written, will have a stack trace error if we try to 
+      # do something like power.(mult).(2).(32)
+      # If we eliminate the recursion, we can avoid this, but it means we need
+      # to use some regular Ruby constructs (eg, `while`, instead of the Y combinator)
+      # The following is essentially how Stepanov & McJones define `power` in 
+      # Elements of Programming
+      def power_accumulate_positive
+        ->(op){
+          ->(r){
+            ->(a){
+              ->(n){
+                while (true)
+                  if n % 2 != 0
+                    r = op.(r).(a)
+                    return r if n == 1
+                  end
+                  a = op.(a).(a)
+                  n = div.(n).(2)
+                end
+              }
+            }
+          }
+        }
+      end
+
+      def power_accumulate
+        ->(op){
+          ->(r){
+            ->(n){
+              ->(a){
+                return r if n == 0
+                power_accumulate_positive.(op).(r).(n).(a)
+              }
+            }
+          }
+        }
+      end
+
+      def power_2
+        ->(op){
+          ->(b){
+            ->(e){
+              while (e % 2 == 0)
+                b = op.(b).(b)
+                e = e/2
+              end
+              e = e/2
+              return b if e == 0
+              power_accumulate.(op).(b).(op.(b).(b)).(e)
+            }
+          }
+        }
+      end
+
+      # average expects an array
+      # eg: average.([1,2,3]) => 2.0
       def average
         Smullyan::Birds::Phi.
           (Magick::Maths::div_to_f).
@@ -80,19 +150,24 @@ module Magick
           (Magick::Loops::length)
       end
 
-      def powers_of_two = power.(multiply).(2)
+      def powers_of_two = exp.(2)
 
       # x and y are pairs of ints
       def fibonacci_matrix_multiply = ->(x){
         ->(y){
-          [x[0] * (y[1] + y[0]) + x[1] * y[0], x[0] * y[0] + x[1] * y[1]]
+          [
+            x[0] * (y[1] + y[0]) +
+              x[1] * y[0], 
+            x[0] * y[0] +
+              x[1] * y[1]
+          ]
         }
       }
 
       def fibonacci
         ->(n){
           n == 0 ? 0 :
-          power.(fibonacci_matrix_multiply).([1,0]).(n)[0]
+          power_2.(fibonacci_matrix_multiply).([1,0]).(n)[0]
         }
       end
     end

data/lib/magick/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Magick
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: magick
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Phil Crissman