keisan 0.5.0 → 0.6.0

data/lib/keisan/ast/cell.rb

@@ -0,0 +1,60 @@
+module Keisan
+  module AST
+    class Cell < Node
+      attr_accessor :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def unbound_variables(context = nil)
+        node.unbound_variables(context)
+      end
+
+      def unbound_functions(context = nil)
+        node.unbound_functions(context)
+      end
+
+      def deep_dup
+        dupped = dup
+        dupped.instance_variable_set(
+          :@node,
+          dupped.node.deep_dup
+        )
+        dupped
+      end
+
+      def value(context = nil)
+        node.value(context)
+      end
+
+      def evaluate(context = nil)
+        node.evaluate(context)
+      end
+
+      def simplify(context = nil)
+        node.simplify(context)
+      end
+
+      def evaluate_assignments(context = nil)
+        node.evaluate_assignments(context)
+      end
+
+      def differentiate(variable, context = nil)
+        node.differentiate(variable, context)
+      end
+
+      def replace(variable, replacement)
+        node.replace(variable, replacement)
+      end
+
+      def to_s
+        node.to_s
+      end
+
+      def to_node
+        node
+      end
+    end
+  end
+end

data/lib/keisan/ast/constant_literal.rb

@@ -5,6 +5,15 @@ module Keisan
         self
       end
 
+      def ==(other)
+        case other
+        when ConstantLiteral
+          value == other.value
+        else
+          false
+        end
+      end
+
       def to_s
         case value
         when Rational

data/lib/keisan/ast/exponent.rb

@@ -19,20 +19,20 @@ module Keisan
           child ** total
         end
 
-        unless reduced.is_a?(AST::Exponent)
+        unless reduced.is_a?(Exponent)
           return reduced.simplify(context)
         end
 
         if reduced.children.count != 2
-          raise Keisan::Exceptions::InternalError.new("Exponent should be binary")
+          raise Exceptions::InternalError.new("Exponent should be binary")
         end
         @children = reduced.children
 
-        if children[1].is_a?(AST::Number) && children[1].value(context) == 1
+        if children[1].is_a?(Number) && children[1].value(context) == 1
           return children[0]
         end
 
-        if children.all? {|child| child.is_a?(AST::Number)}
+        if children.all? {|child| child.is_a?(Number)}
           (children[0] ** children[1]).simplify(context)
         else
           self
@@ -57,7 +57,7 @@ module Keisan
         exponent = children[1].simplified(context)
 
         # Special simple case where exponent is a pure number
-        if exponent.is_a?(AST::Number)
+        if exponent.is_a?(Number)
           return (exponent * base.differentiate(variable, context) * base ** (exponent -1)).simplify(context)
         end
 
@@ -65,7 +65,7 @@ module Keisan
         exponent_diff = exponent.differentiate(variable, context)
 
         res = base ** exponent * (
-          exponent_diff * AST::Function.new([base], "log") +
+          exponent_diff * Function.new([base], "log") +
           base_diff * exponent / base
         )
         res.simplify(context)

data/lib/keisan/ast/function.rb

