sevgi-geometry 0.93.1 → 0.94.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 692e31b99ab3fb9e757badcf6b764bc5c788ed79a6d6955109e6edc44e9929b1
-  data.tar.gz: 92eb5d40058eeafafc625767e4abef2c201ee516fab38372bb1da440ec6c2c42
+  metadata.gz: d61732219fd2a5aec56e466123a5aab75df9e1b25734fe8449a2d4235b8d10b4
+  data.tar.gz: a0ba1edbfaefbcc54912f5fe0e24cea5af13ec834fde5e3147c81fe4ae3a80c2
 SHA512:
-  metadata.gz: 6c741e60a6f2f37d0b6418cd2c574c9e6bae2bbc02ab0ee4835564bd49b9ddb68ceef420aacb62dfba25d405c0ad7c0db93efa1fa4c263839bb1dcb802010598
-  data.tar.gz: e596f27e84b36bcccabdb059c47641fdd468857595b60eda23592e4b69eccb59500159be5ece5b7f9a96e463bf4731a68ab13e7f1fedbe90094d71094fbe4b5a
+  metadata.gz: cfdf1b5a5e128e678225357e9073282dfc8376ed0547f9dadb00bad1d7c60243b748077912a3b218226a079ba5605ab5c5d9a6f7abe0d0541132dcc0aeca2328
+  data.tar.gz: 37aa84553b62b5d8316923fdfb258de010cafbed34ea3a464a7e5d3134f746acd18e3bb39985a613b64a731d2195246aab755c545345d812a14d141bb8fd2625

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog
+
+Sevgi Geometry follows the root Sevgi release notes:
+https://github.com/roktas/sevgi/blob/main/CHANGELOG.md

data/LICENSE

@@ -0,0 +1,5 @@
+Sevgi Geometry is distributed under the GNU General Public License v3.0 or later.
+
+SPDX-License-Identifier: GPL-3.0-or-later
+
+Full project license: https://github.com/roktas/sevgi/blob/main/LICENSE

data/README.md

@@ -1,5 +1,37 @@
 # Sevgi Geometry
 
-Provides small geometry primitives and operations for Sevgi drawings.
+Small geometry primitives and operations for Sevgi drawings.
 
-See the root [README](../README.md) and the documentation site for usage.
+## Install
+
+```sh
+gem install sevgi-geometry
+```
+
+## Require
+
+```ruby
+require "sevgi/geometry"
+```
+
+## Example
+
+```ruby
+rect = Sevgi::Geometry::Rect[3, 5]
+rect.box.width
+```
+
+## Ruby compatibility
+
+Requires Ruby 3.4.0 or newer. CI verifies Ruby 3.4 and the current development Ruby from `.ruby-version`.
+
+## Native prerequisites
+
+None beyond Ruby and this gem's Ruby dependencies.
+
+## Links
+
+- Documentation: https://sevgi.roktas.dev
+- API documentation: https://www.rubydoc.info/gems/sevgi-geometry
+- Source: https://github.com/roktas/sevgi/tree/main/geometry
+- Changelog: https://github.com/roktas/sevgi/blob/main/CHANGELOG.md

data/lib/sevgi/geometry/element.rb

@@ -19,6 +19,8 @@ module Sevgi
       #   @raise [NoMethodError] until arced elements are implemented
       def self.arced(...) = Arced.build(...)
 
+      private_class_method :arced
+
       # Core API
 
       # Returns a copy moved to a point and optional offset.
@@ -210,6 +212,7 @@ module Sevgi
 
           @points ||= calculate_points_from_segments
           @segments ||= calculate_segments_from_points
+          freeze_geometry!
 
           sanitize
         end
@@ -234,11 +237,11 @@ module Sevgi
           approx.draw!(...)
         end
 
-        # Returns element points.
+        # Returns immutable element points.
         # @param approximate [Boolean] true to round points with the current function precision
