keisanjaku 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 58531155e91da64cf07fa9ad169ffee269730111d701b934a278299038881ca2
+  data.tar.gz: 027372ea33da151f6fe8b7e2f7565f5d76dd8fa060eb8f17514661f22dad730d
+SHA512:
+  metadata.gz: 619c4bbc53e672ca79d717cc148bd134d833361eda0502104e9577c8f2b09a3b21b2b21e56821d354407d95e0b1efda1a5796f093854d0a43db7f520251ae3ea
+  data.tar.gz: 7e61d7255ae0af07d6414b1dbdb0a31d1870c02ae207caba7b93305f87bcc2b68293eac7fa9b9d738a7ad0a57a3ebc12e3346c53eebc8878a939548d6f7cfc5a

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+# keisanjaku
+
+`keisanjaku` is a terminal slide rule simulator. It runs on Ruby's standard
+library only and provides ANSI text rendering, an interactive sandbox, expression
+demos, and drill practice.
+
+## Requirements
+
+- Ruby 3.x or later
+- A terminal with at least 100 columns is recommended
+- No external gems are required
+
+## Usage
+
+```sh
+exe/keisanjaku --version
+exe/keisanjaku --render-only --slide=0.3 --cursor=0.477 --width=100
+exe/keisanjaku --no-anim --demo='2*3'
+exe/keisanjaku --sandbox
+exe/keisanjaku --drill --tolerance=1.0
+```
+
+## Installation
+
+Build and install the gem locally:
+
+```sh
+gem build keisanjaku.gemspec
+gem install keisanjaku-0.1.0.gem
+```
+
+Publish to RubyGems after signing in with `gem signin`:
+
+```sh
+gem push keisanjaku-0.1.0.gem
+```
+
+In interactive modes, omitting `--width=N` makes the display follow the current
+terminal width. Unix-like terminals use `SIGWINCH`; Windows terminals use a
+polling fallback. Use `NO_COLOR=1` or `--no-color` for plain monochrome output.
+
+The expression parser accepts:
+
+- Multiplication: `2*3` or `2×3`
+- Division: `6/2` or `6÷2`
+- Powers: `2^2`, `2^3`
+- Functions: `sqrt(2)`, `cbrt(8)`, `log(2)`, `sin(30)`, `cos(60)`, `tan(30)`
+
+## Example Output
+
+```text
+      +--------------------------------------------------------------------------------------------+
+     K||      |   |  |   || || | |      |   |   |  | | | | ||      |    |  |  | | || || | | ||
+      |1      2   3  4   56 78 9 1      2   3   4  5 6 7 891      2    3  4  5 6 78 9 1 |
+     A||          |     |    |   |   | |  | | | |          |     |    |   |  |  | | | | ||
+      |1          2     3    4   5   6 7  8 9 1          2     3    4   5  6  7 8 9 1 |
+      +--------------------------------------------------------------------------------------------+
+     B|........................|.............|........|.....|....|...|..|..|.|.....................|
+      |........................1.............2........3.....4....5...6..7..8.9.....................|
+    CI|........................|...|..:..|.:.|..:..|...|....:....|.....:......|...........:........|
+      |........................1...9.....8...7.....6...5.........4............3....................|
+     C|........................|....................|............:........|.......:.....|....:...|.|
+      |........................1....................2....................3.............4............|
+      +--------------------------------------------------------------------------------------------+
+     D||            :       |         :       |      :    |   :    |  :  |  : |  : | :  | : | : ||
+      |1                    2                 3           4        5     6     7    8    9      1|
+     L||        |        |        |        |        |        |        |        |        |        ||
+      |0       .1       .2       .3       .4       .5       .6       .7       .8       .9        1|
+      +--------------------------------------------------------------------------------------------+
+cursor=0.4770 slide=+0.3000 face=front K=26.977 A=8.995 B=2.2594 CI=6.6527 C=1.5 D=2.9997 L=0.477
+```
+
+## Controls
+
+Sandbox:
+
+- `h` / `l`: move the slide left or right in coarse steps
+- `H` / `L`, or `,` / `.`: move the slide in fine steps
+- `c` / `j` / `k`: switch arrow-key control between the cursor and slide
+- `Left` / `Right`: move the selected target
+- `Tab`: flip between the front and back slide faces
+- `?`: toggle the value readout
+- `r`: reset
+- `q`: quit
+
+Drill:
+
+- Choose the problem range at startup, for example `multiply,sin`
+- Press `Enter` or `o` for the slide-rule workspace and answer entry
+- Type a numeric answer in the workspace and press `Enter` to submit it
+- `g`: show the worked demo
+- `s`: skip the workspace and answer as plain text
+- Correct answers report whether the exact operation sequence matched the model
+  steps, including scale, value, and side information such as `MOVE_CURSOR(D, 2)`
+
+Demo:
+
+- `Enter` / `Space`: advance one step
+- `b`: go back one step
+- `a`: toggle autoplay
+- `1` / `2` / `3`: change autoplay speed
+- `q`: quit
+
+## Principle
+
+The C and D scales are modeled with positions based on `log10(x)`.
+Multiplication is addition of distances: align the C scale index with a value on
+the D scale, move the cursor to the other factor on the C scale, and read the
+mantissa of the product on the D scale.
+
+When the result would fall outside the frame, use the opposite slide index to
+wrap the operation. A slide rule reads mantissas, so the final power-of-ten place
+must be determined separately. Demo mode prints that place-value explanation at
+the end.
+
+## Tests
+
+```sh
+bundle install
+rake test
+ruby -w -Ilib -rkeisanjaku -e 'puts Keisanjaku::VERSION'
+```
+
+## License
+
+MIT. See [LICENSE.txt](LICENSE.txt).

