perf: cache expensive computations in Bayes classifier (#84)

* perf: cache expensive computations in Bayes classifier

Addresses issue #65 by memoizing O(n) operations that were recalculated
on every classification call:

- Cache training_count (sum of category counts) with dirty-flag pattern
- Cache vocab_size (unique words across categories) with invalidation
- Cache Vector#magnitude since Vector objects are immutable

The dirty-flag pattern ensures caches are invalidated when training data
changes via train, untrain, add_category, or remove_category calls.

Also updates CLAUDE.md to use bundle exec for rake commands.

Closes #65

* fix: align memoized variable names with method names

RuboCop's Naming/MemoizedInstanceVariableName requires the memoized
instance variable to match the method name. Update:

- @training_count_cache -> @cached_training_count
- @vocab_size_cache -> @cached_vocab_size
- @magnitude_cache -> @magnitude

Author: cardmagic

CLAUDE.md

@@ -12,27 +12,27 @@ Ruby gem providing text classification via two algorithms:
 
 ```bash
 # Compile native C extension
-rake compile
+bundle exec rake compile
 
 # Run all tests (compiles first)
-rake test
+bundle exec rake test
 
 # Run a single test file
 ruby -Ilib test/bayes/bayesian_test.rb
 ruby -Ilib test/lsi/lsi_test.rb
 
 # Run tests with pure Ruby (no native extension)
-NATIVE_VECTOR=true rake test
+NATIVE_VECTOR=true bundle exec rake test
 
 # Run benchmarks
-rake benchmark
-rake benchmark:compare
+bundle exec rake benchmark
+bundle exec rake benchmark:compare
 
 # Interactive console
-rake console
+bundle exec rake console
 
 # Generate documentation
-rake doc
+bundle exec rake doc
 ```
 
 ## Architecture
@@ -67,7 +67,7 @@ LSI uses a native C extension for fast linear algebra operations:
 - Jacobi SVD implementation for singular value decomposition
 
 Check current backend: `Classifier::LSI.backend` returns `:native` or `:ruby`
-Force pure Ruby: `NATIVE_VECTOR=true rake test`
+Force pure Ruby: `NATIVE_VECTOR=true bundle exec rake test`
 
 ### Content Nodes (`lib/classifier/lsi/content_node.rb`)
 

lib/classifier/bayes.rb

@@ -15,6 +15,8 @@ class Bayes
     # @rbs @total_words: Integer
     # @rbs @category_counts: Hash[Symbol, Integer]
     # @rbs @category_word_count: Hash[Symbol, Integer]
+    # @rbs @cached_training_count: Float?
+    # @rbs @cached_vocab_size: Integer?
 
     # The class can be created with one or more categories, each of which will be
     # initialized and given a training method. E.g.,
@@ -27,6 +29,8 @@ def initialize(*categories)
       @total_words = 0
       @category_counts = Hash.new(0)
       @category_word_count = Hash.new(0)
+      @cached_training_count = nil
+      @cached_vocab_size = nil
     end
 
     # Provides a general training method for all categories specified in Bayes#new
@@ -41,6 +45,7 @@ def train(category, text)
       category = category.prepare_category_name
       word_hash = text.word_hash
       synchronize do
+        invalidate_caches
         @category_counts[category] += 1
         word_hash.each do |word, count|
           @categories[category][word] ||= 0
@@ -64,6 +69,7 @@ def untrain(category, text)
       category = category.prepare_category_name
       word_hash = text.word_hash
       synchronize do
+        invalidate_caches
         @category_counts[category] -= 1
         word_hash.each do |word, count|
           next unless @total_words >= 0
@@ -90,8 +96,8 @@ def untrain(category, text)
     def classifications(text)
       words = text.word_hash.keys
       synchronize do
-        training_count = @category_counts.values.sum.to_f
-        vocab_size = [@categories.values.flat_map(&:keys).uniq.size, 1].max
+        training_count = cached_training_count
+        vocab_size = cached_vocab_size
 
         @categories.to_h do |category, category_words|
           smoothed_total = ((@category_word_count[category] || 0) + vocab_size).to_f
@@ -211,7 +217,10 @@ def categories
     #
     # @rbs (String | Symbol) -> Hash[Symbol, Integer]
     def add_category(category)
-      synchronize { @categories[category.prepare_category_name] = {} }
+      synchronize do
+        invalidate_caches
+        @categories[category.prepare_category_name] = {}
+      end
     end
 
     alias append_category add_category
@@ -227,6 +236,8 @@ def marshal_dump
     def marshal_load(data)
       mu_initialize
       @categories, @total_words, @category_counts, @category_word_count = data
+      @cached_training_count = nil
+      @cached_vocab_size = nil
     end
 
     # Allows you to remove categories from the classifier.
@@ -243,6 +254,7 @@ def remove_category(category)
       synchronize do
         raise StandardError, "No such category: #{category}" unless @categories.key?(category)
 
+        invalidate_caches
         @total_words -= @category_word_count[category].to_i
 
         @categories.delete(category)
@@ -261,6 +273,8 @@ def restore_state(data)
       @total_words = data['total_words']
       @category_counts = Hash.new(0) #: Hash[Symbol, Integer]
       @category_word_count = Hash.new(0) #: Hash[Symbol, Integer]
+      @cached_training_count = nil
+      @cached_vocab_size = nil
 
       data['categories'].each do |cat_name, words|
         @categories[cat_name.to_sym] = words.transform_keys(&:to_sym)
@@ -274,5 +288,21 @@ def restore_state(data)
         @category_word_count[cat_name.to_sym] = count
       end
     end
+
+    # @rbs () -> void
+    def invalidate_caches
+      @cached_training_count = nil
+      @cached_vocab_size = nil
+    end
+
+    # @rbs () -> Float
+    def cached_training_count
+      @cached_training_count ||= @category_counts.values.sum.to_f
+    end
+
+    # @rbs () -> Integer
+    def cached_vocab_size
+      @cached_vocab_size ||= [@categories.values.flat_map(&:keys).uniq.size, 1].max
+    end
   end
 end

lib/classifier/extensions/vector.rb

@@ -27,11 +27,14 @@ class Vector
   undef_method :normalize if method_defined?(:normalize)
 
   def magnitude
-    sum_of_squares = 0.to_r
-    size.times do |i|
-      sum_of_squares += self[i]**2.to_r
+    # Cache magnitude since Vector is immutable after creation
+    @magnitude ||= begin
+      sum_of_squares = 0.to_r
+      size.times do |i|
+        sum_of_squares += self[i]**2.to_r
+      end
+      Math.sqrt(sum_of_squares.to_f)
     end
-    Math.sqrt(sum_of_squares.to_f)
   end
 
   def normalize