зеркало из https://github.com/github/ruby.git
4882 строки
129 KiB
C
4882 строки
129 KiB
C
/**********************************************************************
|
|
|
|
enum.c -
|
|
|
|
$Author$
|
|
created at: Fri Oct 1 15:15:19 JST 1993
|
|
|
|
Copyright (C) 1993-2007 Yukihiro Matsumoto
|
|
|
|
**********************************************************************/
|
|
|
|
#include "id.h"
|
|
#include "internal.h"
|
|
#include "internal/compar.h"
|
|
#include "internal/enum.h"
|
|
#include "internal/hash.h"
|
|
#include "internal/imemo.h"
|
|
#include "internal/numeric.h"
|
|
#include "internal/object.h"
|
|
#include "internal/proc.h"
|
|
#include "internal/rational.h"
|
|
#include "internal/re.h"
|
|
#include "ruby/util.h"
|
|
#include "ruby_assert.h"
|
|
#include "symbol.h"
|
|
|
|
VALUE rb_mEnumerable;
|
|
|
|
static ID id_next;
|
|
static ID id__alone;
|
|
static ID id__separator;
|
|
static ID id_chunk_categorize;
|
|
static ID id_chunk_enumerable;
|
|
static ID id_sliceafter_enum;
|
|
static ID id_sliceafter_pat;
|
|
static ID id_sliceafter_pred;
|
|
static ID id_slicebefore_enumerable;
|
|
static ID id_slicebefore_sep_pat;
|
|
static ID id_slicebefore_sep_pred;
|
|
static ID id_slicewhen_enum;
|
|
static ID id_slicewhen_inverted;
|
|
static ID id_slicewhen_pred;
|
|
|
|
#define id_div idDiv
|
|
#define id_each idEach
|
|
#define id_eqq idEqq
|
|
#define id_cmp idCmp
|
|
#define id_lshift idLTLT
|
|
#define id_call idCall
|
|
#define id_size idSize
|
|
|
|
VALUE
|
|
rb_enum_values_pack(int argc, const VALUE *argv)
|
|
{
|
|
if (argc == 0) return Qnil;
|
|
if (argc == 1) return argv[0];
|
|
return rb_ary_new4(argc, argv);
|
|
}
|
|
|
|
#define ENUM_WANT_SVALUE() do { \
|
|
i = rb_enum_values_pack(argc, argv); \
|
|
} while (0)
|
|
|
|
static VALUE
|
|
enum_yield(int argc, VALUE ary)
|
|
{
|
|
if (argc > 1)
|
|
return rb_yield_force_blockarg(ary);
|
|
if (argc == 1)
|
|
return rb_yield(ary);
|
|
return rb_yield_values2(0, 0);
|
|
}
|
|
|
|
static VALUE
|
|
enum_yield_array(VALUE ary)
|
|
{
|
|
long len = RARRAY_LEN(ary);
|
|
|
|
if (len > 1)
|
|
return rb_yield_force_blockarg(ary);
|
|
if (len == 1)
|
|
return rb_yield(RARRAY_AREF(ary, 0));
|
|
return rb_yield_values2(0, 0);
|
|
}
|
|
|
|
static VALUE
|
|
grep_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (RTEST(rb_funcallv(memo->v1, id_eqq, 1, &i)) == RTEST(memo->u3.value)) {
|
|
rb_ary_push(memo->v2, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
grep_regexp_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
VALUE converted_element, match;
|
|
ENUM_WANT_SVALUE();
|
|
|
|
/* In case element can't be converted to a Symbol or String: not a match (don't raise) */
|
|
converted_element = SYMBOL_P(i) ? i : rb_check_string_type(i);
|
|
match = NIL_P(converted_element) ? Qfalse : rb_reg_match_p(memo->v1, i, 0);
|
|
if (match == memo->u3.value) {
|
|
rb_ary_push(memo->v2, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
grep_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (RTEST(rb_funcallv(memo->v1, id_eqq, 1, &i)) == RTEST(memo->u3.value)) {
|
|
rb_ary_push(memo->v2, enum_yield(argc, i));
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
enum_grep0(VALUE obj, VALUE pat, VALUE test)
|
|
{
|
|
VALUE ary = rb_ary_new();
|
|
struct MEMO *memo = MEMO_NEW(pat, ary, test);
|
|
rb_block_call_func_t fn;
|
|
if (rb_block_given_p()) {
|
|
fn = grep_iter_i;
|
|
}
|
|
else if (RB_TYPE_P(pat, T_REGEXP) &&
|
|
LIKELY(rb_method_basic_definition_p(CLASS_OF(pat), idEqq))) {
|
|
fn = grep_regexp_i;
|
|
}
|
|
else {
|
|
fn = grep_i;
|
|
}
|
|
rb_block_call(obj, id_each, 0, 0, fn, (VALUE)memo);
|
|
|
|
return ary;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* grep(pattern) -> array
|
|
* grep(pattern) {|element| ... } -> array
|
|
*
|
|
* Returns an array of objects based elements of +self+ that match the given pattern.
|
|
*
|
|
* With no block given, returns an array containing each element
|
|
* for which <tt>pattern === element</tt> is +true+:
|
|
*
|
|
* a = ['foo', 'bar', 'car', 'moo']
|
|
* a.grep(/ar/) # => ["bar", "car"]
|
|
* (1..10).grep(3..8) # => [3, 4, 5, 6, 7, 8]
|
|
* ['a', 'b', 0, 1].grep(Integer) # => [0, 1]
|
|
*
|
|
* With a block given,
|
|
* calls the block with each matching element and returns an array containing each
|
|
* object returned by the block:
|
|
*
|
|
* a = ['foo', 'bar', 'car', 'moo']
|
|
* a.grep(/ar/) {|element| element.upcase } # => ["BAR", "CAR"]
|
|
*
|
|
* Related: #grep_v.
|
|
*/
|
|
|
|
static VALUE
|
|
enum_grep(VALUE obj, VALUE pat)
|
|
{
|
|
return enum_grep0(obj, pat, Qtrue);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* grep_v(pattern) -> array
|
|
* grep_v(pattern) {|element| ... } -> array
|
|
*
|
|
* Returns an array of objects based on elements of +self+
|
|
* that <em>don't</em> match the given pattern.
|
|
*
|
|
* With no block given, returns an array containing each element
|
|
* for which <tt>pattern === element</tt> is +false+:
|
|
*
|
|
* a = ['foo', 'bar', 'car', 'moo']
|
|
* a.grep_v(/ar/) # => ["foo", "moo"]
|
|
* (1..10).grep_v(3..8) # => [1, 2, 9, 10]
|
|
* ['a', 'b', 0, 1].grep_v(Integer) # => ["a", "b"]
|
|
*
|
|
* With a block given,
|
|
* calls the block with each non-matching element and returns an array containing each
|
|
* object returned by the block:
|
|
*
|
|
* a = ['foo', 'bar', 'car', 'moo']
|
|
* a.grep_v(/ar/) {|element| element.upcase } # => ["FOO", "MOO"]
|
|
*
|
|
* Related: #grep.
|
|
*/
|
|
|
|
static VALUE
|
|
enum_grep_v(VALUE obj, VALUE pat)
|
|
{
|
|
return enum_grep0(obj, pat, Qfalse);
|
|
}
|
|
|
|
#define COUNT_BIGNUM IMEMO_FL_USER0
|
|
#define MEMO_V3_SET(m, v) RB_OBJ_WRITE((m), &(m)->u3.value, (v))
|
|
|
|
static void
|
|
imemo_count_up(struct MEMO *memo)
|
|
{
|
|
if (memo->flags & COUNT_BIGNUM) {
|
|
MEMO_V3_SET(memo, rb_int_succ(memo->u3.value));
|
|
}
|
|
else if (++memo->u3.cnt == 0) {
|
|
/* overflow */
|
|
unsigned long buf[2] = {0, 1};
|
|
MEMO_V3_SET(memo, rb_big_unpack(buf, 2));
|
|
memo->flags |= COUNT_BIGNUM;
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
imemo_count_value(struct MEMO *memo)
|
|
{
|
|
if (memo->flags & COUNT_BIGNUM) {
|
|
return memo->u3.value;
|
|
}
|
|
else {
|
|
return ULONG2NUM(memo->u3.cnt);
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
count_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(memop);
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (rb_equal(i, memo->v1)) {
|
|
imemo_count_up(memo);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
count_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(memop);
|
|
|
|
if (RTEST(rb_yield_values2(argc, argv))) {
|
|
imemo_count_up(memo);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
count_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(memop);
|
|
|
|
imemo_count_up(memo);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* count -> integer
|
|
* count(object) -> integer
|
|
* count {|element| ... } -> integer
|
|
*
|
|
* Returns the count of elements, based on an argument or block criterion, if given.
|
|
*
|
|
* With no argument and no block given, returns the number of elements:
|
|
*
|
|
* [0, 1, 2].count # => 3
|
|
* {foo: 0, bar: 1, baz: 2}.count # => 3
|
|
*
|
|
* With argument +object+ given,
|
|
* returns the number of elements that are <tt>==</tt> to +object+:
|
|
*
|
|
* [0, 1, 2, 1].count(1) # => 2
|
|
*
|
|
* With a block given, calls the block with each element
|
|
* and returns the number of elements for which the block returns a truthy value:
|
|
*
|
|
* [0, 1, 2, 3].count {|element| element < 2} # => 2
|
|
* {foo: 0, bar: 1, baz: 2}.count {|key, value| value < 2} # => 2
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_count(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
VALUE item = Qnil;
|
|
struct MEMO *memo;
|
|
rb_block_call_func *func;
|
|
|
|
if (argc == 0) {
|
|
if (rb_block_given_p()) {
|
|
func = count_iter_i;
|
|
}
|
|
else {
|
|
func = count_all_i;
|
|
}
|
|
}
|
|
else {
|
|
rb_scan_args(argc, argv, "1", &item);
|
|
if (rb_block_given_p()) {
|
|
rb_warn("given block not used");
|
|
}
|
|
func = count_i;
|
|
}
|
|
|
|
memo = MEMO_NEW(item, 0, 0);
|
|
rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
|
|
return imemo_count_value(memo);
|
|
}
|
|
|
|
static VALUE
|
|
find_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (RTEST(enum_yield(argc, i))) {
|
|
struct MEMO *memo = MEMO_CAST(memop);
|
|
MEMO_V1_SET(memo, i);
|
|
memo->u3.cnt = 1;
|
|
rb_iter_break();
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* find(if_none_proc = nil) {|element| ... } -> object or nil
|
|
* find(if_none_proc = nil) -> enumerator
|
|
*
|
|
* Returns the first element for which the block returns a truthy value.
|
|
*
|
|
* With a block given, calls the block with successive elements of the collection;
|
|
* returns the first element for which the block returns a truthy value:
|
|
*
|
|
* (0..9).find {|element| element > 2} # => 3
|
|
*
|
|
* If no such element is found, calls +if_none_proc+ and returns its return value.
|
|
*
|
|
* (0..9).find(proc {false}) {|element| element > 12} # => false
|
|
* {foo: 0, bar: 1, baz: 2}.find {|key, value| key.start_with?('b') } # => [:bar, 1]
|
|
* {foo: 0, bar: 1, baz: 2}.find(proc {[]}) {|key, value| key.start_with?('c') } # => []
|
|
*
|
|
* With no block given, returns an \Enumerator.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_find(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo;
|
|
VALUE if_none;
|
|
|
|
if_none = rb_check_arity(argc, 0, 1) ? argv[0] : Qnil;
|
|
RETURN_ENUMERATOR(obj, argc, argv);
|
|
memo = MEMO_NEW(Qundef, 0, 0);
|
|
rb_block_call(obj, id_each, 0, 0, find_i, (VALUE)memo);
|
|
if (memo->u3.cnt) {
|
|
return memo->v1;
|
|
}
|
|
if (!NIL_P(if_none)) {
|
|
return rb_funcallv(if_none, id_call, 0, 0);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
find_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(memop);
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (rb_equal(i, memo->v2)) {
|
|
MEMO_V1_SET(memo, imemo_count_value(memo));
|
|
rb_iter_break();
|
|
}
|
|
imemo_count_up(memo);
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
find_index_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(memop);
|
|
|
|
if (RTEST(rb_yield_values2(argc, argv))) {
|
|
MEMO_V1_SET(memo, imemo_count_value(memo));
|
|
rb_iter_break();
|
|
}
|
|
imemo_count_up(memo);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* find_index(object) -> integer or nil
|
|
* find_index {|element| ... } -> integer or nil
|
|
* find_index -> enumerator
|
|
*
|
|
* Returns the index of the first element that meets a specified criterion,
|
|
* or +nil+ if no such element is found.
|
|
*
|
|
* With argument +object+ given,
|
|
* returns the index of the first element that is <tt>==</tt> +object+:
|
|
*
|
|
* ['a', 'b', 'c', 'b'].find_index('b') # => 1
|
|
*
|
|
* With a block given, calls the block with successive elements;
|
|
* returns the first element for which the block returns a truthy value:
|
|
*
|
|
* ['a', 'b', 'c', 'b'].find_index {|element| element.start_with?('b') } # => 1
|
|
* {foo: 0, bar: 1, baz: 2}.find_index {|key, value| value > 1 } # => 2
|
|
*
|
|
* With no argument and no block given, returns an \Enumerator.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_find_index(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo; /* [return value, current index, ] */
|
|
VALUE condition_value = Qnil;
|
|
rb_block_call_func *func;
|
|
|
|
if (argc == 0) {
|
|
RETURN_ENUMERATOR(obj, 0, 0);
|
|
func = find_index_iter_i;
|
|
}
|
|
else {
|
|
rb_scan_args(argc, argv, "1", &condition_value);
|
|
if (rb_block_given_p()) {
|
|
rb_warn("given block not used");
|
|
}
|
|
func = find_index_i;
|
|
}
|
|
|
|
memo = MEMO_NEW(Qnil, condition_value, 0);
|
|
rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
|
|
return memo->v1;
|
|
}
|
|
|
|
static VALUE
|
|
find_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (RTEST(enum_yield(argc, i))) {
|
|
rb_ary_push(ary, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
enum_size(VALUE self, VALUE args, VALUE eobj)
|
|
{
|
|
return rb_check_funcall_default(self, id_size, 0, 0, Qnil);
|
|
}
|
|
|
|
static long
|
|
limit_by_enum_size(VALUE obj, long n)
|
|
{
|
|
unsigned long limit;
|
|
VALUE size = rb_check_funcall(obj, id_size, 0, 0);
|
|
if (!FIXNUM_P(size)) return n;
|
|
limit = FIX2ULONG(size);
|
|
return ((unsigned long)n > limit) ? (long)limit : n;
|
|
}
|
|
|
|
static int
|
|
enum_size_over_p(VALUE obj, long n)
|
|
{
|
|
VALUE size = rb_check_funcall(obj, id_size, 0, 0);
|
|
if (!FIXNUM_P(size)) return 0;
|
|
return ((unsigned long)n > FIX2ULONG(size));
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* select {|element| ... } -> array
|
|
* select -> enumerator
|
|
*
|
|
* Returns an array containing elements selected by the block.
|
|
*
|
|
* With a block given, calls the block with successive elements;
|
|
* returns an array of those elements for which the block returns a truthy value:
|
|
*
|
|
* (0..9).select {|element| element % 3 == 0 } # => [0, 3, 6, 9]
|
|
* a = {foo: 0, bar: 1, baz: 2}.select {|key, value| key.start_with?('b') }
|
|
* a # => {:bar=>1, :baz=>2}
|
|
*
|
|
* With no block given, returns an \Enumerator.
|
|
*
|
|
* Related: #reject.
|
|
*/
|
|
static VALUE
|
|
enum_find_all(VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
ary = rb_ary_new();
|
|
rb_block_call(obj, id_each, 0, 0, find_all_i, ary);
|
|
|
|
return ary;
|
|
}
|
|
|
|
static VALUE
|
|
filter_map_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
i = rb_yield_values2(argc, argv);
|
|
|
|
if (RTEST(i)) {
|
|
rb_ary_push(ary, i);
|
|
}
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* filter_map {|element| ... } -> array
|
|
* filter_map -> enumerator
|
|
*
|
|
* Returns an array containing truthy elements returned by the block.
|
|
*
|
|
* With a block given, calls the block with successive elements;
|
|
* returns an array containing each truthy value returned by the block:
|
|
*
|
|
* (0..9).filter_map {|i| i * 2 if i.even? } # => [0, 4, 8, 12, 16]
|
|
* {foo: 0, bar: 1, baz: 2}.filter_map {|key, value| key if value.even? } # => [:foo, :baz]
|
|
*
|
|
* When no block given, returns an \Enumerator.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_filter_map(VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
ary = rb_ary_new();
|
|
rb_block_call(obj, id_each, 0, 0, filter_map_i, ary);
|
|
|
|
return ary;
|
|
}
|
|
|
|
|
|
static VALUE
|
|
reject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (!RTEST(enum_yield(argc, i))) {
|
|
rb_ary_push(ary, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* reject {|element| ... } -> array
|
|
* reject -> enumerator
|
|
*
|
|
* Returns an array of objects rejected by the block.
|
|
*
|
|
* With a block given, calls the block with successive elements;
|
|
* returns an array of those elements for which the block returns +nil+ or +false+:
|
|
*
|
|
* (0..9).reject {|i| i * 2 if i.even? } # => [1, 3, 5, 7, 9]
|
|
* {foo: 0, bar: 1, baz: 2}.reject {|key, value| key if value.odd? } # => {:foo=>0, :baz=>2}
|
|
*
|
|
* When no block given, returns an \Enumerator.
|
|
*
|
|
* Related: #select.
|
|
*/
|
|
|
|
static VALUE
|
|
enum_reject(VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
ary = rb_ary_new();
|
|
rb_block_call(obj, id_each, 0, 0, reject_i, ary);
|
|
|
|
return ary;
|
|
}
|
|
|
|
static VALUE
|
|
collect_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
rb_ary_push(ary, rb_yield_values2(argc, argv));
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
collect_all(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
rb_ary_push(ary, rb_enum_values_pack(argc, argv));
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* map {|element| ... } -> array
|
|
* map -> enumerator
|
|
*
|
|
* Returns an array of objects returned by the block.
|
|
*
|
|
* With a block given, calls the block with successive elements;
|
|
* returns an array of the objects returned by the block:
|
|
*
|
|
* (0..4).map {|i| i*i } # => [0, 1, 4, 9, 16]
|
|
* {foo: 0, bar: 1, baz: 2}.map {|key, value| value*2} # => [0, 2, 4]
|
|
*
|
|
* With no block given, returns an \Enumerator.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_collect(VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
int min_argc, max_argc;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
ary = rb_ary_new();
|
|
min_argc = rb_block_min_max_arity(&max_argc);
|
|
rb_lambda_call(obj, id_each, 0, 0, collect_i, min_argc, max_argc, ary);
|
|
|
|
return ary;
|
|
}
|
|
|
|
static VALUE
|
|
flat_map_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
VALUE tmp;
|
|
|
|
i = rb_yield_values2(argc, argv);
|
|
tmp = rb_check_array_type(i);
|
|
|
|
if (NIL_P(tmp)) {
|
|
rb_ary_push(ary, i);
|
|
}
|
|
else {
|
|
rb_ary_concat(ary, tmp);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* flat_map {|element| ... } -> array
|
|
* flat_map -> enumerator
|
|
*
|
|
* Returns an array of flattened objects returned by the block.
|
|
*
|
|
* With a block given, calls the block with successive elements;
|
|
* returns a flattened array of objects returned by the block:
|
|
*
|
|
* [0, 1, 2, 3].flat_map {|element| -element } # => [0, -1, -2, -3]
|
|
* [0, 1, 2, 3].flat_map {|element| [element, -element] } # => [0, 0, 1, -1, 2, -2, 3, -3]
|
|
* [[0, 1], [2, 3]].flat_map {|e| e + [100] } # => [0, 1, 100, 2, 3, 100]
|
|
* {foo: 0, bar: 1, baz: 2}.flat_map {|key, value| [key, value] } # => [:foo, 0, :bar, 1, :baz, 2]
|
|
*
|
|
* With no block given, returns an \Enumerator.
|
|
*
|
|
* Alias: #collect_concat.
|
|
*/
|
|
static VALUE
|
|
enum_flat_map(VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
ary = rb_ary_new();
|
|
rb_block_call(obj, id_each, 0, 0, flat_map_i, ary);
|
|
|
|
return ary;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* to_a -> array
|
|
*
|
|
* Returns an array containing the items in +self+:
|
|
*
|
|
* (0..4).to_a # => [0, 1, 2, 3, 4]
|
|
*
|
|
* Enumerable#entries is an alias for Enumerable#to_a.
|
|
*/
|
|
static VALUE
|
|
enum_to_a(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
VALUE ary = rb_ary_new();
|
|
|
|
rb_block_call_kw(obj, id_each, argc, argv, collect_all, ary, RB_PASS_CALLED_KEYWORDS);
|
|
|
|
return ary;
|
|
}
|
|
|
|
static VALUE
|
|
enum_hashify_into(VALUE obj, int argc, const VALUE *argv, rb_block_call_func *iter, VALUE hash)
|
|
{
|
|
rb_block_call(obj, id_each, argc, argv, iter, hash);
|
|
return hash;
|
|
}
|
|
|
|
static VALUE
|
|
enum_hashify(VALUE obj, int argc, const VALUE *argv, rb_block_call_func *iter)
|
|
{
|
|
return enum_hashify_into(obj, argc, argv, iter, rb_hash_new());
|
|
}
|
|
|
|
static VALUE
|
|
enum_to_h_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
return rb_hash_set_pair(hash, i);
|
|
}
|
|
|
|
static VALUE
|
|
enum_to_h_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
|
|
{
|
|
return rb_hash_set_pair(hash, rb_yield_values2(argc, argv));
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* to_h -> hash
|
|
* to_h {|element| ... } -> hash
|
|
*
|
|
* When +self+ consists of 2-element arrays,
|
|
* returns a hash each of whose entries is the key-value pair
|
|
* formed from one of those arrays:
|
|
*
|
|
* [[:foo, 0], [:bar, 1], [:baz, 2]].to_h # => {:foo=>0, :bar=>1, :baz=>2}
|
|
*
|
|
* When a block is given, the block is called with each element of +self+;
|
|
* the block should return a 2-element array which becomes a key-value pair
|
|
* in the returned hash:
|
|
*
|
|
* (0..3).to_h {|i| [i, i ** 2]} # => {0=>0, 1=>1, 2=>4, 3=>9}
|
|
*
|
|
* Raises an exception if an element of +self+ is not a 2-element array,
|
|
* and a block is not passed.
|
|
*/
|
|
|
|
static VALUE
|
|
enum_to_h(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
rb_block_call_func *iter = rb_block_given_p() ? enum_to_h_ii : enum_to_h_i;
|
|
return enum_hashify(obj, argc, argv, iter);
|
|
}
|
|
|
|
static VALUE
|
|
inject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(p);
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->v1 == Qundef) {
|
|
MEMO_V1_SET(memo, i);
|
|
}
|
|
else {
|
|
MEMO_V1_SET(memo, rb_yield_values(2, memo->v1, i));
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
inject_op_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(p);
|
|
VALUE name;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->v1 == Qundef) {
|
|
MEMO_V1_SET(memo, i);
|
|
}
|
|
else if (SYMBOL_P(name = memo->u3.value)) {
|
|
const ID mid = SYM2ID(name);
|
|
MEMO_V1_SET(memo, rb_funcallv_public(memo->v1, mid, 1, &i));
|
|
}
|
|
else {
|
|
VALUE args[2];
|
|
args[0] = name;
|
|
args[1] = i;
|
|
MEMO_V1_SET(memo, rb_f_send(numberof(args), args, memo->v1));
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
ary_inject_op(VALUE ary, VALUE init, VALUE op)
|
|
{
|
|
ID id;
|
|
VALUE v, e;
|
|
long i, n;
|
|
|
|
if (RARRAY_LEN(ary) == 0)
|
|
return init == Qundef ? Qnil : init;
|
|
|
|
if (init == Qundef) {
|
|
v = RARRAY_AREF(ary, 0);
|
|
i = 1;
|
|
if (RARRAY_LEN(ary) == 1)
|
|
return v;
|
|
}
|
|
else {
|
|
v = init;
|
|
i = 0;
|
|
}
|
|
|
|
id = SYM2ID(op);
|
|
if (id == idPLUS) {
|
|
if (RB_INTEGER_TYPE_P(v) &&
|
|
rb_method_basic_definition_p(rb_cInteger, idPLUS) &&
|
|
rb_obj_respond_to(v, idPLUS, FALSE)) {
|
|
n = 0;
|
|
for (; i < RARRAY_LEN(ary); i++) {
|
|
e = RARRAY_AREF(ary, i);
|
|
if (FIXNUM_P(e)) {
|
|
n += FIX2LONG(e); /* should not overflow long type */
|
|
if (!FIXABLE(n)) {
|
|
v = rb_big_plus(LONG2NUM(n), v);
|
|
n = 0;
|
|
}
|
|
}
|
|
else if (RB_BIGNUM_TYPE_P(e))
|
|
v = rb_big_plus(e, v);
|
|
else
|
|
goto not_integer;
|
|
}
|
|
if (n != 0)
|
|
v = rb_fix_plus(LONG2FIX(n), v);
|
|
return v;
|
|
|
|
not_integer:
|
|
if (n != 0)
|
|
v = rb_fix_plus(LONG2FIX(n), v);
|
|
}
|
|
}
|
|
for (; i < RARRAY_LEN(ary); i++) {
|
|
VALUE arg = RARRAY_AREF(ary, i);
|
|
v = rb_funcallv_public(v, id, 1, &arg);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* inject(symbol) -> object
|
|
* inject(initial_operand, symbol) -> object
|
|
* inject {|memo, operand| ... } -> object
|
|
* inject(initial_operand) {|memo, operand| ... } -> object
|
|
*
|
|
* Returns an object formed from operands via either:
|
|
*
|
|
* - A method named by +symbol+.
|
|
* - A block to which each operand is passed.
|
|
*
|
|
* With method-name argument +symbol+,
|
|
* combines operands using the method:
|
|
*
|
|
* # Sum, without initial_operand.
|
|
* (1..4).inject(:+) # => 10
|
|
* # Sum, with initial_operand.
|
|
* (1..4).inject(10, :+) # => 20
|
|
*
|
|
* With a block, passes each operand to the block:
|
|
*
|
|
* # Sum of squares, without initial_operand.
|
|
* (1..4).inject {|sum, n| sum + n*n } # => 30
|
|
* # Sum of squares, with initial_operand.
|
|
* (1..4).inject(2) {|sum, n| sum + n*n } # => 32
|
|
*
|
|
* <b>Operands</b>
|
|
*
|
|
* If argument +initial_operand+ is not given,
|
|
* the operands for +inject+ are simply the elements of +self+.
|
|
* Example calls and their operands:
|
|
*
|
|
* - <tt>(1..4).inject(:+)</tt>:: <tt>[1, 2, 3, 4]</tt>.
|
|
* - <tt>(1...4).inject(:+)</tt>:: <tt>[1, 2, 3]</tt>.
|
|
* - <tt>('a'..'d').inject(:+)</tt>:: <tt>['a', 'b', 'c', 'd']</tt>.
|
|
* - <tt>('a'...'d').inject(:+)</tt>:: <tt>['a', 'b', 'c']</tt>.
|
|
*
|
|
* Examples with first operand (which is <tt>self.first</tt>) of various types:
|
|
*
|
|
* # Integer.
|
|
* (1..4).inject(:+) # => 10
|
|
* # Float.
|
|
* [1.0, 2, 3, 4].inject(:+) # => 10.0
|
|
* # Character.
|
|
* ('a'..'d').inject(:+) # => "abcd"
|
|
* # Complex.
|
|
* [Complex(1, 2), 3, 4].inject(:+) # => (8+2i)
|
|
*
|
|
* If argument +initial_operand+ is given,
|
|
* the operands for +inject+ are that value plus the elements of +self+.
|
|
* Example calls their operands:
|
|
*
|
|
* - <tt>(1..4).inject(10, :+)</tt>:: <tt>[10, 1, 2, 3, 4]</tt>.
|
|
* - <tt>(1...4).inject(10, :+)</tt>:: <tt>[10, 1, 2, 3]</tt>.
|
|
* - <tt>('a'..'d').inject('e', :+)</tt>:: <tt>['e', 'a', 'b', 'c', 'd']</tt>.
|
|
* - <tt>('a'...'d').inject('e', :+)</tt>:: <tt>['e', 'a', 'b', 'c']</tt>.
|
|
*
|
|
* Examples with +initial_operand+ of various types:
|
|
*
|
|
* # Integer.
|
|
* (1..4).inject(2, :+) # => 12
|
|
* # Float.
|
|
* (1..4).inject(2.0, :+) # => 12.0
|
|
* # String.
|
|
* ('a'..'d').inject('foo', :+) # => "fooabcd"
|
|
* # Array.
|
|
* %w[a b c].inject(['x'], :push) # => ["x", "a", "b", "c"]
|
|
* # Complex.
|
|
* (1..4).inject(Complex(2, 2), :+) # => (12+2i)
|
|
*
|
|
* <b>Combination by Given \Method</b>
|
|
*
|
|
* If the method-name argument +symbol+ is given,
|
|
* the operands are combined by that method:
|
|
*
|
|
* - The first and second operands are combined.
|
|
* - That result is combined with the third operand.
|
|
* - That result is combined with the fourth operand.
|
|
* - And so on.
|
|
*
|
|
* The return value from +inject+ is the result of the last combination.
|
|
*
|
|
* This call to +inject+ computes the sum of the operands:
|
|
*
|
|
* (1..4).inject(:+) # => 10
|
|
*
|
|
* Examples with various methods:
|
|
*
|
|
* # Integer addition.
|
|
* (1..4).inject(:+) # => 10
|
|
* # Integer multiplication.
|
|
* (1..4).inject(:*) # => 24
|
|
* # Character range concatenation.
|
|
* ('a'..'d').inject('', :+) # => "abcd"
|
|
* # String array concatenation.
|
|
* %w[foo bar baz].inject('', :+) # => "foobarbaz"
|
|
* # Hash update.
|
|
* h = [{foo: 0, bar: 1}, {baz: 2}, {bat: 3}].inject(:update)
|
|
* h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3}
|
|
* # Hash conversion to nested arrays.
|
|
* h = {foo: 0, bar: 1}.inject([], :push)
|
|
* h # => [[:foo, 0], [:bar, 1]]
|
|
*
|
|
* <b>Combination by Given Block</b>
|
|
*
|
|
* If a block is given, the operands are passed to the block:
|
|
*
|
|
* - The first call passes the first and second operands.
|
|
* - The second call passes the result of the first call,
|
|
* along with the third operand.
|
|
* - The third call passes the result of the second call,
|
|
* along with the fourth operand.
|
|
* - And so on.
|
|
*
|
|
* The return value from +inject+ is the return value from the last block call.
|
|
*
|
|
* This call to +inject+ gives a block
|
|
* that writes the memo and element, and also sums the elements:
|
|
*
|
|
* (1..4).inject do |memo, element|
|
|
* p "Memo: #{memo}; element: #{element}"
|
|
* memo + element
|
|
* end # => 10
|
|
*
|
|
* Output:
|
|
*
|
|
* "Memo: 1; element: 2"
|
|
* "Memo: 3; element: 3"
|
|
* "Memo: 6; element: 4"
|
|
*
|
|
* Enumerable#reduce is an alias for Enumerable#inject.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_inject(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo;
|
|
VALUE init, op;
|
|
rb_block_call_func *iter = inject_i;
|
|
ID id;
|
|
|
|
switch (rb_scan_args(argc, argv, "02", &init, &op)) {
|
|
case 0:
|
|
init = Qundef;
|
|
break;
|
|
case 1:
|
|
if (rb_block_given_p()) {
|
|
break;
|
|
}
|
|
id = rb_check_id(&init);
|
|
op = id ? ID2SYM(id) : init;
|
|
init = Qundef;
|
|
iter = inject_op_i;
|
|
break;
|
|
case 2:
|
|
if (rb_block_given_p()) {
|
|
rb_warning("given block not used");
|
|
}
|
|
id = rb_check_id(&op);
|
|
if (id) op = ID2SYM(id);
|
|
iter = inject_op_i;
|
|
break;
|
|
}
|
|
|
|
if (iter == inject_op_i &&
|
|
SYMBOL_P(op) &&
|
|
RB_TYPE_P(obj, T_ARRAY) &&
|
|
rb_method_basic_definition_p(CLASS_OF(obj), id_each)) {
|
|
return ary_inject_op(obj, init, op);
|
|
}
|
|
|
|
memo = MEMO_NEW(init, Qnil, op);
|
|
rb_block_call(obj, id_each, 0, 0, iter, (VALUE)memo);
|
|
if (memo->v1 == Qundef) return Qnil;
|
|
return memo->v1;
|
|
}
|
|
|
|
static VALUE
|
|
partition_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, arys))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(arys);
|
|
VALUE ary;
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (RTEST(enum_yield(argc, i))) {
|
|
ary = memo->v1;
|
|
}
|
|
else {
|
|
ary = memo->v2;
|
|
}
|
|
rb_ary_push(ary, i);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* partition {|element| ... } -> [true_array, false_array]
|
|
* partition -> enumerator
|
|
*
|
|
* With a block given, returns an array of two arrays:
|
|
*
|
|
* - The first having those elements for which the block returns a truthy value.
|
|
* - The other having all other elements.
|
|
*
|
|
* Examples:
|
|
*
|
|
* p = (1..4).partition {|i| i.even? }
|
|
* p # => [[2, 4], [1, 3]]
|
|
* p = ('a'..'d').partition {|c| c < 'c' }
|
|
* p # => [["a", "b"], ["c", "d"]]
|
|
* h = {foo: 0, bar: 1, baz: 2, bat: 3}
|
|
* p = h.partition {|key, value| key.start_with?('b') }
|
|
* p # => [[[:bar, 1], [:baz, 2], [:bat, 3]], [[:foo, 0]]]
|
|
* p = h.partition {|key, value| value < 2 }
|
|
* p # => [[[:foo, 0], [:bar, 1]], [[:baz, 2], [:bat, 3]]]
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
* Related: Enumerable#group_by.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_partition(VALUE obj)
|
|
{
|
|
struct MEMO *memo;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
memo = MEMO_NEW(rb_ary_new(), rb_ary_new(), 0);
|
|
rb_block_call(obj, id_each, 0, 0, partition_i, (VALUE)memo);
|
|
|
|
return rb_assoc_new(memo->v1, memo->v2);
|
|
}
|
|
|
|
static VALUE
|
|
group_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
|
|
{
|
|
VALUE group;
|
|
VALUE values;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
group = enum_yield(argc, i);
|
|
values = rb_hash_aref(hash, group);
|
|
if (!RB_TYPE_P(values, T_ARRAY)) {
|
|
values = rb_ary_new3(1, i);
|
|
rb_hash_aset(hash, group, values);
|
|
}
|
|
else {
|
|
rb_ary_push(values, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* group_by {|element| ... } -> hash
|
|
* group_by -> enumerator
|
|
*
|
|
* With a block given returns a hash:
|
|
*
|
|
* - Each key is a return value from the block.
|
|
* - Each value is an array of those elements for which the block returned that key.
|
|
*
|
|
* Examples:
|
|
*
|
|
* g = (1..6).group_by {|i| i%3 }
|
|
* g # => {1=>[1, 4], 2=>[2, 5], 0=>[3, 6]}
|
|
* h = {foo: 0, bar: 1, baz: 0, bat: 1}
|
|
* g = h.group_by {|key, value| value }
|
|
* g # => {0=>[[:foo, 0], [:baz, 0]], 1=>[[:bar, 1], [:bat, 1]]}
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_group_by(VALUE obj)
|
|
{
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
return enum_hashify(obj, 0, 0, group_by_i);
|
|
}
|
|
|
|
static int
|
|
tally_up(st_data_t *group, st_data_t *value, st_data_t arg, int existing)
|
|
{
|
|
VALUE tally = (VALUE)*value;
|
|
VALUE hash = (VALUE)arg;
|
|
if (!existing) {
|
|
tally = INT2FIX(1);
|
|
}
|
|
else if (FIXNUM_P(tally) && tally < INT2FIX(FIXNUM_MAX)) {
|
|
tally += INT2FIX(1) & ~FIXNUM_FLAG;
|
|
}
|
|
else {
|
|
Check_Type(tally, T_BIGNUM);
|
|
tally = rb_big_plus(tally, INT2FIX(1));
|
|
RB_OBJ_WRITTEN(hash, Qundef, tally);
|
|
}
|
|
*value = (st_data_t)tally;
|
|
if (!SPECIAL_CONST_P(*group)) RB_OBJ_WRITTEN(hash, Qundef, *group);
|
|
return ST_CONTINUE;
|
|
}
|
|
|
|
static VALUE
|
|
rb_enum_tally_up(VALUE hash, VALUE group)
|
|
{
|
|
rb_hash_stlike_update(hash, group, tally_up, (st_data_t)hash);
|
|
return hash;
|
|
}
|
|
|
|
static VALUE
|
|
tally_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
rb_enum_tally_up(hash, i);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* tally -> new_hash
|
|
* tally(hash) -> hash
|
|
*
|
|
* Returns a hash containing the counts of equal elements:
|
|
*
|
|
* - Each key is an element of +self+.
|
|
* - Each value is the number elements equal to that key.
|
|
*
|
|
* With no argument:
|
|
*
|
|
* %w[a b c b c a c b].tally # => {"a"=>2, "b"=>3, "c"=>3}
|
|
*
|
|
* With a hash argument, that hash is used for the tally (instead of a new hash),
|
|
* and is returned;
|
|
* this may be useful for accumulating tallies across multiple enumerables:
|
|
*
|
|
* hash = {}
|
|
* hash = %w[a c d b c a].tally(hash)
|
|
* hash # => {"a"=>2, "c"=>2, "d"=>1, "b"=>1}
|
|
* hash = %w[b a z].tally(hash)
|
|
* hash # => {"a"=>3, "c"=>2, "d"=>1, "b"=>2, "z"=>1}
|
|
* hash = %w[b a m].tally(hash)
|
|
* hash # => {"a"=>4, "c"=>2, "d"=>1, "b"=>3, "z"=>1, "m"=> 1}
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_tally(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
VALUE hash;
|
|
if (rb_check_arity(argc, 0, 1)) {
|
|
hash = rb_convert_type(argv[0], T_HASH, "Hash", "to_hash");
|
|
rb_check_frozen(hash);
|
|
}
|
|
else {
|
|
hash = rb_hash_new();
|
|
}
|
|
|
|
return enum_hashify_into(obj, 0, 0, tally_i, hash);
|
|
}
|
|
|
|
NORETURN(static VALUE first_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, params)));
|
|
static VALUE
|
|
first_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, params))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(params);
|
|
ENUM_WANT_SVALUE();
|
|
|
|
MEMO_V1_SET(memo, i);
|
|
rb_iter_break();
|
|
|
|
UNREACHABLE_RETURN(Qnil);
|
|
}
|
|
|
|
static VALUE enum_take(VALUE obj, VALUE n);
|
|
|
|
/*
|
|
* call-seq:
|
|
* first -> element or nil
|
|
* first(n) -> array
|
|
*
|
|
* Returns the first element or elements.
|
|
*
|
|
* With no argument, returns the first element, or +nil+ if there is none:
|
|
*
|
|
* (1..4).first # => 1
|
|
* %w[a b c].first # => "a"
|
|
* {foo: 1, bar: 1, baz: 2}.first # => [:foo, 1]
|
|
* [].first # => nil
|
|
*
|
|
* With integer argument +n+, returns an array
|
|
* containing the first +n+ elements that exist:
|
|
*
|
|
* (1..4).first(2) # => [1, 2]
|
|
* %w[a b c d].first(3) # => ["a", "b", "c"]
|
|
* %w[a b c d].first(50) # => ["a", "b", "c", "d"]
|
|
* {foo: 1, bar: 1, baz: 2}.first(2) # => [[:foo, 1], [:bar, 1]]
|
|
* [].first(2) # => []
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_first(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo;
|
|
rb_check_arity(argc, 0, 1);
|
|
if (argc > 0) {
|
|
return enum_take(obj, argv[0]);
|
|
}
|
|
else {
|
|
memo = MEMO_NEW(Qnil, 0, 0);
|
|
rb_block_call(obj, id_each, 0, 0, first_i, (VALUE)memo);
|
|
return memo->v1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* sort -> array
|
|
* sort {|a, b| ... } -> array
|
|
*
|
|
* Returns an array containing the sorted elements of +self+.
|
|
* The ordering of equal elements is indeterminate and may be unstable.
|
|
*
|
|
* With no block given, the sort compares
|
|
* using the elements' own method <tt><=></tt>:
|
|
*
|
|
* %w[b c a d].sort # => ["a", "b", "c", "d"]
|
|
* {foo: 0, bar: 1, baz: 2}.sort # => [[:bar, 1], [:baz, 2], [:foo, 0]]
|
|
*
|
|
* With a block given, comparisons in the block determine the ordering.
|
|
* The block is called with two elements +a+ and +b+, and must return:
|
|
*
|
|
* - A negative integer if <tt>a < b</tt>.
|
|
* - Zero if <tt>a == b</tt>.
|
|
* - A positive integer if <tt>a > b</tt>.
|
|
*
|
|
* Examples:
|
|
*
|
|
* a = %w[b c a d]
|
|
* a.sort {|a, b| b <=> a } # => ["d", "c", "b", "a"]
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* h.sort {|a, b| b <=> a } # => [[:foo, 0], [:baz, 2], [:bar, 1]]
|
|
*
|
|
* See also #sort_by. It implements a Schwartzian transform
|
|
* which is useful when key computation or comparison is expensive.
|
|
*/
|
|
|
|
static VALUE
|
|
enum_sort(VALUE obj)
|
|
{
|
|
return rb_ary_sort_bang(enum_to_a(0, 0, obj));
|
|
}
|
|
|
|
#define SORT_BY_BUFSIZE 16
|
|
struct sort_by_data {
|
|
const VALUE ary;
|
|
const VALUE buf;
|
|
long n;
|
|
};
|
|
|
|
static VALUE
|
|
sort_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data))
|
|
{
|
|
struct sort_by_data *data = (struct sort_by_data *)&MEMO_CAST(_data)->v1;
|
|
VALUE ary = data->ary;
|
|
VALUE v;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
v = enum_yield(argc, i);
|
|
|
|
if (RBASIC(ary)->klass) {
|
|
rb_raise(rb_eRuntimeError, "sort_by reentered");
|
|
}
|
|
if (RARRAY_LEN(data->buf) != SORT_BY_BUFSIZE*2) {
|
|
rb_raise(rb_eRuntimeError, "sort_by reentered");
|
|
}
|
|
|
|
RARRAY_ASET(data->buf, data->n*2, v);
|
|
RARRAY_ASET(data->buf, data->n*2+1, i);
|
|
data->n++;
|
|
if (data->n == SORT_BY_BUFSIZE) {
|
|
rb_ary_concat(ary, data->buf);
|
|
data->n = 0;
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static int
|
|
sort_by_cmp(const void *ap, const void *bp, void *data)
|
|
{
|
|
struct cmp_opt_data cmp_opt = { 0, 0 };
|
|
VALUE a;
|
|
VALUE b;
|
|
VALUE ary = (VALUE)data;
|
|
|
|
if (RBASIC(ary)->klass) {
|
|
rb_raise(rb_eRuntimeError, "sort_by reentered");
|
|
}
|
|
|
|
a = *(VALUE *)ap;
|
|
b = *(VALUE *)bp;
|
|
|
|
return OPTIMIZED_CMP(a, b, cmp_opt);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* sort_by {|element| ... } -> array
|
|
* sort_by -> enumerator
|
|
*
|
|
* With a block given, returns an array of elements of +self+,
|
|
* sorted according to the value returned by the block for each element.
|
|
* The ordering of equal elements is indeterminate and may be unstable.
|
|
*
|
|
* Examples:
|
|
*
|
|
* a = %w[xx xxx x xxxx]
|
|
* a.sort_by {|s| s.size } # => ["x", "xx", "xxx", "xxxx"]
|
|
* a.sort_by {|s| -s.size } # => ["xxxx", "xxx", "xx", "x"]
|
|
* h = {foo: 2, bar: 1, baz: 0}
|
|
* h.sort_by{|key, value| value } # => [[:baz, 0], [:bar, 1], [:foo, 2]]
|
|
* h.sort_by{|key, value| key } # => [[:bar, 1], [:baz, 0], [:foo, 2]]
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
* The current implementation of #sort_by generates an array of
|
|
* tuples containing the original collection element and the mapped
|
|
* value. This makes #sort_by fairly expensive when the keysets are
|
|
* simple.
|
|
*
|
|
* require 'benchmark'
|
|
*
|
|
* a = (1..100000).map { rand(100000) }
|
|
*
|
|
* Benchmark.bm(10) do |b|
|
|
* b.report("Sort") { a.sort }
|
|
* b.report("Sort by") { a.sort_by { |a| a } }
|
|
* end
|
|
*
|
|
* <em>produces:</em>
|
|
*
|
|
* user system total real
|
|
* Sort 0.180000 0.000000 0.180000 ( 0.175469)
|
|
* Sort by 1.980000 0.040000 2.020000 ( 2.013586)
|
|
*
|
|
* However, consider the case where comparing the keys is a non-trivial
|
|
* operation. The following code sorts some files on modification time
|
|
* using the basic #sort method.
|
|
*
|
|
* files = Dir["*"]
|
|
* sorted = files.sort { |a, b| File.new(a).mtime <=> File.new(b).mtime }
|
|
* sorted #=> ["mon", "tues", "wed", "thurs"]
|
|
*
|
|
* This sort is inefficient: it generates two new File
|
|
* objects during every comparison. A slightly better technique is to
|
|
* use the Kernel#test method to generate the modification
|
|
* times directly.
|
|
*
|
|
* files = Dir["*"]
|
|
* sorted = files.sort { |a, b|
|
|
* test(?M, a) <=> test(?M, b)
|
|
* }
|
|
* sorted #=> ["mon", "tues", "wed", "thurs"]
|
|
*
|
|
* This still generates many unnecessary Time objects. A more
|
|
* efficient technique is to cache the sort keys (modification times
|
|
* in this case) before the sort. Perl users often call this approach
|
|
* a Schwartzian transform, after Randal Schwartz. We construct a
|
|
* temporary array, where each element is an array containing our
|
|
* sort key along with the filename. We sort this array, and then
|
|
* extract the filename from the result.
|
|
*
|
|
* sorted = Dir["*"].collect { |f|
|
|
* [test(?M, f), f]
|
|
* }.sort.collect { |f| f[1] }
|
|
* sorted #=> ["mon", "tues", "wed", "thurs"]
|
|
*
|
|
* This is exactly what #sort_by does internally.
|
|
*
|
|
* sorted = Dir["*"].sort_by { |f| test(?M, f) }
|
|
* sorted #=> ["mon", "tues", "wed", "thurs"]
|
|
*
|
|
* To produce the reverse of a specific order, the following can be used:
|
|
*
|
|
* ary.sort_by { ... }.reverse!
|
|
*/
|
|
|
|
static VALUE
|
|
enum_sort_by(VALUE obj)
|
|
{
|
|
VALUE ary, buf;
|
|
struct MEMO *memo;
|
|
long i;
|
|
struct sort_by_data *data;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
if (RB_TYPE_P(obj, T_ARRAY) && RARRAY_LEN(obj) <= LONG_MAX/2) {
|
|
ary = rb_ary_new2(RARRAY_LEN(obj)*2);
|
|
}
|
|
else {
|
|
ary = rb_ary_new();
|
|
}
|
|
RBASIC_CLEAR_CLASS(ary);
|
|
buf = rb_ary_tmp_new(SORT_BY_BUFSIZE*2);
|
|
rb_ary_store(buf, SORT_BY_BUFSIZE*2-1, Qnil);
|
|
memo = MEMO_NEW(0, 0, 0);
|
|
data = (struct sort_by_data *)&memo->v1;
|
|
RB_OBJ_WRITE(memo, &data->ary, ary);
|
|
RB_OBJ_WRITE(memo, &data->buf, buf);
|
|
data->n = 0;
|
|
rb_block_call(obj, id_each, 0, 0, sort_by_i, (VALUE)memo);
|
|
ary = data->ary;
|
|
buf = data->buf;
|
|
if (data->n) {
|
|
rb_ary_resize(buf, data->n*2);
|
|
rb_ary_concat(ary, buf);
|
|
}
|
|
if (RARRAY_LEN(ary) > 2) {
|
|
RARRAY_PTR_USE(ary, ptr,
|
|
ruby_qsort(ptr, RARRAY_LEN(ary)/2, 2*sizeof(VALUE),
|
|
sort_by_cmp, (void *)ary));
|
|
}
|
|
if (RBASIC(ary)->klass) {
|
|
rb_raise(rb_eRuntimeError, "sort_by reentered");
|
|
}
|
|
for (i=1; i<RARRAY_LEN(ary); i+=2) {
|
|
RARRAY_ASET(ary, i/2, RARRAY_AREF(ary, i));
|
|
}
|
|
rb_ary_resize(ary, RARRAY_LEN(ary)/2);
|
|
RBASIC_SET_CLASS_RAW(ary, rb_cArray);
|
|
|
|
return ary;
|
|
}
|
|
|
|
#define ENUMFUNC(name) argc ? name##_eqq : rb_block_given_p() ? name##_iter_i : name##_i
|
|
|
|
#define MEMO_ENUM_NEW(v1) (rb_check_arity(argc, 0, 1), MEMO_NEW((v1), (argc ? *argv : 0), 0))
|
|
|
|
#define DEFINE_ENUMFUNCS(name) \
|
|
static VALUE enum_##name##_func(VALUE result, struct MEMO *memo); \
|
|
\
|
|
static VALUE \
|
|
name##_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \
|
|
{ \
|
|
return enum_##name##_func(rb_enum_values_pack(argc, argv), MEMO_CAST(memo)); \
|
|
} \
|
|
\
|
|
static VALUE \
|
|
name##_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \
|
|
{ \
|
|
return enum_##name##_func(rb_yield_values2(argc, argv), MEMO_CAST(memo)); \
|
|
} \
|
|
\
|
|
static VALUE \
|
|
name##_eqq(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \
|
|
{ \
|
|
ENUM_WANT_SVALUE(); \
|
|
return enum_##name##_func(rb_funcallv(MEMO_CAST(memo)->v2, id_eqq, 1, &i), MEMO_CAST(memo)); \
|
|
} \
|
|
\
|
|
static VALUE \
|
|
enum_##name##_func(VALUE result, struct MEMO *memo)
|
|
|
|
#define WARN_UNUSED_BLOCK(argc) do { \
|
|
if ((argc) > 0 && rb_block_given_p()) { \
|
|
rb_warn("given block not used"); \
|
|
} \
|
|
} while (0)
|
|
|
|
DEFINE_ENUMFUNCS(all)
|
|
{
|
|
if (!RTEST(result)) {
|
|
MEMO_V1_SET(memo, Qfalse);
|
|
rb_iter_break();
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* all? -> true or false
|
|
* all?(pattern) -> true or false
|
|
* all? {|element| ... } -> true or false
|
|
*
|
|
* Returns whether every element meets a given criterion.
|
|
*
|
|
* With no argument and no block,
|
|
* returns whether every element is truthy:
|
|
*
|
|
* (1..4).all? # => true
|
|
* %w[a b c d].all? # => true
|
|
* [1, 2, nil].all? # => false
|
|
* ['a','b', false].all? # => false
|
|
* [].all? # => true
|
|
*
|
|
* With argument +pattern+ and no block,
|
|
* returns whether for each element +element+,
|
|
* <tt>pattern === element</tt>:
|
|
*
|
|
* (1..4).all?(Integer) # => true
|
|
* (1..4).all?(Numeric) # => true
|
|
* (1..4).all?(Float) # => false
|
|
* %w[bar baz bat bam].all?(/ba/) # => true
|
|
* %w[bar baz bat bam].all?(/bar/) # => false
|
|
* %w[bar baz bat bam].all?('ba') # => false
|
|
* {foo: 0, bar: 1, baz: 2}.all?(Array) # => true
|
|
* {foo: 0, bar: 1, baz: 2}.all?(Hash) # => false
|
|
* [].all?(Integer) # => true
|
|
*
|
|
* With a block given, returns whether the block returns a truthy value
|
|
* for every element:
|
|
*
|
|
* (1..4).all? {|element| element < 5 } # => true
|
|
* (1..4).all? {|element| element < 4 } # => false
|
|
* {foo: 0, bar: 1, baz: 2}.all? {|key, value| value < 3 } # => true
|
|
* {foo: 0, bar: 1, baz: 2}.all? {|key, value| value < 2 } # => false
|
|
*
|
|
* Related: #any?, #none? #one?.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_all(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo = MEMO_ENUM_NEW(Qtrue);
|
|
WARN_UNUSED_BLOCK(argc);
|
|
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(all), (VALUE)memo);
|
|
return memo->v1;
|
|
}
|
|
|
|
DEFINE_ENUMFUNCS(any)
|
|
{
|
|
if (RTEST(result)) {
|
|
MEMO_V1_SET(memo, Qtrue);
|
|
rb_iter_break();
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* any? -> true or false
|
|
* any?(pattern) -> true or false
|
|
* any? {|element| ... } -> true or false
|
|
*
|
|
* Returns whether any element meets a given criterion.
|
|
*
|
|
* With no argument and no block,
|
|
* returns whether any element is truthy:
|
|
*
|
|
* (1..4).any? # => true
|
|
* %w[a b c d].any? # => true
|
|
* [1, false, nil].any? # => true
|
|
* [].any? # => false
|
|
*
|
|
* With argument +pattern+ and no block,
|
|
* returns whether for any element +element+,
|
|
* <tt>pattern === element</tt>:
|
|
*
|
|
* [nil, false, 0].any?(Integer) # => true
|
|
* [nil, false, 0].any?(Numeric) # => true
|
|
* [nil, false, 0].any?(Float) # => false
|
|
* %w[bar baz bat bam].any?(/m/) # => true
|
|
* %w[bar baz bat bam].any?(/foo/) # => false
|
|
* %w[bar baz bat bam].any?('ba') # => false
|
|
* {foo: 0, bar: 1, baz: 2}.any?(Array) # => true
|
|
* {foo: 0, bar: 1, baz: 2}.any?(Hash) # => false
|
|
* [].any?(Integer) # => false
|
|
*
|
|
* With a block given, returns whether the block returns a truthy value
|
|
* for any element:
|
|
*
|
|
* (1..4).any? {|element| element < 2 } # => true
|
|
* (1..4).any? {|element| element < 1 } # => false
|
|
* {foo: 0, bar: 1, baz: 2}.any? {|key, value| value < 1 } # => true
|
|
* {foo: 0, bar: 1, baz: 2}.any? {|key, value| value < 0 } # => false
|
|
*
|
|
*
|
|
* Related: #all?, #none?, #one?.
|
|
*/
|
|
|
|
static VALUE
|
|
enum_any(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo = MEMO_ENUM_NEW(Qfalse);
|
|
WARN_UNUSED_BLOCK(argc);
|
|
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(any), (VALUE)memo);
|
|
return memo->v1;
|
|
}
|
|
|
|
DEFINE_ENUMFUNCS(one)
|
|
{
|
|
if (RTEST(result)) {
|
|
if (memo->v1 == Qundef) {
|
|
MEMO_V1_SET(memo, Qtrue);
|
|
}
|
|
else if (memo->v1 == Qtrue) {
|
|
MEMO_V1_SET(memo, Qfalse);
|
|
rb_iter_break();
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
struct nmin_data {
|
|
long n;
|
|
long bufmax;
|
|
long curlen;
|
|
VALUE buf;
|
|
VALUE limit;
|
|
int (*cmpfunc)(const void *, const void *, void *);
|
|
int rev: 1; /* max if 1 */
|
|
int by: 1; /* min_by if 1 */
|
|
};
|
|
|
|
static VALUE
|
|
cmpint_reenter_check(struct nmin_data *data, VALUE val)
|
|
{
|
|
if (RBASIC(data->buf)->klass) {
|
|
rb_raise(rb_eRuntimeError, "%s%s reentered",
|
|
data->rev ? "max" : "min",
|
|
data->by ? "_by" : "");
|
|
}
|
|
return val;
|
|
}
|
|
|
|
static int
|
|
nmin_cmp(const void *ap, const void *bp, void *_data)
|
|
{
|
|
struct cmp_opt_data cmp_opt = { 0, 0 };
|
|
struct nmin_data *data = (struct nmin_data *)_data;
|
|
VALUE a = *(const VALUE *)ap, b = *(const VALUE *)bp;
|
|
#define rb_cmpint(cmp, a, b) rb_cmpint(cmpint_reenter_check(data, (cmp)), a, b)
|
|
return OPTIMIZED_CMP(a, b, cmp_opt);
|
|
#undef rb_cmpint
|
|
}
|
|
|
|
static int
|
|
nmin_block_cmp(const void *ap, const void *bp, void *_data)
|
|
{
|
|
struct nmin_data *data = (struct nmin_data *)_data;
|
|
VALUE a = *(const VALUE *)ap, b = *(const VALUE *)bp;
|
|
VALUE cmp = rb_yield_values(2, a, b);
|
|
cmpint_reenter_check(data, cmp);
|
|
return rb_cmpint(cmp, a, b);
|
|
}
|
|
|
|
static void
|
|
nmin_filter(struct nmin_data *data)
|
|
{
|
|
long n;
|
|
VALUE *beg;
|
|
int eltsize;
|
|
long numelts;
|
|
|
|
long left, right;
|
|
long store_index;
|
|
|
|
long i, j;
|
|
|
|
if (data->curlen <= data->n)
|
|
return;
|
|
|
|
n = data->n;
|
|
beg = RARRAY_PTR(data->buf);
|
|
eltsize = data->by ? 2 : 1;
|
|
numelts = data->curlen;
|
|
|
|
left = 0;
|
|
right = numelts-1;
|
|
|
|
#define GETPTR(i) (beg+(i)*eltsize)
|
|
|
|
#define SWAP(i, j) do { \
|
|
VALUE tmp[2]; \
|
|
memcpy(tmp, GETPTR(i), sizeof(VALUE)*eltsize); \
|
|
memcpy(GETPTR(i), GETPTR(j), sizeof(VALUE)*eltsize); \
|
|
memcpy(GETPTR(j), tmp, sizeof(VALUE)*eltsize); \
|
|
} while (0)
|
|
|
|
while (1) {
|
|
long pivot_index = left + (right-left)/2;
|
|
long num_pivots = 1;
|
|
|
|
SWAP(pivot_index, right);
|
|
pivot_index = right;
|
|
|
|
store_index = left;
|
|
i = left;
|
|
while (i <= right-num_pivots) {
|
|
int c = data->cmpfunc(GETPTR(i), GETPTR(pivot_index), data);
|
|
if (data->rev)
|
|
c = -c;
|
|
if (c == 0) {
|
|
SWAP(i, right-num_pivots);
|
|
num_pivots++;
|
|
continue;
|
|
}
|
|
if (c < 0) {
|
|
SWAP(i, store_index);
|
|
store_index++;
|
|
}
|
|
i++;
|
|
}
|
|
j = store_index;
|
|
for (i = right; right-num_pivots < i; i--) {
|
|
if (i <= j)
|
|
break;
|
|
SWAP(j, i);
|
|
j++;
|
|
}
|
|
|
|
if (store_index <= n && n <= store_index+num_pivots)
|
|
break;
|
|
|
|
if (n < store_index) {
|
|
right = store_index-1;
|
|
}
|
|
else {
|
|
left = store_index+num_pivots;
|
|
}
|
|
}
|
|
#undef GETPTR
|
|
#undef SWAP
|
|
|
|
data->limit = RARRAY_AREF(data->buf, store_index*eltsize); /* the last pivot */
|
|
data->curlen = data->n;
|
|
rb_ary_resize(data->buf, data->n * eltsize);
|
|
}
|
|
|
|
static VALUE
|
|
nmin_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data))
|
|
{
|
|
struct nmin_data *data = (struct nmin_data *)_data;
|
|
VALUE cmpv;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (data->by)
|
|
cmpv = enum_yield(argc, i);
|
|
else
|
|
cmpv = i;
|
|
|
|
if (data->limit != Qundef) {
|
|
int c = data->cmpfunc(&cmpv, &data->limit, data);
|
|
if (data->rev)
|
|
c = -c;
|
|
if (c >= 0)
|
|
return Qnil;
|
|
}
|
|
|
|
if (data->by)
|
|
rb_ary_push(data->buf, cmpv);
|
|
rb_ary_push(data->buf, i);
|
|
|
|
data->curlen++;
|
|
|
|
if (data->curlen == data->bufmax) {
|
|
nmin_filter(data);
|
|
}
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
VALUE
|
|
rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary)
|
|
{
|
|
VALUE result;
|
|
struct nmin_data data;
|
|
|
|
data.n = NUM2LONG(num);
|
|
if (data.n < 0)
|
|
rb_raise(rb_eArgError, "negative size (%ld)", data.n);
|
|
if (data.n == 0)
|
|
return rb_ary_new2(0);
|
|
if (LONG_MAX/4/(by ? 2 : 1) < data.n)
|
|
rb_raise(rb_eArgError, "too big size");
|
|
data.bufmax = data.n * 4;
|
|
data.curlen = 0;
|
|
data.buf = rb_ary_tmp_new(data.bufmax * (by ? 2 : 1));
|
|
data.limit = Qundef;
|
|
data.cmpfunc = by ? nmin_cmp :
|
|
rb_block_given_p() ? nmin_block_cmp :
|
|
nmin_cmp;
|
|
data.rev = rev;
|
|
data.by = by;
|
|
if (ary) {
|
|
long i;
|
|
for (i = 0; i < RARRAY_LEN(obj); i++) {
|
|
VALUE args[1];
|
|
args[0] = RARRAY_AREF(obj, i);
|
|
nmin_i(obj, (VALUE)&data, 1, args, Qundef);
|
|
}
|
|
}
|
|
else {
|
|
rb_block_call(obj, id_each, 0, 0, nmin_i, (VALUE)&data);
|
|
}
|
|
nmin_filter(&data);
|
|
result = data.buf;
|
|
if (by) {
|
|
long i;
|
|
RARRAY_PTR_USE(result, ptr, {
|
|
ruby_qsort(ptr,
|
|
RARRAY_LEN(result)/2,
|
|
sizeof(VALUE)*2,
|
|
data.cmpfunc, (void *)&data);
|
|
for (i=1; i<RARRAY_LEN(result); i+=2) {
|
|
ptr[i/2] = ptr[i];
|
|
}
|
|
});
|
|
rb_ary_resize(result, RARRAY_LEN(result)/2);
|
|
}
|
|
else {
|
|
RARRAY_PTR_USE(result, ptr, {
|
|
ruby_qsort(ptr, RARRAY_LEN(result), sizeof(VALUE),
|
|
data.cmpfunc, (void *)&data);
|
|
});
|
|
}
|
|
if (rev) {
|
|
rb_ary_reverse(result);
|
|
}
|
|
RBASIC_SET_CLASS(result, rb_cArray);
|
|
return result;
|
|
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* one? -> true or false
|
|
* one?(pattern) -> true or false
|
|
* one? {|element| ... } -> true or false
|
|
*
|
|
* Returns whether exactly one element meets a given criterion.
|
|
*
|
|
* With no argument and no block,
|
|
* returns whether exactly one element is truthy:
|
|
*
|
|
* (1..1).one? # => true
|
|
* [1, nil, false].one? # => true
|
|
* (1..4).one? # => false
|
|
* {foo: 0}.one? # => true
|
|
* {foo: 0, bar: 1}.one? # => false
|
|
* [].one? # => false
|
|
*
|
|
* With argument +pattern+ and no block,
|
|
* returns whether for exactly one element +element+,
|
|
* <tt>pattern === element</tt>:
|
|
*
|
|
* [nil, false, 0].one?(Integer) # => true
|
|
* [nil, false, 0].one?(Numeric) # => true
|
|
* [nil, false, 0].one?(Float) # => false
|
|
* %w[bar baz bat bam].one?(/m/) # => true
|
|
* %w[bar baz bat bam].one?(/foo/) # => false
|
|
* %w[bar baz bat bam].one?('ba') # => false
|
|
* {foo: 0, bar: 1, baz: 2}.one?(Array) # => false
|
|
* {foo: 0}.one?(Array) # => true
|
|
* [].one?(Integer) # => false
|
|
*
|
|
* With a block given, returns whether the block returns a truthy value
|
|
* for exactly one element:
|
|
*
|
|
* (1..4).one? {|element| element < 2 } # => true
|
|
* (1..4).one? {|element| element < 1 } # => false
|
|
* {foo: 0, bar: 1, baz: 2}.one? {|key, value| value < 1 } # => true
|
|
* {foo: 0, bar: 1, baz: 2}.one? {|key, value| value < 2 } # => false
|
|
*
|
|
* Related: #none?, #all?, #any?.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_one(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo = MEMO_ENUM_NEW(Qundef);
|
|
VALUE result;
|
|
|
|
WARN_UNUSED_BLOCK(argc);
|
|
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(one), (VALUE)memo);
|
|
result = memo->v1;
|
|
if (result == Qundef) return Qfalse;
|
|
return result;
|
|
}
|
|
|
|
DEFINE_ENUMFUNCS(none)
|
|
{
|
|
if (RTEST(result)) {
|
|
MEMO_V1_SET(memo, Qfalse);
|
|
rb_iter_break();
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* none? -> true or false
|
|
* none?(pattern) -> true or false
|
|
* none? {|element| ... } -> true or false
|
|
*
|
|
* Returns whether no element meets a given criterion.
|
|
*
|
|
* With no argument and no block,
|
|
* returns whether no element is truthy:
|
|
*
|
|
* (1..4).none? # => false
|
|
* [nil, false].none? # => true
|
|
* {foo: 0}.none? # => false
|
|
* {foo: 0, bar: 1}.none? # => false
|
|
* [].none? # => true
|
|
*
|
|
* With argument +pattern+ and no block,
|
|
* returns whether for no element +element+,
|
|
* <tt>pattern === element</tt>:
|
|
*
|
|
* [nil, false, 1.1].none?(Integer) # => true
|
|
* %w[bar baz bat bam].none?(/m/) # => false
|
|
* %w[bar baz bat bam].none?(/foo/) # => true
|
|
* %w[bar baz bat bam].none?('ba') # => true
|
|
* {foo: 0, bar: 1, baz: 2}.none?(Hash) # => true
|
|
* {foo: 0}.none?(Array) # => false
|
|
* [].none?(Integer) # => true
|
|
*
|
|
* With a block given, returns whether the block returns a truthy value
|
|
* for no element:
|
|
*
|
|
* (1..4).none? {|element| element < 1 } # => true
|
|
* (1..4).none? {|element| element < 2 } # => false
|
|
* {foo: 0, bar: 1, baz: 2}.none? {|key, value| value < 0 } # => true
|
|
* {foo: 0, bar: 1, baz: 2}.none? {|key, value| value < 1 } # => false
|
|
*
|
|
* Related: #one?, #all?, #any?.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_none(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo = MEMO_ENUM_NEW(Qtrue);
|
|
|
|
WARN_UNUSED_BLOCK(argc);
|
|
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(none), (VALUE)memo);
|
|
return memo->v1;
|
|
}
|
|
|
|
struct min_t {
|
|
VALUE min;
|
|
struct cmp_opt_data cmp_opt;
|
|
};
|
|
|
|
static VALUE
|
|
min_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct min_t *memo = MEMO_FOR(struct min_t, args);
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->min == Qundef) {
|
|
memo->min = i;
|
|
}
|
|
else {
|
|
if (OPTIMIZED_CMP(i, memo->min, memo->cmp_opt) < 0) {
|
|
memo->min = i;
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
min_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
VALUE cmp;
|
|
struct min_t *memo = MEMO_FOR(struct min_t, args);
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->min == Qundef) {
|
|
memo->min = i;
|
|
}
|
|
else {
|
|
cmp = rb_yield_values(2, i, memo->min);
|
|
if (rb_cmpint(cmp, i, memo->min) < 0) {
|
|
memo->min = i;
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
|
|
/*
|
|
* call-seq:
|
|
* min -> element
|
|
* min(n) -> array
|
|
* min {|a, b| ... } -> element
|
|
* min(n) {|a, b| ... } -> array
|
|
*
|
|
* Returns the element with the minimum element according to a given criterion.
|
|
* The ordering of equal elements is indeterminate and may be unstable.
|
|
*
|
|
* With no argument and no block, returns the minimum element,
|
|
* using the elements' own method <tt><=></tt> for comparison:
|
|
*
|
|
* (1..4).min # => 1
|
|
* (-4..-1).min # => -4
|
|
* %w[d c b a].min # => "a"
|
|
* {foo: 0, bar: 1, baz: 2}.min # => [:bar, 1]
|
|
* [].min # => nil
|
|
*
|
|
* With positive integer argument +n+ given, and no block,
|
|
* returns an array containing the first +n+ minimum elements that exist:
|
|
*
|
|
* (1..4).min(2) # => [1, 2]
|
|
* (-4..-1).min(2) # => [-4, -3]
|
|
* %w[d c b a].min(2) # => ["a", "b"]
|
|
* {foo: 0, bar: 1, baz: 2}.min(2) # => [[:bar, 1], [:baz, 2]]
|
|
* [].min(2) # => []
|
|
*
|
|
* With a block given, the block determines the minimum elements.
|
|
* The block is called with two elements +a+ and +b+, and must return:
|
|
*
|
|
* - A negative integer if <tt>a < b</tt>.
|
|
* - Zero if <tt>a == b</tt>.
|
|
* - A positive integer if <tt>a > b</tt>.
|
|
*
|
|
* With a block given and no argument,
|
|
* returns the minimum element as determined by the block:
|
|
*
|
|
* %w[xxx x xxxx xx].min {|a, b| a.size <=> b.size } # => "x"
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* h.min {|pair1, pair2| pair1[1] <=> pair2[1] } # => [:foo, 0]
|
|
* [].min {|a, b| a <=> b } # => nil
|
|
*
|
|
* With a block given and positive integer argument +n+ given,
|
|
* returns an array containing the first +n+ minimum elements that exist,
|
|
* as determined by the block.
|
|
*
|
|
* %w[xxx x xxxx xx].min(2) {|a, b| a.size <=> b.size } # => ["x", "xx"]
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* h.min(2) {|pair1, pair2| pair1[1] <=> pair2[1] }
|
|
* # => [[:foo, 0], [:bar, 1]]
|
|
* [].min(2) {|a, b| a <=> b } # => []
|
|
*
|
|
* Related: #min_by, #minmax, #max.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_min(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
VALUE memo;
|
|
struct min_t *m = NEW_CMP_OPT_MEMO(struct min_t, memo);
|
|
VALUE result;
|
|
VALUE num;
|
|
|
|
if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))
|
|
return rb_nmin_run(obj, num, 0, 0, 0);
|
|
|
|
m->min = Qundef;
|
|
m->cmp_opt.opt_methods = 0;
|
|
m->cmp_opt.opt_inited = 0;
|
|
if (rb_block_given_p()) {
|
|
rb_block_call(obj, id_each, 0, 0, min_ii, memo);
|
|
}
|
|
else {
|
|
rb_block_call(obj, id_each, 0, 0, min_i, memo);
|
|
}
|
|
result = m->min;
|
|
if (result == Qundef) return Qnil;
|
|
return result;
|
|
}
|
|
|
|
struct max_t {
|
|
VALUE max;
|
|
struct cmp_opt_data cmp_opt;
|
|
};
|
|
|
|
static VALUE
|
|
max_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct max_t *memo = MEMO_FOR(struct max_t, args);
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->max == Qundef) {
|
|
memo->max = i;
|
|
}
|
|
else {
|
|
if (OPTIMIZED_CMP(i, memo->max, memo->cmp_opt) > 0) {
|
|
memo->max = i;
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
max_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct max_t *memo = MEMO_FOR(struct max_t, args);
|
|
VALUE cmp;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->max == Qundef) {
|
|
memo->max = i;
|
|
}
|
|
else {
|
|
cmp = rb_yield_values(2, i, memo->max);
|
|
if (rb_cmpint(cmp, i, memo->max) > 0) {
|
|
memo->max = i;
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* max -> element
|
|
* max(n) -> array
|
|
* max {|a, b| ... } -> element
|
|
* max(n) {|a, b| ... } -> array
|
|
*
|
|
* Returns the element with the maximum element according to a given criterion.
|
|
* The ordering of equal elements is indeterminate and may be unstable.
|
|
*
|
|
* With no argument and no block, returns the maximum element,
|
|
* using the elements' own method <tt><=></tt> for comparison:
|
|
*
|
|
* (1..4).max # => 4
|
|
* (-4..-1).max # => -1
|
|
* %w[d c b a].max # => "d"
|
|
* {foo: 0, bar: 1, baz: 2}.max # => [:foo, 0]
|
|
* [].max # => nil
|
|
*
|
|
* With positive integer argument +n+ given, and no block,
|
|
* returns an array containing the first +n+ maximum elements that exist:
|
|
*
|
|
* (1..4).max(2) # => [4, 3]
|
|
* (-4..-1).max(2) # => [-1, -2]
|
|
* %w[d c b a].max(2) # => ["d", "c"]
|
|
* {foo: 0, bar: 1, baz: 2}.max(2) # => [[:foo, 0], [:baz, 2]]
|
|
* [].max(2) # => []
|
|
*
|
|
* With a block given, the block determines the maximum elements.
|
|
* The block is called with two elements +a+ and +b+, and must return:
|
|
*
|
|
* - A negative integer if <tt>a < b</tt>.
|
|
* - Zero if <tt>a == b</tt>.
|
|
* - A positive integer if <tt>a > b</tt>.
|
|
*
|
|
* With a block given and no argument,
|
|
* returns the maximum element as determined by the block:
|
|
*
|
|
* %w[xxx x xxxx xx].max {|a, b| a.size <=> b.size } # => "xxxx"
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* h.max {|pair1, pair2| pair1[1] <=> pair2[1] } # => [:baz, 2]
|
|
* [].max {|a, b| a <=> b } # => nil
|
|
*
|
|
* With a block given and positive integer argument +n+ given,
|
|
* returns an array containing the first +n+ maximum elements that exist,
|
|
* as determined by the block.
|
|
*
|
|
* %w[xxx x xxxx xx].max(2) {|a, b| a.size <=> b.size } # => ["xxxx", "xxx"]
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* h.max(2) {|pair1, pair2| pair1[1] <=> pair2[1] }
|
|
* # => [[:baz, 2], [:bar, 1]]
|
|
* [].max(2) {|a, b| a <=> b } # => []
|
|
*
|
|
* Related: #min, #minmax, #max_by.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_max(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
VALUE memo;
|
|
struct max_t *m = NEW_CMP_OPT_MEMO(struct max_t, memo);
|
|
VALUE result;
|
|
VALUE num;
|
|
|
|
if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))
|
|
return rb_nmin_run(obj, num, 0, 1, 0);
|
|
|
|
m->max = Qundef;
|
|
m->cmp_opt.opt_methods = 0;
|
|
m->cmp_opt.opt_inited = 0;
|
|
if (rb_block_given_p()) {
|
|
rb_block_call(obj, id_each, 0, 0, max_ii, (VALUE)memo);
|
|
}
|
|
else {
|
|
rb_block_call(obj, id_each, 0, 0, max_i, (VALUE)memo);
|
|
}
|
|
result = m->max;
|
|
if (result == Qundef) return Qnil;
|
|
return result;
|
|
}
|
|
|
|
struct minmax_t {
|
|
VALUE min;
|
|
VALUE max;
|
|
VALUE last;
|
|
struct cmp_opt_data cmp_opt;
|
|
};
|
|
|
|
static void
|
|
minmax_i_update(VALUE i, VALUE j, struct minmax_t *memo)
|
|
{
|
|
int n;
|
|
|
|
if (memo->min == Qundef) {
|
|
memo->min = i;
|
|
memo->max = j;
|
|
}
|
|
else {
|
|
n = OPTIMIZED_CMP(i, memo->min, memo->cmp_opt);
|
|
if (n < 0) {
|
|
memo->min = i;
|
|
}
|
|
n = OPTIMIZED_CMP(j, memo->max, memo->cmp_opt);
|
|
if (n > 0) {
|
|
memo->max = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
minmax_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
|
|
{
|
|
struct minmax_t *memo = MEMO_FOR(struct minmax_t, _memo);
|
|
int n;
|
|
VALUE j;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->last == Qundef) {
|
|
memo->last = i;
|
|
return Qnil;
|
|
}
|
|
j = memo->last;
|
|
memo->last = Qundef;
|
|
|
|
n = OPTIMIZED_CMP(j, i, memo->cmp_opt);
|
|
if (n == 0)
|
|
i = j;
|
|
else if (n < 0) {
|
|
VALUE tmp;
|
|
tmp = i;
|
|
i = j;
|
|
j = tmp;
|
|
}
|
|
|
|
minmax_i_update(i, j, memo);
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
static void
|
|
minmax_ii_update(VALUE i, VALUE j, struct minmax_t *memo)
|
|
{
|
|
int n;
|
|
|
|
if (memo->min == Qundef) {
|
|
memo->min = i;
|
|
memo->max = j;
|
|
}
|
|
else {
|
|
n = rb_cmpint(rb_yield_values(2, i, memo->min), i, memo->min);
|
|
if (n < 0) {
|
|
memo->min = i;
|
|
}
|
|
n = rb_cmpint(rb_yield_values(2, j, memo->max), j, memo->max);
|
|
if (n > 0) {
|
|
memo->max = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
minmax_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
|
|
{
|
|
struct minmax_t *memo = MEMO_FOR(struct minmax_t, _memo);
|
|
int n;
|
|
VALUE j;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->last == Qundef) {
|
|
memo->last = i;
|
|
return Qnil;
|
|
}
|
|
j = memo->last;
|
|
memo->last = Qundef;
|
|
|
|
n = rb_cmpint(rb_yield_values(2, j, i), j, i);
|
|
if (n == 0)
|
|
i = j;
|
|
else if (n < 0) {
|
|
VALUE tmp;
|
|
tmp = i;
|
|
i = j;
|
|
j = tmp;
|
|
}
|
|
|
|
minmax_ii_update(i, j, memo);
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* minmax -> [minimum, maximum]
|
|
* minmax {|a, b| ... } -> [minimum, maximum]
|
|
*
|
|
* Returns a 2-element array containing the minimum and maximum elements
|
|
* according to a given criterion.
|
|
* The ordering of equal elements is indeterminate and may be unstable.
|
|
*
|
|
* With no argument and no block, returns the minimum and maximum elements,
|
|
* using the elements' own method <tt><=></tt> for comparison:
|
|
*
|
|
* (1..4).minmax # => [1, 4]
|
|
* (-4..-1).minmax # => [-4, -1]
|
|
* %w[d c b a].minmax # => ["a", "d"]
|
|
* {foo: 0, bar: 1, baz: 2}.minmax # => [[:bar, 1], [:foo, 0]]
|
|
* [].minmax # => [nil, nil]
|
|
*
|
|
* With a block given, returns the minimum and maximum elements
|
|
* as determined by the block:
|
|
*
|
|
* %w[xxx x xxxx xx].minmax {|a, b| a.size <=> b.size } # => ["x", "xxxx"]
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* h.minmax {|pair1, pair2| pair1[1] <=> pair2[1] }
|
|
* # => [[:foo, 0], [:baz, 2]]
|
|
* [].minmax {|a, b| a <=> b } # => [nil, nil]
|
|
*
|
|
* Related: #min, #max, #minmax_by.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_minmax(VALUE obj)
|
|
{
|
|
VALUE memo;
|
|
struct minmax_t *m = NEW_CMP_OPT_MEMO(struct minmax_t, memo);
|
|
|
|
m->min = Qundef;
|
|
m->last = Qundef;
|
|
m->cmp_opt.opt_methods = 0;
|
|
m->cmp_opt.opt_inited = 0;
|
|
if (rb_block_given_p()) {
|
|
rb_block_call(obj, id_each, 0, 0, minmax_ii, memo);
|
|
if (m->last != Qundef)
|
|
minmax_ii_update(m->last, m->last, m);
|
|
}
|
|
else {
|
|
rb_block_call(obj, id_each, 0, 0, minmax_i, memo);
|
|
if (m->last != Qundef)
|
|
minmax_i_update(m->last, m->last, m);
|
|
}
|
|
if (m->min != Qundef) {
|
|
return rb_assoc_new(m->min, m->max);
|
|
}
|
|
return rb_assoc_new(Qnil, Qnil);
|
|
}
|
|
|
|
static VALUE
|
|
min_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct cmp_opt_data cmp_opt = { 0, 0 };
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
VALUE v;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
v = enum_yield(argc, i);
|
|
if (memo->v1 == Qundef) {
|
|
MEMO_V1_SET(memo, v);
|
|
MEMO_V2_SET(memo, i);
|
|
}
|
|
else if (OPTIMIZED_CMP(v, memo->v1, cmp_opt) < 0) {
|
|
MEMO_V1_SET(memo, v);
|
|
MEMO_V2_SET(memo, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* min_by {|element| ... } -> element
|
|
* min_by(n) {|element| ... } -> array
|
|
* min_by -> enumerator
|
|
* min_by(n) -> enumerator
|
|
*
|
|
* Returns the elements for which the block returns the minimum values.
|
|
*
|
|
* With a block given and no argument,
|
|
* returns the element for which the block returns the minimum value:
|
|
*
|
|
* (1..4).min_by {|element| -element } # => 4
|
|
* %w[a b c d].min_by {|element| -element.ord } # => "d"
|
|
* {foo: 0, bar: 1, baz: 2}.min_by {|key, value| -value } # => [:baz, 2]
|
|
* [].min_by {|element| -element } # => nil
|
|
*
|
|
* With a block given and positive integer argument +n+ given,
|
|
* returns an array containing the +n+ elements
|
|
* for which the block returns minimum values:
|
|
*
|
|
* (1..4).min_by(2) {|element| -element }
|
|
* # => [4, 3]
|
|
* %w[a b c d].min_by(2) {|element| -element.ord }
|
|
* # => ["d", "c"]
|
|
* {foo: 0, bar: 1, baz: 2}.min_by(2) {|key, value| -value }
|
|
* # => [[:baz, 2], [:bar, 1]]
|
|
* [].min_by(2) {|element| -element }
|
|
* # => []
|
|
*
|
|
* Returns an Enumerator if no block is given.
|
|
*
|
|
* Related: #min, #minmax, #max_by.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_min_by(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo;
|
|
VALUE num;
|
|
|
|
rb_check_arity(argc, 0, 1);
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
|
|
|
|
if (argc && !NIL_P(num = argv[0]))
|
|
return rb_nmin_run(obj, num, 1, 0, 0);
|
|
|
|
memo = MEMO_NEW(Qundef, Qnil, 0);
|
|
rb_block_call(obj, id_each, 0, 0, min_by_i, (VALUE)memo);
|
|
return memo->v2;
|
|
}
|
|
|
|
static VALUE
|
|
max_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct cmp_opt_data cmp_opt = { 0, 0 };
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
VALUE v;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
v = enum_yield(argc, i);
|
|
if (memo->v1 == Qundef) {
|
|
MEMO_V1_SET(memo, v);
|
|
MEMO_V2_SET(memo, i);
|
|
}
|
|
else if (OPTIMIZED_CMP(v, memo->v1, cmp_opt) > 0) {
|
|
MEMO_V1_SET(memo, v);
|
|
MEMO_V2_SET(memo, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* max_by {|element| ... } -> element
|
|
* max_by(n) {|element| ... } -> array
|
|
* max_by -> enumerator
|
|
* max_by(n) -> enumerator
|
|
*
|
|
* Returns the elements for which the block returns the maximum values.
|
|
*
|
|
* With a block given and no argument,
|
|
* returns the element for which the block returns the maximum value:
|
|
*
|
|
* (1..4).max_by {|element| -element } # => 1
|
|
* %w[a b c d].max_by {|element| -element.ord } # => "a"
|
|
* {foo: 0, bar: 1, baz: 2}.max_by {|key, value| -value } # => [:foo, 0]
|
|
* [].max_by {|element| -element } # => nil
|
|
*
|
|
* With a block given and positive integer argument +n+ given,
|
|
* returns an array containing the +n+ elements
|
|
* for which the block returns maximum values:
|
|
*
|
|
* (1..4).max_by(2) {|element| -element }
|
|
* # => [1, 2]
|
|
* %w[a b c d].max_by(2) {|element| -element.ord }
|
|
* # => ["a", "b"]
|
|
* {foo: 0, bar: 1, baz: 2}.max_by(2) {|key, value| -value }
|
|
* # => [[:foo, 0], [:bar, 1]]
|
|
* [].max_by(2) {|element| -element }
|
|
* # => []
|
|
*
|
|
* Returns an Enumerator if no block is given.
|
|
*
|
|
* Related: #max, #minmax, #min_by.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_max_by(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo;
|
|
VALUE num;
|
|
|
|
rb_check_arity(argc, 0, 1);
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
|
|
|
|
if (argc && !NIL_P(num = argv[0]))
|
|
return rb_nmin_run(obj, num, 1, 1, 0);
|
|
|
|
memo = MEMO_NEW(Qundef, Qnil, 0);
|
|
rb_block_call(obj, id_each, 0, 0, max_by_i, (VALUE)memo);
|
|
return memo->v2;
|
|
}
|
|
|
|
struct minmax_by_t {
|
|
VALUE min_bv;
|
|
VALUE max_bv;
|
|
VALUE min;
|
|
VALUE max;
|
|
VALUE last_bv;
|
|
VALUE last;
|
|
};
|
|
|
|
static void
|
|
minmax_by_i_update(VALUE v1, VALUE v2, VALUE i1, VALUE i2, struct minmax_by_t *memo)
|
|
{
|
|
struct cmp_opt_data cmp_opt = { 0, 0 };
|
|
|
|
if (memo->min_bv == Qundef) {
|
|
memo->min_bv = v1;
|
|
memo->max_bv = v2;
|
|
memo->min = i1;
|
|
memo->max = i2;
|
|
}
|
|
else {
|
|
if (OPTIMIZED_CMP(v1, memo->min_bv, cmp_opt) < 0) {
|
|
memo->min_bv = v1;
|
|
memo->min = i1;
|
|
}
|
|
if (OPTIMIZED_CMP(v2, memo->max_bv, cmp_opt) > 0) {
|
|
memo->max_bv = v2;
|
|
memo->max = i2;
|
|
}
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
minmax_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
|
|
{
|
|
struct cmp_opt_data cmp_opt = { 0, 0 };
|
|
struct minmax_by_t *memo = MEMO_FOR(struct minmax_by_t, _memo);
|
|
VALUE vi, vj, j;
|
|
int n;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
vi = enum_yield(argc, i);
|
|
|
|
if (memo->last_bv == Qundef) {
|
|
memo->last_bv = vi;
|
|
memo->last = i;
|
|
return Qnil;
|
|
}
|
|
vj = memo->last_bv;
|
|
j = memo->last;
|
|
memo->last_bv = Qundef;
|
|
|
|
n = OPTIMIZED_CMP(vj, vi, cmp_opt);
|
|
if (n == 0) {
|
|
i = j;
|
|
vi = vj;
|
|
}
|
|
else if (n < 0) {
|
|
VALUE tmp;
|
|
tmp = i;
|
|
i = j;
|
|
j = tmp;
|
|
tmp = vi;
|
|
vi = vj;
|
|
vj = tmp;
|
|
}
|
|
|
|
minmax_by_i_update(vi, vj, i, j, memo);
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* minmax_by {|element| ... } -> [minimum, maximum]
|
|
* minmax_by -> enumerator
|
|
*
|
|
* Returns a 2-element array containing the elements
|
|
* for which the block returns minimum and maximum values:
|
|
*
|
|
* (1..4).minmax_by {|element| -element }
|
|
* # => [4, 1]
|
|
* %w[a b c d].minmax_by {|element| -element.ord }
|
|
* # => ["d", "a"]
|
|
* {foo: 0, bar: 1, baz: 2}.minmax_by {|key, value| -value }
|
|
* # => [[:baz, 2], [:foo, 0]]
|
|
* [].minmax_by {|element| -element }
|
|
* # => [nil, nil]
|
|
*
|
|
* Returns an Enumerator if no block is given.
|
|
*
|
|
* Related: #max_by, #minmax, #min_by.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_minmax_by(VALUE obj)
|
|
{
|
|
VALUE memo;
|
|
struct minmax_by_t *m = NEW_MEMO_FOR(struct minmax_by_t, memo);
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
|
|
|
|
m->min_bv = Qundef;
|
|
m->max_bv = Qundef;
|
|
m->min = Qnil;
|
|
m->max = Qnil;
|
|
m->last_bv = Qundef;
|
|
m->last = Qundef;
|
|
rb_block_call(obj, id_each, 0, 0, minmax_by_i, memo);
|
|
if (m->last_bv != Qundef)
|
|
minmax_by_i_update(m->last_bv, m->last_bv, m->last, m->last, m);
|
|
m = MEMO_FOR(struct minmax_by_t, memo);
|
|
return rb_assoc_new(m->min, m->max);
|
|
}
|
|
|
|
static VALUE
|
|
member_i(RB_BLOCK_CALL_FUNC_ARGLIST(iter, args))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
|
|
if (rb_equal(rb_enum_values_pack(argc, argv), memo->v1)) {
|
|
MEMO_V2_SET(memo, Qtrue);
|
|
rb_iter_break();
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* include?(object) -> true or false
|
|
*
|
|
* Returns whether for any element <tt>object == element</tt>:
|
|
*
|
|
* (1..4).include?(2) # => true
|
|
* (1..4).include?(5) # => false
|
|
* (1..4).include?('2') # => false
|
|
* %w[a b c d].include?('b') # => true
|
|
* %w[a b c d].include?('2') # => false
|
|
* {foo: 0, bar: 1, baz: 2}.include?(:foo) # => true
|
|
* {foo: 0, bar: 1, baz: 2}.include?('foo') # => false
|
|
* {foo: 0, bar: 1, baz: 2}.include?(0) # => false
|
|
*
|
|
* Enumerable#member? is an alias for Enumerable#include?.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_member(VALUE obj, VALUE val)
|
|
{
|
|
struct MEMO *memo = MEMO_NEW(val, Qfalse, 0);
|
|
|
|
rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo);
|
|
return memo->v2;
|
|
}
|
|
|
|
static VALUE
|
|
each_with_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo))
|
|
{
|
|
struct MEMO *m = MEMO_CAST(memo);
|
|
VALUE n = imemo_count_value(m);
|
|
|
|
imemo_count_up(m);
|
|
return rb_yield_values(2, rb_enum_values_pack(argc, argv), n);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* each_with_index(*args) {|element, i| ..... } -> self
|
|
* each_with_index(*args) -> enumerator
|
|
*
|
|
* With a block given, calls the block with each element and its index;
|
|
* returns +self+:
|
|
*
|
|
* h = {}
|
|
* (1..4).each_with_index {|element, i| h[element] = i } # => 1..4
|
|
* h # => {1=>0, 2=>1, 3=>2, 4=>3}
|
|
*
|
|
* h = {}
|
|
* %w[a b c d].each_with_index {|element, i| h[element] = i }
|
|
* # => ["a", "b", "c", "d"]
|
|
* h # => {"a"=>0, "b"=>1, "c"=>2, "d"=>3}
|
|
*
|
|
* a = []
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* h.each_with_index {|element, i| a.push([i, element]) }
|
|
* # => {:foo=>0, :bar=>1, :baz=>2}
|
|
* a # => [[0, [:foo, 0]], [1, [:bar, 1]], [2, [:baz, 2]]]
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_each_with_index(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
struct MEMO *memo;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
|
|
|
|
memo = MEMO_NEW(0, 0, 0);
|
|
rb_block_call(obj, id_each, argc, argv, each_with_index_i, (VALUE)memo);
|
|
return obj;
|
|
}
|
|
|
|
|
|
/*
|
|
* call-seq:
|
|
* reverse_each(*args) {|element| ... } -> self
|
|
* reverse_each(*args) -> enumerator
|
|
*
|
|
* With a block given, calls the block with each element,
|
|
* but in reverse order; returns +self+:
|
|
*
|
|
* a = []
|
|
* (1..4).reverse_each {|element| a.push(-element) } # => 1..4
|
|
* a # => [-4, -3, -2, -1]
|
|
*
|
|
* a = []
|
|
* %w[a b c d].reverse_each {|element| a.push(element) }
|
|
* # => ["a", "b", "c", "d"]
|
|
* a # => ["d", "c", "b", "a"]
|
|
*
|
|
* a = []
|
|
* h.reverse_each {|element| a.push(element) }
|
|
* # => {:foo=>0, :bar=>1, :baz=>2}
|
|
* a # => [[:baz, 2], [:bar, 1], [:foo, 0]]
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_reverse_each(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
long len;
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
|
|
|
|
ary = enum_to_a(argc, argv, obj);
|
|
|
|
len = RARRAY_LEN(ary);
|
|
while (len--) {
|
|
long nlen;
|
|
rb_yield(RARRAY_AREF(ary, len));
|
|
nlen = RARRAY_LEN(ary);
|
|
if (nlen < len) {
|
|
len = nlen;
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
|
|
static VALUE
|
|
each_val_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
enum_yield(argc, i);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* each_entry(*args) {|element| ... } -> self
|
|
* each_entry(*args) -> enumerator
|
|
*
|
|
* Calls the given block with each element,
|
|
* converting multiple values from yield to an array; returns +self+:
|
|
*
|
|
* a = []
|
|
* (1..4).each_entry {|element| a.push(element) } # => 1..4
|
|
* a # => [1, 2, 3, 4]
|
|
*
|
|
* a = []
|
|
* h = {foo: 0, bar: 1, baz:2}
|
|
* h.each_entry {|element| a.push(element) }
|
|
* # => {:foo=>0, :bar=>1, :baz=>2}
|
|
* a # => [[:foo, 0], [:bar, 1], [:baz, 2]]
|
|
*
|
|
* class Foo
|
|
* include Enumerable
|
|
* def each
|
|
* yield 1
|
|
* yield 1, 2
|
|
* yield
|
|
* end
|
|
* end
|
|
* Foo.new.each_entry {|yielded| p yielded }
|
|
*
|
|
* Output:
|
|
*
|
|
* 1
|
|
* [1, 2]
|
|
* nil
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_each_entry(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
|
|
rb_block_call(obj, id_each, argc, argv, each_val_i, 0);
|
|
return obj;
|
|
}
|
|
|
|
static VALUE
|
|
add_int(VALUE x, long n)
|
|
{
|
|
const VALUE y = LONG2NUM(n);
|
|
if (RB_INTEGER_TYPE_P(x)) return rb_int_plus(x, y);
|
|
return rb_funcallv(x, '+', 1, &y);
|
|
}
|
|
|
|
static VALUE
|
|
div_int(VALUE x, long n)
|
|
{
|
|
const VALUE y = LONG2NUM(n);
|
|
if (RB_INTEGER_TYPE_P(x)) return rb_int_idiv(x, y);
|
|
return rb_funcallv(x, id_div, 1, &y);
|
|
}
|
|
|
|
#define dont_recycle_block_arg(arity) ((arity) == 1 || (arity) < 0)
|
|
|
|
static VALUE
|
|
each_slice_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, m))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(m);
|
|
VALUE ary = memo->v1;
|
|
VALUE v = Qnil;
|
|
long size = memo->u3.cnt;
|
|
ENUM_WANT_SVALUE();
|
|
|
|
rb_ary_push(ary, i);
|
|
|
|
if (RARRAY_LEN(ary) == size) {
|
|
v = rb_yield(ary);
|
|
|
|
if (memo->v2) {
|
|
MEMO_V1_SET(memo, rb_ary_new2(size));
|
|
}
|
|
else {
|
|
rb_ary_clear(ary);
|
|
}
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
static VALUE
|
|
enum_each_slice_size(VALUE obj, VALUE args, VALUE eobj)
|
|
{
|
|
VALUE n, size;
|
|
long slice_size = NUM2LONG(RARRAY_AREF(args, 0));
|
|
ID infinite_p;
|
|
CONST_ID(infinite_p, "infinite?");
|
|
if (slice_size <= 0) rb_raise(rb_eArgError, "invalid slice size");
|
|
|
|
size = enum_size(obj, 0, 0);
|
|
if (NIL_P(size)) return Qnil;
|
|
if (RB_FLOAT_TYPE_P(size) && RTEST(rb_funcall(size, infinite_p, 0))) {
|
|
return size;
|
|
}
|
|
|
|
n = add_int(size, slice_size-1);
|
|
return div_int(n, slice_size);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* each_slice(n) { ... } -> self
|
|
* each_slice(n) -> enumerator
|
|
*
|
|
* Calls the block with each successive disjoint +n+-tuple of elements;
|
|
* returns +self+:
|
|
*
|
|
* a = []
|
|
* (1..10).each_slice(3) {|tuple| a.push(tuple) } # => nil
|
|
* a # => [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
|
|
*
|
|
* a = []
|
|
* h = {foo: 0, bar: 1, baz: 2, bat: 3, bam: 4}
|
|
* h.each_slice(2) {|tuple| a.push(tuple) } # => nil
|
|
* a # => [[[:foo, 0], [:bar, 1]], [[:baz, 2], [:bat, 3]], [[:bam, 4]]]
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_each_slice(VALUE obj, VALUE n)
|
|
{
|
|
long size = NUM2LONG(n);
|
|
VALUE ary;
|
|
struct MEMO *memo;
|
|
int arity;
|
|
|
|
if (size <= 0) rb_raise(rb_eArgError, "invalid slice size");
|
|
RETURN_SIZED_ENUMERATOR(obj, 1, &n, enum_each_slice_size);
|
|
size = limit_by_enum_size(obj, size);
|
|
ary = rb_ary_new2(size);
|
|
arity = rb_block_arity();
|
|
memo = MEMO_NEW(ary, dont_recycle_block_arg(arity), size);
|
|
rb_block_call(obj, id_each, 0, 0, each_slice_i, (VALUE)memo);
|
|
ary = memo->v1;
|
|
if (RARRAY_LEN(ary) > 0) rb_yield(ary);
|
|
|
|
return obj;
|
|
}
|
|
|
|
static VALUE
|
|
each_cons_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
VALUE ary = memo->v1;
|
|
VALUE v = Qnil;
|
|
long size = memo->u3.cnt;
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (RARRAY_LEN(ary) == size) {
|
|
rb_ary_shift(ary);
|
|
}
|
|
rb_ary_push(ary, i);
|
|
if (RARRAY_LEN(ary) == size) {
|
|
if (memo->v2) {
|
|
ary = rb_ary_dup(ary);
|
|
}
|
|
v = rb_yield(ary);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
static VALUE
|
|
enum_each_cons_size(VALUE obj, VALUE args, VALUE eobj)
|
|
{
|
|
struct cmp_opt_data cmp_opt = { 0, 0 };
|
|
const VALUE zero = LONG2FIX(0);
|
|
VALUE n, size;
|
|
long cons_size = NUM2LONG(RARRAY_AREF(args, 0));
|
|
if (cons_size <= 0) rb_raise(rb_eArgError, "invalid size");
|
|
|
|
size = enum_size(obj, 0, 0);
|
|
if (NIL_P(size)) return Qnil;
|
|
|
|
n = add_int(size, 1 - cons_size);
|
|
return (OPTIMIZED_CMP(n, zero, cmp_opt) == -1) ? zero : n;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* each_cons(n) { ... } -> self
|
|
* each_cons(n) -> enumerator
|
|
*
|
|
* Calls the block with each successive overlapped +n+-tuple of elements;
|
|
* returns +self+:
|
|
*
|
|
* a = []
|
|
* (1..5).each_cons(3) {|element| a.push(element) } # => nil
|
|
* a # => [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
|
|
*
|
|
* a = []
|
|
* h = {foo: 0, bar: 1, baz: 2, bam: 3}
|
|
* h.each_cons(2) {|element| a.push(element) } # => nil
|
|
* a # => [[[:foo, 0], [:bar, 1]], [[:bar, 1], [:baz, 2]], [[:baz, 2], [:bam, 3]]]
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_each_cons(VALUE obj, VALUE n)
|
|
{
|
|
long size = NUM2LONG(n);
|
|
struct MEMO *memo;
|
|
int arity;
|
|
|
|
if (size <= 0) rb_raise(rb_eArgError, "invalid size");
|
|
RETURN_SIZED_ENUMERATOR(obj, 1, &n, enum_each_cons_size);
|
|
arity = rb_block_arity();
|
|
if (enum_size_over_p(obj, size)) return Qnil;
|
|
memo = MEMO_NEW(rb_ary_new2(size), dont_recycle_block_arg(arity), size);
|
|
rb_block_call(obj, id_each, 0, 0, each_cons_i, (VALUE)memo);
|
|
|
|
return obj;
|
|
}
|
|
|
|
static VALUE
|
|
each_with_object_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
return rb_yield_values(2, i, memo);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* each_with_object(object) { |(*args), memo_object| ... } -> object
|
|
* each_with_object(object) -> enumerator
|
|
*
|
|
* Calls the block once for each element, passing both the element
|
|
* and the given object:
|
|
*
|
|
* (1..4).each_with_object([]) {|i, a| a.push(i**2) } # => [1, 4, 9, 16]
|
|
* h.each_with_object({}) {|element, h| k, v = *element; h[v] = k }
|
|
* # => {0=>:foo, 1=>:bar, 2=>:baz}
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_each_with_object(VALUE obj, VALUE memo)
|
|
{
|
|
RETURN_SIZED_ENUMERATOR(obj, 1, &memo, enum_size);
|
|
|
|
rb_block_call(obj, id_each, 0, 0, each_with_object_i, memo);
|
|
|
|
return memo;
|
|
}
|
|
|
|
static VALUE
|
|
zip_ary(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval))
|
|
{
|
|
struct MEMO *memo = (struct MEMO *)memoval;
|
|
VALUE result = memo->v1;
|
|
VALUE args = memo->v2;
|
|
long n = memo->u3.cnt++;
|
|
VALUE tmp;
|
|
int i;
|
|
|
|
tmp = rb_ary_new2(RARRAY_LEN(args) + 1);
|
|
rb_ary_store(tmp, 0, rb_enum_values_pack(argc, argv));
|
|
for (i=0; i<RARRAY_LEN(args); i++) {
|
|
VALUE e = RARRAY_AREF(args, i);
|
|
|
|
if (RARRAY_LEN(e) <= n) {
|
|
rb_ary_push(tmp, Qnil);
|
|
}
|
|
else {
|
|
rb_ary_push(tmp, RARRAY_AREF(e, n));
|
|
}
|
|
}
|
|
if (NIL_P(result)) {
|
|
enum_yield_array(tmp);
|
|
}
|
|
else {
|
|
rb_ary_push(result, tmp);
|
|
}
|
|
|
|
RB_GC_GUARD(args);
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
call_next(VALUE w)
|
|
{
|
|
VALUE *v = (VALUE *)w;
|
|
return v[0] = rb_funcallv(v[1], id_next, 0, 0);
|
|
}
|
|
|
|
static VALUE
|
|
call_stop(VALUE w, VALUE _)
|
|
{
|
|
VALUE *v = (VALUE *)w;
|
|
return v[0] = Qundef;
|
|
}
|
|
|
|
static VALUE
|
|
zip_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval))
|
|
{
|
|
struct MEMO *memo = (struct MEMO *)memoval;
|
|
VALUE result = memo->v1;
|
|
VALUE args = memo->v2;
|
|
VALUE tmp;
|
|
int i;
|
|
|
|
tmp = rb_ary_new2(RARRAY_LEN(args) + 1);
|
|
rb_ary_store(tmp, 0, rb_enum_values_pack(argc, argv));
|
|
for (i=0; i<RARRAY_LEN(args); i++) {
|
|
if (NIL_P(RARRAY_AREF(args, i))) {
|
|
rb_ary_push(tmp, Qnil);
|
|
}
|
|
else {
|
|
VALUE v[2];
|
|
|
|
v[1] = RARRAY_AREF(args, i);
|
|
rb_rescue2(call_next, (VALUE)v, call_stop, (VALUE)v, rb_eStopIteration, (VALUE)0);
|
|
if (v[0] == Qundef) {
|
|
RARRAY_ASET(args, i, Qnil);
|
|
v[0] = Qnil;
|
|
}
|
|
rb_ary_push(tmp, v[0]);
|
|
}
|
|
}
|
|
if (NIL_P(result)) {
|
|
enum_yield_array(tmp);
|
|
}
|
|
else {
|
|
rb_ary_push(result, tmp);
|
|
}
|
|
|
|
RB_GC_GUARD(args);
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* zip(*other_enums) -> array
|
|
* zip(*other_enums) {|array| ... } -> nil
|
|
*
|
|
* With no block given, returns a new array +new_array+ of size self.size
|
|
* whose elements are arrays.
|
|
* Each nested array <tt>new_array[n]</tt>
|
|
* is of size <tt>other_enums.size+1</tt>, and contains:
|
|
*
|
|
* - The +n+-th element of self.
|
|
* - The +n+-th element of each of the +other_enums+.
|
|
*
|
|
* If all +other_enums+ and self are the same size,
|
|
* all elements are included in the result, and there is no +nil+-filling:
|
|
*
|
|
* a = [:a0, :a1, :a2, :a3]
|
|
* b = [:b0, :b1, :b2, :b3]
|
|
* c = [:c0, :c1, :c2, :c3]
|
|
* d = a.zip(b, c)
|
|
* d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]
|
|
*
|
|
* f = {foo: 0, bar: 1, baz: 2}
|
|
* g = {goo: 3, gar: 4, gaz: 5}
|
|
* h = {hoo: 6, har: 7, haz: 8}
|
|
* d = f.zip(g, h)
|
|
* d # => [
|
|
* # [[:foo, 0], [:goo, 3], [:hoo, 6]],
|
|
* # [[:bar, 1], [:gar, 4], [:har, 7]],
|
|
* # [[:baz, 2], [:gaz, 5], [:haz, 8]]
|
|
* # ]
|
|
*
|
|
* If any enumerable in other_enums is smaller than self,
|
|
* fills to <tt>self.size</tt> with +nil+:
|
|
*
|
|
* a = [:a0, :a1, :a2, :a3]
|
|
* b = [:b0, :b1, :b2]
|
|
* c = [:c0, :c1]
|
|
* d = a.zip(b, c)
|
|
* d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, nil], [:a3, nil, nil]]
|
|
*
|
|
* If any enumerable in other_enums is larger than self,
|
|
* its trailing elements are ignored:
|
|
*
|
|
* a = [:a0, :a1, :a2, :a3]
|
|
* b = [:b0, :b1, :b2, :b3, :b4]
|
|
* c = [:c0, :c1, :c2, :c3, :c4, :c5]
|
|
* d = a.zip(b, c)
|
|
* d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]
|
|
*
|
|
* When a block is given, calls the block with each of the sub-arrays
|
|
* (formed as above); returns nil:
|
|
*
|
|
* a = [:a0, :a1, :a2, :a3]
|
|
* b = [:b0, :b1, :b2, :b3]
|
|
* c = [:c0, :c1, :c2, :c3]
|
|
* a.zip(b, c) {|sub_array| p sub_array} # => nil
|
|
*
|
|
* Output:
|
|
*
|
|
* [:a0, :b0, :c0]
|
|
* [:a1, :b1, :c1]
|
|
* [:a2, :b2, :c2]
|
|
* [:a3, :b3, :c3]
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_zip(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
int i;
|
|
ID conv;
|
|
struct MEMO *memo;
|
|
VALUE result = Qnil;
|
|
VALUE args = rb_ary_new4(argc, argv);
|
|
int allary = TRUE;
|
|
|
|
argv = RARRAY_PTR(args);
|
|
for (i=0; i<argc; i++) {
|
|
VALUE ary = rb_check_array_type(argv[i]);
|
|
if (NIL_P(ary)) {
|
|
allary = FALSE;
|
|
break;
|
|
}
|
|
argv[i] = ary;
|
|
}
|
|
if (!allary) {
|
|
static const VALUE sym_each = STATIC_ID2SYM(id_each);
|
|
CONST_ID(conv, "to_enum");
|
|
for (i=0; i<argc; i++) {
|
|
if (!rb_respond_to(argv[i], id_each)) {
|
|
rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (must respond to :each)",
|
|
rb_obj_class(argv[i]));
|
|
}
|
|
argv[i] = rb_funcallv(argv[i], conv, 1, &sym_each);
|
|
}
|
|
}
|
|
if (!rb_block_given_p()) {
|
|
result = rb_ary_new();
|
|
}
|
|
|
|
/* TODO: use NODE_DOT2 as memo(v, v, -) */
|
|
memo = MEMO_NEW(result, args, 0);
|
|
rb_block_call(obj, id_each, 0, 0, allary ? zip_ary : zip_i, (VALUE)memo);
|
|
|
|
return result;
|
|
}
|
|
|
|
static VALUE
|
|
take_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
rb_ary_push(memo->v1, rb_enum_values_pack(argc, argv));
|
|
if (--memo->u3.cnt == 0) rb_iter_break();
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* take(n) -> array
|
|
*
|
|
* For non-negative integer +n+, returns the first +n+ elements:
|
|
*
|
|
* r = (1..4)
|
|
* r.take(2) # => [1, 2]
|
|
* r.take(0) # => []
|
|
*
|
|
* h = {foo: 0, bar: 1, baz: 2, bat: 3}
|
|
* h.take(2) # => [[:foo, 0], [:bar, 1]]
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_take(VALUE obj, VALUE n)
|
|
{
|
|
struct MEMO *memo;
|
|
VALUE result;
|
|
long len = NUM2LONG(n);
|
|
|
|
if (len < 0) {
|
|
rb_raise(rb_eArgError, "attempt to take negative size");
|
|
}
|
|
|
|
if (len == 0) return rb_ary_new2(0);
|
|
result = rb_ary_new2(len);
|
|
memo = MEMO_NEW(result, 0, len);
|
|
rb_block_call(obj, id_each, 0, 0, take_i, (VALUE)memo);
|
|
return result;
|
|
}
|
|
|
|
|
|
static VALUE
|
|
take_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
if (!RTEST(rb_yield_values2(argc, argv))) rb_iter_break();
|
|
rb_ary_push(ary, rb_enum_values_pack(argc, argv));
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* take_while {|element| ... } -> array
|
|
* take_while -> enumerator
|
|
*
|
|
* Calls the block with successive elements as long as the block
|
|
* returns a truthy value;
|
|
* returns an array of all elements up to that point:
|
|
*
|
|
*
|
|
* (1..4).take_while{|i| i < 3 } # => [1, 2]
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* h.take_while{|element| key, value = *element; value < 2 }
|
|
* # => [[:foo, 0], [:bar, 1]]
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_take_while(VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
|
|
RETURN_ENUMERATOR(obj, 0, 0);
|
|
ary = rb_ary_new();
|
|
rb_block_call(obj, id_each, 0, 0, take_while_i, ary);
|
|
return ary;
|
|
}
|
|
|
|
static VALUE
|
|
drop_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
if (memo->u3.cnt == 0) {
|
|
rb_ary_push(memo->v1, rb_enum_values_pack(argc, argv));
|
|
}
|
|
else {
|
|
memo->u3.cnt--;
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* drop(n) -> array
|
|
*
|
|
* For positive integer +n+, returns an array containing
|
|
* all but the first +n+ elements:
|
|
*
|
|
* r = (1..4)
|
|
* r.drop(3) # => [4]
|
|
* r.drop(2) # => [3, 4]
|
|
* r.drop(1) # => [2, 3, 4]
|
|
* r.drop(0) # => [1, 2, 3, 4]
|
|
* r.drop(50) # => []
|
|
*
|
|
* h = {foo: 0, bar: 1, baz: 2, bat: 3}
|
|
* h.drop(2) # => [[:baz, 2], [:bat, 3]]
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_drop(VALUE obj, VALUE n)
|
|
{
|
|
VALUE result;
|
|
struct MEMO *memo;
|
|
long len = NUM2LONG(n);
|
|
|
|
if (len < 0) {
|
|
rb_raise(rb_eArgError, "attempt to drop negative size");
|
|
}
|
|
|
|
result = rb_ary_new();
|
|
memo = MEMO_NEW(result, 0, len);
|
|
rb_block_call(obj, id_each, 0, 0, drop_i, (VALUE)memo);
|
|
return result;
|
|
}
|
|
|
|
|
|
static VALUE
|
|
drop_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
struct MEMO *memo = MEMO_CAST(args);
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (!memo->u3.state && !RTEST(enum_yield(argc, i))) {
|
|
memo->u3.state = TRUE;
|
|
}
|
|
if (memo->u3.state) {
|
|
rb_ary_push(memo->v1, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* drop_while {|element| ... } -> array
|
|
* drop_while -> enumerator
|
|
*
|
|
* Calls the block with successive elements as long as the block
|
|
* returns a truthy value;
|
|
* returns an array of all elements after that point:
|
|
*
|
|
*
|
|
* (1..4).drop_while{|i| i < 3 } # => [3, 4]
|
|
* h = {foo: 0, bar: 1, baz: 2}
|
|
* a = h.drop_while{|element| key, value = *element; value < 2 }
|
|
* a # => [[:baz, 2]]
|
|
*
|
|
* With no block given, returns an Enumerator.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_drop_while(VALUE obj)
|
|
{
|
|
VALUE result;
|
|
struct MEMO *memo;
|
|
|
|
RETURN_ENUMERATOR(obj, 0, 0);
|
|
result = rb_ary_new();
|
|
memo = MEMO_NEW(result, 0, FALSE);
|
|
rb_block_call(obj, id_each, 0, 0, drop_while_i, (VALUE)memo);
|
|
return result;
|
|
}
|
|
|
|
static VALUE
|
|
cycle_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
|
|
rb_ary_push(ary, argc > 1 ? i : rb_ary_new_from_values(argc, argv));
|
|
enum_yield(argc, i);
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
enum_cycle_size(VALUE self, VALUE args, VALUE eobj)
|
|
{
|
|
long mul = 0;
|
|
VALUE n = Qnil;
|
|
VALUE size;
|
|
|
|
if (args && (RARRAY_LEN(args) > 0)) {
|
|
n = RARRAY_AREF(args, 0);
|
|
if (!NIL_P(n)) mul = NUM2LONG(n);
|
|
}
|
|
|
|
size = enum_size(self, args, 0);
|
|
if (NIL_P(size) || FIXNUM_ZERO_P(size)) return size;
|
|
|
|
if (NIL_P(n)) return DBL2NUM(HUGE_VAL);
|
|
if (mul <= 0) return INT2FIX(0);
|
|
n = LONG2FIX(mul);
|
|
return rb_funcallv(size, '*', 1, &n);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* cycle(n = nil) {|element| ...} -> nil
|
|
* cycle(n = nil) -> enumerator
|
|
*
|
|
* When called with positive integer argument +n+ and a block,
|
|
* calls the block with each element, then does so again,
|
|
* until it has done so +n+ times; returns +nil+:
|
|
*
|
|
* a = []
|
|
* (1..4).cycle(3) {|element| a.push(element) } # => nil
|
|
* a # => [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
|
|
* a = []
|
|
* ('a'..'d').cycle(2) {|element| a.push(element) }
|
|
* a # => ["a", "b", "c", "d", "a", "b", "c", "d"]
|
|
* a = []
|
|
* {foo: 0, bar: 1, baz: 2}.cycle(2) {|element| a.push(element) }
|
|
* a # => [[:foo, 0], [:bar, 1], [:baz, 2], [:foo, 0], [:bar, 1], [:baz, 2]]
|
|
*
|
|
* If count is zero or negative, does not call the block.
|
|
*
|
|
* When called with a block and +n+ is +nil+, cycles forever.
|
|
*
|
|
* When no block is given, returns an Enumerator.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_cycle(int argc, VALUE *argv, VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
VALUE nv = Qnil;
|
|
long n, i, len;
|
|
|
|
rb_check_arity(argc, 0, 1);
|
|
|
|
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_cycle_size);
|
|
if (!argc || NIL_P(nv = argv[0])) {
|
|
n = -1;
|
|
}
|
|
else {
|
|
n = NUM2LONG(nv);
|
|
if (n <= 0) return Qnil;
|
|
}
|
|
ary = rb_ary_new();
|
|
RBASIC_CLEAR_CLASS(ary);
|
|
rb_block_call(obj, id_each, 0, 0, cycle_i, ary);
|
|
len = RARRAY_LEN(ary);
|
|
if (len == 0) return Qnil;
|
|
while (n < 0 || 0 < --n) {
|
|
for (i=0; i<len; i++) {
|
|
enum_yield_array(RARRAY_AREF(ary, i));
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
struct chunk_arg {
|
|
VALUE categorize;
|
|
VALUE prev_value;
|
|
VALUE prev_elts;
|
|
VALUE yielder;
|
|
};
|
|
|
|
static VALUE
|
|
chunk_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _argp))
|
|
{
|
|
struct chunk_arg *argp = MEMO_FOR(struct chunk_arg, _argp);
|
|
VALUE v, s;
|
|
VALUE alone = ID2SYM(id__alone);
|
|
VALUE separator = ID2SYM(id__separator);
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
v = rb_funcallv(argp->categorize, id_call, 1, &i);
|
|
|
|
if (v == alone) {
|
|
if (!NIL_P(argp->prev_value)) {
|
|
s = rb_assoc_new(argp->prev_value, argp->prev_elts);
|
|
rb_funcallv(argp->yielder, id_lshift, 1, &s);
|
|
argp->prev_value = argp->prev_elts = Qnil;
|
|
}
|
|
v = rb_assoc_new(v, rb_ary_new3(1, i));
|
|
rb_funcallv(argp->yielder, id_lshift, 1, &v);
|
|
}
|
|
else if (NIL_P(v) || v == separator) {
|
|
if (!NIL_P(argp->prev_value)) {
|
|
v = rb_assoc_new(argp->prev_value, argp->prev_elts);
|
|
rb_funcallv(argp->yielder, id_lshift, 1, &v);
|
|
argp->prev_value = argp->prev_elts = Qnil;
|
|
}
|
|
}
|
|
else if (SYMBOL_P(v) && (s = rb_sym2str(v), RSTRING_PTR(s)[0] == '_')) {
|
|
rb_raise(rb_eRuntimeError, "symbols beginning with an underscore are reserved");
|
|
}
|
|
else {
|
|
if (NIL_P(argp->prev_value)) {
|
|
argp->prev_value = v;
|
|
argp->prev_elts = rb_ary_new3(1, i);
|
|
}
|
|
else {
|
|
if (rb_equal(argp->prev_value, v)) {
|
|
rb_ary_push(argp->prev_elts, i);
|
|
}
|
|
else {
|
|
s = rb_assoc_new(argp->prev_value, argp->prev_elts);
|
|
rb_funcallv(argp->yielder, id_lshift, 1, &s);
|
|
argp->prev_value = v;
|
|
argp->prev_elts = rb_ary_new3(1, i);
|
|
}
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
chunk_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator))
|
|
{
|
|
VALUE enumerable;
|
|
VALUE arg;
|
|
struct chunk_arg *memo = NEW_MEMO_FOR(struct chunk_arg, arg);
|
|
|
|
enumerable = rb_ivar_get(enumerator, id_chunk_enumerable);
|
|
memo->categorize = rb_ivar_get(enumerator, id_chunk_categorize);
|
|
memo->prev_value = Qnil;
|
|
memo->prev_elts = Qnil;
|
|
memo->yielder = yielder;
|
|
|
|
rb_block_call(enumerable, id_each, 0, 0, chunk_ii, arg);
|
|
memo = MEMO_FOR(struct chunk_arg, arg);
|
|
if (!NIL_P(memo->prev_elts)) {
|
|
arg = rb_assoc_new(memo->prev_value, memo->prev_elts);
|
|
rb_funcallv(memo->yielder, id_lshift, 1, &arg);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* chunk {|array| ... } -> enumerator
|
|
*
|
|
* Each element in the returned enumerator is a 2-element array consisting of:
|
|
*
|
|
* - A value returned by the block.
|
|
* - An array ("chunk") containing the element for which that value was returned,
|
|
* and all following elements for which the block returned the same value:
|
|
*
|
|
* So that:
|
|
*
|
|
* - Each block return value that is different from its predecessor
|
|
* begins a new chunk.
|
|
* - Each block return value that is the same as its predecessor
|
|
* continues the same chunk.
|
|
*
|
|
* Example:
|
|
*
|
|
* e = (0..10).chunk {|i| (i / 3).floor } # => #<Enumerator: ...>
|
|
* # The enumerator elements.
|
|
* e.next # => [0, [0, 1, 2]]
|
|
* e.next # => [1, [3, 4, 5]]
|
|
* e.next # => [2, [6, 7, 8]]
|
|
* e.next # => [3, [9, 10]]
|
|
*
|
|
* \Method +chunk+ is especially useful for an enumerable that is already sorted.
|
|
* This example counts words for each initial letter in a large array of words:
|
|
*
|
|
* # Get sorted words from a web page.
|
|
* url = 'https://raw.githubusercontent.com/eneko/data-repository/master/data/words.txt'
|
|
* words = URI::open(url).readlines
|
|
* # Make chunks, one for each letter.
|
|
* e = words.chunk {|word| word.upcase[0] } # => #<Enumerator: ...>
|
|
* # Display 'A' through 'F'.
|
|
* e.each {|c, words| p [c, words.length]; break if c == 'F' }
|
|
*
|
|
* Output:
|
|
*
|
|
* ["A", 17096]
|
|
* ["B", 11070]
|
|
* ["C", 19901]
|
|
* ["D", 10896]
|
|
* ["E", 8736]
|
|
* ["F", 6860]
|
|
*
|
|
* You can use the special symbol <tt>:_alone</tt> to force an element
|
|
* into its own separate chuck:
|
|
*
|
|
* a = [0, 0, 1, 1]
|
|
* e = a.chunk{|i| i.even? ? :_alone : true }
|
|
* e.to_a # => [[:_alone, [0]], [:_alone, [0]], [true, [1, 1]]]
|
|
*
|
|
* For example, you can put each line that contains a URL into its own chunk:
|
|
*
|
|
* pattern = /http/
|
|
* open(filename) { |f|
|
|
* f.chunk { |line| line =~ pattern ? :_alone : true }.each { |key, lines|
|
|
* pp lines
|
|
* }
|
|
* }
|
|
*
|
|
* You can use the special symbol <tt>:_separator</tt> or +nil+
|
|
* to force an element to be ignored (not included in any chunk):
|
|
*
|
|
* a = [0, 0, -1, 1, 1]
|
|
* e = a.chunk{|i| i < 0 ? :_separator : true }
|
|
* e.to_a # => [[true, [0, 0]], [true, [1, 1]]]
|
|
*
|
|
* Note that the separator does end the chunk:
|
|
*
|
|
* a = [0, 0, -1, 1, -1, 1]
|
|
* e = a.chunk{|i| i < 0 ? :_separator : true }
|
|
* e.to_a # => [[true, [0, 0]], [true, [1]], [true, [1]]]
|
|
*
|
|
* For example, the sequence of hyphens in svn log can be eliminated as follows:
|
|
*
|
|
* sep = "-"*72 + "\n"
|
|
* IO.popen("svn log README") { |f|
|
|
* f.chunk { |line|
|
|
* line != sep || nil
|
|
* }.each { |_, lines|
|
|
* pp lines
|
|
* }
|
|
* }
|
|
* #=> ["r20018 | knu | 2008-10-29 13:20:42 +0900 (Wed, 29 Oct 2008) | 2 lines\n",
|
|
* # "\n",
|
|
* # "* README, README.ja: Update the portability section.\n",
|
|
* # "\n"]
|
|
* # ["r16725 | knu | 2008-05-31 23:34:23 +0900 (Sat, 31 May 2008) | 2 lines\n",
|
|
* # "\n",
|
|
* # "* README, README.ja: Add a note about default C flags.\n",
|
|
* # "\n"]
|
|
* # ...
|
|
*
|
|
* Paragraphs separated by empty lines can be parsed as follows:
|
|
*
|
|
* File.foreach("README").chunk { |line|
|
|
* /\A\s*\z/ !~ line || nil
|
|
* }.each { |_, lines|
|
|
* pp lines
|
|
* }
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_chunk(VALUE enumerable)
|
|
{
|
|
VALUE enumerator;
|
|
|
|
RETURN_SIZED_ENUMERATOR(enumerable, 0, 0, enum_size);
|
|
|
|
enumerator = rb_obj_alloc(rb_cEnumerator);
|
|
rb_ivar_set(enumerator, id_chunk_enumerable, enumerable);
|
|
rb_ivar_set(enumerator, id_chunk_categorize, rb_block_proc());
|
|
rb_block_call(enumerator, idInitialize, 0, 0, chunk_i, enumerator);
|
|
return enumerator;
|
|
}
|
|
|
|
|
|
struct slicebefore_arg {
|
|
VALUE sep_pred;
|
|
VALUE sep_pat;
|
|
VALUE prev_elts;
|
|
VALUE yielder;
|
|
};
|
|
|
|
static VALUE
|
|
slicebefore_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _argp))
|
|
{
|
|
struct slicebefore_arg *argp = MEMO_FOR(struct slicebefore_arg, _argp);
|
|
VALUE header_p;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (!NIL_P(argp->sep_pat))
|
|
header_p = rb_funcallv(argp->sep_pat, id_eqq, 1, &i);
|
|
else
|
|
header_p = rb_funcallv(argp->sep_pred, id_call, 1, &i);
|
|
if (RTEST(header_p)) {
|
|
if (!NIL_P(argp->prev_elts))
|
|
rb_funcallv(argp->yielder, id_lshift, 1, &argp->prev_elts);
|
|
argp->prev_elts = rb_ary_new3(1, i);
|
|
}
|
|
else {
|
|
if (NIL_P(argp->prev_elts))
|
|
argp->prev_elts = rb_ary_new3(1, i);
|
|
else
|
|
rb_ary_push(argp->prev_elts, i);
|
|
}
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
slicebefore_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator))
|
|
{
|
|
VALUE enumerable;
|
|
VALUE arg;
|
|
struct slicebefore_arg *memo = NEW_MEMO_FOR(struct slicebefore_arg, arg);
|
|
|
|
enumerable = rb_ivar_get(enumerator, id_slicebefore_enumerable);
|
|
memo->sep_pred = rb_attr_get(enumerator, id_slicebefore_sep_pred);
|
|
memo->sep_pat = NIL_P(memo->sep_pred) ? rb_ivar_get(enumerator, id_slicebefore_sep_pat) : Qnil;
|
|
memo->prev_elts = Qnil;
|
|
memo->yielder = yielder;
|
|
|
|
rb_block_call(enumerable, id_each, 0, 0, slicebefore_ii, arg);
|
|
memo = MEMO_FOR(struct slicebefore_arg, arg);
|
|
if (!NIL_P(memo->prev_elts))
|
|
rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* slice_before(pattern) -> enumerator
|
|
* slice_before {|array| ... } -> enumerator
|
|
*
|
|
* With argument +pattern+, returns an enumerator that uses the pattern
|
|
* to partition elements into arrays ("slices").
|
|
* An element begins a new slice if <tt>element === pattern</tt>
|
|
* (or if it is the first element).
|
|
*
|
|
* a = %w[foo bar fop for baz fob fog bam foy]
|
|
* e = a.slice_before(/ba/) # => #<Enumerator: ...>
|
|
* e.each {|array| p array }
|
|
*
|
|
* Output:
|
|
*
|
|
* ["foo"]
|
|
* ["bar", "fop", "for"]
|
|
* ["baz", "fob", "fog"]
|
|
* ["bam", "foy"]
|
|
*
|
|
* With a block, returns an enumerator that uses the block
|
|
* to partition elements into arrays.
|
|
* An element begins a new slice if its block return is a truthy value
|
|
* (or if it is the first element):
|
|
*
|
|
* e = (1..20).slice_before {|i| i % 4 == 2 } # => #<Enumerator: ...>
|
|
* e.each {|array| p array }
|
|
*
|
|
* Output:
|
|
*
|
|
* [1]
|
|
* [2, 3, 4, 5]
|
|
* [6, 7, 8, 9]
|
|
* [10, 11, 12, 13]
|
|
* [14, 15, 16, 17]
|
|
* [18, 19, 20]
|
|
*
|
|
* Other methods of the Enumerator class and Enumerable module,
|
|
* such as +to_a+, +map+, etc., are also usable.
|
|
*
|
|
* For example, iteration over ChangeLog entries can be implemented as
|
|
* follows:
|
|
*
|
|
* # iterate over ChangeLog entries.
|
|
* open("ChangeLog") { |f|
|
|
* f.slice_before(/\A\S/).each { |e| pp e }
|
|
* }
|
|
*
|
|
* # same as above. block is used instead of pattern argument.
|
|
* open("ChangeLog") { |f|
|
|
* f.slice_before { |line| /\A\S/ === line }.each { |e| pp e }
|
|
* }
|
|
*
|
|
* "svn proplist -R" produces multiline output for each file.
|
|
* They can be chunked as follows:
|
|
*
|
|
* IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) { |f|
|
|
* f.lines.slice_before(/\AProp/).each { |lines| p lines }
|
|
* }
|
|
* #=> ["Properties on '.':\n", " svn:ignore\n", " svk:merge\n"]
|
|
* # ["Properties on 'goruby.c':\n", " svn:eol-style\n"]
|
|
* # ["Properties on 'complex.c':\n", " svn:mime-type\n", " svn:eol-style\n"]
|
|
* # ["Properties on 'regparse.c':\n", " svn:eol-style\n"]
|
|
* # ...
|
|
*
|
|
* If the block needs to maintain state over multiple elements,
|
|
* local variables can be used.
|
|
* For example, three or more consecutive increasing numbers can be squashed
|
|
* as follows (see +chunk_while+ for a better way):
|
|
*
|
|
* a = [0, 2, 3, 4, 6, 7, 9]
|
|
* prev = a[0]
|
|
* p a.slice_before { |e|
|
|
* prev, prev2 = e, prev
|
|
* prev2 + 1 != e
|
|
* }.map { |es|
|
|
* es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}"
|
|
* }.join(",")
|
|
* #=> "0,2-4,6,7,9"
|
|
*
|
|
* However local variables should be used carefully
|
|
* if the result enumerator is enumerated twice or more.
|
|
* The local variables should be initialized for each enumeration.
|
|
* Enumerator.new can be used to do it.
|
|
*
|
|
* # Word wrapping. This assumes all characters have same width.
|
|
* def wordwrap(words, maxwidth)
|
|
* Enumerator.new {|y|
|
|
* # cols is initialized in Enumerator.new.
|
|
* cols = 0
|
|
* words.slice_before { |w|
|
|
* cols += 1 if cols != 0
|
|
* cols += w.length
|
|
* if maxwidth < cols
|
|
* cols = w.length
|
|
* true
|
|
* else
|
|
* false
|
|
* end
|
|
* }.each {|ws| y.yield ws }
|
|
* }
|
|
* end
|
|
* text = (1..20).to_a.join(" ")
|
|
* enum = wordwrap(text.split(/\s+/), 10)
|
|
* puts "-"*10
|
|
* enum.each { |ws| puts ws.join(" ") } # first enumeration.
|
|
* puts "-"*10
|
|
* enum.each { |ws| puts ws.join(" ") } # second enumeration generates same result as the first.
|
|
* puts "-"*10
|
|
* #=> ----------
|
|
* # 1 2 3 4 5
|
|
* # 6 7 8 9 10
|
|
* # 11 12 13
|
|
* # 14 15 16
|
|
* # 17 18 19
|
|
* # 20
|
|
* # ----------
|
|
* # 1 2 3 4 5
|
|
* # 6 7 8 9 10
|
|
* # 11 12 13
|
|
* # 14 15 16
|
|
* # 17 18 19
|
|
* # 20
|
|
* # ----------
|
|
*
|
|
* mbox contains series of mails which start with Unix From line.
|
|
* So each mail can be extracted by slice before Unix From line.
|
|
*
|
|
* # parse mbox
|
|
* open("mbox") { |f|
|
|
* f.slice_before { |line|
|
|
* line.start_with? "From "
|
|
* }.each { |mail|
|
|
* unix_from = mail.shift
|
|
* i = mail.index("\n")
|
|
* header = mail[0...i]
|
|
* body = mail[(i+1)..-1]
|
|
* body.pop if body.last == "\n"
|
|
* fields = header.slice_before { |line| !" \t".include?(line[0]) }.to_a
|
|
* p unix_from
|
|
* pp fields
|
|
* pp body
|
|
* }
|
|
* }
|
|
*
|
|
* # split mails in mbox (slice before Unix From line after an empty line)
|
|
* open("mbox") { |f|
|
|
* emp = true
|
|
* f.slice_before { |line|
|
|
* prevemp = emp
|
|
* emp = line == "\n"
|
|
* prevemp && line.start_with?("From ")
|
|
* }.each { |mail|
|
|
* mail.pop if mail.last == "\n"
|
|
* pp mail
|
|
* }
|
|
* }
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_slice_before(int argc, VALUE *argv, VALUE enumerable)
|
|
{
|
|
VALUE enumerator;
|
|
|
|
if (rb_block_given_p()) {
|
|
if (argc != 0)
|
|
rb_error_arity(argc, 0, 0);
|
|
enumerator = rb_obj_alloc(rb_cEnumerator);
|
|
rb_ivar_set(enumerator, id_slicebefore_sep_pred, rb_block_proc());
|
|
}
|
|
else {
|
|
VALUE sep_pat;
|
|
rb_scan_args(argc, argv, "1", &sep_pat);
|
|
enumerator = rb_obj_alloc(rb_cEnumerator);
|
|
rb_ivar_set(enumerator, id_slicebefore_sep_pat, sep_pat);
|
|
}
|
|
rb_ivar_set(enumerator, id_slicebefore_enumerable, enumerable);
|
|
rb_block_call(enumerator, idInitialize, 0, 0, slicebefore_i, enumerator);
|
|
return enumerator;
|
|
}
|
|
|
|
|
|
struct sliceafter_arg {
|
|
VALUE pat;
|
|
VALUE pred;
|
|
VALUE prev_elts;
|
|
VALUE yielder;
|
|
};
|
|
|
|
static VALUE
|
|
sliceafter_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
|
|
{
|
|
#define UPDATE_MEMO ((void)(memo = MEMO_FOR(struct sliceafter_arg, _memo)))
|
|
struct sliceafter_arg *memo;
|
|
int split_p;
|
|
UPDATE_MEMO;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (NIL_P(memo->prev_elts)) {
|
|
memo->prev_elts = rb_ary_new3(1, i);
|
|
}
|
|
else {
|
|
rb_ary_push(memo->prev_elts, i);
|
|
}
|
|
|
|
if (NIL_P(memo->pred)) {
|
|
split_p = RTEST(rb_funcallv(memo->pat, id_eqq, 1, &i));
|
|
UPDATE_MEMO;
|
|
}
|
|
else {
|
|
split_p = RTEST(rb_funcallv(memo->pred, id_call, 1, &i));
|
|
UPDATE_MEMO;
|
|
}
|
|
|
|
if (split_p) {
|
|
rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts);
|
|
UPDATE_MEMO;
|
|
memo->prev_elts = Qnil;
|
|
}
|
|
|
|
return Qnil;
|
|
#undef UPDATE_MEMO
|
|
}
|
|
|
|
static VALUE
|
|
sliceafter_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator))
|
|
{
|
|
VALUE enumerable;
|
|
VALUE arg;
|
|
struct sliceafter_arg *memo = NEW_MEMO_FOR(struct sliceafter_arg, arg);
|
|
|
|
enumerable = rb_ivar_get(enumerator, id_sliceafter_enum);
|
|
memo->pat = rb_ivar_get(enumerator, id_sliceafter_pat);
|
|
memo->pred = rb_attr_get(enumerator, id_sliceafter_pred);
|
|
memo->prev_elts = Qnil;
|
|
memo->yielder = yielder;
|
|
|
|
rb_block_call(enumerable, id_each, 0, 0, sliceafter_ii, arg);
|
|
memo = MEMO_FOR(struct sliceafter_arg, arg);
|
|
if (!NIL_P(memo->prev_elts))
|
|
rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* slice_after(pattern) -> enumerator
|
|
* slice_after {|array| ... } -> enumerator
|
|
*
|
|
* With argument +pattern+, returns an enumerator that uses the pattern
|
|
* to partition elements into arrays ("slices").
|
|
* An element ends the current slice if <tt>element === pattern</tt>:
|
|
*
|
|
* a = %w[foo bar fop for baz fob fog bam foy]
|
|
* e = a.slice_after(/ba/) # => #<Enumerator: ...>
|
|
* e.each {|array| p array }
|
|
*
|
|
* Output:
|
|
*
|
|
* ["foo", "bar"]
|
|
* ["fop", "for", "baz"]
|
|
* ["fob", "fog", "bam"]
|
|
* ["foy"]
|
|
*
|
|
* With a block, returns an enumerator that uses the block
|
|
* to partition elements into arrays.
|
|
* An element ends the current slice if its block return is a truthy value:
|
|
*
|
|
* e = (1..20).slice_after {|i| i % 4 == 2 } # => #<Enumerator: ...>
|
|
* e.each {|array| p array }
|
|
*
|
|
* Output:
|
|
*
|
|
* [1, 2]
|
|
* [3, 4, 5, 6]
|
|
* [7, 8, 9, 10]
|
|
* [11, 12, 13, 14]
|
|
* [15, 16, 17, 18]
|
|
* [19, 20]
|
|
*
|
|
* Other methods of the Enumerator class and Enumerable module,
|
|
* such as +map+, etc., are also usable.
|
|
*
|
|
* For example, continuation lines (lines end with backslash) can be
|
|
* concatenated as follows:
|
|
*
|
|
* lines = ["foo\n", "bar\\\n", "baz\n", "\n", "qux\n"]
|
|
* e = lines.slice_after(/(?<!\\)\n\z/)
|
|
* p e.to_a
|
|
* #=> [["foo\n"], ["bar\\\n", "baz\n"], ["\n"], ["qux\n"]]
|
|
* p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
|
|
* #=>["foo\n", "barbaz\n", "\n", "qux\n"]
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_slice_after(int argc, VALUE *argv, VALUE enumerable)
|
|
{
|
|
VALUE enumerator;
|
|
VALUE pat = Qnil, pred = Qnil;
|
|
|
|
if (rb_block_given_p()) {
|
|
if (0 < argc)
|
|
rb_raise(rb_eArgError, "both pattern and block are given");
|
|
pred = rb_block_proc();
|
|
}
|
|
else {
|
|
rb_scan_args(argc, argv, "1", &pat);
|
|
}
|
|
|
|
enumerator = rb_obj_alloc(rb_cEnumerator);
|
|
rb_ivar_set(enumerator, id_sliceafter_enum, enumerable);
|
|
rb_ivar_set(enumerator, id_sliceafter_pat, pat);
|
|
rb_ivar_set(enumerator, id_sliceafter_pred, pred);
|
|
|
|
rb_block_call(enumerator, idInitialize, 0, 0, sliceafter_i, enumerator);
|
|
return enumerator;
|
|
}
|
|
|
|
struct slicewhen_arg {
|
|
VALUE pred;
|
|
VALUE prev_elt;
|
|
VALUE prev_elts;
|
|
VALUE yielder;
|
|
int inverted; /* 0 for slice_when and 1 for chunk_while. */
|
|
};
|
|
|
|
static VALUE
|
|
slicewhen_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
|
|
{
|
|
#define UPDATE_MEMO ((void)(memo = MEMO_FOR(struct slicewhen_arg, _memo)))
|
|
struct slicewhen_arg *memo;
|
|
int split_p;
|
|
UPDATE_MEMO;
|
|
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (memo->prev_elt == Qundef) {
|
|
/* The first element */
|
|
memo->prev_elt = i;
|
|
memo->prev_elts = rb_ary_new3(1, i);
|
|
}
|
|
else {
|
|
VALUE args[2];
|
|
args[0] = memo->prev_elt;
|
|
args[1] = i;
|
|
split_p = RTEST(rb_funcallv(memo->pred, id_call, 2, args));
|
|
UPDATE_MEMO;
|
|
|
|
if (memo->inverted)
|
|
split_p = !split_p;
|
|
|
|
if (split_p) {
|
|
rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts);
|
|
UPDATE_MEMO;
|
|
memo->prev_elts = rb_ary_new3(1, i);
|
|
}
|
|
else {
|
|
rb_ary_push(memo->prev_elts, i);
|
|
}
|
|
|
|
memo->prev_elt = i;
|
|
}
|
|
|
|
return Qnil;
|
|
#undef UPDATE_MEMO
|
|
}
|
|
|
|
static VALUE
|
|
slicewhen_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator))
|
|
{
|
|
VALUE enumerable;
|
|
VALUE arg;
|
|
struct slicewhen_arg *memo =
|
|
NEW_PARTIAL_MEMO_FOR(struct slicewhen_arg, arg, inverted);
|
|
|
|
enumerable = rb_ivar_get(enumerator, id_slicewhen_enum);
|
|
memo->pred = rb_attr_get(enumerator, id_slicewhen_pred);
|
|
memo->prev_elt = Qundef;
|
|
memo->prev_elts = Qnil;
|
|
memo->yielder = yielder;
|
|
memo->inverted = RTEST(rb_attr_get(enumerator, id_slicewhen_inverted));
|
|
|
|
rb_block_call(enumerable, id_each, 0, 0, slicewhen_ii, arg);
|
|
memo = MEMO_FOR(struct slicewhen_arg, arg);
|
|
if (!NIL_P(memo->prev_elts))
|
|
rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* slice_when {|element, next_element| ... } -> enumerator
|
|
*
|
|
* The returned enumerator uses the block
|
|
* to partition elements into arrays ("slices");
|
|
* it calls the block with each element and its successor;
|
|
* begins a new slice if and only if the block returns a truthy value:
|
|
*
|
|
* a = [0, 1, 2, 4, 5, 6, 8, 9]
|
|
* e = a.slice_when {|i, j| j != i + 1 }
|
|
* e.each {|array| p array }
|
|
*
|
|
* Output:
|
|
*
|
|
* [0, 1, 2]
|
|
* [4, 5, 6]
|
|
* [8, 9]
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_slice_when(VALUE enumerable)
|
|
{
|
|
VALUE enumerator;
|
|
VALUE pred;
|
|
|
|
pred = rb_block_proc();
|
|
|
|
enumerator = rb_obj_alloc(rb_cEnumerator);
|
|
rb_ivar_set(enumerator, id_slicewhen_enum, enumerable);
|
|
rb_ivar_set(enumerator, id_slicewhen_pred, pred);
|
|
rb_ivar_set(enumerator, id_slicewhen_inverted, Qfalse);
|
|
|
|
rb_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator);
|
|
return enumerator;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* chunk_while {|element, next_element| ... } -> enumerator
|
|
*
|
|
* The returned Enumerator uses the block to partition elements
|
|
* into arrays ("chunks");
|
|
* it calls the block with each element and its successor;
|
|
* begins a new chunk if and only if the block returns a truthy value:
|
|
*
|
|
* Example:
|
|
*
|
|
* a = [1, 2, 4, 9, 10, 11, 12, 15, 16, 19, 20, 21]
|
|
* e = a.chunk_while {|i, j| j == i + 1 }
|
|
* e.each {|array| p array }
|
|
*
|
|
* Output:
|
|
*
|
|
* [1, 2]
|
|
* [4]
|
|
* [9, 10, 11, 12]
|
|
* [15, 16]
|
|
* [19, 20, 21]
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_chunk_while(VALUE enumerable)
|
|
{
|
|
VALUE enumerator;
|
|
VALUE pred;
|
|
|
|
pred = rb_block_proc();
|
|
|
|
enumerator = rb_obj_alloc(rb_cEnumerator);
|
|
rb_ivar_set(enumerator, id_slicewhen_enum, enumerable);
|
|
rb_ivar_set(enumerator, id_slicewhen_pred, pred);
|
|
rb_ivar_set(enumerator, id_slicewhen_inverted, Qtrue);
|
|
|
|
rb_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator);
|
|
return enumerator;
|
|
}
|
|
|
|
struct enum_sum_memo {
|
|
VALUE v, r;
|
|
long n;
|
|
double f, c;
|
|
int block_given;
|
|
int float_value;
|
|
};
|
|
|
|
static void
|
|
sum_iter_normalize_memo(struct enum_sum_memo *memo)
|
|
{
|
|
assert(FIXABLE(memo->n));
|
|
memo->v = rb_fix_plus(LONG2FIX(memo->n), memo->v);
|
|
memo->n = 0;
|
|
|
|
switch (TYPE(memo->r)) {
|
|
case T_RATIONAL: memo->v = rb_rational_plus(memo->r, memo->v); break;
|
|
case T_UNDEF: break;
|
|
default: UNREACHABLE; /* or ...? */
|
|
}
|
|
memo->r = Qundef;
|
|
}
|
|
|
|
static void
|
|
sum_iter_fixnum(VALUE i, struct enum_sum_memo *memo)
|
|
{
|
|
memo->n += FIX2LONG(i); /* should not overflow long type */
|
|
if (! FIXABLE(memo->n)) {
|
|
memo->v = rb_big_plus(LONG2NUM(memo->n), memo->v);
|
|
memo->n = 0;
|
|
}
|
|
}
|
|
|
|
static void
|
|
sum_iter_bignum(VALUE i, struct enum_sum_memo *memo)
|
|
{
|
|
memo->v = rb_big_plus(i, memo->v);
|
|
}
|
|
|
|
static void
|
|
sum_iter_rational(VALUE i, struct enum_sum_memo *memo)
|
|
{
|
|
if (memo->r == Qundef) {
|
|
memo->r = i;
|
|
}
|
|
else {
|
|
memo->r = rb_rational_plus(memo->r, i);
|
|
}
|
|
}
|
|
|
|
static void
|
|
sum_iter_some_value(VALUE i, struct enum_sum_memo *memo)
|
|
{
|
|
memo->v = rb_funcallv(memo->v, idPLUS, 1, &i);
|
|
}
|
|
|
|
static void
|
|
sum_iter_Kahan_Babuska(VALUE i, struct enum_sum_memo *memo)
|
|
{
|
|
/*
|
|
* Kahan-Babuska balancing compensated summation algorithm
|
|
* See https://link.springer.com/article/10.1007/s00607-005-0139-x
|
|
*/
|
|
double x;
|
|
|
|
switch (TYPE(i)) {
|
|
case T_FLOAT: x = RFLOAT_VALUE(i); break;
|
|
case T_FIXNUM: x = FIX2LONG(i); break;
|
|
case T_BIGNUM: x = rb_big2dbl(i); break;
|
|
case T_RATIONAL: x = rb_num2dbl(i); break;
|
|
default:
|
|
memo->v = DBL2NUM(memo->f);
|
|
memo->float_value = 0;
|
|
sum_iter_some_value(i, memo);
|
|
return;
|
|
}
|
|
|
|
double f = memo->f;
|
|
|
|
if (isnan(f)) {
|
|
return;
|
|
}
|
|
else if (! isfinite(x)) {
|
|
if (isinf(x) && isinf(f) && signbit(x) != signbit(f)) {
|
|
i = DBL2NUM(f);
|
|
x = nan("");
|
|
}
|
|
memo->v = i;
|
|
memo->f = x;
|
|
return;
|
|
}
|
|
else if (isinf(f)) {
|
|
return;
|
|
}
|
|
|
|
double c = memo->c;
|
|
double t = f + x;
|
|
|
|
if (fabs(f) >= fabs(x)) {
|
|
c += ((f - t) + x);
|
|
}
|
|
else {
|
|
c += ((x - t) + f);
|
|
}
|
|
f = t;
|
|
|
|
memo->f = f;
|
|
memo->c = c;
|
|
}
|
|
|
|
static void
|
|
sum_iter(VALUE i, struct enum_sum_memo *memo)
|
|
{
|
|
assert(memo != NULL);
|
|
if (memo->block_given) {
|
|
i = rb_yield(i);
|
|
}
|
|
|
|
if (memo->float_value) {
|
|
sum_iter_Kahan_Babuska(i, memo);
|
|
}
|
|
else switch (TYPE(memo->v)) {
|
|
default: sum_iter_some_value(i, memo); return;
|
|
case T_FLOAT: sum_iter_Kahan_Babuska(i, memo); return;
|
|
case T_FIXNUM:
|
|
case T_BIGNUM:
|
|
case T_RATIONAL:
|
|
switch (TYPE(i)) {
|
|
case T_FIXNUM: sum_iter_fixnum(i, memo); return;
|
|
case T_BIGNUM: sum_iter_bignum(i, memo); return;
|
|
case T_RATIONAL: sum_iter_rational(i, memo); return;
|
|
case T_FLOAT:
|
|
sum_iter_normalize_memo(memo);
|
|
memo->f = NUM2DBL(memo->v);
|
|
memo->c = 0.0;
|
|
memo->float_value = 1;
|
|
sum_iter_Kahan_Babuska(i, memo);
|
|
return;
|
|
default:
|
|
sum_iter_normalize_memo(memo);
|
|
sum_iter_some_value(i, memo);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
enum_sum_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
sum_iter(i, (struct enum_sum_memo *) args);
|
|
return Qnil;
|
|
}
|
|
|
|
static int
|
|
hash_sum_i(VALUE key, VALUE value, VALUE arg)
|
|
{
|
|
sum_iter(rb_assoc_new(key, value), (struct enum_sum_memo *) arg);
|
|
return ST_CONTINUE;
|
|
}
|
|
|
|
static void
|
|
hash_sum(VALUE hash, struct enum_sum_memo *memo)
|
|
{
|
|
assert(RB_TYPE_P(hash, T_HASH));
|
|
assert(memo != NULL);
|
|
|
|
rb_hash_foreach(hash, hash_sum_i, (VALUE)memo);
|
|
}
|
|
|
|
static VALUE
|
|
int_range_sum(VALUE beg, VALUE end, int excl, VALUE init)
|
|
{
|
|
if (excl) {
|
|
if (FIXNUM_P(end))
|
|
end = LONG2FIX(FIX2LONG(end) - 1);
|
|
else
|
|
end = rb_big_minus(end, LONG2FIX(1));
|
|
}
|
|
|
|
if (rb_int_ge(end, beg)) {
|
|
VALUE a;
|
|
a = rb_int_plus(rb_int_minus(end, beg), LONG2FIX(1));
|
|
a = rb_int_mul(a, rb_int_plus(end, beg));
|
|
a = rb_int_idiv(a, LONG2FIX(2));
|
|
return rb_int_plus(init, a);
|
|
}
|
|
|
|
return init;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* sum(initial_value = 0) -> number
|
|
* sum(initial_value = 0) {|element| ... } -> object
|
|
*
|
|
* With no block given,
|
|
* returns the sum of +initial_value+ and the elements:
|
|
*
|
|
* (1..100).sum # => 5050
|
|
* (1..100).sum(1) # => 5051
|
|
* ('a'..'d').sum('foo') # => "fooabcd"
|
|
*
|
|
* Generally, the sum is computed using methods <tt>+</tt> and +each+;
|
|
* for performance optimizations, those methods may not be used,
|
|
* and so any redefinition of those methods may not have effect here.
|
|
*
|
|
* One such optimization: When possible, computes using Gauss's summation
|
|
* formula <em>n(n+1)/2</em>:
|
|
*
|
|
* 100 * (100 + 1) / 2 # => 5050
|
|
*
|
|
* With a block given, calls the block with each element;
|
|
* returns the sum of +initial_value+ and the block return values:
|
|
*
|
|
* (1..4).sum {|i| i*i } # => 30
|
|
* (1..4).sum(100) {|i| i*i } # => 130
|
|
* h = {a: 0, b: 1, c: 2, d: 3, e: 4, f: 5}
|
|
* h.sum {|key, value| value.odd? ? value : 0 } # => 9
|
|
* ('a'..'f').sum('x') {|c| c < 'd' ? c : '' } # => "xabc"
|
|
*
|
|
*/
|
|
static VALUE
|
|
enum_sum(int argc, VALUE* argv, VALUE obj)
|
|
{
|
|
struct enum_sum_memo memo;
|
|
VALUE beg, end;
|
|
int excl;
|
|
|
|
memo.v = (rb_check_arity(argc, 0, 1) == 0) ? LONG2FIX(0) : argv[0];
|
|
memo.block_given = rb_block_given_p();
|
|
memo.n = 0;
|
|
memo.r = Qundef;
|
|
|
|
if ((memo.float_value = RB_FLOAT_TYPE_P(memo.v))) {
|
|
memo.f = RFLOAT_VALUE(memo.v);
|
|
memo.c = 0.0;
|
|
}
|
|
else {
|
|
memo.f = 0.0;
|
|
memo.c = 0.0;
|
|
}
|
|
|
|
if (RTEST(rb_range_values(obj, &beg, &end, &excl))) {
|
|
if (!memo.block_given && !memo.float_value &&
|
|
(FIXNUM_P(beg) || RB_BIGNUM_TYPE_P(beg)) &&
|
|
(FIXNUM_P(end) || RB_BIGNUM_TYPE_P(end))) {
|
|
return int_range_sum(beg, end, excl, memo.v);
|
|
}
|
|
}
|
|
|
|
if (RB_TYPE_P(obj, T_HASH) &&
|
|
rb_method_basic_definition_p(CLASS_OF(obj), id_each))
|
|
hash_sum(obj, &memo);
|
|
else
|
|
rb_block_call(obj, id_each, 0, 0, enum_sum_i, (VALUE)&memo);
|
|
|
|
if (memo.float_value) {
|
|
return DBL2NUM(memo.f + memo.c);
|
|
}
|
|
else {
|
|
if (memo.n != 0)
|
|
memo.v = rb_fix_plus(LONG2FIX(memo.n), memo.v);
|
|
if (memo.r != Qundef) {
|
|
memo.v = rb_rational_plus(memo.r, memo.v);
|
|
}
|
|
return memo.v;
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
uniq_func(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
rb_hash_add_new_element(hash, i, i);
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
uniq_iter(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
rb_hash_add_new_element(hash, rb_yield_values2(argc, argv), i);
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* uniq -> array
|
|
* uniq {|element| ... } -> array
|
|
*
|
|
* With no block, returns a new array containing only unique elements;
|
|
* the array has no two elements +e0+ and +e1+ such that <tt>e0.eql?(e1)</tt>:
|
|
*
|
|
* %w[a b c c b a a b c].uniq # => ["a", "b", "c"]
|
|
* [0, 1, 2, 2, 1, 0, 0, 1, 2].uniq # => [0, 1, 2]
|
|
*
|
|
* With a block, returns a new array containing only for which the block
|
|
* returns a unique value:
|
|
*
|
|
* a = [0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1]
|
|
* a.uniq {|i| i.even? ? i : 0 } # => [0, 2, 4]
|
|
* a = %w[a b c d e e d c b a a b c d e]
|
|
a.uniq {|c| c < 'c' } # => ["a", "c"]
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_uniq(VALUE obj)
|
|
{
|
|
VALUE hash, ret;
|
|
rb_block_call_func *const func =
|
|
rb_block_given_p() ? uniq_iter : uniq_func;
|
|
|
|
hash = rb_obj_hide(rb_hash_new());
|
|
rb_block_call(obj, id_each, 0, 0, func, hash);
|
|
ret = rb_hash_values(hash);
|
|
rb_hash_clear(hash);
|
|
return ret;
|
|
}
|
|
|
|
static VALUE
|
|
compact_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|
{
|
|
ENUM_WANT_SVALUE();
|
|
|
|
if (!NIL_P(i)) {
|
|
rb_ary_push(ary, i);
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* compact -> array
|
|
*
|
|
* Returns an array of all non-+nil+ elements:
|
|
*
|
|
* a = [nil, 0, nil, 'a', false, nil, false, nil, 'a', nil, 0, nil]
|
|
* a.compact # => [0, "a", false, false, "a", 0]
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
enum_compact(VALUE obj)
|
|
{
|
|
VALUE ary;
|
|
|
|
ary = rb_ary_new();
|
|
rb_block_call(obj, id_each, 0, 0, compact_i, ary);
|
|
|
|
return ary;
|
|
}
|
|
|
|
|
|
/*
|
|
* == What's Here
|
|
*
|
|
* \Module \Enumerable provides methods that are useful to a collection class for:
|
|
* - {Querying}[#module-Enumerable-label-Methods+for+Querying]
|
|
* - {Fetching}[#module-Enumerable-label-Methods+for+Fetching]
|
|
* - {Searching}[#module-Enumerable-label-Methods+for+Searching]
|
|
* - {Sorting}[#module-Enumerable-label-Methods+for+Sorting]
|
|
* - {Iterating}[#module-Enumerable-label-Methods+for+Iterating]
|
|
* - {And more....}[#module-Enumerable-label-Other+Methods]
|
|
*
|
|
* === Methods for Querying
|
|
*
|
|
* These methods return information about the \Enumerable other than the elements themselves:
|
|
*
|
|
* #include?, #member?:: Returns +true+ if self == object, +false+ otherwise.
|
|
* #all?:: Returns +true+ if all elements meet a specified criterion; +false+ otherwise.
|
|
* #any?:: Returns +true+ if any element meets a specified criterion; +false+ otherwise.
|
|
* #none?:: Returns +true+ if no element meets a specified criterion; +false+ otherwise.
|
|
* #one?:: Returns +true+ if exactly one element meets a specified criterion; +false+ otherwise.
|
|
* #count:: Returns the count of elements,
|
|
* based on an argument or block criterion, if given.
|
|
* #tally:: Returns a new \Hash containing the counts of occurrences of each element.
|
|
*
|
|
* === Methods for Fetching
|
|
*
|
|
* These methods return entries from the \Enumerable, without modifying it:
|
|
*
|
|
* <i>Leading, trailing, or all elements</i>:
|
|
* #entries, #to_a:: Returns all elements.
|
|
* #first:: Returns the first element or leading elements.
|
|
* #take:: Returns a specified number of leading elements.
|
|
* #drop:: Returns a specified number of trailing elements.
|
|
* #take_while:: Returns leading elements as specified by the given block.
|
|
* #drop_while:: Returns trailing elements as specified by the given block.
|
|
*
|
|
* <i>Minimum and maximum value elements</i>:
|
|
* #min:: Returns the elements whose values are smallest among the elements,
|
|
* as determined by <tt><=></tt> or a given block.
|
|
* #max:: Returns the elements whose values are largest among the elements,
|
|
* as determined by <tt><=></tt> or a given block.
|
|
* #minmax:: Returns a 2-element \Array containing the smallest and largest elements.
|
|
* #min_by:: Returns the smallest element, as determined by the given block.
|
|
* #max_by:: Returns the largest element, as determined by the given block.
|
|
* #minmax_by:: Returns the smallest and largest elements, as determined by the given block.
|
|
*
|
|
* <i>Groups, slices, and partitions</i>:
|
|
* #group_by:: Returns a \Hash that partitions the elements into groups.
|
|
* #partition:: Returns elements partitioned into two new Arrays, as determined by the given block.
|
|
* #slice_after:: Returns a new \Enumerator whose entries are a partition of +self+,
|
|
based either on a given +object+ or a given block.
|
|
* #slice_before:: Returns a new \Enumerator whose entries are a partition of +self+,
|
|
based either on a given +object+ or a given block.
|
|
* #slice_when:: Returns a new \Enumerator whose entries are a partition of +self+
|
|
based on the given block.
|
|
* #chunk:: Returns elements organized into chunks as specified by the given block.
|
|
* #chunk_while:: Returns elements organized into chunks as specified by the given block.
|
|
*
|
|
* === Methods for Searching and Filtering
|
|
*
|
|
* These methods return elements that meet a specified criterion.
|
|
*
|
|
* #find, #detect:: Returns an element selected by the block.
|
|
* #find_all, #filter, #select:: Returns elements selected by the block.
|
|
* #find_index:: Returns the index of an element selected by a given object or block.
|
|
* #reject:: Returns elements not rejected by the block.
|
|
* #uniq:: Returns elements that are not duplicates.
|
|
*
|
|
* === Methods for Sorting
|
|
*
|
|
* These methods return elements in sorted order.
|
|
*
|
|
* #sort:: Returns the elements, sorted by <tt><=></tt> or the given block.
|
|
* #sort_by:: Returns the elements, sorted by the given block.
|
|
*
|
|
* === Methods for Iterating
|
|
*
|
|
* #each_entry:: Calls the block with each successive element
|
|
* (slightly different from #each).
|
|
* #each_with_index:: Calls the block with each successive element and its index.
|
|
* #each_with_object:: Calls the block with each successive element and a given object.
|
|
* #each_slice:: Calls the block with successive non-overlapping slices.
|
|
* #each_cons:: Calls the block with successive overlapping slices.
|
|
* (different from #each_slice).
|
|
* #reverse_each:: Calls the block with each successive element, in reverse order.
|
|
*
|
|
* === Other Methods
|
|
*
|
|
* #map, #collect:: Returns objects returned by the block.
|
|
* #filter_map:: Returns truthy objects returned by the block.
|
|
* #flat_map, #collect_concat:: Returns flattened objects returned by the block.
|
|
* #grep:: Returns elements selected by a given object
|
|
* or objects returned by a given block.
|
|
* #grep_v:: Returns elements selected by a given object
|
|
* or objects returned by a given block.
|
|
* #reduce, #inject:: Returns the object formed by combining all elements.
|
|
* #sum:: Returns the sum of the elements, using method +++.
|
|
* #zip:: Combines each element with elements from other enumerables;
|
|
* returns the n-tuples or calls the block with each.
|
|
* #cycle:: Calls the block with each element, cycling repeatedly.
|
|
*
|
|
* == Usage
|
|
*
|
|
* To use module \Enumerable in a collection class:
|
|
*
|
|
* - Include it:
|
|
*
|
|
* include Enumerable
|
|
*
|
|
* - Implement method <tt>#each</tt>
|
|
* which must yield successive elements of the collection.
|
|
* The method will be called by almost any \Enumerable method.
|
|
*
|
|
* Example:
|
|
*
|
|
* class Foo
|
|
* include Enumerable
|
|
* def each
|
|
* yield 1
|
|
* yield 1, 2
|
|
* yield
|
|
* end
|
|
* end
|
|
* Foo.new.each_entry{ |element| p element }
|
|
*
|
|
* Output:
|
|
*
|
|
* 1
|
|
* [1, 2]
|
|
* nil
|
|
*
|
|
* == \Enumerable in Ruby Core Classes
|
|
* Some Ruby classes include \Enumerable:
|
|
* - Array
|
|
* - Dir
|
|
* - Hash
|
|
* - IO
|
|
* - Range
|
|
* - Set
|
|
* - Struct
|
|
* Virtually all methods in \Enumerable call method +#each+ in the including class:
|
|
* - <tt>Hash#each</tt> yields the next key-value pair as a 2-element \Array.
|
|
* - <tt>Struct#each</tt> yields the next name-value pair as a 2-element \Array.
|
|
* - For the other classes above, +#each+ yields the next object from the collection.
|
|
*
|
|
* == About the Examples
|
|
* The example code snippets for the \Enumerable methods:
|
|
* - Always show the use of one or more \Array-like classes (often \Array itself).
|
|
* - Sometimes show the use of a \Hash-like class.
|
|
* For some methods, though, the usage would not make sense,
|
|
* and so it is not shown. Example: #tally would find exactly one of each \Hash entry.
|
|
*/
|
|
|
|
void
|
|
Init_Enumerable(void)
|
|
{
|
|
rb_mEnumerable = rb_define_module("Enumerable");
|
|
|
|
rb_define_method(rb_mEnumerable, "to_a", enum_to_a, -1);
|
|
rb_define_method(rb_mEnumerable, "entries", enum_to_a, -1);
|
|
rb_define_method(rb_mEnumerable, "to_h", enum_to_h, -1);
|
|
|
|
rb_define_method(rb_mEnumerable, "sort", enum_sort, 0);
|
|
rb_define_method(rb_mEnumerable, "sort_by", enum_sort_by, 0);
|
|
rb_define_method(rb_mEnumerable, "grep", enum_grep, 1);
|
|
rb_define_method(rb_mEnumerable, "grep_v", enum_grep_v, 1);
|
|
rb_define_method(rb_mEnumerable, "count", enum_count, -1);
|
|
rb_define_method(rb_mEnumerable, "find", enum_find, -1);
|
|
rb_define_method(rb_mEnumerable, "detect", enum_find, -1);
|
|
rb_define_method(rb_mEnumerable, "find_index", enum_find_index, -1);
|
|
rb_define_method(rb_mEnumerable, "find_all", enum_find_all, 0);
|
|
rb_define_method(rb_mEnumerable, "select", enum_find_all, 0);
|
|
rb_define_method(rb_mEnumerable, "filter", enum_find_all, 0);
|
|
rb_define_method(rb_mEnumerable, "filter_map", enum_filter_map, 0);
|
|
rb_define_method(rb_mEnumerable, "reject", enum_reject, 0);
|
|
rb_define_method(rb_mEnumerable, "collect", enum_collect, 0);
|
|
rb_define_method(rb_mEnumerable, "map", enum_collect, 0);
|
|
rb_define_method(rb_mEnumerable, "flat_map", enum_flat_map, 0);
|
|
rb_define_method(rb_mEnumerable, "collect_concat", enum_flat_map, 0);
|
|
rb_define_method(rb_mEnumerable, "inject", enum_inject, -1);
|
|
rb_define_method(rb_mEnumerable, "reduce", enum_inject, -1);
|
|
rb_define_method(rb_mEnumerable, "partition", enum_partition, 0);
|
|
rb_define_method(rb_mEnumerable, "group_by", enum_group_by, 0);
|
|
rb_define_method(rb_mEnumerable, "tally", enum_tally, -1);
|
|
rb_define_method(rb_mEnumerable, "first", enum_first, -1);
|
|
rb_define_method(rb_mEnumerable, "all?", enum_all, -1);
|
|
rb_define_method(rb_mEnumerable, "any?", enum_any, -1);
|
|
rb_define_method(rb_mEnumerable, "one?", enum_one, -1);
|
|
rb_define_method(rb_mEnumerable, "none?", enum_none, -1);
|
|
rb_define_method(rb_mEnumerable, "min", enum_min, -1);
|
|
rb_define_method(rb_mEnumerable, "max", enum_max, -1);
|
|
rb_define_method(rb_mEnumerable, "minmax", enum_minmax, 0);
|
|
rb_define_method(rb_mEnumerable, "min_by", enum_min_by, -1);
|
|
rb_define_method(rb_mEnumerable, "max_by", enum_max_by, -1);
|
|
rb_define_method(rb_mEnumerable, "minmax_by", enum_minmax_by, 0);
|
|
rb_define_method(rb_mEnumerable, "member?", enum_member, 1);
|
|
rb_define_method(rb_mEnumerable, "include?", enum_member, 1);
|
|
rb_define_method(rb_mEnumerable, "each_with_index", enum_each_with_index, -1);
|
|
rb_define_method(rb_mEnumerable, "reverse_each", enum_reverse_each, -1);
|
|
rb_define_method(rb_mEnumerable, "each_entry", enum_each_entry, -1);
|
|
rb_define_method(rb_mEnumerable, "each_slice", enum_each_slice, 1);
|
|
rb_define_method(rb_mEnumerable, "each_cons", enum_each_cons, 1);
|
|
rb_define_method(rb_mEnumerable, "each_with_object", enum_each_with_object, 1);
|
|
rb_define_method(rb_mEnumerable, "zip", enum_zip, -1);
|
|
rb_define_method(rb_mEnumerable, "take", enum_take, 1);
|
|
rb_define_method(rb_mEnumerable, "take_while", enum_take_while, 0);
|
|
rb_define_method(rb_mEnumerable, "drop", enum_drop, 1);
|
|
rb_define_method(rb_mEnumerable, "drop_while", enum_drop_while, 0);
|
|
rb_define_method(rb_mEnumerable, "cycle", enum_cycle, -1);
|
|
rb_define_method(rb_mEnumerable, "chunk", enum_chunk, 0);
|
|
rb_define_method(rb_mEnumerable, "slice_before", enum_slice_before, -1);
|
|
rb_define_method(rb_mEnumerable, "slice_after", enum_slice_after, -1);
|
|
rb_define_method(rb_mEnumerable, "slice_when", enum_slice_when, 0);
|
|
rb_define_method(rb_mEnumerable, "chunk_while", enum_chunk_while, 0);
|
|
rb_define_method(rb_mEnumerable, "sum", enum_sum, -1);
|
|
rb_define_method(rb_mEnumerable, "uniq", enum_uniq, 0);
|
|
rb_define_method(rb_mEnumerable, "compact", enum_compact, 0);
|
|
|
|
id__alone = rb_intern_const("_alone");
|
|
id__separator = rb_intern_const("_separator");
|
|
id_chunk_categorize = rb_intern_const("chunk_categorize");
|
|
id_chunk_enumerable = rb_intern_const("chunk_enumerable");
|
|
id_next = rb_intern_const("next");
|
|
id_sliceafter_enum = rb_intern_const("sliceafter_enum");
|
|
id_sliceafter_pat = rb_intern_const("sliceafter_pat");
|
|
id_sliceafter_pred = rb_intern_const("sliceafter_pred");
|
|
id_slicebefore_enumerable = rb_intern_const("slicebefore_enumerable");
|
|
id_slicebefore_sep_pat = rb_intern_const("slicebefore_sep_pat");
|
|
id_slicebefore_sep_pred = rb_intern_const("slicebefore_sep_pred");
|
|
id_slicewhen_enum = rb_intern_const("slicewhen_enum");
|
|
id_slicewhen_inverted = rb_intern_const("slicewhen_inverted");
|
|
id_slicewhen_pred = rb_intern_const("slicewhen_pred");
|
|
}
|