sevgi-geometry 0.98.2 → 1.0.0

data/lib/sevgi/geometry/equation.rb

@@ -4,15 +4,15 @@ module Sevgi
   module Geometry
     # 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.
+    # 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::Lined#intersection
+    # @see Sevgi::Geometry::Element#intersection
     class Equation
       private_class_method :new
 
@@ -35,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)
@@ -48,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
@@ -60,7 +70,7 @@ 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")
 
@@ -87,7 +97,7 @@ module Sevgi
       end
 
       def nonvertical_vs_nonvertical(left, right)
-        return nil if F.eq?(left.slope, right.slope)
+        return nil if left.slope == right.slope
 
         x = (right.intercept - left.intercept) / (left.slope - right.slope)
 
@@ -100,12 +110,10 @@ module Sevgi
         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
 
@@ -117,18 +125,28 @@ module Sevgi
       #   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

@@ -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

@@ -35,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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module Operation
+      # Returns the smallest axis-aligned rectangle enclosing all elements.
+      #
+      # Each element contributes its existing {Sevgi::Geometry::Element#box},
+      # including zero-size boxes whose positions may still extend the result.
+      # @param elements [Array<Sevgi::Geometry::Element>] elements to enclose
+      # @return [Sevgi::Geometry::Rect] aggregate bounding rectangle
+      # @raise [Sevgi::ArgumentError] when no elements are given
+      # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when an argument is not a geometry element
+      # @example Enclose several geometry values
+      #   a = Sevgi::Geometry::Rect[10, 5, position: [2, 3]]
+      #   b = Sevgi::Geometry::Line.([-4, 8], [20, 12])
+      #   Sevgi::Geometry::Operation.box(a, b) # => Rect spanning both elements
+      def box(*elements)
+        validate_box_elements(elements)
+        boxes = elements.map(&:box)
+
+        Rect.from_corners(minimum_corner(boxes), maximum_corner(boxes))
+      end
+
+      private
+
+      def maximum_corner(boxes)
+        [
+          boxes.map { it.position.x + it.width }.max,
+          boxes.map { it.position.y + it.height }.max
+        ]
+      end
+
+      def minimum_corner(boxes)
+        [
+          boxes.map { it.position.x }.min,
+          boxes.map { it.position.y }.min
+        ]
+      end
+
+      def validate_box_elements(elements)
+        ArgumentError.("At least one geometric element required") if elements.empty?
+
+        elements.each do |element|
+          OperationInapplicableError.("Not a Geometric Element: #{element}") unless element.is_a?(Element)
+        end
+      end
+    end
+  end
+end

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

@@ -11,11 +11,11 @@ module Sevgi
         # Default maximum number of sweep iterations.
         LIMIT = 1_000
 
-        # Sweeps parallel lines across a lined element in both directions.
+        # Sweeps parallel lines across a geometry element in both directions.
         #
         # Generated lines are boundary-to-boundary interior spans. A single
-        # 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
+        # sweep position can produce multiple lines for closed concave elements. Open paths produce no interior lines.
+        # @param element [Sevgi::Geometry::Element] 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
         # @param step [Numeric] signed distance between sweep lines
@@ -38,11 +38,11 @@ module Sevgi
           end
         end
 
-        # Sweeps parallel lines across a lined element and requires at least one result.
+        # Sweeps parallel lines across a geometry 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; open paths produce no interior lines.
-        # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+        # sweep position can produce multiple lines for closed concave elements. Open paths produce no interior lines.
+        # @param element [Sevgi::Geometry::Element] 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
         # @param step [Numeric] signed distance between sweep lines
@@ -66,8 +66,8 @@ 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; open paths produce no interior lines.
-        # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+        # sweep position can produce multiple lines for closed concave elements. Open paths produce no interior lines.
+        # @param element [Sevgi::Geometry::Element] element to intersect
         # @param equation [Sevgi::Geometry::Equation] initial sweep equation
         # @param step [Numeric] signed distance between sweep lines
         # @param limit [Integer] maximum iterations
@@ -97,7 +97,7 @@ module Sevgi
         # @param element [Object] candidate element
         # @return [Boolean]
         def applicable?(element)
