y_support 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39372bbe12e6643f53e78e2b4fd8666477554a67
-  data.tar.gz: 9d1c8f648ab7369104ba1ca178fe6ca4abec4cf7
+  metadata.gz: f7b23faa0d465f3f3a15b4528d5fcfb0a32c6c7f
+  data.tar.gz: 3ef03c2bc2154ff8b552f388726daf8b7a82ab8c
 SHA512:
-  metadata.gz: 7e3457d0f805683af3c83018bb7174b161868f614a77b90e7ecc022937ec9b4768fbbfc904717b97beb71dbe0f96296cac46fe60f52db06f89c80c9afa5ce755
-  data.tar.gz: 8a57a47dcb40f4c286ffcdf3ad19c0ccd3cd6a58bb32f7d32861701c6907c4734db0eb6e72b6490afcf43e8c2797b0661fda1e7166ed15267736729d45fb06b8
+  metadata.gz: 53bcbc5db8d0cdedef378c15d87414d76f12a4d65b42274b9b224fd8d95c36620249057c6deac5aa4b03623b925dcdf75a88899975ccd4b46e33c54ef4419e21
+  data.tar.gz: 5f65f0d77dd1dd2b8808b40b9218b934287636ac5436a785c0ef465bbcbde96fb74815b8c3c9d365faa37d50b8cb2b0cfe0f151c81ea213bce3992ee159d09bd

data/lib/y_support/abstract_algebra.rb

