sevgi-geometry 0.98.2 → 1.0.0

data/lib/sevgi/geometry/elements/ellipse.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    # rubocop:disable Metrics/ClassLength
+
+    # Immutable ellipse with positive radii, a center, and clockwise axis rotation.
+    # Parameter angles belong to the local ellipse axes, not to polar directions from the center.
+    # @example Select a finite boundary and inspect its endpoints
+    #   ellipse = Sevgi::Geometry::Ellipse[4, 2, position: [10, 20]]
+    #   ellipse.point(90).deconstruct # => [10.0, 22.0]
+    #   ellipse.arc(starting_angle: 0, extent: 90).ending == ellipse.point(90)
+    class Ellipse < Element::Arced
+      # Builds an ellipse from local radii and its position.
+      # @param rx [Numeric] positive local x radius
+      # @param ry [Numeric] positive local y radius
+      # @param position [Sevgi::Geometry::Point, Array<Numeric>] ellipse center
+      # @param rotation [Numeric] clockwise rotation in degrees
+      # @return [Sevgi::Geometry::Ellipse]
+      # @raise [Sevgi::Geometry::Error] when inputs are not finite real values or a radius is not positive
+      def self.[](rx, ry, position: Origin, rotation: 0) = new(rx, ry, position:, rotation:)
+
+      def self.close? = true
+      private_class_method :close?
+
+      # @return [Sevgi::Geometry::Point] ellipse center
+      attr_reader :position
+      # @return [Float] clockwise rotation of the local axes in degrees
+      attr_reader :rotation
+      # @return [Float] positive local x radius
+      attr_reader :rx
+      # @return [Float] positive local y radius
+      attr_reader :ry
+
+      # Creates an ellipse. Use the bracket constructor.
+      # @param rx [Numeric] positive local x radius
+      # @param ry [Numeric] positive local y radius
+      # @param position [Sevgi::Geometry::Point, Array<Numeric>] center
+      # @param rotation [Numeric] clockwise rotation in degrees
+      # @return [void]
+      # @raise [Sevgi::Geometry::Error] when an input is invalid
+      def initialize(rx, ry, position:, rotation:)
+        super()
+        @rx, @ry = [[:rx, rx], [:ry, ry]].map do |field, value|
+          value = Real[field, value]
+          Error.("Ellipse #{field} must be positive") unless value.positive?
+          value
+        end
+
+        @position = Tuple[Point, position]
+        @rotation = Real[:rotation, rotation]
+      end
+
+      # Rebuilds an ellipse from rounded canonical fields.
+      # @param precision [Integer, nil] decimal precision, or nil for the current function default
+      # @return [Sevgi::Geometry::Ellipse, Sevgi::Geometry::Circle]
+      # @raise [Sevgi::Geometry::Error] when rounding makes a radius zero
+      # @raise [Sevgi::ArgumentError] when precision is invalid
+      def approx(precision = nil)
+        rebuild(
+          F.approx(rx, precision),
+          F.approx(ry, precision),
+          position.approx(precision),
+          F.approx(rotation, precision)
+        )
+      end
+
+      # Selects a finite, directed arc on this ellipse.
+      # @param starting_angle [Numeric] local starting parameter angle in degrees
+      # @param extent [Numeric] signed angular extent strictly between -360 and 360 degrees
+      # @return [Sevgi::Geometry::Arc]
+      # @raise [Sevgi::Geometry::Error] when angles are invalid
+      def arc(extent:, starting_angle: 0)
+        parent = is_a?(Circle) ? Ellipse[rx, ry, position:] : self
+        Arc.send(:new, parent, starting_angle:, extent:)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+
+      # Returns the axis-aligned bounds without display rounding.
+      # @return [Sevgi::Geometry::Rect]
+      def box
+        cosine, sine = F.cos(rotation), F.sin(rotation)
+        dx = ::Math.hypot(rx * cosine, ry * sine)
+        dy = ::Math.hypot(rx * sine, ry * cosine)
+        Rect.from_corners([position.x - dx, position.y - dy], [position.x + dx, position.y + dy])
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      # Reports whether the radii are exactly equal.
+      # @return [Boolean]
+      def circular? = rx == ry
+
+      # rubocop:disable Metrics/AbcSize
+
+      # Draws an SVG ellipse using original geometric values.
+      # @param node [Object] graphics node receiving the element
+      # @param attributes [Hash] SVG attributes, including an optional outer transform
+      # @return [Object] graphics command result
+      def draw(node, **attributes)
+        unless rotation.zero?
+          transform = "rotate(#{rotation} #{position.x} #{position.y})"
+          attributes = attributes.merge(transform: [attributes[:transform], transform].compact.join(" "))
+        end
+
+        node.ellipse(cx: position.x, cy: position.y, rx:, ry:, **attributes)
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      # Reports whether the ellipse has zero angular extent. A complete ellipse is never empty.
+      # @return [Boolean]
+      def empty? = false
+
+      # Returns the complete quadratic carrier.
+      # @return [Sevgi::Geometry::Equation::Quadratic]
+      def equation = @equation ||= Equation.quadratic(*coefficients, origin: position)
+
+      # Returns the immutable collection containing the complete carrier.
+      # @return [Array<Sevgi::Geometry::Equation::Quadratic>]
+      def equations = @equations ||= [equation].freeze
+
+      # Reports whether a point is inside or on the boundary.
+      # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
+      # @return [Boolean]
+      # @raise [Sevgi::Geometry::Error] when point cannot be coerced
+      def inside?(point)
+        point = Tuple[Point, point]
+        local = local(point)
+        ::Math.hypot(local.x / rx, local.y / ry) < 1.0 || on?(point)
+      end
+
+      # Returns the perimeter with thread-independent numerical accuracy.
+      # @return [Float]
+      # @raise [Sevgi::Geometry::Error] when length is not finite or integration cannot meet its error target
+      def length = @length ||= arc_length(0, 360)
+
+      # Reports whether a point matches its radial boundary reference at the current coordinate precision.
+      # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
+      # @return [Boolean]
+      # @raise [Sevgi::Geometry::Error] when point cannot be coerced
+      def on?(point)
+        point = Tuple[Point, point]
+        point != position && point.eq?(self.point(parameter(point)))
+      end
+
+      # Returns the closed boundary length.
+      # @return [Float]
+      def perimeter = length
+
+      # Evaluates the boundary at a local parameter angle.
+      # @param angle [Numeric] clockwise local angle in degrees
+      # @return [Sevgi::Geometry::Point]
+      # @raise [Sevgi::Geometry::Error] when angle or the resulting coordinates are not finite
+      def point(angle)
+        angle = Real[:angle, angle] % 360.0
+        Point[rx * F.cos(angle), ry * F.sin(angle)].rotate(rotation).translate(position.x, position.y)
+      end
+
+      # Returns a reflected copy, preserving Circle where applicable.
+      # @param x [Boolean] reflect across the x-axis
+      # @param y [Boolean] reflect across the y-axis
+      # @return [Sevgi::Geometry::Ellipse, Sevgi::Geometry::Circle]
+      # @raise [Sevgi::Geometry::Error] when a flag is not Boolean
+      def reflect(x: true, y: true) = affine(:reflect, x:, y:).first
+
+      # Rotates the center around the origin and the ellipse axes by the same angle.
+      # @param angle [Numeric] clockwise angle in degrees
+      # @return [Sevgi::Geometry::Ellipse, Sevgi::Geometry::Circle]
+      # @raise [Sevgi::Geometry::Error] when the angle or resulting geometry is invalid
+      def rotate(angle)
+        angle = Real[:angle, angle]
+        rebuild(rx, ry, position.rotate(angle), rotation + angle)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+
+      # Scales the ellipse from the origin. Unequal factors can widen Circle to Ellipse.
+      # @param sx [Numeric] x scale factor
+      # @param sy [Numeric, Sevgi::Undefined] y factor, defaulting to sx
+      # @return [Sevgi::Geometry::Ellipse, Sevgi::Geometry::Circle]
+      # @raise [Sevgi::Geometry::Error] when the transform is singular or the resulting geometry is invalid
+      def scale(sx, sy = Undefined)
+        sx, sy = Real[:sx, sx], Real[:sy, Undefined.default(sy, sx)]
+        return affine(:scale, sx, sy).first unless sx == sy
+
+        rebuild(rx * sx.abs, ry * sy.abs, position.scale(sx, sy), rotation + (sx.negative? ? 180 : 0))
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      # Skews the ellipse from the origin.
+      # @param ax [Numeric] x-axis skew angle in degrees
+      # @param ay [Numeric, Sevgi::Undefined] y-axis angle, defaulting to ax
+      # @return [Sevgi::Geometry::Ellipse, Sevgi::Geometry::Circle]
+      # @raise [Sevgi::Geometry::Error] when the transform is singular or the resulting geometry is invalid
+      def skew(ax, ay = Undefined) = affine(:skew, ax, ay).first
+
+      # Skews the ellipse along x.
+      # @param angle [Numeric] skew angle in degrees
+      # @return [Sevgi::Geometry::Ellipse, Sevgi::Geometry::Circle]
+      # @raise [Sevgi::Geometry::Error] when the angle or resulting geometry is invalid
+      def skew_x(angle) = affine(:skew_x, angle).first
+
+      # Skews the ellipse along y.
+      # @param angle [Numeric] skew angle in degrees
+      # @return [Sevgi::Geometry::Ellipse, Sevgi::Geometry::Circle]
+      # @raise [Sevgi::Geometry::Error] when the angle or resulting geometry is invalid
+      def skew_y(angle) = affine(:skew_y, angle).first
+
+      # Returns a translated copy.
+      # @param dx [Numeric] x offset
+      # @param dy [Numeric, Sevgi::Undefined] y offset, defaulting to dx
+      # @return [Sevgi::Geometry::Ellipse, Sevgi::Geometry::Circle]
+      # @raise [Sevgi::Geometry::Error] when offsets or the resulting center are invalid
+      def translate(dx, dy = Undefined) = rebuild(rx, ry, position.translate(dx, dy), rotation)
+
+      alias center position
+
+      private
+
+      def affine(...) = Affine.new(self).transform(...)
+
+      def arc_length(starting_angle, extent)
+        return Real[:length, rx * F.to_radians(extent.abs)] if circular?
+
+        Length.new(rx, ry).integrate(starting_angle, extent)
+      end
+
+      # rubocop:disable-next Metrics/AbcSize
+      def coefficients
+        cosine, sine = F.cos(rotation), F.sin(rotation)
+        a = ((cosine / rx) ** 2) + ((sine / ry) ** 2)
+        b = 2 * cosine * sine * (((1.0 / rx) ** 2) - ((1.0 / ry) ** 2))
+        c = ((sine / rx) ** 2) + ((cosine / ry) ** 2)
+        [a, b, c, 0, 0, -1]
+      end
+
+      # rubocop:disable-next Metrics/AbcSize
+      def extrema
+        cosine, sine = F.cos(rotation), F.sin(rotation)
+        x = F.atan2(-ry * sine, rx * cosine)
+        y = F.atan2(ry * cosine, rx * sine)
+        [x, x + 180, y, y + 180]
+      end
+
+      def local(point) = point.translate(-position.x, -position.y).rotate(-rotation)
+
+      def parameter(point)
+        point = local(point)
+        F.to_degrees(::Math.atan2(point.y / ry, point.x / rx))
+      end
+
+      def rebuild(rx, ry, position, rotation)
+        return Circle[rx, position:] if is_a?(Circle) && rx == ry
+
+        Ellipse[rx, ry, position:, rotation:]
+      end
+
+      def state = [position, rx, ry, rotation]
+
+      require_relative "ellipse/affine"
+      require_relative "ellipse/length"
+    end
+
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/sevgi/geometry/elements/line.rb

