range_extd 1.0 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32649fb2085566146ed0bd20a5f1198f4030f56477ea64cb4f7822ce6288ff24
-  data.tar.gz: 3fe7fb3ee23f9cd41550445e1482f86292b84dad8b13f0a3984b5e077a16a740
+  metadata.gz: 2ef735cf8d777f8f86ab2a5d3654577f06f0b41abf796c5c7147bc23482741dc
+  data.tar.gz: 33cf0bf6894c7de27b3c2714c03ba3042235751bd2bbeb506c0105c66badd110
 SHA512:
-  metadata.gz: bc7050082f5af7734ee5946c1f51d21ed633ed275ef93ed9adf9844c8a965f9acab24eef8658cdb06891b852b05ab27bd8a81d0904bce15fbb9a0b0dfb0ba7e1
-  data.tar.gz: 4bf22fb1d18614b5afed4bb8bed88bea3aeb0f90fa8da4c3345be3ee58561313b28453244910c7bac306592945768208dc03cb866c67201eea6c13bc4dbedc34
+  metadata.gz: 2240719d2e3f7f7933cea2e6b03268b87f0357526851b8a54b1645a320b35a44027808063df2176bbe4ac51ffacc91d517c5999c9c382244ab99a29219bbf795
+  data.tar.gz: 32f5f4b3cc81aee0bb099a33a6c905e713896eb875dc749cbb6365243f3f81eebfaf75604031a328faa31bbdcc8466956182cef03fe12d4b5d4d2f6fb59db810

data/ChangeLog

@@ -1,16 +1,16 @@
 -----
-(Version: 1.0)
-2019-10-30  Masa Sakano
-  * Release of Ver.1.0.
-  * Endless Range introduced in Ruby 2.6 is now fully supported.
-  * RangeError is raised now when it is appropriate in initialisation, where ArgumentError used to be raised.
-
------
-(Version: 1.0)
-2019-10-30  Masa Sakano
-  * Release of Ver.1.0.
-  * Endless Range introduced in Ruby 2.6 is now fully supported.
-  * RangeError is raised now when it is appropriate in initialisation, where ArgumentError used to be raised.
+(Version: 1.1)
+2019-11-01  Masa Sakano
+  * Significant upgrade: RangeExtd
+    * size of RangeExtd with an infinity now follows what Ruby Endless Range returns.
+      * Example: (?a..RangeExtd::Infinity::POSITIVE).size used to be Float::INFINITY, but now nil.
+    * RangeExtd::Infinity::POSITIVE etc now replaced with Float::INFINITY when it should be.
+  * RangeExtd::Infinity
+    * POSITIVE (or NEGATIVE) and Float::INFINITY are now NOT comparable. Description added to README.
+    * Newly redefined methods of ">" and "<" for RangeExtd::Infinity, as otherwise the comparison with Numeric fails as of Ruby 2.6 (I do not know whether it has been so or it has changed in recent versions of Ruby)
+    * New class methods of Infinity.infinity? and Infinity.infinite? in which the former excludes Float::INFINITY whereas the latter includes.
+    * Two unary operators (plus and minus) now supported.
+    * The methods "=", ">" and "<" redefined for Float and Integer (hence Rational) so they can be compared with this.
 
 -----
 (Version: 1.0)

data/News

@@ -1,3 +1,7 @@
+-----
+(Version: 1.1) 2019-11-01
+ * Release of Ver.1.1.  A significant upgrade with some change in the specification of how to deal with infinities.
+
 -----
 (Version: 1.0) 2019-10-30
  * Release of Ver.1.0.  Supports Endless Range in Ruby 2.6.

data/README.en.rdoc

@@ -68,14 +68,7 @@ I hope you find this package to be useful.
 === 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.0 finally!
