Class: Range

Inherits:
Object
  • Object
show all
Extended by:
FatCore::Range::ClassMethods
Includes:
FatCore::Range
Defined in:
lib/fat_core/range.rb

Sorting collapse

Queries collapse

Operations collapse

Class Method Details

.overlaps_among?(ranges) ⇒ Boolean Originally defined in module FatCore::Range::ClassMethods

Return whether any of the ranges overlap one another

Instance Method Details

#<=>(other) ⇒ -1, ... Originally defined in module FatCore::Range

Compare this range with other first by min values, then by max values.

This causes a sort of Ranges with Comparable elements to sort from left to right on the number line, then for Ranges that start on the same number, from smallest to largest.

Examples:

(4..8) <=> (5..7) #=> -1
(4..8) <=> (4..7) #=> 1
(4..8) <=> (4..8) #=> 0

#contiguous?(other) ⇒ Boolean Originally defined in module FatCore::Range

Is self contiguous to other either on the left or on the right? First, the two ranges are sorted by their min values, and the range with the lowest min value is considered to be on the "left" and the other range on the "right". Whether one range is "contiguous" to another then has two cases:

  1. If the max element of the Range on the left respond to the #succ method (that is, its value is a discrete value such as Integer or Date) test whether the succ to the max value of the Range on the left is equal to the min value of the Range on the right.
  2. If the max element of the Range on the left does not respond to the #succ method (that is, its values are continuous values such as Floats) test whether the max value of the Range on the left is equal to the min value of the Range on the right

Examples:

(0..10).contiguous?((11..20))           #=> true
(11..20).contiguous?((0..10))           #=> true, right_contiguous
(0..10).contiguous?((15..20))           #=> false
(3.145..12.3).contiguous?((0.5..3.145)) #=> true
(3.146..12.3).contiguous?((0.5..3.145)) #=> false

#difference(other) ⇒ Object Also known as: - Originally defined in module FatCore::Range

The difference method, -, removes the overlapping part of the other argument from self. Because in the case where self is a superset of the other range, this will result in the difference being two non-contiguous ranges, this returns an array of ranges. If there is no overlap or if self is a subset of the other range, return an array of self

#gaps(ranges) ⇒ Array<Range> Originally defined in module FatCore::Range

If this range is not spanned by the ranges collectively, return an Array of ranges representing the gaps in coverage. The ranges can over-cover this range on the left or right without affecting the result, that is, each range in the returned array of gap ranges will always be subsets of this range.

If the ranges span this range, return an empty array.

Examples:

(0..10).gaps([(0..3), (5..6), (9..10)])  #=> [(4..4), (7..8)]
(0..10).gaps([(-4..3), (5..6), (9..15)]) #=> [(4..4), (7..8)]
(0..10).gaps([(-4..3), (4..6), (7..15)]) #=> [] ranges span this one
(0..10).gaps([(-4..-3), (11..16), (17..25)]) #=> [(0..10)] no overlap
(0..10).gaps([])                             #=> [(0..10)] no overlap

#intersection(other) ⇒ Range? Also known as: & Originally defined in module FatCore::Range

Return a Range that represents the intersection between this range and the other range. If there is no intersection, return nil.

Examples:

(0..10) & (5..20)             #=> (5..10)
(0..10).intersection((5..20)) #=> (5..10)
(0..10) & (15..20)            #=> nil

#join(other) ⇒ Range? Originally defined in module FatCore::Range

Return a range that concatenates this range with other if it is contiguous with this range on the left or right; return nil if the ranges are not contiguous.

Examples:

(0..3).join(4..8) #=> (0..8)

See Also:

#left_contiguous?(other) ⇒ Boolean Originally defined in module FatCore::Range

Is self on the left of and contiguous to other? Whether one range is "contiguous" to another has two cases:

  1. If the elements of the Range on the left respond to the #succ method (that is, its values are discrete values such as Integers or Dates) test whether the succ to the max value of the Range on the left is equal to the min value of the Range on the right.
  2. If the elements of the Range on the left do not respond to the #succ method (that is, its values are continuous values such as Floats) test whether the max value of the Range on the left is equal to the min value of the Range on the right

Examples:

(0..10).left_contiguous((11..20))           #=> true
(11..20).left_contiguous((0..10))           #=> false, but right_contiguous
(0.5..3.145).left_contiguous((3.145..18.4)) #=> true
(0.5..3.145).left_contiguous((3.146..18.4)) #=> false

#overlaps(ranges) ⇒ Array<Range> Originally defined in module FatCore::Range

Within this range return an Array of Ranges representing the overlaps among the given Array of Ranges ranges. If there are no overlaps, return an empty array. Don't consider overlaps in the ranges that occur outside of self.

Examples:

(0..10).overlaps([(-4..4), (2..7), (5..12)]) => [(2..4), (5..7)]

#overlaps?(other) ⇒ Boolean Originally defined in module FatCore::Range

Return whether self overlaps with other Range.

#overlaps_among?(ranges) ⇒ Boolean Originally defined in module FatCore::Range

Return whether any of the ranges that overlap self have overlaps among one another.

This does the same thing as Range.overlaps_among?, except that it filters the ranges to only those overlapping self before testing for overlaps among them.

#proper_subset_of?(other) ⇒ Boolean Originally defined in module FatCore::Range

Return whether self is contained within other range, without their boundaries touching.

#proper_superset_of?(other) ⇒ Boolean Originally defined in module FatCore::Range

Return whether self contains other range, without their boundaries touching.

#right_contiguous?(other) ⇒ Boolean Originally defined in module FatCore::Range

Is self on the right of and contiguous to other? Whether one range is "contiguous" to another has two cases:

  1. If the elements of the Range on the left respond to the #succ method (that is, its values are discrete values such as Integers or Dates) test whether the succ to the max value of the Range on the left is equal to the min value of the Range on the right.
  2. If the elements of the Range on the left do not respond to the #succ method (that is, its values are continuous values such as Floats) test whether the max value of the Range on the left is equal to the min value of the Range on the right

Examples:

(11..20).right_contiguous((0..10))           #=> true
(0..10).right_contiguous((11..20))           #=> false, but left_contiguous
(3.145..12.3).right_contiguous((0.5..3.145)) #=> true
(3.146..12.3).right_contiguous((0.5..3.145)) #=> false

#spanned_by?(ranges) ⇒ Boolean Originally defined in module FatCore::Range

Return true if the given ranges collectively cover this range without overlaps and without gaps.

#subset_of?(other) ⇒ Boolean Originally defined in module FatCore::Range

Return whether self is contained within other range, even if their boundaries touch.

#superset_of?(other) ⇒ Boolean Originally defined in module FatCore::Range

Return whether self contains other range, even if their boundaries touch.

#tex_quote ⇒ String Originally defined in module FatCore::Range

Allow erb or erubis documents to directly interpolate a Range.

#union(other) ⇒ Range? Also known as: + Originally defined in module FatCore::Range

Return a Range that represents the union between this range and the other range. If there is no overlap and self is not contiguous with other, return nil.

Examples:

(0..10) + (5..20)       #=> (0..20)
(0..10).union((5..20))  #=> (0..20)
(0..10) + (15..20)      #=> nil