-        # @return [Array<Sevgi::Geometry::Point>]
+        # @return [Array<Sevgi::Geometry::Point>] frozen point collection
         def points(approximate = false)
-          approximate ? @points.map(&:approx) : @points
+          approximate ? @points.map(&:approx).freeze : @points
         end
 
         # Returns the first point.
@@ -247,15 +250,54 @@ module Sevgi
           @position ||= points.first
         end
 
-        # Returns element segments.
+        # Returns immutable element segments.
         # @param approximate [Boolean] true to round segments with the current function precision
-        # @return [Array<Sevgi::Geometry::Segment>]
+        # @return [Array<Sevgi::Geometry::Segment>] frozen segment collection
         def segments(approximate = false)
-          approximate ? @segments.map(&:approx) : @segments
+          approximate ? @segments.map(&:approx).freeze : @segments
         end
 
         # Affinity methods
 
+        # @!parse
+        #   # Returns an element reflected across the selected axes.
+        #   # @param x [Boolean] reflect across the x-axis
+        #   # @param y [Boolean] reflect across the y-axis
+        #   # @return [Sevgi::Geometry::Element::Lined]
+        #   def reflect(x: true, y: true); end
+        #
+        #   # Returns an element rotated around the origin.
+        #   # @param a [Numeric] clockwise angle in degrees
+        #   # @return [Sevgi::Geometry::Element::Lined]
+        #   def rotate(a); end
+        #
+        #   # Returns an element scaled from the origin.
+        #   # @param sx [Numeric] x scale factor
+        #   # @param sy [Numeric, Sevgi::Undefined] y scale factor, defaulting to sx
+        #   # @return [Sevgi::Geometry::Element::Lined]
+        #   def scale(sx, sy = Undefined); end
+        #
+        #   # Returns an element skewed from the origin.
+        #   # @param ax [Numeric] x-axis skew angle in degrees
+        #   # @param ay [Numeric, Sevgi::Undefined] y-axis skew angle in degrees, defaulting to ax
+        #   # @return [Sevgi::Geometry::Element::Lined]
+        #   def skew(ax, ay = Undefined); end
+        #
+        #   # Returns an element skewed along x.
+        #   # @param a [Numeric] skew angle in degrees
+        #   # @return [Sevgi::Geometry::Element::Lined]
+        #   def skew_x(a); end
+        #
+        #   # Returns an element skewed along y.
+        #   # @param a [Numeric] skew angle in degrees
+        #   # @return [Sevgi::Geometry::Element::Lined]
+        #   def skew_y(a); end
+        #
+        #   # Returns an element translated by offset.
+        #   # @param dx [Numeric] x offset
+        #   # @param dy [Numeric, Sevgi::Undefined] y offset, defaulting to dx
+        #   # @return [Sevgi::Geometry::Element::Lined]
+        #   def translate(dx, dy = Undefined); end
         Geometry::Affinity.instance_methods.each do |transform|
           define_method(transform) do |*args, **kwargs, &block|
             self.class.new_by_points!(*points.map { it.public_send(transform, *args, **kwargs, &block) })
@@ -264,35 +306,48 @@ module Sevgi
 
         # Equality methods
 
-        # Reports strict element equality by class and approximate points.
+        # Compares element points with optional numeric precision.
         # @param other [Object] object to compare
+        # @param precision [Integer, nil] decimal precision, or nil for the current function default
         # @return [Boolean]
-        def eql?(other) = self.class == other.class && points(true) == other.points(true)
+        def eq?(other, precision: nil)
+          other.instance_of?(self.class) &&
+            points.size == other.points.size &&
+            points.zip(other.points).all? { |left, right| left.eq?(right, precision:) }
+        end
+
+        # Reports strict element equality by class and exact points.
+        # @param other [Object] object to compare
+        # @return [Boolean]
+        def eql?(other) = other.instance_of?(self.class) && points == other.points
 
         # Returns a hash compatible with strict equality.
         # @return [Integer]
