keisan 0.7.0 → 0.8.4

data/lib/keisan/ast/function_assignment.rb

@@ -29,8 +29,7 @@ module Keisan
 
       def evaluate
         # Blocks might have local variable/function definitions, so skip check
-        verify_rhs_of_function_assignment_is_valid! unless rhs.is_a?(Block)
-
+        verify_rhs_of_function_assignment_is_valid!
         context.register_function!(lhs.name, expression_function, local: local)
         rhs
       end
@@ -38,15 +37,26 @@ module Keisan
       private
 
       def verify_rhs_of_function_assignment_is_valid!
-        # Only variables that can appear are those that are arguments to the function
-        unless rhs.unbound_variables(context) <= Set.new(argument_names)
-          raise Exceptions::InvalidExpression.new("Unbound variables found in function definition")
-        end
+        verify_unbound_functions!
+        verify_unbound_variables!
+      end
+
+      def verify_unbound_functions!
         # Cannot have undefined functions unless allowed by context
         unless context.allow_recursive || rhs.unbound_functions(context).empty?
           raise Exceptions::InvalidExpression.new("Unbound function definitions are not allowed by current context")
         end
       end
+
+      def verify_unbound_variables!
+        # We allow unbound variables inside block statements, as they could be temporary
+        # variables assigned locally
+        return if rhs.is_a?(Block)
+        # Only variables that can appear are those that are arguments to the function
+        unless rhs.unbound_variables(context) <= Set.new(argument_names)
+          raise Exceptions::InvalidExpression.new("Unbound variables found in function definition")
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/hash.rb

@@ -21,6 +21,10 @@ module Keisan
         end
       end
 
+      def contains_a?(klass)
+        super || @hash.any? {|k, v| k.to_node.contains_a?(klass) || v.contains_a?(klass) }
+      end
+
       def evaluate(context = nil)
         context ||= Context.new
 

data/lib/keisan/ast/logical_and.rb

@@ -5,18 +5,35 @@ module Keisan
         :"&&"
       end
 
+      def blank_value
+        true
+      end
+
       def evaluate(context = nil)
-        children[0].evaluate(context).and(children[1].evaluate(context))
+        short_circuit_do(:evaluate, context)
       end
 
-      def blank_value
-        true
+      def simplify(context = nil)
+        short_circuit_do(:simplify, context)
       end
 
       def value(context = nil)
         context ||= Context.new
         children[0].value(context) && children[1].value(context)
       end
+
+      private
+
+      def short_circuit_do(method, context)
+        context ||= Context.new
+        lhs = children[0].send(method, context)
+        case lhs
+        when AST::Boolean
+          lhs.false? ? AST::Boolean.new(false) : children[1].send(method, context)
+        else
+          lhs.and(children[1].send(method, context))
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/logical_equal.rb

@@ -5,13 +5,14 @@ module Keisan
         :"=="
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context).equal(children[1].evaluate(context))
+      protected
+
+      def value_operator
+        :==
       end
 
-      def value(context=nil)
-        context ||= Context.new
-        children[0].value(context) == children[1].value(context)
+      def operator
+        :equal
       end
     end
   end

data/lib/keisan/ast/logical_greater_than.rb

@@ -5,12 +5,14 @@ module Keisan
         :">"
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context) > children[1].evaluate(context)
+      protected
+
+      def value_operator
+        :>
       end
 
-      def value(context = nil)
-        children.first.value(context) > children.last.value(context)
+      def operator
+        :>
       end
     end
   end

data/lib/keisan/ast/logical_greater_than_or_equal_to.rb

@@ -5,12 +5,14 @@ module Keisan
         :">="
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context) >= children[1].evaluate(context)
+      protected
+
+      def value_operator
+        :>=
       end
 
-      def value(context = nil)
-        children.first.value(context) >= children.last.value(context)
+      def operator
+        :>=
       end
     end
   end

data/lib/keisan/ast/logical_less_than.rb

@@ -5,12 +5,14 @@ module Keisan
         :"<"
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context) < children[1].evaluate(context)
+      protected
+
+      def value_operator
+        :<
       end
 
-      def value(context = nil)
-        children.first.value(context) < children.last.value(context)
+      def operator
+        :<
       end
     end
   end

data/lib/keisan/ast/logical_less_than_or_equal_to.rb

@@ -5,12 +5,14 @@ module Keisan
         :"<="
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context) <= children[1].evaluate(context)
+      protected
+
+      def value_operator
+        :<=
       end
 
-      def value(context = nil)
-        children.first.value(context) <= children.last.value(context)
+      def operator
+        :<=
       end
     end
   end

data/lib/keisan/ast/logical_not_equal.rb

@@ -5,13 +5,14 @@ module Keisan
         :"!="
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context).not_equal(children[1].evaluate(context))
+      protected
+
+      def value_operator
+        :!=
       end
 
-      def value(context=nil)
-        context ||= Context.new
-        children[0].value(context) != children[1].value(context)
+      def operator
+        :not_equal
       end
     end
   end

data/lib/keisan/ast/logical_operator.rb

@@ -1,6 +1,30 @@
 module Keisan
   module AST
     class LogicalOperator < Operator
+      def evaluate(context = nil)
+        context ||= Context.new
+        children[0].evaluate(context).send(operator, children[1].evaluate(context))
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+        children[0].simplify(context).send(operator, children[1].simplify(context))
+      end
+
+      def value(context=nil)
+        context ||= Context.new
+        children[0].value(context).send(value_operator, children[1].value(context))
+      end
+
+      protected
+
+      def value_operator
+        raise Exceptions::NotImplementedError.new
+      end
+
+      def operator
+        raise Exceptions::NotImplementedError.new
+      end
     end
   end
 end

