kumi 0.0.18 → 0.0.20

data/lib/kumi/core/function_registry/logical_functions.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      # Logical operations and boolean functions
-      module LogicalFunctions
-        def self.element_wise_and(a, b)
-          if ENV["DEBUG_CASCADE"]
-            puts "DEBUG element_wise_and called with:"
-            puts "  a: #{a.inspect} (depth: #{array_depth(a)})"
-            puts "  b: #{b.inspect} (depth: #{array_depth(b)})"
-          end
-
-          case [a.class, b.class]
-          when [Array, Array]
-            # Both are arrays - handle hierarchical broadcasting
-            if hierarchical_broadcasting_needed?(a, b)
-              puts "  -> Using hierarchical broadcasting" if ENV["DEBUG_CASCADE"]
-              result = perform_hierarchical_and(a, b)
-              puts "  -> Hierarchical result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
-            else
-              # Same structure - use zip for element-wise operations
-              puts "  -> Using same-structure zip" if ENV["DEBUG_CASCADE"]
-              result = a.zip(b).map { |elem_a, elem_b| element_wise_and(elem_a, elem_b) }
-              puts "  -> Zip result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
-            end
-            result
-          when [Array, Object], [Object, Array]
-            # One is array, one is scalar - broadcast scalar
-            puts "  -> Broadcasting scalar to array" if ENV["DEBUG_CASCADE"]
-            result = if a.is_a?(Array)
-                       a.map { |elem| element_wise_and(elem, b) }
-                     else
-                       b.map { |elem| element_wise_and(a, elem) }
-                     end
-            puts "  -> Broadcast result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
-            result
-          else
-            # Both are scalars - simple AND
-            puts "  -> Simple scalar AND: #{a} && #{b} = #{a && b}" if ENV["DEBUG_CASCADE"]
-            a && b
-          end
-        end
-
-        def self.hierarchical_broadcasting_needed?(a, b)
-          # Check if arrays have different nesting depths (hierarchical broadcasting)
-          depth_a = array_depth(a)
-          depth_b = array_depth(b)
-          depth_a != depth_b
-        end
-
-        def self.array_depth(arr)
-          return 0 unless arr.is_a?(Array)
-          return 1 if arr.empty? || !arr.first.is_a?(Array)
-
-          1 + array_depth(arr.first)
-        end
-
-        def self.perform_hierarchical_and(a, b)
-          # Determine which is the higher dimension and which is lower
-          depth_a = array_depth(a)
-          depth_b = array_depth(b)
-
-          puts "    perform_hierarchical_and: depth_a=#{depth_a}, depth_b=#{depth_b}" if ENV["DEBUG_CASCADE"]
-
-          if depth_a > depth_b
-            # a is deeper (child level), b is shallower (parent level)
-            # Broadcast b values to match a's structure - PRESERVE a's structure
-            puts "    -> Broadcasting b (parent) to match a (child) structure" if ENV["DEBUG_CASCADE"]
-            broadcast_parent_to_child_structure(a, b)
-          else
-            # b is deeper (child level), a is shallower (parent level)
-            # Broadcast a values to match b's structure - PRESERVE b's structure
-            puts "    -> Broadcasting a (parent) to match b (child) structure" if ENV["DEBUG_CASCADE"]
-            broadcast_parent_to_child_structure(b, a)
-          end
-        end
-
-        def self.broadcast_parent_to_child_structure(child_array, parent_array)
-          # Broadcast parent array values to match child array structure, preserving child structure
-          if ENV["DEBUG_CASCADE"]
-            puts "      broadcast_parent_to_child_structure:"
-            puts "        child_array: #{child_array.inspect}"
-            puts "        parent_array: #{parent_array.inspect}"
-            puts "        child depth: #{array_depth(child_array)}, parent depth: #{array_depth(parent_array)}"
-          end
-
-          # Use child array structure as template and broadcast parent values
-          map_with_parent_broadcasting(child_array, parent_array, [])
-        end
-
-        def self.map_with_parent_broadcasting(child_structure, parent_structure, indices)
-          if child_structure.is_a?(Array)
-            child_structure.map.with_index do |child_elem, index|
-              new_indices = indices + [index]
-
-              # Navigate parent structure with fewer indices (broadcasting)
-              parent_depth = array_depth(parent_structure)
-              parent_indices = new_indices[0, parent_depth]
-              parent_value = navigate_indices(parent_structure, parent_indices)
-
-              if child_elem.is_a?(Array)
-                # Recurse deeper into child structure
-                map_with_parent_broadcasting(child_elem, parent_structure, new_indices)
-              else
-                # Leaf level - apply AND operation
-                result = child_elem && parent_value
-                if ENV["DEBUG_CASCADE"]
-                  puts "          Leaf: child=#{child_elem}, parent=#{parent_value} (indices #{new_indices.inspect}) -> #{result}"
-                end
-                result
-              end
-            end
-          else
-            # Non-array child - just AND with parent
-            child_structure && parent_structure
-          end
-        end
-
-        def self.navigate_indices(structure, indices)
-          return structure if indices.empty?
-          return structure unless structure.is_a?(Array)
-          return nil if indices.first >= structure.length
-
-          navigate_indices(structure[indices.first], indices[1..])
-        end
-
-        def self.broadcast_to_match_structure(child_array, parent_array)
-          # Legacy method - keeping for backward compatibility
-          if ENV["DEBUG_CASCADE"]
-            puts "      broadcast_to_match_structure (LEGACY):"
-            puts "        child_array: #{child_array.inspect}"
-            puts "        parent_array: #{parent_array.inspect}"
-            puts "        child_array.length: #{child_array.length}"
-            puts "        parent_array.length: #{parent_array.length}"
-          end
-
-          result = child_array.zip(parent_array).map do |child_elem, parent_elem|
-            puts "        Combining child_elem: #{child_elem.inspect} with parent_elem: #{parent_elem.inspect}" if ENV["DEBUG_CASCADE"]
-            element_wise_and(child_elem, parent_elem)
-          end
-
-          puts "        broadcast result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
-          result
-        end
-
-        def self.definitions
-          {
-            # Basic logical operations
-            and: FunctionBuilder::Entry.new(
-              fn: ->(*conditions) { conditions.all? },
-              arity: -1,
-              param_types: [:boolean],
-              return_type: :boolean,
-              description: "Logical AND of multiple conditions"
-            ),
-
-            or: FunctionBuilder::Entry.new(
-              fn: ->(*conditions) { conditions.any? },
-              arity: -1,
-              param_types: [:boolean],
-              return_type: :boolean,
-              description: "Logical OR of multiple conditions"
-            ),
-
-            not: FunctionBuilder::Entry.new(
-              fn: lambda(&:!),
-              arity: 1,
-              param_types: [:boolean],
-              return_type: :boolean,
-              description: "Logical NOT"
-            ),
-
-            # Collection logical operations
-            all?: FunctionBuilder.collection_unary(:all?, "Check if all elements in collection are truthy", :all?, reducer: true),
-            any?: FunctionBuilder.collection_unary(:any?, "Check if any element in collection is truthy", :any?, reducer: true),
-            none?: FunctionBuilder.collection_unary(:none?, "Check if no elements in collection are truthy", :none?, reducer: true),
-
-            # Element-wise AND for cascades - works on arrays with same structure
-            cascade_and: FunctionBuilder::Entry.new(
-              fn: lambda do |*conditions|
-                if ENV["DEBUG_CASCADE"]
-                  puts "DEBUG cascade_and called with #{conditions.length} conditions:"
-                  conditions.each_with_index do |cond, i|
-                    puts "  condition[#{i}]: #{cond.inspect}"
-                  end
-                end
-
-                return false if conditions.empty?
-
-                # Always process uniformly, even for single conditions
-                # This ensures DeclarationReferences are evaluated properly
-                result = conditions.first
-                conditions[1..].each_with_index do |condition, i|
-                  puts "  Combining result with condition[#{i + 1}]" if ENV["DEBUG_CASCADE"]
-                  result = LogicalFunctions.element_wise_and(result, condition)
-                  puts "  Result after combining: #{result.inspect}" if ENV["DEBUG_CASCADE"]
-                end
-
-                puts "  Final cascade_and result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
-                result
-              end,
-              arity: -1,
-              param_types: [:boolean],
-              return_type: :boolean,
-              description: "Element-wise AND for arrays with same nested structure"
-            )
-          }
-        end
-      end
-    end
-  end
-end