data/exe/keisanjaku

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "keisanjaku/app"
+
+exit Keisanjaku::App.new(ARGV).run

data/lib/keisanjaku/ansi.rb

@@ -0,0 +1,79 @@
+module Keisanjaku
+  module ANSI
+    module_function
+
+    CODES = {
+      reset: 0,
+      red: 31,
+      yellow: 33,
+      cyan_bg: 46,
+      bold: 1
+    }.freeze
+    AMBIGUOUS_WIDE_CHARS = "×÷±−√°·".chars.freeze
+
+    def enabled?(color)
+      color && ENV["NO_COLOR"].nil?
+    end
+
+    def paint(text, *styles, color: true)
+      return text unless enabled?(color)
+
+      codes = styles.map { |style| CODES.fetch(style) }.join(";")
+      "\e[#{codes}m#{text}\e[0m"
+    end
+
+    def clear_screen
+      "\e[2J\e[H"
+    end
+
+    def hide_cursor
+      "\e[?25l"
+    end
+
+    def show_cursor
+      "\e[?25h"
+    end
+
+    def strip(text)
+      text.gsub(/\e\[[0-9;?]*[A-Za-z]/, "")
+    end
+
+    def visible_width(text)
+      strip(text).each_char.sum { |char| wide?(char) ? 2 : 1 }
+    end
+
+    def fit(text, width)
+      stripped_width = visible_width(text)
+      return text + (" " * (width - stripped_width)) if stripped_width < width
+      return text if stripped_width == width
+
+      truncate(text, width)
+    end
+
+    def truncate(text, width)
+      output = +""
+      used = 0
+      strip(text).each_char do |char|
+        char_width = wide?(char) ? 2 : 1
+        break if used + char_width > width
+
+        output << char
+        used += char_width
+      end
+      output << (" " * (width - used))
+    end
+
+    def wide?(char)
+      code = char.ord
+      (0x1100..0x115F).cover?(code) ||
+        (0x2E80..0xA4CF).cover?(code) ||
+        (0xAC00..0xD7A3).cover?(code) ||
+        (0xF900..0xFAFF).cover?(code) ||
+        (0xFE10..0xFE19).cover?(code) ||
+      (0xFE30..0xFE6F).cover?(code) ||
+        (0xFF00..0xFF60).cover?(code) ||
+        (0xFFE0..0xFFE6).cover?(code) ||
+        AMBIGUOUS_WIDE_CHARS.include?(char)
+    end
+  end
+end

data/lib/keisanjaku/app.rb

@@ -0,0 +1,144 @@
+require "optparse"
+require "io/console"
+require_relative "version"
+require_relative "renderer"
+require_relative "parser"
+require_relative "planner"
+require_relative "engine"
+require_relative "terminal_viewport"
+require_relative "modes/sandbox"
+require_relative "modes/demo"
+require_relative "modes/drill"
+
+module Keisanjaku
+  class App
+    def initialize(argv, input: $stdin, output: $stdout, error: $stderr)
+      @argv = argv.dup
+      @input = input
+      @output = output
+      @error = error
+      @options = {
+        color: ENV["NO_COLOR"].nil?,
+        animate: true,
+        width: nil,
+        tolerance: 1.0,
+        slide: 0.0,
+        cursor: 0.0,
+        face: :front
+      }
+    end
+
+    def run
+      parse_options
+      return print_version if @options[:version]
+      return render_only if @options[:render_only]
+      return key_test if @options[:key_test]
+      return run_demo(@options[:demo]) if @options[:demo]
+      return run_drill if @options[:drill]
+      return run_sandbox if @options[:sandbox]
+
+      expression = @argv.join(" ").strip
+      return run_demo(expression) unless expression.empty?
+
+      run_menu
+    rescue ParseError, ScaleError, OptionParser::ParseError => e
+      @error.puts "keisanjaku: #{e.message}"
+      1
+    end
+
+    private
+
+    def parse_options
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: keisanjaku [options] [expression]"
+        opts.on("--version", "Print version") { @options[:version] = true }
+        opts.on("--no-color", "Disable ANSI colors") { @options[:color] = false }
+        opts.on("--no-anim", "Disable animation") { @options[:animate] = false }
+        opts.on("--width=N", Integer, "Render width") { |value| @options[:width] = value }
+        opts.on("--tolerance=X", Float, "Drill tolerance percent") { |value| @options[:tolerance] = value }
+        opts.on("--render-only", "Render one frame and exit") { @options[:render_only] = true }
+        opts.on("--slide=X", Float, "Initial slide offset") { |value| @options[:slide] = value }
+        opts.on("--cursor=X", Float, "Initial cursor position") { |value| @options[:cursor] = value }
+        opts.on("--face=FACE", "front or back") { |value| @options[:face] = value.to_sym }
+        opts.on("--key-test", "Print decoded key names") { @options[:key_test] = true }
+        opts.on("--demo=EXPR", "Run demo for expression") { |value| @options[:demo] = value }
+        opts.on("--sandbox", "Start sandbox mode") { @options[:sandbox] = true }
+        opts.on("--drill", "Start drill mode") { @options[:drill] = true }
+      end
+      parser.parse!(@argv)
+    end
+
+    def print_version
+      @output.puts "keisanjaku #{VERSION}"
+      0
+    end
+
+    def render_only
+      state = RuleState.new(slide: @options[:slide], cursor: @options[:cursor], face: @options[:face])
+      Renderer.render(state, width: @options[:width] || terminal_width, color: @options[:color]).each { |line| @output.puts line }
+      0
+    end
+
+    def key_test
+      reader = Input.new(@input)
+      Input.with_raw(input: @input, output: @output) do
+        loop do
+          key = reader.read_key
+          Input.raw_puts(@output, key.inspect)
+          break if key == "q" || key == :ctrl_c
+        end
+      end
+      0
+    end
+
+    def run_demo(expression)
+      mode = Modes::Demo.new(expression, width: @options[:width], color: @options[:color], animate: @options[:animate], output: @output)
+      if @input.tty? && @options[:animate]
+        mode.run_interactive(input: @input)
+      else
+        mode.run_noninteractive
+      end
+      0
+    end
+
+    def run_sandbox
+      Modes::Sandbox.new(width: @options[:width], color: @options[:color], output: @output).run(input: @input)
+      0
+    end
+
+    def run_drill
+      Modes::Drill.new(
+        width: @options[:width],
+        color: @options[:color],
+        tolerance_percent: @options[:tolerance],
+        output: @output
+      ).run(input: @input)
+      0
+    end
+
+    def run_menu
+      return run_sandbox unless @input.tty?
+
+      @output.puts "keisanjaku"
+      @output.puts "1 Sandbox"
+      @output.puts "2 Demo"
+      @output.puts "3 Drill"
+      @output.print "> "
+      choice = @input.gets&.strip
+      case choice
+      when "1" then run_sandbox
+      when "2"
+        @output.print "expr> "
+        run_demo(@input.gets&.strip.to_s)
+      when "3" then run_drill
+      else 0
+      end
+    end
+
+    def terminal_width
+      IO.console&.winsize&.last || Renderer::DEFAULT_WIDTH
+    rescue StandardError
+      Renderer::DEFAULT_WIDTH
+    end
+  end
+end

data/lib/keisanjaku/drill.rb

@@ -0,0 +1,118 @@
+require_relative "ansi"
+require_relative "parser"
+require_relative "planner"
+require_relative "procedure"
+
+module Keisanjaku
+  Question = Struct.new(:expression, :prompt, :true_value, :operation, keyword_init: true)
+
+  class QuestionGenerator
+    OPERATIONS = %i[multiply divide square cube sqrt log sin tan].freeze
+
+    def initialize(random: Random.new)
+      @random = random
+    end
+
+    def next_question(operation: OPERATIONS.sample(random: @random))
+      operation = operation.to_sym
+      raise ArgumentError, "unknown operation: #{operation}" unless OPERATIONS.include?(operation)
+
+      case operation
+      when :multiply
+        a = sample_mantissa
+        b = sample_mantissa
+        build("#{a}×#{b}", "#{a} × #{b} を求めよ", operation)
+      when :divide
+        a = sample_mantissa
+        b = sample_mantissa
+        build("#{a}÷#{b}", "#{a} ÷ #{b} を求めよ", operation)
+      when :square
+        a = sample_mantissa(max: 9.0)
+        build("#{a}^2", "#{a} の二乗を求めよ", operation)
+      when :cube
+        a = sample_mantissa(max: 9.0)
+        build("#{a}^3", "#{a} の三乗を求めよ", operation)
+      when :sqrt
+        a = sample_mantissa(max: 9.0)
+        build("sqrt(#{a})", "#{a} の平方根を求めよ", operation)
+      when :log
+        a = sample_mantissa
+        build("log(#{a})", "#{a} の常用対数を求めよ", operation)
+      when :sin
+        angle = @random.rand(6..89)
+        build("sin(#{angle})", "sin(#{angle}) を求めよ", operation)
+      when :tan
+        angle = @random.rand(6..45)
+        build("tan(#{angle})", "tan(#{angle}) を求めよ", operation)
+      else
+        raise ArgumentError, "unknown operation: #{operation}"
+      end
+    end
+
+    private
+
+    def build(expression, prompt, operation)
+      ast = Parser.parse(expression)
+      plan = Planner.compile(ast, expression: expression)
+      Question.new(expression: expression, prompt: prompt, true_value: plan.true_value, operation: operation)
+    end
+
+    def sample_mantissa(max: 9.9)
+      (@random.rand(10..(max * 10).floor) / 10.0).round(1)
+    end
+  end
+
+  class Judge
+    def initialize(tolerance_percent: 1.0)
+      @tolerance_percent = Float(tolerance_percent)
+    end
+
+    def correct?(answer, true_value)
+      relative_error_percent(answer, true_value).abs <= @tolerance_percent + 1e-12
+    end
+
+    def relative_error_percent(answer, true_value)
+      ((Float(answer) - Float(true_value)) / Float(true_value)) * 100.0
+    end
+  end
+
+  class OperationSelector
+    LABELS = {
+      multiply: "乗算",
+      divide: "除算",
+      square: "二乗",
+      cube: "三乗",
+      sqrt: "平方根",
+      log: "対数",
+      sin: "正弦",
+      tan: "正接"
+    }.freeze
+
+    def self.parse(selection)
+      text = selection.to_s.strip
+      return QuestionGenerator::OPERATIONS if text.empty? || text == "all"
+
+      operations = text.split(/[,\s]+/).filter_map do |token|
+        operation = token.to_sym
+        operation if QuestionGenerator::OPERATIONS.include?(operation)
+      end
+      operations.empty? ? QuestionGenerator::OPERATIONS : operations.uniq
+    end
+
+    def self.menu
+      LABELS.map { |key, label| "#{key}=#{label}" }.join("  ")
+    end
+
+    def self.menu_lines(width)
+      LABELS.map { |key, label| "#{key}=#{label}" }.each_with_object([]) do |item, lines|
+        candidate = lines.empty? || lines.last.empty? ? item : "#{lines.last}  #{item}"
+        if lines.empty? || ANSI.visible_width(candidate) > width
+          lines << item
+        else
+          lines[-1] = candidate
+        end
+      end
+    end
+  end
+
+end

data/lib/keisanjaku/engine.rb

@@ -0,0 +1,98 @@
+require_relative "planner"
+
+module Keisanjaku
+  class Engine
+    attr_reader :plan, :index
+
+    def initialize(plan, initial_state: RuleState.new, animate: true)
+      @plan = plan
+      @initial_state = initial_state.dup
+      @history = [@initial_state.dup]
+      @index = 0
+      @animate = animate
+    end
+
+    def state
+      @history[@index]
+    end
+
+    def done?
+      @index >= plan.steps.length
+    end
+
+    def step_forward
+      return nil if done?
+
+      next_state = state.dup
+      step = plan.steps[@index]
+      self.class.apply_step(next_state, step)
+      @history = @history.take(@index + 1)
+      @history << next_state
+      @index += 1
+      step
+    end
+
+    def step_back
+      return nil if @index.zero?
+
+      @index -= 1
+      plan.steps[@index]
+    end
+
+    def run_to_end
+      step_forward until done?
+      state
+    end
+
+    def frames_for(step, from:, to:, count: 8)
+      return [to] unless @animate && movement_step?(step)
+
+      (1..count).map do |n|
+        ratio = n.to_f / count
+        RuleState.new(
+          slide: from.slide + (to.slide - from.slide) * ratio,
+          cursor: from.cursor + (to.cursor - from.cursor) * ratio,
+          face: to.face
+        )
+      end
+    end
+
+    def summary
+      error = if plan.true_value.zero?
+                0.0
+              else
+                ((plan.read_value - plan.true_value) / plan.true_value * 100.0).abs
+              end
+      {
+        read_value: plan.read_value,
+        true_value: plan.true_value,
+        error_percent: error,
+        place_explanation: plan.place_explanation
+      }
+    end
+
+    def self.apply_step(state, step)
+      case step.primitive
+      when :move_cursor
+        state.move_cursor_to(step.scale, step.value)
+      when :move_slide_index
+        state.align_slide_index(step.side)
+      when :move_slide_to
+        state.align_slide_value(step.scale, step.value)
+      when :flip_slide
+        state.flip!
+      when :read
+        state
+      else
+        raise ArgumentError, "unknown step primitive: #{step.primitive}"
+      end
+      state
+    end
+
+    private
+
+    def movement_step?(step)
+      %i[move_cursor move_slide_index move_slide_to flip_slide].include?(step.primitive)
+    end
+  end
+end

data/lib/keisanjaku/input.rb

@@ -0,0 +1,78 @@
+require "io/console"
+require_relative "ansi"
+
+module Keisanjaku
+  class Input
+    CRLF = "\r\n"
+
+    CSI_MAP = {
+      "\e[A" => :up,
+      "\e[B" => :down,
+      "\e[C" => :right,
+      "\e[D" => :left,
+      "\e[H" => :home,
+      "\e[F" => :end,
+      "\e[3~" => :delete
+    }.freeze
+
+    SIMPLE_MAP = {
+      "\r" => :enter,
+      "\n" => :enter,
+      "\t" => :tab,
+      "\u007F" => :backspace,
+      "\e" => :escape,
+      " " => :space
+    }.freeze
+
+    def initialize(io = $stdin)
+      @io = io
+    end
+
+    def read_key(timeout: nil)
+      return nil if timeout && !@io.wait_readable(timeout)
+
+      first = @io.getch
+      return nil unless first
+      return decode_sequence(first) unless first == "\e"
+
+      sequence = first.dup
+      while @io.wait_readable(0.01)
+        sequence << @io.getch
+        break if CSI_MAP.key?(sequence) || sequence.match?(/\A\e\[[0-9;]*[~A-Za-z]\z/)
+      end
+      decode_sequence(sequence)
+    end
+
+    def self.decode_sequence(sequence)
+      return CSI_MAP[sequence] if CSI_MAP.key?(sequence)
+      return SIMPLE_MAP[sequence] if SIMPLE_MAP.key?(sequence)
+      return :ctrl_c if sequence == "\u0003"
+
+      sequence
+    end
+
+    def decode_sequence(sequence)
+      self.class.decode_sequence(sequence)
+    end
+
+    def self.with_raw(input: $stdin, output: $stdout, clear_on_exit: true)
+      output.print ANSI.hide_cursor
+      input.raw do
+        yield
+      ensure
+        output.print ANSI.clear_screen if clear_on_exit
+        output.print ANSI.show_cursor
+        output.flush
+      end
+    end
+
+    def self.raw_puts(output, value = "")
+      output.print value.to_s
+      output.print CRLF
+    end
+
+    def self.raw_print_lines(output, lines)
+      lines.each { |line| raw_puts(output, line) }
+    end
+  end
+end