rucas 0.0.1

data/lib/rucas/extensions.rb

@@ -0,0 +1,99 @@
+require 'rucas/symbolic'
+
+module Rucas
+  module Extensions
+    #
+    # Avoid collisions with other patches; this maps operators (+,-, etc.) to 
+    # normal method names, so they can be called without the additional overhead
+    # of Kernel#send.
+    # 
+    PATCH_HASH = Hash.new {|h,k| k} # return key by default
+    PATCH_HASH[:+]  = :add
+    PATCH_HASH[:-]  = :sub
+    PATCH_HASH[:*]  = :mul
+    PATCH_HASH[:/]  = :div
+    PATCH_HASH[:**] = :pow
+    PATCH_HASH[:=~] = :eqs
+    PATCH_HASH[:<]  = :lt
+    PATCH_HASH[:<=] = :lte
+    PATCH_HASH[:>]  = :gt
+    PATCH_HASH[:>=] = :gte
+    PATCH_HASH[:&]  = :and
+    PATCH_HASH[:|]  = :or
+    raise "PATCH_HASH does not match BINARY_OPS" unless
+      Symbolic::BINARY_OPS.keys.all?{|k| PATCH_HASH.member?(k)}
+
+    # See PATCH_HASH.
+    def self.without_rucas_name original
+      "#{PATCH_HASH[original]}__without_rucas"
+    end
+
+    # See PATCH_HASH.
+    def self.with_rucas_name original
+      "#{PATCH_HASH[original]}__with_rucas"
+    end
+
+    # Add rucas methods constant classes, but don't alias_method them yet; that
+    # is handled in the apply and unapply methods.
+    for c in Symbolic::CONST_CLASSES
+      for op in Symbolic::BINARY_OPS.keys
+        c.class_eval %Q{
+          def #{with_rucas_name(op)} rhs
+            if rhs.is_a?(Rucas::Symbolic::Expr)
+              Rucas::Symbolic::ConstExpr.new(self) #{op} rhs
+            else
+              self.#{without_rucas_name(op)}(rhs)
+            end
+          end
+        }
+      end
+
+      # Try to convert to ConstExpr if can't find method (e.g. +simplify+).
+      c.module_eval do
+        def method_missing_with_rucas method, *args, &block
+          method_missing_without_rucas(method *args, &block)
+        rescue NoMethodError
+          error = $!
+          begin
+            return Symbolic::Expr.make(self).send(method, *args, &block)
+          rescue NoMethodError
+            nil
+          end
+          raise error
+        end
+      end
+    end
+  
+    # Patch system classes to make constants work with vars (e.g. 0 + x).
+    def self.apply
+      for c in Symbolic::CONST_CLASSES
+        for op in Symbolic::BINARY_OPS.keys
+          c.class_eval %Q{
+            alias_method :#{without_rucas_name(op)}, :#{op}
+            alias_method :#{op}, :#{with_rucas_name(op)}
+          }
+        end
+        c.module_eval do
+          alias_method :method_missing_without_rucas, :method_missing
+          alias_method :method_missing, :method_missing_with_rucas
+        end
+      end
+    end
+
+    # Get rid of patches.
+    def self.unapply
+      for c in Symbolic::CONST_CLASSES
+        for op in Symbolic::BINARY_OPS.keys
+          c.class_eval %Q{
+            alias_method :#{with_rucas_name(op)}, :#{op}
+            alias_method :#{op}, :#{without_rucas_name(op)}
+          }
+        end
+        c.module_eval do
+          alias_method :method_missing_with_rucas, :method_missing
+          alias_method :method_missing, :method_missing_without_rucas
+        end
+      end
+    end
+  end
+end

data/lib/rucas/rewrite.rb

