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

Parameters:

  • ranges (Array<Range>) —

    ranges to test for overlaps

Returns:

  • (Boolean) —

    were there overlaps among ranges?

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

Parameters:

  • other (Range) —

    range to compare self with

Returns:

  • (-1, 0, 1) —

    if self is less, equal, or greater than other

#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

Parameters:

  • other (Range) —

    other range to test for contiguity

Returns:

  • (Boolean) —

    is self contiguous with other

#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

Parameters:

Returns:

#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

Parameters:

  • other (Range) —

    the Range self is intersected with

Returns:

  • (Range, nil) —

    a Range representing the intersection

#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)

Parameters:

  • other (Range) —

    the Range to join to this range

Returns:

  • (Range, nil) —

    this range joined to other

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

Parameters:

  • other (Range) —

    other range to test for contiguity

Returns:

  • (Boolean) —

    is self left_contiguous with other

#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)]

Parameters:

  • ranges (Array<Range>) —

    ranges to search for overlaps

Returns:

  • (Array<Range>) —

    overlaps with ranges but inside this Range

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

Return whether self overlaps with other Range.

Parameters:

  • other (Range) —

    range to test for overlap with self

Returns:

  • (Boolean) —

    is there an overlap?

#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.

Parameters:

  • ranges (Array<Range>) —

    ranges to test for overlaps

Returns:

  • (Boolean) —

    were there overlaps among ranges?

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

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

Parameters:

  • other (Range) —

    the containing range

Returns:

  • (Boolean) —

    is self wholly within other

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

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

Parameters:

  • other (Range) —

    the contained range

Returns:

  • (Boolean) —

    does self wholly contain other

#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

Parameters:

  • other (Range) —

    other range to test for contiguity

Returns:

  • (Boolean) —

    is self right_contiguous with other

#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.

Parameters:

Returns:

  • (Boolean)

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

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

Parameters:

  • other (Range) —

    the containing range

Returns:

  • (Boolean) —

    is self within other

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

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

Parameters:

  • other (Range) —

    the contained range

Returns:

  • (Boolean) —

    does self contain other

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

Allow erb or erubis documents to directly interpolate a Range.

Returns:

#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

Parameters:

  • other (Range) —

    the Range self is union-ed with

Returns:

  • (Range, nil) —

    a Range representing the union