data/lib/kumi/core/function_registry/math_functions.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      # Mathematical operations
-      module MathFunctions
-        def self.definitions
-          {
-            # Basic arithmetic
-            add: FunctionBuilder.math_binary(:add, "Add two numbers", :+),
-            subtract: FunctionBuilder.math_binary(:subtract, "Subtract second number from first", :-),
-            multiply: FunctionBuilder.math_binary(:multiply, "Multiply two numbers", :*),
-            divide: FunctionBuilder.math_binary(:divide, "Divide first number by second", :/),
-            modulo: FunctionBuilder.math_binary(:modulo, "Modulo operation", :%),
-            power: FunctionBuilder.math_binary(:power, "Raise first number to power of second", :**),
-
-            # Unary operations
-            abs: FunctionBuilder.math_unary(:abs, "Absolute value", :abs),
-            floor: FunctionBuilder.math_unary(:floor, "Floor of number", :floor, return_type: :integer),
-            ceil: FunctionBuilder.math_unary(:ceil, "Ceiling of number", :ceil, return_type: :integer),
-
-            # Special operations
-            round: FunctionBuilder::Entry.new(
-              fn: ->(a, precision = 0) { a.round(precision) },
-              arity: -1,
-              param_types: [:float],
-              return_type: :float,
-              description: "Round number to specified precision"
-            ),
-
-            clamp: FunctionBuilder::Entry.new(
-              fn: ->(value, min, max) { value.clamp(min, max) },
-              arity: 3,
-              param_types: %i[float float float],
-              return_type: :float,
-              description: "Clamp value between min and max"
-            ),
-            piecewise_sum: FunctionBuilder::Entry.new(
-              # Tiered / piece‑wise accumulator ­­­­­­­­­­­­­­­­­­­­­­­­­
-              fn: lambda do |value, breaks, rates|
-                raise ArgumentError, "breaks & rates size mismatch" unless breaks.size == rates.size
-
-                acc      = 0.0
-                previous = 0.0
-                marginal = rates.last
-
-                breaks.zip(rates).each do |upper, rate|
-                  if value <= upper
-                    marginal = rate
-                    acc += (value - previous) * rate
-                    break
-                  else
-                    acc += (upper - previous) * rate
-                    previous = upper
-                  end
-                end
-                [acc, marginal] # => [sum, marginal_rate]
-              end,
-              arity: 3,
-              param_types: [
-                :float,
-                Kumi::Core::Types.array(:float),                   # breaks
-                Kumi::Core::Types.array(:float)                    # rates
-              ],
-              return_type: Kumi::Core::Types.array(:float),        # 2‑element [sum, marginal]
-              description: "Accumulate over tiered ranges; returns [sum, marginal_rate]"
-            )
-          }
-        end
-      end
-    end
-  end
-end

