keisan 0.5.0 → 0.6.0

data/lib/keisan/functions/cos.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        -Keisan::AST::Function.new([argument], "sin")
+        -AST::Function.new([argument], "sin")
       end
     end
   end

data/lib/keisan/functions/cosh.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Function.new([argument], "sinh")
+        AST::Function.new([argument], "sinh")
       end
     end
   end

data/lib/keisan/functions/cot.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        -Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "sin"), -2])
+        -AST::Exponent.new([AST::Function.new([argument], "sin"), -2])
       end
     end
   end

data/lib/keisan/functions/coth.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        -Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "sinh"), -2])
+        -AST::Exponent.new([AST::Function.new([argument], "sinh"), -2])
       end
     end
   end

data/lib/keisan/functions/csc.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        -Keisan::AST::Function.new([argument], "cos") * Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "sin"), -2])
+        -AST::Function.new([argument], "cos") * AST::Exponent.new([AST::Function.new([argument], "sin"), -2])
       end
     end
   end

data/lib/keisan/functions/csch.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        -Keisan::AST::Function.new([argument], "cosh") * Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "sinh"), -2])
+        -AST::Function.new([argument], "cosh") * AST::Exponent.new([AST::Function.new([argument], "sinh"), -2])
       end
     end
   end

data/lib/keisan/functions/default_registry.rb

@@ -1,6 +1,10 @@
+require_relative "let"
+
 require_relative "if"
+require_relative "while"
 require_relative "diff"
 require_relative "replace"
+require_relative "range"
 require_relative "map"
 require_relative "filter"
 require_relative "reduce"
@@ -8,6 +12,7 @@ require_relative "rand"
 require_relative "sample"
 require_relative "math_function"
 require_relative "cmath_function"
+require_relative "erf"
 require_relative "exp"
 require_relative "log"
 require_relative "sin"
@@ -40,43 +45,27 @@ 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)
-        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)
+        registry.register!(:let, Let.new, force: true)
+
+        registry.register!(:if, If.new, force: true)
+        registry.register!(:while, While.new, force: true)
+        registry.register!(:diff, Diff.new, force: true)
+        registry.register!(:replace, Replace.new, force: true)
+        registry.register!(:map, Map.new, force: true)
+        registry.register!(:collect, Map.new, force: true)
+        registry.register!(:filter, Filter.new, force: true)
+        registry.register!(:select, Filter.new, force: true)
+        registry.register!(:reduce, Reduce.new, force: true)
+        registry.register!(:inject, Reduce.new, force: true)
+
+        register_math!(registry)
         register_array_methods!(registry)
         register_random_methods!(registry)
+      end
 
-        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)
+      def self.register_math!(registry)
+        register_builtin_math!(registry)
+        register_custom_math!(registry)
       end
 
       def self.register_builtin_math!(registry)
@@ -92,54 +81,44 @@ module Keisan
         end
       end
 
+      CUSTOM_MATH_FUNCTIONS = %i(erf exp log sin cos tan cot sec csc sinh cosh tanh coth sech csch sqrt cbrt abs real imag).freeze
+
+      def self.register_custom_math!(registry)
+        factorial = Proc.new {|n|
+          (1..n).inject(1) do |res, i|
+            res * i
+          end
+        }
+        nPk = Proc.new {|n, k|
+          factorial.call(n) / factorial.call(n-k)
+        }
+        nCk = Proc.new {|n, k|
+          factorial.call(n) / factorial.call(k) / factorial.call(n-k)
+        }
+
+        registry.register!(:factorial, factorial, force: true)
+        registry.register!(:nPk, nPk, force: true)
+        registry.register!(:permute, nPk, force: true)
+        registry.register!(:nCk, nCk, force: true)
+        registry.register!(:choose, nCk, force: true)
+
+        CUSTOM_MATH_FUNCTIONS.each do |method|
+          klass = Keisan::Functions.const_get(method.to_s.capitalize)
+          registry.register!(method, klass.new, force: true)
+        end
+      end
+
       def self.register_array_methods!(registry)
         %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)
+        registry.register!("range", Functions::Range.new, force: true)
       end
 
       def self.register_random_methods!(registry)
-        registry.register!(:rand, Keisan::Functions::Rand.new, force: true)
-        registry.register!(:sample, Keisan::Functions::Sample.new, force: true)
+        registry.register!(:rand, Rand.new, force: true)
+        registry.register!(:sample, Sample.new, force: true)
       end
     end
   end

data/lib/keisan/functions/diff.rb

@@ -1,23 +1,26 @@
 module Keisan
   module Functions
-    class Diff < Keisan::Function
+    class Diff < Function
       def initialize
