keisan 0.8.9 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0817ad5c7f153f93b34fd0c3861a1b4d9afcb49ad325310f2258f6ea020e444d'
-  data.tar.gz: 2d1601371bf02fdacdcbd6f29cf72ce9ec15d46a402579dc89418825fde97a5c
+  metadata.gz: c77b933e609cf2ed878939973a183082fa01b87ac49a8bece5278c0df5e66aed
+  data.tar.gz: e737e883ba1fadfa8c9c9ab19f6b995e4cc33ab4f5f2f7f7750bcd0091dd9cfc
 SHA512:
-  metadata.gz: 4faa11222178814693fb58d9db1ddafa7097e49a15e5c59aa8132c26a56e8fc8f69487057ad11e2a37d6dd84d1bb7afa9af4b536ed898d9cd082f357e226098d
-  data.tar.gz: ba57a649fbaf1fec6dc29495f86921141c627ea1e652cccd884f30edf4f9e70096803f1ed36acab4b010930abb75dc01cb09cdd5f399c2bec0b03c6c27d1d449
+  metadata.gz: 1cbf2ba0b83b1c74b6d70530dbdebe5a6519cff81c90a2e79216fff1ced7d7ded853d88691afbcdcb75b3995349d82c7b02b0cda915cb871c545080b37c25b7f
+  data.tar.gz: 7877b72629fe6f90c7d508451dc580f88c8f10b9d14529917fb9235c805d84c55d972188dadd85ffb6acef6a81e728911e60a0012968a66408bb8a600cfaca45

data/README.md

@@ -64,6 +64,36 @@ ast.children.map(&:to_s)
 #=> ["x**2", "1"]
 ```
 
+#### Caching AST results
+
+Computing the AST from a string takes some non-zero amount of time.
+For applications of this gem that evaluate some set of fixed expressions (possibly with different variable values, but with fixed ASTs), it might be worthwhile to cache the ASTs for faster computation.
+To accomplish this, you can use the `Keisan::AST::Cache` class.
+Passing an instance of this class into the `Calculator` will mean everytime a new expression is encountered it will compute the AST and store it in this cache for retrieval next time the expression is encountered.
+
+```ruby
+cache = Keisan::AST::Cache.new
+# Note: if you don't want to create the Cache instance, you can just pass `cache: true` here as well
+calculator = Keisan::Calculator.new(cache: cache)
+calculator.evaluate("exp(-x/T)", x: 1.0, T: 10)
+#=> 0.9048374180359595
+# This call will use the cached AST for "exp(-x/T)"
+calculator.evaluate("exp(-x/T)", x: 2.0, T: 10)
+#=> 0.8187307530779818
+```
+
+If you just want to pre-populate the cache with some predetermined values, you can call `#fetch_or_build` on the `Cache` for each instance, `freeze` the cache, then use this frozen cache in your calculator.
+A cache that has been frozen will only fetch from the cache, never write new values to it.
+
+```ruby
+cache = Keisan::AST::Cache.new
+cache.fetch_or_build("f(x) + diff(g(x), x)")
+cache.freeze
+# This calculator will never write new values to the cache, but when
+# evaluating `"f(x) + diff(g(x), x)"` will fetch this cached AST.
+calculator = Keisan::Calculator.new(cache: cache)
+```
+
 ##### Specifying variables
 
 Passing in a hash of variable (`name`, `value`) pairs to the `evaluate` method is one way of defining variables
@@ -83,6 +113,18 @@ calculator.evaluate("3*x + 1")
 #=> 61
 ```
 
+To perform multiple assignments, lists can be used
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("x = [1, 2]")
+calculator.evaluate("[x[1], y] = [11, 22]")
+calculator.evaluate("x")
+#=> [1, 11]
+calculator.evaluate("y")
+#=> 22
+```
+
 
 ##### Specifying functions
 

data/lib/keisan.rb

