keisan 0.4.0 → 0.5.0

data/lib/keisan/functions/imag.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Functions
+    class Imag < CMathFunction
+      def initialize
+        super("imag", Proc.new {|arg| arg.imag})
+      end
+    end
+  end
+end

data/lib/keisan/functions/log.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Log < CMathFunction
+      def initialize
+        super("log")
+      end
+
+      protected
+
+      def self.derivative(argument)
+        1 / argument
+      end
+    end
+  end
+end

data/lib/keisan/functions/map.rb

@@ -0,0 +1,57 @@
+module Keisan
+  module Functions
+    class Map < Keisan::Function
+      # Maps (list, variable, expression)
+      # e.g. map([1,2,3], x, 2*x)
+      # should give [2,4,6]
+      def initialize
+        @name = "map"
+      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)
+        context ||= Keisan::Context.new
+        list, variable, expression = list_variable_expression_for(ast_function, context)
+
+        local = context.spawn_child(transient: false, shadowed: [variable.name])
+
+        Keisan::AST::List.new(
+          list.children.map do |element|
+            local.register_variable!(variable, element)
+            expression.simplified(local)
+          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 map")
+        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 map must be a list")
+        end
+
+        unless variable.is_a?(Keisan::AST::Variable)
+          raise Keisan::Exceptions::InvalidFunctionError.new("Second argument to map must be a variable")
+        end
+
+        [list, variable, expression]
+      end
+    end
+  end
+end

data/lib/keisan/functions/math_function.rb

@@ -0,0 +1,34 @@
+module Keisan
+  module Functions
+    class MathFunction < ProcFunction
+      def initialize(name, proc_function = nil)
+        super(name, proc_function || Proc.new {|arg| Math.send(name, arg)})
+      end
+
+      def simplify(ast_function, context = nil)
+        simplified = super
+        self.class.apply_simplifications(simplified)
+      end
+
+      def differentiate(ast_function, variable, context = nil)
+        raise Keisan::Exceptions::InvalidFunctionError.new unless ast_function.children.count == 1
+        context ||= Context.new
+
+        argument_simplified = ast_function.children.first.simplify(context)
+        argument_differentiated = argument_simplified.differentiate(variable, context)
+
+        (argument_differentiated * self.class.derivative(argument_simplified)).simplify(context)
+      end
+
+      protected
+
+      def self.derivative(argument)
+        raise Keisan::Exceptions::NotImplementedError.new
+      end
+
+      def self.apply_simplifications(simplified)
+        simplified
+      end
+    end
+  end
+end

data/lib/keisan/functions/proc_function.rb

@@ -1,6 +1,8 @@
 module Keisan
   module Functions
     class ProcFunction < Keisan::Function
+      attr_reader :function_proc
+
       def initialize(name, function_proc)
         raise Keisan::Exceptions::InvalidFunctionError.new unless function_proc.is_a?(Proc)
 
@@ -9,13 +11,13 @@ module Keisan
       end
 
       def call(context, *args)
-        @function_proc.call(*args)
+        function_proc.call(*args).to_node
       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)
+        call(context, *argument_values).value(context)
       end
 
       def evaluate(ast_function, context = nil)
@@ -23,7 +25,7 @@ module Keisan
 
         ast_function.instance_variable_set(
           :@children,
-          ast_function.children.map {|child| child.evaluate(context)}
+          ast_function.children.map {|child| child.evaluate(context).to_node}
         )
 
         if ast_function.children.all? {|child| child.well_defined?(context)}

data/lib/keisan/functions/real.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Functions
+    class Real < CMathFunction
+      def initialize
+        super("real", Proc.new {|arg| arg.real})
+      end
+    end
+  end
+end

data/lib/keisan/functions/reduce.rb

