keisanjaku 0.1.0

data/lib/keisanjaku/planner.rb

@@ -0,0 +1,306 @@
+require_relative "parser"
+require_relative "rule_state"
+
+module Keisanjaku
+  Step = Struct.new(:primitive, :scale, :value, :side, :description, keyword_init: true) do
+    def label
+      parts = [primitive]
+      parts << scale if scale
+      parts << value if value
+      parts << side if side
+      parts.join(" ")
+    end
+  end
+
+  Plan = Struct.new(
+    :expression,
+    :steps,
+    :true_value,
+    :read_scale,
+    :read_value,
+    :place_explanation,
+    keyword_init: true
+  )
+
+  class Planner
+    def initialize(ast, expression: nil)
+      @ast = ast
+      @expression = expression
+      @state = RuleState.new
+      @steps = []
+    end
+
+    def compile
+      terms, operations = flatten(@ast)
+      current_value = term_value(terms.first)
+      emit_initial_term(terms.first, chained: !operations.empty?)
+      if operations.any?
+        ensure_front if @state.face == :back
+        ensure_cursor_on_d(current_value) unless cursor_matches_d?(current_value)
+      end
+
+      operations.each do |operator, term|
+        factor = term_value(term)
+        ensure_front
+        if operator == :multiply
+          emit_multiply(current_value, factor, term)
+          current_value *= factor
+        else
+          emit_divide(current_value, factor, term)
+          current_value /= factor
+        end
+      end
+
+      emit_final_read(current_value, operations.empty? ? terms.first : nil)
+      Plan.new(
+        expression: @expression,
+        steps: @steps,
+        true_value: current_value,
+        read_scale: final_read_scale(operations.empty? ? terms.first : nil),
+        read_value: current_value,
+        place_explanation: place_explanation(current_value)
+      )
+    end
+
+    def self.compile(ast, expression: nil)
+      new(ast, expression: expression).compile
+    end
+
+    private
+
+    def flatten(node)
+      return [[node], []] unless node.is_a?(BinaryNode)
+
+      terms, operations = flatten(node.left)
+      terms << node.right
+      operations << [node.operator, node.right]
+      [terms, operations]
+    end
+
+    def term_value(node)
+      case node
+      when NumberNode
+        node.value
+      when PowerNode
+        node.base**node.power
+      when FunctionNode
+        function_value(node)
+      else
+        raise ArgumentError, "unknown AST node: #{node.inspect}"
+      end
+    end
+
+    def function_value(node)
+      case node.name
+      when :sqrt then Math.sqrt(node.argument)
+      when :cbrt then node.argument**(1.0 / 3.0)
+      when :sin then Math.sin(node.argument * Scale::DEGREE)
+      when :tan then Math.tan(node.argument * Scale::DEGREE)
+      when :log then Math.log10(node.argument)
+      else
+        raise ArgumentError, "unknown function: #{node.name}"
+      end
+    end
+
+    def emit_initial_term(node, chained:)
+      case node
+      when NumberNode
+        add_move_cursor("D", mantissa(node.value), "カーソルを D 尺の #{display_number(node.value)} に合わせます")
+      when PowerNode
+        add_move_cursor("D", mantissa(node.base), "カーソルを D 尺の #{display_number(node.base)} に合わせます")
+        add_read("A", "#{display_number(node.base)}^2 を A 尺で読み取ります") if node.power == 2
+        add_read("K", "#{display_number(node.base)}^3 を K 尺で読み取ります") if node.power == 3
+      when FunctionNode
+        emit_function_term(node)
+      end
+      ensure_cursor_on_d(term_value(node)) if chained
+    end
+
+    def emit_function_term(node)
+      case node.name
+      when :sqrt
+        add_move_cursor("A", normalized_power_value(node.argument, 2), "カーソルを A 尺の #{display_number(node.argument)} に合わせます")
+        add_read("D", "D 尺で平方根を読み取ります")
+      when :cbrt
+        add_move_cursor("K", normalized_power_value(node.argument, 3), "カーソルを K 尺の #{display_number(node.argument)} に合わせます")
+        add_read("D", "D 尺で立方根を読み取ります")
+      when :sin
+        ensure_back
+        add_move_cursor("S", node.argument, "#{source_label(node)} を S 尺に合わせます")
+        add_read("D", "D 尺で正弦の仮数を読み取ります")
+      when :tan
+        ensure_back
+        add_move_cursor("T", node.argument, "#{source_label(node)} を T 尺に合わせます")
+        add_read("D", "D 尺で正接の仮数を読み取ります")
+      when :log
+        add_move_cursor("D", mantissa(node.argument), "カーソルを D 尺の #{display_number(node.argument)} に合わせます")
+        add_read("L", "L 尺で常用対数を読み取ります")
+      end
+    end
+
+    def emit_multiply(current_value, factor, term)
+      current_pos = d_position(current_value)
+      factor_mantissa = mantissa(factor)
+      factor_pos = Scale.fetch("C").position(factor_mantissa)
+      side, target = choose_multiply_side(current_pos, factor_pos)
+      add_move_slide_index(side, multiply_index_description(side, current_value))
+      add_move_cursor("C", factor_mantissa, "#{term_label(term)} を C 尺でカーソルに合わせます")
+      @state.cursor = target
+      add_read("D", "D 尺で積の仮数を読み取ります")
+    end
+
+    def emit_divide(current_value, factor, term)
+      factor_mantissa = mantissa(factor)
+      add_move_slide_to("C", factor_mantissa, "#{term_label(term)} を C 尺で現在のカーソルに合わせます")
+      side, target = choose_division_side(@state.slide)
+      add_move_cursor("C", side == :left ? 1.0 : 10.0, "C 尺の#{side == :left ? '左' : '右'}基線へカーソルを動かします")
+      @state.cursor = target
+      add_read("D", "D 尺で商の仮数を読み取ります")
+    end
+
+    def choose_multiply_side(current_pos, factor_pos)
+      left_target = current_pos + factor_pos
+      return [:left, left_target] if unit?(left_target)
+
+      right_target = current_pos - 1.0 + factor_pos
+      return [:right, right_target] if unit?(right_target)
+
+      raise ScaleError, "no visible slide index can multiply at #{current_pos}"
+    end
+
+    def choose_division_side(slide)
+      left_target = slide
+      return [:left, left_target] if unit?(left_target)
+
+      right_target = slide + 1.0
+      return [:right, right_target] if unit?(right_target)
+
+      raise ScaleError, "no visible slide index can divide at slide #{slide}"
+    end
+
+    def multiply_index_description(side, current_value)
+      if side == :left
+        "滑尺の左基線(1)を現在値 #{display_number(current_value)} に合わせます"
+      else
+        "左基線では枠外に出るため、滑尺の右基線(10)を使って折り返します"
+      end
+    end
+
+    def emit_final_read(value, single_term)
+      scale = final_read_scale(single_term)
+      return if @steps.last&.primitive == :read && @steps.last.scale.to_s == scale.to_s
+
+      ensure_cursor_on_d(value) if scale == "D" && !cursor_matches_d?(value)
+      add_read(scale, "最終結果を #{scale} 尺で読み取ります")
+    end
+
+    def final_read_scale(single_term)
+      case single_term
+      when PowerNode
+        single_term.power == 2 ? "A" : "K"
+      when FunctionNode
+        single_term.name == :log ? "L" : "D"
+      else
+        "D"
+      end
+    end
+
+    def ensure_cursor_on_d(value)
+      return if cursor_matches_d?(value)
+
+      add_move_cursor("D", mantissa(value), "中間結果の仮数 #{display_number(mantissa(value))} を D 尺に移します")
+    end
+
+    def cursor_matches_d?(value)
+      (@state.cursor - d_position(value)).abs < 1e-9
+    end
+
+    def ensure_front
+      add_flip("滑尺を表面(C/CI/B)に戻します") if @state.face == :back
+    end
+
+    def ensure_back
+      add_flip("滑尺を裏面(S/T)に切り替えます") if @state.face == :front
+    end
+
+    def add_move_cursor(scale, value, description)
+      add_step(Step.new(primitive: :move_cursor, scale: scale, value: value, description: description))
+      @state.move_cursor_to(scale, value)
+    end
+
+    def add_move_slide_index(side, description)
+      add_step(Step.new(primitive: :move_slide_index, side: side, description: description))
+      @state.align_slide_index(side)
+    end
+
+    def add_move_slide_to(scale, value, description)
+      add_step(Step.new(primitive: :move_slide_to, scale: scale, value: value, description: description))
+      @state.align_slide_value(scale, value)
+    end
+
+    def add_flip(description)
+      add_step(Step.new(primitive: :flip_slide, description: description))
+      @state.flip!
+    end
+
+    def add_read(scale, description)
+      add_step(Step.new(primitive: :read, scale: scale, description: description))
+    end
+
+    def add_step(step)
+      @steps << step
+    end
+
+    def mantissa(value)
+      numeric = Float(value)
+      exponent = Math.log10(numeric).floor
+      mantissa = numeric / (10.0**exponent)
+      return 1.0 if (mantissa - 10.0).abs < 1e-12
+
+      mantissa
+    end
+
+    def normalized_power_value(value, power)
+      max = 10.0**power
+      numeric = Float(value)
+      numeric /= max while numeric > max
+      numeric *= max while numeric < 1.0
+      numeric
+    end
+
+    def d_position(value)
+      Scale.fetch("D").position(mantissa(value))
+    end
+
+    def unit?(value)
+      value >= -1e-12 && value <= 1.0 + 1e-12
+    end
+
+    def source_label(node)
+      if node.source_name == :cos
+        "cos(#{display_number(node.source_argument)})=sin(#{display_number(node.argument)})"
+      else
+        "#{node.source_name}(#{display_number(node.source_argument)})"
+      end
+    end
+
+    def term_label(node)
+      case node
+      when NumberNode then display_number(node.value)
+      when PowerNode then "#{display_number(node.base)}^#{node.power}"
+      when FunctionNode then source_label(node)
+      else node.to_s
+      end
+    end
+
+    def display_number(value)
+      format("%.6g", value)
+    end
+
+    def place_explanation(value)
+      exponent = Math.log10(value).floor
+      mant = value / (10.0**exponent)
+      "読み取り仮数 #{format('%.4g', mant)} に 10^#{exponent} を掛けて #{format('%.6g', value)} とします"
+    end
+  end
+end

