keisan 0.3.0 → 0.4.0

data/lib/keisan/function.rb

@@ -2,14 +2,20 @@ module Keisan
   class Function
     attr_reader :name
 
-    def initialize(name, function_proc)
-      raise Keisan::Exceptions::InvalidFunctionError.new unless function_proc.is_a?(Proc)
+    def initialize(name)
       @name = name
-      @function_proc = function_proc
     end
 
-    def call(context, *args)
-      @function_proc.call(*args)
+    def value(ast_function, context = nil)
+      raise Keisan::Exceptions::NotImplementedError.new
+    end
+
+    def evaluate(ast_function, context = nil)
+      raise Keisan::Exceptions::NotImplementedError.new
+    end
+
+    def simplify(ast_function, context = nil)
+      raise Keisan::Exceptions::NotImplementedError.new
     end
   end
 end

data/lib/keisan/function_definition_context.rb

@@ -0,0 +1,34 @@
+module Keisan
+  class FunctionDefinitionContext < Context
+    def initialize(parent:, arguments:)
+      super(parent: parent)
+      @arguments = Set.new(arguments)
+      @arguments_context = Context.new
+      set_transient!
+    end
+
+    def variable(name)
+      if @arguments.member?(name)
+        @arguments_context.variable(name)
+      else
+        super
+      end
+    end
+
+    def has_variable?(name)
+      if @arguments.member?(name)
+        @arguments_context.has_variable?(name)
+      else
+        super
+      end
+    end
+
+    def register_variable!(name, value)
+      if @arguments.member?(name)
+        @arguments_context.register_variable!(name, value)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/keisan/functions/default_registry.rb

@@ -1,3 +1,6 @@
+require_relative "if"
+require_relative "diff"
+require_relative "replace"
 require_relative "rand"
 require_relative "sample"
 
@@ -13,6 +16,10 @@ module Keisan
       private
 
       def self.register_defaults!(registry)
+        registry.register!(:if, Keisan::Functions::If.new, force: true)
+        registry.register!(:diff, Keisan::Functions::Diff.new, force: true)
+        registry.register!(:replace, Keisan::Functions::Replace.new, force: true)
+
         register_builtin_math!(registry)
         register_array_methods!(registry)
         register_random_methods!(registry)
@@ -22,22 +29,23 @@ module Keisan
         Math.methods(false).each do |method|
           registry.register!(
             method,
-            Proc.new do |*args|
+            Proc.new {|*args|
               Math.send(method, *args)
-            end
+            },
+            force: true
           )
         end
       end
 
       def self.register_array_methods!(registry)
         %i(min max size).each do |method|
-          registry.register!(method, Proc.new {|a| a.send(method)})
+          registry.register!(method, Proc.new {|a| a.send(method)}, force: true)
         end
       end
 
       def self.register_random_methods!(registry)
-        registry.register!(:rand, Keisan::Functions::Rand.new)
-        registry.register!(:sample, Keisan::Functions::Sample.new)
+        registry.register!(:rand, Keisan::Functions::Rand.new, force: true)
+        registry.register!(:sample, Keisan::Functions::Sample.new, force: true)
       end
     end
   end

data/lib/keisan/functions/diff.rb

@@ -0,0 +1,82 @@
+module Keisan
+  module Functions
+    class Diff < Keisan::Function
+      def initialize
+        @name = "diff"
+      end
+
+      def value(ast_function, context = nil)
+        context ||= Keisan::Context.new
+        evaluation = evaluate(ast_function, context)
+
+        if is_ast_derivative?(evaluation)
+          raise Keisan::Exceptions::NonDifferentiableError.new
+        else
+          evaluation.value(context)
+        end
+      end
+
+      def evaluate(ast_function, context = nil)
+        context ||= Context.new
+        function, vars = function_and_vars(ast_function)
+
+        vars.inject(function.evaluate(context)) do |result, variable|
+          result = differentiate(result, variable, context)
+          if !is_ast_derivative?(result)
+            result = result.evaluate(context)
+          end
+          result
+        end
+      end
+
+      def simplify(ast_function, context = nil)
+        context ||= Context.new
+        function, vars = function_and_vars(ast_function)
+
+        vars.inject(function.simplify(context)) do |result, variable|
+          result = differentiate(result, variable, context)
+          if !is_ast_derivative?(result)
+            result = result.simplify(context)
+          end
+          result
+        end
+      end
+
+      private
+
+      def is_ast_derivative?(node)
+        node.is_a?(Keisan::AST::Function) && node.name == name
+      end
+
+      def differentiate(node, variable, context)
+        if node.unbound_variables(context).include?(variable.name)
+          node.differentiate(variable, context)
+        else
+          return AST::Number.new(0)
+        end
+      rescue Keisan::Exceptions::NonDifferentiableError => e
+        return AST::Function.new(
+          [node, variable],
+          "diff"
+        )
+      end
+
+      def function_and_vars(ast_function)
+        unless ast_function.is_a?(Keisan::AST::Function) && ast_function.name == name
+          raise Keisan::Exceptions::InvalidFunctionError.new("Must receive diff function")
+        end
+
+        vars = ast_function.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
+
+        [
+          ast_function.children.first,
+          vars
+        ]
+      end
+    end
+  end
+end