data/lib/kumi/core/function_registry/stat_functions.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      module StatFunctions
-        def self.definitions
-          {
-            # Statistical Functions
-            avg: FunctionBuilder::Entry.new(
-              fn: ->(array) { array.empty? ? nil : array.sum.to_f / array.size },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Calculate arithmetic mean (average) of numeric collection",
-              reducer: true
-            ),
-
-            mean: FunctionBuilder::Entry.new(
-              fn: ->(array) { array.empty? ? nil : array.sum.to_f / array.size },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Calculate arithmetic mean (average) of numeric collection (alias for avg)",
-              reducer: true
-            ),
-
-            median: FunctionBuilder::Entry.new(
-              fn: lambda do |array|
-                sorted = array.sort
-                len = sorted.length
-                if len.odd?
-                  sorted[len / 2]
-                else
-                  (sorted[(len / 2) - 1] + sorted[len / 2]) / 2.0
-                end
-              end,
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Calculate median (middle value) of numeric collection",
-              reducer: true
-            ),
-
-            variance: FunctionBuilder::Entry.new(
-              fn: lambda do |array|
-                mean = array.sum.to_f / array.size
-                sum_of_squares = array.sum { |x| (x - mean)**2 }
-                sum_of_squares / array.size
-              end,
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Calculate population variance of numeric collection",
-              reducer: true
-            ),
-
-            stdev: FunctionBuilder::Entry.new(
-              fn: lambda do |array|
-                mean = array.sum.to_f / array.size
-                sum_of_squares = array.sum { |x| (x - mean)**2 }
-                variance = sum_of_squares / array.size
-                Math.sqrt(variance)
-              end,
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Calculate population standard deviation of numeric collection",
-              reducer: true
-            ),
-
-            sample_variance: FunctionBuilder::Entry.new(
-              fn: lambda do |array|
-                return 0.0 if array.size <= 1
-
-                mean = array.sum.to_f / array.size
-                sum_of_squares = array.sum { |x| (x - mean)**2 }
-                sum_of_squares / (array.size - 1)
-              end,
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Calculate sample variance of numeric collection",
-              reducer: true
-            ),
-
-            sample_stdev: FunctionBuilder::Entry.new(
-              fn: lambda do |array|
-                return 0.0 if array.size <= 1
-
-                mean = array.sum.to_f / array.size
-                sum_of_squares = array.sum { |x| (x - mean)**2 }
-                variance = sum_of_squares / (array.size - 1)
-                Math.sqrt(variance)
-              end,
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Calculate sample standard deviation of numeric collection",
-              reducer: true
-            ),
-
-            # Convenience functions for flattened statistics
-            flat_size: FunctionBuilder::Entry.new(
-              fn: ->(nested_array) { nested_array.flatten.size },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: :integer,
-              description: "Count total elements across all nested levels",
-              reducer: true
-            ),
-
-            flat_sum: FunctionBuilder::Entry.new(
-              fn: ->(nested_array) { nested_array.flatten.sum },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Sum all numeric elements across all nested levels",
-              reducer: true
-            ),
-
-            flat_avg: FunctionBuilder::Entry.new(
-              fn: lambda do |nested_array|
-                flattened = nested_array.flatten
-                flattened.sum.to_f / flattened.size
-              end,
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Calculate average across all nested levels",
-              reducer: true
-            ),
-
-            flat_max: FunctionBuilder::Entry.new(
-              fn: ->(nested_array) { nested_array.flatten.max },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Find maximum value across all nested levels",
-              reducer: true
-            ),
-
-            flat_min: FunctionBuilder::Entry.new(
-              fn: ->(nested_array) { nested_array.flatten.min },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Find minimum value across all nested levels",
-              reducer: true
-            )
-          }
-        end
-      end
-    end
-  end
-end

