keisan 0.2.1 → 0.3.0

data/lib/keisan/ast/logical_equal.rb

@@ -0,0 +1,18 @@
+module Keisan
+  module AST
+    class LogicalEqual < LogicalOperator
+      def arity
+        2..2
+      end
+
+      def self.symbol
+        :"=="
+      end
+
+      def value(context=nil)
+        context ||= Context.new
+        children[0].value(context) == children[1].value(context)
+      end
+    end
+  end
+end

data/lib/keisan/ast/logical_greater_than.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalGreaterThan < LogicalOperator
-      def self.priority
-        82
-      end
-
       def arity
         2..2
       end
 
+      def self.symbol
+        :">"
+      end
+
       def value(context = nil)
         children.first.value(context) > children.last.value(context)
       end

data/lib/keisan/ast/logical_greater_than_or_equal_to.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalGreaterThanOrEqualTo < LogicalOperator
-      def self.priority
-        62
-      end
-
       def arity
         2..2
       end
 
+      def self.symbol
+        :">="
+      end
+
       def value(context = nil)
         children.first.value(context) >= children.last.value(context)
       end

data/lib/keisan/ast/logical_less_than.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalLessThan < LogicalOperator
-      def self.priority
-        72
-      end
-
       def arity
         2..2
       end
 
+      def self.symbol
+        :"<"
+      end
+
       def value(context = nil)
         children.first.value(context) < children.last.value(context)
       end

data/lib/keisan/ast/logical_less_than_or_equal_to.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalLessThanOrEqualTo < LogicalOperator
-      def self.priority
-        52
-      end
-
       def arity
         2..2
       end
 
+      def self.symbol
+        :"<="
+      end
+
       def value(context = nil)
         children.first.value(context) <= children.last.value(context)
       end

data/lib/keisan/ast/logical_not_equal.rb

@@ -0,0 +1,18 @@
+module Keisan
+  module AST
+    class LogicalNotEqual < LogicalOperator
+      def arity
+        2..2
+      end
+
+      def self.symbol
+        :"!="
+      end
+
+      def value(context=nil)
+        context ||= Context.new
+        children[0].value(context) != children[1].value(context)
+      end
+    end
+  end
+end

data/lib/keisan/ast/logical_or.rb

@@ -1,15 +1,11 @@
 module Keisan
   module AST
     class LogicalOr < LogicalOperator
-      def self.priority
-        12
-      end
-
       def arity
         2..Float::INFINITY
       end
 
-      def symbol
+      def self.symbol
         :"|"
       end
 

data/lib/keisan/ast/modulo.rb

@@ -0,0 +1,18 @@
+module Keisan
+  module AST
+    class Modulo < ArithmeticOperator
+      def arity
+        2..Float::INFINITY
+      end
+
+      def self.symbol
+        :%
+      end
+
+      def value(context = nil)
+        children_values = children.map {|child| child.value(context)}
+        children_values[1..-1].inject(children_values[0], &:%)
+      end
+    end
+  end
+end

data/lib/keisan/ast/node.rb

@@ -4,6 +4,32 @@ module Keisan
       def value(context = nil)
         raise Keisan::Exceptions::NotImplementedError.new
       end
+
+      def unbound_variables(context = nil)
+        context ||= Keisan::Context.new
+
+        case self
+        when Parent
+          children.inject(Set.new) do |vars, child|
+            vars | child.unbound_variables(context)
+          end
+        else
+          Set.new
+        end
+      end
+
+      def unbound_functions(context = nil)
+        context ||= Keisan::Context.new
+
+        case self
+        when Parent
+          children.inject(Set.new) do |fns, child|
+            fns | child.unbound_functions(context)
+          end
+        else
+          Set.new
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/operator.rb

@@ -16,17 +16,24 @@ module Keisan
         @parsing_operators = parsing_operators
       end
 
-
       def arity
         raise Keisan::Exceptions::NotImplementedError.new
       end
 
+      def priority
+        self.class.priority
+      end
+
+      def self.priority
+        Keisan::AST::Priorities.priorities[symbol]
+      end
+
       def associativity
         raise Keisan::Exceptions::NotImplementedError.new
       end
 
       def symbol
-        raise Keisan::Exceptions::NotImplementedError.new
+        self.class.symbol
       end
 
       def blank_value

data/lib/keisan/ast/plus.rb

@@ -6,15 +6,11 @@ module Keisan
         convert_minus_to_plus!
       end
 
-      def self.priority
-        10
-      end
-
       def arity
         2..Float::INFINITY
       end
 
-      def symbol
+      def self.symbol
         :+
       end
 

data/lib/keisan/ast/priorities.rb

@@ -0,0 +1,27 @@
+module Keisan
+  module AST
+    class Priorities
+      PRIORITIES = {
+        "**": 100,
+        "*": 95,
+        "%": 90,
+        "+": 85,
+        "&": 80,
+        "|": 75,
+        "^": 70,
+        ">": 65,
+        ">=": 60,
+        "<": 55,
+        "<=": 50,
+        "==": 45,
+        "!=": 40,
+        "&&": 35,
+        "||": 30
+      }.freeze
+
+      def self.priorities
+        PRIORITIES
+      end
+    end
+  end
+end

data/lib/keisan/ast/times.rb

@@ -6,15 +6,11 @@ module Keisan
         convert_divide_to_inverse!
       end
 