data/lib/keisanjaku/procedure.rb

@@ -0,0 +1,108 @@
+require_relative "planner"
+
+module Keisanjaku
+  ProcedureAttempt = Struct.new(:actions, :used_model, :answer, keyword_init: true)
+
+  ProcedureEvent = Struct.new(:primitive, :scale, :value, :side, keyword_init: true) do
+    def self.from_step(step)
+      new(
+        primitive: step.primitive,
+        scale: step.scale&.to_s,
+        value: step.value,
+        side: step.side
+      )
+    end
+  end
+
+  class ProcedureCapture
+    POSITION_TOLERANCE = 0.002
+
+    attr_reader :events
+
+    def initialize(plan)
+      @steps = plan&.steps || []
+      @index = 0
+      @events = []
+    end
+
+    def record_satisfied!(state, trigger: nil)
+      loop do
+        step = @steps[@index]
+        break unless step_satisfied?(step, state, trigger)
+
+        @events << ProcedureEvent.from_step(step)
+        @index += 1
+        trigger = nil
+      end
+      events
+    end
+
+    private
+
+    def step_satisfied?(step, state, trigger)
+      return false unless step
+
+      case step.primitive
+      when :move_cursor
+        close?(state.cursor, state.board_position(step.scale, step.value))
+      when :move_slide_index
+        close?(state.slide, state.cursor - index_position(step.side))
+      when :move_slide_to
+        close?(state.slide, state.cursor - Scale.fetch(step.scale).position(step.value))
+      when :flip_slide
+        trigger == :flip
+      when :read
+        trigger == :read
+      else
+        false
+      end
+    end
+
+    def index_position(side)
+      side == :right ? 1.0 : 0.0
+    end
+
+    def close?(actual, expected)
+      (actual - expected).abs <= POSITION_TOLERANCE
+    rescue ScaleError
+      false
+    end
+  end
+
+  class ProcedureChecker
+    VALUE_TOLERANCE = 1e-9
+
+    def matches?(plan, attempt)
+      return false if attempt.used_model
+
+      expected = expected_events(plan)
+      observed = observed_events(attempt)
+      expected.length == observed.length &&
+        expected.zip(observed).all? { |expected_event, observed_event| event_matches?(expected_event, observed_event) }
+    end
+
+    def expected_events(plan)
+      plan.steps.map { |step| ProcedureEvent.from_step(step) }
+    end
+
+    def observed_events(attempt)
+      attempt.actions.filter { |action| action.is_a?(ProcedureEvent) }
+    end
+
+    private
+
+    def event_matches?(expected, observed)
+      expected.primitive == observed.primitive &&
+        expected.scale == observed.scale &&
+        expected.side == observed.side &&
+        values_match?(expected.value, observed.value)
+    end
+
+    def values_match?(expected, observed)
+      return true if expected.nil? && observed.nil?
+      return false if expected.nil? || observed.nil?
+
+      (expected.to_f - observed.to_f).abs <= VALUE_TOLERANCE
+    end
+  end
+end

