keisan 0.3.0 → 0.4.0

data/lib/keisan/ast/null.rb

@@ -1,6 +1,6 @@
 module Keisan
   module AST
-    class Null < Literal
+    class Null < ConstantLiteral
       def initialize
       end
 

data/lib/keisan/ast/number.rb

@@ -1,6 +1,6 @@
 module Keisan
   module AST
-    class Number < Literal
+    class Number < ConstantLiteral
       attr_reader :number
 
       def initialize(number)
@@ -10,6 +10,177 @@ module Keisan
       def value(context = nil)
         number
       end
+
+      def -@
+        AST::Number.new(-value)
+      end
+
+      def +@
+        AST::Number.new(value)
+      end
+
+      def +(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Number.new(value + other.value)
+        else
+          super
+        end
+      end
+
+      def -(other)
+        self + (-other.to_node)
+      end
+
+      def *(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Number.new(value * other.value)
+        else
+          super
+        end
+      end
+
+      def /(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Number.new(Rational(value, other.value))
+        else
+          super
+        end
+      end
+
+      def **(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Number.new(value ** other.value)
+        else
+          super
+        end
+      end
+
+      def %(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Number.new(value % other.value)
+        else
+          super
+        end
+      end
+
+      def &(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Number.new(value & other.value)
+        else
+          super
+        end
+      end
+
+      def ~
+        AST::Number.new(~value)
+      end
+
+      def ^(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Number.new(value ^ other.value)
+        else
+          super
+        end
+      end
+
+      def |(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Number.new(value | other.value)
+        else
+          super
+        end
+      end
+
+      def >(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Boolean.new(value > other.value)
+        else
+          super
+        end
+      end
+
+      def >=(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Boolean.new(value >= other.value)
+        else
+          super
+        end
+      end
+
+      def <(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Boolean.new(value < other.value)
+        else
+          super
+        end
+      end
+
+      def <=(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Boolean.new(value <= other.value)
+        else
+          super
+        end
+      end
+
+      def equal(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Boolean.new(value == other.value)
+        else
+          super
+        end
+      end
+
+      def not_equal(other)
+        other = other.to_node
+        case other
+        when AST::Number
+          AST::Boolean.new(value != other.value)
+        else
+          super
+        end
+      end
+
+      def simplify(context = nil)
+        case number
+        when Rational
+          if number.denominator == 1
+            @number = number.numerator
+          end
+        end
+
+        self
+      end
+
+      def differentiate(variable, context = nil)
+        0.to_node
+      end
     end
   end
 end

data/lib/keisan/ast/operator.rb

@@ -1,23 +1,62 @@
 module Keisan
   module AST
     class Operator < Parent
+      # NOTE: operators with same priority must have same associativity
+      ARITY_PRIORITY_ASSOCIATIVITY = {
+        "u!": [1, 100, :right],  # Logical not
+        "u~": [1, 100, :right],  # Bitwise not
+        "u+": [1, 100, :right],  # Unary plus
+        "**": [2,  95, :right],  # Exponent
+        "u-": [1,  90, :right],  # Unary minus
+        "*":  [2,  85, :left],   # Times
+        # "/":  [2,  85, :left], # Divide
+        "%":  [2,  85, :left],   # Modulo
+        "+":  [2,  80, :left],   # Plus
+        # "-":  [2,  80, :left], # Minus
+        "&":  [2,  70, :left],   # Bitwise and
+        "^":  [2,  65, :left],   # Bitwise xor
+        "|":  [2,  65, :left],   # Bitwise or
+        ">":  [2,  60, :left],   # Greater than
+        ">=": [2,  60, :left],   # Greater than or equal to
+        "<":  [2,  60, :left],   # Less than
+        "<=": [2,  60, :left],   # Less than or equal to
+        "==": [2,  55, :none],   # Equal
+        "!=": [2,  55, :none],   # Not equal
+        "&&": [2,  50, :left],   # Logical and
+        "||": [2,  45, :left],   # Logical or
+        "=":  [2,  40, :right] # TODO: handle and test
+      }.freeze
+
+      ARITIES         = Hash[ARITY_PRIORITY_ASSOCIATIVITY.map {|sym, ary| [sym, ary[0]]}].freeze
+      PRIORITIES      = Hash[ARITY_PRIORITY_ASSOCIATIVITY.map {|sym, ary| [sym, ary[1]]}].freeze
+      ASSOCIATIVITIES = Hash[ARITY_PRIORITY_ASSOCIATIVITY.map {|sym, ary| [sym, ary[2]]}].freeze
+
+      ASSOCIATIVITY_OF_PRIORITY = ARITY_PRIORITY_ASSOCIATIVITY.inject({}) do |h, (symbol,arity_priority_associativity)|
+        h[arity_priority_associativity[1]] = arity_priority_associativity[2]
+        h
+      end.freeze
+
       def initialize(children = [], parsing_operators = [])
-        unless children.count == parsing_operators.count + 1
+        unless parsing_operators.empty? || children.count == parsing_operators.count + 1
           raise Keisan::Exceptions::ASTError.new("Mismatch of children and operators")
         end
 
-        unless arity.include?(children.count)
-          raise Keisan::Exceptions::ASTError.new("Invalid number of arguments")
-        end
-
         children = Array.wrap(children)
         super(children)
 
         @parsing_operators = parsing_operators
       end
 
+      def self.associativity_of_priority(priority)
+        ASSOCIATIVITY_OF_PRIORITY[priority]
+      end
+
       def arity
-        raise Keisan::Exceptions::NotImplementedError.new
+        self.class.arity
+      end
+
+      def self.arity
+        ARITIES[symbol]
       end
 
       def priority
@@ -25,17 +64,25 @@ module Keisan
       end
 
       def self.priority
-        Keisan::AST::Priorities.priorities[symbol]
+        PRIORITIES[symbol]
       end
 
       def associativity
-        raise Keisan::Exceptions::NotImplementedError.new
+        self.class.associativity
+      end
+
+      def self.associativity
+        ASSOCIATIVITIES[symbol]
       end
 
       def symbol
         self.class.symbol
       end
 
+      def self.symbol
+        raise Keisan::Exceptions::NotImplementedError.new
+      end
+
       def blank_value
         raise Keisan::Exceptions::NotImplementedError.new
       end
@@ -52,6 +99,17 @@ module Keisan
           end
         end
       end
+
+      def to_s
+        children.map do |child|
+          case child
+          when AST::Operator
+            "(#{child.to_s})"
+          else
+            "#{child.to_s}"
+          end
+        end.join(symbol.to_s)
+      end
     end
   end
 end

data/lib/keisan/ast/parent.rb

@@ -10,6 +10,56 @@ module Keisan
         end
         @children = children
       end
+
+      def unbound_variables(context = nil)
+        context ||= Keisan::Context.new
+        children.inject(Set.new) do |vars, child|
+          vars | child.unbound_variables(context)
+        end
+      end
+
+      def unbound_functions(context = nil)
+        context ||= Keisan::Context.new
+        children.inject(Set.new) do |fns, child|
+          fns | child.unbound_functions(context)
+        end
+      end
+
+      def ==(other)
+        return false unless self.class == other.class
+
+        children.size == other.children.size && children.map.with_index {|_,i|
+          children[i] == other.children[i]
+        }.all? {|bool|
+          bool == true
+        }
+      end
+
+      def deep_dup
+        dupped = dup
+        dupped.instance_variable_set(
+          :@children,
+          dupped.children.map(&:deep_dup)
+        )
+        dupped
+      end
+
+      def evaluate(context = nil)
+        context ||= Keisan::Context.new
+        @children = children.map {|child| child.evaluate(context)}
+        self
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+        @children = @children.map {|child| child.simplify(context)}
+        self
+      end
+
+      def replace(variable, replacement)
+        @children = children.map {|child| child.replace(variable, replacement)}
+        self
+      end
     end
   end
 end

data/lib/keisan/ast/plus.rb

@@ -6,10 +6,6 @@ module Keisan
         convert_minus_to_plus!
       end
 
-      def arity
-        2..Float::INFINITY
-      end
-
       def self.symbol
         :+
       end
@@ -31,6 +27,44 @@ module Keisan
         end
       end
 
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total + child.evaluate(context)}
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+
+        super(context)
+
+        # Commutative, so pull in operands of any `Plus` operators
+        @children = children.inject([]) do |new_children, cur_child|
+          case cur_child
+          when AST::Plus
+            new_children + cur_child.children
+          else
+            new_children << cur_child
+          end
+        end
+
+        constants, non_constants = *children.partition {|child| child.is_a?(AST::Number)}
+        constant = constants.inject(AST::Number.new(0), &:+).simplify(context)
+
+        if non_constants.empty?
+          constant
+        else
+          @children = constant.value(context) == 0 ? [] : [constant]
+          @children += non_constants
+
+          return @children.first.simplify(context) if @children.size == 1
+
+          self
+        end
+      end
+
+      def differentiate(variable, context = nil)
+        AST::Plus.new(children.map {|child| child.differentiate(variable, context)}).simplify(context)
+      end
+
       private
 
       def convert_minus_to_plus!

data/lib/keisan/ast/string.rb

@@ -1,6 +1,6 @@
 module Keisan
   module AST
-    class String < Literal
+    class String < ConstantLiteral
       attr_reader :content
 
       def initialize(content)
@@ -10,6 +10,15 @@ module Keisan
       def value(context = nil)
         content
       end
+
+      def +(other)
+        case other
+        when AST::String
+          AST::String.new(value + other.value)
+        else
+          raise Keisan::Exceptions::TypeError.new("#{other}'s type is invalid, #{other.class}")
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/times.rb

@@ -6,10 +6,6 @@ module Keisan
         convert_divide_to_inverse!
       end
 
-      def arity
-        2..Float::INFINITY
-      end
-
       def self.symbol
         :*
       end
@@ -18,6 +14,53 @@ module Keisan
         1
       end
 
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total * child.evaluate(context)}
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+
+        super(context)
+
+        # Commutative, so pull in operands of any `Times` operators
+        @children = children.inject([]) do |new_children, cur_child|
+          case cur_child
+          when AST::Times
+            new_children + cur_child.children
+          else
+            new_children << cur_child
+          end
+        end
+
+        constants, non_constants = *children.partition {|child| child.is_a?(AST::Number)}
+        constant = constants.inject(AST::Number.new(1), &:*).simplify(context)
+
+        return Keisan::AST::Number.new(0) if constant.value(context) == 0
+
+        if non_constants.empty?
+          constant
+        else
+          @children = constant.value(context) == 1 ? [] : [constant]
+          @children += non_constants
+
+          return @children.first.simplify(context) if @children.size == 1
+
+          self
+        end
+      end
+
+      def differentiate(variable, context = nil)
+        # Product rule
+        AST::Plus.new(
+          children.map.with_index do |child,i|
+            AST::Times.new(
+              children.slice(0,i) + [child.differentiate(variable, context)] + children.slice(i+1,children.size)
+            )
+          end
+        ).simplify(context)
+      end
+
       private
 
       def convert_divide_to_inverse!