@@ -0,0 +1,226 @@
+#encoding: utf-8
+
+require 'y_support'
+require 'y_support/null_object'
+
+# Rudiments of abstract algebra in Ruby.
+#
+# Some objects (users, mixins...) might ask from other classes to have things
+# defined such as operators #+, #*, or to have a specific instance that behaves
+# additive identity element (ie. zero), or multiplicative identity element (ie.
+# one). The essence of some of these requirements is captured by the abstract
+# algebraic notions of magma, monoid, ring, field...
+#
+# At the moment being, y_support/abstract_algebra does not aim as high as to
+# comprehensively support monoids, rings, fields and the plethora of abstract
+# algebraic stuff. Support is provided to such degree, as to make some practical
+# problems tractable. (Our original concern was with Matrix instances filled
+# with non-numeric objects, whose #+ operator was not coercible to work with
+# numerics.)
+# 
+
+# Adds abstract algebra concepts to Ruby.
+#
+module Algebra
+  # A Monoid requires:
+  #
+  # Closed and associative addition: #add method
+  # Additive identity element: #additive_identity
+  # 
+  module Monoid
+    def self.included receiver
+      receiver.extend self::ClassMethods
+    end
+
+    def + summand; add summand end
+
+    module ClassMethods
+      def zero; additive_identity end
+    end
+  end
+
+  # A group is a monoid with additive inverse.
+  #
+  # additive inversion: #additive_inverse
+  # 
+  module Group
+    include Monoid
+    def -@; additive_inverse end
+    def - subtrahend; add subtrahend.additive_inverse end
+  end
+
+  # A group that fulfills the condition of commutativity
+  #
+  # ( a.add b == b.add a ).
+  # 
+  module AbelianGroup
+    include Group
+  end
+
+  # A ring is a commutative group with multiplication.
+  # 
+  # multiplication: #multiply (associative, distributive)
+  # multiplicative identity element: #multiplicative_identity
+  # 
+  module Ring
+    include AbelianGroup
+    def * multiplicand; multiply multiplicand end
+    def one; multiplicative_identity end
+  end
+
+  # A field is a ring that can do division.
+  # 
+  module Field
+    include Ring
+    def inverse; multiplicative_inverse end
+    def / divisor; multiply divisor.multiplicative_inverse end
+  end
+end
+
+
+# Patching Integer with Algebra::Ring compliance methods.
+# 
+class << Integer
+  def additive_identity; 0 end
+  alias zero additive_identity
+  def add( other ); self + other end
+  def additive_inverse; -self end
+  def multiply( other ); self * other end
+  def multiplicative_identity; 1 end
+end
+
+# Patching Float with Algebra::Field compliance methods.
+# 
+class << Float
+  def additive_identity; 0.0 end
+  alias zero additive_identity
+  def add( other ); self + other end
+  def additive_inverse; -self end
+  def multiply( other ); self * other end
+  def multiplicative_identity; 1.0 end
+  alias one multiplicative_identity
+  def multiplicative_inverse; 1.0 / self end
+end
+
+# Patching Rational with Algebra::Field compliance methods.
+# 
+class << Rational
+  def additive_identity; Rational 0, 1 end
+  alias zero additive_identity
+  def add( other ); self + other end
+  def additive_inverse; -self end
+  def multiply( other ); self * other end
+  def multiplicative_identity; Rational 1, 1 end
+  alias one multiplicative_identity
+  def multiplicative_inverse; Rational( 1, 1 ) / self end
+end
+
+# Patching Complex with #zero method.
+# 
+class << Complex
+  def additive_identity; Complex 0.0, 0.0 end
+  alias zero additive_identity
+  def add( other ); self + other end
+  def additive_inverse; -self end
+  def multiply( other ); self * other end
+  def multiplicative_identity; Complex 1, 0 end
+  alias one multiplicative_identity
+  def multiplicative_inverse; Complex( 1, 0 ) / self end
+end
+
+
+
+# Wildcard zero, stronger than ordinary numeric literal 0.
+# 
+( WILDCARD_ZERO = NullObject.new ).instance_exec {
+  ɪ = self
+  singleton_class.class_exec { define_method :zero do ɪ end }
+  def * other; other.class.zero end
+  def / other
+    self unless other.zero?
+    fail ZeroDivisionError, "The divisor is zero! (#{other})"
+  end
+  def + other; other end
+  def - other; -other end
+  def coerce other; return other, other.class.zero end
+  def zero?; true end
+  def to_s; "∅" end
+  def inspect; to_s end
+  def to_f; 0.0 end
+  def to_i; 0 end
+  def == other
+    z = begin
+          other.class.zero
+        rescue NoMethodError
+          return false
+        end
+    other == z
+  end
+}
+
+
+# As a matter of fact, current version of the Matrix class (by Marc-Andre
+# Lafortune) does not work with physical magnitudes. It is a feature of the
+# physical magnitudes, that they do not allow themselves summed with plain
+# numbers or incompatible magnitudes. But current version of Matrix class,
+# upon matrix multiplication, performs needless addition of the matrix elements
+# to literal numeric 0.
+#
+# The obvious solution is to patch Matrix class so that the needless addition
+# to literal 0 is no longer performed.
+#
+# More systematically, abstract algebra is to be added to Ruby, and Matrix is
+# to require that its elements comply with monoid, group, ring, field, depending
+# on the operation one wants to do with such matrices.
+#
+class Matrix
+  # Matrix multiplication.
+  #
+  def * arg # arg is matrix or vector or number
+    case arg
+    when Numeric
+      rows = @rows.map { |row| row.map { |e| e * arg } }
+      return new_matrix rows, column_size
+    when Vector
+      arg = Matrix.column_vector arg
+      result = self * arg
+      return result.column 0
+    when Matrix
+      Matrix.Raise ErrDimensionMismatch if column_size != arg.row_size
+      if empty? then # if empty?, then reduce uses WILDCARD_ZERO
+        rows = Array.new row_size do |i|
+          Array.new arg.column_size do |j|
+            ( 0...column_size ).reduce WILDCARD_ZERO do |sum, c|
+              sum + arg[c, j] * self[i, c]
+            end
+          end
+        end
+      else             # if non-empty, reduce proceeds without WILDCARD_ZERO
+        rows = Array.new row_size do |i|
+          Array.new arg.column_size do |j|
+            ( 0...column_size ).map { |c| arg[c, j] * self[i, c] }.reduce :+
+          end
+        end
+      end
+      return new_matrix( rows, arg.column_size )
+    when SY::Magnitude # newly added - multiplication by a magnitude
+      # I am not happy with this explicit switch on SY::Magnitude type here.
+      # Perhaps coerce should handle this?
+      rows = Array.new row_size do |i|
+        Array.new column_size do |j|
+          self[i, j] * arg
+        end
+      end
+      return self.class[ *rows ]
+    else
+      compat_1, compat_2 = arg.coerce self
+      return compat_1 * compat_2
+    end
+  end
+
+  # Creates a matrix of prescribed dimensions filled with wildcard zeros.
+  # 
+  def Matrix.wildcard_zero r_count, c_count=r_count
+    build r_count, c_count do |r, c| WILDCARD_ZERO end
+  end
+end

data/lib/y_support/all.rb

@@ -8,6 +8,7 @@ require 'y_support/respond_to'
 require 'y_support/null_object'
 require 'y_support/inert_recorder'
 require 'y_support/local_object'
+require 'y_support/abstract_algebra'
 require 'y_support/misc'
 
 

data/lib/y_support/version.rb

@@ -1,3 +1,3 @@
 module YSupport
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/test/abstract_algebra_test.rb

