keisan 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c77b933e609cf2ed878939973a183082fa01b87ac49a8bece5278c0df5e66aed
-  data.tar.gz: e737e883ba1fadfa8c9c9ab19f6b995e4cc33ab4f5f2f7f7750bcd0091dd9cfc
+  metadata.gz: 11f1a2644fbb02817db69dd289564d6fdb9bfd09d294cda62b07156723aebc0e
+  data.tar.gz: 4b9787c0d558af15d466759e40fe4cfac35131d254d227416144588256e5ea9f
 SHA512:
-  metadata.gz: 1cbf2ba0b83b1c74b6d70530dbdebe5a6519cff81c90a2e79216fff1ced7d7ded853d88691afbcdcb75b3995349d82c7b02b0cda915cb871c545080b37c25b7f
-  data.tar.gz: 7877b72629fe6f90c7d508451dc580f88c8f10b9d14529917fb9235c805d84c55d972188dadd85ffb6acef6a81e728911e60a0012968a66408bb8a600cfaca45
+  metadata.gz: 8149fee69d598164334b96f8be59b9763168af97e3803c9abea7285da5ed1d90bb9f87710a3de94498461baec65db335168f8e721fe73c4a837c684a30bc4114
+  data.tar.gz: 8a4e301fb14461b164bf0331684fe7ebe3cd660d4abd38f3c44aba5f50fbed58b6b945082accdf13f9da55bcb76579890fd63db75e8b17e5c098c52d0e2d80ae

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/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/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.1"
 end

metadata

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