data/lib/keisan/functions/expression_function.rb

@@ -0,0 +1,63 @@
+module Keisan
+  module Functions
+    class ExpressionFunction < Keisan::Function
+      attr_reader :arguments, :expression
+
+      def initialize(name, arguments, expression, local_context)
+        super(name)
+        @expression = expression.deep_dup
+        @arguments = arguments
+        @local_context = local_context
+      end
+
+      def call(context, *args)
+        unless @arguments.count == args.count
+          raise Keisan::Exceptions::InvalidFunctionError.new("Invalid number of arguments for #{name} function")
+        end
+
+        local = @local_context.spawn_child
+        arguments.each.with_index do |arg_name, i|
+          local.register_variable!(arg_name, args[i])
+        end
+
+        expression.value(local)
+      end
+
+      def value(ast_function, context = nil)
+        context ||= Keisan::Context.new
+        argument_values = ast_function.children.map {|child| child.value(context)}
+        call(context, *argument_values)
+      end
+
+      def evaluate(ast_function, context = nil)
+        context ||= Keisan::Context.new
+
+        ast_function.instance_variable_set(
+          :@children,
+          ast_function.children.map {|child| child.evaluate(context)}
+        )
+
+        if ast_function.children.all? {|child| child.well_defined?(context)}
+          value(ast_function, context).to_node.evaluate(context)
+        else
+          ast_function
+        end
+      end
+
+      def simplify(ast_function, context = nil)
+        context ||= Context.new
+
+        ast_function.instance_variable_set(
+          :@children,
+          ast_function.children.map {|child| child.evaluate(context)}
+        )
+
+        if ast_function.children.all? {|child| child.is_a?(Keisan::AST::ConstantLiteral)}
+          value(ast_function, context).to_node.simplify(context)
+        else
+          ast_function
+        end
+      end
+    end
+  end
+end

data/lib/keisan/functions/if.rb

@@ -0,0 +1,62 @@
+module Keisan
+  module Functions
+    class If < Keisan::Function
+      def initialize
+        @name = "if"
+      end
+
+      def value(ast_function, context = nil)
+        context ||= Keisan::Context.new
+
+        unless (2..3).cover? ast_function.children.size
+          raise Keisan::Exceptions::InvalidFunctionError.new("Require 2 or 3 arguments to if")
+        end
+
+        bool = ast_function.children[0].value(context)
+
+        if bool
+          ast_function.children[1].value(context)
+        else
+          ast_function.children.size == 3 ? ast_function.children[2].value(context) : nil
+        end
+      end
+
+      def evaluate(ast_function, context = nil)
+        context ||= Keisan::Context.new
+
+        bool = ast_function.children[0].evaluate(context)
+
+        if bool.is_a?(Keisan::AST::Boolean)
+          if bool.value
+            ast_function.children[1].evaluate(context)
+          else
+            ast_function.children[2].to_node.evaluate(context)
+          end
+        else
+          ast_function
+        end
+
+        if ast_function.children.all? {|child| child.well_defined?(context)}
+          value(ast_function, context).to_node.evaluate(context)
+        else
+          ast_function
+        end
+      end
+
+      def simplify(ast_function, context = nil)
+        context ||= Context.new
+        bool = ast_function.children[0].simplify(context)
+
+        if bool.is_a?(Keisan::AST::Boolean)
+          if bool.value
+            ast_function.children[1].simplify(context)
+          else
+            ast_function.children[2].to_node.simplify(context)
+          end
+        else
+          ast_function
+        end
+      end
+    end
+  end
+end

data/lib/keisan/functions/proc_function.rb

