rangeary 0.3.0 → 1.0

data/lib/rangeary/rangeary.rb

@@ -43,64 +43,127 @@ end
 # Class to express the multiple ranges.
 #
 # The library package <tt>range_extd</tt> is required.
-# {https://rubygems.org/gems/range_extd}
+# https://rubygems.org/gems/range_extd
+#
+# An arbitrary number of {Rangeary},
+# {RangeExtd}[http://rubygems.org/gems/range_extd] or Range objects (or its
+# descendant classes) can be supplied for the constructor {#initialize}.
+# Then, an operation of disjunction is performed to get the clean Array of
+# RangeExtd, none of which overlaps with the range.
+#
+# Once it is constructed, {Rangeary} objects are immutable.  Any subsequent
+# operations return a new {Rangeary} object.  All but few methods of {Array}
+# are inherited, though some methods, such as +push+ do not work because of
+# immutability of {Rangeary} objects.
 #
 class Rangeary < Array
   undef_method :*, :+, :length, :reverse
 
-  # Hash with the keys of :negative and :positive
-  attr_reader :infinities
+  # # Hash with the keys of :negative and :positive  => becomes a method in Ver.1
+  # attr_reader :infinities
 
+  # Constructor
   #
   # Arbitrary (positive) number of arguments can be given.
   # (r1, [r2, ...])
   #
-  # It is possible to supply the user-defined infinity objects for both or either
-  # positive and negative infinity.  If one (or more) of the arguments is
-  # a {Rangeary} object, their infinity values are inherited, unless explicitly
-  # specified in the optional arguments.
+  # == Algorithm about the infinity
+  #
+  # In {Rangeary} operations, "infinity" is essential.  Without it, negation
+  # could not be definied.  To determine what the positive and negative
+  # infinities for the given elements is not a trivial task.
+  #
+  # Callers can supply user-defined infinity objects for both or either
+  # positive and negative infinity and in that case they are accepted
+  # as the infinities with the highest priority, though ArgumentError might be
+  # issued if they contradict the elements; for example, if a {Rangeary}
+  # instance consists of an array of Integer Ranges (RangeExtd) like (3..8),
+  # and yet if String "abc" is specified as an infinity, it *contradicts*
+  # with the elements in the sense they are not comparable.
+  #
+  # Alternatively, if the main argument contains one or moer {Rangeary}
+  # instances, their infinities are inherited.  If their infinities are not
+  # identical to one another, warning may be issued if $VERBOSE is true, and
+  # the infinities are selected in the following priority order:
+  #
+  # 1. If one or more user-supplied infinities are found, the smallest and
+  #    largest ones are accepted for the positive and negative infinities.
+  #    Note the consistency is not checked; that is, even if one or more of
+  #    the provided Range elements from which a {Rangeary} instance is about
+  #    to be constructed exceed the infinities, this does not warn. Obviously
+  #    subsequent operations may result in some unexpected result. Be warned.
+  # 2. Float::INFINITY.
+  # 3. RangeExtd::Infinity instances (RangeExtd::Infinity::POSITIVE
+  #    and RangeExtd::Infinity::NEGATIVE)
+  #
+  # If none of the main arguments contains {Rangeary}, the elements of each
+  # Range are checked whether they have any comparable Numeric instances
+  # like Integer (but not Complex), and if so, Float::INFINITY is set
+  # as the infinities.  Otherwise, it falls back to the defaults of
+  # the RangeExtd::Infinity instances.
   #
-  # @param inarall [Object] An arbitrary number of either {Rangeary}, {RangeExtd} or {Range} objects (or its subclasses).
-  # @option **opts [Object] :positive Object for positive infinity. In default {Float::INFINITY} for Numeric Real or else {RangeExtd::Infinity::POSITIVE}.
-  # @option **opts [Object] :negative Object for negative infinity. In default -{Float::INFINITY} for Numeric Real or else {RangeExtd::Infinity::NEGATIVE}.
+  # The registered infinities for each instance is obtained as a Hash with
+  # two keys of +:positive+ and +negative+ with the method {#infinities};
+  # for example,
+  #
+  #   ran.infinities  # => { :positive => RangeExtd::Infinity::POSITIVE,
+  #                   #      :negative => "aa" }
+  #
+  # === Note for Developers about the infinity
+  #
+  # Instance variable @infinities (Hash) is defined.  The elements can be nil;
+  # for example, when only the element is RangeExtd::NONE.
+  # So, it is recommended to access with the {#infinities} method rather
+  # than accessing @infinities directly.
+  #
+  # At the moment, the infinities are guessed from the elements of the Range
+  # it contains and set (+guess_strict: false+ is given to {#_get_infinities}).
+  # If +guess_strict: true+ is given, unless a Range contains literally
+  # +Float::INFINITY+ etc, (the element of) @infinities is not set (remains nil).
+  # I hope it would work even if +guess_strict: true+ is given.  However,
+  # it is not tested properly!  Anyway, to check the consistency of
+  # the infinities is desirable, which is performed now, thanks to
+  # +guess_strict: false+ given to {#_get_infinities}.
+  #
+  # @param inarall [Object] An arbitrary number of either {Rangeary}, RangeExtd or Range objects (or its subclasses).
+  # @option **opts [Object] :positive Object for positive infinity. In default Float::INFINITY for comparable Numeric or else {RangeExtd::Infinity::POSITIVE}.
+  # @option **opts [Object] :negative Object for negative infinity. In default -Float::INFINITY for comparable Numeric or else {RangeExtd::Infinity::NEGATIVE}.
   def initialize(*inarall, **opts)
+    @infinities =  { :negative => nil, :positive => nil }
 
     if inarall.size < 1
-      raise ArgumentError, "wrong number of arguments (#{inarall.size} for 1 or more)."
+      super [RangeExtd::NONE]  # Since Ver.1
+      return
+      # raise ArgumentError, "wrong number of arguments (#{inarall.size} for 1 or more)."
     end
 