-          element.respond_to?(:intersection)
+          element.respond_to?(:intersection) && element.respond_to?(:inside?) && element.respond_to?(:on?)
         end
 
         private
@@ -113,25 +113,23 @@ module Sevgi
         end
 
         def interior_lines(element, equation, points)
-          return [] unless element.class.send(:close?)
+          return [] unless element.closed?
 
           if points.size == 2
+            return [] unless element.inside?(Point.midpoint(*points))
+
             line = simple_line(points)
 
             return line ? [line] : []
           end
 
           sorted_points(equation, points).each_cons(2).filter_map do |starting, ending|
-            next unless element.inside?(midpoint(starting, ending))
+            next unless element.inside?(Point.midpoint(starting, ending))
 
             simple_line([starting, ending])
           end
         end
 
-        def midpoint(starting, ending)
-          Point[(starting.x + ending.x) / 2.0, (starting.y + ending.y) / 2.0]
-        end
-
         def simple_line(points)
           line = Line.(*points)
 

data/lib/sevgi/geometry/operation.rb

@@ -5,9 +5,9 @@ module Sevgi
     # Stateless operations that relate or derive geometry values.
     #
     # `alignment` returns a translation offset, while `align` applies that
-    # offset to a copy. Center alignment works on both axes; edge alignments
+    # offset to a copy. Center alignment works on both axes. Edge alignments
     # change only the named axis and preserve the other coordinate. `sweep`
-    # derives boundary-to-boundary spans from a closed lined element, and
+    # derives boundary-to-boundary spans from a closed geometry element, and
     # `sweep!` additionally requires at least one span.
     module Operation
       extend self
@@ -48,10 +48,10 @@ module Sevgi
       #     #   Sevgi::Geometry::Operation.alignment(inner, outer, :bottom).approx.deconstruct # => [0.0, 13.0]
       #     def alignment(element, other, alignment = :center); end
       #
-      #     # Sweeps parallel lines across a lined element in both directions.
-      #     # `angle` is the direction of the returned lines; `step` is their signed perpendicular spacing.
+      #     # Sweeps parallel lines across a geometry element in both directions.
+      #     # `angle` is the direction of the returned lines. `step` is their signed perpendicular spacing.
       #     # Open paths yield no interior spans.
-      #     # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+      #     # @param element [Sevgi::Geometry::Element] 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
       #     # @param step [Numeric] signed distance between sweep lines
@@ -70,9 +70,9 @@ module Sevgi
       #     #   lines.map(&:length).uniq # => [10.0]
       #     def sweep(element, initial:, angle:, step:, limit: Sweep::LIMIT); end
       #
-      #     # Sweeps parallel lines across a lined element and requires at least one result.
-      #     # It has the same geometry as {sweep}, but raises when the result would be empty.
-      #     # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+      #     # Sweeps parallel lines across a geometry element and requires at least one result.
+      #     # It has the same geometry as {sweep}, but raises when the result is empty.
+      #     # @param element [Sevgi::Geometry::Element] 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
       #     # @param step [Numeric] signed distance between sweep lines
@@ -112,4 +112,5 @@ module Sevgi
 end
 
 require_relative "operation/align"
+require_relative "operation/box"
 require_relative "operation/sweep"

data/lib/sevgi/geometry/point.rb

@@ -78,7 +78,7 @@ module Sevgi
     # Immutable point in SVG/screen coordinates.
     #
     # Use `Point[x, y]` to create a point from two coordinates. Public geometry
-    # methods that expect a point also accept `[x, y]`; explicit Point values are
+    # methods that expect a point also accept `[x, y]`. Explicit Point values are
     # most useful when a result will be transformed, compared, or reused.
     # @example Measure and rotate a point in screen coordinates
     #   point = Sevgi::Geometry::Point[3, 4]
@@ -184,7 +184,17 @@ module Sevgi
       # @raise [Sevgi::Geometry::Error] when either point cannot be coerced
       def self.length(starting, ending)
         starting, ending = Tuples[Point, starting, ending]
