rcas 0.2.0

data/lib/rcas/gcd.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Polynomial gcd.
+  #
+  # * univariate over a field: Euclid, result monic
+  # * anything over ZZ or QQ (any number of variables): primitive
+  #   pseudo-remainder sequences, recursing on the content in one variable
+  #   at a time; result primitive with positive leading coefficient over ZZ,
+  #   monic (leading coefficient 1 in graded lex order) over QQ
+  #
+  # Sources: primitive PRS [Knu98, §4.6.1, Algorithm E], [GCL92, ch. 7];
+  # extended Euclid [Knu98, §4.5.2, Algorithm X]. Keys: MANUAL.md, Sources.
+  module PolyGCD
+    module_function
+
+    def gcd(f, g)
+      ring = f.ring
+      numeric!(f)
+      numeric!(g)
+
+      if ring.univariate? && ring.base.field? && !exact?(ring.base)
+        return euclid(f, g)
+      end
+
+      if ring.base == ZZ
+        gcd_zz(f, g)
+      elsif ring.base == QQ
+        zz = ZZ[*ring.vars]
+        result = gcd_zz(f.clear_denominators.to_ring(zz), g.clear_denominators.to_ring(zz))
+        result.to_ring(ring).monic
+      else
+        raise RCAS::Unsupported, "gcd over #{ring.base} needs a univariate ring"
+      end
+    end
+
+    def lcm(f, g)
+      return f.ring.zero if f.zero? || g.zero?
+      (f * g).exact_div(gcd(f, g))
+    end
+
+    # Extended Euclid over a field: returns [g, s, t] with s*f + t*g = gcd, gcd monic.
+    def xgcd(f, g)
+      ring = f.ring
+      raise RCAS::Unsupported, "xgcd needs a univariate ring over a field" unless ring.univariate? && ring.base.field?
+      r0, r1 = f, g
+      s0, s1 = ring.one, ring.zero
+      t0, t1 = ring.zero, ring.one
+      until r1.zero?
+        q, r = r0.divmod(r1)
+        r0, r1 = r1, r
+        s0, s1 = s1, s0 - q * s1
+        t0, t1 = t1, t0 - q * t1
+      end
+      return [ring.zero, ring.zero, ring.zero] if r0.zero?
+      inv = Scalar.div(Num.new(1), r0.leading_coefficient)
+      [r0 * inv, s0 * inv, t0 * inv]
+    end
+
+    # ---- internals --------------------------------------------------------
+
+    def exact?(base) = base == ZZ || base == QQ
+
+    def numeric!(f)
+      return if f.terms.values.all? { |c| c.is_a?(Num) && (c.value.is_a?(Integer) || c.value.is_a?(Rational) || !exact?(f.ring.base)) }
+      raise DomainError, "gcd needs numeric coefficients, got #{f}"
+    end
+
+    def euclid(a, b)
+      a, b = b, a % b until b.zero?
+      a.monic
+    end
+
+    def gcd_zz(f, g)
+      return g.primitive_part if f.zero?
+      return f.primitive_part if g.zero?
+
+      x = (f.ring.vars.find { |v| f.degree(v).positive? || g.degree(v).positive? })
+      if x.nil?
+        return Polynomial.constant(f.ring, f.constant_term.value.gcd(g.constant_term.value))
+      end
+
+      cf = content_in(f, x)
+      cg = content_in(g, x)
+      c = gcd_zz(cf, cg)
+      a = f.exact_div(cf)
+      b = g.exact_div(cg)
+      until b.zero?
+        r = prem(a, b, x)
+        a, b = b, (r.zero? ? r : r.exact_div(content_in(r, x)))
+      end
+      c * a.exact_div(content_in(a, x)).primitive_part
+    end
+
+    # gcd of the coefficients of f seen as a polynomial in x.
+    def content_in(f, x)
+      coeffs = (0..f.degree(x)).map { |k| f.coefficient_in(x, k) }.reject(&:zero?)
+      coeffs.reduce { |acc, c| gcd_zz(acc, c) }
+    end
+
+    # Pseudo-remainder of a by b with respect to x (no fractions introduced).
+    def prem(a, b, x)
+      db = b.degree(x)
+      lb = b.leading_coefficient_in(x)
+      r = a
+      while !r.zero? && (dr = r.degree(x)) >= db
+        r = lb * r - r.leading_coefficient_in(x) * b.shift(x, dr - db)
+      end
+      r
+    end
+  end
+end