data/lib/kumi/core/function_registry/string_functions.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      # String manipulation functions
-      module StringFunctions
-        def self.definitions
-          {
-            # String transformations
-            upcase: FunctionBuilder.string_unary(:upcase, "Convert string to uppercase", :upcase),
-            downcase: FunctionBuilder.string_unary(:downcase, "Convert string to lowercase", :downcase),
-            capitalize: FunctionBuilder.string_unary(:capitalize, "Capitalize first letter of string", :capitalize),
-            strip: FunctionBuilder.string_unary(:strip, "Remove leading and trailing whitespace", :strip),
-
-            # String queries
-            string_length: FunctionBuilder::Entry.new(
-              fn: ->(str) { str.to_s.length },
-              arity: 1,
-              param_types: [:string],
-              return_type: :integer,
-              description: "Get string length"
-            ),
-
-            # Keep the original length for backward compatibility, but it will be overridden
-            length: FunctionBuilder::Entry.new(
-              fn: ->(str) { str.to_s.length },
-              arity: 1,
-              param_types: [:string],
-              return_type: :integer,
-              description: "Get string length"
-            ),
-
-            # String inclusion using different name to avoid conflict with collection include?
-            string_include?: FunctionBuilder.string_binary(:include?, "Check if string contains substring", :include?,
-                                                           return_type: :boolean),
-            includes?: FunctionBuilder.string_binary(:include?, "Check if string contains substring", :include?, return_type: :boolean),
-            contains?: FunctionBuilder.string_binary(:include?, "Check if string contains substring", :include?, return_type: :boolean),
-
-            start_with?: FunctionBuilder.string_binary(:start_with?, "Check if string starts with prefix", :start_with?,
-                                                       return_type: :boolean),
-            end_with?: FunctionBuilder.string_binary(:end_with?, "Check if string ends with suffix", :end_with?, return_type: :boolean),
-
-            # String building
-            concat: FunctionBuilder::Entry.new(
-              fn: ->(*strings) { strings.join },
-              arity: -1,
-              param_types: [:string],
-              return_type: :string,
-              description: "Concatenate multiple strings"
-            )
-          }
-        end
-      end
-    end
-  end
-end

data/lib/kumi/core/function_registry/type_functions.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      # Type checking and conversion functions
-      module TypeFunctions
-        def self.definitions
-          {
-            fetch: FunctionBuilder::Entry.new(
-              fn: ->(hash, key, default = nil) { hash.fetch(key, default) },
-              arity: -1, # Variable arity (2 or 3)
-              param_types: [Kumi::Core::Types.hash(:any, :any), :any, :any],
-              return_type: :any,
-              description: "Fetch value from hash with optional default"
-            ),
-
-            has_key?: FunctionBuilder::Entry.new(
-              fn: ->(hash, key) { hash.key?(key) },
-              arity: 2,
-              param_types: [Kumi::Core::Types.hash(:any, :any), :any],
-              return_type: :boolean,
-              description: "Check if hash has the given key"
-            ),
-
-            keys: FunctionBuilder::Entry.new(
-              fn: lambda(&:keys),
-              arity: 1,
-              param_types: [Kumi::Core::Types.hash(:any, :any)],
-              return_type: Kumi::Core::Types.array(:any),
-              description: "Get all keys from hash"
-            ),
-
-            values: FunctionBuilder::Entry.new(
-              fn: lambda(&:values),
-              arity: 1,
-              param_types: [Kumi::Core::Types.hash(:any, :any)],
-              return_type: Kumi::Core::Types.array(:any),
-              description: "Get all values from hash"
-            ),
-            at: FunctionBuilder::Entry.new(
-              fn: ->(array, index) { array[index] },
-              arity: 2,
-              param_types: [Kumi::Core::Types.array(:any), :integer],
-              return_type: :any,
-              description: "Get element at index from array"
-            )
-          }
-        end
-      end
-    end
-  end
-end