-    hsInheritedObj   = {:negative =>nil, :positive =>nil}
-    hsInheritedAry   = {:negative => [], :positive => []}
-    hsInheritedClass = {:negative => [], :positive => []}
-    inarall = inarall.map{|i|
-      if defined?(i.first_element) && defined?(i.infinities)
-        begin
-          [:negative, :positive].each do |nega_posi|
-            hsInheritedAry[nega_posi].push(  i.infinities[nega_posi])
-            hsInheritedClass[nega_posi].push(i.infinities[nega_posi].class)
-          end
-        rescue
-          warn "warning: Rangeary#infinities looks wrong in the input (#{i})."
-        end
-        i.to_a
-      else
-        i
-      end
+    # Unfold Rangeary into Array of Arrays and convert Range-s into RangeExtd-s
+    in_ranges = inarall.map{|i|
+      self.class.send(:is_rangeary_type?, i) ? i.to_a : i
     }.flatten.map{|j|
       if (defined? j.exclude_begin?)
         j
       else
         begin
           RangeExtd.new(j)
-        rescue ArgumentError	# Just to change the error message.
+        rescue ArgumentError, RangeError  # Just to change the error message.
           raise ArgumentError, "invalid parameter for RangeExtd, hence for Rangeary (#{j.inspect})."
         end
       end
     }
 
-    # _merge_overlaps
+    # NOTE: Simple map(&:infinities) is not ideal here, because map(&:infinities) tries to
+    #   supplement when the value is nil.  However, in self.conjunction(), it uses map(&:infinities),
+    #   which is not ideal.
+    inherited_infs = inarall.find_all{|i| self.class.send(:is_rangeary_type?, i)}.map{ |ec|
+      ec.instance_variable_get(:@infinities)
+    }
+
+    @infinities = _get_infinities(in_ranges, inherited_infs: inherited_infs, guess_strict: false, **opts) # set @infinities (wherever possible)
+
+    # Call _merge_overlaps
     begin
-      arRange = _merge_overlaps( convert2range(inarall) )
+      arRange = _merge_overlaps( convert2range(in_ranges) )
     rescue => err
       # Trap just to change the type of the exception.
       raise ArgumentError, err.message, err.backtrace
@@ -111,87 +174,7 @@ class Rangeary < Array
     end
 
     ## Setting @infinities[:negative, :positive]
-
-    # Check inherited objects if there is any, namely if the argument includes any RangeAry object.
-    # Priority: Float > Others > RangeExtd::Infinity
-    if hsInheritedAry[:negative].size > 0
-      [:negative, :positive].each do |es| 
-        iFloat = hsInheritedClass[es].find_index(Float)
-        if iFloat.nil?
-          iElse = hsInheritedClass[es].find_index{|i| (i != RangeExtd::Infinity) && (i != Float)}
-          if iElse.nil?
-            iRangeInf = hsInheritedClass[es].find_index(RangeExtd::Infinity)
-            if iRangeInf.nil?
-              raise "Rangeary#infinities is not set in the input."	# Should not happen, as Rangeary#infinities must be set always.
-            else
-              hsInheritedObj[es] = hsInheritedAry[es][iRangeInf]
-            end
-          else
-            hsInheritedObj[es] = hsInheritedAry[es][iElse]
-          end
-        else
-          hsInheritedObj[es] = hsInheritedAry[es][iFloat]
-        end	# if iFloat.nil?
-      end	# [:negative, :positive].each do |es| 
-    end		# if hsInheritedAry.size > 0
-
-    hsFlag = { :found => {:negative => false, :positive => false} }
-    hsCand = { :negative => arRange[0].begin, :positive => arRange[-1].end }
-    infDef = { :negative => RangeExtd::Infinity::NEGATIVE, :positive => RangeExtd::Infinity::POSITIVE }
-    @infinities={ :negative => nil, :positive => nil }
-    [:negative, :positive].each do |es| 
-      if (infDef[es] == hsCand[es])	# Can be Float or whatever.
-        @infinities[es] = hsCand[es]	# highest priority
-        hsFlag[:found][:negative] = true
-      else
-        strtmp = ""
-        [opts[es], hsInheritedObj[es]].each do |opts_or_inherited|
-          @infinities[es] ||= opts_or_inherited		# uses ots[:****tive] or hsInheritedObj[:****tive] if not set.
-          # Now, checking the compatibility of the infinity value specified (or inherited) with the given range.
-          if (! opts_or_inherited.nil?) && (opts_or_inherited == @infinities[es]) && (! arRange[0].is_none?)
-            begin
-              _ = 0 * (opts_or_inherited <=> hsCand[es])
-            rescue TypeError
-              raise ArgumentError, "invalid #{strtmp}parameter for :#{es} => (#{opts_or_inherited.inspect}), incompatible with the range with begin=(#{hsCand[es].inspect})."
-            end
-          end
-          strtmp = "inherited "
-        end	# [opts[es], hsInheritedObj[es]].each do |opts_or_inherited|
-      end	# if (infDef[es] == hsCand[es])	# else
-    end	# [:negative, :positive].each do |es| 
-
-    if ! (@infinities[:negative] && @infinities[:positive])
-      # Either or both @infinities[:negative, :positive] is not set, yet.
-      # Need to set it now.  The possibilities are,
-      #  (1) arRange[0].null? && no opts/inheritance given.
-      #  (2) one of them is given by either arRange or opts or inheritance, but not the other.
-      #  (3) neither of them is given by arRange nor opts nor inheritance.
-      if arRange[0].null?
-        [:negative, :positive].each do |es| 
-          @infinities[es] ||= infDef[es]
-        end
-      else
-        # There must be a non-infinity object - we will find it out.
-        if hsFlag[:found][:negative]
-          obj2refer = arRange[0].end
-        else
-          obj2refer = arRange[-1].begin
-        end
-
-        # Now, if Numeric === obj2refer, Float::INFINITY is the default.
-        begin
-          _dummy = (1.0 < obj2refer)
-        rescue ArgumentError
-          # Not Numeric, hence the current infDef is used as it is.
-        else
-          # Numeric
-          infDef = { :negative => -Float::INFINITY, :positive => Float::INFINITY }
-        end
-        [:negative, :positive].each do |es| 
-          @infinities[es] ||= infDef[es]	# uses default infinity if not set.
-        end
-      end	# if arRange[0].null?
-    end		# if ! (@infinities[:negative] && @infinities[:positive])
+    # set_infinities_legacy(arRange, hsInheritedObj, hsInheritedAry, hsInheritedClass, **opts)
 
     super(arRange)
     self.freeze
@@ -199,13 +182,38 @@ class Rangeary < Array
 
   alias_method :triple_equals_orig, :=== if ! self.method_defined?(:triple_equals_orig)
 
+  # Returns @infinities where nil values are replaced with something significant.
+  #
+  # Best guess approach is taken.
+  #
+  # @return [Hash] keys of :positive and :negative.  The values are never nil.
+  def infinities
+    defhs = {
+      :positive => RangeExtd::Infinity::POSITIVE,
+      :negative => RangeExtd::Infinity::NEGATIVE,
+    }
+    hsret = {}.merge @infinities
+    if hsret[:positive].nil?
+      return defhs if hsret[:negative].nil?
+      hsret[:positive] = (is_num_type?(hsret[:negative]) ?  Float::INFINITY : defhs[:positive])
+      return hsret
+    end
+    if hsret[:negative].nil?
+      hsret[:negative] = (is_num_type?(hsret[:positive]) ? -Float::INFINITY : defhs[:negative])
+      return hsret
+    end
+
+    hsret
+  end
+
   # If self covers the entire range?
   #
   def all?
     rfirst = self[0]
     ((1 == size) &&
-     (@infinities[:negative] == rfirst.begin) &&
-     (@infinities[:positive] == rfirst.end) &&
+     !rfirst.is_none? &&
+     (infinities[:negative] == rfirst.begin) &&
+     ((infinities[:positive] == rfirst.end) || rfirst.end.nil?) &&  # Ruby 2.6 Endless Range
      (!rfirst.exclude_begin?) &&
      (!rfirst.exclude_end?))
   end
@@ -359,13 +367,13 @@ class Rangeary < Array
   #
   # @return [Array]
   # @raise [TypeError] if any of the ranges has no iteration defined, such as, starting from Float.
-  # @example 
+  # @example
   #    Rangeary(2...4, 5..6, 8..9).to_a      # => [2...4, 5..6, 8..9]
   #    Rangeary(2...4, 5..6, 8..9).flatten   # => [2, 3, 5, 6, 8, 9]
   #    Rangeary(2...4, 5..6, 8..9).flatten.reduce(:+)   # => 33
-  def flatten
+  def flatten_element
     to_a.reduce([]){|a,b| a+=b.to_a}
-  end	# def flatten
+  end
 
 
   # @return [String]
@@ -515,7 +523,7 @@ class Rangeary < Array
   alias_method :*, :conjunction
 
 
-  # Negation.
+  # Negation (class method).
   # 
   # @param r [Rangeary, RangeExtd, Range]
   # @return [Rangeary] 
@@ -533,7 +541,8 @@ class Rangeary < Array
     end
 
     arran = []
-    prevend = nil
+    prevend = nil          # if "end" is nil, this is substituted with Infinity.
+    prevend_orig = Object  # For Endless Range (Ruby 2.6), this can be nil.
     prevst  = nil
     to_a.each do |eachr|
 
@@ -546,7 +555,7 @@ class Rangeary < Array
           _beg = 1.0 * eachr.begin
           return (-Float::INFINITY..Float::INFINITY)
         rescue TypeError	# XXXX can't be coerced into Float
-          return Rangeary.new(@infinities[:negative]..@infinities[:positive])
+          return Rangeary.new(infinities[:negative]..infinities[:positive])
         end
       end
 
@@ -556,22 +565,34 @@ class Rangeary < Array
       else
         if prevend.nil?
           # The returned first range starts from the negative infinity.
-          arran.push( RangeExtd(@infinities[:negative]..eachr.begin, :exclude_end => (! eachr.exclude_begin?)) )
+          ran_tmp = normalized_range_for_negation(infinities[:negative], eachr.begin)
+          if RangeExtd::NONE != ran_tmp
+            # Avoid (inf..inf) type, which would cause RangeError (in Ruby 2.6) anyway.
+            arran.push( RangeExtd(ran_tmp, :exclude_end => (! eachr.exclude_begin?)) )
+          end
         else
-          arran.push( RangeExtd(prevend, eachr.begin, :exclude_begin => (! prevst), :exclude_end => (! eachr.exclude_begin?)) )
+          arran.push( RangeExtd(prevend_orig, eachr.begin, :exclude_begin => (! prevst), :exclude_end => (! eachr.exclude_begin?)) )
+          # arran.push( RangeExtd(prevend, eachr.begin, :exclude_begin => (! prevst), :exclude_end => (! eachr.exclude_begin?)) )
         end
       end	# if (eachr.begin == -Float::INFINITY) || (RangeExtd::NONE == eachr.begin)
-      prevend = eachr.end
+      prevend_orig = eachr.end
+      prevend = _comparable_end(eachr)  # For Ruby-2.6 Endless Range
       prevst  = eachr.exclude_end?
     end		# to_a.each do |eachr|
 
     if (RangeExtd::Infinity::POSITIVE == prevend)	# Including Float::INFINITY and other general positive infinities (nb., [#==] is not commutative!).
       ## Do nothing
     else
-      arran.push( RangeExtd.new(prevend..@infinities[:positive], :exclude_begin => (! prevst)) )
+      rbeg = (prevend_orig || prevend)
+      ran_tmp = normalized_range_for_negation(rbeg, infinities[:positive])
+
+      if RangeExtd::NONE != ran_tmp
+        # Avoid (inf..inf) type, which would cause RangeError (in Ruby 2.6) anyway.
+        arran.push( RangeExtd.new(ran_tmp, :exclude_begin => (! prevst)) )
+      end
     end
 
-    Rangeary.new(arran, :positive => @infinities[:positive], :negative => @infinities[:negative])
+    Rangeary.new(arran, :positive => infinities[:positive], :negative => infinities[:negative])
   end	# def negation()
 
   alias_method :~@, :negation
@@ -585,7 +606,7 @@ class Rangeary < Array
   #
   # @param r1 [Rangeary, RangeExtd, Range]
   # @param r2 [Rangeary, RangeExtd, Range]
-  # @return [Rangeary] 
+  # @return [Rangeary]
   def self.conjunction(r1, r2)
 
     r1 = Rangeary.new(r1) if ! defined? r1.first_element
@@ -595,20 +616,8 @@ class Rangeary < Array
     return Rangeary.new(r2) if r1.all?
 
     # Getting inherited options (if Rangeary is given) for the later use.
-    hsInherited = {}
-    [:negative, :positive].each do |ei|
-      hsInherited[ei] = [r1.infinities[ei], r2.infinities[ei]].map{|j|
-        (RangeExtd::Infinity === j) ? nil : j
-      }.compact.sort{|a,b|
-        if a.class == Float
-          -1
-        elsif b.class == Float
-          1
-        else
-          0
-        end
-      }[0]
-    end
+    hsInherited = _validate_select_infinities [r1, r2].map(&:infinities)
+    # hsInherited = _best_inherited_infinities [r1, r2].map(&:infinities)
 
     # Initialisation
     a1 = r1.to_a
@@ -633,8 +642,14 @@ class Rangeary < Array
       a1.each_with_index do |ea1, ind|
         # A bit of trick just to avoid unnecessary process
         next  if ind < last_a1index	# skip
-        break if ea2.end < ea1.begin	# Completely out of range
-        if ea1.end < ea2.begin		# Completely out of range
+
+        # For Ruby-2.6 Endless Range, comparable_end() is employed.
+        # Note: this comparison ignores @infinities even if set,
+        #   because @infinities may not be defined in the arguments!
+        #   Anyway, nothing should be larger than the upper limit (as tested below),
+        #   and so this should be fine.
+        break if comparable_end(ea2) < ea1.begin	# Completely out of range
+        if comparable_end(ea1) < ea2.begin		# Completely out of range
           last_a1index = ind if last_a1index < ind
           next
         end
@@ -652,6 +667,54 @@ class Rangeary < Array
   end	# def self.conjunction(r1, r2)
 
 
+  # Returns the infinity "end" that is comparable.
+  #
+  # Since Ruby-2.6, the Endless Range is introduced.
+  # In Ruby definition, the Endless Range er takes a form of er=(5..nil),
+  # and accordingly its "end" (or +last+) is nil:
+  #
+  #   (5..nil).end  # => nil
+  #
+  # Then, when you compare the "ends" of two Ranges with the method +<=>+,
+  # the result too is nil.
+  #
+  # In fact, in Ruby, two Range objects are not comparable with eath other,
+  # though the operator (or method) +<=>+ is defined for Range:
+  #
+  #   (3..6) <=> (8..9)  # => nil
+  #
+  # (Note this default behaviour is not unreasonable given what one compares
+  # is equivocal for Ranges, for example, the size, start or end?
+  # Indeed Range does not have a method +Range<=+ and hence +<=>+ is meaningless.)
+  #
+  # Then, when Range#end returns just nil, which should be interpreted
+  # as *Endless* in Range's context, it does not matter for Range.
+  # However, it is inconvenient for this class, {Rangeary}!
+  # The heart of comparison in {Rangeary} is +<=>+ for the begin first,
+  # and then the end if the first comparison results in equal.
+  #
+  # This method converts Range#end into something comparable when possible.
+  # More specifically, if the "end" of the given Range is nil, this returns
+  # Infinity (either +Float::INFINITY+ or +RangeExtd::Infinity::POSITIVE+),
+  # unless both begin and end are nil (RangeExtd::NONE, nil..nil, nil...nil),
+  # in which case nil is returned, and else returns simply +Range#end+.
+  #
+  # @param ran [Range, RangeExtd]
+  # @return [Object]
+  def self.comparable_end(ran)
+    if ran.class.method_defined?(:is_none?) && ran.is_none?
+      nil
+    elsif ran.end.nil? && ran.begin.nil?
+      nil
+    elsif ! ran.end.nil?
+      ran.end  # Before Ruby 2.6, this is always the case.
+    elsif ran.begin.class.method_defined? :to_int
+      Float::INFINITY
+    else
+      RangeExtd::Infinity::POSITIVE
+    end
+  end
+
   # Returns the array sorted, based on (1) the begin objects and their boundary state,
   # (2) then the end objects and their boundary state.
   # {RangeExtd::NONE} comes first, if included in the input array.
@@ -661,6 +724,16 @@ class Rangeary < Array
   def self.sort_ranges(*ar)
     ar.flatten.sort{ |a,b|
       err_msg_ab = "invalid parameter (#{a.inspect} or #{b.inspect})."
+
+      # Since Ruby-2.6, the end can be nil (Endless Range).
+      # Before Ruby-2.6, they used to raise Exception (ArgumentError) in Range
+      # and so they would not have sneaked in to RangeExtd, either.
+      # The following is in that sense meaningful only for Ruby 2.6 and later.
+      ends = { :a => a, :b => b }
+      ends.each_pair do |k, v|
+        ends[k] = comparable_end(v)
+      end
+
       ret = a.begin <=> b.begin
       case ret
       when -1, 1
@@ -675,7 +748,7 @@ class Rangeary < Array
             -1
           end
         else	# <= (a.exclude_begin? == b.exclude_begin?)
-          ret = a.end <=> b.end
+          ret = ends[:a] <=> ends[:b]
           case ret
           when -1, 1
             ret
@@ -690,18 +763,18 @@ class Rangeary < Array
           when nil
             # This should not happen for Range, let alone RangeExtd.
             # But could be the case for a user-defined class.
-            if a.end.nil? && b.end.nil?
+            if ends[:a].nil? && ends[:b].nil?
               0
-            elsif a.end.nil?
+            elsif ends[:a].nil?
               -1
-            elsif b.end.nil?
+            elsif ends[:b].nil?
                1
             else
               raise(TypeError, err_msg_ab)
             end
-          else	# case ret # a.end <=> b.end
+          else	# case ret # ends[:a] <=> ends[:b]
             raise(TypeError, err_msg_ab)
-          end	# case ret # a.end <=> b.end
+          end	# case ret # ends[:a] <=> ends[:b]
         end	# if (a.exclude_begin? ^ b.exclude_begin?)
       when nil	# case ret #(a.begin <=> b.begin)
         if a.begin.nil? && b.begin.nil?
@@ -720,7 +793,6 @@ class Rangeary < Array
   end	# def self.sort_ranges(ar)
 
 
-
   ####################
   private
   ####################
@@ -742,8 +814,362 @@ class Rangeary < Array
     }
   end
 
+  # Get the instance variable (Hash) @infinities
+  #
+  # @param in_infs [Hash] infinities template with keys: :positive, :negative
+  # @param arin [Array<Range, RangeExtd, Rangeary>]
+  # @param strict: [Boolean] if true (Def: false), set only when the value satisfies RangeExtd::Infinity.infinite?
+  # @param leave_existing: [Boolean] if true (Def: false), the existing non-nil values are not updated.
+  # @return [Array] Best guess for @infinities
+  def _best_guessed_infinities(in_infs, arin, strict: false, leave_existing: false)
+    reths = {}.merge in_infs
+    # Making the best effort to guess.
+    ar_rae = [RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::POSITIVE]
+    ar_num = [-Float::INFINITY, Float::INFINITY]
+    [arin].flatten.each do |ea|
+      hs = { negative: ea.begin, positive: ea.end }
+      reths.each_key do |ek|
+        errmsg = "Contradictory reference value #{hs[ek].inspect} for infinity (Existent: #{reths[ek].inspect}) is found, but ignored."
+        next if !hs[ek]
+        case reths[ek]
+        when nil
+          reths[ek] =  _guessed_infinity(ek, hs[ek], strict: strict)
+          next
+        when *ar_rae
+          reths[ek] = (_guessed_infinity(ek, hs[ek], strict: strict) || reths[ek]) if !leave_existing   # Update whatever.
+          next
+        when *ar_num
+          # Once Float::INFINITY is set, it will unchange.
+          next if ar_num.include? _guessed_infinity(ek, hs[ek])  # Consistent
+          next if ar_rae.include? _guessed_infinity(ek, hs[ek])  # Inconsistent, but ignore (Prev: Range::Inf, Given: Float::INF)
+          warn errmsg if !$VERBOSE.nil?
+          next
+        else
+          # Once User's value is set, it will unchange.
+          next if ar_rae.include? _guessed_infinity(ek, hs[ek])  # Inconsistent, but ignore (Prev: User, Given: Infinity)
+          warn errmsg if !$VERBOSE.nil?
+          next
+        end
+      end
+    end
+    reths
+  end
+  private :_best_guessed_infinities
+
+  # Instance method version
+  #
+  # where @infinities are taken into account.
+  #
+  # @param ran [Range, RangeExtd]
+  # @return [Object]
+  def _comparable_end(ran)
+    if ran.class.method_defined?(:is_none?) && ran.is_none?
+      nil
+    elsif ran.end.nil? && ran.begin.nil?
+      nil
+    elsif ! ran.end.nil?
+      ran.end  # Before Ruby 2.6, this is always the case.
+    else
+      infinities[:positive] || RangeExtd::Infinity::POSITIVE
+    end
+  end
+  private :_comparable_end
+
+  # Same as {#_comparable_end} but for begin
+  #
+  # Beyond the current Ruby (2.6).
+  # Needed for {#negation}.
+  #
+  # @param rbeg [Object]
+  # @param rend [Object]
+  # @return [Object]
+  def _comparable_begin(rbeg, rend)
+    if rend.nil? && rbeg.nil?
+      nil
+    elsif ! rbeg.nil?
+      rbeg
+    elsif rend.class.method_defined? :to_int
+      -Float::INFINITY
+    else
+      RangeExtd::Infinity::NEGATIVE
+    end
+  end
+  private :_comparable_begin
+
+
+  # Get the instance variable (Hash) @infinities
+  #
+  # @param arin [Array<Range, RangeExtd, Rangeary>]
+  # @param inherited_infs [Array<Hash<Infinity, nil>>] Inherited infinities from the input Rangeary-s
+  # @param guess_strict [Boolean] if true, make only strict guess for infinities, namely, unless the existing elements contain "infinity"-type objects, leave it nil; it is passed to {#_best_guessed_infinities}(strict: false)
+  # @option **opts [Object] :positive Object for positive infinity. In default {Float::INFINITY} for Numeric Comparable or else {RangeExtd::Infinity::POSITIVE}.
+  # @option **opts [Object] :negative Object for negative infinity. In default -{Float::INFINITY} for Numeric Comparable or else {RangeExtd::Infinity::NEGATIVE}.
+  # @return [Array] guessed @infinities
+  def _get_infinities(arin, inherited_infs: [], guess_strict: false, **opts)
+    # Explicitly specified?
+    reths = _get_infinities_from_opts(opts)
+    if reths
+      _validate_opts_infinities(arin, infs: reths)
+      # return reths if (reths.all?{ |i| i[1] })
+    end
+    leave_existing = !!reths
+
+    hs = {}.merge(@infinities)
+    hs.each_key {|k| hs[k] = nil }  # :positive, :negative => nil
+    reths ||= hs
+
+    # Read @infinities from Rangeary-s in arin, if exits
+    reths = self.class.send(:_validate_select_infinities, inherited_infs, reths)
+
+    return reths if (reths.all?{ |i| i[1] })
+    leave_existing ||= reths.any?{ |i| i[1] }
+
+    _best_guessed_infinities(reths, arin, strict: guess_strict, leave_existing: leave_existing)
+  end
+  private :_get_infinities
+
+  # Returns @infinities from the options.
+  #
+  # If not specified actually, returns nil.
+  #
+  # @param opts [Hash]
+  # @return [Hash, nil]
+  def _get_infinities_from_opts(opts)
+    hsret = {}
+    if opts.keys.include?(:positive) || opts.keys.include?(:negative)
+      if opts[:positive]
+        hsret[:positive] = opts[:positive]
+        opts[:negative] = -Float::INFINITY if is_num_type? opts[:positive]
+        hsret[:negative] ||= opts[:negative]
+        return hsret
+      elsif opts[:negative]
+        hsret[:negative] = opts[:negative]
+        opts[:positive] = Float::INFINITY if is_num_type? opts[:negative]
+        return hsret
+      end
+    end
+    return nil
+  end
+  private :_get_infinities_from_opts
+
+  # Returns the best guess Infinity from a given value (like 5.2 or "a")
+  #
+  # @param key [Symbol] either :positive or :negative
+  # @param val [Object] from which Infinity is guessed.
+  # @param strict [Boolean] if strict, unless the value is a kind of Infinite, return nil
+  # @return [Hash<Array>] keys (:positive and :negative) Array#size may not agree between them.
+  def _guessed_infinity(key, val, strict: false)
+    return nil if !val
+    return(RangeExtd::Infinity.infinite?(val) ? val : nil) if strict
+    return(((key == :positive) ? 1 : -1) * Float::INFINITY) if is_num_type? val
+    ((key == :positive) ? RangeExtd::Infinity::POSITIVE : RangeExtd::Infinity::NEGATIVE)
+  end
+  private :_guessed_infinity
+
+
+  # Instance method version
+  def is_num_type?(obj)
+    self.class.send(__method__, obj)
+  end
+  private :is_num_type?
+
+  # Normalize a Range, which is about to be used for new {Rangeary}
+  #
+  # @param rbeg [Object]
+  # @param rend [Object]
+  # @return [Range, RangeExtd::NONE]
+  def normalized_range_for_negation(rbeg, rend)
+    begin
+      ret = rbeg..rend  # Range
+    rescue RangeError
+      # the begin must be nil, after being converted from an Endless Range as in Ruby 2.6
+      ret = (_comparable_begin(rbeg, rend)..rend)  # Range
+    # rescue ArgumentError
+    ## NOTE: If this happens, something is gone wrong!!
+    end
+    return RangeExtd::NONE if same_infinities?(ret.begin, ret.end)
+    ret
+  end
+  private :normalized_range_for_negation
+
+  # True if both are infinities and in the same parity
+  #
+  # @param c1 [Object]
+  # @param c2 [Object]
+  def same_infinities?(c1, c2)
+    arin = [c1, c2]
+    arin.all?{ |ec| RangeExtd::Infinity.infinite?(ec) } &&
+      (arin.all?(&:positive?) || arin.all?(&:negative?))
+  end
+  private :same_infinities?
+
+  # Validate @infinities from the options.
+  #
+  # If fails, raise Exception.
+  #
+  # @param arin [Array<Range, RangeExtd, Rangeary>]
+  # @param infs [Hash]
+  # @return [void]
+  # @raise [ArgumentError]
+  def _validate_opts_infinities(arin, infs: @infinities)
+    infs.each_pair do |ek, my_inf|
+      next if !my_inf #|| RangeExtd::Infinity.infinite?(my_inf)
+      arin.flatten.each do |er|
+        [er.begin, er.end].each do |ev|
+          next if !ev
+          next if (is_num_type?(ev) && is_num_type?(my_inf))
+          begin
+            case my_inf <=> ev
+            when -1, 0, 1
+              next
+            else # nil
+            end
+          rescue # NoMethodError
+          end
+          msg = "invalid parameter for :#{ek} => (#{my_inf.inspect}), incompatible with the range with Range=(#{er.inspect})."
+          raise ArgumentError, msg
+        end
+      end
+    end
+  end
+  private :_validate_opts_infinities
+
+
+  # Legacy routine to set the instance variable (Hash) @infinities
+  #
+  # Maybe more complete?
+  #
+  # @param [Array]
+  # @param [Hash]
+  # @param [Hash]
+  # @param [Hash]
+  # @return [void]
+  def set_infinities_old(arRange, hsInheritedObj, hsInheritedAry, hsInheritedClass, **opts)
+
+    ### The following is required in the caller before calling this routine
+    ## inarall is the arguement received by initialize()
+    #
+    #
+    # hsInheritedObj   = {:negative =>nil, :positive =>nil}
+    # hsInheritedAry   = {:negative => [], :positive => []}
+    # hsInheritedClass = {:negative => [], :positive => []}
+    # inarall = inarall.map{|i|
+    #   if defined?(i.first_element) && defined?(i.infinities)
+    #     begin
+    #       [:negative, :positive].each do |nega_posi|
+    #         hsInheritedAry[nega_posi].push(  i.infinities[nega_posi])
+    #         hsInheritedClass[nega_posi].push(i.infinities[nega_posi].class)
+    #       end
+    #     rescue
+    #       warn "warning: Rangeary#infinities looks wrong in the input (#{i})."
+    #     end
+    #     i.to_a
+    #   else
+    #     i
+    #   end
+    # }.flatten.map{|j|
+    #   if (defined? j.exclude_begin?)
+    #     j
+    #   else
+    #     begin
+    #       RangeExtd.new(j)
+    #     rescue ArgumentError, RangeError  # Just to change the error message.
+    #       raise ArgumentError, "invalid parameter for RangeExtd, hence for Rangeary (#{j.inspect})."
+    #     end
+    #   end
+    # }
+
+    # Check inherited objects if there is any, namely if the argument includes any RangeAry object.
+    # Priority: Float > Others > RangeExtd::Infinity
+    if hsInheritedAry[:negative].size > 0
+      [:negative, :positive].each do |es| 
+        iFloat = hsInheritedClass[es].find_index(Float)
+        if iFloat.nil?
+          iElse = hsInheritedClass[es].find_index{|i| (i != RangeExtd::Infinity) && (i != Float)}
+          if iElse.nil?
+            iRangeInf = hsInheritedClass[es].find_index(RangeExtd::Infinity)
+            if iRangeInf.nil?
+              raise "Rangeary#infinities is not set in the input."	# Should not happen, as Rangeary#infinities must be set always.
+            else
+              hsInheritedObj[es] = hsInheritedAry[es][iRangeInf]
+            end
+          else
+            hsInheritedObj[es] = hsInheritedAry[es][iElse]
+          end
+        else
+          hsInheritedObj[es] = hsInheritedAry[es][iFloat]
+        end	# if iFloat.nil?
+      end	# [:negative, :positive].each do |es| 
+    end		# if hsInheritedAry.size > 0
+
+    # Determines what the infinities are: either Float::INFINITY or RangeExtd::Infinity::(POSI|NEGA)TIVE
+    hsFlag = { :found => {:negative => false, :positive => false} }
+    hsCand = {
+      :negative => arRange[0].begin,
+      :positive => _comparable_end(arRange[-1]),
+      # :pos_orig => arRange[-1].end,  # may be nil in Ruby-2.6
+    }
+    infDef = { :negative => RangeExtd::Infinity::NEGATIVE, :positive => RangeExtd::Infinity::POSITIVE }
+    @infinities={ :negative => nil, :positive => nil }
+    [:negative, :positive].each do |es|
+      if (infDef[es] == hsCand[es])	# Can be Float or whatever.
+        @infinities[es] = hsCand[es]	# highest priority
+        hsFlag[:found][:negative] = true
+      else
+        strtmp = ""
+        [opts[es], hsInheritedObj[es]].each do |opts_or_inherited|
+          @infinities[es] ||= opts_or_inherited		# uses ots[:****tive] or hsInheritedObj[:****tive] if not set.
+          # Now, checking the compatibility of the infinity value specified (or inherited) with the given range.
+          if (! opts_or_inherited.nil?) && (opts_or_inherited == @infinities[es]) && (! arRange[0].is_none?)
+            begin
+              _ = 0 * (opts_or_inherited <=> hsCand[es])
+            rescue TypeError
+              raise ArgumentError, "invalid #{strtmp}parameter for :#{es} => (#{opts_or_inherited.inspect}), incompatible with the range with begin=(#{hsCand[es].inspect})."
+            end
+          end
+          strtmp = "inherited "
+        end	# [opts[es], hsInheritedObj[es]].each do |opts_or_inherited|
+      end	# if (infDef[es] == hsCand[es])	# else
+    end	# [:negative, :positive].each do |es| 
+
+    if ! (@infinities[:negative] && @infinities[:positive])
+      # Either or both @infinities[:negative, :positive] is not set, yet.
+      # Need to set it now.  The possibilities are,
+      #  (1) arRange[0].null? && no opts/inheritance given.
+      #  (2) one of them is given by either arRange or opts or inheritance, but not the other.
+      #  (3) neither of them is given by arRange nor opts nor inheritance.
+      if arRange[0].null?
+        [:negative, :positive].each do |es| 
+          @infinities[es] ||= infDef[es]
+        end
+      else
+        # There must be a non-infinity object - we will find it out.
+        if hsFlag[:found][:negative]
+          obj2refer = _comparable_end(arRange[0])  # For Ruby-2.6 Endless Range
+          # obj2refer = arRange[0].end
+        else
+          obj2refer = arRange[-1].begin
+        end
+
+        # Now, if Numeric === obj2refer, Float::INFINITY is the default.
+        begin
+          _dummy = (1.0 < obj2refer)
+        rescue ArgumentError
+          # Not Numeric, hence the current infDef is used as it is.
+        else
+          # Numeric
+          infDef = { :negative => -Float::INFINITY, :positive => Float::INFINITY }
+        end
+        [:negative, :positive].each do |es| 
+          @infinities[es] ||= infDef[es]	# uses default infinity if not set.
+        end
+      end	# if arRange[0].null?
+    end		# if ! (@infinities[:negative] && @infinities[:positive])
+  end
+  private :set_infinities_old
 
   # Called from {Rangeary#initialize}.
+  #
   # Process the array of RangeExtd and return the new one, in which
   # overlapped ranges are merged accordingly.
   #
@@ -751,6 +1177,9 @@ class Rangeary < Array
   # As a priority, an empty range with a definite class is left,
   # but if there is none, RangeExtd::NONE will be left.
   #
+  # Note that (Inf..Inf) or (-Inf..-Inf) is replaced with +RangeExtd::NONE+,
+  # which then will be truncated.
+  #
   # @param inAr [Array<RangeExtd,Range>]
   # @return [Array]
   def _merge_overlaps(inAr)
@@ -760,7 +1189,7 @@ class Rangeary < Array
     #[st means status.]
     #(0) (prev[0]) and (prev[0].status) unchanged.
     #(1) if (now[-1]<  prev[-1]), do nothing. [Totally inclusive]
-    #   I---* => I---* 
+    #   I---* => I---*
     #   *--*
     #(2) if (now[-1]== prev[-1])
     # (2-1) AND if (now[-1].st? || prev[-1].st?), prev[-1].st=T [Nearly inclusive]
@@ -787,8 +1216,8 @@ class Rangeary < Array
     #    *--*
     #
 
-    # inRanges = sort_arrange( inAr )
-    inRanges = self.class.sort_ranges( inAr ).map{|i| (RangeExtd === i) ? i : RangeExtd(i) }	# => Rangeary.sort_ranges(ar)
+    inRanges = _replace_inf_inf(inAr)  # Replace meaningless inf..inf etc.
+    inRanges = self.class.sort_ranges(inRanges).map{|i| (RangeExtd === i) ? i : RangeExtd(i) }	# => Rangeary.sort_ranges(ar)
 
     if inRanges.size < 1
       return inRanges
@@ -798,8 +1227,14 @@ class Rangeary < Array
 
     inRanges[1..-1].each do |eachr|
       prev = newRanges[-1]
-      case eachr.end <=> prev.end 
-      when -1	# aka, eachr.end < prev.end
+
+      # To deal with Ruby-2.6 Endless Range like (5..) (=(5..nil))
+      # *.end is guaranteed not to be false.
+      eachr_end = _comparable_end(eachr)
+      prev_end  = _comparable_end(prev)
+
+      case eachr_end <=> prev_end
+      when -1	# aka, eachr_end < prev_end
         # Do nothing [Totally inclusive]
       when 0
         if (!eachr.exclude_end?) && prev.exclude_end?
@@ -808,8 +1243,8 @@ class Rangeary < Array
         else
           # Do nothing [Totally inclusive]
         end
-      when 1	# aka, eachr.end > prev.end
-        case eachr.begin <=> prev.end
+      when 1	# aka, eachr_end > prev_end
+        case eachr.begin <=> prev_end
         when -1	# Connect by combining
           newRanges[-1] = RangeExtd.new(prev.begin, eachr.end, :exclude_begin => prev.exclude_begin?, :exclude_end => eachr.exclude_end?)
         when 0
@@ -824,12 +1259,12 @@ class Rangeary < Array
           newRanges.push(eachr)	# must be RangeExtd::NONE (or user-defined equivalent)
         else
           raise
-        end	# case eachr.begin <=> prev.end
-      when nil	# aka, eachr.end > prev.end
+        end	# case eachr.begin <=> prev_end
+      when nil	# aka, eachr_end > prev_end
         newRanges.push(eachr)	# must be RangeExtd::NONE (or user-defined equivalent)
       else
         raise
-      end	# case eachr.end <=> prev.end 
+      end	# case eachr_end <=> prev_end 
 
     end		# inRanges[1..-1].each do |eachr|
 
@@ -885,11 +1320,43 @@ class Rangeary < Array
 
   private :_merge_overlaps
 
+  # Replaces the invalid inf..inf Range with NONE
+  #
+  # @param arin [Array<Range, RangeExtd>]
+  # @return [Array]
+  def _replace_inf_inf(arin)
+    arin.map{ |er|
+      raise 'contact the code developer' if !defined? er.exclude_end?  # Sanity check.
+      arran = [er.begin, er.end] # to_a raises RangeError for Ruby 2.6 Endless Range
+      if (( arran.all?{ |ea| RangeExtd::Infinity.infinite?(ea) } &&
+           (arran.all?(&:positive?) || arran.all?(&:negative?)) ) ||
+          (arran.all?(&:nil?)))
+        RangeExtd::NONE
+      else
+        er
+      end
+    }
+  end
+  private :_replace_inf_inf
 
   ####################
   # private_class_method
   ####################
 
+  # Sort infinities obtained from inherited objects and returns the best one
+  #
+  # RangeExtd::Infinity is ignored.  Float::INFINITY has the lowest priority.
+  #
+  # @param *ar_infs [Array] of Infinities Hash (inherited)
+  # @return [Hash] each key (:(posi|nega)tive) contains a single value (potentially null) for infinity.
+  def self._best_inherited_infinities(*ar_infs)
+    hsar = _sort_inherited_infinities_all( _get_cand_infinities(ar_infs.flatten) )
+    hsar.map{ |k, ev|
+      [k, ev[0]]
+    }.to_h  # Ruby 2.1 or later
+  end
+  private_class_method :_best_inherited_infinities
+
   #== Logical conjunction of two RangeExtd
   #
   # To assure this logical conjunction meaningful,
@@ -948,7 +1415,6 @@ class Rangeary < Array
     end
 
     r = *( sort_ranges([RangeExtd(r1), RangeExtd(r2)]) )	# => Rangeary.sort_ranges
-    # r = *( sort_arrange([RangeExtd(r1), RangeExtd(r2)]) )
 
     ## Note: the end product will be (cBeg(:stBeg), cEnd(:stEnd))
     #    where :stBeg and :stEnd mean exclude_(begin|end)?
@@ -961,14 +1427,20 @@ class Rangeary < Array
       stBeg =  r[1].exclude_begin?
     end
 
-    # Set the candidate end value.
-    if r[0].end == r[1].end
-      cEnd = r[1].end
+    # Set the candidate end value.  (comparable_end() for Ruby-2.6 Endless Range)
+    # Note: this comparison ignores @infinities even if set,
+    #   because @infinities may not be defined in the arguments!
+    #   Anyway, nothing should be larger than the upper limit
+    #   and so this should be fine.
+    if comparable_end(r[0]) == comparable_end(r[1])
+      cEndOrig = r[1].end
+      cEnd     = comparable_end(r[1])
       stEnd = (r[0].exclude_end? || r[1].exclude_end?)
     else
-      a = [[r[0].end, 0], [r[1].end, 1]].min
+      a = [[comparable_end(r[0]), 0, r[0].end], [comparable_end(r[1]), 1, r[1].end]].min
       cEnd  = a[0]
       cEndIndex = a[1]	# r[cEndIndex] == RangeExtd obj that gives the end of the resultant range.
+      cEndOrig = a[2]
       stEnd = nil
     end
 
@@ -992,219 +1464,180 @@ class Rangeary < Array
       # # Already defined.
       end	# if stEnd.nil?
 
-      RangeExtd(cBeg, cEnd, :exclude_begin => stBeg, :exclude_end => stEnd)
+      RangeExtd(cBeg, cEndOrig, :exclude_begin => stBeg, :exclude_end => stEnd)
     else
       raise
     end		# case cBeg <=> cEnd
 
   end	# def self.conjunctionRangeExtd(r1, r2)
-
   private_class_method :conjunctionRangeExtd
 
-
-  # Logical conjunction of two Rangeary
-  #
-  #===Algorithm
-  #
-  #  r1 == [p1, p2, p3, ...]	# Array of RangeExtd
-  #  r2 == [q1, q2, q3, ...]
-  #  rc =  []	# Initial value of Conjunction r1*r2
-  # 1. q1 = r2.shift
-  # 2. r1.delete_if(pi.end<q1.begin) -> (r1==[P1,P2(>q1),P3,...])
-  # 3. make conjunction between RangeExtd P1*q1 => pq1
-  # 4. rc+=Rangeary.new(pq1)
-  # 5a. if q1.end<P1.end, will do P1<->q2 next, hence return to 1 (will do r2.shift).
-  #        *--* =>      *--*  + nil
-  #   *--* *--*    .... *--*
-  #      *---*  =>    .O--*   +    -*
-  #   *---* *--*   ..... *--*   ...-* ----
-  # 5b. if q1.end==P1.end, r1.shift, return to 1 (will do r2.shift).
-  #    *--* *-- =>  .... *--  +  ---* ---
-  #   *---* *--*   ..... *--*   .---* ----  
-  # 5c. if q1.end>P1.end, will do P2<->q1, hence r1.shift, return to 2.
-  #   *---* *-- => ..... *--
-  #      *----        .O---
+  # Returns the candidate @infinities from the input Rangeary
   #
-  # @return [Rangeary] 
-  def self.conjunction_orig(r1, r2)
-
-    r1 = Rangeary.new(r1) if ! defined? r1.first_element
-    r2 = Rangeary.new(r2) if ! defined? r2.first_element
-
-    # Getting inherited options (if Rangeary is given) for the later use.
-    hsInherited = {}
-    [:negative, :positive].each do |ei|
-      hsInherited[ei] = [r1.infinities[ei], r2.infinities[ei]].map{|j|
-        (RangeExtd::Infinity === j) ? nil : j
-      }.compact.sort{|a,b|
-        if a.class == Float
-          -1
-        elsif b.class == Float
-          1
-        else
-          0
-        end
-      }[0]
-    end
-
-    # Initialisation
-    a1 = r1.to_a
-    a2 = r2.to_a
-    rc = Rangeary.new( RangeExtd::NONE, hsInherited )
-
-    if a1.empty? || a2.empty?
-      return rc
+  # If there is any Rangeary in the input.
+  #
+  # Example return:
+  #   { :positive => [nil,  Float::INFINITY],
+  #     :negative => [nil, -Float::INFINITY] }
+  #
+  # Note the standard @infinities is a Hash, but NOT a Hash of Array.
+  # This method returns the candidates.
+  #
+  # @param arin [Array<Hash<Infinity, nil>>] Inherited infinities from the input Rangeary-s
+  # @return [Hash<Array>] keys (:positive and :negative) Array#size may not agree between them.
+  def self._get_cand_infinities(arin)
+    hsret = { positive: [], negative: [] }
+    arin.each do |ec|
+      hsret.each_key do |k|
+        hsret[k] << ec[k]
+      end
     end
+    hsret
+  end
+  private_class_method :_get_cand_infinities
 
-    # Main loop
-    hsFlag = {:a2shift => true}
-    while true
-      if hsFlag[:a2shift]
-        if a2.size > 0
-          q1 = a2.shift
-        else
-          break
-        end
-      end
-      index_valid = a1.find_index{|i| i.begin >= q1.begin }
-      if (! index_valid.nil?) && index_valid > 1
-        a1.shift(index_valid)
-      end
+  # True if object is a type of Rangeary
+  def self.is_rangeary_type?(obj)
+    obj.respond_to?(:infinities) && obj.class.method_defined?(:first_element)
+  end
+  private_class_method :is_rangeary_type?
 
-      if a1.size < 1
-        break
-      end
-      p1 = a1[0]
+  # True if object is a type of Numeric and comparable
+  def self.is_num_type?(obj)
+    Numeric === obj && obj.respond_to?(:between?) && obj.class.method_defined?(:<)
+  end
+  private_class_method :is_num_type?
 
-      # Core - Perform conjunction.
-      pq1 = Rangeary.conjunctionRangeExtd(p1, q1)
-      rc += Rangeary.new(pq1)
+  # Sort infinities obtained from inherited objects
+  #
+  # RangeExtd::Infinity is ignored.  Float::INFINITY has the lowest priority.
+  #
+  # @param hs_inherit [Hash<Array>] :positive => Array, etc (From Rangeary-s in the main Array given)
+  # @return [Hash<Array>] each key (:(posi|nega)tive) contains the sorted candidate Array.
+  def self._sort_inherited_infinities_all(hs_inherit)
+    hs_inherit.map do |ek, ev|
+      [ek, _sort_inherited_infinities_each(ev, key=ek)]
+    end.to_h  # Ruby 2.1 or later
+  end
+  private_class_method :_sort_inherited_infinities_all
 
-      case q1.end <=> p1.end
-      when -1	# q1.end < p1.end
-        hsFlag[:a2shift] = true
-      when 0
-        if a1.size > 0
-          a1.shift
-        else
-          break
-        end
-        hsFlag[:a2shift] = true
-      when 1	# q1.end > p1.end
-        if a1.size > 0
-          a1.shift
-        else
-          break
-        end
-        hsFlag[:a2shift] = false
+  # Sort infinities obtained from inherited objects
+  #
+  # RangeExtd::Infinity is ignored.  Float::INFINITY has the lowest priority.
+  #
+  # @param ar_infs [Array] of Infinities (inherited)
+  # @param key [Symbol] :positive or :negative
+  # @return [Array]
+  def self._sort_inherited_infinities_each(ar_infs, key=:positive)
+    ar_infs.map {|j|
+      (RangeExtd::Infinity === j) ? nil : j
+    }.compact.sort{|a,b|
+      if is_num_type?(a) && RangeExtd::Infinity.infinite?(a)
+        -1
+      elsif is_num_type?(b) && RangeExtd::Infinity.infinite?(b)
+        1
       else
-        raise
-      end	# case q1.end <=> p1.end
-    end		# while (a1.size > 0) || (a2.size > 0)
-
-    rc
+        begin
+          (key == :positive) ? (a<=>b) : (b<=>a)
+        rescue
+          0
+        end
+      end
+    }
   end
-  private_class_method :conjunction_orig
-
+  private_class_method :_sort_inherited_infinities_each
 
-  # Subtract a Range from an Array of Range objects.
-  def self.subtractRange(arRng, r2sub)
+  # Validate the infinities by Options and inherited and select the best
+  #
+  # If Option is specified, that has the priority.
+  # Among the inherited, the youngest non-nil one has the highest priority.
+  #
+  # If there are any inconsistencies, issue a warning message, if $VERBOSE==true.
+  #
+  # Note this method does not look at the contents of the Range Array given.
+  #
+  # @param ar_inherit [Array<Hash<Infinity, nil>>] Inherited infinities from the input Rangeary-s
+  # @param hs_opts [Hash, nil] :positive, :negative, specified by the option to {Rangeary.initialize}
+  # @return [Hash] keys (:positive and :negative) with a single value for each
+  def self._validate_select_infinities(ar_inherit, hs_opts=nil)
+    hs_inherit = _get_cand_infinities(ar_inherit)
+    if !hs_opts
+      hs_opts = hs_inherit.map{ |ek, ev|
+        [hs_inherit[ek], nil]
+      }.to_h  # Ruby 2.1 or later
+    end
+    # e.g., hs_inherit[:positive] == [ "z"(From-Option), nil(Inherited), "y"(Inherited), INFINITY(inherited) ]
+
+    # Selection
+    hsret = _sort_inherited_infinities_all( hs_inherit ).map{ |ek, ev|
+      [ek, ([hs_opts[ek]]+ev).compact[0]]
+    }.to_h  # Ruby 2.1 or later
+
+    # Validation (for warning, issued when $VERBOSE==true)
+    hs_inherit.each_pair do |ek, ev|
+      ev_uniq = ([hs_opts[ek]]+ev).compact.uniq
+      msg = "Inconsistent %s infinities are found: %s (=> %s is used)"%[ek, ev_uniq.inspect, hsret[ek]]
+      #warn msg if $VERBOSE && (ev_uniq.size > 2) && (!ev_uniq.all?{ |c| RangeExtd::Infinity.infinite?(c) })
+      warn msg if (ev_uniq.size > 1) && (!ev_uniq.all?{ |c| RangeExtd::Infinity.infinite?(c) })
+    end
 
-    ### Cases
-    #[st means status.]
-    #(1) if (now[0] < prev[0])
-    # (1-1) if (now[-1] < prev[0]), do nothing. [Totally exclusive]
-    #        *--* => *--* 
-    #   *--*
-    # (1-2) if (now[-1] == prev[0])
-    #  (1-2-1) AND if (now[-1].in?)&&(prev[-1].in?), Change prev[0].ex?=T [Nearly exclusive]
-    #      I--* => O--* 
-    #   *--I
-    #  (1-2-1) ELSE, do nothing. [Totally inclusive]
-    #      O--* => *--* 
-    #   *--I
-    #      *--* => *--* 
-    #   *--o
-    # (1-3) if (now[-1] > prev[0])
-    #  (1-3-1) if (now[-1] < prev[-1]), => (now[-1],Prev[-1]).
-    #    *---* => ..*-* 
-    #   *--*
-    #  (1-3-2) if (now[-1] == prev[-1]), => (now[-1],Prev[-1]).
-    #   (1-3-2-1) if (now[-1].ex?)&&(prev[-1].in?), (Prev[-1],Prev[-1])(Single_number)
-    #    *---I => ....I 
-    #   *----O
-    #   (1-3-2-2) ELSE, none.
-    #    *---O => ..... 
-    #   *----*
-    #    *---* => ..... 
-    #   *----I
-    #  (1-3-3) if (now[-1] > prev[-1]), none
-    #    *---* => ..... 
-    #   *-----*
-    #(2) if (now[0] == prev[0])
-    # (2A-1) if (now[0].ex?)&&(prev[0].in?), => (Prev[0],Prev[0])(Single_number) + Any?
-    #   I--- => I???
-    #   O---
-    # (2A-2) ELSE, none for the first part.
-    #   O--- => .???
-    #   *---
-    #   *--- => .???
-    #   I---
-    # (2B) Follow (1) to get the New Array.
-    #(3) if (now[0] > prev[0])
-    # (3-1) if (now[-1] < prev[-1]), 2 Rangeary (Prev[0],now[0]),(now[-1],prev[-1])
-    #  *-----* => *-*.*-*
-    #    *-*
-    # (3-2) if (now[-1] == prev[-1])
-    #  (3-2-1) if (now[-1].ex?)&&(prev[-1].in?), => (Prev[0],now[0]),(prev[-1],prev[-1])
-    #  *----I => *-*...I
-    #    *--O
-    #  (3-2-2) ELSE, => (Prev[0],now[0])
-    #  *----I => *-*....
-    #    *--I
-    #  *----O => *-*....
-    #    *--*
-    # (3-3) if (now[-1] > prev[-1])
-    #  (3-3-1) if (now[0] < prev[-1]), => (Prev[0],now[0]),(prev[-1],prev[-1])
-    #  *---*  => *-*....
-    #    *---*
-    #  (3-3-2) if (now[0] == prev[-1])
-    #   (3-3-2-1) if (now[0].in?)&&(prev[0].in?), => (Prev[0],prev[-1].ex)
-    #  *--I  => *--O
-    #     I--*
-    #   (3-3-2-2) ELSE, unchanged.
-    #  *--*  => *--*
-    #     O--*
-    #  *--O  => *--O
-    #     *--*
-    #  (3-3-3) if (now[0] > prev[-1]), unchanged.
-    #  *--*  => *--*
-    #      *--*
-    #
+    hsret
+  end
+  private_class_method :_validate_select_infinities
 
-    sort_ranges(arRng).map{ |er|	# => Rangeary.sort_ranges
-    # sort_arrange(arRng).map{ |er|
-      if    er.end < r2sub.begin
-        er
-      elsif er.begin < r2sub.begin && er.end < r2sub.end
-        (er.begin .. (r2sub.begin-1))
-      elsif er.begin < r2sub.begin && r2sub.end < er.end
-        [er.begin .. (r2sub.begin-1), 
-         (r2sub.end+1) .. er.end ]
-      elsif r2sub.begin <= er.begin && er.end <= r2sub.end
-        nil
-      elsif r2sub.begin <= er.begin && er.begin <= r2sub.end && r2sub.end < er.end
-        (r2sub.end+1) .. er.end
-      elsif r2sub.end < er.begin
-        er
-      else
-        raise "This should not happen."
-      end
-    }.flatten.compact 
-  end	# def self.subtractRange(arRng, r2sub)
-  private_class_method :subtractRange
+end # class Rangeary < Array
 
+# Overwrites its equal operator
+class Array
+  alias_method :equals_before_rangeary, :== if ! self.method_defined?(:equals_before_rangeary)
 
-end
+  # Updated Array#==
+  #
+  # This returns true even if the standard #{==} is false, if both are *practically* empty,
+  # that is, if +#empty_element?+ and/or +empty?+ are true for both, they are equal.
+  # Also, this equates the "end" of Endless Range (Ruby 2.6) with Float::INFINITY or
+  # RangeExtd::Infinity::POSITIVE.
+  # Note by definition, it would appear at the last element in Rangeary only,
+  # if it does.
+  #
+  # @param other [Object]
+  def ==(other)
+    return true  if equals_before_rangeary other
+    return false if !other.class.method_defined?(:to_ary)
+    return false if !self.class.method_defined?(:empty_element?) && !other.class.method_defined?(:empty_element?)
+
+    # It was false.  Is it?
+    # eg., (Rangeary[RangeExtd::NONE] == []) is true,
+    # because Rangeary[] with zero components does not exist!
+    # Now either other or self is guranteed to be Rangeary.
+    self_empt  = (respond_to?(:empty_element?) ? empty_element? : empty?)
+    other_empt = (other.respond_to?(:empty_element?) ? other.empty_element? : other.empty?)
+    return true  if self_empt && other_empt
+    return false if self_empt ^  other_empt
+    # return false if size != other.size  # evaluated at the beginning.
+    return false if size >= 2 && self[0..-2] != other[0..-2]
+    return false if !self[-1].respond_to?(:exclude_end?) || !other[-1].respond_to?(:exclude_end?)
+
+    # Now, both are guaranteed to have the same number of non-zero elements,
+    # all their elements except for the last one are equal,
+    # and their last elements are Range-type instances.
+    # Yet, the standard "equal" operator has failed.
+    # Only the potential they may be equal is their last elements differ
+    # between Endless Range (Ruby 2.6) and Infinity.
+    c_self  = Rangeary.comparable_end self[-1]
+    c_other = Rangeary.comparable_end other[-1]
+    return false if c_self != c_other
+
+    if !c_self.class.method_defined?(:infinite?) && !c_self.class.method_defined?(:infinity?)
+      # :infinite? for Float::INFINITY, :infinity? is defined in RangeExtd::Infinity
+      warn "sanity check failed. c_self should be infinite (#{c_self.inspect}). The result is not guranteed. Contact the code developer."
+    end
 
+    # The end of their last elements are both positive Infinity.
+    # How about "begin"?
+    self_flag  = (self[-1].class.method_defined?(:exclude_begin?)  ? self[-1].exclude_begin?  : false)
+    other_flag = (other[-1].class.method_defined?(:exclude_begin?) ? other[-1].exclude_begin? : false)
+    (self[-1].begin == other[-1].begin) && (self_flag == other_flag)
+  end
+end  # class Array