keisan 0.7.0 → 0.8.4

data/lib/keisan/ast/unary_inverse.rb

@@ -19,7 +19,7 @@ module Keisan
         @children = [child.simplify(context)]
         case child
         when Number
-          Number.new(Rational(1,child.value(context))).simplify(context)
+          Number.new(child.value**-1)
         else
           (child ** -1).simplify(context)
         end

data/lib/keisan/ast/unary_operator.rb

@@ -2,7 +2,7 @@ module Keisan
   module AST
     class UnaryOperator < Operator
       def initialize(children = [])
-        children = Array.wrap(children)
+        children = Array(children)
         super(children)
         if children.count != 1
           raise Exceptions::ASTError.new("Unary operator takes has a single child")

data/lib/keisan/ast/variable.rb

@@ -13,7 +13,13 @@ module Keisan
 
       def value(context = nil)
         context ||= Context.new
-        variable_node_from_context(context).value(context)
+        node = variable_node_from_context(context)
+        case node
+        when Variable
+          node
+        else
+          node.value(context)
+        end
       end
 
       def unbound_variables(context = nil)
@@ -60,11 +66,8 @@ module Keisan
       end
 
       def replace(variable, replacement)
-        if name == variable.name
-          replacement
-        else
-          self
-        end
+        to_replace_name = variable.is_a?(::String) ? variable : variable.name
+        name == to_replace_name ? replacement : self
       end
 
       def differentiate(variable, context = nil)
@@ -81,9 +84,7 @@ module Keisan
 
       def variable_node_from_context(context)
         variable = context.variable(name)
-        if variable.is_a?(Cell)
-          variable = variable.node
-        end
+        variable = variable.node if variable.is_a?(Cell)
         variable
       end
     end

data/lib/keisan/calculator.rb

@@ -2,8 +2,14 @@ module Keisan
   class Calculator
     attr_reader :context
 
-    def initialize(context: nil, allow_recursive: false)
-      @context = context || Context.new(allow_recursive: allow_recursive)
+    # Note, allow_recursive would be more appropriately named:
+    # allow_unbound_functions_in_function_definitions, but it is too late for that.
+    def initialize(context: nil, allow_recursive: false, allow_blocks: true, allow_multiline: true)
+      @context = context || Context.new(
+        allow_recursive: allow_recursive,
+        allow_blocks: allow_blocks,
+        allow_multiline: allow_multiline
+      )
     end
 
     def allow_recursive
@@ -14,6 +20,14 @@ module Keisan
       context.allow_recursive!
     end
 
+    def allow_blocks
+      context.allow_blocks
+    end
+
+    def allow_multiline
+      context.allow_multiline
+    end
+
     def evaluate(expression, definitions = {})
       Evaluator.new(self).evaluate(expression, definitions)
     end
@@ -23,7 +37,7 @@ module Keisan
     end
 
     def ast(expression)
-      Evaluator.new(self).ast(expression)
+      Evaluator.new(self).parse_ast(expression)
     end
 
     def define_variable!(name, value)

data/lib/keisan/context.rb

@@ -1,13 +1,24 @@
 module Keisan
   class Context
-    attr_reader :function_registry, :variable_registry, :allow_recursive
-
-    def initialize(parent: nil, random: nil, allow_recursive: false, shadowed: [])
+    attr_reader :function_registry,
+      :variable_registry,
+      :allow_recursive,
+      :allow_multiline,
+      :allow_blocks
+
+    def initialize(parent: nil,
+                   random: nil,
+                   allow_recursive: false,
+                   allow_multiline: true,
+                   allow_blocks: true,
+                   shadowed: [])
       @parent = parent
-      @function_registry = Functions::Registry.new(parent: @parent.try(:function_registry))
-      @variable_registry = Variables::Registry.new(parent: @parent.try(:variable_registry), shadowed: shadowed)
+      @function_registry = Functions::Registry.new(parent: @parent&.function_registry)
+      @variable_registry = Variables::Registry.new(parent: @parent&.variable_registry, shadowed: shadowed)
       @random            = random
       @allow_recursive   = allow_recursive