-        def hash = [self.class, *points(true)].hash
+        def hash = [self.class, *points].hash
 
         alias == eql?
 
         # Interaction methods
 
-        # Returns boundary equations for all lines.
-        # @return [Array<Sevgi::Geometry::Equation::Linear>]
-        def equations = @equations ||= lines.map(&:equation)
+        # Returns immutable boundary equations for all lines.
+        # @return [Array<Sevgi::Geometry::Equation::Linear>] frozen equation collection
+        def equations = @equations ||= lines.map(&:equation).freeze
 
         # Intersects the element boundary with an equation.
+        #
+        # Boundary membership is tested on unrounded candidate points. `precision:`
+        # only rounds returned coordinates and controls duplicate collapse after
+        # membership has been accepted. When `precision` is nil, returned points use
+        # the current function precision.
         # @param equation [Sevgi::Geometry::Equation] equation to intersect with
-        # @param precision [Integer, nil] decimal precision, or nil for the current function default
+        # @param precision [Integer, nil] decimal precision for returned points, or nil for the current function default
         # @return [Array<Sevgi::Geometry::Point>] unique boundary intersection points
         # @raise [Sevgi::Geometry::Error] when equation is not an equation
         # @raise [Sevgi::PanicError] when the equation combination is not implemented
         def intersection(equation, precision: nil)
           equations
-            .map do |candidate|
-              equation.intersect(candidate).map { |point| point.approx(precision) }.select { |point| on?(point) }
-            end
-            .flatten
+            .flat_map { |candidate| equation.intersect(candidate).select { |point| on?(point) } }
+            .map { |point| point.approx(precision) }
             .uniq
         end
 
@@ -318,12 +373,15 @@ module Sevgi
         # @return [Sevgi::Geometry::Segment]
         def head = @head ||= segments.first
 
-        # Returns boundary lines derived from segments and points.
-        # @return [Array<Sevgi::Geometry::Line>]
+        # Returns immutable boundary lines derived from segments and points.
+        # @return [Array<Sevgi::Geometry::Line>] frozen line collection
         def lines
-          @lines ||= segments.zip(points[...segments.size]).map { |segment, position|
-            segment.line(position)
-          }
+          @lines ||= segments
+            .zip(points[...segments.size])
+            .map { |segment, position|
+              segment.line(position)
+            }
+            .freeze
         end
 
         # Returns the sum of segment lengths.
@@ -337,12 +395,17 @@ module Sevgi
         # Relation methods
 
         # Reports whether a point is inside or on the boundary.
+        #
+        # Open paths have no filled interior; for them this predicate is true
+        # only for points on the actual path 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]
 
+          return on?(point) if self.class.open?
+
           on?(point) || pnpoly(points, point)
         end
 
@@ -379,6 +442,11 @@ module Sevgi
           points.each_cons(2).map { Segment.(*it) }
         end
 
+        def freeze_geometry!
+          @points = @points.dup.freeze
+          @segments = @segments.dup.freeze
+        end
+
         # rubocop:disable Metrics/MethodLength
         # https://wrfranklin.org/Research/Short_Notes/pnpoly.html
         def pnpoly(vertices, test)
@@ -418,6 +486,8 @@ module Sevgi
       # @api private
       class Arced < self
       end
+
+      private_constant :Arced
       # rubocop:enable Metrics/ClassLength
     end
 
@@ -427,9 +497,5 @@ module Sevgi
     require_relative "elements/polyline"
     require_relative "elements/rect"
     require_relative "elements/triangle"
-
-    require_relative "elements/circle"
-    require_relative "elements/curve"
-    require_relative "elements/ellipse"
   end
 end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "forwardable"
-
 module Sevgi
   module Geometry
     # Generated superclass for Line.
@@ -36,14 +34,33 @@ module Sevgi
       #   @raise [Sevgi::Geometry::Error] when either point cannot be coerced
       def self.from_points(...) = new_by_points(...)
 
