philiprehberger-interval 0.1.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b5feb2306f98ba2503ab869e66ac58fd56139aa14d3f041061b2ff1b8b04aaf
-  data.tar.gz: fb0243723812d3beba1236ad6748d1883f8d20239d07664629f19ac264104e8c
+  metadata.gz: 2614076496fada8f6202df687ec993c5438e3a47945824e05e6bb4d00cc1c046
+  data.tar.gz: 2557c885218f82fe7de28ea6e91e660b9b901ab2995ca8d68e3a1ef9cf9b2d21
 SHA512:
-  metadata.gz: cdd4cacab98e36b308d8eb2ad34a8344a97a7f05df5f4cfcd3cf995992ee41c605b36bcffe559f15c88b95a942df2cd2450f5762d6dde9f89ace2ddcea70fb74
-  data.tar.gz: 1f7400f6b2cddc7003da83e8e174109d8acdc6cb176558f21b5c02ed18e2af778cf306e968068fde0c1d9fe98ae0ea042b545ac8ba3e632cea9a69b5e6a59c63
+  metadata.gz: ed05a860c2d28ce9cfdf00787585e117c41ee03bd1a4f917f4c06d4c461313a7fcdfe0fa7ce9f6073804c4c67c1169e84a7988a2070d8f54f42a725a0caef36b
+  data.tar.gz: 8451b55300a3d8d489cc895792256f4e7a1077d9be2a0df25aee1e7f9ef42d9defa2de2fe7eabe3b3d3c58c6c959037f65f89a06eaa8e96d61025ff91a09e285

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-04-15
+
+### Added
+- `Interval.intersection(intervals)` — compute the common overlap of a collection of intervals
+
+## [0.2.0] - 2026-04-03
+
+### Added
+- Open, half-open interval types via `type:` parameter (`:closed`, `:open`, `:left_open`, `:right_open`)
+- `shift` method for translating intervals
+- `scale` method for resizing around an anchor point
+- `split` method for dividing into equal sub-intervals
+- `clamp` method for constraining values to interval bounds
+
+## [0.1.6] - 2026-03-31
+
+### Added
+- Add GitHub issue templates, dependabot config, and PR template
+
 ## [0.1.5] - 2026-03-31
 
 ### Changed

data/README.md