+      @allow_multiline   = allow_multiline
+      @allow_blocks      = allow_blocks
     end
 
     def allow_recursive!
@@ -47,7 +58,7 @@ module Keisan
 
     def transient_definitions
       return {} unless @transient
-      parent_definitions = @parent.present? ? @parent.transient_definitions : {}
+      parent_definitions = @parent.nil? ? {} : @parent.transient_definitions
       parent_definitions.merge(
         @variable_registry.locals
       ).merge(
@@ -73,7 +84,7 @@ module Keisan
 
     def register_variable!(name, value, local: false)
       if !@variable_registry.shadowed.member?(name) && (transient? || !local && @parent&.variable_is_modifiable?(name))
-        @parent.register_variable!(name, value)
+        @parent.register_variable!(name, value, local: local)
       else
         @variable_registry.register!(name, value)
       end
@@ -93,14 +104,14 @@ module Keisan
 
     def register_function!(name, function, local: false)
       if transient? || !local && @parent&.function_is_modifiable?(name)
-        @parent.register_function!(name, function)
+        @parent.register_function!(name, function, local: local)
       else
         @function_registry.register!(name.to_s, function)
       end
     end
 
     def random
-      @random || @parent.try(:random) || Random.new
+      @random || @parent&.random || Random.new
     end
 
     protected
@@ -110,7 +121,13 @@ module Keisan
     end
 
     def pure_child(shadowed: [])
-      self.class.new(parent: self, shadowed: shadowed, allow_recursive: allow_recursive)
+      self.class.new(
+        parent: self,
+        shadowed: shadowed,
+        allow_recursive: allow_recursive,
+        allow_multiline: allow_multiline,
+        allow_blocks: allow_blocks
+      )
     end
   end
 end

data/lib/keisan/evaluator.rb

@@ -8,7 +8,7 @@ module Keisan
 
     def evaluate(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = ast(expression)
+      ast = parse_ast(expression)
       last_line = last_line(ast)
 
       evaluation = ast.evaluated(context)
@@ -24,16 +24,28 @@ module Keisan
 
     def simplify(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = AST.parse(expression)
+      ast = parse_ast(expression)
       ast.simplify(context)
     end
 
-    def ast(expression)
-      AST.parse(expression)
+    def parse_ast(expression)
+      AST.parse(expression).tap do |ast|
+        disallowed = disallowed_nodes
+        if !disallowed.empty? && ast.contains_a?(disallowed)
+          raise Keisan::Exceptions::InvalidExpression.new("Context does not permit expressions with #{disallowed}")
+        end
+      end
     end
 
     private
 
+    def disallowed_nodes
+      disallowed = []
+      disallowed << Keisan::AST::Block unless calculator.allow_blocks
+      disallowed << Keisan::AST::MultiLine unless calculator.allow_multiline
+      disallowed
+    end
+
     def last_line(ast)
       ast.is_a?(AST::MultiLine) ? ast.children.last : ast
     end

data/lib/keisan/exceptions.rb

@@ -18,5 +18,8 @@ module Keisan
     class InvalidExpression < StandardError; end
     class TypeError < StandardError; end
     class NonDifferentiableError < StandardError; end
+
+    class BreakError < StandardError; end
+    class ContinueError < StandardError; end
   end
 end

data/lib/keisan/function.rb

@@ -23,6 +23,12 @@ module Keisan
       raise Exceptions::NotImplementedError.new
     end
 
+    def unbound_variables(children, context)
+      children.inject(Set.new) do |vars, child|
+        vars | child.unbound_variables(context)
+      end
+    end
+
     protected
 
     def validate_arguments!(count)

data/lib/keisan/functions/break.rb

@@ -0,0 +1,11 @@
+require_relative "loop_control_flow_function"
+
+module Keisan
+  module Functions
+    class Break < LoopControlFlowFuntion
+      def initialize
+        super("break", Exceptions::BreakError)
+      end
+    end
+  end
+end

data/lib/keisan/functions/cmath_function.rb

@@ -4,7 +4,9 @@ module Keisan
   module Functions
     class CMathFunction < MathFunction
       def initialize(name, proc_function = nil)
-        super(name, proc_function || Proc.new {|arg| CMath.send(name, arg)})
+        super(name, proc_function || Proc.new {|arg|
+          CMath.send(name, arg)
+        })
       end
     end
   end

data/lib/keisan/functions/continue.rb

@@ -0,0 +1,11 @@
+require_relative "loop_control_flow_function"
+
+module Keisan
+  module Functions
+    class Continue < LoopControlFlowFuntion
+      def initialize
+        super("continue", Exceptions::ContinueError)
+      end
+    end
+  end
+end

data/lib/keisan/functions/default_registry.rb

@@ -1,5 +1,7 @@
 require_relative "let"
 require_relative "puts"
+require_relative "break"
+require_relative "continue"
 
 require_relative "if"
 require_relative "while"
@@ -49,6 +51,8 @@ module Keisan
       def self.register_defaults!(registry)
         registry.register!(:let, Let.new, force: true)
         registry.register!(:puts, Puts.new, force: true)
+        registry.register!(:break, Break.new, force: true)
+        registry.register!(:continue, Continue.new, force: true)
 
         registry.register!(:if, If.new, force: true)
         registry.register!(:while, While.new, force: true)
@@ -65,6 +69,7 @@ module Keisan
         register_math!(registry)
         register_array_methods!(registry)
         register_random_methods!(registry)
+        register_date_time_methods!(registry)
       end
 
       def self.register_math!(registry)
@@ -124,6 +129,40 @@ module Keisan
         registry.register!(:rand, Rand.new, force: true)
         registry.register!(:sample, Sample.new, force: true)
       end
+
+      def self.register_date_time_methods!(registry)
+        register_date_time!(registry)
+
+        registry.register!(:today, Proc.new { ::Date.today }, force: true)
+        registry.register!(:day,  Proc.new {|d| d.mday }, force: true)
+        registry.register!(:weekday,  Proc.new {|d| d.wday }, force: true)
+        registry.register!(:month, Proc.new {|d| d.month }, force: true)
+        registry.register!(:year,  Proc.new {|d| d.year }, force: true)
+
+        registry.register!(:now, Proc.new { ::Time.now }, force: true)
+        registry.register!(:hour,  Proc.new {|t| t.hour }, force: true)
+        registry.register!(:minute,  Proc.new {|t| t.min }, force: true)
+        registry.register!(:second, Proc.new {|t| t.sec }, force: true)
+        registry.register!(:strftime, Proc.new {|*args| args.first.strftime(*args[1..-1]) }, force: true)
+
+        registry.register!(:to_time, Proc.new {|d| d.to_time }, force: true)
+        registry.register!(:to_date, Proc.new {|t| t.to_date }, force: true)
+
+        registry.register!(:epoch_seconds, Proc.new {|d| d.to_time - Time.new(1970, 1, 1, 0, 0, 0) }, force: true)
+        registry.register!(:epoch_days, Proc.new {|t| t.to_date  - Date.new(1970, 1, 1) }, force: true)
+      end
+
+      def self.register_date_time!(registry)
+        [::Date, ::Time].each do |klass|
+          registry.register!(klass.to_s.downcase.to_sym, Proc.new {|*args|
+            if args.count == 1 && args.first.is_a?(::String)
+              AST.const_get(klass.to_s).new(klass.parse(args.first))
+            else
+              AST.const_get(klass.to_s).new(klass.new(*args))
+            end
+          }, force: true)
+        end
+      end
     end
   end
 end

data/lib/keisan/functions/enumerable_function.rb

@@ -12,6 +12,10 @@ module Keisan
         evaluate(ast_function, context)
       end
 
+      def unbound_variables(children, context)
+        super - Set.new(shadowing_variable_names(children).map(&:name))
+      end
+
       def evaluate(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Context.new
@@ -20,9 +24,9 @@ module Keisan
 
         case operand
         when AST::List
-          evaluate_list(operand, arguments, expression, context)
+          evaluate_list(operand, arguments, expression, context).evaluate(context)
         when AST::Hash
-          evaluate_hash(operand, arguments, expression, context)
+          evaluate_hash(operand, arguments, expression, context).evaluate(context)
         else
           raise Exceptions::InvalidFunctionError.new("Unhandled first argument to #{name}: #{operand}")
         end
@@ -34,6 +38,10 @@ module Keisan
 
       protected
 
+      def shadowing_variable_names(children)
+        raise Exceptions::NotImplementedError.new
+      end
+
       def verify_arguments!(arguments)
         unless arguments.all? {|argument| argument.is_a?(AST::Variable)}
           raise Exceptions::InvalidFunctionError.new("Middle arguments to #{name} must be variables")

data/lib/keisan/functions/expression_function.rb

@@ -5,7 +5,11 @@ module Keisan
 
       def initialize(name, arguments, expression, transient_definitions)
         super(name, arguments.count)
-        @expression = expression.deep_dup
+        if expression.is_a?(::String)
+          @expression = AST::parse(expression)
+        else
+          @expression = expression.deep_dup
+        end
         @arguments = arguments
         @transient_definitions = transient_definitions
       end
@@ -70,17 +74,20 @@ module Keisan
 
         local = local_context_for(context)
 
-        # expression.differentiate(variable, context)
-
-        argument_values = ast_function.children.map {|child| child.evaluate(local)}
+        argument_values = ast_function.children.map {|child| child.evaluated(local)}
 
         argument_derivatives = ast_function.children.map do |child|
-          child.differentiate(variable, context)
+          child.differentiated(variable, context)
         end
 
+        partial_derivatives = calculate_partial_derivatives(context)
+
         AST::Plus.new(
           argument_derivatives.map.with_index {|argument_derivative, i|
-            partial_derivative = partial_derivatives[i].replace(argument_variables[i], argument_values[i])
+            partial_derivative = partial_derivatives[i]
+            argument_variables.each.with_index {|argument_variable, j|
+              partial_derivative = partial_derivative.replaced(argument_variable, argument_values[j])
+            }
             AST::Times.new([argument_derivative, partial_derivative])
           }
         )
@@ -92,9 +99,9 @@ module Keisan
         @argument_variables ||= arguments.map {|argument| AST::Variable.new(argument)}
       end
 
-      def partial_derivatives
-        @partial_derivatives ||= argument_variables.map.with_index do |variable, i|
-          partial_derivative = expression.differentiate(variable)
+      def calculate_partial_derivatives(context)
+        argument_variables.map.with_index do |variable, i|
+          partial_derivative = expression.differentiated(variable, context)
         end
       end
 

data/lib/keisan/functions/filter.rb

@@ -10,6 +10,12 @@ module Keisan
         super("filter")
       end
 
+      protected
+
+      def shadowing_variable_names(children)
+        children.size == 3 ? children[1..1] : children[1..2]
+      end
+
       private
 
       def evaluate_list(list, arguments, expression, context)

data/lib/keisan/functions/loop_control_flow_function.rb

@@ -0,0 +1,22 @@
+module Keisan
+  module Functions
+    class LoopControlFlowFuntion < Function
+      def initialize(name, exception_class)
+        super(name, 0)
+        @exception_class = exception_class
+      end
+
+      def value(ast_function, context = nil)
+        raise @exception_class.new
+      end
+
+      def evaluate(ast_function, context = nil)
+        raise @exception_class.new
+      end
+
+      def simplify(ast_function, context = nil)
+        raise @exception_class.new
+      end
+    end
+  end
+end