+        super("diff", -1)
         @name = "diff"
       end
 
       def value(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
         evaluation = evaluate(ast_function, context)
 
         if is_ast_derivative?(evaluation)
-          raise Keisan::Exceptions::NonDifferentiableError.new
+          raise Exceptions::NonDifferentiableError.new
         else
           evaluation.value(context)
         end
       end
 
       def evaluate(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
         function, variables = function_and_variables(ast_function)
         local = context_from(variables, context)
 
@@ -30,7 +33,7 @@ module Keisan
         end
 
         case result
-        when Keisan::AST::Function
+        when AST::Function
           result.name == "diff" ? result : result.simplify(context)
         else
           result.simplify(context)
@@ -38,9 +41,10 @@ module Keisan
       end
 
       def simplify(ast_function, context = nil)
-        raise Keisan::Exceptions::InternalError.new("received non-diff function") unless ast_function.name == "diff"
+        validate_arguments!(ast_function.children.count)
+        raise Exceptions::InternalError.new("received non-diff function") unless ast_function.name == "diff"
         function, variables = function_and_variables(ast_function)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         local = context_from(variables, context)
 
         result = variables.inject(function.simplify(local)) do |result, variable|
@@ -52,7 +56,7 @@ module Keisan
         end
 
         case result
-        when Keisan::AST::Function
+        when AST::Function
           result.name == "diff" ? result : result.simplify(context)
         else
           result.simplify(context)
@@ -62,7 +66,7 @@ module Keisan
       private
 
       def is_ast_derivative?(node)
-        node.is_a?(Keisan::AST::Function) && node.name == name
+        node.is_a?(AST::Function) && node.name == name
       end
 
       def differentiate(node, variable, context)
@@ -71,7 +75,7 @@ module Keisan
         else
           return AST::Number.new(0)
         end
-      rescue Keisan::Exceptions::NonDifferentiableError => e
+      rescue Exceptions::NonDifferentiableError => e
         return AST::Function.new(
           [node, variable],
           "diff"
@@ -79,14 +83,14 @@ module Keisan
       end
 
       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")
+        unless ast_function.is_a?(AST::Function) && ast_function.name == name
+          raise Exceptions::InvalidFunctionError.new("Must receive diff function")
         end
 
         variables = ast_function.children[1..-1]
 
         unless variables.all? {|var| var.is_a?(AST::Variable)}
-          raise Keisan::Exceptions::InvalidFunctionError.new("Diff must differentiate with respect to variables")
+          raise Exceptions::InvalidFunctionError.new("Diff must differentiate with respect to variables")
         end
 
         [
@@ -96,7 +100,7 @@ module Keisan
       end
 
       def context_from(variables, context = nil)
-        context ||= Keisan::Context.new(shadowed: variables.map(&:name))
+        context ||= Context.new(shadowed: variables.map(&:name))
         context.spawn_child(shadowed: variables.map(&:name))
       end
     end

data/lib/keisan/functions/erf.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Erf < MathFunction
+      def initialize
+        super("erf")
+      end
+
+      protected
+
+      def self.derivative(argument)
+        2/Math.sqrt(Math::PI) * AST::Function.new([-argument**2], "exp")
+      end
+    end
+  end
+end

data/lib/keisan/functions/exp.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Function.new([argument], "exp")
+        AST::Function.new([argument], "exp")
       end
     end
   end

data/lib/keisan/functions/expression_function.rb

@@ -1,17 +1,17 @@
 module Keisan
   module Functions
-    class ExpressionFunction < Keisan::Function
+    class ExpressionFunction < Function
       attr_reader :arguments, :expression
 
       def initialize(name, arguments, expression, transient_definitions)
-        super(name)
+        super(name, arguments.count)
         @expression = expression.deep_dup
         @arguments = arguments
         @transient_definitions = transient_definitions
       end
 
       def call(context, *args)
-        verify_argument_size!(args.count)
+        validate_arguments!(args.count)
 
         local = local_context_for(context)
         arguments.each.with_index do |arg_name, i|
@@ -22,17 +22,17 @@ module Keisan
       end
 
       def value(ast_function, context = nil)
-        verify_argument_size!(ast_function.children.count)
+        validate_arguments!(ast_function.children.count)
 
-        context ||= Keisan::Context.new
+        context ||= 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)
+        validate_arguments!(ast_function.children.count)
 
-        context ||= Keisan::Context.new
+        context ||= Context.new
         local = local_context_for(context)
 
         argument_values = ast_function.children.map {|child| child.evaluate(context)}
@@ -41,18 +41,18 @@ module Keisan
           local.register_variable!(arg_name, argument_values[i].evaluate(context))
         end
 
-        expression.evaluate(local)
+        expression.evaluated(local)
       end
 
       def simplify(ast_function, context = nil)
-        verify_argument_size!(ast_function.children.count)
+        validate_arguments!(ast_function.children.count)
 
         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)}
+        if ast_function.children.all? {|child| child.is_a?(AST::ConstantLiteral)}
           value(ast_function, context).to_node.simplify(context)
         else
           ast_function
@@ -66,7 +66,7 @@ module Keisan
       # 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)
+        validate_arguments!(ast_function.children.count)
 
         local = local_context_for(context)
 
@@ -78,10 +78,10 @@ module Keisan
           child.differentiate(variable, context)
         end
 
-        Keisan::AST::Plus.new(
+        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])
+            AST::Times.new([argument_derivative, partial_derivative])
           }
         )
       end
@@ -89,7 +89,7 @@ module Keisan
       private
 
       def argument_variables
-        @argument_variables ||= arguments.map {|argument| Keisan::AST::Variable.new(argument)}
+        @argument_variables ||= arguments.map {|argument| AST::Variable.new(argument)}
       end
 
       def partial_derivatives
@@ -98,14 +98,8 @@ module Keisan
         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 ||= Context.new
         context.spawn_child(definitions: @transient_definitions, shadowed: @arguments, transient: true)
       end
     end