data/lib/rcas/geometry.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Plane geometry with exact coordinates: points, lines and circles, and the
+  # questions a school course asks about them.
+  #
+  #   a = point(0, 0); b = point(4, 0); c = point(0, 3)
+  #   distance(a, b)                  # => 4
+  #   distance(c, line(a, b))         # => 3     (the distance to a line)
+  #   angle(b, a, c)                  # => pi/2
+  #   area(a, b, c)                   # => 6
+  #   intersect(line(a, c), circle(a, 2))
+  #   perpendicular_bisector(a, b)
+  #
+  # Everything is exact: a distance is a square root, an angle a multiple of
+  # pi where the cosine is a known value, and a float only when you ask with
+  # evalf. Coordinates may be symbolic.
+  #
+  # Sources (keys: MANUAL.md, Sources): analytic geometry as in [Spi08,
+  # ch. 4]; the shoelace formula for the area [Bra86].
+  module Geometry
+    class Error < ArgumentError; end
+
+    # A point of the plane.
+    class Point
+      attr_reader :x, :y
+
+      def initialize(x, y)
+        @x = Expression.lift(x).simplify
+        @y = Expression.lift(y).simplify
+        freeze
+      end
+
+      def coordinates = [x, y]
+      def +(other) = Point.new(x + other.x, y + other.y)
+      def -(other) = Point.new(x - other.x, y - other.y)
+      def *(factor) = Point.new(x * factor, y * factor)
+      def to_vector = VectorSpace.new(RR, 2).unchecked([x, y])
+      def to_s = "(#{x}, #{y})"
+      def inspect = to_s
+      def to_latex(wrap: nil) = "\\left(#{LaTeX.of(x)},\; #{LaTeX.of(y)}\\right)"
+      def ==(other) = other.is_a?(Point) && Scalar.zero?((x - other.x).simplify) && Scalar.zero?((y - other.y).simplify)
+      alias eql? ==
+      def hash = [Point, x, y].hash
+      def evalf = Point.new(Num.new(x.evalf), Num.new(y.evalf))
+    end
+
+    # The line a*x + b*y + c = 0, kept in that form so that vertical lines
+    # need no special case.
+    class Line
+      attr_reader :a, :b, :c
+
+      def initialize(a, b, c)
+        a = Expression.lift(a).simplify
+        b = Expression.lift(b).simplify
+        c = Expression.lift(c).simplify
+        raise Error, "a line needs a direction: a and b cannot both be zero" if Scalar.zero?(a) && Scalar.zero?(b)
+        @a, @b, @c = normalize(a, b, c)
+        freeze
+      end
+
+      # Scale so that the first non-zero coefficient is positive and, when the
+      # coefficients are rational, integral and coprime.
+      def normalize(a, b, c)
+        values = [a, b, c]
+        if values.all? { |v| v.is_a?(Num) && (v.value.is_a?(Integer) || v.value.is_a?(Rational)) }
+          rationals = values.map { |v| Rational(v.value) }
+          scale = rationals.map(&:denominator).reduce(1, :lcm)
+          integers = rationals.map { |r| (r * scale).to_i }
+          divisor = integers.reject(&:zero?).map(&:abs).reduce(0, :gcd)
+          integers = integers.map { |i| i / divisor } unless divisor.zero?
+          integers = integers.map(&:-@) if (integers.find { |i| !i.zero? } || 0).negative?
+          return integers.map { |i| Num.new(i) }
+        end
+        values
+      end
+
+      def self.through(p, q)
+        raise Error, "the two points are the same" if p == q
+        a = q.y - p.y
+        b = p.x - q.x
+        new(a, b, -(a * p.x + b * p.y))
+      end
+
+      def self.point_slope(p, slope)
+        slope = Expression.lift(slope)
+        new(slope, -1, p.y - slope * p.x)
+      end
+
+      def slope = Scalar.zero?(b) ? nil : (-a / b).simplify         # nil: vertical
+      def intercept = Scalar.zero?(b) ? nil : (-c / b).simplify
+      def direction = [(-b).simplify, a]
+      def normal_vector = [a, b]
+      def equation(x = :x, y = :y) = Equation.new((a * Expression.lift(x) + b * Expression.lift(y) + c).simplify, 0)
+      def contains?(p) = Scalar.zero?((a * p.x + b * p.y + c).simplify)
+      def parallel?(other) = Scalar.zero?((a * other.b - b * other.a).simplify)
+      def perpendicular?(other) = Scalar.zero?((a * other.a + b * other.b).simplify)
+
+      # The point of the line closest to p.
+      def foot(p)
+        t = ((a * p.x + b * p.y + c) / (a**2 + b**2)).simplify
+        Point.new(p.x - a * t, p.y - b * t)
+      end
+
+      def to_s = equation.to_s
+      def inspect = to_s
+      def to_latex(wrap: nil) = "#{LaTeX.of(equation)}"
+      def ==(other) = other.is_a?(Line) && parallel?(other) && Scalar.zero?((a * other.c - c * other.a).simplify) && Scalar.zero?((b * other.c - c * other.b).simplify)
+      alias eql? ==
+      def hash = [Line, a, b, c].hash
+    end
+
+    class Circle
+      attr_reader :center, :radius
+
+      def initialize(center, radius)
+        @center = center
+        @radius = Expression.lift(radius).simplify
+        raise Error, "a circle needs a positive radius" if @radius.is_a?(Num) && !@radius.value.positive?
+        freeze
+      end
+
+      def equation(x = :x, y = :y)
+        x = Expression.lift(x)
+        y = Expression.lift(y)
+        Equation.new(((x - center.x)**2 + (y - center.y)**2).simplify, (radius**2).simplify)
+      end
+
+      def area = (PI * radius**2).simplify
+      def circumference = (2 * PI * radius).simplify
+      def contains?(p) = Scalar.zero?(((p.x - center.x)**2 + (p.y - center.y)**2 - radius**2).expand)
+      def to_s = "circle(#{center}, #{radius})"
+      def inspect = to_s
+      def to_latex(wrap: nil) = LaTeX.of(equation)
+      def ==(other) = other.is_a?(Circle) && center == other.center && Scalar.zero?((radius - other.radius).simplify)
+      alias eql? ==
+      def hash = [Circle, center, radius].hash
+    end
+
+    module_function
+
+    def point(x, y = nil)
+      return x if x.is_a?(Point)
+      return Point.new(x[0], x[1]) if x.is_a?(Array)
+      Point.new(x, y)
+    end
+
+    def line(first, second = nil, slope: nil)
+      return first if first.is_a?(Line) && second.nil?
+      p = point(first)
+      return Line.point_slope(p, slope) if slope
+      Line.through(p, point(second))
+    end
+
+    def circle(center, radius) = Circle.new(point(center), radius)
+
+    def midpoint(p, q) = Point.new(((p.x + q.x) / 2).simplify, ((p.y + q.y) / 2).simplify)
+
+    # Point to point, point to line (either order), or between parallel lines.
+    def distance(a, b)
+      return point_distance(a, b) if a.is_a?(Point) && b.is_a?(Point)
+      return line_distance(b, a) if a.is_a?(Line) && b.is_a?(Point)
+      return line_distance(a, b) if a.is_a?(Point) && b.is_a?(Line)
+      if a.is_a?(Line) && b.is_a?(Line)
+        raise Error, "the lines meet, so their distance is zero only there" unless a.parallel?(b)
+        return line_distance(point_on(b), a)
+      end
+      raise Error, "distance: give two points, a point and a line, or two parallel lines"
+    end
+
+    def point_distance(p, q) = RCAS.sqrt(((q.x - p.x)**2 + (q.y - p.y)**2).expand).simplify
+
+    def line_distance(p, l) = (RCAS.abs(l.a * p.x + l.b * p.y + l.c) / RCAS.sqrt((l.a**2 + l.b**2).expand)).simplify
+
+    def point_on(l)
+      Scalar.zero?(l.b) ? Point.new((-l.c / l.a).simplify, 0) : Point.new(0, (-l.c / l.b).simplify)
+    end
+
+    # The angle at b in the corner a-b-c, exact where the cosine is known.
+    def angle(a, b, c)
+      u = [a.x - b.x, a.y - b.y]
+      v = [c.x - b.x, c.y - b.y]
+      dot = (u[0] * v[0] + u[1] * v[1]).expand
+      norms = RCAS.sqrt((u[0]**2 + u[1]**2).expand) * RCAS.sqrt((v[0]**2 + v[1]**2).expand)
+      raise Error, "angle: the corner point coincides with another" if Scalar.zero?(norms.simplify)
+      RCAS.acos((dot / norms).simplify)
+    end
+
+    # The angle between two lines, in [0, pi/2].
+    def line_angle(l, m)
+      cosine = (RCAS.abs(l.a * m.a + l.b * m.b) / (RCAS.sqrt((l.a**2 + l.b**2).expand) * RCAS.sqrt((m.a**2 + m.b**2).expand))).simplify
+      RCAS.acos(cosine)
+    end
+
+    # Triangle area by the shoelace formula, or the area of a circle.
+    def area(a, b = nil, c = nil)
+      return a.area if a.is_a?(Circle)
+      (RCAS.abs(((b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y)).expand) / 2).simplify
+    end
+
+    def perimeter(a, b = nil, c = nil)
+      return a.circumference if a.is_a?(Circle)
+      (point_distance(a, b) + point_distance(b, c) + point_distance(c, a)).simplify
+    end
+
+    def collinear?(a, b, c) = Scalar.zero?(((b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y)).expand)
+
+    def centroid(*points)
+      points = points.flatten
+      Point.new(points.map(&:x).reduce(:+) / points.size, points.map(&:y).reduce(:+) / points.size)
+    end
+
+    def perpendicular_bisector(p, q)
+      m = midpoint(p, q)
+      Line.new(q.x - p.x, q.y - p.y, (-((q.x - p.x) * m.x + (q.y - p.y) * m.y)).expand)
+    end
+
+    def parallel_through(l, p) = Line.new(l.a, l.b, (-(l.a * p.x + l.b * p.y)).expand)
+    def perpendicular_through(l, p) = Line.new(l.b, -l.a, (-(l.b * p.x - l.a * p.y)).expand)
+
+    # The circle through three points that do not lie on a line.
+    def circumcircle(a, b, c)
+      raise Error, "the three points lie on a line" if collinear?(a, b, c)
+      centre = intersect(perpendicular_bisector(a, b), perpendicular_bisector(b, c))
+      Circle.new(centre, point_distance(centre, a))
+    end
+
+    # => a Point, an Array of points, nil (nothing), or the shared line or circle.
+    def intersect(first, second)
+      case [first, second]
+      in [Line, Line] then line_line(first, second)
+      in [Line, Circle] then line_circle(first, second)
+      in [Circle, Line] then line_circle(second, first)
+      in [Circle, Circle] then circle_circle(first, second)
+      else raise Error, "intersect: give two lines, a line and a circle, or two circles"
+      end
+    end
+
+    def line_line(l, m)
+      determinant = (l.a * m.b - m.a * l.b).simplify
+      return (l == m ? l : nil) if Scalar.zero?(determinant)
+      Point.new(((l.b * m.c - m.b * l.c) / determinant).simplify, ((m.a * l.c - l.a * m.c) / determinant).simplify)
+    end
+
+    def line_circle(l, k)
+      foot = l.foot(k.center)
+      gap = (k.radius**2 - point_distance(foot, k.center)**2).simplify
+      value = gap.is_a?(Num) ? gap.value : gap.evalf
+      return [] if value.is_a?(Numeric) && value.negative?
+      return [foot] if Scalar.zero?(gap)
+      step = (RCAS.sqrt(gap) / RCAS.sqrt((l.a**2 + l.b**2).expand)).simplify
+      direction = l.direction
+      [Point.new((foot.x + direction[0] * step).simplify, (foot.y + direction[1] * step).simplify),
+       Point.new((foot.x - direction[0] * step).simplify, (foot.y - direction[1] * step).simplify)]
+    end
+
+    # Subtracting the two circle equations leaves the radical line.
+    def circle_circle(k, l)
+      return (k == l ? k : nil) if k.center == l.center
+      radical = Line.new((2 * (l.center.x - k.center.x)).simplify,
+                         (2 * (l.center.y - k.center.y)).simplify,
+                         (k.center.x**2 + k.center.y**2 - l.center.x**2 - l.center.y**2 - k.radius**2 + l.radius**2).expand)
+      line_circle(radical, k)
+    end
+  end
+end

