keisan 0.4.0 → 0.5.0

data/lib/keisan/functions/csch.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Csch < CMathFunction
+      def initialize
+        super("csch", Proc.new {|arg| 1 / CMath::sinh(arg)})
+      end
+
+      protected
+
+      def self.derivative(argument)
+        -Keisan::AST::Function.new([argument], "cosh") * Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "sinh"), -2])
+      end
+    end
+  end
+end

data/lib/keisan/functions/default_registry.rb

@@ -1,8 +1,32 @@
 require_relative "if"
 require_relative "diff"
 require_relative "replace"
+require_relative "map"
+require_relative "filter"
+require_relative "reduce"
 require_relative "rand"
 require_relative "sample"
+require_relative "math_function"
+require_relative "cmath_function"
+require_relative "exp"
+require_relative "log"
+require_relative "sin"
+require_relative "cos"
+require_relative "sec"
+require_relative "tan"
+require_relative "cot"
+require_relative "csc"
+require_relative "sinh"
+require_relative "cosh"
+require_relative "sech"
+require_relative "tanh"
+require_relative "coth"
+require_relative "csch"
+require_relative "sqrt"
+require_relative "cbrt"
+require_relative "abs"
+require_relative "real"
+require_relative "imag"
 
 module Keisan
   module Functions
@@ -19,10 +43,40 @@ module Keisan
         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)
+        registry.register!(:map, Keisan::Functions::Map.new, force: true)
+        registry.register!(:collect, Keisan::Functions::Map.new, force: true)
+        registry.register!(:filter, Keisan::Functions::Filter.new, force: true)
+        registry.register!(:select, Keisan::Functions::Filter.new, force: true)
+        registry.register!(:reduce, Keisan::Functions::Reduce.new, force: true)
+        registry.register!(:inject, Keisan::Functions::Reduce.new, force: true)
 
         register_builtin_math!(registry)
         register_array_methods!(registry)
         register_random_methods!(registry)
+
+        registry.register!(:exp, Keisan::Functions::Exp.new, force: true)
+        registry.register!(:log, Keisan::Functions::Log.new, force: true)
+
+        registry.register!(:sin, Keisan::Functions::Sin.new, force: true)
+        registry.register!(:cos, Keisan::Functions::Cos.new, force: true)
+        registry.register!(:tan, Keisan::Functions::Tan.new, force: true)
+        registry.register!(:cot, Keisan::Functions::Cot.new, force: true)
+        registry.register!(:sec, Keisan::Functions::Sec.new, force: true)
+        registry.register!(:csc, Keisan::Functions::Csc.new, force: true)
+
+        registry.register!(:sinh, Keisan::Functions::Sinh.new, force: true)
+        registry.register!(:cosh, Keisan::Functions::Cosh.new, force: true)
+        registry.register!(:tanh, Keisan::Functions::Tanh.new, force: true)
+        registry.register!(:coth, Keisan::Functions::Coth.new, force: true)
+        registry.register!(:sech, Keisan::Functions::Sech.new, force: true)
+        registry.register!(:csch, Keisan::Functions::Csch.new, force: true)
+
+        registry.register!(:sqrt, Keisan::Functions::Sqrt.new, force: true)
+        registry.register!(:cbrt, Keisan::Functions::Cbrt.new, force: true)
+
+        registry.register!(:abs, Keisan::Functions::Abs.new, force: true)
+        registry.register!(:real, Keisan::Functions::Real.new, force: true)
+        registry.register!(:imag, Keisan::Functions::Imag.new, force: true)
       end
 
       def self.register_builtin_math!(registry)
