keisan 0.9.0 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c77b933e609cf2ed878939973a183082fa01b87ac49a8bece5278c0df5e66aed
-  data.tar.gz: e737e883ba1fadfa8c9c9ab19f6b995e4cc33ab4f5f2f7f7750bcd0091dd9cfc
+  metadata.gz: e9daac57399adbc7f0028c078c8ec1a74e6a5b7222f2473a871d2ca7ae46c1e4
+  data.tar.gz: 2ffd26dec791b8a88e1edce5aeaf331622ccbb2403b5f17185d3aad36065c173
 SHA512:
-  metadata.gz: 1cbf2ba0b83b1c74b6d70530dbdebe5a6519cff81c90a2e79216fff1ced7d7ded853d88691afbcdcb75b3995349d82c7b02b0cda915cb871c545080b37c25b7f
-  data.tar.gz: 7877b72629fe6f90c7d508451dc580f88c8f10b9d14529917fb9235c805d84c55d972188dadd85ffb6acef6a81e728911e60a0012968a66408bb8a600cfaca45
+  metadata.gz: 90b892b2b7602af3406bdbd84b18d211e790afcf185268f3d84800d8fe390d099870053e39f39d2c46e82da0ba7b185597c1d462af359a1fdb7a0f3aad07c80a
+  data.tar.gz: 29175b77265433e8e619a098e7e862472c7575bc2de91b38ed8e853355e3a133da5a33f6e43a321295cbff0a900e41502885c1fc4dbe649431fadc1baa767469

data/README.md

@@ -280,6 +280,14 @@ calculator.evaluate("range(5,10)")
 #=> [5,6,7,8,9]
 calculator.evaluate("range(0,10,2)")
 #=> [0,2,4,6,8]