@@ -0,0 +1,52 @@
+module Keisan
+  module Functions
+    class ProcFunction < Keisan::Function
+      def initialize(name, function_proc)
+        raise Keisan::Exceptions::InvalidFunctionError.new unless function_proc.is_a?(Proc)
+
+        super(name)
+        @function_proc = function_proc
+      end
+
+      def call(context, *args)
+        @function_proc.call(*args)
+      end
+
+      def value(ast_function, context = nil)
+        context ||= Keisan::Context.new
+        argument_values = ast_function.children.map {|child| child.value(context)}
+        call(context, *argument_values)
+      end
+
+      def evaluate(ast_function, context = nil)
+        context ||= Keisan::Context.new
+
+        ast_function.instance_variable_set(
+          :@children,
+          ast_function.children.map {|child| child.evaluate(context)}
+        )
+
+        if ast_function.children.all? {|child| child.well_defined?(context)}
+          value(ast_function, context).to_node.evaluate(context)
+        else
+          ast_function
+        end
+      end
+
+      def simplify(ast_function, context = nil)
+        context ||= Context.new
+
+        ast_function.instance_variable_set(
+          :@children,
+          ast_function.children.map {|child| child.evaluate(context)}
+        )
+
+        if ast_function.children.all? {|child| child.is_a?(Keisan::AST::ConstantLiteral)}
+          value(ast_function, context).to_node.simplify(context)
+        else
+          ast_function
+        end
+      end
+    end
+  end
+end

data/lib/keisan/functions/rand.rb

@@ -1,6 +1,6 @@
 module Keisan
   module Functions
-    class Rand < Keisan::Function
+    class Rand < ProcFunction
       def initialize
         @name = "rand"
       end

data/lib/keisan/functions/registry.rb

@@ -1,19 +1,23 @@
 module Keisan
   module Functions
     class Registry
-      def initialize(functions: {}, parent: nil, use_defaults: true)
+      def initialize(functions: {}, parent: nil, use_defaults: true, force: false)
         @hash = {}
         @parent = parent
         @use_defaults = use_defaults
 
         functions.each do |name, function|
-          register!(name, function)
+          register!(name, function, force: force)
         end
       end
 
       def [](name)
         return @hash[name] if @hash.has_key?(name)
-        return @parent[name] if !@parent.nil? && @parent.has_name?(name)
+
+        if @parent && (parent_value = @parent[name])
+          return parent_value
+        end
+
         return default_registry[name] if @use_defaults && default_registry.has_name?(name)
         raise Keisan::Exceptions::UndefinedFunctionError.new name
       end
@@ -24,18 +28,17 @@ module Keisan
         false
       end
 
-      # For checking if locally defined
-      def has_name?(name)
-        @hash.has_key?(name)
-      end
-
-      def register!(name, function)
+      def register!(name, function, force: false)
         raise Keisan::Exceptions::UnmodifiableError.new("Cannot modify frozen functions registry") if frozen?
         name = name.to_s
 
+        if !force && @use_defaults && default_registry.has_name?(name)
+          raise Keisan::Exceptions::UnmodifiableError.new("Cannot overwrite default function")
+        end
+
         case function
         when Proc
-          self[name] = Keisan::Function.new(name, function)
+          self[name] = Keisan::Functions::ProcFunction.new(name, function)
         when Keisan::Function
           self[function.name] = function
         else
@@ -43,6 +46,13 @@ module Keisan
         end
       end
 
+      protected
+
+      # For checking if locally defined
+      def has_name?(name)
+        @hash.has_key?(name)
+      end
+
       private
 
       def []=(name, function)

data/lib/keisan/functions/replace.rb

@@ -0,0 +1,49 @@
+module Keisan
+  module Functions
+    class Replace < Keisan::Function
+      def initialize
+        @name = "replace"
+      end
+
+      def value(ast_function, context = nil)
+        context ||= Keisan::Context.new
+        evaluate(ast_function, context).value(context)
+      end
+
+      def evaluate(ast_function, context = nil)
+        context ||= Keisan::Context.new
+        expression, variable, replacement = expression_variable_replacement(ast_function)
+
+        expression = expression.evaluate(context)
+        replacement = replacement.evaluate(context)
+
+        expression.replace(variable, replacement).evaluate(context)
+      end
+
+      def simplify(ast_function, context = nil)
+        context ||= Context.new
+        evaluate(ast_function, context).simplify(context)
+      end
+
+      private
+
+      def expression_variable_replacement(ast_function)
+        unless ast_function.is_a?(Keisan::AST::Function) && ast_function.name == name
+          raise Keisan::Exceptions::InvalidFunctionError.new("Must receive replace function")
+        end
+
+        unless ast_function.children.size == 3
+          raise Keisan::Exceptions::InvalidFunctionError.new("Require 3 arguments to replace")
+        end
+
+        expression, variable, replacement = *ast_function.children.map(&:deep_dup)
+
+        unless variable.is_a?(Keisan::AST::Variable)
+          raise Keisan::Exceptions::InvalidFunctionError.new("Replace must replace a variable")
+        end
+
+        [expression, variable, replacement]
+      end
+    end
+  end
+end