keisan 0.3.0 → 0.4.0

data/lib/keisan/ast/unary_bitwise_not.rb

@@ -2,7 +2,15 @@ module Keisan
   module AST
     class UnaryBitwiseNot < UnaryOperator
       def value(context = nil)
-        return ~children.first.value(context)
+        return ~child.value(context)
+      end
+
+      def evaluate(context = nil)
+        ~child.evaluate(context)
+      end
+
+      def self.symbol
+        :"~"
       end
     end
   end

data/lib/keisan/ast/unary_identity.rb

@@ -2,7 +2,24 @@ module Keisan
   module AST
     class UnaryIdentity < UnaryOperator
       def value(context = nil)
-        return children.first.value(context)
+        return child.value(context)
+      end
+
+      def evaluate(context = nil)
+        child.evaluate(context)
+      end
+
+      def self.symbol
+        nil
+      end
+
+      def simplify(context = nil)
+        child.simplify(context)
+      end
+
+      def differentiate(variable, context = nil)
+        context ||= Context.new
+        child.differentiate(variable, context).simplify(context)
       end
     end
   end

data/lib/keisan/ast/unary_inverse.rb

@@ -2,7 +2,41 @@ module Keisan
   module AST
     class UnaryInverse < UnaryOperator
       def value(context = nil)
-        return Rational(1, children.first.value(context))
+        return Rational(1, child.value(context))
+      end
+
+      def to_s
+        "(#{child.to_s})**(-1)"
+      end
+
+      def evaluate(context = nil)
+        1.to_node / child.evaluate(context)
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+
+        @children = [child.simplify(context)]
+        case child
+        when AST::Number
+          AST::Number.new(Rational(1,child.value(context))).simplify(context)
+        else
+          (child ** -1).simplify(context)
+        end
+      end
+
+      def differentiate(variable, context = nil)
+        context ||= Context.new
+        AST::Times.new(
+          [
+            AST::UnaryMinus.new(child.differentiate(variable, context)),
+            AST::UnaryInverse.new(
+              AST::Exponent.new([
+                child.deep_dup, AST::Number.new(2)
+              ])
+            )
+          ]
+        ).simplify(context)
       end
     end
   end

data/lib/keisan/ast/unary_logical_not.rb

@@ -2,7 +2,11 @@ module Keisan
   module AST
     class UnaryLogicalNot < UnaryOperator
       def value(context = nil)
-        return !children.first.value(context)
+        return !child.value(context)
+      end
+
+      def self.symbol
+        :"!"
       end
     end
   end

data/lib/keisan/ast/unary_minus.rb

@@ -2,7 +2,37 @@ module Keisan
   module AST
     class UnaryMinus < UnaryOperator
       def value(context = nil)
-        return -1 * children.first.value(context)
+        return -1 * child.value(context)
+      end
+
+      def evaluate(context = nil)
+        -child.evaluate(context)
+      end
+
+      def self.symbol
+        :"-"
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+
+        case child
+        when AST::Number
+          AST::Number.new(-child.value(context)).simplify(context)
+        else
+          AST::Times.new([
+            AST::Number.new(-1),
+            child
+          ]).simplify(context)
+        end
+      end
+
+      def differentiate(variable, context = nil)
+        context ||= Context.new
+        AST::Times.new([
+          -1.to_node,
+          child.differentiate(variable, context)
+        ]).simplify(context)
       end
     end
   end

data/lib/keisan/ast/unary_operator.rb

@@ -1,6 +1,6 @@
 module Keisan
   module AST
-    class UnaryOperator < Parent
+    class UnaryOperator < Operator
       def initialize(children = [])
         children = Array.wrap(children)
         super
@@ -8,6 +8,34 @@ module Keisan
           raise Keisan::Exceptions::ASTError.new("Unary operator takes has a single child")
         end
       end
+
+      def child
+        children.first
+      end
+
+      def self.arity
+        ARITIES[:"u#{symbol}"]
+      end
+
+      def self.priority
+        PRIORITIES[:"u#{symbol}"]
+      end
+
+      def self.associativity
+        ASSOCIATIVITIES[:"u#{symbol}"]
+      end
+
+      def to_s
+        if child.is_a?(AST::Operator)
+          "#{symbol.to_s}(#{child.to_s})"
+        else
+          "#{symbol.to_s}#{child.to_s}"
+        end
+      end
+
+      def simplify(context = nil)
+        self
+      end
     end
   end
 end

data/lib/keisan/ast/unary_plus.rb

@@ -1,9 +1,22 @@
 module Keisan
   module AST
-    class UnaryPlus < UnaryOperator
+    class UnaryPlus < UnaryIdentity
       def value(context = nil)
         return children.first.value(context)
       end