@@ -30,6 +84,7 @@ module Keisan
           registry.register!(
             method,
             Proc.new {|*args|
+              args = args.map(&:value)
               Math.send(method, *args)
             },
             force: true
@@ -38,9 +93,48 @@ module Keisan
       end
 
       def self.register_array_methods!(registry)
-        %i(min max size).each do |method|
+        %i(min max size flatten reverse).each do |method|
           registry.register!(method, Proc.new {|a| a.send(method)}, force: true)
         end
+
+        # range(10) => Integers from 0 inclusive to 10 exclusively
+        # range(5, 15) => Integers from 5 inclusive to 15 exclusive
+        # range(10, -1, -2) => Integers from 10 inclusive to -1 exclusive, decreasing by twos
+        #   i.e.:  [10, 8, 6, 4, 2, 0]
+        registry.register!("range", Proc.new {|*args|
+          case args.count
+          when 1
+            (0...args[0]).to_a
+          when 2
+            (args[0]...args[1]).to_a
+          when 3
+            current = args[0]
+            final = args[1]
+            shift = args[2]
+
+            if shift == 0 or !shift.is_a?(Integer)
+              raise Keisan::Exceptions::InvalidFunctionError.new("range's 3rd argument must be non-zero integer")
+            end
+
+            result = []
+
+            if shift > 0
+              while current < final
+                result << current
+                current += shift
+              end
+            else
+              while current > final
+                result << current
+                current += shift
+              end
+            end
+
+            result
+          else
+            raise Keisan::Exceptions::InvalidFunctionError.new("range takes 1 to 3 arguments")
+          end
+        }, force: true)
       end
 
       def self.register_random_methods!(registry)

data/lib/keisan/functions/diff.rb

@@ -17,29 +17,46 @@ module Keisan
       end
 
       def evaluate(ast_function, context = nil)
-        context ||= Context.new
-        function, vars = function_and_vars(ast_function)
+        context ||= Keisan::Context.new
+        function, variables = function_and_variables(ast_function)
+        local = context_from(variables, context)
 
-        vars.inject(function.evaluate(context)) do |result, variable|
-          result = differentiate(result, variable, context)
+        result = variables.inject(function.evaluate(local)) do |result, variable|
+          result = differentiate(result, variable, local)
           if !is_ast_derivative?(result)
-            result = result.evaluate(context)
+            result = result.evaluate(local)
           end
           result
         end
+
+        case result
+        when Keisan::AST::Function
+          result.name == "diff" ? result : result.simplify(context)
+        else
+          result.simplify(context)
+        end
       end
 
       def simplify(ast_function, context = nil)
-        context ||= Context.new
-        function, vars = function_and_vars(ast_function)
+        raise Keisan::Exceptions::InternalError.new("received non-diff function") unless ast_function.name == "diff"
+        function, variables = function_and_variables(ast_function)
+        context ||= Keisan::Context.new
+        local = context_from(variables, context)
 
-        vars.inject(function.simplify(context)) do |result, variable|
-          result = differentiate(result, variable, context)
+        result = variables.inject(function.simplify(local)) do |result, variable|
+          result = differentiate(result, variable, local)
           if !is_ast_derivative?(result)
-            result = result.simplify(context)
+            result = result.simplify(local)
           end
           result
         end
+
+        case result
+        when Keisan::AST::Function
+          result.name == "diff" ? result : result.simplify(context)
+        else
+          result.simplify(context)
+        end
       end
 
       private
@@ -61,22 +78,27 @@ module Keisan
         )
       end
 
-      def function_and_vars(ast_function)
+      def function_and_variables(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]
+        variables = ast_function.children[1..-1]
 
-        unless vars.all? {|var| var.is_a?(AST::Variable)}
+        unless variables.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
+          variables
         ]
       end
+
+      def context_from(variables, context = nil)
+        context ||= Keisan::Context.new(shadowed: variables.map(&:name))
+        context.spawn_child(shadowed: variables.map(&:name))
+      end
     end
   end
 end

data/lib/keisan/functions/exp.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Exp < CMathFunction
+      def initialize
+        super("exp")
+      end
+
+      protected
+
+      def self.derivative(argument)
+        Keisan::AST::Function.new([argument], "exp")
+      end
+    end
+  end
+end

data/lib/keisan/functions/expression_function.rb

@@ -3,19 +3,17 @@ module Keisan
     class ExpressionFunction < Keisan::Function
       attr_reader :arguments, :expression
 
-      def initialize(name, arguments, expression, local_context)
+      def initialize(name, arguments, expression, transient_definitions)
         super(name)
         @expression = expression.deep_dup
         @arguments = arguments
-        @local_context = local_context
+        @transient_definitions = transient_definitions
       end
 
       def call(context, *args)
-        unless @arguments.count == args.count
-          raise Keisan::Exceptions::InvalidFunctionError.new("Invalid number of arguments for #{name} function")
-        end
+        verify_argument_size!(args.count)
 
-        local = @local_context.spawn_child
+        local = local_context_for(context)
         arguments.each.with_index do |arg_name, i|
           local.register_variable!(arg_name, args[i])
         end
@@ -24,28 +22,30 @@ module Keisan
       end
 
       def value(ast_function, context = nil)
+        verify_argument_size!(ast_function.children.count)
+
         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)
+        verify_argument_size!(ast_function.children.count)
+
         context ||= Keisan::Context.new
+        local = local_context_for(context)
 
-        ast_function.instance_variable_set(
-          :@children,
-          ast_function.children.map {|child| child.evaluate(context)}
-        )
+        argument_values = 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
+        arguments.each.with_index do |arg_name, i|
+          local.register_variable!(arg_name, argument_values[i].evaluate(context))
         end
+
+        expression.evaluate(local)
       end
 
       def simplify(ast_function, context = nil)