@@ -0,0 +1,145 @@
+#! /usr/bin/ruby
+#encoding: utf-8
+
+require 'test/unit'
+require 'shoulda'
+
+class AbstractAlgebraTest < Test::Unit::TestCase
+  context "Algebra" do
+    setup do
+      require 'y_support/abstract_algebra'
+      # Define the stupidest monoid:
+      @monoid = Class.new { include Algebra::Monoid } # make some class
+      zero = @monoid.new         # call arbitrary instance zero
+      @monoid.class_exec {
+        # Define the stupidest #add method.
+        define_method :add do |other|
+          if self == zero then other
+          elsif other == zero then self
+          else self.class.addition_table[[self, other]] end
+        end
+        # Define the stupidest addition table.
+        instance_variable_set :@addition_table,                      
+                              Hash.new { |ꜧ, k|
+                                ꜧ[k] = if k[0].object_id <= k[1].object_id
+                                         new # just make up an instance
+                                       else
+                                         ꜧ[k[1], k[0]] # swap operands
+                                       end
+                              }
+      }
+      # And refine the @monoid's singleton class.
+      @monoid.singleton_class.class_exec { attr_reader :addition_table }
+      @monoid.define_singleton_method :additive_identity do zero end
+    end
+
+    should "have working Monoid" do
+      m = @monoid.random                  # choose an instance
+
+      # #== method
+      assert m == m
+
+      # closure
+      # (not tested)
+
+      # associativity
+      n, o = @monoid.random, @monoid.random
+      assert ( m + n ) + o == m + ( n + o )
+
+      # identity element
+      assert m + @monoid.zero == m
+      assert @monoid.zero + m == m
+    end
+
+    should "have working Group" do
+      g = @group.random
+
+      # (monoid properties not tested)
+
+      # inverse element
+      assert g + (-g) == @group.zero
+      assert (-g) + g == @group.zero
+    end
+
+    should "define AbelianGroup" do
+      ag = @abelian_group.random
+
+      # (group properties not tested)
+
+      # commutativity
+      bh = @abelian_group.random
+      assert ag + bh == bh + ag
+    end
+
+    should "define Ring" do
+      r = @ring.random
+
+      # (abelian group properties with respect to addition not tested)
+
+      # (multiplication closure not tested)
+
+      # multiplication associativity
+      s, t = @ring.random, @ring.random
+      assert r * ( s * t ) == ( r * s ) * t
+
+      # multiplication identity
+      mi = @ring.one
+      assert r * mi == r
+      assert mi * r == r
+
+      # distributivity
+      assert r * ( s + t ) == ( r * s ) + ( s * t )
+    end
+
+    should "define Field" do
+      f = @field.random
+
+      # (ring properties not tested)
+      
+      # multiplicative inverse
+      mi = @ring.multiplicative_identity
+      assert f * f.multiplicative_inverse == mi
+      assert f.multiplicative_inverse * f == mi
+    end
+  end
+
+  context "numerics" do
+    setup do
+      require 'y_support/abstract_algebra'
+    end
+
+    should "have patched Integer" do
+      assert Integer.zero.equal? 0
+    end
+
+    should "have patched Float" do
+      assert Float.zero.equal? 0.0
+    end
+
+    should "have patched Rational" do
+      assert Rational.zero.equal? Rational( 0, 0 )
+    end
+
+    should "have patched Complex" do
+      assert Complex.zero.equal? Complex( 0, 0 )
+    end
+  end
+
+  context "Matrix" do
+    setup do
+      require 'y_support/abstract_algebra'
+    end
+
+    should "have Matrix.wildcard_zero public instance method" do
+      # FIXME
+    end
+
+    should "be able to perform #* with nonnumerics in the matrix" do
+      # FIXME
+    end
+
+    should "numeric matrix multiplication still be working normally" do
+      # FIXME
+    end
+  end # context Matrix
+end # class AbstractAlgebraTest

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: y_support
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - boris
@@ -51,6 +51,7 @@ files:
 - README.md
 - Rakefile
 - lib/y_support.rb
+- lib/y_support/abstract_algebra.rb
 - lib/y_support/all.rb
 - lib/y_support/core_ext.rb
 - lib/y_support/core_ext/array.rb
@@ -91,6 +92,7 @@ files:
 - lib/y_support/typing/object/typing.rb
 - lib/y_support/unicode.rb
 - lib/y_support/version.rb
+- test/abstract_algebra_test.rb
 - test/inert_recorder_test.rb
 - test/local_object_test.rb
 - test/misc_test.rb
@@ -126,6 +128,7 @@ specification_version: 4
 summary: LocalObject, RespondTo, InertRecorder, NullObject, NameMagic, core extensions,
   typing etc.
 test_files:
+- test/abstract_algebra_test.rb
 - test/inert_recorder_test.rb
 - test/local_object_test.rb
 - test/misc_test.rb