kumi 0.0.29 → 0.0.30

data/examples/federal_tax_calculator_2024.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-# U.S. federal income‑tax plus FICA
-
-require_relative "../lib/kumi"
-
-module Tax2024
-  FED_BREAKS_SINGLE   = [11_600, 47_150, 100_525, 191_950,
-                         243_725, 609_350, Float::INFINITY].freeze
-
-  FED_BREAKS_MARRIED  = [23_200, 94_300, 201_050, 383_900,
-                         487_450, 731_200, Float::INFINITY].freeze
-
-  FED_BREAKS_SEPARATE = [11_600, 47_150, 100_525, 191_950,
-                         243_725, 365_600, Float::INFINITY].freeze
-
-  FED_BREAKS_HOH      = [16_550, 63_100, 100_500, 191_950,
-                         243_700, 609_350, Float::INFINITY].freeze
-
-  FED_RATES           = [0.10, 0.12, 0.22, 0.24,
-                         0.32, 0.35, 0.37].freeze
-end
-
-module FederalTaxCalculator
-  extend Kumi::Schema
-  include Tax2024
-
-  schema do
-    input do
-      float  :income
-      string :filing_status, domain: %w[single married_joint married_separate head_of_household]
-    end
-
-    # ── standard deduction table ───────────────────────────────────────
-    trait :single,     input.filing_status == "single"
-    trait :married,    input.filing_status == "married_joint"
-    trait :separate,   input.filing_status == "married_separate"
-    trait :hoh,        input.filing_status == "head_of_household"
-
-    value :std_deduction do
-      on  single,   14_600
-      on  married,  29_200
-      on  separate, 14_600
-      base           21_900 # HOH default
-    end
-
-    value :taxable_income, [input.income - std_deduction, 0].max
-
-    value :fed_breaks do
-      on  single,   FED_BREAKS_SINGLE
-      on  married,  FED_BREAKS_MARRIED
-      on  separate, FED_BREAKS_SEPARATE
-      on  hoh,      FED_BREAKS_HOH
-    end
-
-    value :fed_rates, FED_RATES
-    value :fed_calc,
-          fn(:piecewise_sum, taxable_income, fed_breaks, fed_rates)
-
-    value :fed_tax,       fed_calc[0]
-    value :fed_marginal,  fed_calc[1]
-    value :fed_eff,       fed_tax / [input.income, 1.0].max
-
-    # ── FICA (employee share) ─────────────────────────────────────────────
-    value :ss_wage_base, 168_600.0
-    value :ss_rate,      0.062
-
-    value :med_base_rate, 0.0145
-    value :addl_med_rate, 0.009
-
-    # additional‑Medicare threshold depends on filing status
-    value :addl_threshold do
-      on  single,   200_000
-      on  married,  250_000
-      on  separate, 125_000
-      base           200_000 # HOH same as single
-    end
-
-    # social‑security portion (capped)
-    value :ss_tax, [input.income, ss_wage_base].min * ss_rate
-
-    # medicare (1.45 % on everything)
-    value :med_tax, input.income * med_base_rate
-
-    # additional medicare on income above threshold
-    value :addl_med_tax, [input.income - addl_threshold, 0].max * addl_med_rate
-
-    value :fica_tax,  ss_tax + med_tax + addl_med_tax
-    value :fica_eff,  fica_tax / [input.income, 1.0].max
-
-    # ── Totals ─────────────────────────────────────────────────────────
-    value :total_tax, fed_tax + fica_tax
-
-    value :total_eff, total_tax / fn(:max, [input.income, 1.0])
-    value :after_tax, input.income - total_tax
-  end
-end
-
-def print_tax_summary(args)
-  r = FederalTaxCalculator.from(args)
-  puts "\n=== 2024 U.S. Income‑Tax Example ==="
-  printf "Income:                      $%0.2f\n", args[:income]
-  puts   "Filing status:               #{args[:filing_status]}\n\n"
-
-  puts "Federal tax:             $#{r[:fed_tax].round(2)} (#{(r[:fed_eff] * 100).round(2)}% effective)"
-  puts "FICA tax:                $#{r[:fica_tax].round(2)} (#{(r[:fica_eff] * 100).round(2)}% effective)"
-  puts "Total tax:               $#{r[:total_tax].round(2)} (#{(r[:total_eff] * 100).round(2)}% effective)"
-  puts "After-tax income:        $#{r[:after_tax].round(2)}"
-end
-
-
-input = {  income: 1_000_000,
-  filing_status: "single"
-}
-print_tax_summary(input)

