sevgi-geometry 0.95.0 → 1.0.0

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

@@ -3,10 +3,61 @@
 module Sevgi
   module Geometry
     class Equation
-      # Base class for linear equations.
+      # Base class for unoriented linear equations.
+      #
+      # An equation has no ordered endpoints, so it does not define intrinsic left and right sides. Signed shifts use a
+      # canonical direction only to select a normal: increasing x for non-vertical equations and increasing y for
+      # vertical equations. Positive distance moves to screen-left of that canonical direction.
       class Linear < Equation
+        def shift_values(distance, dx, dy)
+          [[:distance, distance], [:dx, dx], [:dy, dy]].map do |field, value|
+            value.nil? ? 0.0 : Real[field, value]
+          end
+        end
+
+        private :shift_values
+
+        # Shared behavior for equations that map x coordinates to y coordinates.
+        # @api private
+        module Nonvertical
+          # Reports strict equality for two nonvertical equations.
+          # @param equation [Sevgi::Geometry::Equation::Linear] equation to compare
+          # @param other [Object] comparison target
+          # @return [Boolean]
+          def self.equal?(equation, other)
+            equation.class == other.class && [equation.slope, equation.intercept] == [other.slope, other.intercept]
+          end
+
+          # Returns a strict-equality hash for a nonvertical equation.
+          # @param equation [Sevgi::Geometry::Equation::Linear] equation to hash
+          # @return [Integer]
+          def self.hash(equation) = [equation.class, equation.slope, equation.intercept].hash
+
+          # Reports whether a point is on a nonvertical equation.
+          # @param equation [Sevgi::Geometry::Equation::Linear] equation to test
+          # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
+          # @return [Boolean]
+          # @raise [Sevgi::Geometry::Error] when point cannot be coerced
+          def self.on?(equation, point)
+            point = Tuple[Point, point]
+
+            F.eq?(point.y, y(equation, point.x))
+          end
+
+          # Evaluates a nonvertical equation at an x coordinate.
+          # @param equation [Sevgi::Geometry::Equation::Linear] equation to evaluate
+          # @param x [Numeric] x coordinate
+          # @return [Float]
+          # @raise [Sevgi::Geometry::Error] when x is not a finite real number
+          def self.y(equation, x) = (equation.slope * Real[:x, x]) + equation.intercept
+        end
+
+        private_constant :Nonvertical
+
         # Non-axis-aligned linear equation in `y = slope * x + intercept` form.
         class Diagonal < Linear
+          public_class_method :new
+
           # Returns the line slope.
           # @return [Float]
           attr_reader :slope
@@ -19,12 +70,13 @@ module Sevgi
           # @param slope [Numeric] line slope
           # @param intercept [Numeric] y-intercept
           # @return [void]
-          # @raise [Sevgi::Geometry::Error] when a coefficient is not a finite Numeric
+          # @raise [Sevgi::Geometry::Error] when a coefficient is not finite Numeric or slope is zero
           def initialize(slope:, intercept:)
             super()
 
             @slope = Real[:slope, slope]
             @intercept = Real[:intercept, intercept]
+            Error.("A diagonal equation requires a non-zero slope") if @slope.zero?
           end
 
           # Returns an equation rounded to precision.
@@ -37,55 +89,30 @@ module Sevgi
           # Reports strict equation equality.
           # @param other [Object] object to compare
           # @return [Boolean]
-          def eql?(other) = self.class == other.class && [slope, intercept] == [other.slope, other.intercept]
+          def eql?(other) = Nonvertical.equal?(self, other)
 
           # Returns a hash compatible with strict equality.
           # @return [Integer]
-          def hash = [self.class, slope, intercept].hash
-
-          # Reports whether a point is on the left side of the line in screen coordinates.
-          # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
-          # @return [Boolean]
-          # @raise [Sevgi::Geometry::Error] when point cannot be coerced
-          def left?(point)
-            point = Tuple[Point, point]
-
-            F.gt?(point.y, y(point.x))
-          end
+          def hash = Nonvertical.hash(self)
 
           # Reports whether a point is on the line.
           # @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]
-
-            F.eq?(point.y, y(point.x))
-          end
-
-          # Reports whether a point is on the right side of the line in screen coordinates.
-          # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
-          # @return [Boolean]
-          # @raise [Sevgi::Geometry::Error] when point cannot be coerced
-          def right?(point)
-            point = Tuple[Point, point]
-
-            F.lt?(point.y, y(point.x))
-          end
+          def on?(point) = Nonvertical.on?(self, point)
 
           # Returns a parallel equation shifted by a signed perpendicular offset.
+          # Positive distance moves to screen-left of the equation's canonical increasing-x direction.
           # @param distance [Numeric, nil] signed perpendicular offset
           # @param dx [Numeric, nil] explicit x translation
           # @param dy [Numeric, nil] explicit y translation
           # @return [Sevgi::Geometry::Equation::Linear::Diagonal]
+          # @raise [Sevgi::Geometry::Error] when an operand is not a finite real number
           def shift(distance = nil, dx: nil, dy: nil)
-            dx ||= 0.0
-            dy ||= 0.0
-
-            if distance
-              dx += distance * F.sin(angle = F.atan(slope))
-              dy -= distance * F.cos(angle)
-            end
+            distance, dx, dy = shift_values(distance, dx, dy)
+            angle = F.atan(slope)
+            dx += distance * F.sin(angle)
+            dy -= distance * F.cos(angle)
 
             Diagonal.new(slope:, intercept: intercept - (slope * dx) + dy)
           end
@@ -104,29 +131,61 @@ module Sevgi
           # Evaluates x for a y coordinate.
           # @param y [Numeric] y coordinate
           # @return [Float]
-          def x(y) = (y - intercept) / slope
+          # @raise [Sevgi::Geometry::Error] when y is not a finite real number
+          def x(y) = (Real[:y, y] - intercept) / slope
 
           # Evaluates y for an x coordinate.
           # @param x [Numeric] x coordinate
           # @return [Float]
-          def y(x) = (slope * x) + intercept
+          # @raise [Sevgi::Geometry::Error] when x is not a finite real number
+          def y(x) = Nonvertical.y(self, x)
 
           alias == eql?
         end
 
         # Horizontal linear equation in `y = c` form.
-        class Horizontal < Diagonal
+        class Horizontal < Linear
+          public_class_method :new
+
+          # Returns the zero line slope.
+          # @return [Float]
+          attr_reader :slope
+
+          # Returns the y coordinate.
+          # @return [Float]
+          attr_reader :intercept
+
           # Creates a horizontal equation.
           # @param c [Numeric] y coordinate
           # @return [void]
           # @raise [Sevgi::Geometry::Error] when c is not a finite Numeric
-          def initialize(c) = super(slope: 0.0, intercept: c)
+          def initialize(c)
+            super()
+
+            @slope = 0.0
+            @intercept = Real[:y, c]
+          end
 
           # Returns an equation rounded to precision.
           # @param precision [Integer, nil] decimal precision, or nil for the current function default
           # @return [Sevgi::Geometry::Equation::Linear::Horizontal]
           def approx(precision = nil) = self.class.new(F.approx(intercept, precision))
 
+          # Reports strict equation equality.
+          # @param other [Object] object to compare
+          # @return [Boolean]
+          def eql?(other) = Nonvertical.equal?(self, other)
+
+          # Returns a hash compatible with strict equality.
+          # @return [Integer]
+          def hash = Nonvertical.hash(self)
+
+          # Reports whether a point is on the line.
+          # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
+          # @return [Boolean]
+          # @raise [Sevgi::Geometry::Error] when point cannot be coerced
+          def on?(point) = Nonvertical.on?(self, point)
+
           # Returns a parallel horizontal equation shifted by offsets.
           #
           # A positive signed distance shifts upward in screen coordinates.
@@ -134,19 +193,36 @@ module Sevgi
           # @param dx [Numeric, nil] accepted for signature compatibility and ignored
           # @param dy [Numeric, nil] explicit y translation
           # @return [Sevgi::Geometry::Equation::Linear::Horizontal]
+          # @raise [Sevgi::Geometry::Error] when an operand is not a finite real number
           def shift(distance = nil, dx: nil, dy: nil)
-            _dx = dx
+            distance, _dx, dy = shift_values(distance, dx, dy)
 
-            self.class.new(intercept + (dy || 0.0) - (distance || 0.0))
+            self.class.new(intercept + dy - distance)
           end
 
+          # Rejects x lookup because a horizontal equation does not determine one x coordinate.
+          # @param _y [Numeric] y coordinate
+          # @return [void]
+          # @raise [Sevgi::Geometry::Error] always, because x is indeterminate
+          def x(_y) = Error.("x is indeterminate for a horizontal equation")
+
           # Formats the equation for display.
           # @return [String]
           def to_s = "Linear<y = #{F.approx(intercept)}>"
+
+          # Evaluates y for an x coordinate.
+          # @param x [Numeric] x coordinate
+          # @return [Float]
+          # @raise [Sevgi::Geometry::Error] when x is not a finite real number
+          def y(x) = Nonvertical.y(self, x)
+
+          alias == eql?
         end
 
         # Vertical linear equation in `x = c` form.
         class Vertical < Linear
+          public_class_method :new
+
           # Creates a vertical equation.
           # @param c [Numeric] x coordinate
           # @return [void]
@@ -171,16 +247,6 @@ module Sevgi
           # @return [Integer]
           def hash = [self.class, x].hash
 
-          # Reports whether a point is on the left side of the line.
-          # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
-          # @return [Boolean]
-          # @raise [Sevgi::Geometry::Error] when point cannot be coerced
-          def left?(point)
-            point = Tuple[Point, point]
-
-            F.lt?(point.x, x(point.y))
-          end
-
           # Reports whether a point is on the line.
           # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
           # @return [Boolean]
@@ -191,16 +257,6 @@ module Sevgi
             F.eq?(point.x, x(point.y))
           end
 
-          # Reports whether a point is on the right side of the line.
-          # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
-          # @return [Boolean]
-          # @raise [Sevgi::Geometry::Error] when point cannot be coerced
-          def right?(point)
-            point = Tuple[Point, point]
-
-            F.gt?(point.x, x(point.y))
-          end
-
           # Returns a parallel vertical equation shifted by offsets.
           #
           # A positive signed distance shifts right in screen coordinates.
@@ -208,10 +264,11 @@ module Sevgi
           # @param dx [Numeric, nil] explicit x translation
           # @param dy [Numeric, nil] accepted for signature compatibility and ignored
           # @return [Sevgi::Geometry::Equation::Linear::Vertical]
+          # @raise [Sevgi::Geometry::Error] when an operand is not a finite real number
           def shift(distance = nil, dx: nil, dy: nil)
-            _dy = dy
+            distance, dx, _dy = shift_values(distance, dx, dy)
 
-            self.class.new(x + (distance || 0.0) + (dx || 0.0))
+            self.class.new(x + distance + dx)
           end
 
           # Formats the equation for display.
@@ -219,14 +276,19 @@ module Sevgi
           def to_s = "Linear<x = #{F.approx(x)}>"
 
           # Evaluates x for a y coordinate.
-          # @param _ [Numeric, nil] ignored y coordinate
+          # @param y [Numeric, nil] ignored finite y coordinate
           # @return [Float]
-          def x(_ = nil) = @x
+          # @raise [Sevgi::Geometry::Error] when y is present and not a finite real number
+          def x(y = nil)
+            Real[:y, y] unless y.nil?
+            @x
+          end
 
           # Evaluates y for an x coordinate.
-          # @param _ [Numeric, nil] ignored x coordinate
-          # @return [Float] positive infinity because a vertical line has no single y
-          def y(_ = nil) = ::Float::INFINITY
+          # @param _x [Numeric] x coordinate
+          # @return [void]
+          # @raise [Sevgi::Geometry::Error] always, because y is indeterminate
+          def y(_x) = Error.("y is indeterminate for a vertical equation")
 
           alias == eql?
         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

data/lib/sevgi/geometry/equation.rb

@@ -2,13 +2,25 @@
 
 module Sevgi
   module Geometry
-    # Base class for geometric equations that can intersect with each other.
+    # Abstract base class for geometry equations used in boundary intersections.
+    #
+    # Public factories build linear and implicit quadratic equations.
+    # Linear/quadratic intersection is supported in either order. {#intersect} returns an Array: no intersection is
+    # `[]`, while one crossing is a one-item Array. Parallel and coincident lines return an empty Array.
+    # Linear equation construction and intersection do not round angles or slopes to the display precision.
+    # @example Intersect two linear equations
+    #   diagonal = Sevgi::Geometry::Equation.diagonal(slope: 1, intercept: 0)
+    #   vertical = Sevgi::Geometry::Equation.vertical(3)
+    #   diagonal.intersect(vertical).map(&:deconstruct) # => [[3.0, 3.0]]
+    # @see Sevgi::Geometry::Element#intersection
     class Equation
+      private_class_method :new
+
       # Builds a non-axis-aligned linear equation.
       # @param slope [Numeric] line slope
       # @param intercept [Numeric] y-intercept
       # @return [Sevgi::Geometry::Equation::Linear::Diagonal]
-      # @raise [Sevgi::Geometry::Error] when a coefficient is not a finite Numeric
+      # @raise [Sevgi::Geometry::Error] when a coefficient is not finite Numeric or slope is zero
       def self.diagonal(slope:, intercept:) = Linear::Diagonal.new(slope:, intercept:)
 
       # Builds a horizontal linear equation.
@@ -23,10 +35,18 @@ module Sevgi
       # @raise [Sevgi::Geometry::Error] when const is not a finite Numeric
       def self.vertical(const) = Linear::Vertical.new(const)
 
+      # Builds an implicit quadratic carrier around an optional local origin.
+      # Coefficients follow `a*x*x + b*x*y + c*y*y + d*x + e*y + f = 0` in coordinates relative to origin.
+      # @param coefficients [Array<Numeric>] six finite coefficients in a, b, c, d, e, f order
+      # @param origin [Sevgi::Geometry::Point, Array<Numeric>] local coordinate origin
+      # @return [Sevgi::Geometry::Equation::Quadratic]
+      # @raise [Sevgi::Geometry::Error] when coefficients or origin are invalid, or the degree is less than two
+      def self.quadratic(*coefficients, origin: Origin) = Quadratic.new(*coefficients, origin:)
+
       # Intersects this equation with another equation.
       # @param other [Sevgi::Geometry::Equation] equation to intersect with
       # @return [Array<Sevgi::Geometry::Point>] intersection points
-      # @raise [Sevgi::Geometry::Error] when other is not an equation
+      # @raise [Sevgi::Geometry::Error] when other is not an equation or quadratic/quadratic intersection is requested
       # @raise [Sevgi::PanicError] when the equation combination is not implemented
       def intersect(other)
         Error.("Must be an equation: #{other}") unless other.is_a?(Equation)
@@ -36,6 +56,8 @@ module Sevgi
           linear_vs_linear(other)
         in [Linear, Quadratic]
           linear_vs_quadratic(other)
+        in [Quadratic, Linear]
+          other.intersect(self)
         in [Quadratic, Quadratic]
           quadratic_vs_quadratic(other)
         else
@@ -48,64 +70,83 @@ module Sevgi
       # Evaluates y for an x coordinate.
       # @abstract Subclasses implement equation-specific mapping.
       # @param _x [Numeric] x coordinate
-      # @return [Float]
+      # @return [Float, Array<Float>] one value for a linear equation, or zero to two roots for a quadratic
       # @raise [Sevgi::PanicError] when a subclass does not implement y
       def y(_x, ...) = PanicError.("#{self.class}#y must be implemented")
 
       private
 
       def linear_vs_linear(other)
-        case [self, other]
-        in [Linear::Diagonal, Linear::Diagonal]
-          diagonal_vs_diagonal(self, other)
-        in [Linear::Diagonal, Linear::Vertical]
-          diagonal_vs_vertical(self, other)
-        in [Linear::Vertical, Linear::Diagonal]
-          diagonal_vs_vertical(other, self)
-        in [Linear::Vertical, Linear::Vertical]
+        case [linear_category(self), linear_category(other)]
+        in [:vertical, :vertical]
           nil
+        in [:vertical, :nonvertical]
+          nonvertical_vs_vertical(other, self)
+        in [:nonvertical, :vertical]
+          nonvertical_vs_vertical(self, other)
+        in [:nonvertical, :nonvertical]
+          nonvertical_vs_nonvertical(self, other)
         end
       end
 
-      def diagonal_vs_diagonal(left, right)
-        return nil if F.eq?(left.slope, right.slope)
+      def linear_category(equation)
+        return :vertical if equation.is_a?(Linear::Vertical)
+        return :nonvertical if equation.is_a?(Linear::Diagonal) || equation.is_a?(Linear::Horizontal)
+
+        PanicError.("Linear equation category not implemented: #{equation.class}")
+      end
+
+      def nonvertical_vs_nonvertical(left, right)
+        return nil if left.slope == right.slope
 
         x = (right.intercept - left.intercept) / (left.slope - right.slope)
 
         Point[x, left.y(x)]
       end
 
-      def diagonal_vs_vertical(diagonal, vertical)
+      def nonvertical_vs_vertical(nonvertical, vertical)
         x = vertical.x
 
-        Point[x, diagonal.y(x)]
+        Point[x, nonvertical.y(x)]
       end
 
-      def linear_vs_quadratic(...)
-        PanicError.("Linear/quadratic intersection must be implemented")
-      end
+      def linear_vs_quadratic(other) = other.send(:intersect_linear, self)
 
       def quadratic_vs_quadratic(...)
-        PanicError.("Quadratic/quadratic intersection must be implemented")
+        Error.("Quadratic/quadratic intersection is not supported")
       end
     end
 
     class Point
       # Returns the linear equation passing through this point at an angle.
+      # @example Create axis-aligned equations through a point
+      #   point = Sevgi::Geometry::Point[4, 3]
+      #   point.equation(0).y(20)  # => 3.0
+      #   point.equation(90).x(20) # => 4.0
       # @param angle [Numeric] clockwise angle in degrees
       # @return [Sevgi::Geometry::Equation::Linear]
+      # @raise [Sevgi::Geometry::Error] when angle is not a finite real number
       def equation(angle)
-        return Equation.horizontal(y) if F.zero?(angle % 180.0)
-        return Equation.vertical(x) if F.zero?(angle % 90.0)
+        angle = Real[:angle, angle]
+        return Equation.horizontal(y) if (angle % 180.0).zero?
+        return Equation.vertical(x) if (angle % 90.0).zero?
 
         Equation.diagonal(slope: (slope = F.tan(angle)), intercept: y - (slope * x))
       end
     end
 
     class Line
-      # Returns the linear equation containing this line.
+      # Returns the linear equation through the stored endpoints without a polar conversion.
       # @return [Sevgi::Geometry::Equation::Linear]
-      def equation = position.equation(angle)
+      def equation
+        x, y = starting.deconstruct
+        dx, dy = ending.x - x, ending.y - y
+        return Equation.horizontal(y) if dy.zero?
+        return Equation.vertical(x) if dx.zero?
+
+        slope = dy / dx
+        Equation.diagonal(slope:, intercept: y - (slope * x))
+      end
     end
 
     require_relative "equation/linear"

data/lib/sevgi/geometry/internal.rb

@@ -11,8 +11,8 @@ module Sevgi
       # @return [Float] finite float value
       # @raise [Sevgi::Geometry::Error] when value is not a Numeric, cannot be converted to Float, or is not finite
       def self.[](field, value)
-        unless value.is_a?(::Numeric)
-          Error.("Geometry #{field} must be a finite Numeric: #{value.inspect}")
+        unless value.is_a?(::Numeric) && !value.is_a?(::Complex)
+          Error.("Geometry #{field} must be a finite real Numeric: #{value.inspect}")
         end
 
         number = coerce(field, value)
@@ -27,7 +27,7 @@ module Sevgi
       def self.coerce(field, value)
         value.to_f
       rescue ::StandardError => e
-        Error.("Geometry #{field} must be a finite Numeric: #{value.inspect} (#{e.message})")
+        Error.("Geometry #{field} must be a finite real Numeric: #{value.inspect} (#{e.message})")
       end
 
       private_class_method :coerce
@@ -35,6 +35,14 @@ module Sevgi
 
     private_constant :Real
 
+    # Calculates the scalar cross product of two planar component pairs.
+    # @api private
+    module Cross
+      def self.[](ax, ay, bx, by) = (ax * by) - (ay * bx)
+    end
+
+    private_constant :Cross
+
     # Coerces array-like geometry inputs into typed tuple objects.
     # @api private
     module Tuple

data/lib/sevgi/geometry/operation/align.rb

@@ -4,6 +4,7 @@ module Sevgi
   module Geometry
     module Operation
       # Alignment operation implementation.
+      # @api private
       module Align
         extend self
 
@@ -34,10 +35,7 @@ module Sevgi
 
           case alignment
           when :center
-            Point[
-              that.position.x + ((that.width - this.width) / 2.0) - this.position.x,
-              that.position.y + ((that.height - this.height) / 2.0) - this.position.y
-            ]
+            Point[that.center.x - this.center.x, that.center.y - this.center.y]
           when :left
             Point[that.position.x - this.position.x, 0]
           when :right