data/lib/keisanjaku/renderer.rb

@@ -0,0 +1,142 @@
+require_relative "ansi"
+require_relative "rule_state"
+
+module Keisanjaku
+  class Renderer
+    MIN_WIDTH = 60
+    DEFAULT_WIDTH = 100
+    LABEL_WIDTH = 6
+
+    def initialize(color: true)
+      @color = color
+    end
+
+    def render(state, width: DEFAULT_WIDTH, message: nil, highlight_scale: nil)
+      width = [width.to_i, MIN_WIDTH].max
+      rail_width = width - LABEL_WIDTH - 2
+      cursor_col = column_for(state.cursor, rail_width)
+      highlight_name = highlight_scale&.to_s&.upcase
+      lines = []
+      lines << border_line(rail_width, :top)
+      lines.concat(render_scale("K", state, rail_width, cursor_col, highlight_name))
+      lines.concat(render_scale("A", state, rail_width, cursor_col, highlight_name))
+      lines << border_line(rail_width, :divider)
+      slide_names = state.face == :front ? %w[B CI C] : %w[S T]
+      slide_names.each { |name| lines.concat(render_scale(name, state, rail_width, cursor_col, highlight_name)) }
+      lines << border_line(rail_width, :divider)
+      lines.concat(render_scale("D", state, rail_width, cursor_col, highlight_name))
+      lines.concat(render_scale("L", state, rail_width, cursor_col, highlight_name))
+      lines << border_line(rail_width, :bottom)
+      lines << status_line(state, width, highlight_name)
+      lines << ANSI.fit(message.to_s, width) if message
+      lines.map { |line| ANSI.fit(line, width) }
+    end
+
+    def self.render(state, width: DEFAULT_WIDTH, color: true, message: nil, highlight_scale: nil)
+      new(color: color).render(state, width: width, message: message, highlight_scale: highlight_scale)
+    end
+
+    private
+
+    def border_line(rail_width, kind)
+      left = kind == :top || kind == :bottom ? "+" : "+"
+      right = "+"
+      label = " " * LABEL_WIDTH
+      "#{label}#{left}#{'-' * rail_width}#{right}"
+    end
+
+    def render_scale(name, state, rail_width, cursor_col, highlight_name)
+      scale = Scale.fetch(name)
+      slide_scale = state.slide_scale?(name)
+      tick_row = base_row(rail_width, slide_scale, state.slide)
+      label_row = base_row(rail_width, slide_scale, state.slide)
+      highlight_col = highlight_name == name ? cursor_col : nil
+
+      scale.ticks(rail_width).each do |tick|
+        board_pos = slide_scale ? tick[:col].to_f / (rail_width - 1) + state.slide : tick[:col].to_f / (rail_width - 1)
+        next unless board_pos >= 0.0 && board_pos <= 1.0
+
+        col = column_for(board_pos, rail_width)
+        tick_row[col] = tick_mark(tick[:level])
+        write_label(label_row, col, tick[:label]) if tick[:label]
+      end
+
+      draw_cursor(tick_row, cursor_col)
+      draw_cursor(label_row, cursor_col)
+      label = name.rjust(LABEL_WIDTH)
+      [
+        "#{label}|#{join_row(tick_row, slide_scale, state.slide, rail_width, highlight_col)}|",
+        "#{' ' * LABEL_WIDTH}|#{join_row(label_row, slide_scale, state.slide, rail_width, highlight_col)}|"
+      ]
+    end
+
+    def base_row(rail_width, slide_scale, slide)
+      return Array.new(rail_width, " ") unless slide_scale
+
+      Array.new(rail_width) do |index|
+        board_pos = index.to_f / (rail_width - 1)
+        board_pos >= slide && board_pos <= slide + 1.0 ? "." : " "
+      end
+    end
+
+    def tick_mark(level)
+      case level
+      when 0 then "|"
+      when 1 then ":"
+      else "'"
+      end
+    end
+
+    def write_label(row, col, label)
+      start = [[col - (label.length / 2), 0].max, row.length - label.length].min
+      label.each_char.with_index { |char, index| row[start + index] = char }
+    end
+
+    def draw_cursor(row, cursor_col)
+      row[cursor_col] = ANSI.paint("|", :red, color: @color)
+    end
+
+    def join_row(row, slide_scale, slide, rail_width, highlight_col)
+      row.each_with_index.map do |cell, index|
+        highlighted = highlight_col == index
+        inside_slide = slide_scale && inside_slide?(index, slide, rail_width)
+        decorate_cell(cell, inside_slide, highlighted)
+      end.join
+    end
+
+    def decorate_cell(cell, inside_slide, highlighted)
+      return ANSI.paint(cell, :yellow, :bold, color: @color) if highlighted
+      return cell unless inside_slide
+      return cell unless @color
+
+      display = cell == "." ? " " : cell
+      ANSI.paint(display, :cyan_bg, color: @color)
+    end
+
+    def inside_slide?(index, slide, rail_width)
+      board_pos = index.to_f / (rail_width - 1)
+      board_pos >= slide && board_pos <= slide + 1.0
+    end
+
+    def column_for(pos, rail_width)
+      (pos.clamp(0.0, 1.0) * (rail_width - 1)).round
+    end
+
+    def status_line(state, width, highlight_name)
+      values = state.visible_scale_names.filter_map do |name|
+        value = state.read(name)
+        next unless value
+
+        text = "#{name}=#{format_value(value)}"
+        name == highlight_name ? ANSI.paint(text, :yellow, :bold, color: @color) : text
+      end
+      ANSI.fit("cursor=#{format('%.4f', state.cursor)} slide=#{format('%+.4f', state.slide)} face=#{state.face} #{values.join(' ')}", width)
+    end
+
+    def format_value(value)
+      return "--" unless value
+
+      format("%.5g", value)
+    end
+  end
+end