data/examples/game_of_life.rb

@@ -1,95 +0,0 @@
-require "kumi"
-
-begin
-  # in a block so we dont define this globally
-  def neighbor_cells_sum_method(cells, row, col, height, width)
-    # Calculate neighbor indices with wraparound
-    [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]].map do |dr, dc|
-      neighbor_row = (row + dr) % height
-      neighbor_col = (col + dc) % width
-      neighbor_index = (neighbor_row * width) + neighbor_col
-      cells[neighbor_index]
-    end.sum
-  end
-  Kumi::Registry.register_with_metadata(:neighbor_cells_sum, method(:neighbor_cells_sum_method),
-                                                return_type: :integer, arity: 5,
-                                                param_types: %i[array integer integer integer integer],
-                                                description: "Get neighbor cells for Conway's Game of Life")
-end
-
-module GameOfLife
-  extend Kumi::Schema
-  WIDTH = 50
-  HEIGHT = 30
-
-  schema do
-    # Complete Game of Life engine - computes entire next generation
-    input do
-      array :cells, elem: { type: :integer }
-    end
-
-    # Generate next state for every cell in the grid
-    next_cell_values = []
-
-    (0...HEIGHT).each do |row|
-      (0...WIDTH).each do |col|
-        # Neighbor count and current state for this cell
-        cell_index = (row * WIDTH) + col
-        value :"neighbor_sum_#{cell_index}", fn(:neighbor_cells_sum, input.cells, row, col, HEIGHT, WIDTH)
-
-        # Game of Life rules: (alive && neighbors == 2) || (neighbors == 3)
-        trait :"cell_#{cell_index}_alive",
-              ((input.cells[cell_index] == 1) & (ref(:"neighbor_sum_#{cell_index}") == 2)) |
-              (ref(:"neighbor_sum_#{cell_index}") == 3)
-
-        # Next state for this cell
-        value :"cell_#{cell_index}_next" do
-          on :"cell_#{cell_index}_alive", 1
-          base 0
-        end
-
-        next_cell_values << ref(:"cell_#{cell_index}_next")
-      end
-    end
-
-    # Complete next generation as array
-    value :next_cells, next_cell_values
-
-    # Render current state as visual string
-    value :cell_symbols, fn(:map_conditional, input.cells, 1, "█", " ")
-    value :grid_rows, fn(:each_slice, cell_symbols, WIDTH)
-    value :rendered_grid, fn(:map_join_rows, grid_rows, "", "\n")
-  end
-end
-
-# # Helper to pretty‑print the grid
-def render(cells, width)
-  cells.each_slice(width) do |row|
-    puts row.map { |v| v == 1 ? "█" : " " }.join
-  end
-end
-
-# # Bootstrap a simple glider on a 10×10 grid
-width  = GameOfLife::WIDTH
-height = GameOfLife::HEIGHT
-cells  = Array.new(width * height, 0)
-# Glider pattern
-[[1, 1], [2, 3], [3, 1], [3, 2], [3, 3]].each { |r, c| cells[(r * width) + c] = 1 }
-
-10_000.times do |gen|
-  system("clear") || system("cls")
-  puts "Conway's Game of Life - Generation #{gen}"
-  puts ""
-
-  # Create schema instance for this generation
-  runner = GameOfLife.from(cells: cells)
-
-  # Render using Kumi instead of Ruby function!
-  rendered_output = runner[:rendered_grid]
-  puts rendered_output
-
-  # Calculate next generation with single schema call!
-  cells = runner[:next_cells]
-
-  sleep 0.1
-end