keisanjaku 0.1.0

data/lib/keisanjaku/modes/demo.rb

@@ -0,0 +1,142 @@
+require_relative "../engine"
+require_relative "../renderer"
+require_relative "../input"
+require_relative "../terminal_viewport"
+
+module Keisanjaku
+  module Modes
+    class Demo
+      REDRAW_INTERVAL = 0.1
+
+      def initialize(expression, width: nil, color: true, animate: true, output: $stdout)
+        @expression = expression
+        @width = width
+        @viewport = TerminalViewport.new(width: width)
+        @renderer = Renderer.new(color: color)
+        @animate = animate
+        @output = output
+      end
+
+      def plan
+        @plan ||= Planner.compile(Parser.parse(@expression), expression: @expression)
+      end
+
+      def run_noninteractive
+        engine = Engine.new(plan, animate: false)
+        @output.puts "Expression: #{@expression}"
+        plan.steps.each_with_index do |step, index|
+          @output.puts "#{index + 1}. #{step.description}"
+          engine.step_forward
+        end
+        @renderer.render(engine.state, width: @viewport.current_width, highlight_scale: plan.read_scale).each { |line| @output.puts line }
+        print_summary(engine.summary)
+      end
+
+      def run_interactive(input: $stdin)
+        engine = Engine.new(plan, animate: @animate)
+        reader = Input.new(input)
+        auto = false
+        speed = 0.35
+        next_auto_at = Time.now + speed
+        needs_draw = true
+        @viewport = TerminalViewport.new(width: @width, right_margin: 1, clamp_fixed_width: true)
+        @viewport.install
+        Input.with_raw(input: input, output: @output) do
+          loop do
+            if needs_draw || @viewport.refresh_needed?
+              draw(engine)
+              needs_draw = false
+            end
+
+            key = reader.read_key(timeout: auto ? [speed, REDRAW_INTERVAL].min : REDRAW_INTERVAL)
+            if key.nil?
+              if auto && Time.now >= next_auto_at
+                auto = false unless advance(engine)
+                next_auto_at = Time.now + speed
+                needs_draw = true
+              end
+              next
+            end
+
+            case key
+            when :enter, :space
+              advance(engine)
+              needs_draw = true
+            when "b"
+              engine.step_back
+              needs_draw = true
+            when "a"
+              auto = !auto
+              next_auto_at = Time.now + speed
+              needs_draw = true
+            when "1"
+              speed = 0.7
+              next_auto_at = Time.now + speed
+            when "2"
+              speed = 0.35
+              next_auto_at = Time.now + speed
+            when "3"
+              speed = 0.15
+              next_auto_at = Time.now + speed
+            when "q", :ctrl_c
+              break
+            end
+          end
+        end
+      ensure
+        @viewport.restore if @viewport
+      end
+
+      private
+
+      def advance(engine)
+        from = engine.state.dup
+        step = engine.step_forward
+        return nil unless step
+
+        animate_transition(engine, step, from, engine.state)
+        step
+      end
+
+      def animate_transition(engine, step, from, to)
+        return unless @animate
+
+        engine.frames_for(step, from: from, to: to).each do |frame|
+          draw_frame(frame, step.description, highlight_scale_for(step))
+          sleep 0.04
+        end
+      end
+
+      def draw(engine)
+        step = plan.steps[engine.index]
+        message = step ? step.description : summary_text(engine.summary)
+        highlight_scale = step ? highlight_scale_for(step) : plan.read_scale
+        draw_frame(engine.state, message, highlight_scale)
+        Input.raw_puts(@output, "Enter/Space next  b back  a auto  1/2/3 speed  q quit")
+      end
+
+      def draw_frame(state, message, highlight_scale)
+        @output.print ANSI.clear_screen
+        Input.raw_print_lines(@output, @renderer.render(
+          state,
+          width: @viewport.current_width,
+          message: message,
+          highlight_scale: highlight_scale
+        ))
+      end
+
+      def highlight_scale_for(step)
+        step&.primitive == :read ? step.scale : nil
+      end
+
+      def print_summary(summary)
+        @output.puts summary_text(summary)
+        @output.puts summary[:place_explanation]
+      end
+
+      def summary_text(summary)
+        "Read=#{format('%.6g', summary[:read_value])} True=#{format('%.6g', summary[:true_value])} Error=#{format('%.4f', summary[:error_percent])}%"
+      end
+    end
+  end
+end

data/lib/keisanjaku/modes/drill.rb