@@ -9,12 +9,12 @@ module Keisan
       end
 
       def value(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         function_from_context(context).value(self, context)
       end
 
       def unbound_functions(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
 
         functions = children.inject(Set.new) do |res, child|
           res | child.unbound_functions(context)
@@ -23,8 +23,12 @@ module Keisan
         context.has_function?(name) ? functions : functions | Set.new([name])
       end
 
+      def evaluate_assignments(context = nil)
+        self
+      end
+
       def function_defined?(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         context.has_function?(name)
       end
 
@@ -34,7 +38,7 @@ module Keisan
 
       def ==(other)
         case other
-        when AST::Function
+        when Function
           name == other.name && super
         else
           false
@@ -42,7 +46,7 @@ module Keisan
       end
 
       def evaluate(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
 
         if function_defined?(context)
           function_from_context(context).evaluate(self, context)
@@ -71,12 +75,12 @@ module Keisan
         function = function_from_context(context)
         function.differentiate(self, variable, context)
 
-      rescue Keisan::Exceptions::UndefinedFunctionError, Keisan::Exceptions::NotImplementedError
+      rescue Exceptions::UndefinedFunctionError, Exceptions::NotImplementedError
         unless unbound_variables(context).include?(variable.name)
-          return AST::Number.new(0)
+          return Number.new(0)
         end
 
-        AST::Function.new([self, variable], "diff")
+        self.class.new([self, variable], "diff")
       end
     end
   end

data/lib/keisan/ast/indexing.rb

@@ -16,19 +16,20 @@ module Keisan
         "(#{child.to_s})[#{indexes.map(&:to_s).join(',')}]"
       end
 
+      def evaluate_assignments(context = nil)
+        self
+      end
+
       def evaluate(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         @children = children.map {|child| child.evaluate(context)}
         @indexes = indexes.map {|index| index.evaluate(context)}
 
-        case child
-        when AST::List
-          if @indexes.size == 1 && @indexes.first.is_a?(AST::Number)
-            return child.children[@indexes.first.value(context)].evaluate(context)
-          end
+        if list = extract_list
+          list.children[@indexes.first.value(context)]
+        else
+          self
         end
-
-        self
       end
 
       def simplify(context = nil)
@@ -37,20 +38,29 @@ module Keisan
         @indexes = indexes.map {|index| index.simplify(context)}
         @children = [child.simplify(context)]
 
-        case child
-        when AST::List
-          if @indexes.size == 1 && @indexes.first.is_a?(AST::Number)
-            return child.children[@indexes.first.value(context)].simplify(context)
-          end
+        if list = extract_list
+          Cell.new(list.children[@indexes.first.value(context)].simplify(context))
+        else
+          self
         end
-
-        self
       end
 
       def replace(variable, replacement)
         super
         @indexes = indexes.map {|index| index.replace(variable, replacement)}
       end
+
+      private
+
+      def extract_list
+        if child.is_a?(List)
+          child
+        elsif child.is_a?(Cell) && child.node.is_a?(List)
+          child.node
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/line_builder.rb

@@ -0,0 +1,230 @@
+module Keisan
+  module AST
+    class LineBuilder
+      # Build from parser
+      def initialize(components)
+        @components = components
+        @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!
+
+        case @nodes.count
+        when 0
+          # Empty string, set to just Null
+          @nodes = [Keisan::AST::Null.new]
+        when 1
+          # Good
+        else
+          raise Keisan::Exceptions::ASTError.new("Should end up with a single node")
+        end
+      end
+
+      def node
+        @nodes.first
+      end
+
+      def ast
+        node
+      end
+
+      private
+
+      # Array of AST elements, and Parsing operators
+      def components_to_basic_nodes(components)
+        nodes_components = []
+
+        components.each do |component|
+          if component.is_a?(Keisan::Parsing::LineSeparator)
+            nodes_components << [component]
+          elsif nodes_components.empty? || nodes_components.last.last.is_a?(Keisan::Parsing::LineSeparator)
+            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)
+        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
+
+        node
+      end
+
+      def apply_postfix_component_to_node(postfix_component, node)
+        case postfix_component
+        when Keisan::Parsing::Indexing
+          postfix_component.node_class.new(
+            node,
+            postfix_component.arguments.map {|parsing_argument|
+              Builder.new(components: parsing_argument.components).node
+            }
+          )
+        when Keisan::Parsing::DotWord
+          Keisan::AST::Function.new(
+            [node],
+            postfix_component.name
+          )
+        when Keisan::Parsing::DotOperator
+          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}")
+        end
+      end
+
+      # Returns an array of the form
+      # [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 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)
+        unless index_of_postfix_components.reverse.map.with_index.all? {|i,j| i + j == components.size - 1 }
+          raise Keisan::Exceptions::ASTError.new("postfix components must be in back")
+        end
+
+        num_postfix = index_of_postfix_components.size
+
+        unless num_postfix + 1 == components.size
+          raise Keisan::Exceptions::ASTError.new("have too many components")
+        end
+
+        [
+          node_of_component(components[0]),
+          index_of_postfix_components.map {|i| components[i]}
+        ]
+      end
+
+      def node_of_component(component)
+        case component
+        when Parsing::Number
+          AST::Number.new(component.value)
+        when Parsing::String
+          AST::String.new(component.value)
+        when Parsing::Null
+          AST::Null.new
+        when Parsing::Variable
+          AST::Variable.new(component.name)
+        when Parsing::Boolean
+          AST::Boolean.new(component.value)
+        when Parsing::List
+          AST::List.new(
+            component.arguments.map {|parsing_argument|
+              Builder.new(components: parsing_argument.components).node
+            }
+          )
+        when Parsing::RoundGroup
+          Builder.new(components: component.components).node
+        when Parsing::CurlyGroup
+          Block.new(Builder.new(components: component.components).node)
+        when Parsing::Function
+          AST::Function.new(
+            component.arguments.map {|parsing_argument|
+              Builder.new(components: parsing_argument.components).node
+            },
+            component.name
+          )
+        when Parsing::DotWord
+          AST::Function.new(
+            [node_of_component(component.target)],
+            component.name
+          )
+        when Parsing::DotOperator
+          AST::Function.new(
+            [node_of_component(component.target)] + component.arguments.map {|parsing_argument|
+              Builder.new(components: parsing_argument.components).node
+            },
+            component.name
+          )
+        else
+          raise Exceptions::ASTError.new("Unhandled component, #{component}")
+        end
+      end
+
+      def consume_operators!
+        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)
+        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
+
+        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
+  end
+end