-
-==== NOTE: Relationship with Rangesmaller
-
-This package supersedes the obsolete {Rangesmaller}[https://rubygems.org/gems/rangesmaller] package and class,
-with the added open-ended feature, and a different interface in
-creating a new instance.
-https://rubygems.org/gems/rangesmaller
+introduced in Ruby 2.6.  It is released as Version 1.* finally!
 
 ==== NOTE: Relationship with Rangeary
 
@@ -83,8 +76,20 @@ The class to handle multiple Ranges with objects of the same class
 (most typically Float),
 {Rangeary}[https://rubygems.org/gems/rangeary] uses this library to
 fullest, because the concept of potentially open-ended Range on both
-begin and end is essential to realise Rangeary.
-https://rubygems.org/gems/rangeary
+begin and end is essential to realise it.  For example, the negation
+of Range +(?a..?d)+ is Ranges +(-"Infinity-Character"...3)+ and
++(?d(exclusive).."Infinity-Character")+ and its negation is back to
+the original +(?a..?d)+.  Such operations are possible only with this
+class +RangeExtd+ 
+
+Rangeary: https://rubygems.org/gems/rangeary
+
+==== NOTE: Relationship with Rangesmaller
+
+This package RangeExtd supersedes the obsolete {Rangesmaller}[https://rubygems.org/gems/rangesmaller] package and class,
+with the added open-ended feature, and a different interface in
+creating a new instance.
+https://rubygems.org/gems/rangesmaller
 
 
 == Install
@@ -215,7 +220,7 @@ politely.
 For more detail, see its documents (YARD or RDoc-style
 documents embedded in the code, or see {RubyGems webpage}[http://rubygems.org/gems/range_extd]).
 
-**Note** +RangeExtd::Infinity::POSITIVE+ is practically the same as
+**Note1:** +RangeExtd::Infinity::POSITIVE+ is practically the same as
 {Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
 introduced in Ruby 2.6 released in 2018 December!!  In other words,
 the official Ruby has finally implement a part of this library!
@@ -224,6 +229,28 @@ official Ruby Range (it has no "boundless begin"), and hence this library still
 supplements the mathematical incompleteness of the standard Range in
 the official Ruby.
 
+**Note2:**
+As of Ver.1.1, the +RangeExtd::Infinity+ class instances are not
+comparable with +Float::INFINITY+; for example,
+
+  RangeExtd::Infinity::POSITIVE != Float::INFINITY  # => true
+
+Conceptionally, the former is a generalised object of the latter and
+hence they should not be *equal*.  See the reference of
+{RangeExtd::Infinity} for detail.  Note, the behaviour of Endless Range from Ruby 2.6
+may feel a little odd, as follows:
+
+  num1 = (5..Float::INFINITY)
+  num2 = (5..)
+  num1.end != rnum2.end  # => true
+  num1.size              # => Infinity
+  num2.size              # => Infinity
+
+  str1 = (?a..)
+  str1.end == num2.end   # => true (because both are nil)
+  str1.size              # => nil
+
+
 === RangeExtd Class
 
 RangeExtd objects are immutable, the same as Range.
@@ -372,7 +399,7 @@ Enjoy.
 
 == Copyright etc
 
-Author::  Masa Sakano < imagine a_t sakano dot co dot uk >
+Author::  Masa Sakano < info a_t wisebabel dot com >
 License:: MIT.
 Warranty:: No warranty whatsoever.
 Versions:: The versions of this package follow Semantic Versioning (2.0.0) http://semver.org/
@@ -448,6 +475,18 @@ Versions:: The versions of this package follow Semantic Versioning (2.0.0) http:
 2019年10月より、本パッケージは、Ruby 2.6 で導入された {Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
 (終端のない Range)を正式サポートしました。よって、Version 1.0 をリリースしました!
 
+==== 注: Rangearyとの関係
+
+同クラス(典型的にはFloat)のオブジェクトからなる複数のRangeを扱うクラス
+{Rangeary}[https://rubygems.org/gems/rangeary] は、本ライブラリを使い
+切っています。Rangeを実現するためには、始端と終端との両方で開いた可能
+性があるRangeを扱うことが必須だからです。例えば、
+Range +(?a..?d)+ の否定は、複数Range +(-"Infinity(文字)"...3)+ と
++(?d(始端除外).."Infinity(文字)")+ であり、その否定は、元の +(?a..?d)+
+です。このような演算は、+RangeExtd+ があって初めて可能になります。
+
+Rangeary: https://rubygems.org/gems/rangeary
+
 ==== 注: Rangesmallerとの関係
 
 このパッケージは、(今やサポートされていない) {Rangesmaller}[https://rubygems.org/gems/rangesmaller] パッケージ及びクラスを
@@ -455,14 +494,6 @@ Versions:: The versions of this package follow Semantic Versioning (2.0.0) http:
 ブジェクト生成時のインターフェースが変更されています。
 https://rubygems.org/gems/rangesmaller
 
-==== 注: Rangearyとの関係
-
-同クラス(典型的にはFloat)のオブジェクトからなる複数のRangeを扱うクラス
-{Rangeary}[https://rubygems.org/gems/rangeary] は、本ライブラリを使い
-切っています。Rangeを実現するためには、始端と終端との両方で開いた可能
-性があるRangeを扱うことが必須だからです。
-https://rubygems.org/gems/rangeary
-
 == インストール
 
   gem install range_extd
@@ -733,7 +764,7 @@ RangeExtd内部に閉じた(Rangeでなく)挙動、たとえば RangeExtd同士
 
 == 著作権他情報
 
-著者::  Masa Sakano < imagine a_t sakano dot co dot uk >
+著者::  Masa Sakano < info a_t wisebabel dot com >
 利用許諾条項:: MIT.
 保証:: 一切無し。
 バージョン:: Semantic Versioning (2.0.0) http://semver.org/

data/README.ja.rdoc

@@ -68,14 +68,7 @@ I hope you find this package to be useful.
 === 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.0 finally!
-
-==== NOTE: Relationship with Rangesmaller
-
-This package supersedes the obsolete {Rangesmaller}[https://rubygems.org/gems/rangesmaller] package and class,
-with the added open-ended feature, and a different interface in
-creating a new instance.
-https://rubygems.org/gems/rangesmaller
+introduced in Ruby 2.6.  It is released as Version 1.* finally!
 
 ==== NOTE: Relationship with Rangeary
 
@@ -83,8 +76,20 @@ The class to handle multiple Ranges with objects of the same class
 (most typically Float),
 {Rangeary}[https://rubygems.org/gems/rangeary] uses this library to
 fullest, because the concept of potentially open-ended Range on both
-begin and end is essential to realise Rangeary.
-https://rubygems.org/gems/rangeary
+begin and end is essential to realise it.  For example, the negation
+of Range +(?a..?d)+ is Ranges +(-"Infinity-Character"...3)+ and
++(?d(exclusive).."Infinity-Character")+ and its negation is back to
+the original +(?a..?d)+.  Such operations are possible only with this
+class +RangeExtd+ 
+
+Rangeary: https://rubygems.org/gems/rangeary
+
+==== NOTE: Relationship with Rangesmaller
+
+This package RangeExtd supersedes the obsolete {Rangesmaller}[https://rubygems.org/gems/rangesmaller] package and class,
+with the added open-ended feature, and a different interface in
+creating a new instance.
+https://rubygems.org/gems/rangesmaller
 
 
 == Install
@@ -448,6 +453,18 @@ Versions:: The versions of this package follow Semantic Versioning (2.0.0) http:
 2019年10月より、本パッケージは、Ruby 2.6 で導入された {Endless Range}[https://rubyreferences.github.io/rubychanges/2.6.html#endless-range-1]
 (終端のない Range)を正式サポートしました。よって、Version 1.0 をリリースしました!
 
+==== 注: Rangearyとの関係
+
+同クラス(典型的にはFloat)のオブジェクトからなる複数のRangeを扱うクラス
+{Rangeary}[https://rubygems.org/gems/rangeary] は、本ライブラリを使い
+切っています。Rangeを実現するためには、始端と終端との両方で開いた可能
+性があるRangeを扱うことが必須だからです。例えば、
+Range +(?a..?d)+ の否定は、複数Range +(-"Infinity(文字)"...3)+ と
++(?d(始端除外).."Infinity(文字)")+ であり、その否定は、元の +(?a..?d)+
+です。このような演算は、+RangeExtd+ があって初めて可能になります。
+
+Rangeary: https://rubygems.org/gems/rangeary
+
 ==== 注: Rangesmallerとの関係
 
 このパッケージは、(今やサポートされていない) {Rangesmaller}[https://rubygems.org/gems/rangesmaller] パッケージ及びクラスを
@@ -455,14 +472,6 @@ Versions:: The versions of this package follow Semantic Versioning (2.0.0) http:
 ブジェクト生成時のインターフェースが変更されています。
 https://rubygems.org/gems/rangesmaller
 
-==== 注: Rangearyとの関係
-
-同クラス(典型的にはFloat)のオブジェクトからなる複数のRangeを扱うクラス
-{Rangeary}[https://rubygems.org/gems/rangeary] は、本ライブラリを使い
-切っています。Rangeを実現するためには、始端と終端との両方で開いた可能
-性があるRangeを扱うことが必須だからです。
-https://rubygems.org/gems/rangeary
-
 == インストール
 
   gem install range_extd

data/lib/range_extd/infinity/infinity.rb

@@ -17,7 +17,9 @@ class RangeExtd < Range
   # Class to hold just two constants: 
   # * RangeExtd::Infinity::NEGATIVE
   # * RangeExtd::Infinity::POSITIVE
+  #
   # and two more:
+  #
   # * FLOAT_INFINITY  (OBSOLETE; workaround for Ruby 1.8 to represent Float::INFINITY)
   # * CLASSES_ACCEPTABLE (see below)
   #
@@ -42,7 +44,7 @@ class RangeExtd < Range
   # There are only three built-in classes that are Comparable: String, Time and Numeric
   # (except for Complex).
   # Note Date and DateTime objects are so, too, however practically
-  # they need "require", hence are (and must be) treated, the same as any other class.
+  # they need "require", hence are (and must be) treated, the same as any other classes.
   # For String and Time class objects, the [#<=>] operator work as expected
   # in the commutative way.
   #    ?z <=> RangeExtd::Infinity::POSITIVE    # => nil
@@ -96,9 +98,43 @@ class RangeExtd < Range
   #
   # Only the methods defined in this class are
   # {#===}, {#==}, {#<=>}, {#succ}, {#to_s}, {#inspect},
-  # {#infinity?}, {#positive?} and {#negative?}.
+  # {#infinity?}, {#positive?} and {#negative?}, and in addition, since Version 1.1,
+  # two unary operators {#@+} and {#@-} to unchange/swap the parity are defined
+  # ({#<} and {#>} are modified, too, to deal with Integer and Float;
+  # I do not know whether the default behaviour of these classes have changed
+  # in the recent versions of Ruby, hence resulting in the neccesity of this change).
+  #
+  # === Comparison operators
+  #
+  # {RangeExtd::Infinity::POSITIVE} and InfN {RangeExtd::Infinity::NEGATIVE}
+  # are always comparable with any comparable objects except for
+  # Float::INFINITY, in which case
+  #
+  #   (RangeExtd::Infinity::POSITIVE <=> Float::INFINITY)  # => nil
+  #   (RangeExtd::Infinity::POSITIVE <   Float::INFINITY)  # => ArgumentError
+  #   (RangeExtd::Infinity::POSITIVE >   Float::INFINITY)  # => ArgumentError
+  #   (RangeExtd::Infinity::POSITIVE ==  Float::INFINITY)  # => false
+  #
+  # which is what happens for the comparison operators for Float::INFINITY.
+  #
+  # Basically, the concept of {RangeExtd::Infinity::POSITIVE} is a generalised
+  # concept of Float::INFINITY.  Therefore they are really not *equal*.
+  # On the other hand, {RangeExtd::Infinity::POSITIVE} is *greater* than
+  # any normal comparable objects (except those that are *infinite*).
+  # Therefore, all the following are true ({Object#<=>} and some methods
+  # in some classes are modified)
+  #
+  #   (5 < RangeExtd::Infinity::POSITIVE)
+  #   (5 > RangeExtd::Infinity::NEGATIVE)
   #
-  # Note that the unary operand [#-@] is not defined.
+  #   ("a" < RangeExtd::Infinity::POSITIVE)
+  #   ("a" > RangeExtd::Infinity::NEGATIVE)
+  #
+  # whereas
+  #
+  #   (RangeExtd::Infinity::POSITIVE < Object.new)  # => ArgumentError
+  #
+  # raises ArgumentError.
   #
   class Infinity
   
@@ -118,9 +154,25 @@ class RangeExtd < Range
     # CLASSES_ACCEPTABLE = [self, Float, Fixnum, Bignum, Rational, Numeric, String]	# , BigFloat
     CLASSES_ACCEPTABLE.push BigFloat if defined? BigFloat
 
+    # Unary Operator: Plus
+    def +@
+      self
+    end
+
+    # Unary Operator: Minus
+    def -@
+      positive? ? NEGATIVE : POSITIVE
+    end
+
     def infinity?
       true
     end
+    #alias_method :infinite?, :infinity? if !self.method_defined? :infinite?  # Common with Float::INFINITY
+    ## If the alias for :infinite? is defined as above, the following would raise
+    #    NoMethodError: undefined method `>' for true:TrueClass
+    #  in the operation
+    #    Float::INFINITY <=> RangeExtd::Infinity::POSITIVE
+    #
   
     def positive?
       @positive 
@@ -134,44 +186,53 @@ class RangeExtd < Range
 
     # Always -1 or 1 except for itself and the corresponding infinities (== 0).  See {#==}.
     # Or, nil (as defined by Object), if the argument is not Comparable, such as, nil and IO.
+    #
     # @return [Integer, nil]
     def <=>(c)
-      if c.nil?
-        super
-      elsif !defined?(c.<=)	# Not Comparable?
-        super
-      elsif @positive 
-        if self == c
-          0
-        else
-          1
-        end
-      else	# aka negative
-        if self == c
-          0
-        else
-          -1
-        end
+      if c.nil? || !c.class.method_defined?(:<=) # Not Comparable?
+        nil
+      elsif c == Float::INFINITY
+        nil  # Special case.
+      else
+        (self == c) ? 0 : (@positive ? 1 : -1)
       end
     end
-  
+
+    alias_method :greater_than_before_rangeextd_infinity?, :>  if ! self.method_defined?(:greater_than_before_rangeextd_infinity?)	# No overwriting.
+    # Special case for Float::INFINITY
+    #
+    #   (Float::INFINITY > RangeExtd::Infinity::POSITIVE)
+    # raises ArgumentError and so does this method.
+    def >(c)
+      ((c.abs rescue c) == Float::INFINITY) ? raise(ArgumentError, "RangeExtd::Infinity object not comparable with '#{__method__}' with Float::INFINITY") : greater_than_before_rangeextd_infinity?(c)
+    end
+
+    alias_method :less_than_before_rangeextd_infinity?, :<  if ! self.method_defined?(:less_than_before_rangeextd_infinity?)	# No overwriting.
+    # Special case for Float::INFINITY
+    #
+    #   (Float::INFINITY > RangeExtd::Infinity::POSITIVE)
+    # raises ArgumentError and so does this method.
+    def <(c)
+      ((c.abs rescue c) == Float::INFINITY) ? raise(ArgumentError, "RangeExtd::Infinity object not comparable with '#{__method__}' with Float::INFINITY") : less_than_before_rangeextd_infinity?(c)
+    end
+
     # Always false except for itself and the corresponding {Float::INFINITY}
     # and those that have methods of {#infinity?} and {#positive?}
     # with the corresponding true/false values, in which case this returns true.
     def ==(c)
       if (Infinity === c)
         (@positive ^! c.positive?)	# It should be OK to compare object_id?
-      elsif c ==  FLOAT_INFINITY &&  @positive
-        true
-      elsif c == -FLOAT_INFINITY && !@positive
-        true
+      #elsif c ==  FLOAT_INFINITY &&  @positive
+      #  true
+      #elsif c == -FLOAT_INFINITY && !@positive
+      #  true
       elsif defined?(c.infinity?) && defined?(c.positive?)
         (c.infinity? && (@positive ^! c.positive?))
       else
         false
       end
     end
-  
+
     # Equivalent to {#==}
     def ===(c)
       self == c
@@ -283,6 +344,34 @@ __EOF__
     end
   end	# def self.overwrite_compare(obj)
 
+  # True if obj is a kind of Infinity like this class
+  #
+  # This is similar to the following, but is in a duck-typing way:
+  #
+  #   RangeExtd::Infinity === obj
+  #
+  # Note that this returns false for Float::INFINITY.
+  # If you want true for Float::INFINITY, use {RangeExtd::Infinity.infinite?} instead.
+  #
+  # @param obj [Object]
+  def self.infinity?(obj)
+    kl = obj.class
+    kl.method_defined?(:infinity?) && kl.method_defined?(:positive?) && kl.method_defined?(:negative?)
+  end
+
+  # True if obj is either Float::INFINITY or Infinity type.
+  #
+  # Note +Float#infinite?+ is defined - how to memorise this method name.
+  #
+  # @param obj [Object]
+  def self.infinite?(obj)
+    kl = obj.class
+    (kl.method_defined?(:infinite?) && obj.infinite?) || (kl.method_defined?(:infinity?) && obj.infinity?)
+  end
+
+  ######################################
+  # Special tricky routine below.  Do not rouch!
+  ######################################
 
     private
   
@@ -303,6 +392,10 @@ __EOF__
     # Disable new() so no other object will be created.
     private_class_method :new
   
+    ######################################
+    # Special tricky routine below.  Do not rouch!
+    ######################################
+
     warn_level = $VERBOSE
     begin
       $VERBOSE = nil	# Suppress the warning in the following line.
@@ -350,43 +443,158 @@ class Object
   #        if c._is_what_i_expect?
   #          # Write your definition.
   #        else       # When self does not know what to do with c.
-  #          super    # to call Object#<=>
+  #          super c  # to call Object#<=>
   #        end
   #      end
   #    end
   #
   def <=>(c)
-    if defined?(self.<=) && RangeExtd::Infinity === c
-      # if defined?(self.<=) && defined?(c.infinity?) && defined?(c.positive?)
-      # NOTE: Duck-typing is inappropriate here.
-      #   Only the objects that self wants to deal with here are
-      #   the instances of RangeExtd::Infinity, and not other
-      #   "infinity" object, such as, Float::INFINITY.  So,
-      #     (self <=> RangeExtd::Infinity::POSITIVE)  # => -1
-      #     (self <=> Float::INFINITY)                # => nil
-      #   in default.
-      if defined?(self.infinity?) && defined?(self.positive?)
-        if (self.positive? ^! c.positive?)
-          0
-        elsif self.positive?
-          1
-        else
-          -1
-        end
-      else
-        # (c <=> self) * (-1)
-        if c.positive?
-          -1
-        else
-          1
-        end
-      end
-    elsif object_id == c.object_id	# (nil <=> nil)  # => 0
-      0
-    else
-      nil
-    end	# if defined?(self.<=) && RangeExtd::Infinity === c
+    return (-(c.send(__method__, self) || return)) if RangeExtd::Infinity.infinity? c
+    compare_obj_before_infinity(c)
   end	# def <=>(c)
 end	# class Object
 
 
+#
+# = class Numeric
+#
+# Modify {Numeric#>} and {Numeric#<} because +5 < RangeExtd::Infinity::POSITIVE+
+# raises ArgumentError(!).  In other words, +Integer#<+ does not respect
+# +Object#<=>+ but rewrites it.
+#
+# I do not know if it has been always the case, or some changes have been made
+# in more recent versions of Ruby.
+#
+# Note that +Float#<+ etc need to be redefined individually, because they seem
+# not to use +Numeric#<+ any more.
+class Numeric
+
+  alias_method :compare_than_numeric_before_infinity?, :<=>  if ! self.method_defined?(:compare_than_numeric_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def <=>(c)
+    # Default if the special case INFINITY.
+    return compare_than_numeric_before_infinity?(c) if ((abs rescue self) == Float::INFINITY)
+
+    return (-(c.send(__method__, self) || return)) if RangeExtd::Infinity.infinity? c
+    compare_than_numeric_before_infinity?(c)
+  end
+
+  alias_method :greater_than_numeric_before_infinity?, :>  if ! self.method_defined?(:greater_than_numeric_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def >(c)
+    # Default if self is Complex or something not Integer, Rational, Float or alike
+    # or the special case INFINITY.
+    return greater_than_numeric_before_infinity?(c) if !self.class.method_defined?(:>) || ((abs rescue self) == Float::INFINITY)
+
+    if RangeExtd::Infinity.infinity? c
+      c.negative?
+    else
+      greater_than_numeric_before_infinity?(c)
+    end
+  end
+
+  alias_method :less_than_numeric_before_infinity?, :<  if ! self.method_defined?(:less_than_numeric_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def <(c)
+    # Default if self is Complex or something not Integer, Rational, Float or alike
+    # or the special case INFINITY.
+    return less_than_numeric_before_infinity?(c) if !self.class.method_defined?(:>) || ((abs rescue self) == Float::INFINITY)
+
+    if RangeExtd::Infinity.infinity? c
+      c.positive?
+    else
+      less_than_numeric_before_infinity?(c)
+    end
+  end
+end  # class Numeric
+
+
+#
+# = class Float
+#
+# The same as {Numeric#>} and {Numeric#<}.  See them for the background.
+class Float
+
+  alias_method :compare_than_float_before_infinity?, :<=>  if ! self.method_defined?(:compare_than_float_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def <=>(c)
+    # Default if the special case INFINITY.
+    return compare_than_float_before_infinity?(c) if ((abs rescue self) == Float::INFINITY)
+
+    return (-(c.send(__method__, self) || return)) if RangeExtd::Infinity.infinity? c
+    compare_than_float_before_infinity?(c)
+  end
+
+  alias_method :greater_than_float_before_infinity?, :>  if ! self.method_defined?(:greater_than_float_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def >(c)
+    # Default if self is Complex or something not Integer, Rational, Float or alike
+    # or the special case INFINITY.
+    return greater_than_float_before_infinity?(c) if ((abs rescue self) == Float::INFINITY)
+
+    if RangeExtd::Infinity.infinity? c
+      c.negative?
+    else
+      greater_than_float_before_infinity?(c)
+    end
+  end
+
+  alias_method :less_than_float_before_infinity?, :<  if ! self.method_defined?(:less_than_float_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def <(c)
+    # Default if self is Complex or something not Integer, Rational, Float or alike
+    # or the special case INFINITY.
+    return less_than_float_before_infinity?(c) if ((abs rescue self) == Float::INFINITY)
+
+    if RangeExtd::Infinity.infinity? c
+      c.positive?
+    else
+      less_than_float_before_infinity?(c)
+    end
+  end
+end  # class Float
+
+
+#
+# = class Integer
+#
+# The same as {Numeric#>} and {Numeric#<}.  See them for the background.
+class Integer
+
+  alias_method :compare_than_integer_before_infinity?, :<=>  if ! self.method_defined?(:compare_than_integer_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def <=>(c)
+    # Default if the special case INFINITY (never happens in Default, but a user may define Integer::INFINITY).
+    return compare_than_integer_before_infinity?(c) if ((abs rescue self) == Float::INFINITY)
+
+    return (-(c.send(__method__, self) || return)) if RangeExtd::Infinity.infinity? c
+    compare_than_integer_before_infinity?(c)
+  end
+
+  alias_method :greater_than_integer_before_infinity?, :>  if ! self.method_defined?(:greater_than_integer_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def >(c)
+    # Default if self is not comparable (in case the Integer method is redifined by a user).
+    return greater_than_integer_before_infinity?(c) if !self.class.method_defined?(:>)
+
+    if RangeExtd::Infinity.infinity? c
+      c.negative?
+    else
+      greater_than_integer_before_infinity?(c)
+    end
+  end
+
+  alias_method :less_than_integer_before_infinity?, :<  if ! self.method_defined?(:less_than_integer_before_infinity?)	# No overwriting.
+  # Special case for comparison with a {RangeExtd::Infinity} instance.
+  def <(c)
+    # Default if self is not comparable (in case the Integer method is redifined by a user).
+    return less_than_integer_before_infinity?(c) if !self.class.method_defined?(:>)
+
+    if RangeExtd::Infinity.infinity? c
+      c.positive?
+    else
+      less_than_integer_before_infinity?(c)
+    end
+  end
+end  # class Integer
+

data/lib/range_extd/range_extd.rb

@@ -26,9 +26,6 @@ req_files.each do |req_file|
   end
 end	# req_files.each do |req_file|
 
-########################################
-# Initial set up of 2 constants in RangeExtd.
-########################################
 
 # =Class RangeExtd
 #
@@ -60,6 +57,10 @@ end	# req_files.each do |req_file|
 #
 class RangeExtd < Range
 
+  # To conrol how the {RangeExtd} should be displayed or set (in one form).
+  # It can be read and reset by {RangeExtd.middle_strings} and
+  # {RangeExtd.middle_strings=}
+  # Default is +['', '', '<', '..', '.', '', '']+
   @@middle_strings = []
 
   # Error messages
@@ -726,6 +727,28 @@ class RangeExtd < Range
   # in the range whereas 4.8 is not in the range by definition,
   # but not the example right above.
   #
+  # === Ruby 2.6 Endless Range and Infinity.
+  #
+  # Before RangeExtd Ver.1.1, if a {RangeExtd} object contains
+  # {RangeExtd::Infinity} objects for either begin or end, {#size} used to
+  # be always +Float::INFINITY+ no matter what the other object is
+  # (except when the other object is also a {RangeExtd::Infinity} object).
+  # However, since the introduction of the endless Range in Ruby 2.6,
+  # Ruby returns as follows:
+  #
+  #   (5..).size  # => Float::INFINITY
+  #   (?a..).size # => nil
+  #
+  # Accordingly, this class {RangeExtd} now behaves the same as Ruby (2.6 or later).
+  #
+  # Similarly,
+  #
+  #   (Float::INFINITY..Float::INFINITY).size
+  #
+  # has changed (I do not know in which Ruby version)!
+  # It used to be 0.  However, As of Ruby 2.6, it is +FloatDomainError: NaN+
+  # Again this class now follows Ruby's default ({RangeExtd} Ver.1.0 or later).
+  #
   # @note When both ends n are the same INFINITY (of the same parity),
   #   +(n..n).size+ used to be 0.  As of Ruby 2.6, it is FloatDomainError: NaN.
   #   This routine follows what Ruby produces, depending on Ruby's version it is run on.
@@ -758,11 +781,16 @@ class RangeExtd < Range
     # Note (Infinity..Infinity) => 0  (Range as in Ruby 2.1)
     # however, 
     elsif (defined?(self.begin.infinity?) && self.begin.infinity? || self.begin == -Infinity::FLOAT_INFINITY) ||
-          (defined?(self.end.infinity?)   && self.end.infinity?   || self.end == Infinity::FLOAT_INFINITY)
+          (defined?(self.end.infinity?)   && self.end.infinity?   || self.end == Infinity::FLOAT_INFINITY) ||
+          (self.end.nil?)  # RangeExtd#end can be nil only for Ruby-2.6
       if self.begin == self.end
         # This varies, depending on Ruby's version!  It used to be 0.  As of Ruby 2.6, it is FloatDomainError: NaN.
         return (Float::INFINITY..Float::INFINITY).size
         # return 0
+      elsif self.end.nil?
+        # Behaves as Ruby does -
+        #  Infinity::FLOAT_INFINITY for Numeric and nil for any other
+        return (self.begin..nil).size
       else
         return Infinity::FLOAT_INFINITY
       end
@@ -952,13 +980,40 @@ class RangeExtd < Range
     if hsopt.has_key?(:exclude_end)
       exclude_end   = (hsopt[:exclude_end] && true)
     end
-    # [RangeBeginValue, RangeEndValue, exclude_end?, exclude_begin?]
-    beginend + [exclude_end, exclude_begin]
 
+    # [RangeBeginValue, RangeEndValue, exclude_end?, exclude_begin?]
+    _normalize_infinity_float(beginend) + [exclude_end, exclude_begin]
   end	# def self._get_init_args(*inar)
-
   private_class_method :_get_init_args	# From Ruby 1.8.7 (?)
 
+  # Replaces {RangeExtd::Infinity} with {Float::INFINITY} when appropriate
+  #
+  # @param beginend [Array] 2-compoents
+  # @return [Array] 2-compoents
+  def self._normalize_infinity_float(beginend)
+    is_begin_inf = Infinity.infinity?(beginend[0])
+    return beginend if is_begin_inf ^! Infinity.infinity?(beginend[1])
+
+    # Now, only one of them is a {RangeExtd::Infinity} type object.
+    if is_begin_inf && beginend[1].class.method_defined?(:divmod)
+      [_normalize_infinity_float_core(beginend[0]), beginend[1]] # "begin" is Infinity
+    elsif beginend[0].class.method_defined?(:divmod)
+      [beginend[0], _normalize_infinity_float_core(beginend[1])] # "end" is Infinity
+    else
+      beginend
+    end
+  end
+  private_class_method :_normalize_infinity_float  # From Ruby 1.8.7 (?)
+
+  # @param inf [RangeExtd::Infinity]
+  # @return [RangeExtd::Infinity, Float] +/-Float::INFINITY if Float
+  def self._normalize_infinity_float_core(inf)
+    msg = 'RangeExtd component of the RangeExtd::Infinity object replaced with Float::INFINITY.'
+    warn msg if !$VERBOSE.nil?
+    (inf.positive? ? 1 : -1) * Float::INFINITY
+  end
+  private_class_method :_normalize_infinity_float_core  # From Ruby 1.8.7 (?)
+
 
   # Returns true if the range to be constructed (or given) is valid,
   # as a range, accepted in {RangeExtd}.
@@ -977,7 +1032,7 @@ class RangeExtd < Range
   #    introduced in Ruby 2.6 (see below for the exceptions), both of which are valid.
   #    For example, (nil..nil) is NOT valid (nb., it raised Exception in Ruby 1.8).
   # 2. Except for {RangeExtd::NONE}, {#begin} must have the method +<=+.
-  #    Therefore, some Endless Ranges (Ruby 2.6 and upwards) like (true..) are *not* valid.
+  #    Therefore, some Endless Ranges (Ruby 2.6 and later) like (true..) are *not* valid.
   #    Note even "true" has the method +<=>+ and hence checking +<=+ is essential.
   # 3. {#begin} must be smaller than or equal to {#end},
   #    that is, ({#begin} <=> {#end}) must be either -1 or 0.
@@ -1053,7 +1108,7 @@ class RangeExtd < Range
       rescue NoMethodError, TypeError
         if (Float === vend && defined?(vbeg.infinity?) && vbeg.infinity?) ||
            (Float === vbeg && defined?(vend.infinity?) && vend.infinity?)
-          warn self.const_get(:ERR_MSGS)[:infinity_compare]  # one of the tests comes here.
+          warn self.const_get(:ERR_MSGS)[:infinity_compare] if !$VERBOSE.nil?  # one of the tests comes here.
         end
         return false	# return
       end
@@ -1074,7 +1129,7 @@ class RangeExtd < Range
       else
         if (Float === vend && defined?(vbeg.infinity?) && vbeg.infinity?) ||
            (Float === vbeg && defined?(vend.infinity?) && vend.infinity?)
-          warn self.const_get(:ERR_MSGS)[:infinity_compare]  # not tested so far?
+          warn self.const_get(:ERR_MSGS)[:infinity_compare] if !$VERBOSE.nil?  # not tested so far?
         end
         false	# Not Comparable.
       end	# case t
@@ -1082,7 +1137,6 @@ class RangeExtd < Range
     end
   end	# def valid?
 
-
   # Set the class variable to be used in {RangeExtd#to_s} and {RangeExtd#inspect}
   # to configure the format of their returned values.
   #
@@ -1283,11 +1337,11 @@ class RangeExtd < Range
   # No range.
   # In Ruby1.8, this causes  ArgumentError: bad value for range (because (nil..nil) is unaccepted).
   NONE = RangeExtd.new(nil, nil, true, true, :Constant)
-  #NONE = RangeExtd.new(nil...nil, true, true, :Constant)
+  #NONE= RangeExtd.new(nil...nil, true, true, :Constant)
 
   # Range covers everything.
   ALL  = RangeExtd.new(Infinity::NEGATIVE, Infinity::POSITIVE, false, false, :Constant)
-  #ALL  = RangeExtd.new(Infinity::NEGATIVE..Infinity::POSITIVE, false, false, :Constant)
+  #ALL = RangeExtd.new(Infinity::NEGATIVE..Infinity::POSITIVE, false, false, :Constant)
 
 end	# class RangeExtd < Range
 

data/test/test_range_extd.rb

@@ -49,6 +49,12 @@ end
 # Unit Test
 #################################################
 
+begin
+  _ = Rational(2, 3)
+rescue
+  require 'rational'
+end
+
 #if $0 == __FILE__
 gem "minitest"
 # require 'minitest/unit'
@@ -142,6 +148,10 @@ gem "minitest"
   class TestUnitFoo < MiniTest::Unit::TestCase
     T = true
     F = false
+    InfF = Float::INFINITY
+    InfP = RangeExtd::Infinity::POSITIVE
+    InfN = RangeExtd::Infinity::NEGATIVE
+
     def setup
       @ib = 1
       @ie = 6
@@ -166,6 +176,48 @@ gem "minitest"
       assert_equal 0, (IO <=> IO)
     end	# def test_object_compare
 
+    # InfP (RangeExtd::Infinity::POSITIVE) and InfN (RangeExtd::Infinity::NEGATIVE)
+    # are always comparable with any comparable objects except for
+    # Float::INFINITY, in which case ArgumentError is raised.
+    def test_infinity_compare
+      assert_operator            7.7, '<', InfF
+      assert_operator            7.7, '<', InfP
+      assert_operator            7.7, '>', InfN
+      assert_operator           InfP, '>', 7.7
+      assert_operator           InfN, '<', 7.7
+      assert_operator              8, '<', InfF
+      assert_operator              8, '<', InfP
+      assert_operator Rational(2, 3), '<', InfF
+      assert_operator Rational(2, 3), '<', InfP
+      assert_operator           InfP, '>', Rational(2, 3)
+      assert_operator           InfN, '<', Rational(2, 3)
+      assert_operator 'h', '<',  InfP
+      assert_operator 'h', '>',  InfN
+      assert_raises(ArgumentError) { InfF <  InfP }
+      assert_raises(ArgumentError) { InfP <  InfF }
+      assert_raises(ArgumentError) { InfP < -InfF }
+      assert_raises(ArgumentError) { InfP >  InfF }
+      assert_raises(ArgumentError) { InfP > -InfF }
+      assert_raises(ArgumentError) { InfN <  InfF }
+      assert_raises(ArgumentError) { InfN < -InfF }
+      assert_raises(ArgumentError) { InfF < Object.new }
+      assert_raises(ArgumentError) { InfP < Object.new }
+      assert_nil     (InfF <=> InfP)
+      assert_nil     (InfP <=> InfF)
+      assert_equal(-1,  7.7 <=> InfP)
+      assert_equal( 1,  7.7 <=> InfN)
+      assert_equal( 1, InfP <=> 7.7)
+      assert_equal(-1, InfN <=> 7.7)
+      assert_equal(-1,    5 <=> InfP)
+      assert_equal( 1,    5 <=> InfN)
+      assert_equal( 1, InfP <=> 5)
+      assert_equal(-1, InfN <=> 5)
+      assert_equal(-1,  'h' <=> InfP)
+      assert_equal(-1, InfN <=> 'h')
+      #assert_raises(ArgumentError) { puts "##########  #{(InfP > InfF).inspect}";InfP < InfF }
+      #puts "##########  #{(InfP <=> InfF).inspect}"
+    end
+
     def test_overwrite_compare
       assert_nil     (Float::INFINITY <=> RangeExtd::Infinity::POSITIVE)
       assert_nil  RangeExtd::Infinity.overwrite_compare(Numeric)
@@ -295,6 +347,15 @@ gem "minitest"
     end
 
     def test_new_endless_range01
+      begin
+        _ = (0..nil)
+      rescue ArgumentError
+        # Before Ruby 2.6
+        assert_raises(ArgumentError) {RangeExtd.new(-2, nil)}
+        return  # Before Ruby 2.6
+      end
+
+      # Ruby 2.6 upwards
       ra00 = (-2..)
       rae0 = RangeExtd.new(ra00)
       assert rae0.valid?
@@ -303,9 +364,26 @@ gem "minitest"
       assert_equal Float::INFINITY,   rae0.size
       assert_equal ra00.exclude_end?, rae0.exclude_end?
       refute                          rae0.exclude_begin?
+
+      rae0 = RangeExtd.new(-2, nil)
+      assert rae0.valid?
+      assert_equal(-2,  rae0.begin)
+      assert_nil        rae0.end
+      assert_equal Float::INFINITY,   rae0.size
+      assert_equal ra00.exclude_end?, rae0.exclude_end?
+      refute                          rae0.exclude_begin?
     end
 
     def test_new_endless_range02
+      begin
+        _ = (?d...nil)
+      rescue ArgumentError
+        # Before Ruby 2.6
+        assert_raises(ArgumentError) {RangeExtd.new(?d, nil)}
+        return  # Before Ruby 2.6
+      end
+
+      # Ruby 2.6 upwards
       ra00 = (Float::INFINITY...)
       rae0 = RangeExtd.new(ra00)
       assert rae0.valid?
@@ -314,6 +392,38 @@ gem "minitest"
       assert_equal Float::INFINITY,   rae0.size
       assert_equal ra00.exclude_end?, rae0.exclude_end?
       refute                          rae0.exclude_begin?
+
+      assert_equal Float::INFINITY, RangeExtd.new(?d, RangeExtd::Infinity::POSITIVE).size
+      assert_equal Float::INFINITY, RangeExtd.new(RangeExtd::Infinity::NEGATIVE, ?d).size
+
+      rae0 = RangeExtd.new(?d, nil, false, true)
+      assert rae0.valid?
+      assert_equal(?d,  rae0.begin)
+      assert_nil        rae0.end
+      # assert_equal (?d..nil).size, rae0.size   # assert_nil warning!
+      assert_nil  (?d..nil).size
+      assert_nil  rae0.size
+      assert_equal true,           rae0.exclude_end?
+      refute                       rae0.exclude_begin?
+    end
+
+    def test_new_endless_range03
+      begin
+        _ = (?d...nil)
+      rescue ArgumentError
+        # Before Ruby 2.6
+        assert_raises(ArgumentError) {RangeExtd.new(?d, nil)}
+        return  # Before Ruby 2.6
+      end
+
+      ra00 = (-Float::INFINITY...)
+      rae0 = RangeExtd.new(ra00)
+      assert rae0.valid?
+      assert_equal(-Float::INFINITY,   rae0.begin)
+      assert_nil         rae0.end
+      assert_equal  Float::INFINITY,   rae0.size
+      assert_equal  ra00.exclude_end?, rae0.exclude_end?
+      refute                           rae0.exclude_begin?
     end
 
     def test_new_middle_strings
@@ -419,19 +529,26 @@ gem "minitest"
       assert_equal RangeExtd::NONE, RaE(?a, ?a, true, true)
       assert_equal (0..0), RaE(0, 0, false, false)
 
+      # The following used to raise RangeError (Ver.0.4 and 1.0) or ArgumentError (<= Ver.0.4.0)
+      assert_output('', /Infinity/i){RaE(RangeExtd::Infinity::NEGATIVE,  Float::INFINITY)}  # Warning = "RangeExtd component of the RangeExtd::Infinity object replaced with Float::INFINITY"
+      capture_io{
+        ra_b = RaE(InfN, InfF).begin  # RangeExtd::Infinity::NEGATIVE replaced with -Float::INFINITY
+        assert_equal    -InfF, ra_b
+        assert_operator Float, '===', ra_b
+      }
+
       # Wrong range (Infinity input)
       assert_raises(re){ RaE(?a, RangeExtd::Infinity::NEGATIVE) }
       assert_equal (RangeExtd::Infinity::NEGATIVE..?a),  RaE(RangeExtd::Infinity::NEGATIVE, ?a)
       assert_equal (RangeExtd::Infinity::NEGATIVE...?a), RaE(RangeExtd::Infinity::NEGATIVE, ?a, nil, 3)
       assert_equal (?a..RangeExtd::Infinity::POSITIVE),  RaE(?a, RangeExtd::Infinity::POSITIVE)
       assert_equal RangeExtd, RaE(?a, RangeExtd::Infinity::POSITIVE, 1).class
-      assert_raises(re){ RaE(RangeExtd::Infinity::NEGATIVE,  Float::INFINITY) }	# Float::INFINITY is an exception - you should not mix it up.
-      assert_raises(re){ RaE(-Float::INFINITY, RangeExtd::Infinity::POSITIVE) }	# Float::INFINITY is an exception - you should not mix it up.
+
       assert_raises(re){ RaE(RangeExtd::Infinity::POSITIVE, ?a) }
       assert_raises(re){      RaE(RangeExtd::Infinity::POSITIVE, RangeExtd::Infinity::NEGATIVE) }
       assert_equal RangeExtd, RaE(RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::POSITIVE).class
-      assert_raises(re){ RaE(RangeExtd::Infinity::NEGATIVE, 0, false, false) }	# For Numeric, you should use -Float::INFINITY
-      assert_raises(re){ RaE(0, RangeExtd::Infinity::POSITIVE, false, false) }	# For Numeric, you should use  Float::INFINITY
+      # assert_raises(re){ RaE(RangeExtd::Infinity::NEGATIVE, 0, false, false) }	# For Numeric, you should use -Float::INFINITY
+      # assert_raises(re){ RaE(0, RangeExtd::Infinity::POSITIVE, false, false) }	# For Numeric, you should use  Float::INFINITY
       assert_equal RangeExtd, RaE(RangeExtd::Infinity::NEGATIVE, ?a, false, false).class
       assert_equal RangeExtd, RaE(?a, RangeExtd::Infinity::POSITIVE, false, false).class
       # assert_raises(ae){ RaE(RangeExtd::Infinity::NEGATIVE, ?a, true) }	#### No exception.  Is it OK???
@@ -1051,12 +1168,20 @@ gem "minitest"
       assert_equal RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::NEGATIVE
       assert_equal RangeExtd::Infinity::POSITIVE, RangeExtd::Infinity::POSITIVE.succ
       assert_equal RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::NEGATIVE.succ
-      assert_equal(-Float::INFINITY, RangeExtd::Infinity::NEGATIVE)
-      assert_equal  Float::INFINITY, RangeExtd::Infinity::POSITIVE
-      assert !(RangeExtd::Infinity::NEGATIVE > -Float::INFINITY)
-      assert !(RangeExtd::Infinity::NEGATIVE < -Float::INFINITY)
-      assert !(RangeExtd::Infinity::POSITIVE >  Float::INFINITY)
-      assert !(RangeExtd::Infinity::POSITIVE <  Float::INFINITY)
+      refute_equal(-Float::INFINITY, RangeExtd::Infinity::NEGATIVE)
+      refute_equal  Float::INFINITY, RangeExtd::Infinity::POSITIVE
+      assert_raises(ArgumentError) { Float::INFINITY < RangeExtd::Infinity::POSITIVE }
+      assert_raises(ArgumentError) { Float::INFINITY > RangeExtd::Infinity::POSITIVE }
+      assert_raises(ArgumentError) { Float::INFINITY > RangeExtd::Infinity::NEGATIVE }
+      assert_raises(ArgumentError) { RangeExtd::Infinity::NEGATIVE > -Float::INFINITY }
+      assert_raises(ArgumentError) { RangeExtd::Infinity::NEGATIVE >  Float::INFINITY }
+      assert_raises(ArgumentError) { RangeExtd::Infinity::NEGATIVE < -Float::INFINITY }
+      assert_raises(ArgumentError) { RangeExtd::Infinity::POSITIVE >  Float::INFINITY }
+      assert_raises(ArgumentError) { RangeExtd::Infinity::POSITIVE < -Float::INFINITY }
+      #assert !(RangeExtd::Infinity::POSITIVE >  Float::INFINITY)  # Before Ver.1.1
+      #assert !(RangeExtd::Infinity::NEGATIVE > -Float::INFINITY)  # Before Ver.1.1
+      #assert !(RangeExtd::Infinity::POSITIVE >  Float::INFINITY)  # Before Ver.1.1
+      #assert !(RangeExtd::Infinity::POSITIVE <  Float::INFINITY)  # Before Ver.1.1
       assert  (RangeExtd::Infinity::POSITIVE > 0)
       assert  (RangeExtd::Infinity::POSITIVE > RangeExtd::Infinity::NEGATIVE)
       assert  (RangeExtd::Infinity::NEGATIVE < 0)
@@ -1068,6 +1193,8 @@ gem "minitest"
       assert !(RangeExtd::Infinity::POSITIVE === RangeExtd::Infinity::NEGATIVE)
       assert !(RangeExtd::Infinity::NEGATIVE === RangeExtd::Infinity::POSITIVE)
 
+      #### Comment valid up to Ver.1.0  (changed in Ver.1.1)
+      #
       ## This is the case so far.  Rewrite Float/Fixnum/Bignum/Rational??
       ## It would get slow, though!  It is a lot better to use Float::INFINITY, instead.
       # assert_raises ArgumentError do
@@ -1082,6 +1209,21 @@ gem "minitest"
       assert_equal(-1, (Time.now <=> RangeExtd::Infinity::POSITIVE))
     end
 
+    def test_is_infinities
+      # infinity?
+      refute RangeExtd::Infinity.infinity? 5
+      refute RangeExtd::Infinity.infinity? InfF
+      assert RangeExtd::Infinity.infinity? InfP
+      assert RangeExtd::Infinity.infinity? InfN
+      assert RangeExtd::Infinity.infinity? RangeExtd::ALL.begin
+
+      # infinite?  (similar but different!)
+      refute RangeExtd::Infinity.infinite? 5
+      assert RangeExtd::Infinity.infinite? InfF
+      assert RangeExtd::Infinity.infinite? InfP
+      assert RangeExtd::Infinity.infinite? InfN
+      assert RangeExtd::Infinity.infinite? RangeExtd::ALL.begin
+    end
 
     def test_RangeExtdClass_valid
       assert !RangeExtd.valid?(nil, nil, 9,9)	# All 3 were true up to Version 0.1.0
@@ -1303,8 +1445,8 @@ gem "minitest"
       assert  RangeExtd::ALL.valid?
       assert !RangeExtd::ALL.null?
       assert !RangeExtd::ALL.empty?
-      assert_equal (-Float::INFINITY..Float::INFINITY), RangeExtd::ALL
-      assert_equal RangeExtd::ALL, (-Float::INFINITY..Float::INFINITY)
+      refute_equal (-Float::INFINITY..Float::INFINITY), RangeExtd::ALL
+      refute_equal RangeExtd::ALL, (-Float::INFINITY..Float::INFINITY)
       assert_equal RangeExtd::Infinity::POSITIVE, RangeExtd::ALL.end
       assert_equal RangeExtd::Infinity::NEGATIVE, RangeExtd::ALL.begin
     end
@@ -1377,7 +1519,7 @@ gem "minitest"
       assert       rs.cover?(?x)
       assert_nil  (rs === ?x)
       assert_equal RangeExtd::Infinity::NEGATIVE, rs.begin	# It is Infinity,
-      assert_equal(-Float::INFINITY, rs.begin)	# but still equal to Float.
+      refute_equal(-Float::INFINITY, rs.begin)
       assert     ! rs.begin.positive?
       assert_equal  Float::INFINITY, rs.size
       assert_raises TypeError do
@@ -1385,6 +1527,12 @@ gem "minitest"
       end
     end
 
+    def test_infinity_unary_operators
+      assert_equal RangeExtd::Infinity::POSITIVE, +RangeExtd::Infinity::POSITIVE
+      assert_equal RangeExtd::Infinity::NEGATIVE, -RangeExtd::Infinity::POSITIVE
+      assert_equal RangeExtd::Infinity::NEGATIVE, +RangeExtd::Infinity::NEGATIVE
+      assert_equal RangeExtd::Infinity::POSITIVE, -RangeExtd::Infinity::NEGATIVE
+    end
 
     # Tests of all the examples in the document.
     def test_in_document
@@ -1579,7 +1727,7 @@ gem "minitest"
       # class Infinity
       assert_equal( -1, (?z <=> RangeExtd::Infinity::POSITIVE))
       assert_equal   1, (RangeExtd::Infinity::POSITIVE <=> ?z)
-      assert_nil        (50 <=> RangeExtd::Infinity::POSITIVE)
+      assert_equal( -1, (50 <=> RangeExtd::Infinity::POSITIVE))
       assert_equal   1, (RangeExtd::Infinity::POSITIVE <=> 50)
     end	# def test_in_document
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: range_extd
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: '1.1'
 platform: ruby
 authors:
 - Masa Sakano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-30 00:00:00.000000000 Z
+date: 2019-11-01 00:00:00.000000000 Z
 dependencies: []
 description: Package for a subclass of Range, RangeExtd and RangeExtd::Infinity.  The
   former defines a range that enables an exclusion of the begin boundary, in addition