-        ::Math.sqrt(((starting.y - ending.y) ** 2) + ((starting.x - ending.x) ** 2))
+        ::Math.hypot(starting.x - ending.x, starting.y - ending.y)
+      end
+
+      # Returns the midpoint between two points.
+      # @param starting [Sevgi::Geometry::Point, Array<Numeric>] first point
+      # @param ending [Sevgi::Geometry::Point, Array<Numeric>] second point
+      # @return [Sevgi::Geometry::Point] midpoint
+      # @raise [Sevgi::Geometry::Error] when either point cannot be coerced
+      def self.midpoint(starting, ending)
+        starting, ending = Tuples[Point, starting, ending]
+        self[(starting.x / 2.0) + (ending.x / 2.0), (starting.y / 2.0) + (ending.y / 2.0)]
       end
 
       # Returns the origin point.

data/lib/sevgi/geometry/predicate.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    # Internal helpers shared by public geometry predicates.
+    # @api private
+    module Predicate
+      extend self
+
+      def adjacent_overlap?(a, b, c, precision: nil)
+        orientation(a, b, c, precision:).zero? &&
+          (point_on_segment?(c, a, b, precision:) || point_on_segment?(a, b, c, precision:))
+      end
+
+      def adjacent_overlap_in?(vertices, precision: nil)
+        vertices.each_index.any? do |i|
+          adjacent_overlap?(vertices[i - 1], vertices[i], vertices[(i + 1) % vertices.size], precision:)
+        end
+      end
+
+      def between?(value, a, b, precision: nil)
+        minimum, maximum = [a, b].minmax
+        F.ge?(value, minimum, precision:) && F.le?(value, maximum, precision:)
+      end
+
+      def collinear?(points, precision: nil)
+        # ponytail: cubic worst-case comparisons; optimize the maximum triangle area if large sets need faster queries.
+        points.sort_by { [it.x, it.y] }.combination(3).all? do |a, b, c|
+          orientation(a, b, c, precision:).zero?
+        end
+      end
+
+      def convex_turns?(vertices, precision: nil)
+        turns = turn_orientations(vertices, precision:)
+        !turns.empty? && turns.uniq.one?
+      end
+
+      def edges(vertices)
+        vertices.each_index.map { |i| [vertices[i], vertices[(i + 1) % vertices.size]] }
+      end
+
+      def nonadjacent_intersection?(vertices, precision: nil)
+        edges = edges(vertices)
+        # ponytail: quadratic comparisons; use a sweep-line algorithm if large polygons need faster queries.
+        edges.each_index.any? do |i|
+          ((i + 1)...edges.size).any? do |j|
+            !adjacent_indices?(i, j, edges.size) && segments_intersect?(*edges[i], *edges[j], precision:)
+          end
+        end
+      end
+
+      def orientation(a, b, c, precision: nil)
+        cross = Cross[b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y]
+        return 0 if F.zero?(cross, precision:)
+
+        F.lt?(cross, 0.0, precision:) ? -1 : 1
+      end
+
+      def point_on_segment?(point, a, b, precision: nil)
+        orientation(a, b, point, precision:).zero? &&
+          between?(point.x, a.x, b.x, precision:) &&
+          between?(point.y, a.y, b.y, precision:)
+      end
+
+      def repeated_vertex?(vertices, precision: nil)
+        vertices.each_index.any? do |i|
+          ((i + 1)...vertices.size).any? { |j| Point.eq?(vertices[i], vertices[j], precision:) }
+        end
+      end
+
+      def segments_intersect?(a, b, c, d, precision: nil)
+        first = [a, b]
+        second = [c, d]
+        turns = segment_orientations(*first, *second, precision:)
+
+        proper_intersection?(turns) || boundary_intersection?(first, second, turns, precision:)
+      end
+
+      def simple?(vertices, precision: nil)
+        !repeated_vertex?(vertices, precision:) &&
+          !adjacent_overlap_in?(vertices, precision:) &&
+          !nonadjacent_intersection?(vertices, precision:)
+      end
+
+      private
+
+      def adjacent_indices?(i, j, size) = j == i + 1 || (i.zero? && j == size - 1)
+
+      def boundary_intersection?(first, second, turns, precision: nil)
+        a, b = first
+        c, d = second
+        candidates = [[turns[0], c, a, b], [turns[1], d, a, b], [turns[2], a, c, d], [turns[3], b, c, d]]
+
+        candidates.any? { |turn, point, from, to| turn.zero? && point_on_segment?(point, from, to, precision:) }
+      end
+
+      def proper_intersection?(turns)
+        turns.none?(&:zero?) && turns[0] != turns[1] && turns[2] != turns[3]
+      end
+
+      def segment_orientations(a, b, c, d, precision: nil)
+        [
+          orientation(a, b, c, precision:),
+          orientation(a, b, d, precision:),
+          orientation(c, d, a, precision:),
+          orientation(c, d, b, precision:)
+        ]
+      end
+
+      def turn_orientations(vertices, precision: nil)
+        vertices
+          .each_index
+          .map { |i|
+            orientation(vertices[i], vertices[(i + 1) % vertices.size], vertices[(i + 2) % vertices.size], precision:)
+          }
+          .reject(&:zero?)
+      end
+    end
+
+    private_constant :Predicate
+
+    class Point
+      # Reports whether three or more points lie on one infinite line.
+      #
+      # Every three-point subset must have a cross product that rounds to zero at the selected decimal precision.
+      # The cross-product magnitude is twice the triangle area, not a distance tolerance.
+      # Repeated points are allowed. Input order does not affect the result, and accepted sets have accepted subsets.
+      # Triangle area is invariant under rigid motion, subject to floating-point error near the rounding threshold.
+      # The worst-case number of comparisons is cubic in the point count.
+      # @param points [Array<Sevgi::Geometry::Point, Array<Numeric>>] point-like values
+      # @param precision [Integer, nil] decimal precision, or nil for the current function default
+      # @return [Boolean]
+      # @raise [Sevgi::ArgumentError] when fewer than three points are given or precision is not an Integer or nil
+      # @raise [Sevgi::Geometry::Error] when a point cannot be coerced
+      # @example Test a point set
+      #   Sevgi::Geometry::Point.collinear?([0, 0], [1, 1], [2, 2]) # => true
+      def self.collinear?(*points, precision: nil)
+        ArgumentError.("At least three points required") if points.size < 3
+
+        Predicate.collinear?(Tuples[self, *points], precision:)
+      end
+    end
+
+    class Polygon
+      # Reports whether the polygon boundary has no self-intersection.
+      #
+      # Adjacent edges may meet only at their shared endpoint. Non-adjacent
+      # touches and overlaps make the polygon non-simple.
+      # @param precision [Integer, nil] decimal precision, or nil for the current function default
+      # @return [Boolean]
+      # @raise [Sevgi::ArgumentError] when precision is not an Integer or nil
+      def simple?(precision: nil) = Predicate.simple?(vertices, precision:)
+
+      # Reports whether this is a simple polygon whose non-collinear turns all have one orientation.
+      #
+      # Redundant vertices on straight edges are permitted. Self-intersecting
+      # and fully degenerate polygons are not convex.
+      # @param precision [Integer, nil] decimal precision, or nil for the current function default
+      # @return [Boolean]
+      # @raise [Sevgi::ArgumentError] when precision is not an Integer or nil
+      def convex?(precision: nil)
+        simple?(precision:) && Predicate.convex_turns?(vertices, precision:)
+      end
+
+      # Reports whether this is a simple non-convex polygon.
+      #
+      # Self-intersecting and degenerate polygons are neither convex nor concave.
+      # @param precision [Integer, nil] decimal precision, or nil for the current function default
+      # @return [Boolean]
+      # @raise [Sevgi::ArgumentError] when precision is not an Integer or nil
+      def concave?(precision: nil)
+        simple?(precision:) && !Predicate.convex_turns?(vertices, precision:)
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/segment.rb

