magick 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8d6e452deba31a7756fb5d9fbb58f11a5e6be0050c7fd66728f08235707a798
-  data.tar.gz: 40fc7e21adc03fac84f439a41f25ad23e778ecc50e5a438ac27aeac791abed79
+  metadata.gz: 5ae8b9cd9f9526ea3adac12fd63ab30cd38895c035493a3f4866c83d25df015b
+  data.tar.gz: d60e88dbedd1c8d9c7bedf778beeefed2c3012678ce5022a741c02471ba76abd
 SHA512:
-  metadata.gz: 3d13d4e771af6db5087d66ac1f8336411d3b00232d9abbfe790df6da8b454fb83ec5ecf6f238708b4ee72a23263fa8a62d6f26e2384f2febea8f16ee36b1bb92
-  data.tar.gz: 219f308752938b16d27fd1b6c35832dff2e2e2054cf21fe37c086b683b24801a5c4948ea8295fddc295357657e6ed6c9b4aadd27bbf401e5e9483e9eada96a5d
+  metadata.gz: 9f033baf4e66b21b0c542d7f99ab95a717fb864acb48e5f51ba06e3c7eec9cd8e68f3d659272942fe4ffb487c618bb563e2b6c6765f4e016e196826cfd6cc45b
+  data.tar.gz: c967a3d6c062ee01b0f804cae609d8f281d4a33f66ba7449edaf2a08f8c505f52607090f769811c1db205745bf458bebdcd506cacfadc2f29b6295b3acf74bf9

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

@@ -1,9 +1,9 @@
 # maths
 
-# for addition, we'll just use Ruby
 module Magick
   module Maths
     class << self
+      # for addition, we'll just use Ruby
       def add = ->(x){ ->(y) { x + y }}
 
       def negate = ->(x) { -x }
@@ -11,11 +11,7 @@ module Magick
       def subtract = ->(x){ ->(y) { add.(x).(negate.(y)) }}
 
       def multiply
-        ->(a){
-          ->(b){
-            power.(a).(b).(add)
-          }
-        }
+        power_2.(add)
       end
       alias :mult :multiply
 
@@ -30,6 +26,17 @@ module Magick
       end
       alias :div :divide
 
+      def div_to_f
+        ->(n){
+          ->(d){
+            # in order to get a float, we'll just
+            # use Ruby's `/` operator, and make sure
+            # at least one argument is cast to float.
+            n / d.to_f
+          }
+        }
+      end
+
       def mod
         Smullyan::Birds::Y.(->(f){
           ->(n){
@@ -41,11 +48,7 @@ module Magick
       end
 
       def exp
-        ->(a){
-          ->(b){
-            power.(a).(b).(multiply)
-          }
-        }
+        power_2.(multiply)
       end
 
       def power
@@ -53,9 +56,9 @@ module Magick
         # operation. Powers of addition is equivalent
         # to multiplication; powers of multiplication
         # is equivalent to exponentiation
-        ->(base) { 
-          ->(exponent) {
-            ->(op) {
+        ->(op) { 
+          ->(base) {
+            ->(exponent) {
               Smullyan::Birds::Y.(->(f) {
                 ->(b) {
                   ->(e) {
@@ -70,12 +73,87 @@ 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 = 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
+
       def average
         Smullyan::Birds::Phi.
-          (Magick::Maths::divide).
+          (Magick::Maths::div_to_f).
           (Magick::Loops::sum).
           (Magick::Loops::length)
       end
+
+      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]
+          ]
+        }
+      }
+
+      def fibonacci
+        ->(n){
+          n == 0 ? 0 :
+          power_2.(fibonacci_matrix_multiply).([1,0]).(n)[0]
+        }
+      end
     end
   end
 end

data/lib/magick/version.rb

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

metadata

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