keisan 0.3.0 → 0.4.0

data/lib/keisan/ast/builder.rb

@@ -15,8 +15,10 @@ module Keisan
           @components = Array.wrap(components)
         end
 
-        @nodes = nodes_split_by_operators(@components)
-        @operators = @components.select {|component| component.is_a?(Keisan::Parsing::Operator)}
+        @nodes = components_to_basic_nodes(@components)
+
+        # Negative means not an operator
+        @priorities = @nodes.map {|node| node.is_a?(Keisan::Parsing::Operator) ? node.priority : -1}
 
         consume_operators!
 
@@ -35,27 +37,44 @@ module Keisan
 
       private
 
-      def nodes_split_by_operators(components)
-        components.split {|component|
-          component.is_a?(Keisan::Parsing::Operator)
-        }.map {|group_of_components|
-          node_from_components(group_of_components)
-        }
+      # Array of AST elements, and Parsing operators
+      def components_to_basic_nodes(components)
+        nodes_components = []
+
+        components.each do |component|
+          if nodes_components.empty?
+            nodes_components << [component]
+          else
+            is_operator = [nodes_components.last.last.is_a?(Keisan::Parsing::Operator), component.is_a?(Keisan::Parsing::Operator)]
+
+            if is_operator.first == is_operator.last
+              nodes_components.last << component
+            else
+              nodes_components << [component]
+            end
+          end
+        end
+
+        nodes_components.inject([]) do |nodes, node_or_component_group|
+          if node_or_component_group.first.is_a?(Keisan::Parsing::Operator)
+            node_or_component_group.each do |component|
+              nodes << component
+            end
+          else
+            nodes << node_from_components(node_or_component_group)
+          end
+
+          nodes
+        end
       end
 
       def node_from_components(components)
-        unary_components, node, postfix_components = *unarys_node_postfixes(components)
-
+        node, postfix_components = *node_postfixes(components)
         # Apply postfix operators
         postfix_components.each do |postfix_component|
           node = apply_postfix_component_to_node(postfix_component, node)
         end
 
-        # Apply prefix unary operators
-        unary_components.reverse.each do |unary_component|
-          node = unary_component.node_class.new(node)
-        end
-
         node
       end
 
@@ -69,16 +88,16 @@ module Keisan
             }
           )
         when Keisan::Parsing::DotWord