@@ -10,7 +10,7 @@ module Sevgi
     # Finite, directed line between two endpoints.
     #
     # Direction affects {#left?}, {#right?}, and the sign of {#shift}. Use
-    # {#equation} when the corresponding infinite line is required; {#over?}
+    # {#equation} when the corresponding infinite line is required. {#over?}
     # deliberately tests only the finite extent between the endpoints.
     # @example Query sides of a directed line in screen coordinates
     #   line = Sevgi::Geometry::Line.([0, 0], [10, 0])
@@ -27,6 +27,15 @@ module Sevgi
     #   @param ending [Sevgi::Geometry::Point, Array<Numeric>] ending point
     #   @return [Sevgi::Geometry::Line]
     #   @raise [Sevgi::Geometry::Error] when either point cannot be coerced
+    # @!method starting
+    #   Returns the first point in the directed path.
+    #   @return [Sevgi::Geometry::Point]
+    # @!method ending
+    #   Returns the last point in the directed path.
+    #   @return [Sevgi::Geometry::Point]
+    # @!method reverse
+    #   Returns the same finite trace with opposite traversal.
+    #   @return [Sevgi::Geometry::Line]
     # @!attribute [r] A
     #   @return [Sevgi::Geometry::Point] starting point
     # @!attribute [r] B
