keisan 0.8.13 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05596336b8e5f1de3f7787b6a36120152f4e13c8caa822da225fe989f6af3c72'
-  data.tar.gz: 9a4d79fbc8ed709ec7d0f9b90d0e31f4f3e65c7e43b067800b66a0ea7c568ffb
+  metadata.gz: c77b933e609cf2ed878939973a183082fa01b87ac49a8bece5278c0df5e66aed
+  data.tar.gz: e737e883ba1fadfa8c9c9ab19f6b995e4cc33ab4f5f2f7f7750bcd0091dd9cfc
 SHA512:
-  metadata.gz: d040a4d12325c74a8775d7a87a7d450fd0218de3e639b7ac43fe53bbb1310000cd53207e98727266f59535c5f7347d74392b941b66ad10359d97c515d5e02f75
-  data.tar.gz: 81ce4fe88b6d215a194bd8cf45388957689353c275cb8e60ec921a26eac8cb86d10c067ed34e09f6f303482f2b913005bc07c3448aed413d291b3beb66ecbf4f
+  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

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/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/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/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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.8.13
+  version: 0.9.0
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-21 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