rcas 0.2.0

data/lib/rcas/hold.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Ruby keeps the source of eval'd code (and so lets us read a block's
+  # syntax tree) only while this is on. irb turns it on itself; other hosts
+  # such as the chat REPL evaluate input with eval, so we turn it on here.
+  RubyVM.keep_script_lines = true
+
+  # hold { 1 + 2 } builds the expression tree of the block's source instead of
+  # letting Ruby evaluate it, so numeric arithmetic is kept symbolic:
+  #
+  #   hold { 1 + 2 }            # => 1 + 2
+  #   hold { 1 / 2 }.simplify   # => 1/2   (Ruby alone would give 0)
+  #   hold { 2 * x**2 / 2 }     # => 2*x**2/2
+  #
+  # Inside the block: literals become Num, bare identifiers and symbols
+  # become Var, the arithmetic operators build nodes, sin/cos/... build Fn,
+  # local variables and constants are read from the block's binding, and any
+  # other method call is performed normally on the held arguments.
+  module Hold
+    OPERATORS = { :+ => Add, :- => Sub, :* => Mul, :/ => Div, :** => Pow }.freeze
+    LITERALS = %i[LIT INTEGER FLOAT RATIONAL IMAGINARY SYM].freeze
+    # Calls kept as formal nodes instead of being evaluated; see Expression#evaluate.
+    FORMAL = %i[integrate diff sum product limit discuss].freeze
+
+    module_function
+
+    IDENTIFIER = RCAS::IDENTIFIER
+
+    # The syntax tree of a piece of source text, without Ruby's lint
+    # warnings. Parsing `x + 1` on its own warns "possibly useless use of +
+    # in void context" under -w, and so does every line of a session that is
+    # read to be inspected (In[n], the chat's checks) rather than run: the
+    # warnings are about the fragment, not about anything the reader wrote
+    # wrong, and the test suite printed dozens of them.
+    def parse(text) = quietly { RubyVM::AbstractSyntaxTree.parse(text) }
+
+    # AbstractSyntaxTree.of parses the block's lines again, with the same
+    # warnings.
+    def quietly
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = verbose
+    end
+
+    # A block whose source cannot be read is refused, never run: running it
+    # is exactly what hold was asked not to do, and `hold { 1 / 2 }` came
+    # back as 0 under Ruby 4 that way (a review, 23 Sept 2026).
+    def hold(block)
+      body = block_body(block)
+      raise RCAS::Unsupported, "hold could not read the block's source, so it cannot keep it unevaluated" if body.nil?
+      Builder.new(block.binding).build(body)
+    end
+
+    # The syntax tree of the block's body. RubyVM::AbstractSyntaxTree.of
+    # reads it directly where the block was compiled by parse.y (Ruby 3.3,
+    # or --parser=parse.y later, which hands back the whole call, ITER,
+    # rather than the block's SCOPE). A block compiled by Prism - the
+    # default since Ruby 3.4 - has no such tree, and `reparsed_body` cuts
+    # its source out by the code location of its instruction sequence.
+    def block_body(block)
+      ast = quietly { RubyVM::AbstractSyntaxTree.of(block, keep_script_lines: true) }
+      ast = ast.children.last if ast&.type == :ITER
+      ast&.children&.last
+    rescue ArgumentError, RuntimeError, IOError, SystemCallError
+      reparsed_body(block)
+    end
+
+    def reparsed_body(block)
+      iseq = RubyVM::InstructionSequence.of(block)
+      l1, c1, l2, c2 = iseq.to_a[4][:code_location]
+      eval_lines = iseq.script_lines
+      lines = eval_lines || (File.readlines(iseq.path) if File.file?(iseq.path))
+      return nil unless lines && l1
+      # a file starts at line 1; code eval'd with a line number (irb's, the
+      # chat's) starts wherever that says, which the block does not record,
+      # so every start that keeps the block inside the text is tried
+      bases = eval_lines ? [1, *(l2 - lines.size + 1..l1)].uniq : [1]
+      bases.each do |base|
+        from, to = l1 - base, l2 - base
+        next if from.negative? || to >= lines.size
+        text = from == to ? lines[from].byteslice(c1...c2) : lines[from].byteslice(c1..) + lines[from + 1...to].join + lines[to].byteslice(0, c2)
+        next unless text&.match?(/\A(\{|do\b)/)
+        node = begin
+          Hold.parse("proc #{text}").children.last
+        rescue SyntaxError
+          next
+        end
+        return node.children.last.children.last if node&.type == :ITER
+      end
+      nil
+    rescue ArgumentError, RuntimeError, IOError, SystemCallError
+      nil
+    end
+
+    # The same for a line of source text instead of a block: the expression
+    # the line builds, held. +context+ is the binding its names are read in.
+    # nil for an empty line; raises SyntaxError on one that does not parse
+    # and ArgumentError on a node hold cannot keep. RCAS::Results uses it
+    # for In[n].
+    def source(text, context = nil)
+      body = parse(text).children.last
+      body = body.children.first if body&.type == :BEGIN # an empty line, or a comment
+      body.nil? ? nil : Builder.new(context || TOPLEVEL_BINDING).build(body)
+    end
+
+    class Builder
+      def initialize(binding)
+        @binding = binding
+      end
+
+      def build(node)
+        case node.type
+        when *LITERALS then literal(node.children.first)
+        when :OPCALL then operator(node)
+        when :LVAR, :DVAR then lift(@binding.local_variable_get(node.children.first))
+        when :VCALL then identifier(node.children.first)
+        when :FCALL then function(node.children[0], arguments(node.children[1]))
+        when :CALL then call(build(node.children[0]), node.children[1], arguments(node.children[2]))
+        when :BLOCK then node.children.map { |c| build(c) }.last
+        when :BEGIN then build(node.children.first)
+        when :HASH then hash_node(node)
+        when :DOT2, :DOT3 then range_node(node)
+        when :CONST, :COLON2, :COLON3 then lift(@binding.eval(constant_path(node)))
+        when :SELF then lift(@binding.receiver)
+        else evaluate(node)
+        end
+      end
+
+      private
+
+      # Anything else (a block call, a string, an array, ...) is evaluated as
+      # written and the value is used.
+      def evaluate(node)
+        source = begin
+          node.source
+        rescue StandardError # user code: a NameError is an answer here
+          nil
+        end
+        raise ArgumentError, "hold: can't keep a #{node.type} node (line #{node.first_lineno})" if source.nil?
+        lift(@binding.eval(source))
+      end
+
+      def literal(value)
+        case value
+        when Symbol then Var.new(value)
+        when Numeric then Num.new(value)
+        else raise ArgumentError, "hold: unsupported literal #{value.inspect}"
+        end
+      end
+
+      def operator(node)
+        receiver, op, list = node.children
+        left = build(receiver)
+        if list.nil?
+          return Neg.new(left) if op == :-@
+          return left if op == :+@
+          raise ArgumentError, "hold: unsupported unary operator #{op}"
+        end
+        right = build(list.children.first)
+        return Equation.new(left, right) if op == :== # hold { x**2 - 3 == 0 } is the equation
+        return Inequality.new(left, :!=, right) if op == :!=
+        klass = OPERATORS[op]
+        klass ? klass.new(left, right) : lift(left.public_send(op, right))
+      end
+
+      # A bare name: a real method of the block's self if there is one
+      # (irb's auto-symbols included), otherwise a variable.
+      # A bare name: a local of the block's binding when one is set (irb
+      # re-parses each line on its own, so earlier locals show up as bare
+      # names), else a real method of the block's self (irb's auto-symbols
+      # included), else a variable. A hoisted-but-unassigned local is nil
+      # and is skipped.
+      def identifier(name)
+        if @binding.local_variable_defined?(name) && !(value = @binding.local_variable_get(name)).nil?
+          return lift(value)
+        end
+        value = @binding.receiver.__send__(name)
+        value.nil? ? Var.new(name) : lift(value) # Kernel#p without arguments returns nil: an indeterminate
+      rescue NameError
+        Var.new(name)
+      end
+
+      def function(name, args)
+        return Pow.new(args.first, Num.new(Rational(1, 2))) if name == :sqrt && args.size == 1
+        return Fn.new(name, args) if Functions::NAMES.include?(name)
+        return formal(name, args) if FORMAL.include?(name)
+        receiver = @binding.receiver
+        target = receiver.respond_to?(name, true) ? receiver : RCAS
+        lift(target.__send__(name, *args))
+      end
+
+      def call(receiver, name, args)
+        klass = OPERATORS[name]
+        return klass.new(receiver, args.first) if klass && args.size == 1
+        return Neg.new(receiver) if name == :-@
+        # RCAS.integrate(f, x) is the same call as a bare integrate(f, x):
+        # outside bin/rcas that qualified form is how the manual writes it.
+        # x.in?(ZZ) inside a block is the statement, not the answer, the way
+        # == is an Equation here and != an Inequality.
+        return Membership.new(receiver, args.first) if name == :in? && args.size == 1 && args.first.is_a?(Domain)
+        return function(name, args) if receiver.equal?(RCAS)
+        return formal(name, [receiver] + args) if FORMAL.include?(name) && receiver.is_a?(Expression)
+        lift(receiver.public_send(name, *args))
+      end
+
+      # integrate(f, x) / integrate(f, x: 0..1), diff(f, x, n), sum(f, k, a, b) /
+      # sum(f, k: 1..n), limit(f, x, a) / limit(f, x: 0), discuss(f, x) as
+      # unevaluated nodes.
+      def formal(name, args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        f = Expression.lift(args.shift)
+        case name
+        when :integrate
+          var, from, to = Functions.range_arguments(*args.values_at(0, 1, 2), opts, "integrate", discrete: false) if args.size < 2 && (opts.any? || args.size == 1)
+          var, from, to = args.values_at(0, 1, 2) if args.size >= 2
+          Integral.new(f, Expression.lift(var), from && Expression.lift(from), to && Expression.lift(to))
+        when :diff
+          var, n = args
+          Derivative.new(f, Expression.lift(var), n.is_a?(Num) ? n.value : (n || 1))
+        when :sum, :product
+          var, from, to = Functions.range_arguments(*args.values_at(0, 1, 2), opts, name.to_s, discrete: true)
+          (name == :sum ? Sum : Product).new(f, Expression.lift(var), Expression.lift(from), Expression.lift(to))
+        when :limit
+          opts = opts.dup
+          opts.delete(:dir)
+          var, point, = Functions.point_arguments(args[0], args[1], nil, opts, "limit")
+          Limit.new(f, Expression.lift(var), Expression.lift(point))
+        when :discuss
+          # A curve discussion has no node of its own: it is a question,
+          # not a value, and steps { discuss(f, x) } is what holds it.
+          Fn.new(:discuss, args.first ? [f, Expression.lift(args.first)] : [f])
+        end
+      end
+
+      # Keyword arguments such as `x: 0..1` (symbol keys stay symbols).
+      def hash_node(node)
+        list = node.children.first
+        return {} if list.nil?
+        list.children.compact.each_slice(2).to_h do |key, value|
+          k = LITERALS.include?(key.type) && key.children.first.is_a?(Symbol) ? key.children.first : build(key)
+          [k, build(value)]
+        end
+      end
+
+      def range_node(node)
+        lo, hi = node.children.map { |c| c.nil? ? nil : build(c) }
+        Range.new(lo, hi, node.type == :DOT3)
+      end
+
+      def arguments(list)
+        return [] if list.nil?
+        list.children.compact.map { |c| build(c) }
+      end
+
+      def constant_path(node)
+        case node.type
+        when :CONST then node.children.first.to_s
+        when :COLON3 then "::#{node.children.first}"
+        when :COLON2 then "#{constant_path(node.children[0])}::#{node.children[1]}"
+        end
+      end
+
+      # Expressions, symbols and numbers become nodes; anything else
+      # (a polynomial, a matrix, a string) is passed through untouched.
+      def lift(value)
+        Expression.lift(value)
+      rescue TypeError
+        value
+      end
+    end
+  end
+
+  def self.hold(&block) = Hold.hold(block)
+end

data/lib/rcas/hypothesis.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Hypothesis tests and confidence intervals.
+  #
+  #   ttest([5.1, 4.9, 5.6, 5.2, 5.0], mu: 5)      # one-sample t test
+  #   ttest(xs, ys)                                 # Welch's two-sample t test
+  #   ttest(xs, ys, paired: true)
+  #   ztest(data, sigma: 2, mu: 100)
+  #   chisquare_test([18, 22, 20, 25, 15])          # goodness of fit
+  #   chisquare_test([[30, 20], [15, 35]])          # independence
+  #   ftest(xs, ys)                                 # ratio of variances
+  #   binomial_test(9, 10)                          # exact, p stays a rational
+  #   confidence_interval(data)                     # t interval for the mean
+  #   confidence_interval(data, parameter: :variance)
+  #   proportion_interval(41, 100)
+  #
+  # A test returns a TestResult: statistic, degrees of freedom, p value,
+  # `reject?(alpha)`. The p values come from the t, chi-square, F and normal
+  # CDFs and are Floats, labelled as numeric; the binomial test is exact.
+  # `alternative:` is :two_sided (the default), :less or :greater.
+  #
+  # Sources (keys: MANUAL.md, Sources): [Ros14, ch. 8-9]; Welch's degrees of
+  # freedom [Wel47]; the exact binomial p value is the sum of the outcomes no
+  # more probable than the observed one [Ros14, §9.7]; Wilson's score interval
+  # for a proportion [Wil27].
+  module Hypothesis
+    ALTERNATIVES = %i[two_sided less greater].freeze
+
+    # The outcome of a test: printable, and usable as a value.
+    class TestResult
+      attr_reader :name, :statistic_name, :statistic, :pvalue, :distribution, :alternative, :estimate, :parameters
+
+      def initialize(name:, statistic:, pvalue:, distribution:, alternative:, statistic_name: "statistic", estimate: nil, parameters: {})
+        @name = name
+        @statistic_name = statistic_name
+        @statistic = Expression.lift(statistic)
+        @pvalue = Expression.lift(pvalue)
+        @distribution = distribution
+        @alternative = alternative
+        @estimate = estimate
+        @parameters = parameters
+        freeze
+      end
+
+      # Is the null hypothesis rejected at this level?
+      def reject?(alpha = 0.05)
+        p = pvalue.evalf
+        raise ArgumentError, "reject?: the p value #{pvalue} is not numeric" unless p.is_a?(Numeric) && !p.is_a?(Complex)
+        p <= alpha
+      end
+
+      # Exact values print exactly, unless the fraction is unwieldy (the exact
+      # binomial p value for n = 100, say); the value itself stays exact.
+      def self.number(value)
+        v = Expression.lift(value)
+        if v.is_a?(Num) && (v.value.is_a?(Integer) || (v.value.is_a?(Rational) && v.value.denominator <= 10**6))
+          return v.to_s
+        end
+        f = v.evalf
+        f.is_a?(Numeric) ? format("%.6g", f) : v.to_s
+      end
+
+      def parameter_text = parameters.map { |k, v| "#{k} = #{self.class.number(v)}" }
+
+      def to_s
+        parts = ["#{statistic_name} = #{self.class.number(statistic)}"] + parameter_text
+        parts << "p = #{self.class.number(pvalue)}"
+        "#{name}: #{parts.join(', ')} (#{alternative.to_s.tr('_', '-')})"
+      end
+
+      def inspect = to_s
+
+      def to_latex(wrap: nil)
+        parts = ["#{LaTeX.escape(statistic_name)} = #{self.class.number(statistic)}"] +
+                parameters.map { |k, v| "#{LaTeX.escape(k.to_s)} = #{self.class.number(v)}" } +
+                ["p = #{self.class.number(pvalue)}"]
+        "\\text{#{LaTeX.escape(name)}}: #{parts.join(',\; ')}"
+      end
+    end
+
+    module_function
+
+    def check_alternative(alternative)
+      raise ArgumentError, "alternative: use #{ALTERNATIVES.join(', ')}" unless ALTERNATIVES.include?(alternative)
+      alternative
+    end
+
+    def float(value, name)
+      v = Expression.lift(value).evalf
+      raise ArgumentError, "#{name}: a real number is needed, got #{value}" unless v.is_a?(Numeric) && !v.is_a?(Complex)
+      v.to_f
+    end
+
+    # P(|T| >= |t|), P(T <= t) or P(T >= t) for a symmetric or one-sided statistic.
+    # The upper tail is the distribution's survival function, not 1 - cdf:
+    # z = 10 has p = 1.5e-23, and 1 - cdf said 0 (third review, P-11).
+    def tail(distribution, statistic, alternative, symmetric: true)
+      t = float(statistic, "p value")
+      case alternative
+      when :less then float(distribution.cdf(t), "p value")
+      when :greater then float(distribution.survival(t), "p value")
+      else
+        if symmetric
+          [2.0 * float(distribution.survival(t.abs), "p value"), 1.0].min
+        else
+          lower = float(distribution.cdf(t), "p value")
+          upper = float(distribution.survival(t), "p value")
+          [2.0 * [lower, upper].min, 1.0].min
+        end
+      end
+    end
+
+    # ---- t tests ---------------------------------------------------------------------
+
+    def ttest(data, other = nil, mu: 0, alternative: :two_sided, paired: false, equal_variance: false)
+      check_alternative(alternative)
+      return one_sample_t(data, mu, alternative) if other.nil?
+      if paired
+        xs = Statistics.data(data, "ttest")
+        ys = Statistics.data(other, "ttest")
+        raise ArgumentError, "ttest: paired samples must have the same length" unless xs.size == ys.size
+        return one_sample_t(xs.zip(ys).map { |x, y| (x - y).simplify }, mu, alternative, name: "paired t test")
+      end
+      two_sample_t(data, other, mu, alternative, equal_variance)
+    end
+
+    def one_sample_t(data, mu, alternative, name: "one-sample t test")
+      values = Statistics.data(data, "ttest")
+      n = values.size
+      raise ArgumentError, "ttest: at least two values are needed" if n < 2
+      mean = Statistics.mean(values)
+      error = (Statistics.stdev(values) / RCAS.sqrt(Num.new(n))).simplify
+      raise ArgumentError, "ttest: the sample has no spread" if Scalar.zero?(error)
+      t = ((mean - Expression.lift(mu)) / error).simplify
+      df = n - 1
+      TestResult.new(name: name, statistic_name: "t", statistic: t, distribution: Distributions::StudentT.new(df),
+                     pvalue: Num.new(tail(Distributions::StudentT.new(df), t, alternative)),
+                     alternative: alternative, estimate: mean, parameters: { df: df })
+    end
+
+    # Welch by default (unequal variances), the pooled test with equal_variance: true.
+    def two_sample_t(xs, ys, mu, alternative, equal_variance)
+      xs = Statistics.data(xs, "ttest")
+      ys = Statistics.data(ys, "ttest")
+      raise ArgumentError, "ttest: at least two values per sample are needed" if xs.size < 2 || ys.size < 2
+      n = xs.size
+      m = ys.size
+      vx = float(Statistics.variance(xs), "ttest")
+      vy = float(Statistics.variance(ys), "ttest")
+      difference = float(Statistics.mean(xs), "ttest") - float(Statistics.mean(ys), "ttest") - float(mu, "ttest")
+      if equal_variance
+        pooled = ((n - 1) * vx + (m - 1) * vy) / (n + m - 2.0)
+        error = Math.sqrt(pooled * (1.0 / n + 1.0 / m))
+        df = n + m - 2
+        name = "two-sample t test"
+      else
+        error = Math.sqrt(vx / n + vy / m)
+        df = (vx / n + vy / m)**2 / ((vx / n)**2 / (n - 1) + (vy / m)**2 / (m - 1))
+        name = "Welch t test"
+      end
+      raise ArgumentError, "ttest: the samples have no spread" if error.zero?
+      t = difference / error
+      distribution = Distributions::StudentT.new(df)
+      TestResult.new(name: name, statistic_name: "t", statistic: Num.new(t), distribution: distribution,
+                     pvalue: Num.new(tail(distribution, t, alternative)), alternative: alternative,
+                     estimate: Num.new(difference), parameters: { df: Num.new(df) })
+    end
+
+    # ---- z test ----------------------------------------------------------------------
+
+    def ztest(data, sigma:, mu: 0, alternative: :two_sided)
+      check_alternative(alternative)
+      values = Statistics.data(data, "ztest")
+      n = values.size
+      mean = Statistics.mean(values)
+      z = ((mean - Expression.lift(mu)) / (Expression.lift(sigma) / RCAS.sqrt(Num.new(n)))).simplify
+      normal = Distributions::Normal.new(0, 1)
+      TestResult.new(name: "z test", statistic_name: "z", statistic: z, distribution: normal,
+                     pvalue: Num.new(tail(normal, z, alternative)), alternative: alternative,
+                     estimate: mean, parameters: { n: n })
+    end
+
+    # ---- chi-square ------------------------------------------------------------------
+
+    # A flat list is a goodness-of-fit test against +expected+ (counts or
+    # probabilities, uniform by default); a list of rows is a test of
+    # independence. +df:+ lowers the degrees of freedom for estimated parameters.
+    def chisquare_test(observed, expected: nil, df: nil, alternative: :greater)
+      check_alternative(alternative)
+      rows = observed.is_a?(Matrix) ? observed.to_a : observed
+      return independence_test(rows) if rows.is_a?(Array) && rows.first.is_a?(Array)
+      goodness_of_fit(rows, expected, df, alternative)
+    end
+
+    def goodness_of_fit(observed, expected, df, alternative)
+      counts = Statistics.data(observed, "chisquare_test")
+      total = counts.reduce(:+).simplify
+      expected = if expected.nil?
+                   Array.new(counts.size) { (total / counts.size).simplify }
+                 else
+                   e = Statistics.data(expected, "chisquare_test")
+                   raise ArgumentError, "chisquare_test: #{e.size} expected values for #{counts.size} observed ones" unless e.size == counts.size
+                   sum = e.reduce(:+).simplify
+                   # probabilities sum to 1 and counts to the number observed;
+                   # anything else is an input error, as R has it (P-16)
+                   if Scalar.zero?((sum - 1).simplify) || close?(sum, 1)
+                     e.map { |v| (v * total).simplify }
+                   elsif Scalar.zero?((sum - total).simplify) || close?(sum, total)
+                     e
+                   elsif e.all? { |v| float(v, "chisquare_test") <= 1 }
+                     raise ArgumentError, "chisquare_test: the expected probabilities sum to #{sum}, not 1"
+                   else
+                     raise ArgumentError, "chisquare_test: the expected counts sum to #{sum}, not to the #{total} observed"
+                   end
+                 end
+      expected.each { |v| raise ArgumentError, "chisquare_test: expected counts must be positive" if float(v, "chisquare_test") <= 0 }
+      statistic = counts.zip(expected).map { |o, e| ((o - e)**2 / e).expand }.reduce(:+).simplify
+      degrees = df || counts.size - 1
+      distribution = Distributions::ChiSquare.new(degrees)
+      TestResult.new(name: "chi-square goodness of fit", statistic_name: "X^2", statistic: statistic,
+                     distribution: distribution, pvalue: Num.new(tail(distribution, statistic, alternative, symmetric: false)),
+                     alternative: alternative, parameters: { df: degrees })
+    end
+
+    def close?(a, b)
+      x = float(a, "chisquare_test")
+      y = float(b, "chisquare_test")
+      (x - y).abs <= 1e-9 * [1.0, y.abs].max
+    end
+
+    def independence_test(rows)
+      table = rows.map { |row| Statistics.data(row, "chisquare_test") }
+      width = table.first.size
+      raise ArgumentError, "chisquare_test: the rows must have the same length" unless table.all? { |r| r.size == width }
+      raise ArgumentError, "chisquare_test: a table of at least 2 by 2 is needed" if table.size < 2 || width < 2
+      total = table.flatten.reduce(:+).simplify
+      row_sums = table.map { |r| r.reduce(:+).simplify }
+      column_sums = (0...width).map { |j| table.map { |r| r[j] }.reduce(:+).simplify }
+      statistic = table.each_with_index.map do |row, i|
+        row.each_with_index.map do |observed, j|
+          expected = (row_sums[i] * column_sums[j] / total).simplify
+          raise ArgumentError, "chisquare_test: a row or column sums to zero" if Scalar.zero?(expected)
+          ((observed - expected)**2 / expected).expand
+        end.reduce(:+)
+      end.reduce(:+).simplify
+      degrees = (table.size - 1) * (width - 1)
+      distribution = Distributions::ChiSquare.new(degrees)
+      TestResult.new(name: "chi-square test of independence", statistic_name: "X^2", statistic: statistic,
+                     distribution: distribution, pvalue: Num.new(tail(distribution, statistic, :greater, symmetric: false)),
+                     alternative: :greater, parameters: { df: degrees })
+    end
+
+    # ---- F test ----------------------------------------------------------------------
+
+    def ftest(xs, ys, alternative: :two_sided)
+      check_alternative(alternative)
+      xs = Statistics.data(xs, "ftest")
+      ys = Statistics.data(ys, "ftest")
+      raise ArgumentError, "ftest: at least two values per sample are needed" if xs.size < 2 || ys.size < 2
+      vx = Statistics.variance(xs)
+      vy = Statistics.variance(ys)
+      raise ArgumentError, "ftest: the second sample has no spread" if Scalar.zero?(vy)
+      f = (vx / vy).simplify
+      distribution = Distributions::FRatio.new(xs.size - 1, ys.size - 1)
+      TestResult.new(name: "F test of two variances", statistic_name: "F", statistic: f, distribution: distribution,
+                     pvalue: Num.new(tail(distribution, f, alternative, symmetric: false)), alternative: alternative,
+                     estimate: f, parameters: { df1: xs.size - 1, df2: ys.size - 1 })
+    end
+
+    # ---- exact binomial test ------------------------------------------------------------
+
+    # Two-sided: the sum of the probabilities of all outcomes no more probable
+    # than the observed one. Exact, so the p value stays a rational.
+    def binomial_test(successes, trials, p: Rational(1, 2), alternative: :two_sided)
+      check_alternative(alternative)
+      k = successes.is_a?(Num) ? successes.value : successes
+      n = trials.is_a?(Num) ? trials.value : trials
+      raise ArgumentError, "binomial_test: 0 <= successes <= trials is needed" unless k.is_a?(Integer) && n.is_a?(Integer) && k >= 0 && k <= n
+      distribution = Distributions::Binomial.new(n, p)
+      probabilities = exact_binomial_pmf(n, p) || (0..n).map { |j| distribution.pdf(j) }
+      pvalue =
+        case alternative
+        when :less then probabilities[0..k].reduce(:+)
+        when :greater then probabilities[k..].reduce(:+)
+        else
+          # "no more probable than the observed one", compared exactly when
+          # the probabilities are exact: as Floats, 2**-1100 underflowed and
+          # every outcome was as improbable as k = 0 (third review, P-12)
+          observed = probabilities[k]
+          exact = probabilities.all? { |q| q.is_a?(Rational) || q.is_a?(Integer) }
+          if exact
+            probabilities.select { |q| q <= observed }.sum
+          else
+            reference = float(observed, "binomial_test")
+            probabilities.select { |q| float(q, "binomial_test") <= reference * (1 + 1e-9) }.reduce(:+)
+          end
+        end
+      TestResult.new(name: "exact binomial test", statistic_name: "k", statistic: Num.new(k), distribution: distribution,
+                     pvalue: Expression.lift(pvalue).simplify, alternative: alternative,
+                     estimate: Num.new(Simplify.normalize_number(Rational(k, n))), parameters: { n: n })
+    end
+
+    # The pmf of Binomial(n, p) for a rational p as Rationals, the
+    # binomial coefficients built up one from the next; nil otherwise.
+    def exact_binomial_pmf(n, p)
+      q = p.is_a?(Num) ? p.value : p
+      return nil unless q.is_a?(Rational) || q.is_a?(Integer)
+      q = Rational(q)
+      coefficient = 1
+      (0..n).map do |j|
+        coefficient = coefficient * (n - j + 1) / j unless j.zero?
+        coefficient * q**j * (1 - q)**(n - j)
+      end
+    end
+
+    # ---- confidence intervals -------------------------------------------------------------
+
+    # For the mean (Student t, or normal when sigma is known), the variance or
+    # the standard deviation of a sample. Returns an Interval.
+    def confidence_interval(data, level: 0.95, sigma: nil, parameter: :mean)
+      values = Statistics.data(data, "confidence_interval")
+      n = values.size
+      raise ArgumentError, "confidence_interval: at least two values are needed" if n < 2
+      alpha = 1.0 - float(level, "confidence_interval")
+      raise ArgumentError, "confidence_interval: level must be in (0, 1)" unless alpha.positive? && alpha < 1
+      case parameter
+      when :mean
+        mean = float(Statistics.mean(values), "confidence_interval")
+        if sigma
+          error = float(sigma, "confidence_interval") / Math.sqrt(n)
+          critical = float(Distributions::Normal.new(0, 1).quantile(1 - alpha / 2), "confidence_interval")
+        else
+          error = float(Statistics.stdev(values), "confidence_interval") / Math.sqrt(n)
+          critical = float(Distributions::StudentT.new(n - 1).quantile(1 - alpha / 2), "confidence_interval")
+        end
+        Interval.closed(Num.new(mean - critical * error), Num.new(mean + critical * error))
+      when :variance, :stdev
+        scaled = (n - 1) * float(Statistics.variance(values), "confidence_interval")
+        chi = Distributions::ChiSquare.new(n - 1)
+        upper = scaled / float(chi.quantile(alpha / 2), "confidence_interval")
+        lower = scaled / float(chi.quantile(1 - alpha / 2), "confidence_interval")
+        lower, upper = [Math.sqrt(lower), Math.sqrt(upper)] if parameter == :stdev
+        Interval.closed(Num.new(lower), Num.new(upper))
+      else raise ArgumentError, "confidence_interval: parameter must be :mean, :variance or :stdev"
+      end
+    end
+
+    # Wilson's score interval for a proportion.
+    def proportion_interval(successes, trials, level: 0.95)
+      k = float(successes, "proportion_interval")
+      n = float(trials, "proportion_interval")
+      raise ArgumentError, "proportion_interval: 0 <= successes <= trials is needed" unless k >= 0 && k <= n && n.positive?
+      alpha = 1.0 - float(level, "proportion_interval")
+      z = float(Distributions::Normal.new(0, 1).quantile(1 - alpha / 2), "proportion_interval")
+      phat = k / n
+      centre = (phat + z * z / (2 * n)) / (1 + z * z / n)
+      spread = z * Math.sqrt(phat * (1 - phat) / n + z * z / (4 * n * n)) / (1 + z * z / n)
+      low = k.zero? ? 0.0 : [centre - spread, 0.0].max
+      high = k == n ? 1.0 : [centre + spread, 1.0].min
+      Interval.closed(Num.new(low), Num.new(high))
+    end
+  end
+end