@@ -0,0 +1,127 @@
+require_relative "../drill"
+require_relative "../terminal_viewport"
+require_relative "demo"
+require_relative "sandbox"
+
+module Keisanjaku
+  module Modes
+    class Drill
+      def initialize(width: nil, color: true, tolerance_percent: 1.0, output: $stdout)
+        @width = width
+        @color = color
+        @generator = QuestionGenerator.new
+        @judge = Judge.new(tolerance_percent: tolerance_percent)
+        @procedure_checker = ProcedureChecker.new
+        @output = output
+        @score = 0
+        @streak = 0
+        @started_at = Time.now
+      end
+
+      def run(input: $stdin)
+        operations = choose_operations(input)
+        loop do
+          question = @generator.next_question(operation: operations.sample)
+          puts_fitted(question.prompt)
+          attempt = operate_before_answer(input, question)
+          break if attempt == :quit
+          next if attempt == :next
+
+          answer = attempt.answer || read_text_answer(input)
+          break if answer.nil? || answer == "q"
+
+          if answer == "g"
+            show_demo(question)
+            next
+          end
+
+          judge_answer(answer, question, attempt)
+        end
+      end
+
+      private
+
+      def choose_operations(input)
+        puts_fitted("出題範囲を選択してください。空欄/all で全範囲。")
+        OperationSelector.menu_lines(display_width).each { |line| puts_fitted(line) }
+        @output.print "range> "
+        selection = input.gets
+        @output.puts unless input.tty?
+        OperationSelector.parse(selection)
+      end
+
+      def operate_before_answer(input, question)
+        return ProcedureAttempt.new(actions: [], used_model: false) unless input.tty?
+
+        loop do
+          puts_fitted("operate: Enter/o 操作+回答  s text answer  g demo  q quit")
+          @output.print "> "
+          choice = input.gets&.strip
+          return :quit if choice.nil? || choice == "q"
+          return ProcedureAttempt.new(actions: [], used_model: false) if choice == "s"
+          if choice == "g"
+            show_demo(question)
+            return ProcedureAttempt.new(actions: [], used_model: true)
+          end
+          return run_operation_workspace(input, question) if choice.empty? || choice == "o"
+        end
+      end
+
+      def run_operation_workspace(input, question)
+        plan = Planner.compile(Parser.parse(question.expression), expression: question.expression)
+        sandbox = Modes::Sandbox.new(
+          width: @width,
+          color: @color,
+          output: @output,
+          prompt: question.prompt,
+          answer_entry: true,
+          procedure_plan: plan
+        )
+        result = sandbox.run(input: input)
+        return :quit if result.quit
+
+        ProcedureAttempt.new(actions: result.actions, used_model: false, answer: result.answer)
+      end
+
+      def show_demo(question)
+        Modes::Demo.new(question.expression, width: @width, color: @color, animate: false, output: @output).run_noninteractive
+      end
+
+      def judge_answer(answer, question, attempt)
+        if @judge.correct?(answer, question.true_value)
+          @score += 1
+          @streak += 1
+          @output.puts "OK score=#{@score} streak=#{@streak} procedure=#{procedure_result(question, attempt)} elapsed=#{elapsed}s"
+        else
+          @streak = 0
+          error = @judge.relative_error_percent(answer, question.true_value)
+          @output.puts "NG true=#{format('%.6g', question.true_value)} error=#{format('%.3f', error)}%"
+        end
+      rescue ArgumentError
+        @output.puts "数値を入力してください"
+      end
+
+      def read_text_answer(input)
+        @output.print "answer (g demo, q quit)> "
+        input.gets&.strip
+      end
+
+      def puts_fitted(text)
+        @output.puts ANSI.fit(text, display_width)
+      end
+
+      def display_width
+        @display_width ||= TerminalViewport.new(width: @width, right_margin: 1, clamp_fixed_width: true).current_width
+      end
+
+      def elapsed
+        (Time.now - @started_at).round(1)
+      end
+
+      def procedure_result(question, attempt)
+        plan = Planner.compile(Parser.parse(question.expression), expression: question.expression)
+        @procedure_checker.matches?(plan, attempt) ? "matched" : "unchecked"
+      end
+    end
+  end
+end

data/lib/keisanjaku/modes/sandbox.rb

