Method: Array#sum

Defined in:

array.c

#sum(init = 0) ⇒ Object #sum(init = 0) {|element| ... } ⇒ Object

With no block given, returns the sum of init and all elements of self;

for array +array+ and value +init+, equivalent to:

  sum = init
  array.each {|element| sum += element }
  sum

For example, <tt>[e0, e1, e2].sum</tt> returns <tt>init + e0 + e1 + e2</tt>.

Examples:

  [0, 1, 2, 3].sum                 # => 6
  [0, 1, 2, 3].sum(100)            # => 106
  ['abc', 'def', 'ghi'].sum('jkl') # => "jklabcdefghi"
  [[:foo, :bar], ['foo', 'bar']].sum([2, 3])
  # => [2, 3, :foo, :bar, "foo", "bar"]

The +init+ value and elements need not be numeric, but must all be <tt>+</tt>-compatible:

  # Raises TypeError: Array can't be coerced into Integer.
  [[:foo, :bar], ['foo', 'bar']].sum(2)

With a block given, calls the block with each element of +self+;
the block's return value (instead of the element itself) is used as the addend:

  ['zero', 1, :two].sum('Coerced and concatenated: ') {|element| element.to_s }
  # => "Coerced and concatenated: zero1two"

Notes:

- Array#join and Array#flatten may be faster than Array#sum
  for an array of strings or an array of arrays.
- Array#sum method may not respect method redefinition of "+" methods such as Integer#+.

Overloads:

• #sum(init = 0) ⇒ Object

  Returns:

  • (Object)
• #sum(init = 0) {|element| ... } ⇒ Object

  Yields:

  • (element)

  Returns:

  • (Object)

# File 'array.c', line 8098

static VALUE
rb_ary_sum(int argc, VALUE *argv, VALUE ary)
{
    VALUE e, v, r;
    long i, n;
    int block_given;

    v = (rb_check_arity(argc, 0, 1) ? argv[0] : LONG2FIX(0));

    block_given = rb_block_given_p();

    if (RARRAY_LEN(ary) == 0)
        return v;

    n = 0;
    r = Qundef;

    if (!FIXNUM_P(v) && !RB_BIGNUM_TYPE_P(v) && !RB_TYPE_P(v, T_RATIONAL)) {
        i = 0;
        goto init_is_a_value;
    }

    for (i = 0; i < RARRAY_LEN(ary); i++) {
        e = RARRAY_AREF(ary, i);
        if (block_given)
            e = rb_yield(e);
        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 if (RB_TYPE_P(e, T_RATIONAL)) {
            if (UNDEF_P(r))
                r = e;
            else
                r = rb_rational_plus(r, e);
        }
        else
            goto not_exact;
    }
    v = finish_exact_sum(n, r, v, argc!=0);
    return v;

  not_exact:
    v = finish_exact_sum(n, r, v, i!=0);

    if (RB_FLOAT_TYPE_P(e)) {
        /*
         * Kahan-Babuska balancing compensated summation algorithm
         * See https://link.springer.com/article/10.1007/s00607-005-0139-x
         */
        double f, c;
        double x, t;

        f = NUM2DBL(v);
        c = 0.0;
        goto has_float_value;
        for (; i < RARRAY_LEN(ary); i++) {
            e = RARRAY_AREF(ary, i);
            if (block_given)
                e = rb_yield(e);
            if (RB_FLOAT_TYPE_P(e))
              has_float_value:
                x = RFLOAT_VALUE(e);
            else if (FIXNUM_P(e))
                x = FIX2LONG(e);
            else if (RB_BIGNUM_TYPE_P(e))
                x = rb_big2dbl(e);
            else if (RB_TYPE_P(e, T_RATIONAL))
                x = rb_num2dbl(e);
            else
                goto not_float;

            if (isnan(f)) continue;
            if (isnan(x)) {
                f = x;
                continue;
            }
            if (isinf(x)) {
                if (isinf(f) && signbit(x) != signbit(f))
                    f = NAN;
                else
                    f = x;
                continue;
            }
            if (isinf(f)) continue;

            t = f + x;
            if (fabs(f) >= fabs(x))
                c += ((f - t) + x);
            else
                c += ((x - t) + f);
            f = t;
        }
        f += c;
        return DBL2NUM(f);

      not_float:
        v = DBL2NUM(f);
    }

    goto has_some_value;
    init_is_a_value:
    for (; i < RARRAY_LEN(ary); i++) {
        e = RARRAY_AREF(ary, i);
        if (block_given)
            e = rb_yield(e);
      has_some_value:
        v = rb_funcall(v, idPLUS, 1, e);
    }
    return v;
}