+
+      def self.symbol
+        :"+"
+      end
+
+      def simplify(context = nil)
+        case child
+        when AST::Number
+          AST::Number.new(child.value(context)).simplify(context)
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/variable.rb

@@ -16,6 +16,50 @@ module Keisan
         context ||= Keisan::Context.new
         context.has_variable?(name) ? Set.new : Set.new([name])
       end
+
+      def ==(other)
+        name == other.name
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      def evaluate(context = nil)
+        context ||= Keisan::Context.new
+        if context.has_variable?(name)
+          context.variable(name).to_node.evaluate(context)
+        else
+          self
+        end
+      end
+
+      def simplify(context = nil)
+        context ||= Keisan::Context.new
+        if context.has_variable?(name)
+          context.variable(name).to_node.simplify(context)
+        else
+          self
+        end
+      end
+
+      def replace(variable, replacement)
+        if name == variable.name
+          replacement
+        else
+          self
+        end
+      end
+
+      def differentiate(variable, context = nil)
+        context ||= Keisan::Context.new
+
+        if name == variable.name && !context.has_variable?(name)
+          1.to_node
+        else
+          0.to_node
+        end
+      end
     end
   end
 end

data/lib/keisan/calculator.rb

@@ -2,8 +2,8 @@ module Keisan
   class Calculator
     attr_reader :context
 
-    def initialize(context = nil)
-      @context = context || Context.new
+    def initialize(context: nil, allow_recursive: false)
+      @context = context || Context.new(allow_recursive: allow_recursive)
     end
 
     def evaluate(expression, definitions = {})

data/lib/keisan/context.rb

@@ -1,16 +1,17 @@
 module Keisan
   class Context
-    attr_reader :function_registry, :variable_registry
+    attr_reader :function_registry, :variable_registry, :allow_recursive
 
-    def initialize(parent: nil, random: nil)
+    def initialize(parent: nil, random: nil, allow_recursive: false)
       @parent = parent
       @function_registry = Functions::Registry.new(parent: @parent.try(:function_registry))
       @variable_registry = Variables::Registry.new(parent: @parent.try(:variable_registry))
       @random            = random
+      @allow_recursive   = allow_recursive
     end
 
-    def spawn_child(definitions = {})
-      child = self.class.new(parent: self)
+    def spawn_child(definitions: {}, transient: false)
+      child = Context.new(parent: self, allow_recursive: allow_recursive)
 
       definitions.each do |name, value|
         case value
@@ -21,35 +22,50 @@ module Keisan
         end
       end
 
+      child.set_transient! if transient
       child
     end
 
-    def function(name)
-      @function_registry[name.to_s]
+    def variable(name)
+      @variable_registry[name.to_s]
     end
 
-    def has_function?(name)
-      @function_registry.has?(name)
+    def has_variable?(name)
+      @variable_registry.has?(name)
     end
 
-    def register_function!(name, function)
-      @function_registry.register!(name.to_s, function)
+    def register_variable!(name, value)
+      if @transient
+        @parent.register_variable!(name, value)
+      else
+        @variable_registry.register!(name.to_s, value)
+      end
     end
 
-    def variable(name)
-      @variable_registry[name.to_s]
+    def function(name)
+      @function_registry[name.to_s]
     end
 
-    def has_variable?(name)
-      @variable_registry.has?(name)
+    def has_function?(name)
+      @function_registry.has?(name)
     end
 
-    def register_variable!(name, value)
-      @variable_registry.register!(name.to_s, value)
+    def register_function!(name, function)
+      if @transient
+        @parent.register_function!(name, function)
+      else
+        @function_registry.register!(name.to_s, function)
+      end
     end
 
     def random
       @random || @parent.try(:random) || Random.new
     end
+
+    protected
+
+    def set_transient!
+      @transient = true
+    end
   end
 end

data/lib/keisan/evaluator.rb

@@ -1,9 +1,5 @@
 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)
@@ -11,69 +7,18 @@ module Keisan
     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])
+      context = calculator.context.spawn_child(definitions: definitions, transient: true)
+      ast = Keisan::AST.parse(expression)
+      evaluation = ast.evaluate(context)
+
+      case ast
+      when Keisan::AST::Assignment
+        if ast.children.first.is_a?(Keisan::AST::Variable)
+          context.variable(ast.children.first.name)
         end
-
-        ast.value(local)
+      else
+        evaluation.value(context)
       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

@@ -16,5 +16,7 @@ module Keisan
     class UndefinedVariableError < StandardError; end
     class UnmodifiableError < StandardError; end
     class InvalidExpression < StandardError; end
+    class TypeError < StandardError; end
+    class NonDifferentiableError < StandardError; end
   end
 end