@@ -55,6 +55,7 @@ require "keisan/ast/indexing"
 
 require "keisan/ast/line_builder"
 require "keisan/ast/builder"
+require "keisan/ast/cache"
 require "keisan/ast"
 
 require "keisan/function"

data/lib/keisan/ast/assignment.rb

@@ -1,5 +1,6 @@
 require_relative "variable_assignment"
 require_relative "function_assignment"
+require_relative "list_assignment"
 require_relative "cell_assignment"
 
 module Keisan
@@ -31,6 +32,8 @@ module Keisan
           evaluate_variable_assignment(context, lhs, rhs)
         elsif is_function_definition?
           evaluate_function_assignment(context, lhs, rhs)
+        elsif is_list_assignment?
+          evaluate_list_assignment(context, lhs, rhs)
         else
           # Try cell assignment
           evaluate_cell_assignment(context, lhs, rhs)
@@ -71,6 +74,10 @@ module Keisan
         children.first.is_a?(Function)
       end
 
+      def is_list_assignment?
+        children.first.is_a?(List)
+      end
+
       private
 
       def evaluate_variable_assignment(context, lhs, rhs)
@@ -82,6 +89,10 @@ module Keisan
         FunctionAssignment.new(context, lhs, rhs, local).evaluate
       end
 
+      def evaluate_list_assignment(context, lhs, rhs)
+        ListAssignment.new(self, context, lhs, rhs).evaluate
+      end
+
       def evaluate_cell_assignment(context, lhs, rhs)
         CellAssignment.new(self, context, lhs, rhs).evaluate
       end

data/lib/keisan/ast/cache.rb

@@ -0,0 +1,31 @@
+module Keisan
+  module AST
+    class Cache
+      def initialize
+        @cache = {}
+      end
+
+      def fetch_or_build(string)
+        return @cache[string] if @cache.has_key?(string)
+
+        build_from_scratch(string).tap do |ast|
+          unless frozen?
+            # Freeze the AST to keep it from changing in the cache
+            ast.freeze
+            @cache[string] = ast
+          end
+        end
+      end
+
+      def has_key?(string)
+        @cache.has_key?(string)
+      end
+
+      private
+
+      def build_from_scratch(string)
+        Builder.new(string: string).ast
+      end
+    end
+  end
+end

data/lib/keisan/ast/cell.rb

@@ -66,7 +66,7 @@ module Keisan
       end
 
       def to_cell
-        self.class.new(node.to_cell)
+        self.class.new(node.to_node)
       end
 
       def to_s

data/lib/keisan/ast/cell_assignment.rb

@@ -30,7 +30,11 @@ module Keisan
       private
 
       def lhs_evaluate_and_check_modifiable
-        lhs.evaluate(context)
+        res = lhs.evaluate(context)
+        if res.frozen?
+          raise Exceptions::UnmodifiableError.new("Cannot modify frozen variables")
+        end
+        res
       rescue RuntimeError => e
         raise Exceptions::UnmodifiableError.new("Cannot modify frozen variables") if e.message =~ /can't modify frozen/
         raise

data/lib/keisan/ast/constant_literal.rb

@@ -22,6 +22,170 @@ module Keisan
           value.to_s
         end
       end