-      extend Forwardable
+      # Returns the clockwise line angle in degrees.
+      # @return [Float]
+      def angle = head.angle
+
+      # Returns the ending point.
+      # @return [Sevgi::Geometry::Point]
+      def ending = points.last
 
-      def_delegators :head, :length, :angle
+      # Reports whether a point is left of the line equation.
+      # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
+      # @return [Boolean]
+      # @raise [Sevgi::Geometry::Error] when point cannot be coerced
+      def left?(point) = equation.left?(point)
 
-      def_delegator :points, :first, :starting
-      def_delegator :points, :last, :ending
+      # Returns the line segment length.
+      # @return [Float]
+      def length = head.length
+
+      # Reports whether a point is right of the line equation.
+      # @param point [Sevgi::Geometry::Point, Array<Numeric>] point to test
+      # @return [Boolean]
+      # @raise [Sevgi::Geometry::Error] when point cannot be coerced
+      def right?(point) = equation.right?(point)
 
-      def_delegators :equation, :left?, :right?
+      # 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

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

@@ -72,10 +72,42 @@ module Sevgi
       # @return [Float]
       def width = @width ||= segments[0].length
 
+      # @!parse
+      #   # Returns the top-left corner.
+      #   # @return [Sevgi::Geometry::Point]
+      #   def top_left; end
+      #
+      #   # Returns the top-right corner.
+      #   # @return [Sevgi::Geometry::Point]
+      #   def top_right; end
+      #
+      #   # Returns the bottom-right corner.
+      #   # @return [Sevgi::Geometry::Point]
+      #   def bottom_right; end
+      #
+      #   # Returns the bottom-left corner.
+      #   # @return [Sevgi::Geometry::Point]
+      #   def bottom_left; end
       %i[top_left top_right bottom_right bottom_left].each_with_index do |corner, i|
         define_method(corner) { points[i] }
       end
 
+      # @!parse
+      #   # Returns the top side line.
+      #   # @return [Sevgi::Geometry::Line]
+      #   def top; end
+      #
+      #   # Returns the right side line.
+      #   # @return [Sevgi::Geometry::Line]
+      #   def right; end
+      #
+      #   # Returns the bottom side line.
+      #   # @return [Sevgi::Geometry::Line]
+      #   def bottom; end
+      #
+      #   # Returns the left side line.
+      #   # @return [Sevgi::Geometry::Line]
+      #   def left; end
       %i[top right bottom left].each_with_index do |side, i|
         define_method(side) { lines[i] }
       end

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

@@ -7,37 +7,41 @@ module Sevgi
     TriangleBase = Element.lined(3)
     private_constant :TriangleBase
 
-    # Closed three-sided element built from two adjacent segments.
+    # Closed three-sided element built from two non-collinear adjacent segments.
     class Triangle < TriangleBase
       # 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
+      # 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
       # @param segment_b [Sevgi::Geometry::Segment, Array<Numeric>] second segment
       # @param position [Sevgi::Geometry::Point, Array<Numeric>] starting point
       # @return [Sevgi::Geometry::Triangle]
-      # @raise [Sevgi::Geometry::Error] when segments or position cannot be coerced
+      # @raise [Sevgi::Geometry::Error] when segments or position cannot be coerced, or the segments are degenerate
       def self.[](segment_a, segment_b, position: Origin)
         a, b = Tuples[Segment, segment_a, segment_b]
 
+        validate!(a, b)
         new_by_segments(a, b, closing_segment(a, b), position:)
       end
 
       def self.closing_segment(a, b)
-        b_reverse_angle = b.angle - 180.0
-        angle_between = b_reverse_angle - a.angle
-        length = closing_length(a, b, angle_between)
-
-        Segment[length, closing_angle(a, b_reverse_angle, angle_between, length)]
+        Segment.(b.ending(a.ending(Origin)), Origin)
       end
 
-      def self.closing_angle(a, b_reverse_angle, angle_between, length)
-        b_reverse_angle + F.asin(a.length * F.sin(angle_between) / length)
-      end
+      def self.cross(a, b) = (a.x * b.y) - (a.y * b.x)
 