@@ -69,10 +78,6 @@ module Sevgi
       # @return [Float]
       def angle = head.angle
 
-      # Returns the ending point.
-      # @return [Sevgi::Geometry::Point]
-      def ending = points.last
-
       # Reports whether a point is left of the directed line from {#starting} to {#ending} in screen coordinates.
       # Points on the infinite line are on neither side. A zero-length line has no direction and returns false.
       # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
@@ -87,10 +92,6 @@ module Sevgi
       # @raise [Sevgi::Geometry::Error] when point cannot be coerced
       def right?(point) = F.gt?(side(point), 0.0)
 
-      # Returns the starting point.
-      # @return [Sevgi::Geometry::Point]
-      def starting = points.first
-
       # Draws the line into a graphics node.
       # @param node [Object] graphics node receiving the drawing command
       # @return [Object] graphics node command result
@@ -109,7 +110,7 @@ module Sevgi
       end
 
       # Returns a parallel line shifted by a signed perpendicular offset.
-      # Positive distance moves to the directed line's left in screen coordinates; reversing the endpoints reverses the
+      # Positive distance moves to the directed line's left in screen coordinates. Reversing the endpoints reverses the
       # shift direction.
       # @param distance [Numeric] signed perpendicular offset
       # @return [Sevgi::Geometry::Line]
