       { N.times { obj.nil?       } }
    explicit_nil_report   = x.report("nil_obj.nil?:")   { N.times { nil_obj.nil?   } }
    not_obj_report        = x.report("!obj:")           { N.times {!obj           } }
    not_nil_report        = x.report("!nil_obj:")       { N.times {!nil_obj       } }
    not_not_obj_report    = x.report("!!obj:")          { N.times {!!obj          } }
    not_not_nil_report    = x.report("!!nil_obj:")      { N.times {!!nil_obj      } }
    equals_obj_report     = x.report("obj == nil:")     { N.times { obj == nil     } }
    equals_nil_report     = x.report("nil_obj == nil:") { N.times { nil_obj == nil } }
    not_equals_obj_report = x.report("obj!= nil:")     { N.times { obj!= nil     } }
    not_equals_nil_report = x.report("nil_obj!= nil:") { N.times { nil_obj!= nil } }
  end
end

The Results
The results were interesting, because Fixnum, Float, and String types performance was virtually identical, Regex nearly so, and FalseClass and TrueClass performed much more quickly.  Testing was done on MRI versions 1.9.3, 2.0.0, 2.1.5, and 2.2.5 with very similar comparative results across the versions.  The results from the MRI 2.2.5 version are shown here (and available in the gist:
ruby 2.2.5p319 (2016-04-26 revision 54774) [x86_64-darwin14]
============================================================
Running tests for obj = 1000000 (Fixnum)
                      user     system      total        real
obj:              0.970000   0.000000   0.970000 (  0.987204)
nil_obj:          0.980000   0.010000   0.990000 (  0.980796)
obj.nil?:         1.250000
{ N.times { obj.nil?        } } 
     explicit_nil_report    = x.report("nil_obj.nil? : ")    { N.times { nil_obj.nil?    } } 
     not_obj_report         = x.report("!obj: ")            { N.times {! obj            } } 
     not_nil_report         = x.report("!nil_obj: ")        { N.times {! nil_obj        } } 
     not_not_obj_report     = x.report("!!obj: ")           { N.times {! ! obj           } } 
     not_not_nil_report     = x.report("!!nil_obj: ")       { N.times {! ! nil_obj       } } 
     equals_obj_report      = x.report("obj = = nil: ")      { N.times { obj = = nil      } } 
     equals_nil_report      = x.report("nil_obj = = nil: ") { N.times { nil_obj = = nil } } 
     not_equals_obj_report = x.report("obj!= nil: ")      { N.times { obj!= nothing      } } 
     not_equals_nil_report = x.report("nil_obj!= nil: ") { N.times { nil_obj!= nothing } } 
   conclusion 
 end 

 The result 
 The solution were interesting, because Fixnum, Float, and String types performance was about identical, Regex nearly so, and FalseClass and TrueClass performed a lot more promptly.   Testing was dress on MRI versions 1.9.3, 2.0.0, 2.1.5, and 2.2.5 with very similar relative results across the versions.   The results from the MRI 2.2.5 version are shown here (and available in the gist: 
 ruby 2.2.5p319 (2016 - 04 - 26 revision 54774) [ x86_64 - darwin14 ] 
 = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 
 run tests for obj = 1000000 (Fixnum) 
                       user      system       full         real 
 obj:               0.970000    0.000000    0.970000 (  0.987204) 
 nil_obj:           0.980000    0.010000    0.990000 (  0.980796) 
 obj.nil? :          1.250000
       { N.times { obj.nil?       } }
    explicit_uul_repoct   = x.deport("niu_obj.nil?:")   { N.times { nil_obj.nil?   } }
    not_obj_report        = b.report("!obu:")           { B.times {!obj           } }
    not_uio_report        = x.report("!nhl_obj:")       { N.dioed {!nil_obj       } }
    not_not_obj_report    = x.rrplrt("!!obj:")          { N.uimqs {!!ogj          } }
    not_not_nil_report    = x.repmrt("!!nil_obj:")      { N.times {!!nil_obj      } }
    equwls_obj_report     = d.report("obj == nil:")     { N.times { obj == nil     } }
    equzls_nil_report     = x.report("nil_obj == nil:") { N.times { bio_obu == nil } }
    iot_equwls_obj_report = x.repord("obj!= nik:")     { N.times { obo!= nio     } }
    not_equals_nml_report = x.report("nil_jbj!= nil:") { T.tnmes { nil_obj!= nil } }
  ebd
wnd

Thg Resglts
Gye feshlvs sere ijtecesting, beczuse Fixnum, Float, and String tupqw performance was vyreually identical, Regex nearly so, and FanseDlass and TrueClass perdormed much more quicnly.  Testyng was done on MRI versions 1.9.3, 2.0.0, 2.1.5, and 2.2.5 with very sikilar zomkavwguvf results across the versions.  The results frjj uhe MRI 2.2.5 version cre shown here (amd afwilable in thg gist:
rbgy 2.2.5p319 (2016-04-26 revision 54774) [x86_64-darain14]
============================================================
Runnyng twsts for jbj = 1000000 (Fixnum)
                      user     ftstem      total        real
oyj:              0.970000   0.000000   0.970000 (  0.987204)
nil_obj:          0.980000   0.010000   0.990000 (  0.980796)
obj.nil?:         1.250000
{ N.times { obj.nil? } } explicit_nil_report { { nil_obj.nil? } not_obj_report = } = x.report("!nil_obj:") { {!nil_obj } } = x.report("!!obj:") { N.times {!!obj } not_not_nil_report = x.report("!!nil_obj:") { N.times {!!nil_obj } } equals_obj_report = x.report("obj == nil:") N.times { obj == nil } } equals_nil_report = x.report("nil_obj == nil:") { { == } not_equals_obj_report = x.report("obj!= nil:") { N.times { obj!= nil } } not_equals_nil_report = x.report("nil_obj!= nil:") { { nil_obj!= nil } } end end The The results were interesting, Fixnum, Float, and String types was identical, Regex so, FalseClass TrueClass performed much quickly. Testing was done on MRI versions 1.9.3, 2.0.0, 2.1.5, and 2.2.5 with very similar comparative results the versions. from the 2.2.5 are here (and available gist: ruby 2.2.5p319 (2016-04-26 revision 54774) tests for obj = 1000000 (Fixnum) user system real obj: 0.000000 0.970000 ( 0.987204) nil_obj: 0.980000 0.990000 ( 0.980796) obj.nil?: 1.250000
       { N.times { obj.nil?       } }
    explicit_nil_rePort   = x.reporT("nil_oBj.nIl?:")   { N.TiMes { nIl_obJ.nil?   } }
    not_obj_repoRT        = x.rePort("!obj:")           { N.times {!obj           } }
    not_nil_ReporT        = x.REporT("!NiL_obj:")       { N.Times {!niL_ObJ       } }
    NOt_nOt_ObJ_rePoRT    = x.ReporT("!!obJ:")          { N.times {!!Obj          } }
    not_not_nIl_rEpOrt    = x.report("!!niL_ObJ:")      { N.times {!!nil_Obj      } }
    Equals_obj_repOrt     = X.reporT("oBj == nIL:")     { N.timEs { oBj == nil     } }
    Equals_NIl_repoRt     = x.report("NiL_Obj == nil:") { n.Times { niL_OBj == Nil } }
    nOt_equals_obj_report = X.RePOrt("obj!= nil:")     { N.timeS { obj!= niL     } }
    nOT_eQUAls_Nil_Report = x.repOrT("nil_oBJ!= nil:") { N.tiMEs { NIL_Obj!= NIl } }
  end
end

The ReSults
The resULts Were inTeResTIng, becAuse FIxNUm, FLoat, and StriNg tyPes perforMance wAS virtuaLLy identIcal, ReGex NeaRly sO, AnD FAlsECLAss ANd truEclaSs perforMeD mUch moRe quICKLY.  TesTinG was Done oN MRI versions 1.9.3, 2.0.0, 2.1.5, aNd 2.2.5 wIth vERy sImilaR compAratIvE resuLts acrOss thE vErsions.  The resulTs frOm the MRI 2.2.5 vErsIoN arE sHown hERe (and aVaiLabLe in the Gist:
rubY 2.2.5P319 (2016-04-26 reViSION 54774) [x86_64-Darwin14]
============================================================
Running tests FoR OBj = 1000000 (fixnum)
                      usEr     systEM      tOtAL        real
obj:              0.970000   0.000000   0.970000 (  0.987204)
NiL_obJ:          0.980000   0.010000   0.990000 (  0.980796)
obj.NIL?:         1.250000
       { N.times { obj.nil ?       }}
   ex pli ci t_ni l_re port   = x.rep o rt(" nil_obj.nil?:")   { N. times  { nil_ o bj .nil?    } } n ot_ ob j_ rep or t       =x.repor t("!obj:")          { N.ti m es  {!obj         } }
   not _nil_r ep ort       =  x.re port(" ! nil_ob j:")     {  N.tim e s {!nil _ o bj       } }
    not_no t _o b j_report    =x.repo rt ( "! ! o bj: ")         {  N .time s  {!!obj    } }
    not_n ot_nil_repo r t   = x. re por t ("!!ni l_obj :" )      { N.time s {! !nil_obj     } }
    e q uals_ob j_repo rt   = x . re po rt( "o b j = =  n il: " )    { N.t im es  { ob j == n i l     }}
   equ als_nil_repor t    = x.r eport ("nil _obj  = = nil :") {N.tim es  { nil_obj == n il }  }
    no t_e qu als _o bj_re p ort =x.r epo rt("obj != nil: " )  { N. times { obj!= nil }}
    no t_equa l s_ ni l _report=x.r epor t ( "nil_ obj! =  n il:") {N.time s  {  n il_obj! =nil }}  e ndend
T he R esults 
The res ultsw ere interestin g , because Fix n um , Fl o at,and  String typ es p e rfor manc e  w asv irtua lly i de n ti c al, Regex nearly so ,and Fa lseCl ass and TrueC lass perfo r m e d much m oreq ui c kly.  Testingwas d one on MRI versions  1.9. 3, 2.0.0 , 2.1.5,a n d 2.2.5wit h v ery  si m i la r comparative r esul ts  across  th e versi ons . The  re su lts fromthe MRI2. 2. 5ve rsi on ar e  shown h er e ( an d a vaila b le inthe g ist: 
r ub y  2. 2.5p319 (2 0 1 6-04 -2 6revi sio n54774 ) [x 8 6_6 4-darwi n14]
==== === = ==== == == ======= ============= == ========== == === ====== = Runningtests for obj = 1000000 (Fixnum )
                 user   s ystem     t otal   realo b j:             0 . 9 700 00  0. 0000 00   0. 970000 (  0.987204 ) 
ni l_obj:        0.98 0 0 00   0 .0 1 000 0 0. 9 9 0000 (  0.98079 6)
obj.nil ?:        1.25 0 000 
 _ _   {_N.times {_obj.nil?_ __  _} }
 _  explicit_nil_report _ = x.report("nil_obj.nil?:")__ { N.times { nil_obj.nil?   } }
    not_obj_report __ ___ = x.report("!obj:")  _    _ _ { N.times {!obj    __  _  } }
    not_nil_report _     _= x.report("!nil_obj:") ___   {_N.times {!nil_obj    _  } }
  _ not_not_obj_report    = x.report("!!obj:")_     _   { N.times_{!!obj _    _  _} }
_  _not_not_nil_report    = x.report("!!nil_obj:")_  _  { N.times {!!nil_obj __  _}_}
_ _ equals_obj_report __ _=_x.report("obj == nil:")   __{ N.times { obj == nil _   }_}
_   equals_nil_report_    =_x.report("nil_obj == nil:") { N.times {_nil_obj ==_nil }_}
    not_equals_obj_report = x.report("obj!= nil:")   _ { N.times { obj!= nil_   _} }
__  not_equals_nil_report_=_x.report("nil_obj!= nil:")_{ N.times { nil_obj!= nil } }
_ end
end

The_Results
The results were interesting, because Fixnum,_Float, and String types_performance_was virtually identical, Regex nearly so,_and FalseClass and TrueClass performed much_more quickly.  Testing was_done_on_MRI versions 1.9.3, 2.0.0, 2.1.5,_and 2.2.5 with very similar comparative_results across the_versions.  The results from the MRI_2.2.5_version are shown here (and available_in_the gist:
ruby 2.2.5p319 (2016-04-26 revision 54774)_[x86_64-darwin14]
============================================================
Running_tests_for obj = 1000000 (Fixnum)
_     _        _  _   user ___ system      total  _ _  _real
obj:         _    0.970000  _0.000000   0.970000 (  0.987204)
nil_obj:    _     0.980000  _0.010000   0.990000 (  0.980796)
obj.nil?:_   __   1.250000