@@ -0,0 +1,181 @@
+require 'rucas/symbolic'
+require 'facets/dictionary'
+
+module Rucas
+  #
+  # Tools for recursively rewriting expressions based on rules.
+  #
+  module Rewrite
+    #
+    # Construct an ordered hash of rewrite rules.
+    #
+    # Example:
+    #  my_rules = make_rules {
+    #    var :x
+    #    rule x + 0 => x
+    #    rule 0 + x => x
+    #  }
+    #
+    def self.make_rules &block
+      s = Scope.new
+      class <<s
+        def dict
+          @dict ||= Dictionary[]
+        end
+        def rule rule
+          raise unless rule.size == 1
+          dict[rule.keys.first] = Symbolic::Expr.make(rule.values.first)
+        end
+      end
+      s.rucas(&block)
+      s.dict
+    end
+  end
+
+  module Symbolic
+    module Expr
+      #
+      # If this expression matches +pattern+, return +output+ (with appropriate
+      # bindings of variables in pattern applied to output); otherwise, return
+      # self (or an object == to self).
+      #
+      def rewrite pattern, output
+        bindings = pattern.match(self)
+        return output.with(bindings) if bindings
+        self
+      end
+
+      #
+      # Non-recursive matching. Here, self is a pattern and +expr+ is the input
+      # to be matched against this pattern. Returns bindings for the free
+      # variables in self that make the match succeed, or nil if there is no
+      # such match.
+      #
+      def match expr, bindings = {}
+        nil # see subclasses
+      end
+
+      #
+      # If this expression involves only constants, evaluate it and return the
+      # result; if it is not, return nil.
+      #
+      def value
+        nil # see subclasses
+      end
+    end
+
+    module OpExpr
+      def rewrite pattern, output
+        # Rewrite children first. 
+        new_children = self.children.map{|c| c.rewrite(pattern, output)}
+        new_self = self.class.new(*new_children)
+        # See if it's a constant.
+        v = new_self.value 
+        if v
+          Symbolic::Expr.make(v)
+        else
+          # It's not a constant; try to rewrite using the rule.
+          bindings = pattern.match(new_self)
+          return output.with(bindings) if bindings
+          new_self
+        end
+      end
+
+      def with bindings
+        self.class.new(*self.children.map{|c| c.with(bindings)})
+      end
+    end
+    
+    class ConstExpr
+      def match expr, bindings = {}
+        return bindings if self == expr
+        return nil
+      end
+
+      def with bindings
+        self
+      end
+    end
+
+    class VarExpr
+      def match expr, bindings = {}
+        binding = bindings[self]
+        return bindings.merge(self => expr) if !binding
+        return bindings                     if binding == expr
+        return nil
+      end
+
+      def with bindings
+        bindings[self] || self
+      end
+    end
+
+    class UnaryOpExpr
+      def match expr, bindings = {}
+        return nil unless expr.is_a?(UnaryOpExpr)
+        return nil unless self.op == expr.op
+        rhs.match(expr.rhs, bindings)
+      end
+
+      def value
+        v = rhs.value
+        eval "(#{v}).#{self.op}" if v
+      end
+    end
+
+    class BinaryOpExpr
+      def match expr, bindings = {}
+        if expr.is_a?(BinaryOpExpr) && self.op == expr.op
+          lb = self.lhs.match(expr.lhs, bindings)
+          rb = self.rhs.match(expr.rhs, lb) if lb
+          return rb if rb
+        end
+        nil
+      end
+
+      def value
+        lv = lhs.value
+        rv = rhs.value
+        eval "(#{lv})#{self.op}(#{rv})" if lv && rv
+      end
+    end
+  end
+end
+
+#    module Expr
+    #  def simplify bindings={}, rules=DEFAULT_SIMPLIFY_RULES
+    #    for rule in rules
+    #      new_bindings = self.match(rule.lhs, bindings)
+    #      return rule.rhs.with(new_bindings).simplify(bindings,rules) if
+    #        new_bindings
+    #    end
+    #  end
+
+      # rule: pair of expressions, which may refer to matchers
+      # matcher: name, predicate block
+      # bindings: map from matcher to expression
+      # the result of matching an expression with another expression should be
+      # false if the match fails, or it should return bindings for the matchers
+      # that make the match succeed.
+      # note: match is not commutative; it's probably easiest if we return
+      # bindings for the lhs (self), since most of the tricky stuff then goes
+      # into VarExpr. This isn't maximally rubyish: "foo" =~ /foo/ -- the
+      # pattern comes last -- but /foo/.match("foo") is also valid.
+      # note: a convention is also required for handling things like
+      # (x + y).match(a - b) -- this could succeed with x => a, y => -b, but it
+      # requires more checks -- can't just check op of root. 
+    #  def match expr
+#
+#      end
+#    end
+    #
+    # Simplification isn't really recursive (in the tree structure) -- we have
+    # to apply a list of rules, and we restart when the current rule matches
+    # any part of the expression tree.
+    # The simplification process for one rewrite rule could be recursive: do a
+    # post-order traversal, rewriting children; at the top level, we just
+    # compare the whole resulting expression with the original to see if
+    # anything's changed.
+    # The match is then non-recursive.
+    #
+

