Ruby » Ruby master

/*

* call-seq:

* ary.overlaps?(ary2) -> true or false

*

* Returns +true+ if the intersection of +ary+ and +ary2+ is non empty, else returns false.

*

* This is equivalent to (ary & ary2).any?

*

* [ "a", "b", "c" ].overlaps?( [ "c", "d", "a" ] ) #=> true

* [ "a" ].overlaps?( ["e", "b"] ) #=> false

* [ "a" ].overlaps?( [] ) #=> false

*

* See also Array#&.

*/

static VALUE

rb_ary_and_p(VALUE ary1, VALUE ary2)

{

VALUE hash, result, v;

st_data_t vv;

long i;

ary2 = to_ary(ary2);

if (RARRAY_LEN(ary1) == 0 || RARRAY_LEN(ary2) == 0) return Qfalse;

if (RARRAY_LEN(ary1) <= SMALL_ARRAY_LEN && RARRAY_LEN(ary2) <= SMALL_ARRAY_LEN) {

for (i=0; i<RARRAY_LEN(ary1); i++) {

v = RARRAY_AREF(ary1, i);

if (rb_ary_includes_by_eql(ary2, v)) {

return Qtrue;

}

}

return Qfalse;

}

hash = ary_make_hash(ary2);

result = Qfalse;

for (i=0; i<RARRAY_LEN(ary1); i++) {

v = RARRAY_AREF(ary1, i);

vv = (st_data_t)v;

if (rb_hash_stlike_delete(hash, &vv, 0)) {

result = Qtrue;

break;

}

}

ary_recycle_hash(hash);

return result;

}

rb_define_method(rb_cArray, "overlaps?", rb_ary_and_p, 1);

def test_overlaps

assert_equal(true, @cls[ 1, 1, 3, 5 ].overlaps?( @cls[ 1, 2, 3 ]))

assert_equal(false, @cls[ 1, 1, 3, 5 ].overlaps?( @cls[ ]))

assert_equal(false, @cls[ ].overlaps?( @cls[ 1, 2, 3 ]))

assert_equal(false, @cls[ 1, 2, 3 ].overlaps?( @cls[ 4, 5, 6 ]))

end

def test_overlaps_big_array

assert_equal(true, (@cls[ 1, 1, 3, 5 ]*64).overlaps?(@cls[ 1, 2, 3 ]*64))

assert_equal(false, (@cls[ 1, 1, 3, 5 ]*64).overlaps?(@cls[ ]))

assert_equal(false, (@cls[ ]).overlaps?(@cls[ 1, 2, 3 ]*64))

assert_equal(false, (@cls[ 1, 2, 3 ]*64).overlaps?(@cls[ 4, 5, 6 ]*64))

end

* ary.overlap?(ary2) -> true or false

* [ "a", "b", "c" ].overlap?( [ "c", "d", "a" ] ) #=> true

* [ "a" ].overlap?( ["e", "b"] ) #=> false

* [ "a" ].overlap?( [] ) #=> false

rb_define_method(rb_cArray, "overlap?", rb_ary_and_p, 1);

def test_overlap

assert_equal(true, @cls[ 1, 1, 3, 5 ].overlap?( @cls[ 1, 2, 3 ]))

assert_equal(false, @cls[ 1, 1, 3, 5 ].overlap?( @cls[ ]))

assert_equal(false, @cls[ ].overlap?( @cls[ 1, 2, 3 ]))

assert_equal(false, @cls[ 1, 2, 3 ].overlap?( @cls[ 4, 5, 6 ]))

end

def test_overlap_big_array

assert_equal(true, (@cls[ 1, 1, 3, 5 ]*64).overlap?(@cls[ 1, 2, 3 ]*64))

assert_equal(false, (@cls[ 1, 1, 3, 5 ]*64).overlap?(@cls[ ]))

assert_equal(false, (@cls[ ]).overlap?(@cls[ 1, 2, 3 ]*64))

assert_equal(false, (@cls[ 1, 2, 3 ]*64).overlap?(@cls[ 4, 5, 6 ]*64))

* This is equivalent to !(ary & ary2).empty?

assert_equal(true, @cls[ nil ].overlap?( @cls[ nil ]))