Summary

mrb_obj_eq() asks whether two values hold the same thing, and equal? is the one caller that asks for exactly that. For a Float it asked whether they were equal as numbers instead, which is a different question, and it asked it only under MRB_NO_BOXING: the boxed builds compare the mrb_value and so read the representation. The same expression answered one way there and the other way here.

Changes

Where the two questions part

A Float holds two kinds of pair that tell the questions apart. 0.0 and -0.0 are equal as numbers and hold different bits; a NaN holds a NaN and is equal to no number at all, its own operand included. Reading them as numbers, MRB_NO_BOXING called 0.0 and -0.0 one object and said a NaN was not the same object as itself, while the boxings that keep a Float in the value read the bits and answered both the other way.

memcmp() over sizeof(mrb_float) asks the question the boxed builds answer, so equal? reads alike whatever the build stores a Float in. Float#== is untouched, and what a Float is equal to does not move with it: 0.0 == -0.0 is still true, and a NaN is still equal to nothing.

Behaviour

pzero and nzero are built at run time as z + 0.0 and z * -1.0, and nan as z / z, from z = [0.0][0], so that nothing folds them into a single literal. Bold marks where a build differs from CRuby today.

The this PR column is what all three boxings answer after the change. Measured against CRuby 4.0.6.

Speed

MRB_NO_BOXING is the only build the change reaches, so the counts below are from a MRB_NO_BOXING build of the full-core gembox:

z = [0.0][0]
a = z + 1.5
b = z + 1.5
i = 0
while i < 1000000 do a == b; i += 1 end                 # the shortcut, over two Floats

t = 0.0; i = 0
while i < 1000000 do t += i * 0.5; i += 1 end           # Float arithmetic

h = {}; i = 0
while i < 100000 do h[i * 0.5] = i; i += 1 end          # Float-keyed Hash
i = 0
while i < 100000 do h[i * 0.5]; i += 1 end

Instruction counts as callgrind reads them, taken as Ir(2N) - Ir(N) so that startup cancels:

memcmp() over eight bytes is four instructions fewer per comparison than loading the two Floats and comparing them, so the path equal? and the == shortcut take is slightly shorter than it was. The other two rows are the same code either way.

Size

bin/mruby .text for every build in build_config/ci/gcc-clang.rb:

None of the five defines MRB_NO_BOXING, so none of them compiles the edit. The build that does is 96 bytes smaller: object.o .text reads 5,288 against master and 5,192 here, and bin/mruby the same 96 less.

Testing

rake test passes for the default build, for build_config/host-nofloat.rb, for every build in build_config/ci/gcc-clang.rb including the C++ ABI one, and for a MRB_NO_BOXING build of the full-core gembox, with no compiler warnings beyond the one -Wmaybe-uninitialized about eq in hash.c that master already emits in a MRB_NO_BOXING build.

Environment

The instruction counts were taken with a full-core gembox build at MRB_NO_BOXING:

gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_NO_BOXING -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER

The ## Size table was taken with build_config/ci/gcc-clang.rb:

bintest      gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_GC_FIXED_ARENA -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -DMRB_USE_DEBUG_HOOK
ascii-ctype  gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_ASCII_CTYPE -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER
byte-string  gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER
cxx_abi      gcc -g -O3 -Wall -Wundef -Wwrite-strings -x c++ -std=gnu++03 -DMRB_GC_FIXED_ARENA -DMRB_USE_CXX_EXCEPTION -DMRB_USE_CXX_ABI -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER
full-debug   gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -g3 -O0 -DMRB_GC_STRESS -DMRB_USE_DEBUG_HOOK -DMRB_DEBUG -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER

cxx_abi compiles mruby as C++ with gcc -x c++ -std=gnu++03; g++ only links. full-debug is the one build at -O0, enable_debug putting -g3 -O0 after the toolchain default of -g -O3.

Summary by CodeRabbit

• Bug Fixes

  • Updated Float equal? behavior to compare exact object representations.
  • NaN values now preserve identity when aliased.
  • Positive and negative zero are correctly distinguished.
  • Float equal? remains distinct from numeric == comparisons.

• Documentation

  • Clarified that equal? checks object representation rather than numeric equality.

• Tests

  • Added coverage for NaN identity, signed zero, and differences between equal? and ==.