-      def self.closing_length(a, b, angle_between)
-        ::Math.sqrt((a.length ** 2) + (b.length ** 2) - (2 * a.length * b.length * F.cos(angle_between)))
+      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")
+        end
       end
 
-      private_class_method :closing_angle, :closing_length, :closing_segment
+      private_class_method :closing_segment, :cross, :validate!
     end
   end
 end

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

@@ -17,11 +17,12 @@ 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
           def initialize(slope:, intercept:)
             super()
 
-            @slope = slope.to_f
-            @intercept = intercept.to_f
+            @slope = Real[:slope, slope]
+            @intercept = Real[:intercept, intercept]
           end
 
           # Returns an equation rounded to precision.
@@ -116,6 +117,7 @@ module Sevgi
           # 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)
 
           # Returns an equation rounded to precision.
@@ -146,10 +148,11 @@ module Sevgi
           # Creates a vertical equation.
           # @param c [Numeric] x coordinate
           # @return [void]
+          # @raise [Sevgi::Geometry::Error] when c is not a finite Numeric
           def initialize(c)
             super()
 
-            @x = c.to_f
+            @x = Real[:x, c]
           end
 
           # Returns an equation rounded to precision.

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

@@ -8,7 +8,8 @@ module Sevgi
       end
     end
 
-    # Circle equation support is not implemented yet.
+    # Reserved circle element support.
+    # @api private
     class Circle
       # Returns the circle equation.
       # @abstract Circle equation support is not implemented yet.
@@ -18,5 +19,7 @@ module Sevgi
         PanicError.("#{self.class}#equation must be implemented")
       end
     end
+
+    private_constant :Circle
   end
 end

data/lib/sevgi/geometry/equation.rb

@@ -8,16 +8,19 @@ module Sevgi
       # @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
       def self.diagonal(slope:, intercept:) = Linear::Diagonal.new(slope:, intercept:)
 
       # Builds a horizontal linear equation.
       # @param const [Numeric] y coordinate
       # @return [Sevgi::Geometry::Equation::Linear::Horizontal]
+      # @raise [Sevgi::Geometry::Error] when const is not a finite Numeric
       def self.horizontal(const) = Linear::Horizontal.new(const)
 
       # Builds a vertical linear equation.
       # @param const [Numeric] x coordinate
       # @return [Sevgi::Geometry::Equation::Linear::Vertical]
+      # @raise [Sevgi::Geometry::Error] when const is not a finite Numeric
       def self.vertical(const) = Linear::Vertical.new(const)
 
       # Intersects this equation with another equation.

data/lib/sevgi/geometry/internal.rb

@@ -2,6 +2,27 @@
 
 module Sevgi
   module Geometry
+    # Validates finite real numeric inputs for geometry primitives.
+    # @api private
+    module Real
+      # Coerces a public numeric value to 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
+      def self.[](field, value)
+        unless value.is_a?(::Numeric)
+          Error.("Geometry #{field} must be a finite Numeric: #{value.inspect}")
+        end
+
+        value.to_f.tap do |number|
+          Error.("Geometry #{field} must be finite: #{value.inspect}") unless number.finite?
+        end
+      end
+    end
+
+    private_constant :Real
+
     # Coerces array-like geometry inputs into typed tuple objects.
     # @api private
     module Tuple
@@ -13,8 +34,7 @@ module Sevgi
       def self.[](klass, arg)
         case arg
         when ::Array
-          Error.("Array must have 2 elements: #{arg}", arg) unless arg.size == 2
-          Error.("Must be a numeric array: #{arg}") unless arg.all?(::Numeric)
+          Error.("Array must have 2 elements: #{arg.inspect}") unless arg.size == 2
 
           klass.send(:new, *arg)
         when klass

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

@@ -59,6 +59,8 @@ module Sevgi
       end
 
       register(Align, :align, :alignment)