data/lib/keisanjaku/rule_state.rb

@@ -0,0 +1,98 @@
+require_relative "scale"
+
+module Keisanjaku
+  class RuleState
+    FRONT_SLIDE_SCALES = %w[B CI C].freeze
+    BACK_SLIDE_SCALES = %w[S T].freeze
+    FIXED_SCALES = %w[K A D L].freeze
+    SLIDE_SCALES = (FRONT_SLIDE_SCALES + BACK_SLIDE_SCALES).freeze
+
+    attr_reader :slide, :cursor, :face
+
+    def initialize(slide: 0.0, cursor: 0.0, face: :front)
+      self.slide = slide
+      self.cursor = cursor
+      self.face = face
+    end
+
+    def slide=(value)
+      @slide = Float(value).clamp(-1.0, 1.0)
+    end
+
+    def cursor=(value)
+      @cursor = Float(value).clamp(0.0, 1.0)
+    end
+
+    def face=(value)
+      symbol = value.to_sym
+      raise ArgumentError, "face must be :front or :back" unless %i[front back].include?(symbol)
+
+      @face = symbol
+    end
+
+    def dup
+      self.class.new(slide: slide, cursor: cursor, face: face)
+    end
+
+    def read(scale_name)
+      scale = Scale.fetch(scale_name)
+      pos = local_position_for(scale.name)
+      return nil unless pos && pos >= -1e-12 && pos <= 1.0 + 1e-12
+
+      scale.value_at(pos.clamp(0.0, 1.0))
+    rescue ScaleError
+      nil
+    end
+
+    def visible_scale_names
+      face == :front ? %w[K A B CI C D L] : %w[K A S T D L]
+    end
+
+    def board_position(scale_name, value)
+      scale = Scale.fetch(scale_name)
+      local = scale.position(value)
+      slide_scale?(scale.name) ? local + slide : local
+    end
+
+    def move_cursor_to(scale_name, value)
+      self.cursor = board_position(scale_name, value)
+    end
+
+    def align_slide_index(side)
+      self.slide = cursor - index_position(side)
+    end
+
+    def align_slide_value(scale_name, value)
+      scale = Scale.fetch(scale_name)
+      raise ScaleError, "#{scale.name} is not on the slide" unless slide_scale?(scale.name)
+
+      self.slide = cursor - scale.position(value)
+    end
+
+    def flip!
+      self.face = face == :front ? :back : :front
+    end
+
+    def slide_scale?(scale_name)
+      SLIDE_SCALES.include?(scale_name.to_s.upcase)
+    end
+
+    def local_position_for(scale_name)
+      name = scale_name.to_s.upcase
+      slide_scale?(name) ? cursor - slide : cursor
+    end
+
+    private
+
+    def index_position(side)
+      case side
+      when :left, "left", 1, "1"
+        0.0
+      when :right, "right", 10, "10"
+        1.0
+      else
+        raise ArgumentError, "unknown slide index side: #{side}"
+      end
+    end
+  end
+end