data/lib/rcas/groebner.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Gröbner bases.
+  #
+  #   G = groebner([x**2 + y**2 - 1, x - y], [x, y])   # reduced lex basis
+  #   reduce(x**3, G, [x, y])                          # normal form; 0 iff x**3 is in the ideal
+  #
+  # Buchberger's algorithm with the product criterion (coprime leading
+  # monomials give nothing new), normal forms by the multivariate division
+  # algorithm, and the basis made reduced (minimal, inter-reduced, monic) at
+  # the end. Monomial orders: :lex (the default, for elimination and
+  # solving), :grlex, :grevlex; the variables are compared in the order given.
+  #
+  # Sources (keys: MANUAL.md, Sources): [Buc65]; [CLO15, ch. 2 §§3, 7, 9-10;
+  # ch. 3 §1; ch. 5 §3]; [GCL92, ch. 10].
+  module Groebner
+    ORDERS = %i[lex grlex grevlex].freeze
+
+    module_function
+
+    # ---- monomial orders -------------------------------------------------------
+
+    def order_key(exps, order)
+      case order
+      when :lex then exps
+      when :grlex then [exps.sum, exps]
+      when :grevlex then [exps.sum, exps.reverse.map(&:-@)]
+      else raise ArgumentError, "unknown monomial order #{order.inspect}; use one of #{ORDERS.join(', ')}"
+      end
+    end
+
+    # => [exponent vector, coefficient] of the leading term
+    def leading(poly, order)
+      e = poly.terms.keys.max_by { |k| order_key(k, order) }
+      [e, poly.terms[e]]
+    end
+
+    def divides?(a, b) = a.zip(b).all? { |x, y| x <= y }
+
+    # ---- division and S-polynomials --------------------------------------------
+
+    # Normal form of f modulo the polynomials gs [CLO15, ch. 2 §3].
+    def reduce(f, gs, order = :lex)
+      ring = f.ring
+      gs = gs.reject(&:zero?)
+      leads = gs.map { |g| leading(g, order) }
+      remainder = {}
+      p = f
+      until p.zero?
+        ep, cp = leading(p, order)
+        i = leads.index { |eg, _| divides?(eg, ep) }
+        if i
+          eg, cg = leads[i]
+          shift = ep.zip(eg).map { |a, b| a - b }
+          p -= Polynomial.new(ring, { shift => Scalar.div(cp, cg) }) * gs[i]
+        else
+          remainder[ep] = cp
+          p -= Polynomial.new(ring, { ep => cp })
+        end
+      end
+      Polynomial.new(ring, remainder)
+    end
+
+    def s_polynomial(f, g, order)
+      ef, cf = leading(f, order)
+      eg, cg = leading(g, order)
+      l = ef.zip(eg).map(&:max)
+      mf = Polynomial.new(f.ring, { l.zip(ef).map { |a, b| a - b } => Scalar.div(Num.new(1), cf) })
+      mg = Polynomial.new(f.ring, { l.zip(eg).map { |a, b| a - b } => Scalar.div(Num.new(1), cg) })
+      mf * f - mg * g
+    end
+
+    # ---- Buchberger ----------------------------------------------------------------
+
+    # Reduced Gröbner basis of the ideal generated by polys (ring elements).
+    def basis(polys, order = :lex)
+      g = polys.reject(&:zero?)
+      return [] if g.empty?
+      ring = g.first.ring
+      g = g.map { |p| monic(p.ring == ring ? p : p.to_ring(ring), order) }
+      pairs = (0...g.size).to_a.combination(2).to_a
+      until pairs.empty?
+        i, j = pairs.shift
+        next if coprime?(leading(g[i], order).first, leading(g[j], order).first) # product criterion
+        s = reduce(s_polynomial(g[i], g[j], order), g, order)
+        next if s.zero?
+        g << s
+        k = g.size - 1
+        pairs.concat((0...k).map { |m| [m, k] })
+        return [ring.one] if s.constant?
+      end
+      interreduce(g, order)
+    end
+
+    def coprime?(a, b) = a.zip(b).all? { |x, y| x.zero? || y.zero? }
+
+    # Minimal (no leading monomial divides another), every element reduced
+    # modulo the others, monic; sorted by leading monomial, largest first.
+    def interreduce(g, order)
+      sorted = g.reject(&:zero?).sort_by { |p| order_key(leading(p, order).first, order) }
+      minimal = []
+      sorted.each do |p|
+        ep = leading(p, order).first
+        minimal << p unless minimal.any? { |q| divides?(leading(q, order).first, ep) }
+      end
+      reduced = minimal.dup
+      minimal.each_index do |i|
+        others = reduced.each_with_index.reject { |_, j| j == i }.map(&:first)
+        reduced[i] = monic(reduce(reduced[i], others, order), order)
+      end
+      reduced.sort_by { |p| order_key(leading(p, order).first, order) }.reverse
+    end
+
+    def monic(p, order)
+      return p if p.zero?
+      _, c = leading(p, order)
+      Scalar.one?(c) ? p : p * Scalar.div(Num.new(1), c)
+    end
+
+    # ---- the ideal ------------------------------------------------------------------
+
+    # Finitely many solutions? Every variable must be the leading monomial of
+    # some basis element as a pure power [CLO15, ch. 5 §3, Theorem 6].
+    def zero_dimensional?(basis, order = :lex)
+      return false if basis.empty?
+      n = basis.first.ring.vars.size
+      (0...n).all? do |i|
+        basis.any? do |p|
+          e = leading(p, order).first
+          e[i].positive? && e.each_with_index.all? { |v, j| j == i || v.zero? }
+        end
+      end
+    end
+
+    # ---- expression front end -----------------------------------------------------
+
+    # groebner([f, g], [x, y]) with expressions: the ring is QQ[x, y], or
+    # Frac(QQ[params])[x, y] when other symbols occur in the coefficients.
+    def groebner(polys, vars = nil, order: :lex)
+      _ring, elements = lift(polys, vars)
+      basis(elements, order)
+    end
+
+    def normal_form(f, basis, vars = nil, order: :lex)
+      _ring, elements = lift(basis + [f], vars)
+      reduce(elements.last, elements[0...-1], order)
+    end
+
+    def lift(polys, vars)
+      polys = Array(polys).map { |p| p.is_a?(Polynomial) ? p : Expression.lift(p) }
+      if vars.nil? || Array(vars).empty?
+        vars = polys.flat_map { |p| p.is_a?(Polynomial) ? p.ring.vars : p.variables }.uniq.sort
+        raise ArgumentError, "groebner: no variables in #{polys.map(&:to_s).join(', ')}" if vars.empty?
+      end
+      vars = Array(vars).map { |v| v.is_a?(Var) ? v.name : v.to_sym }
+      params = polys.flat_map { |p| p.is_a?(Polynomial) ? p.ring.vars : p.variables }.uniq - vars
+      ring = params.empty? ? QQ[*vars] : QQ[*params].fraction_field[*vars]
+      [ring, polys.map { |p| p.is_a?(Polynomial) ? p.to_ring(ring) : ring.call(p) }]
+    end
+  end
+end