@@ -7,7 +7,7 @@ module Sevgi
     # A Segment has no position: `length` is a distance and `angle` is a
     # clockwise direction. Use {#ending} to apply it to a starting point or
     # {#line} when a placed, finite line is required. `Segment[length, angle]`
-    # starts from polar components; `Segment.(starting, ending)` derives them
+    # starts from polar components. `Segment.(starting, ending)` derives them
     # from two points.
     # @example Derive polar components from two points
     #   segment = Sevgi::Geometry::Segment.([1, 2], [4, 6])
@@ -128,11 +128,13 @@ module Sevgi
       # @raise [Sevgi::Geometry::Error] when other cannot be coerced
       def eq?(other, precision: nil) = self.class.eq?(self, other, precision:)
 
-      # Reports strict segment equality.
+      # Reports exact length-and-direction equality, also used by ==. Ordering through <=> compares length only.
       # @param other [Object] object to compare
       # @return [Boolean]
       def eql?(other) = self.class == other.class && deconstruct == other.deconstruct
 
+      alias_method :==, :eql?
+
       # Returns a hash compatible with strict equality.
       # @return [Integer]
       def hash = [self.class, *deconstruct].hash

data/lib/sevgi/geometry/version.rb

@@ -3,6 +3,6 @@
 module Sevgi
   module Geometry
     # Component version.