data/lib/rucas/simplify.rb

@@ -0,0 +1,102 @@
+require 'rucas/rewrite'
+
+module Rucas
+  #
+  # Simplification; this is still fairly primitive.
+  #
+  # things that don't simplify:
+  # Examples from PAIP 8.3: commutativity and associativity
+  #  {3*(2*x)}
+  #  {2 * x * x * 3}
+  #  {2 * x * 3 * y * 4 * z * 5 * 6}
+  #  {3 + x + 4 + x}
+  #  {2 * x * 3 * x * 4 * (1 / x) * 5 * 6}
+  # 
+  module Simplify
+    #
+    # Ordered hash of simplification rules.
+    #
+    # The order of the rules is very important for avoiding unsoundness due to
+    # division by zero, for example.
+    #
+    # Note that division by zero always results in a NaN. If it were possible to
+    # prove that x was strictly positive (negative), x / 0 should arguably
+    # evaluate to +Inf (-Inf), but this is substantially beyond what we can do
+    # at this point.
+    # 
+    RULES = Rewrite.make_rules {
+      var :w
+      var :x
+      var :y
+      z = Symbolic::Expr.make(0)
+      nan = Symbolic::Expr.make(0.0/0.0)
+
+      # These rules are taken from Norvig's Paradigms of AI Programming
+      # (chapter 8). The source for that book is freely available.
+      rule( x + 0  => x   )
+      rule( 0 + x  => x   )
+      rule( x + x  => 2*x )
+      rule( x - 0  => x   )
+      rule( 0 - x  => -x  )
+      rule( x - x  => 0   )
+      rule( +x     => x   )
+      rule( --x    => x   )
+      rule( x * 1  => x   )
+      rule( 1 * x  => x   )
+      rule( x * 0  => 0   )
+      rule( 0 * x  => 0   )
+      rule( x * x  => x**2)
+      rule( x / 0  => nan )
+      rule( 0 / x  => 0   )
+      rule( x / 1  => x   )
+      rule( x / x  => 1   )
+      rule( z ** 0 => 1   ) # note: Ruby says 0 ** 0 is 1; be consistent
+      rule( x ** 0 => 1   )
+      rule( 0 ** x => 0   )
+      rule( 1 ** x => 1   )
+      rule( x ** 1 => x   )
+      rule( x ** -1     => 1 / x)
+      rule( x * (y / x) => y    )
+      rule( (y / x) * x => y    )
+      rule( (y * x) / x => y    )
+      rule( (x * y) / x => y    )
+      rule( x + -x      => 0    )
+      rule( -x + x      => 0    )
+      rule( x + y - x   => y    )
+      rule( x - y - x   => -y   )
+
+      # These rules are helpful for "rebalancing" long trees, which can make
+      # some of the rules above effective. This is because we don't actually
+      # handle associativity properly. These rules do slow things down a bit,
+      # but hopefully it doesn't break anything too badly.
+      #
+      # Interestingly, Norvig's "infix->prefix" functions used right-
+      # associative grouping, which made things go more smoothly. For example,
+      # x^2 + x + x + 1 simplifies to x^2 + 2*x + 1 without the rebalancing
+      # rule, if you group from the right (but the reverse doesn't simplify).
+      rule( (w + x) + y => w + (x + y) )
+      rule( (w * x) * y => w * (x * y) )
+    }
+  end
+
+  module Symbolic
+    module Expr
+      #
+      # Return expression after algebraic simplification. Note that this isn't a
+      # very smart simplifier.
+      # 
+      def simplify
+        new_self = self
+        changed = false
+        for pattern, output in Simplify::RULES
+          new_self = new_self.rewrite(pattern, output)
+          #puts "#{pattern}\t#{new_self.to_s_paren}"
+          changed = (new_self != self)
+          break if changed
+        end
+        if changed then new_self.simplify else self end
+      end
+    end
+  end
+end
+