data/lib/keisan/ast/logical_or.rb

@@ -10,13 +10,30 @@ module Keisan
       end
 
       def evaluate(context = nil)
-        children[0].evaluate(context).or(children[1].evaluate(context))
+        short_circuit_do(:evaluate, context)
+      end
+
+      def simplify(context = nil)
+        short_circuit_do(:simplify, context)
       end
 
       def value(context = nil)
         context ||= Context.new
         children[0].value(context) || children[1].value(context)
       end
+
+      private
+
+      def short_circuit_do(method, context)
+        context ||= Context.new
+        lhs = children[0].send(method, context)
+        case lhs
+        when AST::Boolean
+          lhs.true? ? AST::Boolean.new(true) : children[1].send(method, context)
+        else
+          lhs.or(children[1].send(method, context))
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/node.rb

@@ -37,6 +37,15 @@ module Keisan
         value(context)
       end
 
+      def contains_a?(klass)
+        case klass
+        when Array
+          klass.any? {|k| is_a?(k) }
+        else
+          is_a?(klass)
+        end
+      end
+
       def evaluate_assignments(context = nil)
         self
       end
@@ -45,10 +54,18 @@ module Keisan
         raise Exceptions::NonDifferentiableError.new
       end
 
+      def differentiated(variable, context = nil)
+        deep_dup.differentiate(variable, context)
+      end
+
       def replace(variable, replacement)
         self
       end
 
+      def replaced(variable, replacement)
+        deep_dup.replace(variable, replacement)
+      end
+
       def coerce(other)
         [other.to_node, self]
       end
@@ -132,6 +149,14 @@ module Keisan
         BitwiseOr.new([self, other.to_node])
       end
 
+      def <<(other)
+        BitwiseLeftShift.new([self, other.to_node])
+      end
+
+      def >>(other)
+        BitwiseRightShift.new([self, other.to_node])
+      end
+
       def >(other)
         LogicalGreaterThan.new([self, other.to_node])
       end

data/lib/keisan/ast/number.rb

@@ -24,6 +24,10 @@ module Keisan
         case other
         when Number
           Number.new(value + other.value)
+        when Date
+          Date.new(other.value + value)
+        when Time
+          Time.new(other.value + value)
         else
           super
         end
@@ -107,6 +111,26 @@ module Keisan
         end
       end
 
+      def <<(other)
+        other = other.to_node
+        case other
+        when Number
+          Number.new(value << other.value)
+        else
+          super
+        end
+      end
+
+      def >>(other)
+        other = other.to_node
+        case other
+        when Number
+          Number.new(value >> other.value)
+        else
+          super
+        end
+      end
+
       def >(other)
         other = other.to_node
         case other

data/lib/keisan/ast/operator.rb

@@ -13,6 +13,8 @@ module Keisan
         "%":  [2,  85, :left],   # Modulo
         "+":  [2,  80, :left],   # Plus
         # "-":  [2,  80, :left], # Minus
+        "<<": [2,  75, :left],   # Bitwise left shift
+        ">>": [2,  75, :left],   # Bitwise right shift
         "&":  [2,  70, :left],   # Bitwise and
         "^":  [2,  65, :left],   # Bitwise xor
         "|":  [2,  65, :left],   # Bitwise or
@@ -41,7 +43,7 @@ module Keisan
           raise Exceptions::ASTError.new("Mismatch of children and operators")
         end
 
-        children = Array.wrap(children)
+        children = Array(children)
         super(children)
 
         @parsing_operators = parsing_operators

data/lib/keisan/ast/parent.rb

@@ -4,7 +4,7 @@ module Keisan
       attr_reader :children
 
       def initialize(children = [])
-        children = Array.wrap(children).map do |child|
+        children = Array(children).map do |child|
           child.is_a?(Cell) ? child : child.to_node
         end
         raise Exceptions::InternalError.new unless children.is_a?(Array)
@@ -25,6 +25,10 @@ module Keisan
         end
       end
 
+      def contains_a?(klass)
+        super || children.any? {|child| child.contains_a?(klass) }
+      end
+
       def freeze
         children.each(&:freeze)
         super

data/lib/keisan/ast/plus.rb

@@ -22,6 +22,10 @@ module Keisan
         # Special case of array concatenation
         elsif children_values.all? {|child| child.is_a?(::Array)}
           children_values.inject([], &:+)
+        elsif children_values.one? {|child| child.is_a?(::Date)}
+          date_time_plus(children_values, ::Date)
+        elsif children_values.one? {|child| child.is_a?(::Time)}
+          date_time_plus(children_values, ::Time)
         else
           children_values.inject(0, &:+)
         end.to_node.value(context)
@@ -77,6 +81,12 @@ module Keisan
 
       private
 
+      def date_time_plus(elements, klass)
+        date_time = elements.select {|child| child.is_a?(klass)}.first
+        others = elements.select {|child| !child.is_a?(klass)}
+        date_time + others.inject(0, &:+)
+      end
+
       def convert_minus_to_plus!
         @parsing_operators.each.with_index do |parsing_operator, index|
           if parsing_operator.is_a?(Parsing::Minus)

data/lib/keisan/ast/time.rb

@@ -0,0 +1,23 @@
+require_relative "date_time_methods"
+
+module Keisan
+  module AST
+    class Time < ConstantLiteral
+      include DateTimeMethods
+
+      attr_reader :time
+
+      def initialize(time)
+        @time = time
+      end
+
+      def value(context = nil)
+        time
+      end
+
+      def to_s
+        value.strftime("%Y-%m-%d %H:%M:%S")
+      end
+    end
+  end
+end