+
+      def is_constant?
+        true
+      end
+
+      def +(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot add #{self.class} to #{other.class}")
+        else
+          super
+        end
+      end
+
+      def -(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot subtract #{self.class} from #{other.class}")
+        else
+          super
+        end
+      end
+
+      def *(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot multiply #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def /(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot divide #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def %(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot modulo #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def !
+        raise Keisan::Exceptions::InvalidExpression.new("Cannot take logical not of #{self.class}")
+      end
+
+      def ~
+        raise Keisan::Exceptions::InvalidExpression.new("Cannot take bitwise not of #{self.class}")
+      end
+
+      def +@
+        raise Keisan::Exceptions::InvalidExpression.new("Cannot take unary plus of #{self.class}")
+      end
+
+      def -@
+        raise Keisan::Exceptions::InvalidExpression.new("Cannot take unary minus of #{self.class}")
+      end
+
+      def **(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot exponentiate #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def &(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise and #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def ^(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise xor #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def |(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise or #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def <<(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise left shift #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def >>(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise right shift #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def >(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot compute #{self.class} > #{other.class}")
+        else
+          super
+        end
+      end
+
+      def >=(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot compute #{self.class} >= #{other.class}")
+        else
+          super
+        end
+      end
+
+      def <(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot compute #{self.class} < #{other.class}")
+        else
+          super
+        end
+      end
+
+      def <=(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot compute #{self.class} <= #{other.class}")
+        else
+          super
+        end
+      end
+
+      def equal(other)
+        other.is_constant? ? Boolean.new(false) : super
+      end
+
+      def not_equal(other)
+        other.is_constant? ? Boolean.new(true) : super
+      end
+
+      def and(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot logical and #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def or(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot logical or #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/function.rb

@@ -91,6 +91,13 @@ module Keisan
 
         self.class.new([self, variable], "diff")
       end
+
+      # Functions cannot be guaranteed to be constant even if the arguments
+      # are constants, because there might be randomness involved in the
+      # outputs.
+      def is_constant?
+        false
+      end
     end
   end
 end

data/lib/keisan/ast/hash.rb

@@ -34,6 +34,7 @@ module Keisan
       end
 
       def evaluate(context = nil)
+        return self if frozen?
         context ||= Context.new
 
         @hash = ::Hash[
@@ -89,6 +90,10 @@ module Keisan
         ])
         AST::Cell.new(h)
       end
+
+      def is_constant?
+        @hash.all? {|k,v| v.is_constant?}
+      end
     end
   end
 end

data/lib/keisan/ast/list.rb

@@ -6,6 +6,7 @@ module Keisan
       end
 
       def evaluate(context = nil)
+        return self if frozen?
         context ||= Context.new
         @children = children.map {|child| child.is_a?(Cell) ? child : child.evaluate(context)}
         self

data/lib/keisan/ast/list_assignment.rb

@@ -0,0 +1,38 @@
+module Keisan
+  module AST
+    class ListAssignment
+      attr_reader :assignment, :context, :lhs, :rhs
+
+      def initialize(assignment, context, lhs, rhs)
+        @assignment = assignment
+        @context = context
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      def evaluate
+        rhs = @rhs.evaluate(context)
+
+        if !rhs.is_a?(List)
+          raise Exceptions::InvalidExpression.new("To do multiple assignment, RHS must be a list")
+        end
+        if lhs.children.size != rhs.children.size
+          raise Exceptions::InvalidExpression.new("To do multiple assignment, RHS list must have same length as LHS list")
+        end
+
+        i = 0
+        while i < lhs.children.size
+          lhs_variable = lhs.children[i]
+          rhs_assignment = rhs.children[i]
+          individual_assignment = Assignment.new(
+            children = [lhs_variable, rhs_assignment],
+            local: assignment.local,
+            compound_operator: assignment.compound_operator
+          )
+          individual_assignment.evaluate(context)
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/keisan/ast/logical_and.rb

@@ -26,7 +26,7 @@ module Keisan
 
       def short_circuit_do(method, context)
         context ||= Context.new
-        lhs = children[0].send(method, context)
+        lhs = children[0].send(method, context).to_node
         case lhs
         when AST::Boolean
           lhs.false? ? AST::Boolean.new(false) : children[1].send(method, context)

data/lib/keisan/ast/logical_or.rb

@@ -26,7 +26,7 @@ module Keisan
 
       def short_circuit_do(method, context)
         context ||= Context.new
-        lhs = children[0].send(method, context)
+        lhs = children[0].send(method, context).to_node
         case lhs
         when AST::Boolean
           lhs.true? ? AST::Boolean.new(true) : children[1].send(method, context)

data/lib/keisan/ast/node.rb

@@ -202,6 +202,10 @@ module Keisan
       def or(other)
         LogicalOr.new([self, other.to_node])
       end
+
+      def is_constant?
+        false
+      end
     end
   end
 end

data/lib/keisan/ast/operator.rb

@@ -45,8 +45,6 @@ module Keisan
 
         children = Array(children)
         super(children)
-
-        @parsing_operators = parsing_operators
       end
 
       def evaluate_assignments(context = nil)

data/lib/keisan/ast/parent.rb

@@ -75,6 +75,10 @@ module Keisan
         @children = children.map {|child| child.replace(variable, replacement)}
         self
       end
+
+      def is_constant?
+        @children.all?(&:is_constant?)
+      end
     end
   end
 end

data/lib/keisan/ast/plus.rb

@@ -3,7 +3,7 @@ module Keisan
     class Plus < ArithmeticOperator
       def initialize(children = [], parsing_operators = [])
         super
-        convert_minus_to_plus!
+        convert_minus_to_plus!(parsing_operators)
       end
 
       def self.symbol
@@ -87,8 +87,8 @@ module Keisan
         date_time + others.inject(0, &:+)
       end
 
-      def convert_minus_to_plus!
-        @parsing_operators.each.with_index do |parsing_operator, index|
+      def convert_minus_to_plus!(parsing_operators)
+        parsing_operators.each.with_index do |parsing_operator, index|
           if parsing_operator.is_a?(Parsing::Minus)
             @children[index+1] = UnaryMinus.new(@children[index+1])
           end

data/lib/keisan/ast/times.rb

@@ -3,7 +3,7 @@ module Keisan
     class Times < ArithmeticOperator
       def initialize(children = [], parsing_operators = [])
         super
-        convert_divide_to_inverse!
+        convert_divide_to_inverse!(parsing_operators)
       end
 
       def self.symbol
@@ -63,8 +63,8 @@ module Keisan
 
       private
 
-      def convert_divide_to_inverse!
-        @parsing_operators.each.with_index do |parsing_operator, index|
+      def convert_divide_to_inverse!(parsing_operators)
+        parsing_operators.each.with_index do |parsing_operator, index|
           if parsing_operator.is_a?(Parsing::Divide)
             @children[index+1] = UnaryInverse.new(@children[index+1])
           end

data/lib/keisan/ast/unary_logical_not.rb

@@ -8,6 +8,32 @@ module Keisan
       def self.symbol
         :"!"
       end
+
+      def evaluate(context = nil)
+        context ||= Context.new
+        node = child.evaluate(context).to_node
+        case node
+        when AST::Boolean
+          AST::Boolean.new(!node.value)
+        else
+          if node.is_constant?
+            raise Keisan::Exceptions::InvalidFunctionError.new("Cannot take unary logical not of non-boolean constant")
+          else
+            super
+          end
+        end
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+        node = child.simplify(context).to_node
+        case node
+        when AST::Boolean
+          AST::Boolean.new(!node.value)
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/keisan/calculator.rb

@@ -4,13 +4,23 @@ module Keisan
 
     # 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, allow_random: true)
+    def initialize(context: nil, allow_recursive: false, allow_blocks: true, allow_multiline: true, allow_random: true, cache: nil)
       @context = context || Context.new(
         allow_recursive: allow_recursive,
         allow_blocks: allow_blocks,
         allow_multiline: allow_multiline,
         allow_random: allow_random
       )
+      @cache = case cache
+               when nil, false
+                 nil
+               when true
+                 AST::Cache.new
+               when AST::Cache
+                 cache
+               else
+                 raise Exceptions::StandardError.new("cache must be either nil, false, true, or an instance of Keisan::AST::Cache")
+               end
     end
 
     def allow_recursive
@@ -34,15 +44,15 @@ module Keisan
     end
 
     def evaluate(expression, definitions = {})
-      Evaluator.new(self).evaluate(expression, definitions)
+      Evaluator.new(self, cache: @cache).evaluate(expression, definitions)
     end
 
     def simplify(expression, definitions = {})
-      Evaluator.new(self).simplify(expression, definitions)
+      Evaluator.new(self, cache: @cache).simplify(expression, definitions)
     end
 
     def ast(expression)
-      Evaluator.new(self).parse_ast(expression)
+      Evaluator.new(self, cache: @cache).parse_ast(expression)
     end
 
     def define_variable!(name, value)

data/lib/keisan/evaluator.rb

@@ -2,8 +2,9 @@ module Keisan
   class Evaluator
     attr_reader :calculator
 
-    def initialize(calculator)
+    def initialize(calculator, cache: nil)
       @calculator = calculator
+      @cache = cache
     end
 
     def evaluate(expression, definitions = {})
@@ -25,16 +26,16 @@ module Keisan
     def simplify(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
       ast = parse_ast(expression)
-      ast.simplify(context)
+      ast.simplified(context)
     end
 
     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
+      ast = @cache.nil? ? AST.parse(expression) : @cache.fetch_or_build(expression)
+      disallowed = disallowed_nodes
+      if !disallowed.empty? && ast.contains_a?(disallowed)
+        raise Keisan::Exceptions::InvalidExpression.new("Context does not permit expressions with #{disallowed}")
       end
+      ast
     end
 
     private

data/lib/keisan/functions/enumerable_function.rb

@@ -21,7 +21,7 @@ module Keisan
         context ||= Context.new
 
         operand, arguments, expression = operand_arguments_expression_for(ast_function, context)
-        
+
         # Extract underlying operand for cells
         real_operand = operand.is_a?(AST::Cell) ? operand.node : operand
 

data/lib/keisan/functions/filter.rb

@@ -29,7 +29,7 @@ module Keisan
         AST::List.new(
           list.children.select do |element|
             local.register_variable!(variable, element)
-            result = expression.evaluated(local)
+            result = expression.evaluated(local).to_node
 
             case result
             when AST::Boolean
@@ -54,7 +54,7 @@ module Keisan
           hash.select do |cur_key, cur_value|
             local.register_variable!(key, cur_key)
             local.register_variable!(value, cur_value)
-            result = expression.evaluated(local)
+            result = expression.evaluated(local).to_node
 
             case result
             when AST::Boolean

data/lib/keisan/functions/if.rb

@@ -13,12 +13,13 @@ module Keisan
       def evaluate(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Context.new
-
-        bool = ast_function.children[0].evaluate(context)
+        bool = ast_function.children[0].evaluate(context).to_node
 
         if bool.is_a?(AST::Boolean)
           node = bool.value ? ast_function.children[1] : ast_function.children[2]
           node.to_node.evaluate(context)
+        elsif bool.is_constant?
+          raise Keisan::Exceptions::InvalidFunctionError.new("if statement must work on booleans, other constants are not supported")
         else
           ast_function
         end
@@ -27,7 +28,7 @@ module Keisan
       def simplify(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Context.new
-        bool = ast_function.children[0].simplify(context)
+        bool = ast_function.children[0].simplify(context).to_node
 
         if bool.is_a?(AST::Boolean)
           if bool.value
@@ -37,6 +38,8 @@ module Keisan
           else
             Keisan::AST::Null.new
           end
+        elsif bool.is_constant?
+          raise Keisan::Exceptions::InvalidFunctionError.new("if statement must work on booleans, other constants are not supported")
         else
           ast_function
         end

data/lib/keisan/functions/while.rb

@@ -1,6 +1,9 @@
 module Keisan
   module Functions
     class While < Keisan::Function
+      class WhileLogicalNodeIsNotConstant < Keisan::Exceptions::StandardError; end
+      class WhileLogicalNodeIsNonBoolConstant < Keisan::Exceptions::StandardError; end
+
       def initialize
         super("while", 2)
       end
@@ -13,27 +16,43 @@ module Keisan
       def evaluate(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Keisan::Context.new
-        simplify(ast_function, context)
+        while_loop(ast_function, context, simplify: false)
       end
 
       def simplify(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Context.new
-        while_loop(ast_function.children[0], ast_function.children[1], context)
+        while_loop(ast_function, context, simplify: true)
       end
 
       private
 
-      def while_loop(logical_node, body_node, context)
+      def while_loop(ast_function, context, simplify: true)
+        logical_node, body_node = ast_function.children[0], ast_function.children[1]
         current = Keisan::AST::Null.new
 
-        while logical_node_evaluates_to_true(logical_node, context)
-          begin
-            current = body_node.evaluated(context)
-          rescue Exceptions::BreakError
-            break
-          rescue Exceptions::ContinueError
-            next
+        begin
+          while logical_node_evaluates_to_true(logical_node, context)
+            begin
+              current = body_node.evaluated(context)
+            rescue Exceptions::BreakError
+              break
+            rescue Exceptions::ContinueError
+              next
+            end
+          end
+
+        # While loops should work on booleans, not other types of constants
+        rescue WhileLogicalNodeIsNonBoolConstant
+          raise Keisan::Exceptions::InvalidFunctionError.new("while condition must evaluate to a boolean")
+
+        # If the logical expression is not constant (e.g. boolean), then we
+        # cannot simplify the while loop, and an evaluate should raise an error.
+        rescue WhileLogicalNodeIsNotConstant
+          if simplify
+            return ast_function
+          else
+            raise Keisan::Exceptions::InvalidFunctionError.new("while condition must evaluate to a boolean")
           end
         end
 
@@ -41,11 +60,15 @@ module Keisan
       end
 
       def logical_node_evaluates_to_true(logical_node, context)
-        bool = logical_node.evaluated(context)
-        unless bool.is_a?(AST::Boolean)
-          raise Keisan::Exceptions::InvalidFunctionError.new("while condition must evaluate to a boolean")
+        bool = logical_node.evaluated(context).to_node
+
+        if bool.is_a?(AST::Boolean)
+          bool.value(context)
+        elsif bool.is_constant?
+          raise WhileLogicalNodeIsNonBoolConstant.new
+        else
+          raise WhileLogicalNodeIsNotConstant.new
         end
-        bool.value(context)
       end
     end
   end

data/lib/keisan/variables/registry.rb

@@ -1,3 +1,5 @@
+require "set"
+
 module Keisan
   module Variables
     class Registry
@@ -5,7 +7,7 @@ module Keisan
 
       def initialize(variables: {}, shadowed: [], parent: nil, use_defaults: true, force: false)
         @hash = {}
-        @shadowed = Set.new(shadowed.map(&:to_s))
+        @shadowed = ::Set.new(shadowed.map(&:to_s))
         @parent = parent
         @use_defaults = use_defaults
 

data/lib/keisan/version.rb

@@ -1,3 +1,3 @@
 module Keisan
-  VERSION = "0.8.9"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.9.0
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-17 00:00:00.000000000 Z
+date: 2021-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmath
@@ -139,6 +139,7 @@ files:
 - lib/keisan/ast/block.rb
 - lib/keisan/ast/boolean.rb
 - lib/keisan/ast/builder.rb
+- lib/keisan/ast/cache.rb
 - lib/keisan/ast/cell.rb
 - lib/keisan/ast/cell_assignment.rb
 - lib/keisan/ast/constant_literal.rb
@@ -151,6 +152,7 @@ files:
 - lib/keisan/ast/indexing.rb
 - lib/keisan/ast/line_builder.rb
 - lib/keisan/ast/list.rb
+- lib/keisan/ast/list_assignment.rb
 - lib/keisan/ast/literal.rb
 - lib/keisan/ast/logical_and.rb
 - lib/keisan/ast/logical_equal.rb