@@ -121,12 +122,11 @@ module Sevgi
 
       private
 
-      def cross(ax, ay, bx, by) = (ax * by) - (ay * bx)
       def delta(from, to) = [to.x - from.x, to.y - from.y]
 
       def side(point)
         point = Tuple[Point, point]
-        cross(*delta(starting, ending), *delta(starting, point))
+        Cross[*delta(starting, ending), *delta(starting, point)]
       end
 
       def within_range?(point)

data/lib/sevgi/geometry/elements/parallelogram.rb

@@ -8,7 +8,7 @@ module Sevgi
     private_constant :ParallelogramBase
 
     # Closed four-sided element whose opposite sides are equal and parallel. Every construction path rejects
-    # degenerate or unrelated side pairs; affine operations preserve the class while that invariant holds.
+    # degenerate or unrelated side pairs. Affine operations preserve the class while that invariant holds.
     # @!method self.call(*points)
     #   Builds a parallelogram from four boundary points.
     #   @param points [Array<Sevgi::Geometry::Point, Array<Numeric>>] four boundary points
@@ -56,7 +56,7 @@ module Sevgi
     #   shape.box.width     # => 6.0
     #   shape.box.height    # => 3.0
     class Parallelogram < ParallelogramBase
-      # Builds a parallelogram from adjacent base and side segments. Both segments originate at `position`; `base`
+      # Builds a parallelogram from adjacent base and side segments. Both segments originate at `position`. `base`
       # defines AB and `side` defines AD, regardless of their angles.
       # @param base [Sevgi::Geometry::Segment, Array<Numeric>] segment from A to B
       # @param side [Sevgi::Geometry::Segment, Array<Numeric>] segment from A to D
