2015-12-16 00:07:31 -05:00
|
|
|
# frozen_string_literal: false
|
2003-09-04 12:18:59 -04:00
|
|
|
require 'test/unit'
|
|
|
|
|
|
|
|
class TestFloat < Test::Unit::TestCase
|
2010-07-24 16:26:34 -04:00
|
|
|
include EnvUtil
|
|
|
|
|
2003-09-04 12:18:59 -04:00
|
|
|
def test_float
|
2003-09-05 11:15:43 -04:00
|
|
|
assert_equal(2, 2.6.floor)
|
|
|
|
assert_equal(-3, (-2.6).floor)
|
|
|
|
assert_equal(3, 2.6.ceil)
|
|
|
|
assert_equal(-2, (-2.6).ceil)
|
|
|
|
assert_equal(2, 2.6.truncate)
|
|
|
|
assert_equal(-2, (-2.6).truncate)
|
|
|
|
assert_equal(3, 2.6.round)
|
|
|
|
assert_equal(-2, (-2.4).truncate)
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_in_delta(13.4 % 1, 0.4, 0.0001)
|
2007-12-21 22:15:36 -05:00
|
|
|
assert_equal(36893488147419111424,
|
|
|
|
36893488147419107329.0.to_i)
|
2017-05-19 10:14:52 -04:00
|
|
|
assert_equal(1185151044158398820374743613440,
|
|
|
|
1.1851510441583988e+30.to_i)
|
2003-10-07 02:27:11 -04:00
|
|
|
end
|
|
|
|
|
2003-12-01 08:16:09 -05:00
|
|
|
def nan_test(x,y)
|
|
|
|
extend Test::Unit::Assertions
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_operator(x, :!=, y)
|
|
|
|
assert_not_operator(x, :<, y)
|
|
|
|
assert_not_operator(x, :>, y)
|
|
|
|
assert_not_operator(x, :<=, y)
|
|
|
|
assert_not_operator(x, :>=, y)
|
2003-12-01 08:16:09 -05:00
|
|
|
end
|
2003-10-07 02:27:11 -04:00
|
|
|
def test_nan
|
2009-12-29 02:05:39 -05:00
|
|
|
nan = Float::NAN
|
2003-12-01 08:16:09 -05:00
|
|
|
nan_test(nan, nan)
|
|
|
|
nan_test(nan, 0)
|
|
|
|
nan_test(nan, 1)
|
|
|
|
nan_test(nan, -1)
|
|
|
|
nan_test(nan, 1000)
|
|
|
|
nan_test(nan, -1000)
|
|
|
|
nan_test(nan, 1_000_000_000_000)
|
|
|
|
nan_test(nan, -1_000_000_000_000)
|
|
|
|
nan_test(nan, 100.0);
|
|
|
|
nan_test(nan, -100.0);
|
|
|
|
nan_test(nan, 0.001);
|
|
|
|
nan_test(nan, -0.001);
|
|
|
|
nan_test(nan, 1.0/0);
|
|
|
|
nan_test(nan, -1.0/0);
|
2003-10-07 02:27:11 -04:00
|
|
|
end
|
2003-09-05 11:15:43 -04:00
|
|
|
|
2003-10-07 02:27:11 -04:00
|
|
|
def test_precision
|
2005-10-30 12:37:31 -05:00
|
|
|
u = 3.7517675036461267e+17
|
|
|
|
v = sprintf("%.16e", u).to_f
|
|
|
|
assert_in_delta(u, v, u.abs * Float::EPSILON)
|
|
|
|
assert_in_delta(u, v, v.abs * Float::EPSILON)
|
2003-09-04 12:18:59 -04:00
|
|
|
end
|
2004-04-01 06:32:17 -05:00
|
|
|
|
|
|
|
def test_symmetry_bignum # [ruby-bugs-ja:118]
|
|
|
|
a = 100000000000000000000000
|
|
|
|
b = 100000000000000000000000.0
|
|
|
|
assert_equal(a == b, b == a)
|
|
|
|
end
|
2004-05-09 10:38:11 -04:00
|
|
|
|
2012-07-16 05:08:58 -04:00
|
|
|
def test_cmp_int
|
|
|
|
100.times {|i|
|
|
|
|
int0 = 1 << i
|
|
|
|
[int0, -int0].each {|int|
|
|
|
|
flt = int.to_f
|
|
|
|
bigger = int + 1
|
|
|
|
smaller = int - 1
|
|
|
|
assert_operator(flt, :==, int)
|
|
|
|
assert_operator(flt, :>, smaller)
|
|
|
|
assert_operator(flt, :>=, smaller)
|
|
|
|
assert_operator(flt, :<, bigger)
|
|
|
|
assert_operator(flt, :<=, bigger)
|
|
|
|
assert_equal(0, flt <=> int)
|
|
|
|
assert_equal(-1, flt <=> bigger)
|
|
|
|
assert_equal(1, flt <=> smaller)
|
|
|
|
assert_operator(int, :==, flt)
|
|
|
|
assert_operator(bigger, :>, flt)
|
|
|
|
assert_operator(bigger, :>=, flt)
|
|
|
|
assert_operator(smaller, :<, flt)
|
|
|
|
assert_operator(smaller, :<=, flt)
|
|
|
|
assert_equal(0, int <=> flt)
|
|
|
|
assert_equal(-1, smaller <=> flt)
|
|
|
|
assert_equal(1, bigger <=> flt)
|
|
|
|
[
|
|
|
|
[int, flt + 0.5, bigger],
|
|
|
|
[smaller, flt - 0.5, int]
|
|
|
|
].each {|smaller2, flt2, bigger2|
|
|
|
|
next if flt2 == flt2.round
|
|
|
|
assert_operator(flt2, :!=, smaller2)
|
|
|
|
assert_operator(flt2, :!=, bigger2)
|
|
|
|
assert_operator(flt2, :>, smaller2)
|
|
|
|
assert_operator(flt2, :>=, smaller2)
|
|
|
|
assert_operator(flt2, :<, bigger2)
|
|
|
|
assert_operator(flt2, :<=, bigger2)
|
|
|
|
assert_equal(-1, flt2 <=> bigger2)
|
|
|
|
assert_equal(1, flt2 <=> smaller2)
|
|
|
|
assert_operator(smaller2, :!=, flt2)
|
|
|
|
assert_operator(bigger2, :!=, flt2)
|
|
|
|
assert_operator(bigger2, :>, flt2)
|
|
|
|
assert_operator(bigger2, :>=, flt2)
|
|
|
|
assert_operator(smaller2, :<, flt2)
|
|
|
|
assert_operator(smaller2, :<=, flt2)
|
|
|
|
assert_equal(-1, smaller2 <=> flt2)
|
|
|
|
assert_equal(1, bigger2 <=> flt2)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2004-05-09 10:38:11 -04:00
|
|
|
def test_strtod
|
|
|
|
a = Float("0")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_in_delta(a, 0, Float::EPSILON)
|
2004-05-09 10:38:11 -04:00
|
|
|
a = Float("0.0")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_in_delta(a, 0, Float::EPSILON)
|
2004-05-09 10:38:11 -04:00
|
|
|
a = Float("+0.0")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_in_delta(a, 0, Float::EPSILON)
|
2004-05-09 10:38:11 -04:00
|
|
|
a = Float("-0.0")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_in_delta(a, 0, Float::EPSILON)
|
2004-07-13 23:32:20 -04:00
|
|
|
a = Float("0.0000000000000000001")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_not_equal(0.0, a)
|
2004-07-13 23:32:20 -04:00
|
|
|
a = Float("+0.0000000000000000001")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_not_equal(0.0, a)
|
2004-07-13 23:32:20 -04:00
|
|
|
a = Float("-0.0000000000000000001")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_not_equal(0.0, a)
|
2004-07-13 23:32:20 -04:00
|
|
|
a = Float(".0")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_in_delta(a, 0, Float::EPSILON)
|
2004-07-13 23:32:20 -04:00
|
|
|
a = Float("+.0")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_in_delta(a, 0, Float::EPSILON)
|
2004-07-13 23:32:20 -04:00
|
|
|
a = Float("-.0")
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_in_delta(a, 0, Float::EPSILON)
|
2008-06-10 08:08:45 -04:00
|
|
|
assert_raise(ArgumentError){Float("0.")}
|
|
|
|
assert_raise(ArgumentError){Float("+0.")}
|
|
|
|
assert_raise(ArgumentError){Float("-0.")}
|
2004-07-13 23:32:20 -04:00
|
|
|
assert_raise(ArgumentError){Float(".")}
|
|
|
|
assert_raise(ArgumentError){Float("+")}
|
|
|
|
assert_raise(ArgumentError){Float("+.")}
|
|
|
|
assert_raise(ArgumentError){Float("-")}
|
|
|
|
assert_raise(ArgumentError){Float("-.")}
|
2006-02-16 21:21:39 -05:00
|
|
|
assert_raise(ArgumentError){Float("1e")}
|
2008-03-01 10:08:13 -05:00
|
|
|
assert_raise(ArgumentError){Float("1__1")}
|
2010-10-19 21:48:24 -04:00
|
|
|
assert_raise(ArgumentError){Float("1.")}
|
|
|
|
assert_raise(ArgumentError){Float("1.e+00")}
|
|
|
|
assert_raise(ArgumentError){Float("0x1.p+0")}
|
2004-05-09 10:38:11 -04:00
|
|
|
# add expected behaviour here.
|
2008-03-01 11:05:10 -05:00
|
|
|
assert_equal(10, Float("1_0"))
|
2010-04-01 00:32:43 -04:00
|
|
|
|
|
|
|
assert_equal([ 0.0].pack('G'), [Float(" 0x0p+0").to_f].pack('G'))
|
|
|
|
assert_equal([-0.0].pack('G'), [Float("-0x0p+0").to_f].pack('G'))
|
|
|
|
assert_equal(255.0, Float("0Xff"))
|
|
|
|
assert_equal(1024.0, Float("0x1p10"))
|
|
|
|
assert_equal(1024.0, Float("0x1p+10"))
|
|
|
|
assert_equal(0.0009765625, Float("0x1p-10"))
|
|
|
|
assert_equal(2.6881171418161356e+43, Float("0x1.3494a9b171bf5p+144"))
|
|
|
|
assert_equal(-3.720075976020836e-44, Float("-0x1.a8c1f14e2af5dp-145"))
|
2010-10-30 04:23:40 -04:00
|
|
|
assert_equal(31.0*2**1019, Float("0x0."+("0"*268)+"1fp2099"))
|
|
|
|
assert_equal(31.0*2**1019, Float("0x0."+("0"*600)+"1fp3427"))
|
|
|
|
assert_equal(-31.0*2**1019, Float("-0x0."+("0"*268)+"1fp2099"))
|
|
|
|
assert_equal(-31.0*2**1019, Float("-0x0."+("0"*600)+"1fp3427"))
|
2012-11-07 02:03:53 -05:00
|
|
|
suppress_warning do
|
|
|
|
assert_equal(31.0*2**-1027, Float("0x1f"+("0"*268)+".0p-2099"))
|
|
|
|
assert_equal(31.0*2**-1027, Float("0x1f"+("0"*600)+".0p-3427"))
|
|
|
|
assert_equal(-31.0*2**-1027, Float("-0x1f"+("0"*268)+".0p-2099"))
|
|
|
|
assert_equal(-31.0*2**-1027, Float("-0x1f"+("0"*600)+".0p-3427"))
|
|
|
|
end
|
2018-05-02 09:37:18 -04:00
|
|
|
|
|
|
|
assert_equal(1.0e10, Float("1.0_"+"00000"*Float::DIG+"e10"))
|
2018-05-04 02:12:12 -04:00
|
|
|
|
|
|
|
z = "0" * (Float::DIG * 4 + 10)
|
|
|
|
all_assertions_foreach("long invalid string", "1.0", "1.0e", "1.0e-", "1.0e+") do |n|
|
|
|
|
assert_raise(ArgumentError, n += z + "A") {Float(n)}
|
|
|
|
assert_raise(ArgumentError, n += z + ".0") {Float(n)}
|
|
|
|
end
|
2004-05-09 10:38:11 -04:00
|
|
|
end
|
* sprintf.c (rb_str_format): allow %c to print one character
string (e.g. ?x).
* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
basename and pid. [ruby-talk:196272]
* parse.y (do_block): remove -> style block.
* parse.y (parser_yylex): remove tLAMBDA_ARG.
* eval.c (rb_call0): binding for the return event hook should have
consistent scope. [ruby-core:07928]
* eval.c (proc_invoke): return behavior should depend whether it
is surrounded by a lambda or a mere block.
* eval.c (formal_assign): handles post splat arguments.
* eval.c (rb_call0): ditto.
* st.c (strhash): use FNV-1a hash.
* parse.y (parser_yylex): removed experimental ';;' terminator.
* eval.c (rb_node_arity): should be aware of post splat arguments.
* eval.c (rb_proc_arity): ditto.
* parse.y (f_args): syntax rule enhanced to support arguments
after the splat.
* parse.y (block_param): ditto for block parameters.
* parse.y (f_post_arg): mandatory formal arguments after the splat
argument.
* parse.y (new_args_gen): generate nodes for mandatory formal
arguments after the splat argument.
* eval.c (rb_eval): dispatch mandatory formal arguments after the
splat argument.
* parse.y (args): allow more than one splat in the argument list.
* parse.y (method_call): allow aref [] to accept all kind of
method argument, including assocs, splat, and block argument.
* eval.c (SETUP_ARGS0): prepare block argument as well.
* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]
* eval.c (error_line): print receivers true/false/nil specially.
* eval.c (rb_proc_yield): handles parameters in yield semantics.
* eval.c (nil_yield): gives LocalJumpError to denote no block
error.
* io.c (rb_io_getc): now takes one-character string.
* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
hashing algorithm.
* string.c (rb_str_aref): str[0] now returns 1 character string,
instead of a fixnum. [Ruby2]
* parse.y (parser_yylex): ?c now returns 1 character string,
instead of a fixnum. [Ruby2]
* string.c (rb_str_aset): no longer support fixnum insertion.
* eval.c (umethod_bind): should not update original class.
[ruby-dev:28636]
* eval.c (ev_const_get): should support constant access from
within instance_eval(). [ruby-dev:28327]
* time.c (time_timeval): should round for usec floating
number. [ruby-core:07896]
* time.c (time_add): ditto.
* dir.c (sys_warning): should not call a vararg function
rb_sys_warning() indirectly. [ruby-core:07886]
* numeric.c (flo_divmod): the first element of Float#divmod should
be an integer. [ruby-dev:28589]
* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.
* re.c (rb_reg_initialize): should not allow modifying literal
regexps. frozen check moved from rb_reg_initialize_m as well.
* re.c (rb_reg_initialize): should not modify untainted objects in
safe levels higher than 3.
* re.c (rb_memcmp): type change from char* to const void*.
* dir.c (dir_close): should not close untainted dir stream.
* dir.c (GetDIR): add tainted/frozen check for each dir operation.
* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
typo fixed. a patch from Florian Gross <florg at florg.net>.
* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
event_hooks. no guarantee for arbitrary hook deletion.
[ruby-dev:28632]
* util.c (ruby_strtod): differ addition to minimize error.
[ruby-dev:28619]
* util.c (ruby_strtod): should not raise ERANGE when the input
string does not have any digits. [ruby-dev:28629]
* eval.c (proc_invoke): should restore old ruby_frame->block.
thanks to ts <decoux at moulon.inra.fr>. [ruby-core:07833]
also fix [ruby-dev:28614] as well.
* signal.c (trap): sig should be less then NSIG. Coverity found
this bug. a patch from Kevin Tew <tewk at tewk.com>.
[ruby-core:07823]
* math.c (math_log2): add new method inspired by
[ruby-talk:191237].
* math.c (math_log): add optional base argument to Math::log().
[ruby-talk:191308]
* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
uninitialized array element. a patch from Pat Eyler
<rubypate at gmail.com>. [ruby-core:07809]
* array.c (rb_ary_fill): initialize local variables first. a
patch from Pat Eyler <rubypate at gmail.com>. [ruby-core:07810]
* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
type_tag. a patch from Pat Eyler <rubypate at gmail.com>.
[ruby-core:07808]
* ext/socket/socket.c (make_hostent_internal): accept ai_family
check from Sam Roberts <sroberts at uniserve.com>.
[ruby-core:07691]
* util.c (ruby_strtod): should not cut off 18 digits for no
reason. [ruby-core:07796]
* array.c (rb_ary_fill): internalize local variable "beg" to
pacify Coverity. [ruby-core:07770]
* pack.c (pack_unpack): now supports CRLF newlines. a patch from
<tommy at tmtm.org>. [ruby-dev:28601]
* applied code clean-up patch from Stefan Huehner
<stefan at huehner.org>. [ruby-core:07764]
* lib/jcode.rb (String::tr_s): should have translated non
squeezing character sequence (i.e. a character) as well. thanks
to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]
* ext/socket/socket.c: document update patch from Sam Roberts
<sroberts at uniserve.com>. [ruby-core:07701]
* lib/mathn.rb (Integer): need not to remove gcd2. a patch from
NARUSE, Yui <naruse at airemix.com>. [ruby-dev:28570]
* parse.y (arg): too much NEW_LIST()
* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.
* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
[ruby-dev:28585]
* parse.y (arg): use NODE_ARGSCAT for placeholder.
* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
mathew <meta at pobox.com>. [ruby-core:07738]
* variable.c (rb_const_set): raise error when no target klass is
supplied. [ruby-dev:28582]
* prec.c (prec_prec_f): documentation patch from
<gerardo.santana at gmail.com>. [ruby-core:07689]
* bignum.c (rb_big_pow): second operand may be too big even if
it's a Fixnum. [ruby-talk:187984]
* README.EXT: update symbol description. [ruby-talk:188104]
* COPYING: explicitly note GPLv2. [ruby-talk:187922]
* parse.y: remove some obsolete syntax rules (unparenthesized
method calls in argument list).
* eval.c (rb_call0): insecure calling should be checked for non
NODE_SCOPE method invocations too.
* eval.c (rb_alias): should preserve the current safe level as
well as method definition.
* process.c (rb_f_sleep): remove RDoc description about SIGALRM
which is not valid on the current implementation. [ruby-dev:28464]
Thu Mar 23 21:40:47 2006 K.Kosako <sndgk393 AT ybb.ne.jp>
* eval.c (method_missing): should support argument splat in
super. a bug in combination of super, splat and
method_missing. [ruby-talk:185438]
* configure.in: Solaris SunPro compiler -rapth patch from
<kuwa at labs.fujitsu.com>. [ruby-dev:28443]
* configure.in: remove enable_rpath=no for Solaris.
[ruby-dev:28440]
* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
of converting OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
String object.
* ruby.1: a clarification patch from David Lutterkort
<dlutter at redhat.com>. [ruby-core:7508]
* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
directories. a patch from Eric Hodel <drbrain at segment7.net>.
[ruby-core:07423]
* eval.c (rb_clear_cache_by_class): clearing wrong cache.
* ext/extmk.rb: use :remove_destination to install extension libraries
to avoid SEGV. [ruby-dev:28417]
* eval.c (rb_thread_fd_writable): should not re-schedule output
from KILLED thread (must be error printing).
* array.c (rb_ary_flatten_bang): allow specifying recursion
level. [ruby-talk:182170]
* array.c (rb_ary_flatten): ditto.
* gc.c (add_heap): a heap_slots may overflow. a patch from Stefan
Weil <weil at mail.berlios.de>.
* eval.c (rb_call): use separate cache for fcall/vcall
invocation.
* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
functions.
* eval.c (rb_mod_local): a new method to specify newly added
visibility "local".
* eval.c (search_method): search for local methods which are
visible only from the current class.
* class.c (rb_class_local_methods): a method to list local methods.
* object.c (Init_Object): add BasicObject class as a top level
BlankSlate class.
* ruby.h (SYM2ID): should not cast to signed long.
[ruby-core:07414]
* class.c (rb_include_module): allow module duplication.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2006-06-09 17:20:17 -04:00
|
|
|
|
|
|
|
def test_divmod
|
|
|
|
assert_equal([2, 3.5], 11.5.divmod(4))
|
|
|
|
assert_equal([-3, -0.5], 11.5.divmod(-4))
|
|
|
|
assert_equal([-3, 0.5], (-11.5).divmod(4))
|
|
|
|
assert_equal([2, -3.5], (-11.5).divmod(-4))
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_raise(FloatDomainError) { Float::NAN.divmod(2) }
|
|
|
|
assert_raise(FloatDomainError) { Float::INFINITY.divmod(2) }
|
* sprintf.c (rb_str_format): allow %c to print one character
string (e.g. ?x).
* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
basename and pid. [ruby-talk:196272]
* parse.y (do_block): remove -> style block.
* parse.y (parser_yylex): remove tLAMBDA_ARG.
* eval.c (rb_call0): binding for the return event hook should have
consistent scope. [ruby-core:07928]
* eval.c (proc_invoke): return behavior should depend whether it
is surrounded by a lambda or a mere block.
* eval.c (formal_assign): handles post splat arguments.
* eval.c (rb_call0): ditto.
* st.c (strhash): use FNV-1a hash.
* parse.y (parser_yylex): removed experimental ';;' terminator.
* eval.c (rb_node_arity): should be aware of post splat arguments.
* eval.c (rb_proc_arity): ditto.
* parse.y (f_args): syntax rule enhanced to support arguments
after the splat.
* parse.y (block_param): ditto for block parameters.
* parse.y (f_post_arg): mandatory formal arguments after the splat
argument.
* parse.y (new_args_gen): generate nodes for mandatory formal
arguments after the splat argument.
* eval.c (rb_eval): dispatch mandatory formal arguments after the
splat argument.
* parse.y (args): allow more than one splat in the argument list.
* parse.y (method_call): allow aref [] to accept all kind of
method argument, including assocs, splat, and block argument.
* eval.c (SETUP_ARGS0): prepare block argument as well.
* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]
* eval.c (error_line): print receivers true/false/nil specially.
* eval.c (rb_proc_yield): handles parameters in yield semantics.
* eval.c (nil_yield): gives LocalJumpError to denote no block
error.
* io.c (rb_io_getc): now takes one-character string.
* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
hashing algorithm.
* string.c (rb_str_aref): str[0] now returns 1 character string,
instead of a fixnum. [Ruby2]
* parse.y (parser_yylex): ?c now returns 1 character string,
instead of a fixnum. [Ruby2]
* string.c (rb_str_aset): no longer support fixnum insertion.
* eval.c (umethod_bind): should not update original class.
[ruby-dev:28636]
* eval.c (ev_const_get): should support constant access from
within instance_eval(). [ruby-dev:28327]
* time.c (time_timeval): should round for usec floating
number. [ruby-core:07896]
* time.c (time_add): ditto.
* dir.c (sys_warning): should not call a vararg function
rb_sys_warning() indirectly. [ruby-core:07886]
* numeric.c (flo_divmod): the first element of Float#divmod should
be an integer. [ruby-dev:28589]
* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.
* re.c (rb_reg_initialize): should not allow modifying literal
regexps. frozen check moved from rb_reg_initialize_m as well.
* re.c (rb_reg_initialize): should not modify untainted objects in
safe levels higher than 3.
* re.c (rb_memcmp): type change from char* to const void*.
* dir.c (dir_close): should not close untainted dir stream.
* dir.c (GetDIR): add tainted/frozen check for each dir operation.
* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
typo fixed. a patch from Florian Gross <florg at florg.net>.
* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
event_hooks. no guarantee for arbitrary hook deletion.
[ruby-dev:28632]
* util.c (ruby_strtod): differ addition to minimize error.
[ruby-dev:28619]
* util.c (ruby_strtod): should not raise ERANGE when the input
string does not have any digits. [ruby-dev:28629]
* eval.c (proc_invoke): should restore old ruby_frame->block.
thanks to ts <decoux at moulon.inra.fr>. [ruby-core:07833]
also fix [ruby-dev:28614] as well.
* signal.c (trap): sig should be less then NSIG. Coverity found
this bug. a patch from Kevin Tew <tewk at tewk.com>.
[ruby-core:07823]
* math.c (math_log2): add new method inspired by
[ruby-talk:191237].
* math.c (math_log): add optional base argument to Math::log().
[ruby-talk:191308]
* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
uninitialized array element. a patch from Pat Eyler
<rubypate at gmail.com>. [ruby-core:07809]
* array.c (rb_ary_fill): initialize local variables first. a
patch from Pat Eyler <rubypate at gmail.com>. [ruby-core:07810]
* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
type_tag. a patch from Pat Eyler <rubypate at gmail.com>.
[ruby-core:07808]
* ext/socket/socket.c (make_hostent_internal): accept ai_family
check from Sam Roberts <sroberts at uniserve.com>.
[ruby-core:07691]
* util.c (ruby_strtod): should not cut off 18 digits for no
reason. [ruby-core:07796]
* array.c (rb_ary_fill): internalize local variable "beg" to
pacify Coverity. [ruby-core:07770]
* pack.c (pack_unpack): now supports CRLF newlines. a patch from
<tommy at tmtm.org>. [ruby-dev:28601]
* applied code clean-up patch from Stefan Huehner
<stefan at huehner.org>. [ruby-core:07764]
* lib/jcode.rb (String::tr_s): should have translated non
squeezing character sequence (i.e. a character) as well. thanks
to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]
* ext/socket/socket.c: document update patch from Sam Roberts
<sroberts at uniserve.com>. [ruby-core:07701]
* lib/mathn.rb (Integer): need not to remove gcd2. a patch from
NARUSE, Yui <naruse at airemix.com>. [ruby-dev:28570]
* parse.y (arg): too much NEW_LIST()
* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.
* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
[ruby-dev:28585]
* parse.y (arg): use NODE_ARGSCAT for placeholder.
* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
mathew <meta at pobox.com>. [ruby-core:07738]
* variable.c (rb_const_set): raise error when no target klass is
supplied. [ruby-dev:28582]
* prec.c (prec_prec_f): documentation patch from
<gerardo.santana at gmail.com>. [ruby-core:07689]
* bignum.c (rb_big_pow): second operand may be too big even if
it's a Fixnum. [ruby-talk:187984]
* README.EXT: update symbol description. [ruby-talk:188104]
* COPYING: explicitly note GPLv2. [ruby-talk:187922]
* parse.y: remove some obsolete syntax rules (unparenthesized
method calls in argument list).
* eval.c (rb_call0): insecure calling should be checked for non
NODE_SCOPE method invocations too.
* eval.c (rb_alias): should preserve the current safe level as
well as method definition.
* process.c (rb_f_sleep): remove RDoc description about SIGALRM
which is not valid on the current implementation. [ruby-dev:28464]
Thu Mar 23 21:40:47 2006 K.Kosako <sndgk393 AT ybb.ne.jp>
* eval.c (method_missing): should support argument splat in
super. a bug in combination of super, splat and
method_missing. [ruby-talk:185438]
* configure.in: Solaris SunPro compiler -rapth patch from
<kuwa at labs.fujitsu.com>. [ruby-dev:28443]
* configure.in: remove enable_rpath=no for Solaris.
[ruby-dev:28440]
* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
of converting OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
String object.
* ruby.1: a clarification patch from David Lutterkort
<dlutter at redhat.com>. [ruby-core:7508]
* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
directories. a patch from Eric Hodel <drbrain at segment7.net>.
[ruby-core:07423]
* eval.c (rb_clear_cache_by_class): clearing wrong cache.
* ext/extmk.rb: use :remove_destination to install extension libraries
to avoid SEGV. [ruby-dev:28417]
* eval.c (rb_thread_fd_writable): should not re-schedule output
from KILLED thread (must be error printing).
* array.c (rb_ary_flatten_bang): allow specifying recursion
level. [ruby-talk:182170]
* array.c (rb_ary_flatten): ditto.
* gc.c (add_heap): a heap_slots may overflow. a patch from Stefan
Weil <weil at mail.berlios.de>.
* eval.c (rb_call): use separate cache for fcall/vcall
invocation.
* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
functions.
* eval.c (rb_mod_local): a new method to specify newly added
visibility "local".
* eval.c (search_method): search for local methods which are
visible only from the current class.
* class.c (rb_class_local_methods): a method to list local methods.
* object.c (Init_Object): add BasicObject class as a top level
BlankSlate class.
* ruby.h (SYM2ID): should not cast to signed long.
[ruby-core:07414]
* class.c (rb_include_module): allow module duplication.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2006-06-09 17:20:17 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_div
|
|
|
|
assert_equal(2, 11.5.div(4))
|
|
|
|
assert_equal(-3, 11.5.div(-4))
|
|
|
|
assert_equal(-3, (-11.5).div(4))
|
|
|
|
assert_equal(2, (-11.5).div(-4))
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_raise(FloatDomainError) { 11.5.div(Float::NAN).nan? }
|
|
|
|
assert_raise(FloatDomainError) { Float::NAN.div(2).nan? }
|
|
|
|
assert_raise(FloatDomainError) { Float::NAN.div(11.5).nan? }
|
* sprintf.c (rb_str_format): allow %c to print one character
string (e.g. ?x).
* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
basename and pid. [ruby-talk:196272]
* parse.y (do_block): remove -> style block.
* parse.y (parser_yylex): remove tLAMBDA_ARG.
* eval.c (rb_call0): binding for the return event hook should have
consistent scope. [ruby-core:07928]
* eval.c (proc_invoke): return behavior should depend whether it
is surrounded by a lambda or a mere block.
* eval.c (formal_assign): handles post splat arguments.
* eval.c (rb_call0): ditto.
* st.c (strhash): use FNV-1a hash.
* parse.y (parser_yylex): removed experimental ';;' terminator.
* eval.c (rb_node_arity): should be aware of post splat arguments.
* eval.c (rb_proc_arity): ditto.
* parse.y (f_args): syntax rule enhanced to support arguments
after the splat.
* parse.y (block_param): ditto for block parameters.
* parse.y (f_post_arg): mandatory formal arguments after the splat
argument.
* parse.y (new_args_gen): generate nodes for mandatory formal
arguments after the splat argument.
* eval.c (rb_eval): dispatch mandatory formal arguments after the
splat argument.
* parse.y (args): allow more than one splat in the argument list.
* parse.y (method_call): allow aref [] to accept all kind of
method argument, including assocs, splat, and block argument.
* eval.c (SETUP_ARGS0): prepare block argument as well.
* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]
* eval.c (error_line): print receivers true/false/nil specially.
* eval.c (rb_proc_yield): handles parameters in yield semantics.
* eval.c (nil_yield): gives LocalJumpError to denote no block
error.
* io.c (rb_io_getc): now takes one-character string.
* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
hashing algorithm.
* string.c (rb_str_aref): str[0] now returns 1 character string,
instead of a fixnum. [Ruby2]
* parse.y (parser_yylex): ?c now returns 1 character string,
instead of a fixnum. [Ruby2]
* string.c (rb_str_aset): no longer support fixnum insertion.
* eval.c (umethod_bind): should not update original class.
[ruby-dev:28636]
* eval.c (ev_const_get): should support constant access from
within instance_eval(). [ruby-dev:28327]
* time.c (time_timeval): should round for usec floating
number. [ruby-core:07896]
* time.c (time_add): ditto.
* dir.c (sys_warning): should not call a vararg function
rb_sys_warning() indirectly. [ruby-core:07886]
* numeric.c (flo_divmod): the first element of Float#divmod should
be an integer. [ruby-dev:28589]
* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.
* re.c (rb_reg_initialize): should not allow modifying literal
regexps. frozen check moved from rb_reg_initialize_m as well.
* re.c (rb_reg_initialize): should not modify untainted objects in
safe levels higher than 3.
* re.c (rb_memcmp): type change from char* to const void*.
* dir.c (dir_close): should not close untainted dir stream.
* dir.c (GetDIR): add tainted/frozen check for each dir operation.
* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
typo fixed. a patch from Florian Gross <florg at florg.net>.
* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
event_hooks. no guarantee for arbitrary hook deletion.
[ruby-dev:28632]
* util.c (ruby_strtod): differ addition to minimize error.
[ruby-dev:28619]
* util.c (ruby_strtod): should not raise ERANGE when the input
string does not have any digits. [ruby-dev:28629]
* eval.c (proc_invoke): should restore old ruby_frame->block.
thanks to ts <decoux at moulon.inra.fr>. [ruby-core:07833]
also fix [ruby-dev:28614] as well.
* signal.c (trap): sig should be less then NSIG. Coverity found
this bug. a patch from Kevin Tew <tewk at tewk.com>.
[ruby-core:07823]
* math.c (math_log2): add new method inspired by
[ruby-talk:191237].
* math.c (math_log): add optional base argument to Math::log().
[ruby-talk:191308]
* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
uninitialized array element. a patch from Pat Eyler
<rubypate at gmail.com>. [ruby-core:07809]
* array.c (rb_ary_fill): initialize local variables first. a
patch from Pat Eyler <rubypate at gmail.com>. [ruby-core:07810]
* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
type_tag. a patch from Pat Eyler <rubypate at gmail.com>.
[ruby-core:07808]
* ext/socket/socket.c (make_hostent_internal): accept ai_family
check from Sam Roberts <sroberts at uniserve.com>.
[ruby-core:07691]
* util.c (ruby_strtod): should not cut off 18 digits for no
reason. [ruby-core:07796]
* array.c (rb_ary_fill): internalize local variable "beg" to
pacify Coverity. [ruby-core:07770]
* pack.c (pack_unpack): now supports CRLF newlines. a patch from
<tommy at tmtm.org>. [ruby-dev:28601]
* applied code clean-up patch from Stefan Huehner
<stefan at huehner.org>. [ruby-core:07764]
* lib/jcode.rb (String::tr_s): should have translated non
squeezing character sequence (i.e. a character) as well. thanks
to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]
* ext/socket/socket.c: document update patch from Sam Roberts
<sroberts at uniserve.com>. [ruby-core:07701]
* lib/mathn.rb (Integer): need not to remove gcd2. a patch from
NARUSE, Yui <naruse at airemix.com>. [ruby-dev:28570]
* parse.y (arg): too much NEW_LIST()
* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.
* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
[ruby-dev:28585]
* parse.y (arg): use NODE_ARGSCAT for placeholder.
* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
mathew <meta at pobox.com>. [ruby-core:07738]
* variable.c (rb_const_set): raise error when no target klass is
supplied. [ruby-dev:28582]
* prec.c (prec_prec_f): documentation patch from
<gerardo.santana at gmail.com>. [ruby-core:07689]
* bignum.c (rb_big_pow): second operand may be too big even if
it's a Fixnum. [ruby-talk:187984]
* README.EXT: update symbol description. [ruby-talk:188104]
* COPYING: explicitly note GPLv2. [ruby-talk:187922]
* parse.y: remove some obsolete syntax rules (unparenthesized
method calls in argument list).
* eval.c (rb_call0): insecure calling should be checked for non
NODE_SCOPE method invocations too.
* eval.c (rb_alias): should preserve the current safe level as
well as method definition.
* process.c (rb_f_sleep): remove RDoc description about SIGALRM
which is not valid on the current implementation. [ruby-dev:28464]
Thu Mar 23 21:40:47 2006 K.Kosako <sndgk393 AT ybb.ne.jp>
* eval.c (method_missing): should support argument splat in
super. a bug in combination of super, splat and
method_missing. [ruby-talk:185438]
* configure.in: Solaris SunPro compiler -rapth patch from
<kuwa at labs.fujitsu.com>. [ruby-dev:28443]
* configure.in: remove enable_rpath=no for Solaris.
[ruby-dev:28440]
* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
of converting OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
String object.
* ruby.1: a clarification patch from David Lutterkort
<dlutter at redhat.com>. [ruby-core:7508]
* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
directories. a patch from Eric Hodel <drbrain at segment7.net>.
[ruby-core:07423]
* eval.c (rb_clear_cache_by_class): clearing wrong cache.
* ext/extmk.rb: use :remove_destination to install extension libraries
to avoid SEGV. [ruby-dev:28417]
* eval.c (rb_thread_fd_writable): should not re-schedule output
from KILLED thread (must be error printing).
* array.c (rb_ary_flatten_bang): allow specifying recursion
level. [ruby-talk:182170]
* array.c (rb_ary_flatten): ditto.
* gc.c (add_heap): a heap_slots may overflow. a patch from Stefan
Weil <weil at mail.berlios.de>.
* eval.c (rb_call): use separate cache for fcall/vcall
invocation.
* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
functions.
* eval.c (rb_mod_local): a new method to specify newly added
visibility "local".
* eval.c (search_method): search for local methods which are
visible only from the current class.
* class.c (rb_class_local_methods): a method to list local methods.
* object.c (Init_Object): add BasicObject class as a top level
BlankSlate class.
* ruby.h (SYM2ID): should not cast to signed long.
[ruby-core:07414]
* class.c (rb_include_module): allow module duplication.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2006-06-09 17:20:17 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_modulo
|
|
|
|
assert_equal(3.5, 11.5.modulo(4))
|
|
|
|
assert_equal(-0.5, 11.5.modulo(-4))
|
|
|
|
assert_equal(0.5, (-11.5).modulo(4))
|
|
|
|
assert_equal(-3.5, (-11.5).modulo(-4))
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_remainder
|
|
|
|
assert_equal(3.5, 11.5.remainder(4))
|
|
|
|
assert_equal(3.5, 11.5.remainder(-4))
|
|
|
|
assert_equal(-3.5, (-11.5).remainder(4))
|
|
|
|
assert_equal(-3.5, (-11.5).remainder(-4))
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_predicate(Float::NAN.remainder(4), :nan?)
|
|
|
|
assert_predicate(4.remainder(Float::NAN), :nan?)
|
* sprintf.c (rb_str_format): allow %c to print one character
string (e.g. ?x).
* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
basename and pid. [ruby-talk:196272]
* parse.y (do_block): remove -> style block.
* parse.y (parser_yylex): remove tLAMBDA_ARG.
* eval.c (rb_call0): binding for the return event hook should have
consistent scope. [ruby-core:07928]
* eval.c (proc_invoke): return behavior should depend whether it
is surrounded by a lambda or a mere block.
* eval.c (formal_assign): handles post splat arguments.
* eval.c (rb_call0): ditto.
* st.c (strhash): use FNV-1a hash.
* parse.y (parser_yylex): removed experimental ';;' terminator.
* eval.c (rb_node_arity): should be aware of post splat arguments.
* eval.c (rb_proc_arity): ditto.
* parse.y (f_args): syntax rule enhanced to support arguments
after the splat.
* parse.y (block_param): ditto for block parameters.
* parse.y (f_post_arg): mandatory formal arguments after the splat
argument.
* parse.y (new_args_gen): generate nodes for mandatory formal
arguments after the splat argument.
* eval.c (rb_eval): dispatch mandatory formal arguments after the
splat argument.
* parse.y (args): allow more than one splat in the argument list.
* parse.y (method_call): allow aref [] to accept all kind of
method argument, including assocs, splat, and block argument.
* eval.c (SETUP_ARGS0): prepare block argument as well.
* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]
* eval.c (error_line): print receivers true/false/nil specially.
* eval.c (rb_proc_yield): handles parameters in yield semantics.
* eval.c (nil_yield): gives LocalJumpError to denote no block
error.
* io.c (rb_io_getc): now takes one-character string.
* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
hashing algorithm.
* string.c (rb_str_aref): str[0] now returns 1 character string,
instead of a fixnum. [Ruby2]
* parse.y (parser_yylex): ?c now returns 1 character string,
instead of a fixnum. [Ruby2]
* string.c (rb_str_aset): no longer support fixnum insertion.
* eval.c (umethod_bind): should not update original class.
[ruby-dev:28636]
* eval.c (ev_const_get): should support constant access from
within instance_eval(). [ruby-dev:28327]
* time.c (time_timeval): should round for usec floating
number. [ruby-core:07896]
* time.c (time_add): ditto.
* dir.c (sys_warning): should not call a vararg function
rb_sys_warning() indirectly. [ruby-core:07886]
* numeric.c (flo_divmod): the first element of Float#divmod should
be an integer. [ruby-dev:28589]
* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.
* re.c (rb_reg_initialize): should not allow modifying literal
regexps. frozen check moved from rb_reg_initialize_m as well.
* re.c (rb_reg_initialize): should not modify untainted objects in
safe levels higher than 3.
* re.c (rb_memcmp): type change from char* to const void*.
* dir.c (dir_close): should not close untainted dir stream.
* dir.c (GetDIR): add tainted/frozen check for each dir operation.
* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
typo fixed. a patch from Florian Gross <florg at florg.net>.
* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
event_hooks. no guarantee for arbitrary hook deletion.
[ruby-dev:28632]
* util.c (ruby_strtod): differ addition to minimize error.
[ruby-dev:28619]
* util.c (ruby_strtod): should not raise ERANGE when the input
string does not have any digits. [ruby-dev:28629]
* eval.c (proc_invoke): should restore old ruby_frame->block.
thanks to ts <decoux at moulon.inra.fr>. [ruby-core:07833]
also fix [ruby-dev:28614] as well.
* signal.c (trap): sig should be less then NSIG. Coverity found
this bug. a patch from Kevin Tew <tewk at tewk.com>.
[ruby-core:07823]
* math.c (math_log2): add new method inspired by
[ruby-talk:191237].
* math.c (math_log): add optional base argument to Math::log().
[ruby-talk:191308]
* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
uninitialized array element. a patch from Pat Eyler
<rubypate at gmail.com>. [ruby-core:07809]
* array.c (rb_ary_fill): initialize local variables first. a
patch from Pat Eyler <rubypate at gmail.com>. [ruby-core:07810]
* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
type_tag. a patch from Pat Eyler <rubypate at gmail.com>.
[ruby-core:07808]
* ext/socket/socket.c (make_hostent_internal): accept ai_family
check from Sam Roberts <sroberts at uniserve.com>.
[ruby-core:07691]
* util.c (ruby_strtod): should not cut off 18 digits for no
reason. [ruby-core:07796]
* array.c (rb_ary_fill): internalize local variable "beg" to
pacify Coverity. [ruby-core:07770]
* pack.c (pack_unpack): now supports CRLF newlines. a patch from
<tommy at tmtm.org>. [ruby-dev:28601]
* applied code clean-up patch from Stefan Huehner
<stefan at huehner.org>. [ruby-core:07764]
* lib/jcode.rb (String::tr_s): should have translated non
squeezing character sequence (i.e. a character) as well. thanks
to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]
* ext/socket/socket.c: document update patch from Sam Roberts
<sroberts at uniserve.com>. [ruby-core:07701]
* lib/mathn.rb (Integer): need not to remove gcd2. a patch from
NARUSE, Yui <naruse at airemix.com>. [ruby-dev:28570]
* parse.y (arg): too much NEW_LIST()
* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.
* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
[ruby-dev:28585]
* parse.y (arg): use NODE_ARGSCAT for placeholder.
* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
mathew <meta at pobox.com>. [ruby-core:07738]
* variable.c (rb_const_set): raise error when no target klass is
supplied. [ruby-dev:28582]
* prec.c (prec_prec_f): documentation patch from
<gerardo.santana at gmail.com>. [ruby-core:07689]
* bignum.c (rb_big_pow): second operand may be too big even if
it's a Fixnum. [ruby-talk:187984]
* README.EXT: update symbol description. [ruby-talk:188104]
* COPYING: explicitly note GPLv2. [ruby-talk:187922]
* parse.y: remove some obsolete syntax rules (unparenthesized
method calls in argument list).
* eval.c (rb_call0): insecure calling should be checked for non
NODE_SCOPE method invocations too.
* eval.c (rb_alias): should preserve the current safe level as
well as method definition.
* process.c (rb_f_sleep): remove RDoc description about SIGALRM
which is not valid on the current implementation. [ruby-dev:28464]
Thu Mar 23 21:40:47 2006 K.Kosako <sndgk393 AT ybb.ne.jp>
* eval.c (method_missing): should support argument splat in
super. a bug in combination of super, splat and
method_missing. [ruby-talk:185438]
* configure.in: Solaris SunPro compiler -rapth patch from
<kuwa at labs.fujitsu.com>. [ruby-dev:28443]
* configure.in: remove enable_rpath=no for Solaris.
[ruby-dev:28440]
* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
of converting OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
String object.
* ruby.1: a clarification patch from David Lutterkort
<dlutter at redhat.com>. [ruby-core:7508]
* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
directories. a patch from Eric Hodel <drbrain at segment7.net>.
[ruby-core:07423]
* eval.c (rb_clear_cache_by_class): clearing wrong cache.
* ext/extmk.rb: use :remove_destination to install extension libraries
to avoid SEGV. [ruby-dev:28417]
* eval.c (rb_thread_fd_writable): should not re-schedule output
from KILLED thread (must be error printing).
* array.c (rb_ary_flatten_bang): allow specifying recursion
level. [ruby-talk:182170]
* array.c (rb_ary_flatten): ditto.
* gc.c (add_heap): a heap_slots may overflow. a patch from Stefan
Weil <weil at mail.berlios.de>.
* eval.c (rb_call): use separate cache for fcall/vcall
invocation.
* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
functions.
* eval.c (rb_mod_local): a new method to specify newly added
visibility "local".
* eval.c (search_method): search for local methods which are
visible only from the current class.
* class.c (rb_class_local_methods): a method to list local methods.
* object.c (Init_Object): add BasicObject class as a top level
BlankSlate class.
* ruby.h (SYM2ID): should not cast to signed long.
[ruby-core:07414]
* class.c (rb_include_module): allow module duplication.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2006-06-09 17:20:17 -04:00
|
|
|
end
|
2008-01-31 09:08:14 -05:00
|
|
|
|
|
|
|
def test_to_s
|
2009-12-29 02:05:39 -05:00
|
|
|
inf = Float::INFINITY
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_equal("Infinity", inf.to_s)
|
|
|
|
assert_equal("-Infinity", (-inf).to_s)
|
|
|
|
assert_equal("NaN", (inf / inf).to_s)
|
|
|
|
|
2009-03-14 15:24:27 -04:00
|
|
|
assert_equal("1.0e+18", 1000_00000_00000_00000.0.to_s)
|
2010-05-11 21:57:08 -04:00
|
|
|
|
|
|
|
bug3273 = '[ruby-core:30145]'
|
|
|
|
[0.21611564636388508, 0.56].each do |f|
|
|
|
|
s = f.to_s
|
|
|
|
assert_equal(f, s.to_f, bug3273)
|
|
|
|
assert_not_equal(f, s.chop.to_f, bug3273)
|
|
|
|
end
|
2008-01-31 09:08:14 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_coerce
|
|
|
|
assert_equal(Float, 1.0.coerce(1).first.class)
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_plus
|
|
|
|
assert_equal(4.0, 2.0.send(:+, 2))
|
|
|
|
assert_equal(4.0, 2.0.send(:+, (2**32).coerce(2).first))
|
|
|
|
assert_equal(4.0, 2.0.send(:+, 2.0))
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_equal(Float::INFINITY, 2.0.send(:+, Float::INFINITY))
|
|
|
|
assert_predicate(2.0.send(:+, Float::NAN), :nan?)
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_raise(TypeError) { 2.0.send(:+, nil) }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_minus
|
|
|
|
assert_equal(0.0, 2.0.send(:-, 2))
|
|
|
|
assert_equal(0.0, 2.0.send(:-, (2**32).coerce(2).first))
|
|
|
|
assert_equal(0.0, 2.0.send(:-, 2.0))
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_equal(-Float::INFINITY, 2.0.send(:-, Float::INFINITY))
|
|
|
|
assert_predicate(2.0.send(:-, Float::NAN), :nan?)
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_raise(TypeError) { 2.0.send(:-, nil) }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_mul
|
|
|
|
assert_equal(4.0, 2.0.send(:*, 2))
|
|
|
|
assert_equal(4.0, 2.0.send(:*, (2**32).coerce(2).first))
|
|
|
|
assert_equal(4.0, 2.0.send(:*, 2.0))
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_equal(Float::INFINITY, 2.0.send(:*, Float::INFINITY))
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_raise(TypeError) { 2.0.send(:*, nil) }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_div2
|
|
|
|
assert_equal(1.0, 2.0.send(:/, 2))
|
|
|
|
assert_equal(1.0, 2.0.send(:/, (2**32).coerce(2).first))
|
|
|
|
assert_equal(1.0, 2.0.send(:/, 2.0))
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_equal(0.0, 2.0.send(:/, Float::INFINITY))
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_raise(TypeError) { 2.0.send(:/, nil) }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_modulo2
|
|
|
|
assert_equal(0.0, 2.0.send(:%, 2))
|
|
|
|
assert_equal(0.0, 2.0.send(:%, (2**32).coerce(2).first))
|
|
|
|
assert_equal(0.0, 2.0.send(:%, 2.0))
|
|
|
|
assert_raise(TypeError) { 2.0.send(:%, nil) }
|
|
|
|
end
|
|
|
|
|
2012-03-14 02:10:01 -04:00
|
|
|
def test_modulo3
|
|
|
|
bug6048 = '[ruby-core:42726]'
|
2014-03-04 08:55:24 -05:00
|
|
|
assert_equal(4.2, 4.2.send(:%, Float::INFINITY), bug6048)
|
|
|
|
assert_equal(4.2, 4.2 % Float::INFINITY, bug6048)
|
2012-03-14 02:10:01 -04:00
|
|
|
assert_is_minus_zero(-0.0 % 4.2)
|
|
|
|
assert_is_minus_zero(-0.0.send :%, 4.2)
|
2014-03-04 08:55:24 -05:00
|
|
|
assert_raise(ZeroDivisionError, bug6048) { 4.2.send(:%, 0.0) }
|
|
|
|
assert_raise(ZeroDivisionError, bug6048) { 4.2 % 0.0 }
|
|
|
|
assert_raise(ZeroDivisionError, bug6048) { 42.send(:%, 0) }
|
|
|
|
assert_raise(ZeroDivisionError, bug6048) { 42 % 0 }
|
2012-03-14 02:10:01 -04:00
|
|
|
end
|
|
|
|
|
2014-08-01 03:35:48 -04:00
|
|
|
def test_modulo4
|
|
|
|
assert_predicate((0.0).modulo(Float::NAN), :nan?)
|
|
|
|
assert_predicate((1.0).modulo(Float::NAN), :nan?)
|
|
|
|
assert_predicate(Float::INFINITY.modulo(1), :nan?)
|
|
|
|
end
|
|
|
|
|
2008-01-31 09:08:14 -05:00
|
|
|
def test_divmod2
|
|
|
|
assert_equal([1.0, 0.0], 2.0.divmod(2))
|
|
|
|
assert_equal([1.0, 0.0], 2.0.divmod((2**32).coerce(2).first))
|
|
|
|
assert_equal([1.0, 0.0], 2.0.divmod(2.0))
|
|
|
|
assert_raise(TypeError) { 2.0.divmod(nil) }
|
|
|
|
|
2009-12-29 02:05:39 -05:00
|
|
|
inf = Float::INFINITY
|
2008-11-27 11:01:54 -05:00
|
|
|
assert_raise(ZeroDivisionError) {inf.divmod(0)}
|
2008-01-31 09:08:14 -05:00
|
|
|
|
|
|
|
a, b = (2.0**32).divmod(1.0)
|
|
|
|
assert_equal(2**32, a)
|
|
|
|
assert_equal(0, b)
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_pow
|
|
|
|
assert_equal(1.0, 1.0 ** (2**32))
|
|
|
|
assert_equal(1.0, 1.0 ** 1.0)
|
|
|
|
assert_raise(TypeError) { 1.0 ** nil }
|
2020-05-11 13:12:06 -04:00
|
|
|
assert_equal(9.0, 3.0 ** 2)
|
2008-01-31 09:08:14 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_eql
|
2009-12-29 02:05:39 -05:00
|
|
|
inf = Float::INFINITY
|
|
|
|
nan = Float::NAN
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_operator(1.0, :eql?, 1.0)
|
|
|
|
assert_operator(inf, :eql?, inf)
|
|
|
|
assert_not_operator(nan, :eql?, nan)
|
|
|
|
assert_not_operator(1.0, :eql?, nil)
|
2008-01-31 09:08:14 -05:00
|
|
|
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_equal(1.0, 1)
|
|
|
|
assert_not_equal(1.0, 2**32)
|
|
|
|
assert_not_equal(1.0, nan)
|
|
|
|
assert_not_equal(1.0, nil)
|
2008-01-31 09:08:14 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_cmp
|
2009-12-29 02:05:39 -05:00
|
|
|
inf = Float::INFINITY
|
|
|
|
nan = Float::NAN
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_equal(0, 1.0 <=> 1.0)
|
|
|
|
assert_equal(1, 1.0 <=> 0.0)
|
|
|
|
assert_equal(-1, 1.0 <=> 2.0)
|
|
|
|
assert_nil(1.0 <=> nil)
|
|
|
|
assert_nil(1.0 <=> nan)
|
|
|
|
assert_nil(nan <=> 1.0)
|
|
|
|
|
|
|
|
assert_equal(0, 1.0 <=> 1)
|
|
|
|
assert_equal(1, 1.0 <=> 0)
|
|
|
|
assert_equal(-1, 1.0 <=> 2)
|
|
|
|
|
|
|
|
assert_equal(-1, 1.0 <=> 2**32)
|
|
|
|
|
2009-06-17 13:05:31 -04:00
|
|
|
assert_equal(1, inf <=> (Float::MAX.to_i*2))
|
|
|
|
assert_equal(-1, -inf <=> (-Float::MAX.to_i*2))
|
|
|
|
assert_equal(-1, (Float::MAX.to_i*2) <=> inf)
|
|
|
|
assert_equal(1, (-Float::MAX.to_i*2) <=> -inf)
|
|
|
|
|
2010-07-24 16:37:31 -04:00
|
|
|
bug3609 = '[ruby-core:31470]'
|
|
|
|
def (pinf = Object.new).infinite?; +1 end
|
|
|
|
def (ninf = Object.new).infinite?; -1 end
|
|
|
|
def (fin = Object.new).infinite?; nil end
|
|
|
|
nonum = Object.new
|
|
|
|
assert_equal(0, inf <=> pinf, bug3609)
|
|
|
|
assert_equal(1, inf <=> fin, bug3609)
|
|
|
|
assert_equal(1, inf <=> ninf, bug3609)
|
|
|
|
assert_nil(inf <=> nonum, bug3609)
|
|
|
|
assert_equal(-1, -inf <=> pinf, bug3609)
|
|
|
|
assert_equal(-1, -inf <=> fin, bug3609)
|
|
|
|
assert_equal(0, -inf <=> ninf, bug3609)
|
|
|
|
assert_nil(-inf <=> nonum, bug3609)
|
|
|
|
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_raise(ArgumentError) { 1.0 > nil }
|
|
|
|
assert_raise(ArgumentError) { 1.0 >= nil }
|
|
|
|
assert_raise(ArgumentError) { 1.0 < nil }
|
|
|
|
assert_raise(ArgumentError) { 1.0 <= nil }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_zero_p
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_predicate(0.0, :zero?)
|
|
|
|
assert_not_predicate(1.0, :zero?)
|
2008-01-31 09:08:14 -05:00
|
|
|
end
|
|
|
|
|
2015-05-17 02:01:47 -04:00
|
|
|
def test_positive_p
|
|
|
|
assert_predicate(+1.0, :positive?)
|
|
|
|
assert_not_predicate(+0.0, :positive?)
|
|
|
|
assert_not_predicate(-0.0, :positive?)
|
|
|
|
assert_not_predicate(-1.0, :positive?)
|
|
|
|
assert_predicate(+(0.0.next_float), :positive?)
|
|
|
|
assert_not_predicate(-(0.0.next_float), :positive?)
|
|
|
|
assert_predicate(Float::INFINITY, :positive?)
|
|
|
|
assert_not_predicate(-Float::INFINITY, :positive?)
|
|
|
|
assert_not_predicate(Float::NAN, :positive?)
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_negative_p
|
|
|
|
assert_predicate(-1.0, :negative?)
|
|
|
|
assert_not_predicate(-0.0, :negative?)
|
|
|
|
assert_not_predicate(+0.0, :negative?)
|
|
|
|
assert_not_predicate(+1.0, :negative?)
|
|
|
|
assert_predicate(-(0.0.next_float), :negative?)
|
|
|
|
assert_not_predicate(+(0.0.next_float), :negative?)
|
|
|
|
assert_predicate(-Float::INFINITY, :negative?)
|
|
|
|
assert_not_predicate(Float::INFINITY, :negative?)
|
|
|
|
assert_not_predicate(Float::NAN, :negative?)
|
|
|
|
end
|
|
|
|
|
2008-01-31 09:08:14 -05:00
|
|
|
def test_infinite_p
|
2009-12-29 02:05:39 -05:00
|
|
|
inf = Float::INFINITY
|
2010-04-29 01:33:43 -04:00
|
|
|
assert_equal(1, inf.infinite?)
|
|
|
|
assert_equal(-1, (-inf).infinite?)
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_nil(1.0.infinite?)
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_finite_p
|
2009-12-29 02:05:39 -05:00
|
|
|
inf = Float::INFINITY
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_not_predicate(inf, :finite?)
|
|
|
|
assert_not_predicate(-inf, :finite?)
|
|
|
|
assert_predicate(1.0, :finite?)
|
2008-01-31 09:08:14 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_floor_ceil_round_truncate
|
|
|
|
assert_equal(1, 1.5.floor)
|
|
|
|
assert_equal(2, 1.5.ceil)
|
|
|
|
assert_equal(2, 1.5.round)
|
|
|
|
assert_equal(1, 1.5.truncate)
|
|
|
|
|
|
|
|
assert_equal(2, 2.0.floor)
|
|
|
|
assert_equal(2, 2.0.ceil)
|
|
|
|
assert_equal(2, 2.0.round)
|
|
|
|
assert_equal(2, 2.0.truncate)
|
|
|
|
|
|
|
|
assert_equal(-2, (-1.5).floor)
|
|
|
|
assert_equal(-1, (-1.5).ceil)
|
|
|
|
assert_equal(-2, (-1.5).round)
|
|
|
|
assert_equal(-1, (-1.5).truncate)
|
|
|
|
|
|
|
|
assert_equal(-2, (-2.0).floor)
|
|
|
|
assert_equal(-2, (-2.0).ceil)
|
|
|
|
assert_equal(-2, (-2.0).round)
|
|
|
|
assert_equal(-2, (-2.0).truncate)
|
|
|
|
|
2009-12-29 02:05:39 -05:00
|
|
|
inf = Float::INFINITY
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_raise(FloatDomainError) { inf.floor }
|
|
|
|
assert_raise(FloatDomainError) { inf.ceil }
|
|
|
|
assert_raise(FloatDomainError) { inf.round }
|
|
|
|
assert_raise(FloatDomainError) { inf.truncate }
|
2011-09-01 12:07:16 -04:00
|
|
|
end
|
2008-01-31 09:08:14 -05:00
|
|
|
|
2011-09-01 12:07:16 -04:00
|
|
|
def test_round_with_precision
|
2008-01-31 09:08:14 -05:00
|
|
|
assert_equal(1.100, 1.111.round(1))
|
|
|
|
assert_equal(1.110, 1.111.round(2))
|
|
|
|
assert_equal(11110.0, 11111.1.round(-1))
|
|
|
|
assert_equal(11100.0, 11111.1.round(-2))
|
2016-04-17 23:40:03 -04:00
|
|
|
assert_equal(-1.100, -1.111.round(1))
|
|
|
|
assert_equal(-1.110, -1.111.round(2))
|
|
|
|
assert_equal(-11110.0, -11111.1.round(-1))
|
|
|
|
assert_equal(-11100.0, -11111.1.round(-2))
|
|
|
|
assert_equal(0, 11111.1.round(-5))
|
2011-03-22 19:07:36 -04:00
|
|
|
|
|
|
|
assert_equal(10**300, 1.1e300.round(-300))
|
2011-05-29 02:09:08 -04:00
|
|
|
assert_equal(-10**300, -1.1e300.round(-300))
|
2011-09-01 12:07:16 -04:00
|
|
|
assert_equal(1.0e-300, 1.1e-300.round(300))
|
|
|
|
assert_equal(-1.0e-300, -1.1e-300.round(300))
|
|
|
|
|
|
|
|
bug5227 = '[ruby-core:39093]'
|
|
|
|
assert_equal(42.0, 42.0.round(308), bug5227)
|
|
|
|
assert_equal(1.0e307, 1.0e307.round(2), bug5227)
|
|
|
|
|
|
|
|
assert_raise(TypeError) {1.0.round("4")}
|
|
|
|
assert_raise(TypeError) {1.0.round(nil)}
|
|
|
|
def (prec = Object.new).to_int; 2; end
|
|
|
|
assert_equal(1.0, 0.998.round(prec))
|
2016-07-07 03:37:55 -04:00
|
|
|
|
|
|
|
assert_equal(+5.02, +5.015.round(2))
|
|
|
|
assert_equal(-5.02, -5.015.round(2))
|
|
|
|
assert_equal(+1.26, +1.255.round(2))
|
|
|
|
assert_equal(-1.26, -1.255.round(2))
|
2008-01-31 09:08:14 -05:00
|
|
|
end
|
|
|
|
|
2016-04-13 02:54:38 -04:00
|
|
|
def test_floor_with_precision
|
2017-05-26 21:26:31 -04:00
|
|
|
assert_equal(+0.0, +0.001.floor(1))
|
|
|
|
assert_equal(-0.1, -0.001.floor(1))
|
2016-04-13 02:54:38 -04:00
|
|
|
assert_equal(1.100, 1.111.floor(1))
|
|
|
|
assert_equal(1.110, 1.111.floor(2))
|
|
|
|
assert_equal(11110, 11119.9.floor(-1))
|
|
|
|
assert_equal(11100, 11100.0.floor(-2))
|
|
|
|
assert_equal(11100, 11199.9.floor(-2))
|
2016-04-17 23:40:03 -04:00
|
|
|
assert_equal(-1.200, -1.111.floor(1))
|
|
|
|
assert_equal(-1.120, -1.111.floor(2))
|
|
|
|
assert_equal(-11120, -11119.9.floor(-1))
|
|
|
|
assert_equal(-11100, -11100.0.floor(-2))
|
|
|
|
assert_equal(-11200, -11199.9.floor(-2))
|
2016-04-13 02:54:38 -04:00
|
|
|
assert_equal(0, 11111.1.floor(-5))
|
|
|
|
|
|
|
|
assert_equal(10**300, 1.1e300.floor(-300))
|
|
|
|
assert_equal(-2*10**300, -1.1e300.floor(-300))
|
|
|
|
assert_equal(1.0e-300, 1.1e-300.floor(300))
|
|
|
|
assert_equal(-2.0e-300, -1.1e-300.floor(300))
|
|
|
|
|
|
|
|
assert_equal(42.0, 42.0.floor(308))
|
|
|
|
assert_equal(1.0e307, 1.0e307.floor(2))
|
|
|
|
|
|
|
|
assert_raise(TypeError) {1.0.floor("4")}
|
|
|
|
assert_raise(TypeError) {1.0.floor(nil)}
|
|
|
|
def (prec = Object.new).to_int; 2; end
|
|
|
|
assert_equal(0.99, 0.998.floor(prec))
|
|
|
|
end
|
|
|
|
|
2016-04-13 02:56:36 -04:00
|
|
|
def test_ceil_with_precision
|
2017-05-26 21:26:31 -04:00
|
|
|
assert_equal(+0.1, +0.001.ceil(1))
|
|
|
|
assert_equal(-0.0, -0.001.ceil(1))
|
2016-04-13 02:56:36 -04:00
|
|
|
assert_equal(1.200, 1.111.ceil(1))
|
|
|
|
assert_equal(1.120, 1.111.ceil(2))
|
|
|
|
assert_equal(11120, 11111.1.ceil(-1))
|
|
|
|
assert_equal(11200, 11111.1.ceil(-2))
|
2016-04-17 23:40:03 -04:00
|
|
|
assert_equal(-1.100, -1.111.ceil(1))
|
|
|
|
assert_equal(-1.110, -1.111.ceil(2))
|
|
|
|
assert_equal(-11110, -11111.1.ceil(-1))
|
|
|
|
assert_equal(-11100, -11111.1.ceil(-2))
|
2016-04-13 02:56:36 -04:00
|
|
|
assert_equal(100000, 11111.1.ceil(-5))
|
|
|
|
|
|
|
|
assert_equal(2*10**300, 1.1e300.ceil(-300))
|
|
|
|
assert_equal(-10**300, -1.1e300.ceil(-300))
|
|
|
|
assert_equal(2.0e-300, 1.1e-300.ceil(300))
|
|
|
|
assert_equal(-1.0e-300, -1.1e-300.ceil(300))
|
|
|
|
|
|
|
|
assert_equal(42.0, 42.0.ceil(308))
|
|
|
|
assert_equal(1.0e307, 1.0e307.ceil(2))
|
|
|
|
|
|
|
|
assert_raise(TypeError) {1.0.ceil("4")}
|
|
|
|
assert_raise(TypeError) {1.0.ceil(nil)}
|
|
|
|
def (prec = Object.new).to_int; 2; end
|
|
|
|
assert_equal(0.99, 0.981.ceil(prec))
|
|
|
|
end
|
|
|
|
|
2016-04-17 23:56:33 -04:00
|
|
|
def test_truncate_with_precision
|
|
|
|
assert_equal(1.100, 1.111.truncate(1))
|
|
|
|
assert_equal(1.110, 1.111.truncate(2))
|
|
|
|
assert_equal(11110, 11119.9.truncate(-1))
|
|
|
|
assert_equal(11100, 11100.0.truncate(-2))
|
|
|
|
assert_equal(11100, 11199.9.truncate(-2))
|
|
|
|
assert_equal(-1.100, -1.111.truncate(1))
|
|
|
|
assert_equal(-1.110, -1.111.truncate(2))
|
|
|
|
assert_equal(-11110, -11111.1.truncate(-1))
|
|
|
|
assert_equal(-11100, -11111.1.truncate(-2))
|
|
|
|
assert_equal(0, 11111.1.truncate(-5))
|
|
|
|
|
|
|
|
assert_equal(10**300, 1.1e300.truncate(-300))
|
|
|
|
assert_equal(-10**300, -1.1e300.truncate(-300))
|
|
|
|
assert_equal(1.0e-300, 1.1e-300.truncate(300))
|
|
|
|
assert_equal(-1.0e-300, -1.1e-300.truncate(300))
|
|
|
|
|
|
|
|
assert_equal(42.0, 42.0.truncate(308))
|
|
|
|
assert_equal(1.0e307, 1.0e307.truncate(2))
|
|
|
|
|
|
|
|
assert_raise(TypeError) {1.0.truncate("4")}
|
|
|
|
assert_raise(TypeError) {1.0.truncate(nil)}
|
|
|
|
def (prec = Object.new).to_int; 2; end
|
|
|
|
assert_equal(0.99, 0.998.truncate(prec))
|
|
|
|
end
|
|
|
|
|
2008-04-28 01:42:34 -04:00
|
|
|
VS = [
|
|
|
|
18446744073709551617.0,
|
|
|
|
18446744073709551616.0,
|
|
|
|
18446744073709551615.8,
|
|
|
|
18446744073709551615.5,
|
|
|
|
18446744073709551615.2,
|
|
|
|
18446744073709551615.0,
|
|
|
|
18446744073709551614.0,
|
|
|
|
|
|
|
|
4611686018427387905.0,
|
|
|
|
4611686018427387904.0,
|
|
|
|
4611686018427387903.8,
|
|
|
|
4611686018427387903.5,
|
|
|
|
4611686018427387903.2,
|
|
|
|
4611686018427387903.0,
|
|
|
|
4611686018427387902.0,
|
|
|
|
|
|
|
|
4294967297.0,
|
|
|
|
4294967296.0,
|
|
|
|
4294967295.8,
|
|
|
|
4294967295.5,
|
|
|
|
4294967295.2,
|
|
|
|
4294967295.0,
|
|
|
|
4294967294.0,
|
|
|
|
|
|
|
|
1073741825.0,
|
|
|
|
1073741824.0,
|
|
|
|
1073741823.8,
|
|
|
|
1073741823.5,
|
|
|
|
1073741823.2,
|
|
|
|
1073741823.0,
|
|
|
|
1073741822.0,
|
|
|
|
|
|
|
|
-1073741823.0,
|
|
|
|
-1073741824.0,
|
|
|
|
-1073741824.2,
|
|
|
|
-1073741824.5,
|
|
|
|
-1073741824.8,
|
|
|
|
-1073741825.0,
|
|
|
|
-1073741826.0,
|
|
|
|
|
|
|
|
-4294967295.0,
|
|
|
|
-4294967296.0,
|
|
|
|
-4294967296.2,
|
|
|
|
-4294967296.5,
|
|
|
|
-4294967296.8,
|
|
|
|
-4294967297.0,
|
|
|
|
-4294967298.0,
|
|
|
|
|
|
|
|
-4611686018427387903.0,
|
|
|
|
-4611686018427387904.0,
|
|
|
|
-4611686018427387904.2,
|
|
|
|
-4611686018427387904.5,
|
|
|
|
-4611686018427387904.8,
|
|
|
|
-4611686018427387905.0,
|
|
|
|
-4611686018427387906.0,
|
|
|
|
|
|
|
|
-18446744073709551615.0,
|
|
|
|
-18446744073709551616.0,
|
|
|
|
-18446744073709551616.2,
|
|
|
|
-18446744073709551616.5,
|
|
|
|
-18446744073709551616.8,
|
|
|
|
-18446744073709551617.0,
|
|
|
|
-18446744073709551618.0,
|
|
|
|
]
|
|
|
|
|
|
|
|
def test_truncate
|
|
|
|
VS.each {|f|
|
|
|
|
i = f.truncate
|
|
|
|
assert_equal(i, f.to_i)
|
|
|
|
if f < 0
|
|
|
|
assert_operator(i, :<, 0)
|
|
|
|
else
|
|
|
|
assert_operator(i, :>, 0)
|
|
|
|
end
|
|
|
|
assert_operator(i.abs, :<=, f.abs)
|
2008-04-28 01:45:37 -04:00
|
|
|
d = f.abs - i.abs
|
|
|
|
assert_operator(0, :<=, d)
|
|
|
|
assert_operator(d, :<, 1)
|
2008-04-28 01:42:34 -04:00
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_ceil
|
|
|
|
VS.each {|f|
|
|
|
|
i = f.ceil
|
|
|
|
if f < 0
|
|
|
|
assert_operator(i, :<, 0)
|
|
|
|
else
|
|
|
|
assert_operator(i, :>, 0)
|
|
|
|
end
|
|
|
|
assert_operator(i, :>=, f)
|
2008-04-28 01:45:37 -04:00
|
|
|
d = f - i
|
|
|
|
assert_operator(-1, :<, d)
|
|
|
|
assert_operator(d, :<=, 0)
|
2008-04-28 01:42:34 -04:00
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_floor
|
|
|
|
VS.each {|f|
|
|
|
|
i = f.floor
|
|
|
|
if f < 0
|
|
|
|
assert_operator(i, :<, 0)
|
|
|
|
else
|
|
|
|
assert_operator(i, :>, 0)
|
|
|
|
end
|
|
|
|
assert_operator(i, :<=, f)
|
2008-04-28 01:45:37 -04:00
|
|
|
d = f - i
|
|
|
|
assert_operator(0, :<=, d)
|
|
|
|
assert_operator(d, :<, 1)
|
2008-04-28 01:42:34 -04:00
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_round
|
|
|
|
VS.each {|f|
|
2011-09-05 04:46:44 -04:00
|
|
|
msg = "round(#{f})"
|
2008-04-28 01:42:34 -04:00
|
|
|
i = f.round
|
|
|
|
if f < 0
|
2011-09-05 04:46:44 -04:00
|
|
|
assert_operator(i, :<, 0, msg)
|
2008-04-28 01:42:34 -04:00
|
|
|
else
|
2011-09-05 04:46:44 -04:00
|
|
|
assert_operator(i, :>, 0, msg)
|
2008-04-28 01:42:34 -04:00
|
|
|
end
|
|
|
|
d = f - i
|
2011-09-05 04:46:44 -04:00
|
|
|
assert_operator(-0.5, :<=, d, msg)
|
|
|
|
assert_operator(d, :<=, 0.5, msg)
|
2008-04-28 01:42:34 -04:00
|
|
|
}
|
2008-04-28 01:25:03 -04:00
|
|
|
end
|
2008-04-28 01:42:34 -04:00
|
|
|
|
2016-11-05 05:49:39 -04:00
|
|
|
def test_round_half_even
|
|
|
|
assert_equal(12.0, 12.5.round(half: :even))
|
|
|
|
assert_equal(14.0, 13.5.round(half: :even))
|
|
|
|
|
|
|
|
assert_equal(2.2, 2.15.round(1, half: :even))
|
|
|
|
assert_equal(2.2, 2.25.round(1, half: :even))
|
|
|
|
assert_equal(2.4, 2.35.round(1, half: :even))
|
|
|
|
|
|
|
|
assert_equal(-2.2, -2.15.round(1, half: :even))
|
|
|
|
assert_equal(-2.2, -2.25.round(1, half: :even))
|
|
|
|
assert_equal(-2.4, -2.35.round(1, half: :even))
|
|
|
|
|
|
|
|
assert_equal(7.1364, 7.13645.round(4, half: :even))
|
|
|
|
assert_equal(7.1365, 7.1364501.round(4, half: :even))
|
|
|
|
assert_equal(7.1364, 7.1364499.round(4, half: :even))
|
|
|
|
|
|
|
|
assert_equal(-7.1364, -7.13645.round(4, half: :even))
|
|
|
|
assert_equal(-7.1365, -7.1364501.round(4, half: :even))
|
|
|
|
assert_equal(-7.1364, -7.1364499.round(4, half: :even))
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_round_half_up
|
|
|
|
assert_equal(13.0, 12.5.round(half: :up))
|
|
|
|
assert_equal(14.0, 13.5.round(half: :up))
|
|
|
|
|
|
|
|
assert_equal(2.2, 2.15.round(1, half: :up))
|
|
|
|
assert_equal(2.3, 2.25.round(1, half: :up))
|
|
|
|
assert_equal(2.4, 2.35.round(1, half: :up))
|
|
|
|
|
|
|
|
assert_equal(-2.2, -2.15.round(1, half: :up))
|
|
|
|
assert_equal(-2.3, -2.25.round(1, half: :up))
|
|
|
|
assert_equal(-2.4, -2.35.round(1, half: :up))
|
|
|
|
|
|
|
|
assert_equal(7.1365, 7.13645.round(4, half: :up))
|
|
|
|
assert_equal(7.1365, 7.1364501.round(4, half: :up))
|
|
|
|
assert_equal(7.1364, 7.1364499.round(4, half: :up))
|
|
|
|
|
|
|
|
assert_equal(-7.1365, -7.13645.round(4, half: :up))
|
|
|
|
assert_equal(-7.1365, -7.1364501.round(4, half: :up))
|
|
|
|
assert_equal(-7.1364, -7.1364499.round(4, half: :up))
|
|
|
|
end
|
|
|
|
|
2016-11-25 01:28:00 -05:00
|
|
|
def test_round_half_down
|
|
|
|
assert_equal(12.0, 12.5.round(half: :down))
|
|
|
|
assert_equal(13.0, 13.5.round(half: :down))
|
|
|
|
|
|
|
|
assert_equal(2.1, 2.15.round(1, half: :down))
|
|
|
|
assert_equal(2.2, 2.25.round(1, half: :down))
|
|
|
|
assert_equal(2.3, 2.35.round(1, half: :down))
|
|
|
|
|
|
|
|
assert_equal(-2.1, -2.15.round(1, half: :down))
|
|
|
|
assert_equal(-2.2, -2.25.round(1, half: :down))
|
|
|
|
assert_equal(-2.3, -2.35.round(1, half: :down))
|
|
|
|
|
|
|
|
assert_equal(7.1364, 7.13645.round(4, half: :down))
|
|
|
|
assert_equal(7.1365, 7.1364501.round(4, half: :down))
|
|
|
|
assert_equal(7.1364, 7.1364499.round(4, half: :down))
|
|
|
|
|
|
|
|
assert_equal(-7.1364, -7.13645.round(4, half: :down))
|
|
|
|
assert_equal(-7.1365, -7.1364501.round(4, half: :down))
|
|
|
|
assert_equal(-7.1364, -7.1364499.round(4, half: :down))
|
|
|
|
end
|
|
|
|
|
2016-12-22 05:29:40 -05:00
|
|
|
def test_round_half_nil
|
|
|
|
assert_equal(13.0, 12.5.round(half: nil))
|
|
|
|
assert_equal(14.0, 13.5.round(half: nil))
|
|
|
|
|
|
|
|
assert_equal(2.2, 2.15.round(1, half: nil))
|
|
|
|
assert_equal(2.3, 2.25.round(1, half: nil))
|
|
|
|
assert_equal(2.4, 2.35.round(1, half: nil))
|
|
|
|
|
|
|
|
assert_equal(-2.2, -2.15.round(1, half: nil))
|
|
|
|
assert_equal(-2.3, -2.25.round(1, half: nil))
|
|
|
|
assert_equal(-2.4, -2.35.round(1, half: nil))
|
|
|
|
|
|
|
|
assert_equal(7.1365, 7.13645.round(4, half: nil))
|
|
|
|
assert_equal(7.1365, 7.1364501.round(4, half: nil))
|
|
|
|
assert_equal(7.1364, 7.1364499.round(4, half: nil))
|
|
|
|
|
|
|
|
assert_equal(-7.1365, -7.13645.round(4, half: nil))
|
|
|
|
assert_equal(-7.1365, -7.1364501.round(4, half: nil))
|
|
|
|
assert_equal(-7.1364, -7.1364499.round(4, half: nil))
|
|
|
|
end
|
|
|
|
|
2016-11-20 21:17:29 -05:00
|
|
|
def test_round_half_invalid
|
2016-12-20 20:29:57 -05:00
|
|
|
assert_raise_with_message(ArgumentError, /Object/) {
|
|
|
|
1.0.round(half: Object)
|
2016-12-06 07:54:19 -05:00
|
|
|
}
|
2016-11-20 21:17:29 -05:00
|
|
|
assert_raise_with_message(ArgumentError, /xxx/) {
|
|
|
|
1.0.round(half: "\0xxx")
|
|
|
|
}
|
2020-01-27 02:12:15 -05:00
|
|
|
assert_raise_with_message(Encoding::CompatibilityError, /ASCII incompatible/) {
|
|
|
|
1.0.round(half: "up".force_encoding("utf-16be"))
|
|
|
|
}
|
2016-11-20 21:17:29 -05:00
|
|
|
end
|
|
|
|
|
2008-05-14 08:52:17 -04:00
|
|
|
def test_Float
|
|
|
|
assert_in_delta(0.125, Float("0.1_2_5"), 0.00001)
|
|
|
|
assert_in_delta(0.125, "0.1_2_5__".to_f, 0.00001)
|
2017-03-15 04:15:32 -04:00
|
|
|
assert_in_delta(0.0, "0_.125".to_f, 0.00001)
|
|
|
|
assert_in_delta(0.0, "0._125".to_f, 0.00001)
|
|
|
|
assert_in_delta(0.1, "0.1__2_5".to_f, 0.00001)
|
|
|
|
assert_in_delta(0.1, "0.1_e10".to_f, 0.00001)
|
|
|
|
assert_in_delta(0.1, "0.1e_10".to_f, 0.00001)
|
|
|
|
assert_in_delta(1.0, "0.1e1__0".to_f, 0.00001)
|
2010-07-24 16:26:34 -04:00
|
|
|
assert_equal(1, suppress_warning {Float(([1] * 10000).join)}.infinite?)
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_not_predicate(Float(([1] * 10000).join("_")), :infinite?) # is it really OK?
|
2008-05-14 08:52:17 -04:00
|
|
|
assert_raise(ArgumentError) { Float("1.0\x001") }
|
2010-08-22 23:19:58 -04:00
|
|
|
assert_equal(15.9375, Float('0xf.fp0'))
|
2010-09-05 21:00:29 -04:00
|
|
|
assert_raise(ArgumentError) { Float('0x') }
|
2010-09-12 21:15:39 -04:00
|
|
|
assert_equal(15, Float('0xf'))
|
|
|
|
assert_equal(15, Float('0xfp0'))
|
|
|
|
assert_raise(ArgumentError) { Float('0xfp') }
|
|
|
|
assert_raise(ArgumentError) { Float('0xf.') }
|
|
|
|
assert_raise(ArgumentError) { Float('0xf.p') }
|
2010-10-19 21:48:24 -04:00
|
|
|
assert_raise(ArgumentError) { Float('0xf.p0') }
|
2010-09-12 21:15:39 -04:00
|
|
|
assert_raise(ArgumentError) { Float('0xf.f') }
|
2010-08-22 23:19:58 -04:00
|
|
|
assert_raise(ArgumentError) { Float('0xf.fp') }
|
2019-07-31 01:35:21 -04:00
|
|
|
begin
|
|
|
|
verbose_bak, $VERBOSE = $VERBOSE, nil
|
|
|
|
assert_equal(Float::INFINITY, Float('0xf.fp1000000000000000'))
|
|
|
|
ensure
|
|
|
|
$VERBOSE = verbose_bak
|
|
|
|
end
|
2010-07-24 16:26:34 -04:00
|
|
|
assert_equal(1, suppress_warning {Float("1e10_00")}.infinite?)
|
2008-05-14 08:52:17 -04:00
|
|
|
assert_raise(TypeError) { Float(nil) }
|
2018-03-15 03:19:45 -04:00
|
|
|
assert_raise(TypeError) { Float(:test) }
|
2008-05-14 08:52:17 -04:00
|
|
|
o = Object.new
|
2009-12-29 02:05:39 -05:00
|
|
|
def o.to_f; inf = Float::INFINITY; inf/inf; end
|
2013-12-13 04:18:05 -05:00
|
|
|
assert_predicate(Float(o), :nan?)
|
2008-05-14 08:52:17 -04:00
|
|
|
end
|
|
|
|
|
2011-01-24 07:04:47 -05:00
|
|
|
def test_invalid_str
|
|
|
|
bug4310 = '[ruby-core:34820]'
|
|
|
|
assert_raise(ArgumentError, bug4310) {under_gc_stress {Float('a'*10000)}}
|
|
|
|
end
|
|
|
|
|
2019-07-11 06:20:53 -04:00
|
|
|
def test_Float_with_invalid_exception
|
|
|
|
assert_raise(ArgumentError) {
|
|
|
|
Float("0", exception: 1)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2018-03-15 03:19:45 -04:00
|
|
|
def test_Float_with_exception_keyword
|
|
|
|
assert_raise(ArgumentError) {
|
|
|
|
Float(".", exception: true)
|
|
|
|
}
|
|
|
|
assert_nothing_raised(ArgumentError) {
|
|
|
|
assert_equal(nil, Float(".", exception: false))
|
|
|
|
}
|
|
|
|
assert_raise(RangeError) {
|
|
|
|
Float(1i, exception: true)
|
|
|
|
}
|
|
|
|
assert_nothing_raised(RangeError) {
|
|
|
|
assert_equal(nil, Float(1i, exception: false))
|
|
|
|
}
|
|
|
|
assert_raise(TypeError) {
|
|
|
|
Float(nil, exception: true)
|
|
|
|
}
|
|
|
|
assert_nothing_raised(TypeError) {
|
|
|
|
assert_equal(nil, Float(nil, exception: false))
|
|
|
|
}
|
|
|
|
assert_nothing_raised(TypeError) {
|
|
|
|
assert_equal(nil, Float(:test, exception: false))
|
|
|
|
}
|
|
|
|
assert_nothing_raised(TypeError) {
|
|
|
|
assert_equal(nil, Float(Object.new, exception: false))
|
|
|
|
}
|
|
|
|
assert_nothing_raised(TypeError) {
|
|
|
|
o = Object.new
|
|
|
|
def o.to_f; 3.14; end
|
|
|
|
assert_equal(3.14, Float(o, exception: false))
|
|
|
|
}
|
|
|
|
assert_nothing_raised(RuntimeError) {
|
|
|
|
o = Object.new
|
|
|
|
def o.to_f; raise; end
|
|
|
|
assert_equal(nil, Float(o, exception: false))
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2008-05-14 08:52:17 -04:00
|
|
|
def test_num2dbl
|
2017-04-25 07:42:31 -04:00
|
|
|
assert_raise(ArgumentError, "comparison of String with 0 failed") do
|
2008-05-14 08:52:17 -04:00
|
|
|
1.0.step(2.0, "0.5") {}
|
|
|
|
end
|
2013-09-02 18:54:58 -04:00
|
|
|
assert_raise(TypeError) do
|
|
|
|
1.0.step(2.0, nil) {}
|
|
|
|
end
|
2008-05-14 08:52:17 -04:00
|
|
|
end
|
|
|
|
|
2009-05-09 06:59:54 -04:00
|
|
|
def test_sleep_with_Float
|
|
|
|
assert_nothing_raised("[ruby-core:23282]") do
|
|
|
|
sleep(0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1)
|
|
|
|
end
|
|
|
|
end
|
2011-11-21 20:47:35 -05:00
|
|
|
|
|
|
|
def test_step
|
|
|
|
1000.times do
|
|
|
|
a = rand
|
|
|
|
b = a+rand*1000
|
|
|
|
s = (b - a) / 10
|
|
|
|
assert_equal(11, (a..b).step(s).to_a.length)
|
|
|
|
end
|
|
|
|
|
|
|
|
(1.0..12.7).step(1.3).each do |n|
|
|
|
|
assert_operator(n, :<=, 12.7)
|
|
|
|
end
|
2011-11-21 23:54:42 -05:00
|
|
|
|
|
|
|
assert_equal([5.0, 4.0, 3.0, 2.0], 5.0.step(1.5, -1).to_a)
|
2021-04-29 15:51:05 -04:00
|
|
|
|
|
|
|
assert_equal(11, ((0.24901079128550474)..(340.2500808898068)).step(34.00010700985213).to_a.size)
|
|
|
|
assert_equal(11, ((0.24901079128550474)..(340.25008088980684)).step(34.00010700985213).to_a.size)
|
|
|
|
assert_equal(11, ((-0.24901079128550474)..(-340.2500808898068)).step(-34.00010700985213).to_a.size)
|
|
|
|
assert_equal(11, ((-0.24901079128550474)..(-340.25008088980684)).step(-34.00010700985213).to_a.size)
|
2011-11-21 20:47:35 -05:00
|
|
|
end
|
|
|
|
|
2012-11-07 02:03:50 -05:00
|
|
|
def test_step2
|
|
|
|
assert_equal([0.0], 0.0.step(1.0, Float::INFINITY).to_a)
|
|
|
|
end
|
|
|
|
|
2011-11-21 20:47:35 -05:00
|
|
|
def test_step_excl
|
|
|
|
1000.times do
|
|
|
|
a = rand
|
|
|
|
b = a+rand*1000
|
|
|
|
s = (b - a) / 10
|
2021-05-29 17:08:24 -04:00
|
|
|
b = a + s*9.999999
|
2020-02-07 04:10:36 -05:00
|
|
|
seq = (a...b).step(s)
|
|
|
|
assert_equal(10, seq.to_a.length, seq.inspect)
|
2011-11-21 20:47:35 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
assert_equal([1.0, 2.9, 4.8, 6.699999999999999], (1.0...6.8).step(1.9).to_a)
|
|
|
|
|
|
|
|
e = 1+1E-12
|
|
|
|
(1.0 ... e).step(1E-16) do |n|
|
|
|
|
assert_operator(n, :<=, e)
|
|
|
|
end
|
2021-04-29 15:51:05 -04:00
|
|
|
|
|
|
|
assert_equal(10, ((0.24901079128550474)...(340.2500808898068)).step(34.00010700985213).to_a.size)
|
|
|
|
assert_equal(11, ((0.24901079128550474)...(340.25008088980684)).step(34.00010700985213).to_a.size)
|
|
|
|
assert_equal(10, ((-0.24901079128550474)...(-340.2500808898068)).step(-34.00010700985213).to_a.size)
|
|
|
|
assert_equal(11, ((-0.24901079128550474)...(-340.25008088980684)).step(-34.00010700985213).to_a.size)
|
2011-11-21 20:47:35 -05:00
|
|
|
end
|
2012-08-23 07:51:30 -04:00
|
|
|
|
|
|
|
def test_singleton_method
|
|
|
|
# flonum on 64bit platform
|
|
|
|
assert_raise(TypeError) { a = 1.0; def a.foo; end }
|
|
|
|
# always not flonum
|
|
|
|
assert_raise(TypeError) { a = Float::INFINITY; def a.foo; end }
|
|
|
|
end
|
2013-11-21 22:43:56 -05:00
|
|
|
|
|
|
|
def test_long_string
|
|
|
|
assert_separately([], <<-'end;')
|
|
|
|
assert_in_epsilon(10.0, ("1."+"1"*300000).to_f*9)
|
|
|
|
end;
|
|
|
|
end
|
2014-05-17 20:37:10 -04:00
|
|
|
|
|
|
|
def test_next_float
|
|
|
|
smallest = 0.0.next_float
|
|
|
|
assert_equal(-Float::MAX, (-Float::INFINITY).next_float)
|
|
|
|
assert_operator(-Float::MAX, :<, (-Float::MAX).next_float)
|
|
|
|
assert_equal(Float::EPSILON/2, (-1.0).next_float + 1.0)
|
|
|
|
assert_operator(0.0, :<, smallest)
|
|
|
|
assert_operator([0.0, smallest], :include?, smallest/2)
|
|
|
|
assert_equal(Float::EPSILON, 1.0.next_float - 1.0)
|
|
|
|
assert_equal(Float::INFINITY, Float::MAX.next_float)
|
|
|
|
assert_equal(Float::INFINITY, Float::INFINITY.next_float)
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_predicate(Float::NAN.next_float, :nan?)
|
2014-05-17 20:37:10 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_prev_float
|
|
|
|
smallest = 0.0.next_float
|
|
|
|
assert_equal(-Float::INFINITY, (-Float::INFINITY).prev_float)
|
|
|
|
assert_equal(-Float::INFINITY, (-Float::MAX).prev_float)
|
|
|
|
assert_equal(-Float::EPSILON, (-1.0).prev_float + 1.0)
|
|
|
|
assert_equal(-smallest, 0.0.prev_float)
|
|
|
|
assert_operator([0.0, 0.0.prev_float], :include?, 0.0.prev_float/2)
|
|
|
|
assert_equal(-Float::EPSILON/2, 1.0.prev_float - 1.0)
|
|
|
|
assert_operator(Float::MAX, :>, Float::MAX.prev_float)
|
|
|
|
assert_equal(Float::MAX, Float::INFINITY.prev_float)
|
2014-08-01 03:35:34 -04:00
|
|
|
assert_predicate(Float::NAN.prev_float, :nan?)
|
2014-05-17 20:37:10 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_next_prev_float_zero
|
|
|
|
z = 0.0.next_float.prev_float
|
|
|
|
assert_equal(0.0, z)
|
|
|
|
assert_equal(Float::INFINITY, 1.0/z)
|
|
|
|
z = 0.0.prev_float.next_float
|
|
|
|
assert_equal(0.0, z)
|
|
|
|
assert_equal(-Float::INFINITY, 1.0/z)
|
|
|
|
end
|
2015-03-17 23:01:58 -04:00
|
|
|
|
|
|
|
def test_hash_0
|
2015-03-17 23:02:33 -04:00
|
|
|
bug10979 = '[ruby-core:68541] [Bug #10979]'
|
2015-03-17 23:01:58 -04:00
|
|
|
assert_equal(+0.0.hash, -0.0.hash)
|
|
|
|
assert_operator(+0.0, :eql?, -0.0)
|
|
|
|
h = {0.0 => bug10979}
|
|
|
|
assert_equal(bug10979, h[-0.0])
|
|
|
|
end
|
2016-08-13 10:08:03 -04:00
|
|
|
|
|
|
|
def test_aliased_quo_recursion
|
|
|
|
assert_separately([], "#{<<-"begin;"}\n#{<<-"end;"}")
|
|
|
|
begin;
|
|
|
|
class Float
|
|
|
|
$VERBOSE = nil
|
|
|
|
alias / quo
|
|
|
|
end
|
|
|
|
assert_raise(NameError) do
|
|
|
|
begin
|
|
|
|
1.0/2.0
|
|
|
|
rescue SystemStackError => e
|
|
|
|
raise SystemStackError, e.message
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end;
|
|
|
|
end
|
2003-09-04 12:18:59 -04:00
|
|
|
end
|