-    VERSION = "0.98.2"
+    VERSION = "1.0.0"
   end
 end

data/lib/sevgi/geometry.rb

@@ -8,6 +8,7 @@ require_relative "geometry/errors"
 require_relative "geometry/point"
 require_relative "geometry/segment"
 require_relative "geometry/element"
+require_relative "geometry/predicate"
 require_relative "geometry/equation"
 require_relative "geometry/operation"
 
@@ -18,8 +19,8 @@ module Sevgi
   #
   # Coordinates follow SVG screen conventions: +x points right, +y points down,
   # and positive angles turn clockwise. Constructors accept Point and Segment
-  # objects or their two-number Array forms. Transformations return new values;
-  # they do not mutate their receiver.
+  # objects or their two-number Array forms. Transformations return new values.
+  # They do not mutate their receiver.
   #
   # Shape constructors have two complementary notations: `Shape[...]` accepts
   # dimensions or segments, while `Shape.(...)` accepts points. Named factories
@@ -27,7 +28,7 @@ module Sevgi
   # when a call site benefits from spelling it out.
   #
   # Trigonometric construction can retain ordinary floating-point noise. Use
-  # `approx` for presentation values and `eq?` for precision-aware comparison;
+  # `approx` for presentation values and `eq?` for precision-aware comparison.
   # strict `==` intentionally compares the exact immutable value.
   #
   # @example Measure and move a line

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sevgi-geometry
 version: !ruby/object:Gem::Version
-  version: 0.98.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Recai Oktaş
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.98.2
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.98.2
+        version: 1.0.0
 description: Models the points, lines, shapes, and transforms used by the DSL.
 email: roktas@gmail.com
 executables: []
@@ -34,6 +34,11 @@ files:
 - README.md
 - lib/sevgi/geometry.rb
 - lib/sevgi/geometry/element.rb
+- lib/sevgi/geometry/elements/arc.rb
+- lib/sevgi/geometry/elements/circle.rb
+- lib/sevgi/geometry/elements/ellipse.rb
+- lib/sevgi/geometry/elements/ellipse/affine.rb
+- lib/sevgi/geometry/elements/ellipse/length.rb
 - lib/sevgi/geometry/elements/line.rb
 - lib/sevgi/geometry/elements/parallelogram.rb
 - lib/sevgi/geometry/elements/polygon.rb
@@ -47,8 +52,10 @@ files:
 - lib/sevgi/geometry/internal.rb
 - lib/sevgi/geometry/operation.rb
 - lib/sevgi/geometry/operation/align.rb
+- lib/sevgi/geometry/operation/box.rb
 - lib/sevgi/geometry/operation/sweep.rb
 - lib/sevgi/geometry/point.rb
+- lib/sevgi/geometry/predicate.rb
 - lib/sevgi/geometry/segment.rb
 - lib/sevgi/geometry/version.rb
 homepage: https://sevgi.roktas.dev
@@ -73,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Geometry values and operations for Sevgi drawings.
 test_files: []