@@ -69,7 +69,7 @@ module Sevgi
         new_by_segments(base, side.reverse, base.reverse, side, position:)
       end
 
-      # Builds a parallelogram from a base and bounding-height constraint. The constraint length is the target height;
+      # Builds a parallelogram from a base and bounding-height constraint. The constraint length is the target height.
       # its signed angle is retained as the direction of the derived side while the component magnitude determines that
       # side's non-negative length.
       # @param base [Sevgi::Geometry::Segment, Array<Numeric>] segment from A to B
@@ -96,7 +96,7 @@ module Sevgi
         self[base, Segment[height / sine.abs, angle], position:]
       end
 
-      # Builds a parallelogram from a side and bounding-width constraint. The constraint length is the target width; its
+      # Builds a parallelogram from a side and bounding-width constraint. The constraint length is the target width. Its
       # signed angle is retained as the direction of the derived base while the component magnitude determines that
       # base's non-negative length.
       # @param side [Sevgi::Geometry::Segment, Array<Numeric>] segment from A to D
@@ -127,13 +127,11 @@ module Sevgi
 
       def validate_geometry!
         a, b, c, d = segments
-        valid = opposite?(a, c) && opposite?(b, d) && !F.zero?(cross(a, b))
+        valid = opposite?(a, c) && opposite?(b, d) && !F.zero?(Cross[a.x, a.y, b.x, b.y])
 
         Error.("Parallelogram sides must be non-degenerate opposite pairs") unless valid
       end
 
-      def cross(a, b) = (a.x * b.y) - (a.y * b.x)
-
       def opposite?(a, b) = F.zero?(a.x + b.x) && F.zero?(a.y + b.y)
     end
   end

data/lib/sevgi/geometry/elements/polyline.rb

@@ -30,6 +30,15 @@ module Sevgi
     #   @param points [Array<Sevgi::Geometry::Point, Array<Numeric>>] ordered points
     #   @return [Sevgi::Geometry::Polyline]
     #   @raise [Sevgi::Geometry::Error] when inputs cannot be coerced or do not form a polyline
+    # @!method starting
+    #   Returns the first point in the directed path.
+    #   @return [Sevgi::Geometry::Point]
+    # @!method ending
+    #   Returns the last point in the directed path.
+    #   @return [Sevgi::Geometry::Point]
+    # @!method reverse
+    #   Returns the same trace with opposite traversal.
+    #   @return [Sevgi::Geometry::Polyline]
     # @example Pair mathematical notation with English conveniences
     #   Sevgi::Geometry::Polyline[[2, 0], [1, 90]] == Sevgi::Geometry::Polyline.from_segments([2, 0], [1, 90])
     #   Sevgi::Geometry::Polyline.([0, 0], [2, 0]) == Sevgi::Geometry::Polyline.from_points([0, 0], [2, 0])

data/lib/sevgi/geometry/elements/rect.rb

@@ -161,6 +161,10 @@ module Sevgi
 
       private :draw!
 
+      # Returns the rectangle center.
+      # @return [Sevgi::Geometry::Point]
+      def center = Point.midpoint(top_left, bottom_right)
+
       # Returns rectangle height.
       # @return [Float]
       def height = @height ||= segments[1].length