-      def self.priority
-        20
-      end
-
       def arity
         2..Float::INFINITY
       end
 
-      def symbol
+      def self.symbol
         :*
       end
 

data/lib/keisan/ast/variable.rb

@@ -11,6 +11,11 @@ module Keisan
         context = Keisan::Context.new if context.nil?
         context.variable(name)
       end
+
+      def unbound_variables(context = nil)
+        context ||= Keisan::Context.new
+        context.has_variable?(name) ? Set.new : Set.new([name])
+      end
     end
   end
 end

data/lib/keisan/calculator.rb

@@ -7,18 +7,7 @@ module Keisan
     end
 
     def evaluate(expression, definitions = {})
-      context.spawn_child do |local|
-        definitions.each do |name, value|
-          case value
-          when Proc
-            local.register_function!(name, value)
-          else
-            local.register_variable!(name, value)
-          end
-        end
-
-        Keisan::AST::Builder.new(string: expression).ast.value(local)
-      end
+      Evaluator.new(self).evaluate(expression, definitions)
     end
 
     def define_variable!(name, value)

data/lib/keisan/context.rb

@@ -9,18 +9,29 @@ module Keisan
       @random            = random
     end
 
-    def spawn_child
-      if block_given?
-        yield self.class.new(parent: self)
-      else
-        self.class.new(parent: self)
+    def spawn_child(definitions = {})
+      child = self.class.new(parent: self)
+
+      definitions.each do |name, value|
+        case value
+        when Proc
+          child.register_function!(name, value)
+        else
+          child.register_variable!(name, value)
+        end
       end
+
+      child
     end
 
     def function(name)
       @function_registry[name.to_s]
     end
 
+    def has_function?(name)
+      @function_registry.has?(name)
+    end
+
     def register_function!(name, function)
       @function_registry.register!(name.to_s, function)
     end
@@ -29,6 +40,10 @@ module Keisan
       @variable_registry[name.to_s]
     end
 
+    def has_variable?(name)
+      @variable_registry.has?(name)
+    end
+
     def register_variable!(name, value)
       @variable_registry.register!(name.to_s, value)
     end

data/lib/keisan/evaluator.rb

@@ -0,0 +1,79 @@
+module Keisan
+  class Evaluator
+    WORD = /[a-zA-Z_]\w*/
+    VARIABLE_DEFINITION = /\A\s*(#{WORD})\s*=\s*(.+)\z/
+    FUNCTION_DEFINITION = /\A\s*(#{WORD})\s*\(((?:\s*#{WORD}\s*)(?:,\s*#{WORD}\s*)*)\)\s*=\s*(.+)\z/
+
+    attr_reader :calculator
+
+    def initialize(calculator)
+      @calculator = calculator
+    end
+
+    def evaluate(expression, definitions = {})
+      case expression
+      when VARIABLE_DEFINITION
+        variable_evaluate(expression, definitions)
+      when FUNCTION_DEFINITION
+        function_evaluate(expression, definitions)
+      else
+        pure_evaluate(expression, definitions)
+      end
+    end
+
+    private
+
+    def variable_evaluate(expression, definitions = {})
+      match = expression.match VARIABLE_DEFINITION
+      name = match[1]
+      expression = match[2]
+      ast = Keisan::AST::Builder.new(string: expression).ast
+
+      context = calculator.context.spawn_child(definitions)
+      unbound_variables = ast.unbound_variables(context)
+      unless unbound_variables <= Set.new([name])
+        raise Keisan::Exceptions::InvalidExpression.new("Unbound variables found in variable definition")
+      end
+
+      calculator.context.register_variable!(name, ast.value(context))
+    end
+
+    def function_evaluate(expression, definitions = {})
+      match = expression.match FUNCTION_DEFINITION
+      name = match[1]
+      args = match[2].split(",").map(&:strip)
+      expression = match[3]
+      ast = Keisan::AST::Builder.new(string: expression).ast
+
+      context = calculator.context.spawn_child(definitions)
+      unbound_variables = ast.unbound_variables(context)
+      unbound_functions = ast.unbound_functions(context)
+      # Ensure the variables are contained within the arguments
+      unless unbound_variables <= Set.new(args) && unbound_functions <= Set.new([name])
+        raise Keisan::Exceptions::InvalidExpression.new("Unbound variables found in function definition")
+      end
+
+      function = lambda do |*received_args|
+        unless args.count == received_args.count
+          raise Keisan::Exceptions::InvalidFunctionError.new("Invalid number of arguments for #{name} function")
+        end
+
+        local = calculator.context.spawn_child(definitions)
+        args.each.with_index do |arg, i|
+          local.register_variable!(arg, received_args[i])
+        end
+
+        ast.value(local)
+      end
+
+      calculator.context.register_function!(
+        name,
+        Keisan::Function.new(name, function)
+      )
+    end
+
+    def pure_evaluate(expression, definitions = {})
+      Keisan::AST::Builder.new(string: expression).ast.value(calculator.context.spawn_child(definitions))
+    end
+  end
+end

data/lib/keisan/exceptions.rb

@@ -15,5 +15,6 @@ module Keisan
     class UndefinedFunctionError < StandardError; end
     class UndefinedVariableError < StandardError; end
     class UnmodifiableError < StandardError; end
+    class InvalidExpression < StandardError; end
   end
 end