keisan 0.8.8 → 0.8.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d539ead6f33b2151b228dfe6c30a0e3f7d40bb7b1113c90b851d020e04106df5
-  data.tar.gz: c36af3538e6f448c285b9857aa5ea14e3bc90853e5d3f4a74fd726d8b0c35068
+  metadata.gz: '05596336b8e5f1de3f7787b6a36120152f4e13c8caa822da225fe989f6af3c72'
+  data.tar.gz: 9a4d79fbc8ed709ec7d0f9b90d0e31f4f3e65c7e43b067800b66a0ea7c568ffb
 SHA512:
-  metadata.gz: 67557029c43754d862406fc0491594b94dcc4dac5a925e518232accfd75c42582f8e5d11b5f99eec7f44dcb1ea29ea31f087668bf70a68c56fa25fc4ca8f2929
-  data.tar.gz: 2451bd2dbe844af1bc3a4f2ec9d0819aeb4df52f96bd45dbbc5ada1993b2c6003245c8f6191ce3f5dc59de18b106f313e07dedd3aef9ba670525d4bacabfb43a
+  metadata.gz: d040a4d12325c74a8775d7a87a7d450fd0218de3e639b7ac43fe53bbb1310000cd53207e98727266f59535c5f7347d74392b941b66ad10359d97c515d5e02f75
+  data.tar.gz: 81ce4fe88b6d215a194bd8cf45388957689353c275cb8e60ec921a26eac8cb86d10c067ed34e09f6f303482f2b913005bc07c3448aed413d291b3beb66ecbf4f

data/README.md

@@ -83,6 +83,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/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/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/number.rb

@@ -5,6 +5,11 @@ module Keisan
 
       def initialize(number)
         @number = number
+        # Reduce the number if possible
+        case @number
+        when Rational
+          @number = @number.numerator if @number.denominator == 1
+        end
       end
 
       def value(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/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.8"
+  VERSION = "0.8.13"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.8.8
+  version: 0.8.13
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-30 00:00:00.000000000 Z
+date: 2021-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmath
@@ -151,6 +151,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