+
+      private_constant :Align
     end
   end
 end

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

@@ -10,8 +10,11 @@ module Sevgi
         # Default maximum number of sweep iterations.
         LIMIT = 1_000
 
-        # Sweeps parallel lines across an element in both directions.
-        # @param element [Sevgi::Geometry::Element] element to intersect
+        # 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.
+        # @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
         # @param step [Numeric] signed distance between sweep lines
@@ -33,8 +36,11 @@ module Sevgi
           end
         end
 
-        # Sweeps parallel lines and requires at least one result.
-        # @param element [Sevgi::Geometry::Element] element to intersect
+        # 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.
+        # @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
         # @param step [Numeric] signed distance between sweep lines
@@ -56,7 +62,10 @@ module Sevgi
         end
 
         # Sweeps parallel lines in one signed direction from an equation.
-        # @param element [Sevgi::Geometry::Element] element to intersect
+        #
+        # Generated lines are boundary-to-boundary interior spans. A single
+        # sweep position can produce multiple lines for closed concave elements.
+        # @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
@@ -69,9 +78,7 @@ module Sevgi
             points = element.intersection(equation)
             return lines if points.empty?
 
-            if points.size == 2 && !(line = Line.(*points)).ignorable?
-              lines << line
-            end
+            lines.concat(interior_lines(element, equation, points))
 
             equation = equation.shift(step)
           end
@@ -86,9 +93,43 @@ module Sevgi
         def applicable?(element)
           element.respond_to?(:intersection)
         end
+
+        private
+
+        def interior_lines(element, equation, points)
+          if points.size == 2
+            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))
+
+            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)
+
+          line unless line.ignorable?
+        end
+
+        def sorted_points(equation, points)
+          points.sort_by do |point|
+            equation.is_a?(Equation::Linear::Vertical) ? [point.y, point.x] : [point.x, point.y]
+          end
+        end
       end
 
       register(Sweep, :sweep, :sweep!, :unisweep)
+
+      private_constant :Sweep
     end
   end
 end

data/lib/sevgi/geometry/operation.rb

@@ -12,6 +12,66 @@ module Sevgi
       # Raised when an operation does not apply to the target element.
       OperationInapplicableError = Class.new(Error)
 
+      # @!parse
+      #   class << self
+      #     # Returns an element translated to align with another element.
+      #     # @param element [Sevgi::Geometry::Element] element to move
+      #     # @param other [Sevgi::Geometry::Element] reference element
+      #     # @param alignment [Symbol] one of :center, :left, :right, :top, or :bottom
+      #     # @return [Sevgi::Geometry::Element] translated element
+      #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when an argument is not a geometry element
+      #     # @raise [Sevgi::ArgumentError] when alignment is unknown
+      #     def align(element, other, alignment = :center); end
+      #
+      #     # Returns the offset needed to align one element with another.
+      #     # @param element [Sevgi::Geometry::Element] element to move
+      #     # @param other [Sevgi::Geometry::Element] reference element
+      #     # @param alignment [Symbol] one of :center, :left, :right, :top, or :bottom
+      #     # @return [Sevgi::Geometry::Point] translation offset
+      #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when an argument is not a geometry element
+      #     # @raise [Sevgi::ArgumentError] when alignment is unknown
+      #     def alignment(element, other, alignment = :center); end
+      #
+      #     # Sweeps parallel lines across a lined element in both directions.
+      #     # @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
+      #     # @param step [Numeric] signed distance between sweep lines
+      #     # @param limit [Integer] maximum iterations per direction
+      #     # @yield [lines] optional hook receiving the generated lines
+      #     # @yieldparam lines [Array<Sevgi::Geometry::Line>] generated sweep lines
+      #     # @yieldreturn [void]
+      #     # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
+      #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when element is not sweepable
+      #     # @raise [Sevgi::Geometry::Error] when initial cannot be coerced
+      #     # @raise [Sevgi::Geometry::Operation::OperationError] when iteration reaches the limit
+      #     def sweep(element, initial:, angle:, step:, limit: Sweep::LIMIT); end
+      #
+      #     # Sweeps parallel lines across a lined element and requires at least one result.
+      #     # @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
+      #     # @param step [Numeric] signed distance between sweep lines
+      #     # @param limit [Integer] maximum iterations per direction
+      #     # @yield [lines] optional hook receiving the generated lines
+      #     # @yieldparam lines [Array<Sevgi::Geometry::Line>] generated sweep lines
+      #     # @yieldreturn [void]
+      #     # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
+      #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when element is not sweepable
+      #     # @raise [Sevgi::Geometry::Error] when initial cannot be coerced
+      #     # @raise [Sevgi::Geometry::Operation::OperationError] when no lines are found or iteration reaches the limit
+      #     def sweep!(element, initial:, angle:, step:, limit: Sweep::LIMIT); end
+      #
+      #     # Sweeps parallel lines in one signed direction from an equation.
+      #     # @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::Operation::OperationInapplicableError] when element is not sweepable
+      #     # @raise [Sevgi::Geometry::Operation::OperationError] when iteration reaches the limit
+      #     def unisweep(element, equation, step, limit: Sweep::LIMIT); end
+      #   end
       # Registers one or more public operation methods.
       # @api private
       # @param handler [Module] operation handler module