@@ -220,7 +224,7 @@ module Sevgi
       end
     end
 
-    # Rectangle with equal width and height. Use {#width} or {#height} for its side length; inherited
+    # Rectangle with equal width and height. Use {#width} or {#height} for its side length. Inherited
     # {Element::Lined#length} returns the complete path length.
     # @example Construct the same square from opposite corners
     #   Sevgi::Geometry::Square.([0, 0], [5, 5]) == Sevgi::Geometry::Square.from_corners([0, 0], [5, 5])

data/lib/sevgi/geometry/elements/triangle.rb

@@ -8,7 +8,7 @@ module Sevgi
     private_constant :TriangleBase
 
     # Closed three-sided element built from non-collinear segments or points. Every construction path rejects
-    # degenerate triangles; affine operations retain Triangle when the transformed points remain non-degenerate.
+    # degenerate triangles. Affine operations retain Triangle when the transformed points remain non-degenerate.
     # @!method self.call(*points)
     #   Builds a triangle from three boundary points.
     #   @param points [Array<Sevgi::Geometry::Point, Array<Numeric>>] three boundary points
@@ -53,7 +53,7 @@ module Sevgi
       # Builds a triangle from two adjacent segments.
       #
       # The closing segment is the direct vector from the end of `segment_b`
-      # back to `position`. Segment order controls orientation; reversing the
+      # back to `position`. Segment order controls orientation. Reversing the
       # inputs returns the corresponding opposite orientation. Zero-length or
       # collinear inputs are rejected using the current numeric precision.
       # @param segment_a [Sevgi::Geometry::Segment, Array<Numeric>] first segment
@@ -75,14 +75,11 @@ module Sevgi
           Segment.(b.ending(a.ending(Origin)), Origin)
         end
 
-        def cross(a, b) = (a.x * b.y) - (a.y * b.x)
-
         def validate!(a, b)
-          if F.zero?(a.length) ||
-              F.zero?(b.length) ||
-              F.zero?(cross(a, b))
-            Error.("Triangle segments must form a non-degenerate triangle")
-          end
+          middle = a.ending(Origin)
+          return unless F.zero?(a.length) || F.zero?(b.length) || Point.collinear?(Origin, middle, b.ending(middle))
+
+          Error.("Triangle segments must form a non-degenerate triangle")
         end
       end
 

data/lib/sevgi/geometry/equation/quadratic.rb

@@ -3,26 +3,108 @@
 module Sevgi
   module Geometry
     class Equation
-      # Base class reserved for future quadratic equation support.
-      # @api private
+      # Implicit second-degree carrier with an optional local coordinate origin.
+      # The origin avoids expanding large ellipse centers into coefficients that lose the radius through cancellation.
+      # @example Intersect a unit circle carrier with a horizontal line
+      #   equation = Sevgi::Geometry::Equation.quadratic(1, 0, 1, 0, 0, -1)
+      #   equation.y(0) # => [-1.0, 1.0]
       class Quadratic < Equation
-      end
+        public_class_method :new
 