+calculator.evaluate("[1, 2, 2, 3].uniq")
+#=> [1,2,3]
+calculator.evaluate("[1, 2, 3].difference([2, 3, 4])")
+#=> [1]
+calculator.evaluate("[1, 2, 3].intersection([2, 3, 4])")
+#=> [2, 3]
+calculator.evaluate("[1, 2, 3].union([2, 3, 4])")
+#=> [1, 2, 3, 4]
 ```
 
 ##### Hashes

data/lib/keisan/ast/assignment.rb

@@ -49,11 +49,13 @@ module Keisan
       end
 
       def unbound_variables(context = nil)
-        variables = super(context)
+        context ||= Context.new
+
         if is_variable_definition?
-          variables.delete(children.first.name)
+          variable_assignment_unbound_variables(context)
         else
-          variables
+          # TODO: Should update to handle function / list assignment.
+          super(context)
         end
       end
 
@@ -70,6 +72,10 @@ module Keisan
         children.first.is_a?(Variable)
       end
 
+      def variable_name
+        children.first.name
+      end
+
       def is_function_definition?
         children.first.is_a?(Function)
       end
@@ -78,6 +84,10 @@ module Keisan
         children.first.is_a?(List)
       end
 
+      def rhs_unbound_variables(context = nil)
+        children.last.unbound_variables(context)
+      end
+
       private
 
       def evaluate_variable_assignment(context, lhs, rhs)
@@ -96,6 +106,16 @@ module Keisan
       def evaluate_cell_assignment(context, lhs, rhs)
         CellAssignment.new(self, context, lhs, rhs).evaluate
       end
+
+      def variable_assignment_unbound_variables(context)
+        rhs = rhs_unbound_variables(context)
+        # If the right-side is fully defined, then this is a valid assignment.
+        if rhs.empty?
+          Set.new
+        else
+          rhs | Set.new([variable_name])
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/indexing.rb

@@ -8,6 +8,19 @@ module Keisan
         @indexes = indexes
       end
 
+      def deep_dup
+        dupped = super
+        dupped.instance_variable_set(
+          :@indexes, indexes.map(&:deep_dup)
+        )
+        dupped
+      end
+
+      def freeze
+        indexes.each(&:freeze)
+        super
+      end
+
       def value(context = nil)
         return child.value(context).send(:[], *indexes.map {|index| index.value(context)})
       end

data/lib/keisan/ast/multi_line.rb

@@ -20,9 +20,49 @@ module Keisan
         evaluate(context)
       end
 
+      def unbound_variables(context = nil)
+        context ||= Context.new
+        defined_variables = Set.new
+
+        children.inject(Set.new) do |unbound_vars, child|
+          if child.is_a?(Assignment) && child.is_variable_definition?
+            line_unbound_vars = unbound_variables_for_line_variable_assignment(context, child, unbound_vars, defined_variables)
+            if line_unbound_vars.empty?
+              defined_variables.add(child.variable_name)
+            end
+            unbound_vars | line_unbound_vars
+          else
+            unbound_vars | (child.unbound_variables(context) - defined_variables)
+          end
+        end
+      end
+
       def to_s
         children.map(&:to_s).join(";")
       end
+
+      private
+
+      def unbound_variables_for_line_variable_assignment(context, line, unbound_vars, defined_variables)
+        child_unbound_variables = variable_assignment_unbound_variables(context, line, defined_variables)
+        if child_unbound_variables.empty?
+          defined_variables.add(line.variable_name)
+          unbound_vars
+        else
+          unbound_vars | child_unbound_variables
+        end
+      end
+
+      def variable_assignment_unbound_variables(context, assignment, defined_variables)
+        rhs_child_unbound_variables = assignment.rhs_unbound_variables(context) - defined_variables
+
+        # If there are no unbound variables, this is a properly bound assignment.
+        if rhs_child_unbound_variables.empty?
+          Set.new
+        else
+          Set.new([assignment.variable_name]) | rhs_child_unbound_variables
+        end
+      end
     end
   end
 end

data/lib/keisan/calculator.rb

@@ -47,10 +47,18 @@ module Keisan
       Evaluator.new(self, cache: @cache).evaluate(expression, definitions)
     end
 
+    def evaluate_ast(ast, definitions = {})
+      Evaluator.new(self, cache: @cache).evaluate_ast(ast, definitions: definitions)
+    end
+
     def simplify(expression, definitions = {})
       Evaluator.new(self, cache: @cache).simplify(expression, definitions)
     end
 
+    def simplify_ast(ast, definitions = {})
+      Evaluator.new(self, cache: @cache).simplify_ast(ast, definitions: definitions)
+    end
+
     def ast(expression)
       Evaluator.new(self, cache: @cache).parse_ast(expression)
     end

data/lib/keisan/evaluator.rb

@@ -9,7 +9,11 @@ module Keisan
 
     def evaluate(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = parse_ast(expression)
+      evaluate_ast(parse_ast(expression), context: context)
+    end
+
+    def evaluate_ast(ast, definitions: {}, context: nil)
+      context ||= calculator.context.spawn_child(definitions: definitions, transient: true)
       last_line = last_line(ast)
 
       evaluation = ast.evaluated(context)
@@ -25,7 +29,11 @@ module Keisan
 
     def simplify(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = parse_ast(expression)
+      simplify_ast(parse_ast(expression), context: context)
+    end
+
+    def simplify_ast(ast, definitions: {}, context: nil)
+      context ||= calculator.context.spawn_child(definitions: definitions, transient: true)
       ast.simplified(context)
     end
 

data/lib/keisan/functions/default_registry.rb

@@ -118,10 +118,13 @@ module Keisan
       end
 
       def self.register_array_methods!(registry)
-        %i(min max size flatten reverse).each do |method|
+        %i(min max size flatten reverse uniq).each do |method|
           registry.register!(method, Proc.new {|a| a.send(method)}, force: true)
         end
 
+        registry.register!(:difference, Proc.new {|a, b| a - b}, force: true)
+        registry.register!(:intersection, Proc.new {|a, b| a & b}, force: true)
+        registry.register!(:union, Proc.new {|a, b| a | b}, force: true)
         registry.register!("range", Functions::Range.new, force: true)
       end
 

data/lib/keisan/functions/enumerable_function.rb

@@ -54,7 +54,7 @@ module Keisan
       private
 
       def operand_arguments_expression_for(ast_function, context)
-        operand = ast_function.children[0].simplify(context)
+        operand = ast_function.children[0].evaluate(context)
         arguments = ast_function.children[1...-1]
         expression = ast_function.children[-1]
 

data/lib/keisan/functions/expression_function.rb

@@ -14,6 +14,12 @@ module Keisan
         @transient_definitions = transient_definitions
       end
 
+      def freeze
+        @arguments.freeze
+        @expression.freeze
+        super
+      end
+
       def call(context, *args)
         validate_arguments!(args.count)
 
@@ -96,7 +102,7 @@ module Keisan
       private
 
       def argument_variables
-        @argument_variables ||= arguments.map {|argument| AST::Variable.new(argument)}
+        arguments.map {|argument| AST::Variable.new(argument)}
       end
 
       def calculate_partial_derivatives(context)

data/lib/keisan/functions/registry.rb

@@ -44,6 +44,9 @@ module Keisan
         when Proc
           self[name] = ProcFunction.new(name, function)
         when Function
+          # The expression AST which represents the function should be constant,
+          # so we freeze it so it will always have the same behavior.
+          function.freeze if function.is_a?(ExpressionFunction)
           self[name] = function
         else
           raise Exceptions::InvalidFunctionError.new

data/lib/keisan/parser.rb

@@ -211,7 +211,8 @@ module Keisan
       when :square
         @components << Parsing::List.new(arguments_from_group(token))
       when :curly
-        if token.sub_tokens.any? {|token| token.is_a?(Tokens::Colon)}
+        # A hash either has a colon, or is empty
+        if token.sub_tokens.any? {|token| token.is_a?(Tokens::Colon)} || token.sub_tokens.empty?
           @components << Parsing::Hash.new(Util.array_split(token.sub_tokens) {|token| token.is_a?(Tokens::Comma)})
         else
           @components << Parsing::CurlyGroup.new(token.sub_tokens)

data/lib/keisan/parsing/hash.rb

@@ -4,15 +4,25 @@ module Keisan
       attr_reader :key_value_pairs
 
       def initialize(key_value_pairs)
-        @key_value_pairs = Array(key_value_pairs).map {|key_value_pair|
-          validate_and_extract_key_value_pair(key_value_pair)
-        }
+        key_value_pairs = Array(key_value_pairs)
+        if key_value_pairs.size == 1 && key_value_pairs.first.empty?
+          @key_value_pairs = []
+        else
+          @key_value_pairs = key_value_pairs.map {|key_value_pair|
+            validate_and_extract_key_value_pair(key_value_pair)
+          }
+        end
       end
 
       private
 
       def validate_and_extract_key_value_pair(key_value_pair)
-        key, value = Util.array_split(key_value_pair) {|token| token.is_a?(Tokens::Colon)}
+        filtered_key_value_pair = key_value_pair.select {|token|
+          !token.is_a?(Tokens::LineSeparator)
+        }
+        key, value = Util.array_split(filtered_key_value_pair) {|token|
+          token.is_a?(Tokens::Colon)
+        }
         raise Exceptions::ParseError.new("Invalid hash") unless key.size == 1 && value.size >= 1
 
         key = key.first

data/lib/keisan/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.2
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-26 00:00:00.000000000 Z
+date: 2024-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmath