sevgi-geometry 0.94.0 → 0.98.2

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

@@ -7,7 +7,48 @@ module Sevgi
     TriangleBase = Element.lined(3)
     private_constant :TriangleBase
 
-    # Closed three-sided element built from two non-collinear adjacent segments.
+    # 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.
+    # @!method self.call(*points)
+    #   Builds a triangle from three boundary points.
+    #   @param points [Array<Sevgi::Geometry::Point, Array<Numeric>>] three boundary points
+    #   @return [Sevgi::Geometry::Triangle]
+    #   @raise [Sevgi::Geometry::Error] when inputs cannot be coerced or form a degenerate triangle
+    # @!method self.from_segments(segment_a, segment_b, position: Origin)
+    #   Builds a triangle from two adjacent segments and derives the closing side.
+    #   @param segment_a [Sevgi::Geometry::Segment, Array<Numeric>] first adjacent segment
+    #   @param segment_b [Sevgi::Geometry::Segment, Array<Numeric>] second adjacent segment
+    #   @param position [Sevgi::Geometry::Point, Array<Numeric>] starting point
+    #   @return [Sevgi::Geometry::Triangle]
+    #   @raise [Sevgi::Geometry::Error] when inputs cannot be coerced or form a degenerate triangle
+    # @!method self.from_points(*points)
+    #   Builds a triangle from three boundary points.
+    #   @param points [Array<Sevgi::Geometry::Point, Array<Numeric>>] three boundary points
+    #   @return [Sevgi::Geometry::Triangle]
+    #   @raise [Sevgi::Geometry::Error] when inputs cannot be coerced or form a degenerate triangle
+    # @!attribute [r] A
+    #   @return [Sevgi::Geometry::Point] first vertex
+    # @!attribute [r] B
+    #   @return [Sevgi::Geometry::Point] second vertex
+    # @!attribute [r] C
+    #   @return [Sevgi::Geometry::Point] third vertex
+    # @!attribute [r] AB
+    #   @return [Sevgi::Geometry::Line] side from A to B
+    # @!attribute [r] BC
+    #   @return [Sevgi::Geometry::Line] side from B to C
+    # @!attribute [r] CA
+    #   @return [Sevgi::Geometry::Line] side from C to A
+    # @!method perimeter
+    #   Returns the closed path perimeter.
+    #   @return [Float]
+    # @example Pair mathematical notation with English conveniences
+    #   Sevgi::Geometry::Triangle[[2, 0], [2, 90]] == Sevgi::Geometry::Triangle.from_segments([2, 0], [2, 90])
+    #   Sevgi::Geometry::Triangle.([0, 0], [2, 0], [2, 2]) == Sevgi::Geometry::Triangle.from_points([0, 0], [2, 0], [2, 2])
+    # @example Use named vertices and sides
+    #   triangle = Sevgi::Geometry::Triangle.([0, 0], [3, 0], [3, 4])
+    #   triangle.C.deconstruct # => [3.0, 4.0]
+    #   triangle.AB.length     # => 3.0
+    #   triangle.perimeter     # => 12.0
     class Triangle < TriangleBase
       # Builds a triangle from two adjacent segments.
       #
@@ -27,21 +68,29 @@ module Sevgi
         new_by_segments(a, b, closing_segment(a, b), position:)
       end
 
-      def self.closing_segment(a, b)
-        Segment.(b.ending(a.ending(Origin)), Origin)
-      end
+      class << self
+        private
+
+        def closing_segment(a, b)
+          Segment.(b.ending(a.ending(Origin)), Origin)
+        end
 
-      def self.cross(a, b) = (a.x * b.y) - (a.y * b.x)
+        def cross(a, b) = (a.x * b.y) - (a.y * b.x)
 
-      def self.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")
+        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
         end
       end
 
-      private_class_method :closing_segment, :cross, :validate!
+      private
+
+      def validate_geometry!
+        self.class.send(:validate!, segments[0], segments[1])
+      end
     end
   end
 end

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

@@ -3,26 +3,80 @@
 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
-          # @!attribute [r] slope
-          #   @return [Float] line slope
-          # @!attribute [r] intercept
-          #   @return [Float] y-intercept
-          attr_reader :slope, :intercept
+          public_class_method :new
+
+          # Returns the line slope.
+          # @return [Float]
+          attr_reader :slope
+
+          # Returns the y-intercept.
+          # @return [Float]
+          attr_reader :intercept
 
           # Creates a diagonal linear equation.
           # @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.
@@ -35,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
@@ -102,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.
@@ -132,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]
@@ -169,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]
@@ -189,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.
@@ -206,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.
@@ -217,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,9 +3,12 @@
 module Sevgi
   module Geometry
     class Equation
-      # Base class for quadratic equations.
+      # Base class reserved for future quadratic equation support.
+      # @api private
       class Quadratic < Equation
       end
+
+      private_constant :Quadratic
     end
 
     # Reserved circle element support.

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.
+    #
+    # The supported public factories build horizontal, vertical, and diagonal
+    # linear equations. {#intersect} always returns an Array: no intersection is
+    # `[]`, while one crossing is a one-item Array. Coincident parallel lines do
+    # not represent a finite intersection and also return an empty Array.
+    # @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::Lined#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.
@@ -55,19 +67,26 @@ module Sevgi
       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)
+      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 F.eq?(left.slope, right.slope)
 
         x = (right.intercept - left.intercept) / (left.slope - right.slope)
@@ -75,10 +94,10 @@ module Sevgi
         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(...)
@@ -92,6 +111,10 @@ module Sevgi
 
     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]
       def equation(angle)

data/lib/sevgi/geometry/internal.rb

@@ -2,23 +2,35 @@
 
 module Sevgi
   module Geometry
-    # Validates finite real numeric inputs for geometry primitives.
+    # Validates numeric inputs that can be represented as finite Floats.
     # @api private
     module Real
-      # Coerces a public numeric value to Float.
+      # Coerces a public numeric value to a finite Float.
       # @param field [Symbol, String] coordinate or component name
       # @param value [Object] value to coerce
       # @return [Float] finite float value
-      # @raise [Sevgi::Geometry::Error] when value is not a finite Numeric
+      # @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
 
-        value.to_f.tap do |number|
-          Error.("Geometry #{field} must be finite: #{value.inspect}") unless number.finite?
+        number = coerce(field, value)
+
+        unless number.is_a?(::Float) && number.finite?
+          Error.("Geometry #{field} must be finite: #{value.inspect}")
         end
+
+        number
       end
+
+      def self.coerce(field, value)
+        value.to_f
+      rescue ::StandardError => e
+        Error.("Geometry #{field} must be a finite real Numeric: #{value.inspect} (#{e.message})")
+      end
+
+      private_class_method :coerce
     end
 
     private_constant :Real

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
 

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

@@ -4,6 +4,7 @@ module Sevgi
   module Geometry
     module Operation
       # Sweep operation implementation.
+      # @api private
       module Sweep
         extend self
 
@@ -13,7 +14,7 @@ module Sevgi
         # Sweeps parallel lines across a lined element in both directions.
         #
         # Generated lines are boundary-to-boundary interior spans. A single
-        # sweep position can produce multiple lines for closed concave elements.
+        # sweep position can produce multiple lines for closed concave elements; open paths produce no interior lines.
         # @param element [Sevgi::Geometry::Element::Lined] element to intersect
         # @param initial [Sevgi::Geometry::Point, Array<Numeric>] point on the initial sweep line
         # @param angle [Numeric] clockwise sweep line angle in degrees
@@ -23,9 +24,10 @@ module Sevgi
         # @yieldparam lines [Array<Sevgi::Geometry::Line>] generated sweep lines
         # @yieldreturn [void]
         # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
-        # @raise [Sevgi::Geometry::Error] when initial cannot be coerced
+        # @raise [Sevgi::Geometry::Error] when initial, angle, step, or limit is invalid
         # @raise [Sevgi::Geometry::Operation::OperationError] when iteration reaches the limit
         def sweep(element, initial:, angle:, step:, limit: LIMIT, &block)
+          step = validate_arguments(step, limit)
           equation = Tuple[Point, initial].equation(angle)
 
           [
@@ -39,7 +41,7 @@ module Sevgi
         # Sweeps parallel lines across a lined element and requires at least one result.
         #
         # Generated lines are boundary-to-boundary interior spans. A single
-        # sweep position can produce multiple lines for closed concave elements.
+        # sweep position can produce multiple lines for closed concave elements; open paths produce no interior lines.
         # @param element [Sevgi::Geometry::Element::Lined] element to intersect
         # @param initial [Sevgi::Geometry::Point, Array<Numeric>] point on the initial sweep line
         # @param angle [Numeric] clockwise sweep line angle in degrees
@@ -49,7 +51,7 @@ module Sevgi
         # @yieldparam lines [Array<Sevgi::Geometry::Line>] generated sweep lines
         # @yieldreturn [void]
         # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
-        # @raise [Sevgi::Geometry::Error] when initial cannot be coerced
+        # @raise [Sevgi::Geometry::Error] when initial, angle, step, or limit is invalid
         # @raise [Sevgi::Geometry::Operation::OperationError] when no lines are found or iteration reaches the limit
         def sweep!(element, initial:, angle:, step:, limit: LIMIT, &block)
           sweep(element, initial:, angle:, step:, limit:) do |lines|
@@ -64,14 +66,16 @@ module Sevgi
         # Sweeps parallel lines in one signed direction from an equation.
         #
         # Generated lines are boundary-to-boundary interior spans. A single
-        # sweep position can produce multiple lines for closed concave elements.
+        # sweep position can produce multiple lines for closed concave elements; open paths produce no interior lines.
         # @param element [Sevgi::Geometry::Element::Lined] element to intersect
         # @param equation [Sevgi::Geometry::Equation] initial sweep equation
         # @param step [Numeric] signed distance between sweep lines
         # @param limit [Integer] maximum iterations
         # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
+        # @raise [Sevgi::Geometry::Error] when step or limit is invalid
         # @raise [Sevgi::Geometry::Operation::OperationError] when iteration reaches the limit
         def unisweep(element, equation, step, limit: LIMIT)
+          step = validate_arguments(step, limit)
           lines = []
 
           limit.times do
@@ -86,6 +90,8 @@ module Sevgi
           OperationError.("Loop limit reached: #{limit}")
         end
 
+        private :unisweep
+
         # Reports whether the sweep handler can operate on an element.
         # @api private
         # @param element [Object] candidate element
@@ -96,7 +102,19 @@ module Sevgi
 
         private
 
+        def validate_arguments(step, limit)
+          step = Real[:step, step]
+          Error.("Sweep step must be nonzero") if step.zero?
+          unless limit.is_a?(::Integer) && limit.positive?
+            Error.("Sweep limit must be a positive Integer: #{limit.inspect}")
+          end
+
+          step
+        end
+
         def interior_lines(element, equation, points)
+          return [] unless element.class.send(:close?)
+
           if points.size == 2
             line = simple_line(points)
 
@@ -127,7 +145,7 @@ module Sevgi
         end
       end
 
-      register(Sweep, :sweep, :sweep!, :unisweep)
+      register(Sweep, :sweep, :sweep!)
 
       private_constant :Sweep
     end