@@ -4,7 +4,7 @@
 [![Gem Version](https://badge.fury.io/rb/philiprehberger-interval.svg)](https://rubygems.org/gems/philiprehberger-interval)
 [![Last updated](https://img.shields.io/github/last-commit/philiprehberger/rb-interval)](https://github.com/philiprehberger/rb-interval/commits/main)
 
-Interval data type with overlap detection, merging, and gap finding
+Interval data type with open/closed boundaries, arithmetic, merging, and gap finding
 
 ## Requirements
 
@@ -38,6 +38,32 @@ a.union(b)         # => [1, 8]
 a.include?(4)      # => true
 ```
 
+### Interval Types
+
+Supports closed, open, and half-open boundaries:
+
+```ruby
+closed     = Philiprehberger::Interval.new(1, 5, type: :closed)     # [1, 5] (default)
+open       = Philiprehberger::Interval.new(1, 5, type: :open)       # (1, 5)
+left_open  = Philiprehberger::Interval.new(1, 5, type: :left_open)  # (1, 5]
+right_open = Philiprehberger::Interval.new(1, 5, type: :right_open) # [1, 5)
+
+closed.include?(5)      # => true
+right_open.include?(5)  # => false
+```
+
+### Interval Arithmetic
+
+```ruby
+interval = Philiprehberger::Interval.new(2, 8)
+
+interval.shift(3)                    # => [5, 11]
+interval.scale(2, anchor: :left)     # => [2, 14]
+interval.scale(0.5, anchor: :center) # => [3.5, 6.5]
+interval.split(3)                    # => [[2, 4], [4, 6], [6, 8]]
+interval.clamp(10)                   # => 8
+```
+
 ### Merging Intervals
 
 ```ruby
@@ -57,6 +83,19 @@ Philiprehberger::Interval.gaps(intervals)
 # => [[7, 10]]
 ```
 
+### Finding a Common Intersection
+
+Compute the overlap shared by every interval, or `nil` if any pair is disjoint:
+
+```ruby
+Philiprehberger::Interval.intersection([
+  Philiprehberger::Interval.new(1, 10),
+  Philiprehberger::Interval.new(3, 8),
+  Philiprehberger::Interval.new(5, 12)
+])
+# => [5, 8]
+```
+
 ### With Time Values
 
 ```ruby
@@ -68,17 +107,23 @@ shift.include?(Time.new(2026, 1, 1, 12))  # => true
 
 | Method | Description |
 |--------|-------------|
-| `.new(start, finish)` | Create a closed interval |
-| `#overlaps?(other)` | Check if two intervals overlap |
+| `.new(start, finish, type:)` | Create an interval (`:closed`, `:open`, `:left_open`, `:right_open`) |
+| `#type` | Return the interval boundary type |
+| `#overlaps?(other)` | Check if two intervals overlap (respects boundary types) |
 | `#contains?(other)` | Check if interval fully contains another |
 | `#adjacent?(other)` | Check if intervals are touching but not overlapping |
 | `#intersect(other)` | Return the overlap between two intervals |
 | `#union(other)` | Return the combined interval |
 | `#subtract(other)` | Remove another interval, returning remaining parts |
 | `#size` | Length of the interval |
-| `#include?(point)` | Check if a point falls within the interval |
+| `#include?(point)` | Check if a point falls within the interval (respects boundary types) |
+| `#shift(delta)` | Return new interval shifted by delta, preserving type |
+| `#scale(factor, anchor:)` | Scale width around anchor (`:center`, `:left`, `:right`) |
+| `#split(n)` | Split into n equal sub-intervals |
+| `#clamp(value)` | Clamp value to interval bounds |
 | `.merge(intervals)` | Merge overlapping intervals into non-overlapping set |
 | `.gaps(intervals)` | Find gaps between a set of intervals |
+| `.intersection(intervals)` | Common overlap of a collection of intervals, or `nil` |
 
 ## Development
 

data/lib/philiprehberger/interval/range.rb

@@ -2,7 +2,10 @@
 
 module Philiprehberger
   module Interval
-    # Represents a closed interval [start, finish] over any Comparable type.
+    VALID_TYPES = %i[closed open left_open right_open].freeze
+
+    # Represents an interval over any Comparable type.
+    # Supports closed [a, b], open (a, b), left-open (a, b], and right-open [a, b) boundaries.
     class Range
       include Comparable
 
@@ -12,16 +15,23 @@ module Philiprehberger
       # @return [Comparable] the end of the interval
       attr_reader :finish
 
+      # @return [Symbol] the interval type (:closed, :open, :left_open, :right_open)
+      attr_reader :type
+
       # Create a new interval.
       #
       # @param start [Comparable] the start value
       # @param finish [Comparable] the end value
+      # @param type [Symbol] boundary type (:closed, :open, :left_open, :right_open)
       # @raise [Error] if start > finish
-      def initialize(start, finish)
+      # @raise [Error] if type is invalid
+      def initialize(start, finish, type: :closed)
         raise Error, 'start must be <= finish' if start > finish
+        raise Error, "invalid interval type: #{type}" unless VALID_TYPES.include?(type)
 
         @start = start
         @finish = finish
+        @type = type
       end
 
       # Check if this interval overlaps with another.
@@ -29,7 +39,21 @@ module Philiprehberger
       # @param other [Range] the other interval
       # @return [Boolean]
       def overlaps?(other)
-        @start <= other.finish && other.start <= @finish
+        return false if empty? || other.empty?
+
+        left_ok = if right_closed? && other.left_closed?
+                    @finish >= other.start
+                  else
+                    @finish > other.start
+                  end
+
+        right_ok = if other.right_closed? && left_closed?
+                     other.finish >= @start
+                   else
+                     other.finish > @start
+                   end
+
+        left_ok && right_ok
       end
 
       # Check if this interval fully contains another.
@@ -94,7 +118,66 @@ module Philiprehberger
       # @param point [Comparable] the point to check
       # @return [Boolean]
       def include?(point)
-        point.between?(@start, @finish)
+        left = left_closed? ? point >= @start : point > @start
+        right = right_closed? ? point <= @finish : point < @finish
+        left && right
+      end
+
+      # Return a new interval shifted by delta, preserving type.
+      #
+      # @param delta [Numeric] the amount to shift
+      # @return [Range] a new shifted interval
+      def shift(delta)
+        self.class.new(@start + delta, @finish + delta, type: @type)
+      end
+
+      # Scale interval width around an anchor point, preserving type.
+      #
+      # @param factor [Numeric] the scale factor
+      # @param anchor [Symbol] the anchor point (:center, :left, :right)
+      # @return [Range] a new scaled interval
+      def scale(factor, anchor: :center)
+        current_size = size
+        new_size = current_size * factor
+
+        case anchor
+        when :left
+          self.class.new(@start, @start + new_size, type: @type)
+        when :right
+          self.class.new(@finish - new_size, @finish, type: @type)
+        when :center
+          center = @start + (current_size / 2.0)
+          half = new_size / 2.0
+          self.class.new(center - half, center + half, type: @type)
+        else
+          raise Error, "invalid anchor: #{anchor}"
+        end
+      end
+
+      # Split interval into n equal sub-intervals, preserving type.
+      #
+      # @param n [Integer] number of sub-intervals
+      # @return [Array<Range>] array of n equal sub-intervals
+      def split(n)
+        raise Error, 'n must be positive' if n < 1
+
+        step = size.to_f / n
+        Array.new(n) do |i|
+          sub_start = @start + (step * i)
+          sub_finish = @start + (step * (i + 1))
+          self.class.new(sub_start, sub_finish, type: @type)
+        end
+      end
+
+      # Clamp a value to the interval bounds.
+      #
+      # @param value [Comparable] the value to clamp
+      # @return [Comparable] the clamped value
+      def clamp(value)
+        return @start if value < @start
+        return @finish if value > @finish
+
+        value
       end
 
       # Compare intervals by start then finish.
@@ -108,18 +191,37 @@ module Philiprehberger
 
       # @return [Boolean]
       def ==(other)
-        other.is_a?(self.class) && @start == other.start && @finish == other.finish
+        other.is_a?(self.class) && @start == other.start && @finish == other.finish && @type == other.type
       end
 
       # @return [String]
       def to_s
-        "[#{@start}, #{@finish}]"
+        left_bracket = left_closed? ? '[' : '('
+        right_bracket = right_closed? ? ']' : ')'
+        "#{left_bracket}#{@start}, #{@finish}#{right_bracket}"
       end
 
       # @return [String]
       def inspect
         "#<#{self.class} #{self}>"
       end
+
+      # @return [Boolean] true if the left endpoint is included
+      def left_closed?
+        @type == :closed || @type == :right_open
+      end
+
+      # @return [Boolean] true if the right endpoint is included
+      def right_closed?
+        @type == :closed || @type == :left_open
+      end
+
+      protected
+
+      # @return [Boolean] true if the interval contains no points
+      def empty?
+        @start == @finish && @type != :closed
+      end
     end
   end
 end

data/lib/philiprehberger/interval/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module Interval
-    VERSION = '0.1.5'
+    VERSION = '0.3.0'
   end
 end

data/lib/philiprehberger/interval.rb

@@ -12,8 +12,8 @@ module Philiprehberger
     # @param start [Comparable] the start value
     # @param finish [Comparable] the end value
     # @return [Range] a new interval
-    def self.new(start, finish)
-      Range.new(start, finish)
+    def self.new(start, finish, type: :closed)
+      Range.new(start, finish, type: type)
     end
 
     # Merge a collection of overlapping or adjacent intervals into non-overlapping intervals.
@@ -39,6 +39,20 @@ module Philiprehberger
       merged
     end
 
+    # Compute the common overlap across a collection of intervals.
+    #
+    # @param intervals [Array<Range>] the intervals to intersect
+    # @return [Range, nil] the common intersection, or nil if any pair is disjoint
+    def self.intersection(intervals)
+      return nil if intervals.empty?
+
+      intervals[1..].reduce(intervals.first) do |acc, current|
+        return nil if acc.nil?
+
+        acc.intersect(current)
+      end
+    end
+
     # Find gaps between a collection of intervals.
     #
     # @param intervals [Array<Range>] the intervals to analyze

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-interval
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-31 00:00:00.000000000 Z
+date: 2026-04-15 00:00:00.000000000 Z
 dependencies: []
-description: Closed interval data type supporting overlap detection, containment,
-  intersection, union, subtraction, merging collections, and finding gaps. Works with
-  any Comparable type including Numeric and Time.
+description: Interval data type supporting closed, open, and half-open boundaries
+  with overlap detection, containment, intersection, union, subtraction, shift, scale,
+  split, clamp, merging collections, and finding gaps. Works with any Comparable type
+  including Numeric and Time.
 email:
 - me@philiprehberger.com
 executables: []
@@ -25,11 +26,11 @@ files:
 - lib/philiprehberger/interval.rb
 - lib/philiprehberger/interval/range.rb
 - lib/philiprehberger/interval/version.rb
-homepage: https://github.com/philiprehberger/rb-interval
+homepage: https://philiprehberger.com/open-source-packages/ruby/philiprehberger-interval
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/philiprehberger/rb-interval
+  homepage_uri: https://philiprehberger.com/open-source-packages/ruby/philiprehberger-interval
   source_code_uri: https://github.com/philiprehberger/rb-interval
   changelog_uri: https://github.com/philiprehberger/rb-interval/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/philiprehberger/rb-interval/issues
@@ -52,5 +53,6 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Interval data type with overlap detection, merging, and gap finding
+summary: Interval data type with open/closed boundaries, arithmetic, merging, and
+  gap finding
 test_files: []