rangeary 1.0.1 → 2.0

data/README.ja.rdoc

@@ -1,7 +1,7 @@
 
 = Rangeary - Multiple Range(Extd) class
 
-This package defines Rangeary class, which contains any multiple
+This package defines Rangeary class, which contains multiple
 1-dimensional ranges ({RangeExtd}[http://rubygems.org/gems/range_extd] objects).  For example, a multiple
 range of
 
@@ -9,25 +9,30 @@ range of
 
 for <tt>x</tt> can be defined in this class.
 
-The element objects for {Rangeary} can be anthing that can form
-RangeExtd objects; not only Numeric (or Real) but anything
-Comparable.  {Rangeary} accepts the built-in Range-class objects for
-the elements in initialisation, too.
+The element objects for +Rangeary+ can be anything that can form
+RangeExtd objects, not only Numeric (or Real) but anything
+Comparable.  +Rangeary+ accepts the built-in Range-class objects for
+the elements in initialization, too, providing it is a valid
+(<tt>Range#valid? == true</tt>) ones for the
+{RangeExtd}[https://rubygems.org/gems/range_extd] class (n.b., most Range
+objects are valid, but +(true..true)+ is not, for example, which would
+not make sense to constitute multiple ranges).
 
 All the four standard logical operations, that is, negation
 (<tt>~</tt>), conjunction (<tt>&</tt> or <tt>*</tt>), disjunction
 (<tt>|</tt> or <tt>+</tt>) and exclusive disjunction (<tt>^</tt> or
 <tt>xor</tt>) are defined, as well as subtraction (<tt>-</tt>).
 
-{Rangeary} objects are immutable - once it is created, you can not
+{Rangeary} objects are immutable - once it is created, you cannot
 alter the contents.
 
-Practically, {Rangeary} is a sub-class of Array, works as an array of
-RangeExtd, and inherits most of the methods, hence you can apply most
-operations to {Rangeary} that Array accpets, within the restriction of
-immutability of {Rangeary}. In addition, {Rangeary} offers several
-methods that directly work on its element as a range.  In the above
-example, <tt>#cover?(1.0)</tt> would return true, whereas
+{Rangeary} is implemented as a sub-class of Array, works as an array of
+RangeExtd, and inherits most of the methods. Thus, you can apply most
+operations to {Rangeary} that Array accepts, within the restriction of
+immutability of {Rangeary}; for example, +Array#push+ is disabled for
+{Rangeary}. In addition, {Rangeary} offers several
+methods that directly work on its element as a range.  In the
+example above, <tt>#cover?(1.0)</tt> (like +Range#cover?+) returns true, whereas
 <tt>#cover?(9.0)</tt>, false.
 
 
@@ -35,7 +40,21 @@ With this class, logical operations of 1-dimensional range objects are
 now possible and easy.
 I hope you find it to be useful.
 
-=== News: Endless Range supported
+=== News: Library locations and support for Beginless Range
+
+**IMPORTANT**: The path for the library is moved up by one
+directory in {Rangeary} Ver.2 from Ver.1 (same as the change in +RangeExtd+) in order that the
+location follows the Ruby Gems convention.  In short, the standard way
+to require is +require "rangeary"+, the path of which used to be "rangeary/rangeary"
+
+Version of {Rangeary} is now 2.0.
+
+Ruby 2.7 and later supports {Beginless range}[https://rubyreferences.github.io/rubychanges/2.7.html#beginless-range].
+
++Rangeary+ (Ver.2) also supports it now, requiring
+{RangeExtd}[https://rubygems.org/gems/range_extd] Ver.2 (or later).
+
+==== News: Endless Range supported
 
 Now, as of 2019 October, this fully supports {Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
 introduced in Ruby 2.6.  It is released as Version 1.* finally!
@@ -43,39 +62,40 @@ introduced in Ruby 2.6.  It is released as Version 1.* finally!
 
 == Install
 
-First, you need {RangeExtd}[https://rubygems.org/gems/range_extd] class library (basically, two files of pure ruby code), which is in gem:
+First, you need {RangeExtd}[https://rubygems.org/gems/range_extd] class library Ver.2 or later, which is in gem:
 
   gem install range_extd
 
 Or, get it from
-https://rubygems.org/gems/range_extd
-if you have not yet installed it.
+{https://rubygems.org/gems/range_extd}
+
+If you choose manual installation for some reason,
+follow the INSTALL section in the manual of
+{RangeExtd}[https://rubygems.org/gems/range_extd]
 
-Then, install this library.
+Then, install this library with
 
   gem install rangeary
 
-A file
+Files of
 
-  rangeary/rangeary.rb
+  rangeary.rb
+  rangeary/util.rb
+  rangeary/util/hash_inf.rb
 
 should be installed in one of your <tt>$LOAD_PATH</tt>.
 Alternatively, get it from
-http://rubygems.org/gems/rangeary
+{http://rubygems.org/gems/rangeary}
 
 Then all you need to do is
 
-  require 'rangeary/rangeary'
-
-or, possibly as follows, if you manually install it
-
   require 'rangeary'
 
-in your Ruby script (or irb).  The library files like
-<tt>range_extd/range_extd.rb</tt> for RangeExtd are automatically
-loaded.
+in your Ruby script (or irb)
+(Note the path used to be, in Rangeary Ver.1 or earlier), "rangeary/rangeary"),
+in which all the files are automatically loaded.
 
-{Rangeary} itself may work in Ruby 1.8, but RangeExtd works in only Ruby 2.1 or later.
+{Rangeary} Ver.2, along with RangeExtd, works in only Ruby 2.7 or later.
 
 Have fun!
 
@@ -95,9 +115,9 @@ Here are some simple examples.
 Basically, <tt>Rangeary()</tt> or <tt>Rangeary.new()</tt> accepts
 an arbitrary number of either Range, RangeExtd, {Rangeary}, or a
 combination of them.  Note Range objects that return false in
-+Range#valid?+ will raise an exception.
++Range#valid?+ raise an exception.
 
-For more detail and examples, see {Rangeary.new}.
+For more detail and examples, see {Rangeary.initialize}.
 
 
 === Practical application examples
@@ -133,39 +153,54 @@ it does not violate the immutability of {Rangeary} objects, such as
 == Description
 
 Once the file <tt>rangeary.rb</tt> is required, the class +Rangeary+ is defined, in
-addtion to the two defined in the RangeExtd library
-(<tt>RangeExtd</tt> and <tt>RangeExtd::Infinity</tt>).
+addition to those defined in the {RangeExtd}[https://rubygems.org/gems/range_extd] library
+(<tt>RangeExtd</tt>, <tt>RangeExtd::Infinity</tt>, and <tt>RangeExtd::Nowhere</tt>).
+<tt>RangeExtd</tt> adds some methods to the built-in <tt>Range</tt> class.
 
 === Rangeary Class
 
 {Rangeary} objects are immutable, the same as Range and RangeExtd.
 Hence once an instance is created, it would not change.
 
-How to create an instance is explained above (in the Examples
+The ways to create an instance are explained above (in the Example
 sections).  Any attempt to try to create an instance with one of
-elements being not "valid" as a range, that is, +Range#valid?+ returns
+elements being not "valid" as a range, that is, of which +Range#valid?+ returns
 false, raises an exception (<tt>ArgumentError</tt>), and fails.
 
-Note +RangeExtd+ (or +Range+) objects used to initialise {Rangeary}
-instances can contain negative and/or positive infinity objects.
-Since Ruby 2.6 the latter is called {Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
-and is supported as built-in Range.  The former is defined only in
-{RangeExtd}[https://rubygems.org/gems/range_extd] class.
-In default they are of the type of either +Float::INFINITY+ or
-either of the two instances of
++RangeExtd+ (or +Range+) objects given as arguments to initialize +Rangeary+
+instances may contain negative and/or positive infinity objects.
+Since Ruby 2.7 and 2.6,
+{Beginless range}[https://rubyreferences.github.io/rubychanges/2.7.html#beginless-range]
+and {Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
+are respectively introduced. They correspond to more conventional
 {RangeExtd::Infinity}[https://www.rubydoc.info/gems/range_extd/RangeExtd/Infinity]
-class, +POSITIVE+ or +NEGATIVE+.  See {Rangeary.new} for detail about
-how to initialise.
-
-When multiple ranges are given in initialising, they are sorted in
+objects, which Rangeary has supported since its first release.
+
+The built-in borderless Ranges and +RangeExtd::Infinity+ objects are
+similar but are conceptually slightly different; the difference is
+similar to that between borderless Ranges and +Float::INFINITY+.
+See the reference document of {RangeExtd}[http://rubygems.org/gems/range_extd]
+for detail.
+
+In default, when Ranges that contain infinities, be it built-in borderless Ranges
+or +Float::INFINITY+ or +RangeExtd::Infinity+ are given to {Rangeary},
++Rangeary+ use them.  Alternatively, a user can specify their own
+infinity objects; for example, you may provide +"a"+ as the negative
+infinity for +Rangeary+ with String Ranges.  If nothing is provided
+and yet if +Rangeary+ requires one(s), which may happen, for example,
+in an operation of negation, +Rangeary+ uses +Float::INFINITY+ for
+Numeric (Real numbers) and +nil+ for anything else in default. 
+See {Rangeary} and {Rangeary.initialize} for detail.
+
+When multiple ranges are given in initializing, they are internally sorted in
 storing, and if there are any overlaps among any of the elements, they
-are treated as disjunction (that is, simple summation).  That means
+are treated as disjunction (that is, simple summation).  This means that
 the objects a {Rangeary} instance holds internally can be different from 
-the objects given in initialisation, namely, their {#object_id} may be
+the objects given in initialization, namely, their <tt>#object_id</tt> may be
 different.  In particular, if built-in Range objects are given,
 they are always converted into RangeExtd objects internally.
 
-If any of the given range in the intialisation is empty, that is,
+If any of the given range in initialization is "empty", that is,
 +Range#empty?+ returns true, they are ignored, unless all of the
 ranges given are empty ranges, in which case the "smallest" one will be
 preserved.
@@ -174,112 +209,289 @@ If the result of the operation is empty, only the element of the
 resultant {Rangeary} is +RangeExtd::NONE+, and hence
 {Rangeary#empty_element?} will return true.
 
-For any Rangeary objects, {Rangeary#to_a}.size is always
-positive and not zero for that reason, or {Rangeary#empty?} returns
-always false, as {Rangeary#empty?} is a method inherited from Array.
+For any Rangeary objects, <tt>(Rangeary#to_a).size</tt> returns always
+positive and not zero for this reason, or +Rangeary#empty?+ returns
+always false, as +Rangeary#empty?+ is a method inherited from Array.
 Use {Rangeary#empty_element?} instead to check whether the instance is
-*practically* empty or not as a range.
+*practically* empty, or in other words, an empty range.
 
    Rangeary(RangeExtd::NONE).empty?          # => false
    Rangeary(RangeExtd::NONE).empty_element?  # => true
 
 As mentioned, all the methods of Array but a few are inherited
-to this {Rangeary} class, and they work based on each element
-RangeExtd.  Four methods work differently: {Rangeary#+} and
+to this {Rangeary} class, and they in principle work as if +Rangeary+ is an Array of
++RangeExtd+ (which is indeed the case!).  Four methods work differently: {Rangeary#+} and
 {Rangeary#*} are the alias to {Rangeary#disjunction} and
-{Rangeary#conjunction}, repectively.  {Rangeary#===} performs
+{Rangeary#conjunction}, respectively.  {Rangeary#===} performs
 +Range#===+ for all the Rangeary element ranges and return true if any
 of them returns true.  Therefore, {Rangeary#===}(RangeExtd(**))
 returns always false.  Also, +#length+
 and +#reverse+ are undefined.  Finally, {Array#==} is modified (see below).
 
-All the other methods operating on the element of ranges, rather than
+{Rangeary#==} and +Rangeary#eql?+ work in the same way as of Array. Therefore,
+  [2..4, 6..8] == Rangeary(2..4, 6..8)  # => true
+
+However, you should note the following:
+
+  [2..4, 6..8] == Rangeary(6..8, 2..4)  # => true
+  [6..8, 2..4] == Rangeary(6..8, 2..4)  # => false
+
+because Rangeary always sort its contents at the initialization.
+In short, it is really not recommended to compare Array and Rangeary
+directly. Instead, you should compare two {Rangeary} objects.
+
+All the other methods operating on the element ranges, rather than
 on the ranges themselves, have a suffix of <tt>_element</tt>, if there
 is the same method name in the built-in Array.  For example,
-{Rangeary#size} returns the number of RangeExtd objects it holds,
++Rangeary#size+ returns the number of +RangeExtd+ objects it holds as an Array,
 and {Rangeary#size_element} returns the total +Range#size+ of all
 the RangeExtd objects it holds.
 
    Rangeary(1..3, 5..8).size          # => 2
    Rangeary(1..3, 5..8).size_element  # => 7
 
-Or, {Rangeary#flatten_element} returns the concatnated
-single array of {Rangeary#to_a} for all the discrete range elements
+Or, {Rangeary#flatten_element} returns the concatenated
+single array of +Rangeary#to_a+ for all the discrete range elements
 (the element ranges have to be discrete like Integer).
 
+To flatten an Array containing both Arrays and Rangeary while you do
+not want to flatten each Rangeary, use {Rangeary.flatten_no_rangeary}.
+
 The complete reference of the class and methods is available at
 {Rubygems website}[http://rubygems.org/gems/rangeary], or you can compile the
 reference with +yard+ from the source package (+make doc+ at the
 package root directory would do).
 
-===  Array#==
+===  Infinities
 
-Equal method of +Rangeary#==+ should work differently from Array.
-First, it behaves differently for *empty* objects, as Rangeary objects are
-never empty in the sense of Array.  Second, handling of 
-{Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
-introduced in Ruby 2.6 is conceptionally not straightforward.
-For example, in Ruby 2.6,
+The infinities are vital in the logical operation of Rangeary.
+Without it, negation could not be defined, and other logical
+operations are also closely related to it; for example, *subtraction*
+is basically a combination of *negation* and *conjunction*.
+
+To determine what the positive and negative infinities for the given
+elements is not a trivial task. In default, +nil+ is used except for
++Numerics+ (Integer, Rational, Float etc), for which +Float::INFINITY+
+is used. Note that the default used to be 
+<tt>RangeExtd::Infinity::POSITIVE</tt> and  <tt>RangeExtd::Infinity::NEGATIVE</tt>
+defined in {RangeExtd}[http://rubygems.org/gems/range_extd] 
+up to Rangeary Ver.1, where both beginless and endless Ranges were not
+been introduced or supported. Rangeary Ver.2 changes the specification
+to be in line with the latest Ruby Range.
+
+Alternatively, a user can specify their own infinities in
+initialization of {Rangeary} with options of +positive:+ and
++negative:+. The boundaries at the opposite polarities usually should
+match unless they are comparable or either of them is +nil+.
+
+Here are examples of how infinities work with {Rangeary}. In the first
+example, infinities are implicitly contained in the specified Range.
+Then, the infinities are internally preserved throughout operations.
+Note that the first set of 2 operations and the second set of a single operation
+means the same.
+
+  r1 = Rangeary(nil..Float::INFINITY).conjunction( RangeExtd::NONE )
+    # => Rangeary(RangeExtd::NONE)
+  r2 = r1.negation
+    # => Rangeary(nil..Float::INFINITY)
+
+  ~(Rangeary(nil..Float::INFINITY) * RangeExtd::NONE)
+    # => Rangeary(nil..Float::INFINITY)
+
+In the second example below, a negative infinity of "+d+" is explicitly specified
+for a Range of single alphabet String.
+
+  Rangeary("f".."k", negative: "d").negation
+    # => Rangeary("d"..."f", "k"<..nil)
+
+where +"k"<..nil+ means a begin-exclude Range or +RangeExtd("k"..nil, true)+.
+
+A note of caution is that once an infinity is defined for a Rangeary object, any other
+Rangeary objects with which operations are performed should be in line with the
+same infinities.  If you specify your own infinities, it is advised to
+do so at the beginning.  And once the infinities have been manually
+set, it is advised not to modify them (although this library should
+handle such changes appropriately -- see the method document for detail)
+because unexpected errors may occur. Here is a set of examples. 
+
+  r3 =  Rangeary("f".."k", negative: "d")
+  r4 = ~r3
+    # => Rangeary("d"..."f", "k"<..nil)
+   _ =   Rangeary(r4, positive: "t")  # raises ArgumentError(!):
+                                      # because "t" is smaller than end of Endless Range
+  r6 =   Rangeary(r3, positive: "t")  # OK: because end of r3 is only "k"
+  r7 =  ~r6
+    # => Rangeary("a"..."d", "f".."k") # differs from r4 in the second Range
+
+In the example above, +r4+, which is the negation of +r3+ is
+"Endless", i.e., the last Range in +r3+ is an endless Range.
+So, attempting to set a positive infinity of "+t+" raises an Exception (+ArgumentError+).
+
+If the new infinity(ies) does not contradict the current contents (like +r6+), it
+is set accordingly and the subsequent operations (e.g., +r7+) adopt the value
+(though you should make sure it is exactly what you want).
+
+
+==== Algorithm of determining default infinities
+
+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*
+the elements in the sense they are not comparable.
+
+Internally, the {Rangeary} instance has a Hash extended with {Rangeary::Util::HashInf},
+which can be obtained with {Rangeary#infinities}.
+It has only 2 keys of +:negative+ and +:positive+, the values of which
+are the current best-guessed or definite infinities.  The Hash also
+holds status information for each polarity with 3 levels of
+
+1. <tt>false</tt>
+2. <tt>:guessed</tt>
+3. <tt>:definite</tt>
+
+It is +false+ only when the Rangeary is absolutely void with no
+information about the contents: +Rangeary(RangeExtd::NONE)+.
+
+If the user explicitly specifies a boundary in the optional arguments in
+initialization of {Rangeary}, it is accepted in principle with an associated status of <tt>:definite</tt>.
+
+If the user-specified main arguments in initialization contain
+a (potentially multiple) {Rangeary}, their defined infinities are
+inherited with their associated statuses. 
+
+Also, user-supplied Range-s or RangeExtd-s to the arguments in
+initialization of {Rangeary} always have, except for
++RangeExtd::NONE+, concrete boundary values, which can be +nil+.
+
+If one of the boundaries of a Range (n.b., it is *not* Rangeary) contains either +nil+ or one of infinite values
+(which is checked with +RangeExtd::Infinity.infinite?+, where in practice
+a duck-typing check is performed, using the method +infinite?+), then
+it is accepted as an infinite value with an associated status of <tt>:definite</tt>.
+
+Otherwise,
+
+1. if a boundary value is a (real-type) Numeric, +Float::INFINITY+ (or
+   its negative,
+2. or otherwise, +nil+
+
+is set as an infinity of the boundary with an associated status of +:guessed+.
 
-  (?a..).size                  # => nil
-  (10..).size                  # => Infinity
-  (10..Float::INFINITY)).size  # => Infinity
-  (1.0..) != (1.0..Float::INFINITY)
+Note that the priority used to be different up to Rangeary Ver.1; +nil+ was not used and
+instead the +RangeExtd::Infinity+ objects were used. It was because
+the beginless Range (and endless Range before Ruby-2.6) has not been defined before
+Ruby 2.7.  Now they are defined, it is only natural to use +nil+ as the
+default infinities in both ends, hence the change in specification in
+{Rangeary} Ver.2.
+  
+Usually the arguments given in initialization of a {Rangeary} contain
+more than one set of infinities candidate, unless only a single
+argument of either Range (or its subclass instance) with no optional
+arguments is given.  The priority is judged in the following order:
 
-These are not trivial, or even a little inconsistent.  For Range#size method, if it is for
-Numeric (but Complex), Endless Range behaves like the number Infinity,
-yet they (the mathematical infinity and the end of Endless Range) do
-not compare, and are not equal.
+1. the optional arguments
+2. an associated status of <tt>:definite</tt>, <tt>:guessed</tt>, and
+   <tt>false</tt> in this order
 
-Rangeary offers functions of logical operations of arrays of Ranges.
-A consistent definitions of infinity is essential.  For example, the
-negation of +[5..Infinity]+ is
+If the associated statuses are equal for two or more inputs, the most
+extreme one among them for each polarity is chosen.  For example, suppose
+two instances of {Rangeary} are given in initialization of another
+{Rangeary} and their negative infinities are "+b+" and "+c+".  Then,
+because of
 
-  [-Infinity...5]
+  "b" < "c"
 
-that is, from the negative infinity to 5, excluding the end.  Then the
-negation of it must recover the original Rangeary +(5..Infinity)+.
+the former ("+b+") is adopted as the new negative infinity.  Note that
+the parameters given in the optional arguments have always higher
+priority regardless.
+
+
+The following examples demonstrate the specification.
 
-Obviously, it could not be done with +Endless Range+, as it defines only the positive infinity,
-or more accurately *positive endlessness*.  For that reason, the use of
-+RangeExtd+ is crucial for Rangeary.
+  Rangeary(7..).negation
+    # => Rangeary(-Float::INFINITY...7)
+  Rangeary(7..).negation.negation
+    # => Rangeary(7..)
 
-In the Rangeary operation (of negation in this case), the following can happen:
+Remember the default infinity for Float is +Float::INFINITY+. In this
+case, however, the positive infinity was in practice specified by the
+user to be +nil+ in the form of argument of +(7..)+ If you want to
+specify the negative infinity instead, you must do it explicitly: 
 
-  r1 =   Rangeary(5..)   # => [(5..)]  (equivalent to (5..nil))
-  r2 =  ~Rangeary(5..)   # => [(-Float::INFINITY...5)]
-  r3 = ~~Rangeary(5..)   # => [(5..Float::INFINITY)]
+  Rangeary(7.., negative: nil).negation
+    # => Rangeary(...7)
 
-  r4 =   Rangeary(?a..)  # => [(?a..)]  (equivalent to (?a..nil))
-  r5 =  ~Rangeary(?a..)  # => [(RangeExtd::Infinity::NEGATIVE...?a)]
-  r6 = ~~Rangeary(?a..)  # => [(?a..RangeExtd::Infinity::POSITIVE)]
+Alternatively, you can always use conjunction like (the following two mean the same):
 
-There is no reason for this operation to result in the (Ruby-2.6) Endless Range
-that began with, after the negation operation from the negative infinity.
-Nevertheless, +r1==r3+ and +r4==r6+ must hold.
+  Rangeary(..nil).conjunction(Rangeary(7..)).negation
+    # => Rangeary(...7)
+  ~(Rangeary(..nil) * Rangeary(7..))
+    # => Rangeary(...7)
 
-+RangeExtd#==+ behaves in an almost identical way to +Range#==+
-(except it has +exclude_begin+), such as,
+The registered infinities for each instance is obtained (Hash extended with
+HashInf), which has
+two keys of +:positive+ and +negative+, with the method {#infinities};
+for example,
 
-           (1.0..) !=          (1.0..Float::INFINITY)
-  RangeExtd(1.0..) != RangeExtd(1.0..Float::INFINITY)
+  ran.infinities
+    # => <Hash(Inf): {:negative=>"a", :positive=>nil},
+    #     status: {:negative=>:definite, :positive=>:guessed}>
 
-To maintain the mathematical consistency, Rangeary needs modify the
-equal operator so +r1==r3+ and +r4==r6+ hold, as the standard equal operator of Array would not do the job.
-Hence, Rangeary now regards an Endless Range and a Range that ends with another Infinity
-as equal, as long as all the other Range parameters like the "begin"
-and +exclude_end+ are equal.
+Note that the values of the returned Hash (+HashInf) may be +false+;
+if it is not convenient, call it as +#instances(convert: true)+
+with which +false+ in the returned value, if there is any, is converted
+to +nil+ and the standard Hash as opposed to
+Hash extended with {Rangeary::Util::HashInf} is returned:
 
-In practice, +Array#==+ is modified in
-this library (which is naturally inherited to Rangeary), and hence the
-commutativity of the equal operator is assured.
+  ran.infinities(convert: true)  # => { :negative => "a"
+                                 #      :positive => nil, }
 
-Note that +Rangeary#equiv+ method may behave differently from the equal operator.
+Consult the manuals of the methods for detail.
+
+
+===  Array#==
+
+Equal method of +Array#==+ (and thus its child-class +Rangeary#==+) is
+modified slightly so that the behaviour when both are *practically*
+empty.
+
+Rangeary objects are never empty in the sense of Array; it contains at
+least +RangeExtd::NONE+, which is *empty*.  Therefore, if either or
+both the Array/Rangeary return true with {Rangeary#empty_element?},
+then it is regarded as equivalent to +Array#empty?+.
+
+Up to Ver.1 (or more precisely, in Ver.1), the equality behaviour was
+far more complicated. The complexity originated in the incompleteness
+of the Ruby built-in borderless Range;
+while Ruby-2.6 introduced the endless Range, which Rangeary Ver.1 supported,
+it lacked the beginless Range till the release of Ruby-2.7.
+
+Since Rangeary Ver.1 implemented only the endless Range, logical
+operations, especially those that involve negation either explicitly
+or implicitly (like subtraction), were self-incomplete.  To mitigate
+the problem, the equality method was designed to handle the
+incompleteness instead in Rangeary Ver.1.0.
+
+Now that both beginless and endless Ranges are supported by Ruby and
+Rangeary Ver.2, such an ad hoc fix is no longer necessary or
+desirable. The difference from the Ruby default is now minimum.
+
+Note that this library loads the utility library associated with
++RangeExtd+, which modifies some behaviours of the equality method
+(operator) of all Object, if in a backward-compatible way, i.e., users
+do not have to worry about it for the use outside RangeExtd. For
+logical operations implemented in this library, commutative behaviours
+of the operators are essential and they would be only achieved by
+modifying +Object#==+.
+
+Also note that +Rangeary#equiv+ method may behave differently from the equal operator.
 For example, 
 
    Rangeary(RangeExtd(1,"<...",4), 5...8).equiv?(Rangeary(2..3, 5..7))
 
-returns true.  To describe this, this left and right Rangearies are arrays of
+returns true.  To describe this, the left and right Rangearies are arrays of
 ranges of Integers which consist of
 
 * (Left)
@@ -290,41 +502,23 @@ ranges of Integers which consist of
   2. Range that starts and ending at 5 and 7, respectively, both inclusive.
 
 According to +Integer#succ+ (+Range#each+) method, the left and right ones are equivalent.
-Therefore +Rangeary#equiv+ returns true, wheras the equal operator
+Therefore +Rangeary#equiv+ returns true, whereas the equal operator
 returns false for this.
 
-===  Infinities
-
-The infinities are vital in the logical operation of Rangeary.  In
-default, the general infinities of
-<tt>RangeExtd::Infinity::POSITIVE</tt> and  <tt>RangeExtd::Infinity::NEGATIVE</tt>
-are used (see ({RangeExtd}[http://rubygems.org/gems/range_extd] for
-detail), except for comparable Numerics (Integer, Rational, Float
-etc), for which +Float::INFINITY is used in default.  However, a user
-can specify their own infinities in initialisation with the options of
-+positive:+ and +negative:+.
-
-Note once an infinity is defined for a Rangeary object, any other
-Rangeary objects with which operations are performed should have the
-same infinities.  In default, if different infinities are specified
-(or if only one of them has a pair of specified infinities and the
-others have the default values), the values that is smallest for the
-Positive infinity and largest for the Negative are used, though a
-warning may be issued (only if the built-in global variable +$VERBOSE+
-is true).  An exception is when a user explicitly specifies the infinities in the
-option in creating a new Rangeary out of other Rangeary objects and else, in which case the infinities from the
-other "inherited" Rangeary included in the main parameter are ignored.
-
-The last example above shows how it works.
 
 == Known bugs
 
-* To suppress warnings in Ruby-2.7, {RangeExtd}[https://rubygems.org/gems/range_extd] must be Ver.1.1.1 or later.
-* <tt>Rangeary.new(-6..-5, 2..5, 8..8).last_element(3)</tt> returns
-      <tt>[3, 4, 5]</tt> wrongly in Ruby-2.7 but correctly in Ruby-2.6.x or earlier.
+* Rangeary Ver.2, which supports both beginless and endless Ranges (of Ruby 2.7 and later), requires {RangeExtd}[https://rubygems.org/gems/range_extd] Ver.2 or later.
+* To suppress warnings in Ruby-2.7 (in Rangeary Ver.1), {RangeExtd}[https://rubygems.org/gems/range_extd] must be Ver.1.1.1 or later.
+* +Rangeary#last_element+ includes a monkey patch (which used to raise
+  an error before Rangeary Ver.2) to handle a bug in +Range#last+ in Ruby-2.7
+  and above (at least up to 3.1.2).  See
+  {Bug #18994}[https://bugs.ruby-lang.org/issues/18994] for detail of the bug,
+  which was in no time resolved with ({patch #6324}[https://github.com/ruby/ruby/pull/6324],
+  applied at commit {bbe5ec7}[https://github.com/ruby/ruby/commit/bbe5ec78463f8d6ef2e1a3571f17357a3d9ec8e4]).
+  It happens only in very limited conditions.
 
-This library requires Ruby 2.1 or above (it may work all right with
-Ruby 1.9.3, however I have never tested it).
+This library (for Ver.2 and later) requires Ruby 2.7 or later.
 
 Extensive tests have been performed, as included in the package.
 
@@ -336,22 +530,23 @@ Nothing planned.
 
 == Final comment
 
-This work is inspired by Ian Stewart, who developped a (numeric)
-multiple-range library in Fortran90 for the SAS software package for
+This work is inspired by Ian Stewart, who developed a (numeric)
+multiple-range library in FORTRAN90 for the SAS software package for
 XMM-Newton telescope.  I appreciate his work.
 
 The implementation to Ruby was not straightforward, though, partly
 because the built-in Range does not allow to exclude the begin
 boundary, and partly because the infinity is not defined for general
 objects but Numeric (Real) in Ruby (which later changed partially with
-the introduction of Endless Range in Ruby 2.6 released in 2018 December).  RangeExtd class I have developed
+the introduction of Endless Range in Ruby 2.6 released in 2018
+December and further and completely with the introduction of Beginless Range in Ruby
+2.7 released in 2019 December).  +RangeExtd+ class I have developed
 makes this library possible.  I am glad the completeness of ranges in
 the 1-dimensional space for arbitrary Comparable object is achieved now.
 
 Enjoy.
 
 
-
 == Miscellaneous
 
 == Copyright etc
@@ -371,10 +566,14 @@ Versions:: The versions of this package follow Semantic Versioning (2.0.0) http:
    0.5 < x <= 2.5,  6.0 <= x < 8.0,  10.0 <= x (<= 無限大)
 がこのクラスで定義できます。
 
-RangeExtd の要素たり得るオブジェクトは全て {Rangeary} の要素となり
-得ます。Numeric(の実数)に限らず、Comparable であるオブジェクトは全て
-可能です。また、{Rangeary} は、組込Rangeクラスのオブジェクトも初期化に
-使えます。
+RangeExtd の要素たり得るオブジェクトは全て +Rangeary+ の要素となり得ます。
+Numeric(の実数)に限らず、Comparable であるオブジェクトは全て
+可能です。また、+Rangeary+ は、組込Rangeクラスのオブジェクトも、それが
+{RangeExtd}[https://rubygems.org/gems/range_extd] クラスの
+(<tt>Range#valid? == true</tt>) を満たす限り初期化に使えます
+(注: ほとんどの Rangeオブジェクトはこの条件を満たすものの、
++(true..true)+ のように満たさないものもあって、実際、それらは複数
+Rangeの構成要素としては意味をなさないものです)。
 
 四つの標準論理演算全て、すなわち否定(negation; <tt>~</tt>)、論理積
 (conjunction; <tt>&</tt> または <tt>*</tt>)、論理和(disjunction;
@@ -390,38 +589,65 @@ RangeExtd の要素たり得るオブジェクトは全て {Rangeary} の要素
 す。したがって、イミュータブルな{Rangeary}に許される限りにおいて、
 Arrayに使えるほとんどの操作を{Rangeary}に適用できます。加えて、
 {Rangeary}には、そのレンジの要素に直接働きかけるメソッドも幾つかあり
-ます。上に挙げた例ならば、<tt>#cover?(1.0)</tt> は真を返し、
-<tt>#cover?(9.0)</tt> は偽を返します。
+ます。上に挙げた例ならば、<tt>Range#cover?(1.0)</tt> は真を返し、
+<tt>Range#cover?(9.0)</tt> は偽を返します。
 
 このクラスにより、1次元レンジへの論理演算が可能かつ容易になりました。
 これが有用なものであることを願ってここにリリースします。
 
+=== News: Libraryの場所、Beginless Rangeのサポート他
+
+**重要**: ライブラリのパスが{Rangeary} Ver.1 から Ver.2 で、
+ディレクトリの階層一つ上がりました。これは、Ruby Gemの慣用にそうように
+するためです。端的には、標準的方法は、+require "rangeary"+ です。
+以前のパスは、"rangeary/rangeary" でした。
+
+それに伴い、{Rangeary} のバージョンを2.0にあげました。
+
+Ruby 2.7以上では、 {Beginless range}[https://rubyreferences.github.io/rubychanges/2.7.html#beginless-range]
+がサポートされます。
+
++Rangeary+ (Ver.2) もそれをサポートします。ただし、
+{RangeExtd}[https://rubygems.org/gems/range_extd] Ver.2 (以上)
+が必要です。
+
+==== News: Endless Range サポートしました
+
+2019年10月(Rangeary Ver.1)より、Ruby-2.6 で導入された
+{Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
+をついにサポートしました!
+
 
 == インストール
 
-まず、RangeExtd クラスのライブラリ(純粋に rubyで書かれたファイル 2個
-です)が必要です。gem を使ってインストールできます。
+まず、 {RangeExtd}[https://rubygems.org/gems/range_extd] クラス(Ver.2
+以上)のライブラリが必要です。gem を使ってインストールできます。
   gem install range_extd
 もしくは以下から入手して下さい。
-https://rubygems.org/gems/range_extd
+{https://rubygems.org/gems/range_extd}
+
+(同ライブラリを手動でインストールする場合は、同ライブラリのマニュアルを参照。)
 
 次いで、このライブラリをインストールします。
   gem install rangeary
 
-ファイルが一つ、
+ファイル
+  rangeary.rb
+  rangeary/util.rb
+  rangeary/util/hash_inf.rb
   rangeary/rangeary.rb
-<tt>$LOAD_PATH</tt>上のどこかにインストールされるはずです。 
+が<tt>$LOAD_PATH</tt>上のどこかにインストールされるはずです。 
 あるいは以下から入手可能です。
-http://rubygems.org/gems/rangeary
+{http://rubygems.org/gems/rangeary}
 
 後は、Ruby のコード(又は irb)から
-  require 'rangeary/rangeary'
-とするだけです。もしくは、特に手でインストールした場合は、
   require 'rangeary'
-とする必要があるかも知れません。他のファイル(RangeExtd 用の
-<tt>range_extd/range_extd.rb</tt>)は、自動的に読込まれます。
+とするだけです。
+(このパスは、Rangeary Ver.1 では "rangeary/rangeary" でした!)
 
-{Rangeary} は Ruby 2.1 以上で動きます。
+他のファイル(特に<tt>range_extd.rb</tt>)は、自動的に読込まれます。
+
+{Rangeary} Ver.2 は Ruby 2.7 以上で動きます。
 
 お楽しみあれ!
 
@@ -443,7 +669,7 @@ http://rubygems.org/gems/rangeary
 て取ります。ただし、Rangeクラスのオブジェクトで +Range#valid?+ が偽
 を返すものは、例外が発生します。
 
-さらなる解説及び例は、{Rangeary.new}を参照して下さい。
+さらなる解説及び例は、{Rangeary.initialize}を参照して下さい。
 
 
 === 実践例
@@ -478,33 +704,52 @@ http://rubygems.org/gems/rangeary
 
 == 詳説
 
-ファイル <tt>rangeary.rb</tt> が読まれた段階で、RangeExtd ライブラリで
-定義される二つのクラス(<tt>RangeExtd</tt> と
-<tt>RangeExtd::Infinity</tt>)に加えて、クラス一つが定義されます。
-
-* Rangeary
-
+ファイル <tt>rangeary.rb</tt> が読まれた段階で、
+{RangeExtd}[https://rubygems.org/gems/range_extd] ライブラリで定義されるクラス
+(<tt>RangeExtd</tt>, <tt>RangeExtd::Infinity</tt>, <tt>RangeExtd::Nowhere</tt>)
+が読み込まれます。
+<tt>RangeExtd</tt> は、組込み built-in <tt>Range</tt> クラスにいくつかのメソッドを追加します。
 
 === Rangeary クラス
 
 {Rangeary} オブジェクトは、Range や RangeExtd と同様、イミュータブルで
 す。だから、一度インスタンスが生成されると、変化しません。
 
-インスタンスの生成方法は上述の通りです(「使用例」の章)。レンジとして"valid"と見
-なされないインスタンスを生成しようとすると、すなわち +Range#valid?+ が
+インスタンスの生成方法は上述の通りです(「使用例」の章)。レンジとして"valid"
+と見なされないインスタンスを生成しようとすると、すなわち +Range#valid?+ が
 偽を返すレンジを使おうとすると、例外(<tt>ArgumentError</tt>)が発生し、
 失敗します。
 
-なお、ユーザーは、{Rangeary} インスタンス生成の時、レンジ要素に対応し
-た正負の無限大オブジェクトを付加することができます。デフォルトでは、
-+Float::INFINITY+ または +RangeExtd::Infinity::POSITIVE+ の類に
-なります。詳しくは {Rangeary.new} を参照下さい。
++Rangeary+初期化引数の +RangeExtd+ (または +Range+) オブジェクトは
+(どちらかあるいは両方の境界に)無限大オブジェクトを含むかも知れません。
+Ruby 2.7 と2.6にて、
+{Beginless range}[https://rubyreferences.github.io/rubychanges/2.7.html#beginless-range],
+{Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
+がそれぞれ導入されました。これらは、本ライブラリに当初から定義されていた
+{RangeExtd::Infinity}[https://www.rubydoc.info/gems/range_extd/RangeExtd/Infinity]
+に対応すると言えます。
+
+組込みのこれら境界のない Ranges と +RangeExtd::Infinity+ オブジェクトは
+類似しているものの概念としては少し異なります。この違いは、
+境界のない Ranges と+Float::INFINITY+ との違いに似ています。
+{RangeExtd}[http://rubygems.org/gems/range_extd]
+のマニュアルに詳細に解説されています。
+
+デフォルトでは、引数に与えられたRangeがこれら無限大オブジェクト
+(+nil+であれ+Float::INFINITY+であれ+RangeExtd::Infinity+であれ)
+を含む場合、+Rangeary+ はそれをそのまま使います。あるいは、
+ユーザーは、{Rangeary} インスタンス生成の時、
+レンジ要素に対応した正負の無限大オブジェクトを指定することもできます。
+たとえば、1文字のStringのRangeに対して、+"a"+ を負の無限大オブジェクト
+として指定することができます。もし何も指定がない場合は、Rangearyは、
+デフォルトで、 Numeric (実数) に対しては+Float::INFINITY+、
+それ以外には +nil+ を無限大とします。
 
 生成時に複数のレンジが引数として与えられた時、ソートされて保持されます。
 その時、要素のどこかに重複する部分があった時は、論理和として扱われます
 (つまり、単純に足し合わされます)。これはつまり、{Rangeary} が内部的に
 保持するオブジェクトは生成時に与えられたものとは異なる、すなわち
-{#object_id} が異なるかも知れないことを意味します。特に、組込Rangeが引
+<tt>#object_id</tt> が異なるかも知れないことを意味します。特に、組込Rangeが引
 数として与えられた時は、常に RangeExtd オブジェクトに内部で変換されます。
 
 もし生成時に与えられたレンジのどれかが空、すなわち +Range#empty?+ が真
@@ -515,9 +760,9 @@ http://rubygems.org/gems/rangeary
 +RangeExtd::NONE+となり、したがって
 {Rangeary#empty_element?} が真を返します。
 
-そのため、どの Rangeary オブジェクトも、{Rangeary#to_a}.size は常に正
+そのため、どの Rangeary オブジェクトも、+Rangeary#to_a.size+ は常に正
 の値を返し、零を返すことはありません。あるいは、Array から継承した
-{Rangeary#empty?} は常に偽を返します(オブジェクトがレンジとして空かど
++Rangeary#empty?+ は常に偽を返します(オブジェクトがレンジとして空かど
 うかをチェックするには、{Rangeary#empty_element?} を使って下さい)。
    Rangeary(RangeExtd::NONE).empty?          # => false
    Rangeary(RangeExtd::NONE).empty_element?  # => true
@@ -532,7 +777,7 @@ http://rubygems.org/gems/rangeary
 に偽を返します。
 また、[#length] と [#reverse] とは未定義化されています。
 
-{Rangeary#==} と {Rangeary#eql?} は、Arrayと同様に動作します。だから
+{Rangeary#==} と +Rangeary#eql?+ は、Arrayと同様に動作します。だから
   [2..4, 6..8] == Rangeary(2..4, 6..8)  # => true
 も成り立ちます。しかし注意すべきは以下です。
   [2..4, 6..8] == Rangeary(6..8, 2..4)  # => true
@@ -542,7 +787,7 @@ http://rubygems.org/gems/rangeary
 
 レンジ要素に対してではなく、レンジを構成する要素に対して動作する他の
 全てのメソッドは、組込Arrayクラスに同名のメソッドが存在する場合、接尾辞
-<tt>_element</tt> がつきます。たとえば、{Rangeary#size} は、保持する
+<tt>_element</tt> がつきます。たとえば、+Rangeary#size+ は、保持する
 RangeExtd オブジェクトの数を返し、一方、{Rangeary#size_element}は、
 保持するすべての RangeExtdオブジェクトに対して +Range#size+ を行った
 その総和を返します。
@@ -550,7 +795,10 @@ RangeExtd オブジェクトの数を返し、一方、{Rangeary#size_element}
    Rangeary(1..3, 5..8).size_element  # => 7
 
 {Rangeary#flatten_element} は、全てのRangeExtd要素に対して
-{Rangeary#to_a} を実行して、その結果を結合した配列を返します。
++Rangeary#to_a+ を実行して、その結果を結合した配列を返します。
+
+もしArrayをflattenしたいけれど各Rangeary は保持したい場合は、
+{Rangeary.flatten_no_rangeary} を使えます。
 
 クラスとメソッドの完全なマニュアルは、
 {Rubygems のウェブサイト}[http://rubygems.org/gems/rangeary]上にあります。
@@ -558,70 +806,33 @@ RangeExtd オブジェクトの数を返し、一方、{Rangeary#size_element}
 することで、手元でコンパイルすることもできます(RubyGems の +yard+
 がインストールされている必要があります)。
 
-===  Array#==
-
-等号メソッド +Rangeary#==+ は、Array とは異なった挙動をするべきであり、
-実際します。まず、*empty?* の際の意味が、異なります。なぜならば、
-Rangeary オブジェクトは、Array的な意味では、empty になることは決してな
-いからです。次に、Ruby 2.6で導入された
-{Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
-は、概念的にそう素直には組み込まれません。例えば、Ruby 2.6 では以下の
-ような挙動を示します。
-
-  (?a..).size                  # => nil
-  (10..).size                  # => Infinity
-  (10..Float::INFINITY)).size  # => Infinity
-  (1.0..) != (1.0..Float::INFINITY)
-
-これらは、当たり前の挙動ではありませんし、若干矛盾があるとさえ言えるかも
-知れません。Range#size メソッドに関しては、Numericクラス(Complexを除く)
-のオブジェクトに関しては、Endless Range は、数学的無限のように振舞いま
-す。しかし、両者を比較することはできず、等号比較すると、偽が返ります。
-
-Rangeary は、複数の Range からなる数列(array)に対して、論理演算する機
-能を提供します。そのためには、一貫した「無限」の定義が不可欠です。例え
-ば、 +[5..Infinity]+ の否定は、
-
-  [-Infinity...5]
-
-すなわち、無限小から始まり、5 で終わるが、終端は含まれない、ということ
-になります。これに対して再度否定演算を行うと、元の Rangeary +(5..Infinity)+
-が再度得られなければなりません。
-
-この演算は、当然、+Endless Range+ だけでは不可能です。+Endless Range+
-は正の無限大、あるいは正確には、正の方向に開いたもの、しか定義していないからです。
-このため、+RangeExtd+ を使用することは、Rangeary では決定的に重要なの
-です。
-
-Rangearyの演算(ここでは否定演算)においては、以下のようになります。
+===  無限大
 
-  r1 =   Rangeary(5..)   # => [(5..)]  (equivalent to (5..nil))
-  r2 =  ~Rangeary(5..)   # => [(-Float::INFINITY...5)]
-  r3 = ~~Rangeary(5..)   # => [(5..Float::INFINITY)]
+無限大の扱いは単純ではありません。
 
-  r4 =   Rangeary(?a..)  # => [(?a..)]  (equivalent to (?a..nil))
-  r5 =  ~Rangeary(?a..)  # => [(RangeExtd::Infinity::NEGATIVE...?a)]
-  r6 = ~~Rangeary(?a..)  # => [(?a..RangeExtd::Infinity::POSITIVE)]
+最大の注意点として、一旦、無限大が定義されると、そのオブジェクトと演算を行う全ての
+Rangearyオブジェクトも同じ無限大をもつべきです。
 
-この演算において、負の無限大も経過した最後の結果が、元々の出発点である(Ruby2.6で言う)
-Endless Rangeにならなければいけない理由はないことになります。しかしながら、
-+r1==r3+ および +r4==r6+ は成立すべきです。
+取扱いと挙動の詳細は英語版マニュアルの「Infinities」章を参照してください。
 
-+RangeExtd#==+ は、+Range#==+ とほぼ同一に振舞います(前者は
-+exclude_begin+ メソッドを持つことを除いて)。例えば、
+===  Array#==
 
-           (1.0..) !=          (1.0..Float::INFINITY)
-  RangeExtd(1.0..) != RangeExtd(1.0..Float::INFINITY)
+等号メソッド +#==+ は、Array とはほんの少し異なった挙動をします。
+というのも、*empty?* の意味が、異なるからです。なぜならば、
+Rangeary オブジェクトは、Array的な意味では、empty になることは決してありません。
+したがって、{Rangeary#empty_element?} または通常の *empty?* が双方真の時は+Rangeary#==+
+は真を返すように +Array#==+ (したがって +Rangeary#==+)が変更されています。
 
-+r1==r3+ や +r4==r6+ も成立するよう、数学的一貫性を保つために、Rangeary では、
-等号の定義を変更する必要がありました。Array クラスのデフォルトの標準等
-号ではダメだからです。
-そこで、Rangeary では、Endless Range と終端が何か別の無限大である
-Rangeとは、他のパラメーター(例えば始端や+exclude_end+)が等しい限り、等
-しいと見なします。
+Rangeary Ver.1.0 では、
+Ruby 2.6で導入された
+{Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
+を概念的に素直に組み込むのが困難であり、Rangeary 内部で矛盾ない扱いを保証するために、
++Range#==+ に複雑な変更を含みました。Ruby 2.7 で Beginless Range
+が導入されたことでその矛盾が自然に解消されたため、Rangeary Ver.2.0 では、その複雑な判断ルーチンは撤廃されました。
 
-実装としては、本ライブラリ内で +Array#==+ (Rangearyに自然に継承される)を変更しています。
-そのため、等号の可換性が保たれています。
+本ライブラリは +RangeExtd+ 付属ライブラリを読み込み、そこでは Object
+の等号が少し変更されています(Ruby標準と互換性はあるので心配無用)。
+これは、Rangeary内部で演算の双方向性を保証するために必要な措置です。
 
 なお、+Rangeary#equiv+ メソッドは、等号とは異なる挙動をすることがあり
 ます。例えば、
@@ -642,34 +853,23 @@ Rangeからなる配列で、
 +Rangeary#equiv+ でこの両者を比較すると真を返します。一方、等号は負を
 返します。
 
-===  無限大
-
-正負の無限大は、Rangearyの演算に不可欠です。デフォルトでは、正負の一般無限大は
-<tt>RangeExtd::Infinity::POSITIVE</tt> と <tt>RangeExtd::Infinity::NEGATIVE</tt>
-が使われます(詳細は {RangeExtd}[http://rubygems.org/gems/range_extd] 参照)。
-但し、例外が、比較可能な Numerics (Integer, Rational, Floatなど)で、
-+Float::INFINITY がデフォルトで使われます。しかし、ユーザーは、オブジェ
-クト作成の時、+positive:+ および +negative:+ で自分の無限大を定義することもできます。
-
-なお、一旦、無限大が定義されると、そのオブジェクトと演算を行う全ての
-Rangearyオブジェクトも同じ無限大をもつべきです。デフォルトでは、演算す
-るオブジェクト間でもし異なる無限大が使われている場合(端的には、一つの
-オブジェクトにだけ無限大を定義して他はデフォルトで済ませている場合)は、
-正の無限大には最小の値、負の無限大には最大の値が選ばれます。但し、警告
-メッセージが出るかもしれません(組込グローバル変数 +$VERBOSE+が真の時のみ)。
-例外は、複数のRangearyから新しいRangeryオブジェクトを作成の際に、オプ
-ションで陽に無限大を指定した時で、その時は、それらRangearyから継承した
-値は考慮されず、指定した値が使われます。
-
-上記の最後の例が、指定する例です。
 
 == 既知のバグ
 
+* Rangeary Ver.2 は Beginless/Endless Ranges (Ruby 2.7以降)をサポートしますが、そのために、
+  {RangeExtd}[https://rubygems.org/gems/range_extd] Ver.2 以降が必須。
 * Ruby-2.7 で警告を出さないためには、{RangeExtd}[https://rubygems.org/gems/range_extd] は、Ver.1.1.1 以上であること。
+* +Rangeary#last_element+ はちょっと汚いパッチが入っています(Rangeary
+  Ver.1 では例外が発生していた)が、これは、Ruby-2.7以降(3.1.2でもまだ未修正)
+  のバグに対処するためです。バグ詳細は、
+  {Bug #18994}[https://bugs.ruby-lang.org/issues/18994]。
+  すぐに対処されました({patch #6324}[https://github.com/ruby/ruby/pull/6324],
+  コミット {bbe5ec7}[https://github.com/ruby/ruby/commit/bbe5ec78463f8d6ef2e1a3571f17357a3d9ec8e4])。
+  そもそもごくごく限られたケースでしか問題になることはありませんが。
 * <tt>Rangeary.new(-6..-5, 2..5, 8..8).last_element(3)</tt> は、
       Ruby-2.6.x 以前は正しい値を返すが、Ruby-2.7 ではなぜか <tt>[3, 4, 5]</tt> と誤った値を返す。
 
-このライブラリは Ruby 2.1 以上を必要とします。
+このライブラリは Ruby 2.7 以上を必要とします。
 
 パッケージに含まれている通り、網羅的なテストが実行されています。
 
@@ -683,14 +883,15 @@ Rangearyオブジェクトも同じ無限大をもつべきです。デフォル
 
 このライブラリは、イアン・スチュワート氏が開発した、XMM-Newton望遠鏡用の
 SAS解析ソフトウェア・パッケージに含まれる(数値)複数レンジの
-Fortran90ライブラリにアイデアを得たものです。彼の仕事に感謝します。
+FORTRAN90ライブラリにアイデアを得たものです。彼の仕事に感謝します。
 
 しかし、Rubyへの実装は、一筋縄ではいきませんでした。一つには組込Range
-クラスでは始点を除外することができないこと、また一つには Rubyでは数値
-を除いて一般オブジェクトに対しての無限大が定義されていないからです。
-小生の開発した RangeExtd によって初めてこのライブラリが可能となりま
-した。これにより、今、比較可能な任意のオブジェクトについて、1次元上の
-レンジの完全性が実現できたことを嬉しく思います。
+クラスでは始点を除外することができないこと、また一つには Ruby
+では数値を除いて一般オブジェクトに対しての無限大が定義されていないからです
+(後者は、Ruby-2.6と2.7とで一定の解決を見たため、本ライブラリ(Ver.2)でも採り入れました!)。
+小生の開発した RangeExtd によって初めてこのライブラリが可能となりました。
+これにより、今、比較可能な任意のオブジェクトについて、
+1次元上のレンジの完全性が実現できたことを嬉しく思います。
 
 お楽しみ下さい。