@@ -0,0 +1,159 @@
+require_relative "../input"
+require_relative "../procedure"
+require_relative "../renderer"
+require_relative "../terminal_viewport"
+
+module Keisanjaku
+  module Modes
+    class Sandbox
+      COARSE = 0.01
+      FINE = 0.001
+      REDRAW_INTERVAL = 0.1
+
+      SandboxResult = Struct.new(:actions, :answer, :quit, keyword_init: true)
+
+      attr_reader :state, :target, :actions
+
+      def initialize(width: nil, color: true, output: $stdout, prompt: nil, answer_entry: false, viewport: nil, procedure_plan: nil)
+        @state = RuleState.new(cursor: Scale.fetch("D").position(1.0))
+        @target = :slide
+        @show_values = true
+        @viewport = viewport || TerminalViewport.new(width: width, right_margin: 1, clamp_fixed_width: true)
+        @renderer = Renderer.new(color: color)
+        @output = output
+        @prompt = prompt
+        @answer_entry = answer_entry
+        @answer = +""
+        @actions = []
+        @procedure_capture = procedure_plan ? ProcedureCapture.new(procedure_plan) : nil
+      end
+
+      def handle_key(key)
+        return handle_answer_key(key) if @answer_entry && answer_key?(key)
+
+        result = case key
+        when "q", :ctrl_c
+          :quit
+        when "h"
+          record(:slide_move)
+          move_slide(-COARSE)
+        when "l"
+          record(:slide_move)
+          move_slide(COARSE)
+        when "H", ","
+          record(:slide_move)
+          move_slide(-FINE)
+        when "L", "."
+          record(:slide_move)
+          move_slide(FINE)
+        when "c", "j", "k"
+          record(:select_target)
+          @target = target == :slide ? :cursor : :slide
+        when :left
+          record_selected_move
+          move_selected(-COARSE)
+        when :right
+          record_selected_move
+          move_selected(COARSE)
+        when :tab
+          record(:flip)
+          state.flip!
+        when "?"
+          @show_values = !@show_values
+        when "r"
+          record(:reset)
+          @state = RuleState.new
+        end
+        capture_procedure unless result == :quit
+        result
+      end
+
+      def run(input: $stdin)
+        reader = Input.new(input)
+        @viewport.install
+        needs_draw = true
+        quit = false
+        Input.with_raw(input: input, output: @output) do
+          loop do
+            if needs_draw || @viewport.refresh_needed?
+              draw
+              needs_draw = false
+            end
+            key = reader.read_key(timeout: REDRAW_INTERVAL)
+            next unless key
+
+            result = handle_key(key)
+            quit = result == :quit
+            break if quit || result == :done
+
+            needs_draw = true
+          end
+        end
+        SandboxResult.new(actions: actions, answer: @answer.empty? ? nil : @answer, quit: quit)
+      ensure
+        @viewport.restore if @viewport
+      end
+
+      private
+
+      def answer_key?(key)
+        key == :enter ||
+          key == :backspace ||
+          key.is_a?(String) && key.match?(/\A[0-9.eE+-]\z/)
+      end
+
+      def handle_answer_key(key)
+        case key
+        when :enter
+          record(:read)
+          capture_procedure(trigger: :read)
+          :done
+        when :backspace
+          @answer.chop!
+          nil
+        else
+          @answer << key
+          nil
+        end
+      end
+
+      def record(action)
+        @actions << action
+      end
+
+      def capture_procedure(trigger: nil)
+        return unless @procedure_capture
+
+        before = @procedure_capture.events.length
+        @procedure_capture.record_satisfied!(state, trigger: trigger)
+        @actions.concat(@procedure_capture.events.drop(before))
+      end
+
+      def record_selected_move
+        record(target == :slide ? :slide_move : :cursor_move)
+      end
+
+      def move_slide(delta)
+        state.slide = state.slide + delta
+      end
+
+      def move_selected(delta)
+        if target == :slide
+          move_slide(delta)
+        else
+          state.cursor = state.cursor + delta
+        end
+      end
+
+      def draw
+        guide = "Sandbox target=#{target} keys: h/l slide H/L fine arrows selected Tab flip ? values r reset q quit"
+        answer = @answer_entry ? "answer=#{@answer.empty? ? '_' : @answer} Enter=submit Backspace=edit" : nil
+        message = [@prompt, answer, guide].compact.join("  ")
+        @output.print ANSI.clear_screen
+        @renderer.render(state, width: @viewport.current_width, message: @show_values ? message : "Sandbox values hidden").each do |line|
+          Input.raw_puts(@output, line)
+        end
+      end
+    end
+  end
+end

data/lib/keisanjaku/parser.rb