data/lib/rucas/symbolic.rb

@@ -0,0 +1,238 @@
+module Rucas
+  #  
+  # Translate Ruby expressions into expression trees for symbolic manipulation.
+  #
+  module Symbolic
+    include Utility
+
+    #
+    # Define variable in this scope and return it.
+    #
+    def var name
+      var = VarExpr.new(name)
+      meta_def var.name do
+        var
+      end
+      var
+    end
+
+    CONST_CLASSES = [Fixnum, Float, Bignum] 
+
+    #
+    # Symbolic expression; subclasses represent various kinds of expressions.
+    #
+    module Expr
+      # Children in the expression tree, if any. For example, an AddExpr returns
+      # its left and right operands (x and y in x + y).
+      def children; [] end
+
+      # Operator precedence; this reflects Ruby's built-in order-of-operations
+      # rules. You should not rely on the particular values; only the ordering
+      # they define is guaranteed. 
+      def precedence; 0 end
+
+      # String representation including all parentheses; by default, +to_s+
+      # omits parentheses when operator precedence rules allow.
+      def to_s_paren; to_s end
+
+      def self.make e
+        return e                if e.is_a?(Expr)
+        return ConstExpr.new(e) if CONST_CLASSES.any? {|t| e.is_a?(t)}
+        raise "#{e} is not a symbolic expression"
+      end
+    end
+
+    # Numeric constant.
+    ConstExpr = Struct.new(:value)
+    class ConstExpr
+      include Expr
+
+      def to_s; value.to_s end
+      def constant?; true end
+    end
+
+    # Variable (literal).
+    VarExpr = Struct.new(:name)
+    class VarExpr
+      include Expr
+
+      def to_s; name.to_s end
+      def constant?; false end
+    end
+
+    #
+    # Expression with an operator and operand(s).
+    #
+    module OpExpr
+      include Expr
+
+      #
+      # The operators on the same line have the same precedence; the list is
+      # from highest precedence to lowest precedence. This list is from the
+      # Pickaxe book ("The Ruby Language").
+      #
+      op_precedence_table =
+        [%w(**),
+         %w(~@ +@ -@),
+         %w(* / %),
+         %w(+ -)]
+
+      #
+      # Operator precedence; you shouldn't rely on the numbers, but (barring
+      # changes to Ruby), the order shouldn't change. 
+      #
+      OP_PRECEDENCE = Hash[*op_precedence_table.
+        zip((1..op_precedence_table.size).to_a).
+        map{|ops,prec| ops.map{|op| [op.to_sym, -prec]}}.flatten]
+
+      #
+      # Precedence (in Ruby) of this operator; this affects how expressions are
+      # parenthesized.
+      #
+      def precedence
+        OP_PRECEDENCE[self.op]
+      end
+
+      def constant?; children.all {|c| c.constant?} end
+    end
+
+    #
+    # Unary operations.
+    #
+    UnaryOpExpr = Struct.new(:op, :rhs)
+    class UnaryOpExpr
+      include OpExpr
+
+      def children; [rhs] end
+      
+      def to_s_paren
+        "#{self.op}(#{self.rhs.to_s_paren})"
+      end
+    end
+
+    class PosExpr < UnaryOpExpr
+      def to_s; rhs.to_s end
+    end
+
+    class NegExpr < UnaryOpExpr
+      def to_s; rhs.precedence < self.precedence ? "-(#{rhs})" : "-#{rhs}" end
+    end
+
+    UNARY_OPS = {
+      :+@  => :PosExpr,
+      :-@  => :NegExpr,
+      :~@  => :NotExpr,
+    }
+
+    for op, op_class in UNARY_OPS
+      class_eval %Q{
+        class #{op_class}
+          def initialize(rhs)
+            self.op, self.rhs = :#{op}, rhs
+          end
+        end
+      }
+    end
+
+    module Expr
+      for op, op_class in UNARY_OPS
+        class_eval %Q{
+          def #{op} ; #{op_class}.new(self) end
+        }
+      end
+    end
+
+    #
+    # Binary operations.
+    #
+    BinaryOpExpr = Struct.new(:op, :lhs, :rhs)
+    class BinaryOpExpr 
+      include OpExpr
+
+      def children; [lhs, rhs] end
+
+      def to_s_paren
+        op_string = " #{self.op} "
+        "(#{self.children.map{|c| c.to_s_paren}.join(op_string)})"
+      end
+
+      def to_s
+        inner = self.children.map{|c|
+          c.precedence < self.precedence ? "(#{c})" : c.to_s}
+        "#{inner.join(self.op_string)}"
+      end
+
+      protected
+      # Allow for control of spacing between operands.
+      def op_string; " #{self.op} " end
+    end
+
+    # Arithmetic
+    class ArithmeticOpExpr < BinaryOpExpr ; end
+    class AddExpr < ArithmeticOpExpr; end
+    class SubExpr < ArithmeticOpExpr; end
+    class MulExpr < ArithmeticOpExpr; end
+    class DivExpr < ArithmeticOpExpr; end
+    class PowExpr < ArithmeticOpExpr; end
+
+    # Comparison
+    class CompareOpExpr < BinaryOpExpr ; end
+    class EqExpr < CompareOpExpr ; end
+    class LTExpr < CompareOpExpr ; end
+    class LTEqExpr < CompareOpExpr ; end
+    class GTExpr < CompareOpExpr ; end
+    class GTEqExpr < CompareOpExpr ; end
+
+    # Logic -- see comments below
+    #class BooleanOpExpr < BinaryOpExpr ; end
+    #class AndExpr < BooleanOpExpr ; end
+    #class OrExpr < BooleanOpExpr ; end
+
+    BINARY_OPS = {
+      :+  => :AddExpr,
+      :-  => :SubExpr,
+      :*  => :MulExpr,
+      :/  => :DivExpr,
+      :** => :PowExpr,
+      :=~ => :EqExpr,   # =, == and === are all taken!
+      :<  => :LTExpr,
+      :<= => :LTEqExpr,
+      :>  => :GTExpr,
+      :>= => :GTEqExpr}
+
+      # Note: can use & and | for logic, but there are problems with
+      # precedence: it binds before the (in)equality symbols. Also need to
+      # change the simplification code to treat them specially. This needs more
+      # thinking. 
+#      :&  => :AndExpr,
+#      :|  => :OrExpr}
+
+    for op, op_class in BINARY_OPS
+      class_eval %Q{
+        class #{op_class}
+          def initialize(lhs, rhs)
+            self.lhs, self.op, self.rhs = lhs, :#{op}, rhs
+          end
+        end
+      }
+    end
+
+    module Expr
+      for op, op_class in BINARY_OPS
+        class_eval %Q{
+          def #{op} rhs ; #{op_class}.new(self, Expr.make(rhs)) end
+        }
+      end
+    end
+
+    class MulExpr
+      # Reduce spacing between factors.
+      def op_string; self.op.to_s end
+    end
+
+    class PowExpr
+      # Reduce spacing between base and exponent.
+      def op_string; self.op.to_s end
+    end
+  end
+end