@@ -19,6 +79,8 @@ module Sevgi
       # @return [Array<Symbol>] registered operation names
       def register(handler, *operations) = operations.each { |operation| def_operation(operation, handler) }
 
+      private :register
+
       private
 
       def def_operation(operation, handler)

data/lib/sevgi/geometry/point.rb

@@ -100,7 +100,8 @@ module Sevgi
       # @param x [Numeric] x coordinate
       # @param y [Numeric] y coordinate
       # @return [void]
-      def initialize(x:, y:) = super(x: x.to_f, y: y.to_f)
+      # @raise [Sevgi::Geometry::Error] when a coordinate is not a finite Numeric
+      def initialize(x:, y:) = super(x: Real[:x, x], y: Real[:y, y])
 
       # Compares points by x, then y.
       # @param other [Sevgi::Geometry::Point, Array<Numeric>] point to compare

data/lib/sevgi/geometry/segment.rb

@@ -66,7 +66,8 @@ module Sevgi
       # @param length [Numeric] segment length
       # @param angle [Numeric] clockwise angle in degrees
       # @return [void]
-      def initialize(length:, angle:) = super(length: length.to_f, angle: angle.to_f)
+      # @raise [Sevgi::Geometry::Error] when a component is not a finite Numeric
+      def initialize(length:, angle:) = super(length: Real[:length, length], angle: Real[:angle, angle])
 
       # Compares segments by length.
       # @param other [Sevgi::Geometry::Segment, Array<Numeric>] segment to compare

data/lib/sevgi/geometry/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sevgi-geometry
 version: !ruby/object:Gem::Version
-  version: 0.93.1
+  version: 0.94.0
 platform: ruby
 authors:
 - Recai Oktaş
@@ -15,26 +15,25 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.93.1
+        version: 0.94.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.93.1
+        version: 0.94.0
 description: Enhances the Sevgi toolkit with geometry objects and methods.
 email: roktas@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE
 - README.md
 - lib/sevgi/geometry.rb
 - lib/sevgi/geometry/element.rb
-- lib/sevgi/geometry/elements/circle.rb
-- lib/sevgi/geometry/elements/curve.rb
-- lib/sevgi/geometry/elements/ellipse.rb
 - lib/sevgi/geometry/elements/line.rb
 - lib/sevgi/geometry/elements/parallelogram.rb
 - lib/sevgi/geometry/elements/polygon.rb
@@ -67,7 +66,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.4.0.pre.preview1
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

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

@@ -1 +0,0 @@
-

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

@@ -1 +0,0 @@
-

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

@@ -1 +0,0 @@
-