-          Keisan::AST::Function.build(
-            postfix_component.name,
-            [node]
+          Keisan::AST::Function.new(
+            [node],
+            postfix_component.name
           )
         when Keisan::Parsing::DotOperator
-          Keisan::AST::Function.build(
-            postfix_component.name,
+          Keisan::AST::Function.new(
             [node] + postfix_component.arguments.map {|parsing_argument|
               Builder.new(components: parsing_argument.components).node
-            }
+            },
+            postfix_component.name
           )
         else
           raise Keisan::Exceptions::ASTError.new("Invalid postfix component #{postfix_component}")
@@ -86,17 +105,10 @@ module Keisan
       end
 
       # Returns an array of the form
-      # [unary_operators, middle_node, postfix_operators]
-      # unary_operators is an array of Keisan::Parsing::UnaryOperator objects
+      # [node, postfix_operators]
       # middle_node is the main node which will be modified by prefix and postfix operators
       # postfix_operators is an array of Keisan::Parsing::Indexing, DotWord, and DotOperator objects
-      def unarys_node_postfixes(components)
-        index_of_unary_components = components.map.with_index {|c,i| [c,i]}.select {|c,i| c.is_a?(Keisan::Parsing::UnaryOperator)}.map(&:last)
-        # Must be all in the front
-        unless index_of_unary_components.map.with_index.all? {|i,j| i == j}
-          raise Keisan::Exceptions::ASTError.new("unary operators must be in front")
-        end
-
+      def node_postfixes(components)
         index_of_postfix_components = components.map.with_index {|c,i| [c,i]}.select {|c,i|
           c.is_a?(Keisan::Parsing::Indexing) || c.is_a?(Keisan::Parsing::DotWord) || c.is_a?(Keisan::Parsing::DotOperator)
         }.map(&:last)
@@ -104,16 +116,14 @@ module Keisan
           raise Keisan::Exceptions::ASTError.new("postfix components must be in back")
         end
 
-        num_unary   = index_of_unary_components.size
         num_postfix = index_of_postfix_components.size
 
-        unless num_unary + 1 + num_postfix == components.size
+        unless num_postfix + 1 == components.size
           raise Keisan::Exceptions::ASTError.new("have too many components")
         end
 
         [
-          index_of_unary_components.map {|i| components[i]},
-          node_of_component(components[index_of_unary_components.size]),
+          node_of_component(components[0]),
           index_of_postfix_components.map {|i| components[i]}
         ]
       end
@@ -139,23 +149,23 @@ module Keisan
         when Keisan::Parsing::Group
           Builder.new(components: component.components).node
         when Keisan::Parsing::Function
-          Keisan::AST::Function.build(
-            component.name,
+          Keisan::AST::Function.new(
             component.arguments.map {|parsing_argument|
               Builder.new(components: parsing_argument.components).node
-            }
+            },
+            component.name
           )
         when Keisan::Parsing::DotWord
-          Keisan::AST::Function.build(
-            component.name,
-            [node_of_component(component.target)]
+          Keisan::AST::Function.new(
+            [node_of_component(component.target)],
+            component.name
           )
         when Keisan::Parsing::DotOperator
-          Keisan::AST::Function.build(
-            component.name,
+          Keisan::AST::Function.new(
             [node_of_component(component.target)] + component.arguments.map {|parsing_argument|
               Builder.new(components: parsing_argument.components).node
-            }
+            },
+            component.name
           )
         else
           raise Keisan::Exceptions::ASTError.new("Unhandled component, #{component}")
@@ -163,32 +173,57 @@ module Keisan
       end
 
       def consume_operators!
-        while @operators.count > 0
-          priorities = @operators.map(&:priority)
-          max_priority = priorities.uniq.max
+        loop do
+          break if @priorities.empty?
+          max_priority = @priorities.max
+          break if max_priority < 0
+
           consume_operators_with_priority!(max_priority)
         end
       end
 
       def consume_operators_with_priority!(priority)
-        # Treat back-to-back operators with same priority as one single call (e.g. 1 + 2 + 3 is add(1,2,3))
-        while @operators.any? {|operator| operator.priority == priority}
-          next_operator_group = @operators.each.with_index.to_a.split {|operator,i|
-            operator.priority != priority
-          }.select {|ops| !ops.empty?}.first
-          operator_group_indexes = next_operator_group.map(&:last)
-
-          first_index = operator_group_indexes.first
-          last_index  = operator_group_indexes.last
-
-          replacement_node = next_operator_group.first.first.node_class.new(
-            children = @nodes[first_index..(last_index+1)],
-            parsing_operators = @operators[first_index..last_index]
-          )
+        p_indexes = @priorities.map.with_index.select {|p,index| p == priority}
+        # :left, :right, or :none
+        associativity = AST::Operator.associativity_of_priority(priority)
+
+        if associativity == :right
+          index = p_indexes[-1][1]
+        else
+          index = p_indexes[0][1]
+        end
 
-          @nodes.delete_if.with_index {|node, i| i >= first_index && i <= last_index+1}
-          @operators.delete_if.with_index {|node, i| i >= first_index && i <= last_index}
-          @nodes.insert(first_index, replacement_node)
+        operator = @nodes[index]
+
+        # If has unary operators after, must process those first
+        if @nodes[index+1].is_a?(Keisan::Parsing::UnaryOperator)
+          loop do
+            break if !@nodes[index+1].is_a?(Keisan::Parsing::UnaryOperator)
+            index += 1
+          end
+          operator = @nodes[index]
+        end
+
+        # operator is the current operator to process, and index is its index
+        if operator.is_a?(Keisan::Parsing::UnaryOperator)
+          replacement_node = operator.node_class.new(
+            children = [@nodes[index+1]]
+          )
+          @nodes.delete_if.with_index {|node, i| i >= index && i <= index+1}
+          @priorities.delete_if.with_index {|node, i| i >= index && i <= index+1}
+          @nodes.insert(index, replacement_node)
+          @priorities.insert(index, -1)
+        elsif operator.is_a?(Keisan::Parsing::Operator)
+          replacement_node = operator.node_class.new(
+            children = [@nodes[index-1],@nodes[index+1]],
+            parsing_operators = [operator]
+          )
+          @nodes.delete_if.with_index {|node, i| i >= index-1 && i <= index+1}
+          @priorities.delete_if.with_index {|node, i| i >= index-1 && i <= index+1}
+          @nodes.insert(index-1, replacement_node)
+          @priorities.insert(index-1, -1)
+        else
+          raise Keisan::Exceptions::ASTError.new("Can only consume operators")
         end
       end
     end

data/lib/keisan/ast/constant_literal.rb

@@ -0,0 +1,13 @@
+module Keisan
+  module AST
+    class ConstantLiteral < Literal
+      def evaluate(context = nil)
+        self
+      end
+
+      def to_s
+        value.to_s
+      end
+    end
+  end
+end

data/lib/keisan/ast/exponent.rb

@@ -1,14 +1,6 @@
 module Keisan
   module AST
     class Exponent < ArithmeticOperator
-      def arity
-        (2..2)
-      end
-
-      def associativity
-        :right
-      end
-
       def self.symbol
         :**
       end
@@ -16,6 +8,68 @@ module Keisan
       def blank_value
         1
       end
+
+      def simplify(context = nil)
+        context ||= Context.new
+
+        super(context)
+
+        # Reduce to basic binary exponents
+        reduced = children.reverse[1..-1].inject(children.last) do |total, child|
+          child ** total
+        end
+
+        unless reduced.is_a?(AST::Exponent)
+          return reduced.simplify(context)
+        end
+
+        if reduced.children.count != 2
+          raise Keisan::Exceptions::InternalError.new("Exponent should be binary")
+        end
+        @children = reduced.children
+
+        if children[1].is_a?(AST::Number) && children[1].value(context) == 1
+          return children[0]
+        end
+
+        if children.all? {|child| child.is_a?(AST::Number)}
+          (children[0] ** children[1]).simplify(context)
+        else
+          self
+        end
+      end
+
+      def evaluate(context = nil)
+        children.reverse[1..-1].inject(children.last.evaluate(context)) {|total, child| child.evaluate(context) ** total}
+      end
+
+      # d ( a^b ) = d ( exp(b log(a)) ) = a^b * d (b log(a))
+      # = a^b * [ db * log(a) + da * b/a] = da b a^(b-1) + db log(a) a^b
+      def differentiate(variable, context = nil)
+        context ||= Context.new
+
+        # Reduce to binary form
+        unless children.count == 2
+          return simplify(context).differentiate(variable, context)
+        end
+
+        base     = children[0].simplified(context)
+        exponent = children[1].simplified(context)
+
+        # Special simple case where exponent is a pure number
+        if exponent.is_a?(AST::Number)
+          return (exponent * base ** (exponent -1)).simplify(context)
+        end
+
+        base_diff     = base.differentiate(variable, context)
+        exponent_diff = exponent.differentiate(variable, context)
+
+        res = base ** exponent * (
+          exponent_diff * AST::Function.new([base], "log") +
+          base_diff * exponent / base
+        )
+        res.simplify(context)
+      end
     end
   end
 end

data/lib/keisan/ast/function.rb

@@ -9,10 +9,8 @@ module Keisan
       end
 
       def value(context = nil)
-        context = Keisan::Context.new if context.nil?
-        argument_values = children.map {|child| child.value(context)}
-        function = function_from_context(context)
-        function.call(context, *argument_values)
+        context ||= Keisan::Context.new
+        function_from_context(context).value(self, context)
       end
 
       def unbound_functions(context = nil)
@@ -25,43 +23,56 @@ module Keisan
         context.has_function?(name) ? functions : functions | Set.new([name])
       end
 
+      def function_defined?(context = nil)
+        context ||= Keisan::Context.new
+        context.has_function?(name)
+      end
+
       def function_from_context(context)
-        @override || context.function(name)
+        context.function(name)
       end
-    end
 
-    class If < Function
-      def value(context = nil)
-        unless (2..3).cover? children.size
-          raise Keisan::Exceptions::InvalidFunctionError.new("Require 2 or 3 arguments to if")
+      def ==(other)
+        case other
+        when AST::Function
+          name == other.name && super
+        else
+          false
         end
+      end
 
-        bool = children[0].value(context)
+      def evaluate(context = nil)
+        context ||= Keisan::Context.new
 
-        if bool
-          children[1].value(context)
+        if function_defined?(context)
+          function_from_context(context).evaluate(self, context)
         else
-          children.size == 3 ? children[2].value(context) : nil
+          @children = children.map {|child| child.evaluate(context)}
+          self
         end
       end
 
-      def unbound_functions(context = nil)
-        context ||= Keisan::Context.new
+      def simplify(context = nil)
+        context ||= Context.new
 
-        children.inject(Set.new) do |res, child|
-          res | child.unbound_functions(context)
+        if function_defined?(context)
+          function_from_context(context).simplify(self, context)
+        else
+          @children = children.map {|child| child.simplify(context)}
+          self
         end
       end
-    end
 
-    class Function
-      def self.build(name, arguments = [])
-        case name.downcase
-        when "if"
-          If.new(arguments, name)
-        else
-          Function.new(arguments, name)
+      def to_s
+        "#{name}(#{children.map(&:to_s).join(',')})"
+      end
+
+      def differentiate(variable, context = nil)
+        unless unbound_variables(context).include?(variable.name)
+          return AST::Number.new(0)
         end
+        # Do not know how to differentiate a function in general, so leave as derivative
+        AST::Function.new([self, variable], "diff")
       end
     end
   end

data/lib/keisan/ast/functions/diff.rb

@@ -0,0 +1,57 @@
+module Keisan
+  module AST
+    module Functions
+      class Diff < AST::Function
+        def initialize(arguments, name = "diff")
+          super(arguments, name)
+        end
+
+        def value(context = nil)
+          raise Keisan::Exceptions::InvalidFunctionError.new("Derivative not defined")
+        end
+
+        def unbound_functions(context = nil)
+          context ||= Keisan::Context.new
+
+          children.inject(Set.new) do |res, child|
+            res | child.unbound_functions(context)
+          end
+        end
+
+        def simplify(context = nil)
+          unless children.size > 0
+            raise Keisan::Exceptions::InvalidFunctionError.new("Diff requires at least one argument")
+          end
+
+          vars = children[1..-1]
+
+          unless vars.all? {|var| var.is_a?(AST::Variable)}
+            raise Keisan::Exceptions::InvalidFunctionError.new("Diff must differentiate with respect to variables")
+          end
+
+          result = children.first.simplify(context)
+
+          while vars.size > 0
+            begin
+              var = vars.first
+              if result.unbound_variables(context).include?(var.name)
+                result = result.differentiate(var, context)
+              else
+                return AST::Number.new(0)
+              end
+            rescue Keisan::Exceptions::NonDifferentiableError => e
+              return AST::Functions::Diff.new(
+                [result] + vars,
+                "diff"
+              )
+            end
+
+            vars.shift
+          end
+
+          result
+        end
+      end
+    end
+  end
+end