-      private_constant :Quadratic
-    end
+        # @return [Array<Float>] immutable coefficients in a, b, c, d, e, f order
+        attr_reader :coefficients
+        # @return [Sevgi::Geometry::Point] local coordinate origin
+        attr_reader :origin
+
+        # Creates a quadratic equation in local coordinates.
+        # @param coefficients [Array<Numeric>] six finite coefficients, with a nonzero second-degree term
+        # @param origin [Sevgi::Geometry::Point, Array<Numeric>] local coordinate origin
+        # @return [void]
+        # @raise [Sevgi::Geometry::Error] when coefficients or origin are invalid
+        def initialize(*coefficients, origin: Origin)
+          super()
+          Error.("Quadratic equation requires six coefficients") unless coefficients.size == 6
+          @coefficients = coefficients.each_with_index.map { |value, i| Real[("a".."f").to_a[i], value] }.freeze
+          Error.("Quadratic equation requires a second-degree term") if @coefficients.first(3).all?(&:zero?)
+          @origin = Tuple[Point, origin]
+        end
+
+        # Reports exact equality of coefficients and the local origin.
+        # @param other [Object] comparison target
+        # @return [Boolean]
+        def eql?(other) = other.instance_of?(self.class) && coefficients == other.coefficients && origin == other.origin
+
+        # Returns a hash compatible with strict equality.
+        # @return [Integer]
+        def hash = [self.class, coefficients, origin].hash
+
+        # rubocop:disable Metrics/AbcSize
+
+        # Returns the finite y roots at a world x coordinate, in ascending order.
+        # @param x [Numeric] finite world x coordinate
+        # @return [Array<Float>] zero, one, or two y coordinates
+        # @raise [Sevgi::Geometry::Error] when x or a result is not finite, or y is indeterminate
+        def y(x)
+          x = Real[:x, x] - origin.x
+          a, b, c, d, e, f = coefficients
+          roots = roots(c, sum(b * x, e), sum(a * x * x, d * x, f))
+          Error.("y is indeterminate for this quadratic equation") unless roots
+          roots.map { Real[:y, it + origin.y] }
+        end
+
+        # rubocop:enable Metrics/AbcSize
 
-    # Reserved circle element support.
-    # @api private
-    class Circle
-      # Returns the circle equation.
-      # @abstract Circle equation support is not implemented yet.
-      # @return [Sevgi::Geometry::Equation::Quadratic]
-      # @raise [Sevgi::PanicError] until circle equation support is implemented
-      def equation
-        PanicError.("#{self.class}#equation must be implemented")
+        # @return [Boolean] exact equality of coefficients and origin
+        alias == eql?
+
+        private
+
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
+        def intersect_linear(line)
+          if line.is_a?(Linear::Vertical)
+            x = line.x - origin.x
+            a, b, c, d, e, f = coefficients
+            ys = roots(c, sum(b * x, e), sum(a * x * x, d * x, f))
+            return Array(ys).map { Point[line.x, it + origin.y] }
+          end
+
+          a, b, c, d, e, f = coefficients
+          slope, intercept = line.slope, line.y(origin.x) - origin.y
+          xs = roots(
+            sum(a, b * slope, c * slope * slope),
+            sum(b * intercept, 2 * c * slope * intercept, d, e * slope),
+            sum(c * intercept * intercept, e * intercept, f)
+          )
+          Array(xs).map { |x| Point[x + origin.x, (slope * x) + intercept + origin.y] }
+        end
+
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def roots(a, b, c)
+          scale = [a.abs, b.abs, c.abs].max
+          return nil if scale.zero?
+          Error.("Quadratic intersection coefficients are not finite") unless scale.finite?
+          a, b, c = [a, b, c].map { it / scale }
+          return b.zero? ? [] : [-c / b] if a.zero?
+
+          square, product = b * b, 4 * a * c
+          discriminant = square - product
+          # Only arithmetic cancellation at a tangent can merge roots; display precision does not classify them.
+          discriminant = 0.0 if discriminant.abs <= 8 * Float::EPSILON * (square.abs + product.abs)
+          return [] if discriminant.negative?
+          return [-b / (2 * a)] if discriminant.zero?
+
+          root = ::Math.sqrt(discriminant)
+          q = -0.5 * (b + (b.negative? ? -root : root))
+          [q / a, c / q].sort
+        end
+
+        # Substitution can cancel before the discriminant is formed, notably at axis-aligned tangents.
+        def sum(*terms)
+          value = terms.sum
+          Error.("Quadratic intersection coefficients are not finite") unless value.finite?
+          value.abs <= 8 * Float::EPSILON * terms.sum(&:abs) ? 0.0 : value
+        end
       end
     end
-
-    private_constant :Circle
   end
 end