@@ -0,0 +1,65 @@
+module Keisan
+  module Functions
+    class Reduce < Keisan::Function
+      # Reduces (list, initial, accumulator, variable, expression)
+      # e.g. reduce([1,2,3,4], 0, total, x, total+x)
+      # should give 10
+      def initialize
+        @name = "reduce"
+      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)
+        context ||= Keisan::Context.new
+        list, initial, accumulator, variable, expression = list_initial_accumulator_variable_expression_for(ast_function, context)
+
+        local = context.spawn_child(transient: false, shadowed: [accumulator.name, variable.name])
+        local.register_variable!(accumulator, initial.simplify(context))
+
+        list.children.each do |element|
+          local.register_variable!(variable, element)
+          result = expression.simplified(local)
+          local.register_variable!(accumulator, result)
+        end
+
+        local.variable(accumulator.name)
+      end
+
+      private
+
+      def list_initial_accumulator_variable_expression_for(ast_function, context)
+        unless ast_function.children.size == 5
+          raise Keisan::Exceptions::InvalidFunctionError.new("Require 5 arguments to reduce")
+        end
+
+        list = ast_function.children[0].simplify(context)
+        initial = ast_function.children[1]
+        accumulator = ast_function.children[2]
+        variable = ast_function.children[3]
+        expression = ast_function.children[4]
+
+        unless list.is_a?(Keisan::AST::List)
+          raise Keisan::Exceptions::InvalidFunctionError.new("First argument to reduce must be a list")
+        end
+
+        unless accumulator.is_a?(Keisan::AST::Variable)
+          raise Keisan::Exceptions::InvalidFunctionError.new("Third argument to reduce is accumulator and must be a variable")
+        end
+
+        unless variable.is_a?(Keisan::AST::Variable)
+          raise Keisan::Exceptions::InvalidFunctionError.new("Fourth argument to reduce is variable and must be a variable")
+        end
+
+        [list, initial, accumulator, variable, expression]
+      end
+    end
+  end
+end

data/lib/keisan/functions/registry.rb

@@ -22,6 +22,10 @@ module Keisan
         raise Keisan::Exceptions::UndefinedFunctionError.new name
       end
 
+      def locals
+        @hash
+      end
+
       def has?(name)
         !!self[name]
       rescue Keisan::Exceptions::UndefinedFunctionError
@@ -40,7 +44,7 @@ module Keisan
         when Proc
           self[name] = Keisan::Functions::ProcFunction.new(name, function)
         when Keisan::Function
-          self[function.name] = function
+          self[name] = function
         else
           raise Keisan::Exceptions::InvalidFunctionError.new
         end

data/lib/keisan/functions/sec.rb

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

data/lib/keisan/functions/sech.rb

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

data/lib/keisan/functions/sin.rb

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

data/lib/keisan/functions/sinh.rb

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

data/lib/keisan/functions/sqrt.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Sqrt < CMathFunction
+      def initialize
+        super("sqrt")
+      end
+
+      protected
+
+      def self.derivative(argument)
+        Keisan::AST::Exponent.new([argument, Rational(-1,2)]) / 2
+      end
+    end
+  end
+end

data/lib/keisan/functions/tan.rb

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

data/lib/keisan/functions/tanh.rb

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

data/lib/keisan/repl.rb

@@ -0,0 +1,105 @@
+require "pry"
+require "readline"
+
+module Keisan
+  class Repl
+    COMMANDS = %w(
+      reset
+      quit
+      variables
+      functions
+      allow_recursive
+    ).freeze
+
+    attr_reader :calculator
+
+    def initialize
+      @running = true
+      initialize_completion_commands
+      reset
+    end
+
+    def reset
+      @calculator = Keisan::Calculator.new
+    end
+
+    def start
+      while @running
+        command = get_command
+
+        # ctrl-d should break out
+        break if command.nil?
+        process_command command
+      end
+    end
+
+    def get_command
+      Readline.readline("keisan> ", true)
+    end
+
+    def process_command(command)
+      command = command.strip
+      return if command.empty?
+
+      case command
+      when /\Areset\z/i
+        reset
+      when /\Aquit\z/i
+        @running = false
+      when /\Avariables\z/i
+        output_variables
+      when /\Afunctions\z/i
+        output_functions
+      when /\Aallow_recursive\z/i
+        calculator.allow_recursive!
+      else
+        begin
+          output_result calculator.simplify(command)
+        rescue StandardError => error
+          output_error error
+        end
+      end
+    end
+
+    def output_result(result)
+      puts "=> " + CodeRay.encode(result.to_s, :ruby, :terminal)
+    end
+
+    def output_error(error)
+      puts CodeRay.encode(error.class.to_s, :ruby, :terminal) + ": " + CodeRay.encode("\"#{error.message}\"", :ruby, :terminal)
+    end
+
+    def output_variables
+      variable_registry.locals.each do |name, variable|
+        puts CodeRay.encode("#{name} = #{variable.value}", :ruby, :terminal)
+      end
+    end
+
+    def output_functions
+      function_registry.locals.each do |name, function|
+        puts CodeRay.encode("#{name}(#{function.arguments.join(', ')}) = #{function.expression.to_s}", :ruby, :terminal)
+      end
+    end
+
+    private
+
+    def context
+      calculator.context
+    end
+
+    def variable_registry
+      context.variable_registry
+    end
+
+    def function_registry
+      context.function_registry
+    end
+
+    def initialize_completion_commands
+      completion_proc = Proc.new { |s| COMMANDS.grep(/^#{Regexp.escape(s)}/) }
+
+      Readline.completion_append_character = " "
+      Readline.completion_proc = completion_proc
+    end
+  end
+end