@@ -0,0 +1,185 @@
+module Keisanjaku
+  class ParseError < StandardError
+    attr_reader :position
+
+    def initialize(message, position)
+      @position = position
+      super("#{message} at #{position}")
+    end
+  end
+
+  NumberNode = Struct.new(:value, keyword_init: true)
+  PowerNode = Struct.new(:base, :power, keyword_init: true)
+  FunctionNode = Struct.new(:name, :argument, :source_name, :source_argument, keyword_init: true)
+  BinaryNode = Struct.new(:left, :operator, :right, keyword_init: true)
+
+  class Parser
+    FUNCTIONS = %w[sqrt cbrt sin cos tan log].freeze
+
+    def initialize(input)
+      @chars = input.to_s.each_char.to_a
+      @index = 0
+    end
+
+    def parse
+      skip_space
+      node = parse_expr
+      skip_space
+      raise_error("unexpected token '#{peek}'") unless eof?
+
+      node
+    end
+
+    def self.parse(input)
+      new(input).parse
+    end
+
+    private
+
+    def parse_expr
+      node = parse_term
+      loop do
+        skip_space
+        operator = parse_operator
+        break unless operator
+
+        node = BinaryNode.new(left: node, operator: operator, right: parse_term)
+      end
+      node
+    end
+
+    def parse_term
+      skip_space
+      if letter?(peek)
+        return parse_function
+      end
+
+      number = parse_number
+      skip_space
+      return number unless consume("^")
+
+      power_char = consume_any(%w[2 3])
+      raise_error("expected power 2 or 3") unless power_char
+
+      PowerNode.new(base: number.value, power: power_char.to_i)
+    end
+
+    def parse_function
+      start = @index
+      name = parse_identifier
+      raise_error("unknown function '#{name}'", start) unless FUNCTIONS.include?(name)
+      skip_space
+      raise_error("expected '('") unless consume("(")
+
+      argument = parse_number.value
+      skip_space
+      raise_error("expected ')'") unless consume(")")
+
+      build_function(name, argument, start)
+    end
+
+    def build_function(name, argument, position)
+      case name
+      when "sqrt", "cbrt", "log"
+        raise ParseError.new("#{name} expects a positive number", position) unless argument.positive?
+        FunctionNode.new(name: name.to_sym, argument: argument, source_name: name.to_sym, source_argument: argument)
+      when "sin"
+        require_angle(argument, Scale::S_MIN_DEGREES, 90.0, "sin", position)
+        FunctionNode.new(name: :sin, argument: argument, source_name: :sin, source_argument: argument)
+      when "tan"
+        require_angle(argument, Scale::T_MIN_DEGREES, 45.0, "tan", position)
+        FunctionNode.new(name: :tan, argument: argument, source_name: :tan, source_argument: argument)
+      when "cos"
+        converted = 90.0 - argument
+        require_angle(converted, Scale::S_MIN_DEGREES, 90.0, "cos", position)
+        FunctionNode.new(name: :sin, argument: converted, source_name: :cos, source_argument: argument)
+      else
+        raise_error("unknown function '#{name}'", position)
+      end
+    end
+
+    def require_angle(value, min, max, name, position)
+      return if value >= min - 1e-12 && value <= max + 1e-12
+
+      raise ParseError.new("#{name} angle is outside #{format('%.3f', min)}..#{format('%.3f', max)}", position)
+    end
+
+    def parse_operator
+      char = peek
+      case char
+      when "*", "×"
+        advance
+        :multiply
+      when "/", "÷"
+        advance
+        :divide
+      end
+    end
+
+    def parse_number
+      skip_space
+      start = @index
+      digits = +""
+      digits << advance while digit?(peek)
+      if peek == "."
+        digits << advance
+        digits << advance while digit?(peek)
+      end
+      raise_error("expected number", start) if digits.empty? || digits == "."
+
+      value = Float(digits)
+      raise_error("number must be positive", start) unless value.positive?
+
+      NumberNode.new(value: value)
+    end
+
+    def parse_identifier
+      ident = +""
+      ident << advance while letter?(peek)
+      ident
+    end
+
+    def consume(expected)
+      return false unless peek == expected
+
+      advance
+      true
+    end
+
+    def consume_any(expected)
+      return nil unless expected.include?(peek)
+
+      advance
+    end
+
+    def skip_space
+      advance while peek&.match?(/\s/)
+    end
+
+    def eof?
+      @index >= @chars.length
+    end
+
+    def peek
+      @chars[@index]
+    end
+
+    def advance
+      char = @chars[@index]
+      @index += 1
+      char
+    end
+
+    def digit?(char)
+      char&.match?(/[0-9]/)
+    end
+
+    def letter?(char)
+      char&.match?(/[A-Za-z]/)
+    end
+
+    def raise_error(message, position = @index)
+      raise ParseError.new(message, position)
+    end
+  end
+end