-        context ||= Context.new
+        verify_argument_size!(ast_function.children.count)
 
         ast_function.instance_variable_set(
           :@children,
@@ -58,6 +58,56 @@ module Keisan
           ast_function
         end
       end
+
+      # Multi-argument functions work as follows:
+      # Given f(x, y), in general we will take the derivative with respect to t,
+      # and x = x(t), y = y(t).  For instance d/dt f(2*t, t+1).
+      # In this case, chain rule gives derivative:
+      # dx(t)/dt * f_x(x(t), y(t)) + dy(t)/dt * f_y(x(t), y(t)),
+      # where f_x and f_y are the x and y partial derivatives respectively.
+      def differentiate(ast_function, variable, context = nil)
+        verify_argument_size!(ast_function.children.count)
+
+        local = local_context_for(context)
+
+        # expression.differentiate(variable, context)
+
+        argument_values = ast_function.children.map {|child| child.evaluate(local)}
+
+        argument_derivatives = ast_function.children.map do |child|
+          child.differentiate(variable, context)
+        end
+
+        Keisan::AST::Plus.new(
+          argument_derivatives.map.with_index {|argument_derivative, i|
+            partial_derivative = partial_derivatives[i].replace(argument_variables[i], argument_values[i])
+            Keisan::AST::Times.new([argument_derivative, partial_derivative])
+          }
+        )
+      end
+
+      private
+
+      def argument_variables
+        @argument_variables ||= arguments.map {|argument| Keisan::AST::Variable.new(argument)}
+      end
+
+      def partial_derivatives
+        @partial_derivatives ||= argument_variables.map.with_index do |variable, i|
+          partial_derivative = expression.differentiate(variable)
+        end
+      end
+
+      def verify_argument_size!(argument_size)
+        unless @arguments.count == argument_size
+          raise Keisan::Exceptions::InvalidFunctionError.new("Invalid number of arguments for #{name} function")
+        end
+      end
+
+      def local_context_for(context = nil)
+        context ||= Keisan::Context.new
+        context.spawn_child(definitions: @transient_definitions, shadowed: @arguments, transient: true)
+      end
     end
   end
 end

data/lib/keisan/functions/filter.rb

@@ -0,0 +1,64 @@
+module Keisan
+  module Functions
+    class Filter < Keisan::Function
+      # Filters (list, variable, expression)
+      # e.g. filter([1,2,3,4], x, x % 2 == 0)
+      # should give [2,4]
+      def initialize
+        @name = "filter"
+      end
+
+      def value(ast_function, context = nil)
+        evaluate(ast_function, context = nil)
+      end
+
+      def evaluate(ast_function, context = nil)
+        context ||= Context.new
+        simplify(ast_function, context).evaluate(context)
+      end
+
+      def simplify(ast_function, context = nil)
+        list, variable, expression = list_variable_expression_for(ast_function, context)
+
+        context ||= Keisan::Context.new
+        local = context.spawn_child(transient: false, shadowed: [variable.name])
+
+        Keisan::AST::List.new(
+          list.children.select do |element|
+            local.register_variable!(variable, element)
+            result = expression.evaluate(local)
+
+            case result
+            when Keisan::AST::Boolean
+              result.value
+            else
+              raise Keisan::Exceptions::InvalidFunctionError.new("Filter requires expression to be a logical expression")
+            end
+          end
+        )
+      end
+
+      private
+
+      def list_variable_expression_for(ast_function, context)
+        unless ast_function.children.size == 3
+          raise Keisan::Exceptions::InvalidFunctionError.new("Require 3 arguments to filter")
+        end
+
+        list = ast_function.children[0].simplify(context)
+        variable = ast_function.children[1]
+        expression = ast_function.children[2]
+
+        unless list.is_a?(Keisan::AST::List)
+          raise Keisan::Exceptions::InvalidFunctionError.new("First argument to filter must be a list")
+        end
+
+        unless variable.is_a?(Keisan::AST::Variable)
+          raise Keisan::Exceptions::InvalidFunctionError.new("Second argument to filter must be a variable")
+        end
+
+        [list, variable, expression]
+      end
+    end
+  end
+end

data/lib/keisan/functions/if.rb

@@ -27,17 +27,8 @@ module Keisan
         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)
+          node = bool.value ? ast_function.children[1] : ast_function.children[2]
+          node.to_node.evaluate(context)
         else
           ast_function
         end
@@ -49,7 +40,7 @@ module Keisan
 
         if bool.is_a?(Keisan::AST::Boolean)
           if bool.value
-            ast_function.children[1].simplify(context)
+            ast_function.children[1].to_node.simplify(context)
           else
             ast_function.children[2].to_node.simplify(context)
           end
@@ -57,6 +48,18 @@ module Keisan
           ast_function
         end
       end
+
+      def differentiate(ast_function, variable, context = nil)
+        context ||= Context.new
+        Keisan::AST::Function.new(
+          [
+            ast_function.children[0],
+            ast_function.children[1].differentiate(variable, context),
+            ast_function.children[2].differentiate(variable, context)
+          ],
+          @name
+        )
+      end
     end
   end
 end