Class: Array

Inherits:
Object show all
Includes:
Enumerable
Defined in:
array.c

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Enumerable

#all?, #any?, #detect, #each_cons, #each_slice, #each_with_index, #entries, #enum_cons, #enum_slice, #enum_with_index, #find, #find_all, #grep, #group_by, #inject, #max, #max_by, #member?, #min, #min_by, #minmax, #minmax_by, #none?, #one?, #partition, #reduce, #sort_by

Constructor Details

#new(size = 0, obj = nil) ⇒ Object #new(array) ⇒ Object #new(size) {|index| ... } ⇒ Object

Returns a new array. In the first form, the new array is empty. In the second it is created with size copies of obj (that is, size references to the same obj). The third form creates a copy of the array passed as a parameter (the array is generated by calling to_ary on the parameter). In the last form, an array of the given size is created. Each element in this array is calculated by passing the element's index to the given block and storing the return value.

Array.new
Array.new(2)
Array.new(5, "A")

# only one copy of the object is created
a = Array.new(2, Hash.new)
a[0]['cat'] = 'feline'
a
a[1]['cat'] = 'Felix'
a

# here multiple copies are created
a = Array.new(2) { Hash.new }
a[0]['cat'] = 'feline'
a

squares = Array.new(5) {|i| i*i}
squares

copy = Array.new(squares)

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     Array.new(size=0, obj=nil)
 *     Array.new(array)
 *     Array.new(size) {|index| block }
 *
 *  Returns a new array. In the first form, the new array is
 *  empty. In the second it is created with _size_ copies of _obj_
 *  (that is, _size_ references to the same
 *  _obj_). The third form creates a copy of the array
 *  passed as a parameter (the array is generated by calling
 *  to_ary  on the parameter). In the last form, an array
 *  of the given size is created. Each element in this array is
 *  calculated by passing the element's index to the given block and
 *  storing the return value.
 *
 *     Array.new
 *     Array.new(2)
 *     Array.new(5, "A")
 * 
 *     # only one copy of the object is created
 *     a = Array.new(2, Hash.new)
 *     a[0]['cat'] = 'feline'
 *     a
 *     a[1]['cat'] = 'Felix'
 *     a
 * 
 *     # here multiple copies are created
 *     a = Array.new(2) { Hash.new }
 *     a[0]['cat'] = 'feline'
 *     a
 * 
 *     squares = Array.new(5) {|i| i*i}
 *     squares
 * 
 *     copy = Array.new(squares)
 */

static VALUE
rb_ary_initialize(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    long len;
    VALUE size, val;

    rb_ary_modify(ary);
    if (rb_scan_args(argc, argv, "02", &size, &val) == 0) {
    RARRAY(ary)->len = 0;
    if (rb_block_given_p()) {
        rb_warning("given block not used");
    }
    return ary;
    }

    if (argc == 1 && !FIXNUM_P(size)) {
    val = rb_check_array_type(size);
    if (!NIL_P(val)) {
        rb_ary_replace(ary, val);
        return ary;
    }
    }

    len = NUM2LONG(size);
    if (len < 0) {
    rb_raise(rb_eArgError, "negative array size");
    }
    if (len > ARY_MAX_SIZE) {
    rb_raise(rb_eArgError, "array size too big");
    }
    if (len > RARRAY(ary)->aux.capa) {
    REALLOC_N(RARRAY(ary)->ptr, VALUE, len);
    RARRAY(ary)->aux.capa = len;
    }
    if (rb_block_given_p()) {
    long i;

    if (argc == 2) {
        rb_warn("block supersedes default value argument");
    }
    for (i=0; i<len; i++) {
        rb_ary_store(ary, i, rb_yield(LONG2NUM(i)));
        RARRAY(ary)->len = i + 1;
    }
    }
    else {
    memfill(RARRAY(ary)->ptr, len, val);
    RARRAY(ary)->len = len;
    }

    return ary;
}

Class Method Details

.[] ⇒ Object

Returns a new array populated with the given objects.

Array.[]( 1, 'a', /^A/ )
Array[ 1, 'a', /^A/ ]
[ 1, 'a', /^A/ ]




# File 'array.c'

/* 
* Returns a new array populated with the given objects. 
*
*   Array.[]( 1, 'a', /^A/ )
*   Array[ 1, 'a', /^A/ ]
*   [ 1, 'a', /^A/ ]
*/

static VALUE
rb_ary_s_create(argc, argv, klass)
    int argc;
    VALUE *argv;
    VALUE klass;
{
    VALUE ary = ary_alloc(klass);

    if (argc > 0) {
    RARRAY(ary)->ptr = ALLOC_N(VALUE, argc);
    MEMCPY(RARRAY(ary)->ptr, argv, VALUE, argc);
    }
    RARRAY(ary)->len = RARRAY(ary)->aux.capa = argc;

    return ary;
}

Instance Method Details

#&(other_array) ⇒ Object

Set Intersection---Returns a new array containing elements common to the two arrays, with no duplicates.

[ 1, 1, 3, 5 ] & [ 1, 2, 3 ]   #=> [ 1, 3 ]




# File 'array.c'

/* 
 *  call-seq:
 *     array & other_array
 *
 *  Set Intersection---Returns a new array
 *  containing elements common to the two arrays, with no duplicates.
 *
 *     [ 1, 1, 3, 5 ] & [ 1, 2, 3 ]   #=> [ 1, 3 ]
 */


static VALUE
rb_ary_and(ary1, ary2)
    VALUE ary1, ary2;
{
    VALUE hash, ary3, v, vv;
    long i;

    ary2 = to_ary(ary2);
    ary3 = rb_ary_new2(RARRAY(ary1)->len < RARRAY(ary2)->len ?
        RARRAY(ary1)->len : RARRAY(ary2)->len);
    hash = ary_make_hash(ary2, 0);

    for (i=0; i<RARRAY(ary1)->len; i++) {
    v = vv = rb_ary_elt(ary1, i);
    if (st_delete(RHASH(hash)->tbl, (st_data_t*)&vv, 0)) {
        rb_ary_push(ary3, v);
    }
    }

    return ary3;
}

#*(int) ⇒ Array #*(str) ⇒ String

Repetition---With a String argument, equivalent to self.join(str). Otherwise, returns a new array built by concatenating the int copies of self.

[ 1, 2, 3 ] * 3    #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]
[ 1, 2, 3 ] * ","  #=> "1,2,3"

Overloads:




# File 'array.c'

/* 
 *  call-seq:
 *     array * int     ->    an_array
 *     array * str     ->    a_string
 *
 *  Repetition---With a String argument, equivalent to
 *  self.join(str). Otherwise, returns a new array
 *  built by concatenating the _int_ copies of _self_.
 *
 *
 *     [ 1, 2, 3 ] * 3    #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]
 *     [ 1, 2, 3 ] * ","  #=> "1,2,3"
 *
 */

static VALUE
rb_ary_times(ary, times)
    VALUE ary, times;
{
    VALUE ary2, tmp;
    long i, len;

    tmp = rb_check_string_type(times);
    if (!NIL_P(tmp)) {
    return rb_ary_join(ary, tmp);
    }

    len = NUM2LONG(times);
    if (len == 0) return ary_new(rb_obj_class(ary), 0);
    if (len < 0) {
    rb_raise(rb_eArgError, "negative argument");
    }
    if (ARY_MAX_SIZE/len < RARRAY(ary)->len) {
    rb_raise(rb_eArgError, "argument too big");
    }
    len *= RARRAY(ary)->len;

    ary2 = ary_new(rb_obj_class(ary), len);
    RARRAY(ary2)->len = len;

    for (i=0; i<len; i+=RARRAY(ary)->len) {
    MEMCPY(RARRAY(ary2)->ptr+i, RARRAY(ary)->ptr, VALUE, RARRAY(ary)->len);
    }
    OBJ_INFECT(ary2, ary);

    return ary2;
}

#+(other_array) ⇒ Array

Concatenation---Returns a new array built by concatenating the two arrays together to produce a third array.

[ 1, 2, 3 ] + [ 4, 5 ]    #=> [ 1, 2, 3, 4, 5 ]

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array + other_array   -> an_array
 *
 *  Concatenation---Returns a new array built by concatenating the
 *  two arrays together to produce a third array.
 * 
 *     [ 1, 2, 3 ] + [ 4, 5 ]    #=> [ 1, 2, 3, 4, 5 ]
 */

VALUE
rb_ary_plus(x, y)
    VALUE x, y;
{
    VALUE z;
    long len;

    y = to_ary(y);
    len = RARRAY(x)->len + RARRAY(y)->len;
    z = rb_ary_new2(len);
    MEMCPY(RARRAY(z)->ptr, RARRAY(x)->ptr, VALUE, RARRAY(x)->len);
    MEMCPY(RARRAY(z)->ptr + RARRAY(x)->len, RARRAY(y)->ptr, VALUE, RARRAY(y)->len);
    RARRAY(z)->len = len;
    return z;
}

#-(other_array) ⇒ Array

Array Difference---Returns a new array that is a copy of the original array, removing any items that also appear in other_array. (If you need set-like behavior, see the library class Set.)

[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array - other_array    -> an_array
 *
 *  Array Difference---Returns a new array that is a copy of
 *  the original array, removing any items that also appear in
 *  other_array. (If you need set-like behavior, see the
 *  library class Set.)
 *
 *     [ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]
 */

static VALUE
rb_ary_diff(ary1, ary2)
    VALUE ary1, ary2;
{
    VALUE ary3;
    volatile VALUE hash;
    long i;

    hash = ary_make_hash(to_ary(ary2), 0);
    ary3 = rb_ary_new();

    for (i=0; i<RARRAY(ary1)->len; i++) {
    if (st_lookup(RHASH(hash)->tbl, RARRAY(ary1)->ptr[i], 0)) continue;
    rb_ary_push(ary3, rb_ary_elt(ary1, i));
    }
    return ary3;
}

#<<(obj) ⇒ Array

Append---Pushes the given object on to the end of this array. This expression returns the array itself, so several appends may be chained together.

[ 1, 2 ] << "c" << "d" << [ 3, 4 ]
        #=>  [ 1, 2, "c", "d", [ 3, 4 ] ]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array << obj            -> array
 *  
 *  Append---Pushes the given object on to the end of this array. This
 *  expression returns the array itself, so several appends
 *  may be chained together.
 *
 *     [ 1, 2 ] << "c" << "d" << [ 3, 4 ]
 *             #=>  [ 1, 2, "c", "d", [ 3, 4 ] ]
 *
 */

VALUE
rb_ary_push(ary, item)
    VALUE ary;
    VALUE item;
{
    rb_ary_store(ary, RARRAY(ary)->len, item);
    return ary;
}

#<=>(other_array) ⇒ -1, ...

Comparison---Returns an integer (-1, 0, or +1) if this array is less than, equal to, or greater than other_array. Each object in each array is compared (using <=>). If any value isn't equal, then that inequality is the return value. If all the values found are equal, then the return is based on a comparison of the array lengths. Thus, two arrays are "equal" according to Array#<=> if and only if they have the same length and the value of each element is equal to the value of the corresponding element in the other array.

[ "a", "a", "c" ]    <=> [ "a", "b", "c" ]   #=> -1
[ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ]            #=> +1

Returns:

  • (-1, 0, +1) 



# File 'array.c'

/* 
 *  call-seq:
 *     array <=> other_array   ->  -1, 0, +1
 *
 *  Comparison---Returns an integer (-1, 0,
 *  or +1) if this array is less than, equal to, or greater than
 *  other_array.  Each object in each array is compared
 *  (using <=>). If any value isn't
 *  equal, then that inequality is the return value. If all the
 *  values found are equal, then the return is based on a
 *  comparison of the array lengths.  Thus, two arrays are
 *  ``equal'' according to <code>Array#<=></code> if and only if they have
 *  the same length and the value of each element is equal to the
 *  value of the corresponding element in the other array.
 *  
 *     [ "a", "a", "c" ]    <=> [ "a", "b", "c" ]   #=> -1
 *     [ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ]            #=> +1
 *
 */

VALUE
rb_ary_cmp(ary1, ary2)
    VALUE ary1, ary2;
{
    long len;
    VALUE v;

    ary2 = to_ary(ary2);
    if (ary1 == ary2) return INT2FIX(0);
    v = rb_exec_recursive(recursive_cmp, ary1, ary2);
    if (v != Qundef) return v;
    len = RARRAY(ary1)->len - RARRAY(ary2)->len;
    if (len == 0) return INT2FIX(0);
    if (len > 0) return INT2FIX(1);
    return INT2FIX(-1);
}

#==(other_array) ⇒ Object

Equality---Two arrays are equal if they contain the same number of elements and if each element is equal to (according to Object.==) the corresponding element in the other array.

[ "a", "c" ]    == [ "a", "c", 7 ]     #=> false
[ "a", "c", 7 ] == [ "a", "c", 7 ]     #=> true
[ "a", "c", 7 ] == [ "a", "d", "f" ]   #=> false




# File 'array.c'

/* 
 *  call-seq:
 *     array == other_array   ->   bool
 *
 *  Equality---Two arrays are equal if they contain the same number
 *  of elements and if each element is equal to (according to
 *  Object.==) the corresponding element in the other array.
 *
 *     [ "a", "c" ]    == [ "a", "c", 7 ]     #=> false
 *     [ "a", "c", 7 ] == [ "a", "c", 7 ]     #=> true
 *     [ "a", "c", 7 ] == [ "a", "d", "f" ]   #=> false
 *
 */

static VALUE
rb_ary_equal(ary1, ary2)
    VALUE ary1, ary2;
{
    if (ary1 == ary2) return Qtrue;
    if (TYPE(ary2) != T_ARRAY) {
    if (!rb_respond_to(ary2, rb_intern("to_ary"))) {
        return Qfalse;
    }
    return rb_equal(ary2, ary1);
    }
    if (RARRAY(ary1)->len != RARRAY(ary2)->len) return Qfalse;
    return rb_exec_recursive(recursive_equal, ary1, ary2);
}

#[](index) ⇒ Object? #[](start, length) ⇒ Array? #[](range) ⇒ Array? #slice(index) ⇒ Object? #slice(start, length) ⇒ Array? #slice(range) ⇒ Array?

Element Reference---Returns the element at index, or returns a subarray starting at start and continuing for length elements, or returns a subarray specified by range. Negative indices count backward from the end of the array (-1 is the last element). Returns nil if the index (or starting index) are out of range.

a = [ "a", "b", "c", "d", "e" ]
a[2] +  a[0] + a[1]    #=> "cab"
a[6]                   #=> nil
a[1, 2]                #=> [ "b", "c" ]
a[1..3]                #=> [ "b", "c", "d" ]
a[4..7]                #=> [ "e" ]
a[6..10]               #=> nil
a[-3, 3]               #=> [ "c", "d", "e" ]
# special cases
a[5]                   #=> nil
a[5, 1]                #=> []
a[5..10]               #=> []

Overloads:




# File 'array.c'

/* 
 *  call-seq:
 *     array[index]                -> obj      or nil
 *     array[start, length]        -> an_array or nil
 *     array[range]                -> an_array or nil
 *     array.slice(index)          -> obj      or nil
 *     array.slice(start, length)  -> an_array or nil
 *     array.slice(range)          -> an_array or nil
 *
 *  Element Reference---Returns the element at _index_,
 *  or returns a subarray starting at _start_ and
 *  continuing for _length_ elements, or returns a subarray
 *  specified by _range_.
 *  Negative indices count backward from the end of the
 *  array (-1 is the last element). Returns nil if the index
 *  (or starting index) are out of range.
 *
 *     a = [ "a", "b", "c", "d", "e" ]
 *     a[2] +  a[0] + a[1]    #=> "cab"
 *     a[6]                   #=> nil
 *     a[1, 2]                #=> [ "b", "c" ]
 *     a[1..3]                #=> [ "b", "c", "d" ]
 *     a[4..7]                #=> [ "e" ]
 *     a[6..10]               #=> nil
 *     a[-3, 3]               #=> [ "c", "d", "e" ]
 *     # special cases
 *     a[5]                   #=> nil
 *     a[5, 1]                #=> []
 *     a[5..10]               #=> []
 *
 */

VALUE
rb_ary_aref(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE arg;
    long beg, len;

    if (argc == 2) {
    if (SYMBOL_P(argv[0])) {
        rb_raise(rb_eTypeError, "Symbol as array index");
    }
    beg = NUM2LONG(argv[0]);
    len = NUM2LONG(argv[1]);
    if (beg < 0) {
        beg += RARRAY(ary)->len;
    }
    return rb_ary_subseq(ary, beg, len);
    }
    if (argc != 1) {
    rb_scan_args(argc, argv, "11", 0, 0);
    }
    arg = argv[0];
    /* special case - speeding up */
    if (FIXNUM_P(arg)) {
    return rb_ary_entry(ary, FIX2LONG(arg));
    }
    if (SYMBOL_P(arg)) {
    rb_raise(rb_eTypeError, "Symbol as array index");
    }
    /* check if idx is Range */
    switch (rb_range_beg_len(arg, &beg, &len, RARRAY(ary)->len, 0)) {
      case Qfalse:
    break;
      case Qnil:
    return Qnil;
      default:
    return rb_ary_subseq(ary, beg, len);
    }
    return rb_ary_entry(ary, NUM2LONG(arg));
}

#[]=(index) ⇒ Object #[]=(start, length) ⇒ Object, ... #[]=(range) ⇒ Object, ...

Element Assignment---Sets the element at index, or replaces a subarray starting at start and continuing for length elements, or replaces a subarray specified by range. If indices are greater than the current capacity of the array, the array grows automatically. A negative indices will count backward from the end of the array. Inserts elements if length is zero. If nil is used in the second and third form, deletes elements from self. An IndexError is raised if a negative index points past the beginning of the array. See also Array#push, and Array#unshift.

a = Array.new
a[4] = "4";                 #=> [nil, nil, nil, nil, "4"]
a[0, 3] = [ 'a', 'b', 'c' ] #=> ["a", "b", "c", nil, "4"]
a[1..2] = [ 1, 2 ]          #=> ["a", 1, 2, nil, "4"]
a[0, 2] = "?"               #=> ["?", 2, nil, "4"]
a[0..2] = "A"               #=> ["A", "4"]
a[-1]   = "Z"               #=> ["A", "Z"]
a[1..-1] = nil              #=> ["A"]

Overloads:




# File 'array.c'

/* 
 *  call-seq:
 *     array[index]         = obj                     ->  obj
 *     array[start, length] = obj or an_array or nil  ->  obj or an_array or nil
 *     array[range]         = obj or an_array or nil  ->  obj or an_array or nil
 *
 *  Element Assignment---Sets the element at _index_,
 *  or replaces a subarray starting at _start_ and
 *  continuing for _length_ elements, or replaces a subarray
 *  specified by _range_.  If indices are greater than
 *  the current capacity of the array, the array grows
 *  automatically. A negative indices will count backward
 *  from the end of the array. Inserts elements if _length_ is
 *  zero. If +nil+ is used in the second and third form,
 *  deletes elements from _self_. An +IndexError+ is raised if a
 *  negative index points past the beginning of the array. See also
 *  <code>Array#push</code>, and <code>Array#unshift</code>.
 * 
 *     a = Array.new
 *     a[4] = "4";                 #=> [nil, nil, nil, nil, "4"]
 *     a[0, 3] = [ 'a', 'b', 'c' ] #=> ["a", "b", "c", nil, "4"]
 *     a[1..2] = [ 1, 2 ]          #=> ["a", 1, 2, nil, "4"]
 *     a[0, 2] = "?"               #=> ["?", 2, nil, "4"]
 *     a[0..2] = "A"               #=> ["A", "4"]
 *     a[-1]   = "Z"               #=> ["A", "Z"]
 *     a[1..-1] = nil              #=> ["A"]
 */

static VALUE
rb_ary_aset(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    long offset, beg, len;

    if (argc == 3) {
    if (SYMBOL_P(argv[0])) {
        rb_raise(rb_eTypeError, "Symbol as array index");
    }
    if (SYMBOL_P(argv[1])) {
        rb_raise(rb_eTypeError, "Symbol as subarray length");
    }
    rb_ary_splice(ary, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]);
    return argv[2];
    }
    if (argc != 2) {
    rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
    }
    if (FIXNUM_P(argv[0])) {
    offset = FIX2LONG(argv[0]);
    goto fixnum;
    }
    if (SYMBOL_P(argv[0])) {
    rb_raise(rb_eTypeError, "Symbol as array index");
    }
    if (rb_range_beg_len(argv[0], &beg, &len, RARRAY(ary)->len, 1)) {
    /* check if idx is Range */
    rb_ary_splice(ary, beg, len, argv[1]);
    return argv[1];
    }

    offset = NUM2LONG(argv[0]);
fixnum:
    rb_ary_store(ary, offset, argv[1]);
    return argv[1];
}

#assoc(obj) ⇒ Array?

Searches through an array whose elements are also arrays comparing obj with the first element of each contained array using obj.==. Returns the first contained array that matches (that is, the first associated array), or nil if no match is found. See also Array#rassoc.

s1 = [ "colors", "red", "blue", "green" ]
s2 = [ "letters", "a", "b", "c" ]
s3 = "foo"
a  = [ s1, s2, s3 ]
a.assoc("letters")  #=> [ "letters", "a", "b", "c" ]
a.assoc("foo")      #=> nil

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.assoc(obj)   ->  an_array  or  nil
 *
 *  Searches through an array whose elements are also arrays
 *  comparing _obj_ with the first element of each contained array
 *  using obj.==.
 *  Returns the first contained array that matches (that
 *  is, the first associated array),
 *  or +nil+ if no match is found.
 *  See also <code>Array#rassoc</code>.
 *
 *     s1 = [ "colors", "red", "blue", "green" ]
 *     s2 = [ "letters", "a", "b", "c" ]
 *     s3 = "foo"
 *     a  = [ s1, s2, s3 ]
 *     a.assoc("letters")  #=> [ "letters", "a", "b", "c" ]
 *     a.assoc("foo")      #=> nil
 */

VALUE
rb_ary_assoc(ary, key)
    VALUE ary, key;
{
    long i;
    VALUE v;

    for (i = 0; i < RARRAY(ary)->len; ++i) {
    v = rb_check_array_type(RARRAY(ary)->ptr[i]);
    if (!NIL_P(v) && RARRAY(v)->len > 0 &&
        rb_equal(RARRAY(v)->ptr[0], key))
        return v;
    }
    return Qnil;
}

#at(index) ⇒ Object?

Returns the element at index. A negative index counts from the end of self. Returns nil if the index is out of range. See also Array#[]. (Array#at is slightly faster than Array#[], as it does not accept ranges and so on.)

a = [ "a", "b", "c", "d", "e" ]
a.at(0)     #=> "a"
a.at(-1)    #=> "e"

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.at(index)   ->   obj  or nil
 *
 *  Returns the element at _index_. A
 *  negative index counts from the end of _self_.  Returns +nil+
 *  if the index is out of range. See also <code>Array#[]</code>.
 *  (<code>Array#at</code> is slightly faster than <code>Array#[]</code>,
 *  as it does not accept ranges and so on.)
 *
 *     a = [ "a", "b", "c", "d", "e" ]
 *     a.at(0)     #=> "a"
 *     a.at(-1)    #=> "e"
 */

static VALUE
rb_ary_at(ary, pos)
    VALUE ary, pos;
{
    return rb_ary_entry(ary, NUM2LONG(pos));
}

#choice ⇒ Object

Choose a random element from an array.

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.choice        -> obj
 *  
 *  Choose a random element from an array.
 */


static VALUE
rb_ary_choice(ary)
    VALUE ary;
{
    long i, j;

    i = RARRAY(ary)->len;
    if (i == 0) return Qnil;
    j = rb_genrand_real()*i;
    return RARRAY(ary)->ptr[j];
}

#clear ⇒ Array

Removes all elements from self.

a = [ "a", "b", "c", "d", "e" ]
a.clear    #=> [ ]

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.clear    ->  array
 *
 *  Removes all elements from _self_.
 *
 *     a = [ "a", "b", "c", "d", "e" ]
 *     a.clear    #=> [ ]
 */

VALUE
rb_ary_clear(ary)
    VALUE ary;
{
    rb_ary_modify(ary);
    RARRAY(ary)->len = 0;
    if (ARY_DEFAULT_SIZE * 2 < RARRAY(ary)->aux.capa) {
    REALLOC_N(RARRAY(ary)->ptr, VALUE, ARY_DEFAULT_SIZE * 2);
    RARRAY(ary)->aux.capa = ARY_DEFAULT_SIZE * 2;
    }
    return ary;
}

#collect {|item| ... } ⇒ Array #map {|item| ... } ⇒ Array

Invokes block once for each element of self. Creates a new array containing the values returned by the block. See also Enumerable#collect.

a = [ "a", "b", "c", "d" ]
a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]
a                          #=> ["a", "b", "c", "d"]

Overloads:

  • #collect {|item| ... } ⇒ Array

    Yields:

    • (item)

    Returns:

  • #map {|item| ... } ⇒ Array

    Yields:

    • (item)

    Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.collect {|item| block }  -> an_array
 *     array.map     {|item| block }  -> an_array
 *  
 *  Invokes <i>block</i> once for each element of <i>self</i>. Creates a 
 *  new array containing the values returned by the block.
 *  See also <code>Enumerable#collect</code>.
 *     
 *     a = [ "a", "b", "c", "d" ]
 *     a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]
 *     a                          #=> ["a", "b", "c", "d"]
 */

static VALUE
rb_ary_collect(ary)
    VALUE ary;
{
    long i;
    VALUE collect;

    if (!rb_block_given_p()) {
    return rb_ary_new4(RARRAY(ary)->len, RARRAY(ary)->ptr);
    }

    collect = rb_ary_new2(RARRAY(ary)->len);
    for (i = 0; i < RARRAY(ary)->len; i++) {
    rb_ary_push(collect, rb_yield(RARRAY(ary)->ptr[i]));
    }
    return collect;
}

#collect! {|item| ... } ⇒ Array #map! {|item| ... } ⇒ Array

Invokes the block once for each element of self, replacing the element with the value returned by block. See also Enumerable#collect.

a = [ "a", "b", "c", "d" ]
a.collect! {|x| x + "!" }
a             #=>  [ "a!", "b!", "c!", "d!" ]

Overloads:

  • #collect! {|item| ... } ⇒ Array

    Yields:

    • (item)

    Returns:

  • #map! {|item| ... } ⇒ Array

    Yields:

    • (item)

    Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.collect! {|item| block }   ->   array
 *     array.map!     {|item| block }   ->   array
 *
 *  Invokes the block once for each element of _self_, replacing the
 *  element with the value returned by _block_.
 *  See also <code>Enumerable#collect</code>.
 *   
 *     a = [ "a", "b", "c", "d" ]
 *     a.collect! {|x| x + "!" }
 *     a             #=>  [ "a!", "b!", "c!", "d!" ]
 */

static VALUE
rb_ary_collect_bang(ary)
    VALUE ary;
{
    long i;

    RETURN_ENUMERATOR(ary, 0, 0);
    rb_ary_modify(ary);
    for (i = 0; i < RARRAY(ary)->len; i++) {
    rb_ary_store(ary, i, rb_yield(RARRAY(ary)->ptr[i]));
    }
    return ary;
}

#combination(n) {|c| ... } ⇒ Object #combination(n) ⇒ Object

When invoked with a block, yields all combinations of length n of elements from ary and then returns ary itself. The implementation makes no guarantees about the order in which the combinations are yielded.

When invoked without a block, returns an enumerator object instead.

Examples:

a = [1, 2, 3, 4]
a.combination(1).to_a  #=> [[1],[2],[3],[4]]
a.combination(2).to_a  #=> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
a.combination(3).to_a  #=> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]]
a.combination(4).to_a  #=> [[1,2,3,4]]
a.combination(0).to_a  #=> [[]] # one combination of length 0
a.combination(5).to_a  #=> []   # no combinations of length 5

Overloads:

  • #combination(n) {|c| ... } ⇒ Object

    Yields:

    • (c) 



# File 'array.c'

/*
 *  call-seq:
 *     ary.combination(n) { |c| block }    -> ary
 *     ary.combination(n)                  -> enumerator
 *  
 * When invoked with a block, yields all combinations of length <i>n</i> 
 * of elements from <i>ary</i> and then returns <i>ary</i> itself.
 * The implementation makes no guarantees about the order in which 
 * the combinations are yielded.
 *
 * When invoked without a block, returns an enumerator object instead.
 *     
 * Examples:
 *
 *     a = [1, 2, 3, 4]
 *     a.combination(1).to_a  #=> [[1],[2],[3],[4]]
 *     a.combination(2).to_a  #=> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
 *     a.combination(3).to_a  #=> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]]
 *     a.combination(4).to_a  #=> [[1,2,3,4]]
 *     a.combination(0).to_a  #=> [[]] # one combination of length 0
 *     a.combination(5).to_a  #=> []   # no combinations of length 5
 *     
 */

static VALUE
rb_ary_combination(ary, num)
    VALUE ary;
    VALUE num;
{
    long n, i, len;

    n = NUM2LONG(num);
    RETURN_ENUMERATOR(ary, 1, &num);
    len = RARRAY(ary)->len;
    if (n < 0 || len < n) {
    /* yield nothing */
    }
    else if (n == 0) {
    rb_yield(rb_ary_new2(0));
    }
    else if (n == 1) {
    for (i = 0; i < len; i++) {
        rb_yield(rb_ary_new3(1, RARRAY(ary)->ptr[i]));
    }
    }
    else {
    volatile VALUE t0 = tmpbuf(n+1, sizeof(long));
    long *stack = (long*)RSTRING(t0)->ptr;
    long nlen = combi_len(len, n);
    volatile VALUE cc = rb_ary_new2(n);
    VALUE *chosen = RARRAY(cc)->ptr;
    long lev = 0;

    RBASIC(cc)->klass = 0;
    MEMZERO(stack, long, n);
    stack[0] = -1;
    for (i = 0; i < nlen; i++) {
        chosen[lev] = RARRAY(ary)->ptr[stack[lev+1]];
        for (lev++; lev < n; lev++) {
        chosen[lev] = RARRAY(ary)->ptr[stack[lev+1] = stack[lev]+1];
        }
        rb_yield(rb_ary_new4(n, chosen));
        do {
        stack[lev--]++;
        } while (lev && (stack[lev+1]+n == len+lev+1));
    }
    }
    return ary;
}

#compact ⇒ Array

Returns a copy of self with all nil elements removed.

[ "a", nil, "b", nil, "c", nil ].compact
                  #=> [ "a", "b", "c" ]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.compact     ->  an_array
 *
 *  Returns a copy of _self_ with all +nil+ elements removed.
 *
 *     [ "a", nil, "b", nil, "c", nil ].compact
 *                       #=> [ "a", "b", "c" ]
 */

static VALUE
rb_ary_compact(ary)
    VALUE ary;
{
    ary = rb_ary_dup(ary);
    rb_ary_compact_bang(ary);
    return ary;
}

#compact! ⇒ Array?

Removes nil elements from array. Returns nil if no changes were made.

[ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ]
[ "a", "b", "c" ].compact!           #=> nil

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.compact!    ->   array  or  nil
 *
 *  Removes +nil+ elements from array.
 *  Returns +nil+ if no changes were made.
 *
 *     [ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ]
 *     [ "a", "b", "c" ].compact!           #=> nil
 */

static VALUE
rb_ary_compact_bang(ary)
    VALUE ary;
{
    VALUE *p, *t, *end;

    rb_ary_modify(ary);
    p = t = RARRAY(ary)->ptr;
    end = p + RARRAY(ary)->len;
    
    while (t < end) {
    if (NIL_P(*t)) t++;
    else *p++ = *t++;
    }
    if (RARRAY(ary)->len == (p - RARRAY(ary)->ptr)) {
    return Qnil;
    }
    RARRAY(ary)->len = RARRAY(ary)->aux.capa = (p - RARRAY(ary)->ptr);
    REALLOC_N(RARRAY(ary)->ptr, VALUE, RARRAY(ary)->len);

    return ary;
}

#concat(other_array) ⇒ Array

Appends the elements in other_array to self.

[ "a", "b" ].concat( ["c", "d"] ) #=> [ "a", "b", "c", "d" ]

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.concat(other_array)   ->  array
 *
 *  Appends the elements in other_array to _self_.
 *  
 *     [ "a", "b" ].concat( ["c", "d"] ) #=> [ "a", "b", "c", "d" ]
 */


VALUE
rb_ary_concat(x, y)
    VALUE x, y;
{
    y = to_ary(y);
    if (RARRAY(y)->len > 0) {
    rb_ary_splice(x, RARRAY(x)->len, 0, y);
    }
    return x;
}

#count ⇒ Integer #count(obj) ⇒ Integer #count {|item| ... } ⇒ Integer

Returns the number of elements. If an argument is given, counts the number of elements which equals to obj. If a block is given, counts the number of elements yielding a true value.

ary = [1, 2, 4, 2]
ary.count             # => 4
ary.count(2)          # => 2
ary.count{|x|x%2==0}  # => 3

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.count      -> int
 *     array.count(obj) -> int
 *     array.count { |item| block }  -> int
 *  
 *  Returns the number of elements.  If an argument is given, counts
 *  the number of elements which equals to <i>obj</i>.  If a block is
 *  given, counts the number of elements yielding a true value.
 *
 *     ary = [1, 2, 4, 2]
 *     ary.count             # => 4
 *     ary.count(2)          # => 2
 *     ary.count{|x|x%2==0}  # => 3
 *
 */

static VALUE
rb_ary_count(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    long n = 0;

    if (argc == 0) {
    VALUE *p, *pend;

    if (!rb_block_given_p())
        return LONG2NUM(RARRAY_LEN(ary));

    for (p = RARRAY_PTR(ary), pend = p + RARRAY_LEN(ary); p < pend; p++) {
        if (RTEST(rb_yield(*p))) n++;
    }
    }
    else {
    VALUE obj, *p, *pend;

    rb_scan_args(argc, argv, "1", &obj);
    if (rb_block_given_p()) {
        rb_warn("given block not used");
    }
    for (p = RARRAY_PTR(ary), pend = p + RARRAY_LEN(ary); p < pend; p++) {
        if (rb_equal(*p, obj)) n++;
    }
    }

    return LONG2NUM(n);
}

#cycle {|obj| ... } ⇒ Object #cycle(n) {|obj| ... } ⇒ Object

Calls block for each element repeatedly n times or forever if none or nil is given. If a non-positive number is given or the array is empty, does nothing. Returns nil if the loop has finished without getting interrupted.

a = ["a", "b", "c"]
a.cycle {|x| puts x }  # print, a, b, c, a, b, c,.. forever.
a.cycle(2) {|x| puts x }  # print, a, b, c, a, b, c.

Overloads:

  • #cycle {|obj| ... } ⇒ Object

    Yields:

    • (obj)
  • #cycle(n) {|obj| ... } ⇒ Object

    Yields:

    • (obj) 



# File 'array.c'

/*
 *  call-seq:
 *     ary.cycle {|obj| block }
 *     ary.cycle(n) {|obj| block }
 *  
 *  Calls <i>block</i> for each element repeatedly _n_ times or
 *  forever if none or nil is given.  If a non-positive number is
 *  given or the array is empty, does nothing.  Returns nil if the
 *  loop has finished without getting interrupted.
 *     
 *     a = ["a", "b", "c"]
 *     a.cycle {|x| puts x }  # print, a, b, c, a, b, c,.. forever.
 *     a.cycle(2) {|x| puts x }  # print, a, b, c, a, b, c.
 *     
 */

static VALUE
rb_ary_cycle(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    long n, i;
    VALUE nv = Qnil;

    rb_scan_args(argc, argv, "01", &nv);

    RETURN_ENUMERATOR(ary, argc, argv);
    if (NIL_P(nv)) {
        n = -1;
    }
    else {
        n = NUM2LONG(nv);
        if (n <= 0) return Qnil;
    }

    while (RARRAY(ary)->len > 0 && (n < 0 || 0 < n--)) {
        for (i=0; i<RARRAY(ary)->len; i++) {
            rb_yield(RARRAY(ary)->ptr[i]);
        }
    }
    return Qnil;
}

#delete(obj) ⇒ Object? #delete(obj) { ... } ⇒ Object?

Deletes items from self that are equal to obj. If the item is not found, returns nil. If the optional code block is given, returns the result of block if the item is not found.

a = [ "a", "b", "b", "b", "c" ]
a.delete("b")                   #=> "b"
a                               #=> ["a", "c"]
a.delete("z")                   #=> nil
a.delete("z") { "not found" }   #=> "not found"

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.delete(obj)            -> obj or nil 
 *     array.delete(obj) { block }  -> obj or nil
 *  
 *  Deletes items from <i>self</i> that are equal to <i>obj</i>. If
 *  the item is not found, returns <code>nil</code>. If the optional
 *  code block is given, returns the result of <i>block</i> if the item
 *  is not found.
 *     
 *     a = [ "a", "b", "b", "b", "c" ]
 *     a.delete("b")                   #=> "b"
 *     a                               #=> ["a", "c"]
 *     a.delete("z")                   #=> nil
 *     a.delete("z") { "not found" }   #=> "not found"
 */

VALUE
rb_ary_delete(ary, item)
    VALUE ary;
    VALUE item;
{
    long i1, i2;

    for (i1 = i2 = 0; i1 < RARRAY(ary)->len; i1++) {
    VALUE e = RARRAY(ary)->ptr[i1];

    if (rb_equal(e, item)) continue;
    if (i1 != i2) {
        rb_ary_store(ary, i2, e);
    }
    i2++;
    }
    if (RARRAY(ary)->len == i2) {
    if (rb_block_given_p()) {
        return rb_yield(item);
    }
    return Qnil;
    }

    rb_ary_modify(ary);
    if (RARRAY(ary)->len > i2) {
    RARRAY(ary)->len = i2;
    if (i2 * 2 < RARRAY(ary)->aux.capa &&
        RARRAY(ary)->aux.capa > ARY_DEFAULT_SIZE) {
        REALLOC_N(RARRAY(ary)->ptr, VALUE, i2 * 2);
        RARRAY(ary)->aux.capa = i2 * 2;
    }
    }

    return item;
}

#delete_at(index) ⇒ Object?

Deletes the element at the specified index, returning that element, or nil if the index is out of range. See also Array#slice!.

a = %w( ant bat cat dog )
a.delete_at(2)    #=> "cat"
a                 #=> ["ant", "bat", "dog"]
a.delete_at(99)   #=> nil

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.delete_at(index)  -> obj or nil
 *  
 *  Deletes the element at the specified index, returning that element,
 *  or <code>nil</code> if the index is out of range. See also
 *  <code>Array#slice!</code>.
 *     
 *     a = %w( ant bat cat dog )
 *     a.delete_at(2)    #=> "cat"
 *     a                 #=> ["ant", "bat", "dog"]
 *     a.delete_at(99)   #=> nil
 */

static VALUE
rb_ary_delete_at_m(ary, pos)
    VALUE ary, pos;
{
    return rb_ary_delete_at(ary, NUM2LONG(pos));
}

#delete_if {|item| ... } ⇒ Array

Deletes every element of self for which block evaluates to true.

a = [ "a", "b", "c" ]
a.delete_if {|x| x >= "b" }   #=> ["a"]

Yields:

  • (item)

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.delete_if {|item| block }  -> array
 *  
 *  Deletes every element of <i>self</i> for which <i>block</i> evaluates
 *  to <code>true</code>.
 *     
 *     a = [ "a", "b", "c" ]
 *     a.delete_if {|x| x >= "b" }   #=> ["a"]
 */

static VALUE
rb_ary_delete_if(ary)
    VALUE ary;
{
    RETURN_ENUMERATOR(ary, 0, 0);
    rb_ary_reject_bang(ary);
    return ary;
}

#drop(n) ⇒ Array

Drops first n elements from ary, and returns rest elements in an array.

a = [1, 2, 3, 4, 5, 0]
a.drop(3)             # => [4, 5, 0]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     ary.drop(n)               => array
 *  
 *  Drops first n elements from <i>ary</i>, and returns rest elements
 *  in an array.
 *     
 *     a = [1, 2, 3, 4, 5, 0]
 *     a.drop(3)             # => [4, 5, 0]
 *     
 */

static VALUE
rb_ary_drop(ary, n)
    VALUE ary;
    VALUE n;
{
    VALUE result;
    long pos = NUM2LONG(n);
    if (pos < 0) {
    rb_raise(rb_eArgError, "attempt to drop negative size");
    }

    result = rb_ary_subseq(ary, pos, RARRAY(ary)->len);
    if (result == Qnil) result = rb_ary_new();
    return result;
}

#drop_while {|arr| ... } ⇒ Array

Drops elements up to, but not including, the first element for which the block returns nil or false and returns an array containing the remaining elements.

a = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 }   # => [3, 4, 5, 0]

Yields:

  • (arr)

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     ary.drop_while {|arr| block }   => array
 *  
 *  Drops elements up to, but not including, the first element for
 *  which the block returns nil or false and returns an array
 *  containing the remaining elements.
 *     
 *     a = [1, 2, 3, 4, 5, 0]
 *     a.drop_while {|i| i < 3 }   # => [3, 4, 5, 0]
 *     
 */

static VALUE
rb_ary_drop_while(ary)
    VALUE ary;
{
    long i;

    RETURN_ENUMERATOR(ary, 0, 0);
    for (i = 0; i < RARRAY(ary)->len; i++) {
    if (!RTEST(rb_yield(RARRAY(ary)->ptr[i]))) break;
    }
    return rb_ary_drop(ary, LONG2FIX(i));
}

#each {|item| ... } ⇒ Array

Calls block once for each element in self, passing that element as a parameter.

a = [ "a", "b", "c" ]
a.each {|x| print x, " -- " }

produces:

a -- b -- c --

Yields:

  • (item)

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.each {|item| block }   ->   array
 *  
 *  Calls <i>block</i> once for each element in <i>self</i>, passing that
 *  element as a parameter.
 *     
 *     a = [ "a", "b", "c" ]
 *     a.each {|x| print x, " -- " }
 *     
 *  produces:
 *     
 *     a -- b -- c --
 */

VALUE
rb_ary_each(ary)
    VALUE ary;
{
    long i;

    RETURN_ENUMERATOR(ary, 0, 0);
    for (i=0; i<RARRAY(ary)->len; i++) {
    rb_yield(RARRAY(ary)->ptr[i]);
    }
    return ary;
}

#each_index {|index| ... } ⇒ Array

Same as Array#each, but passes the index of the element instead of the element itself.

a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }

produces:

0 -- 1 -- 2 --

Yields:

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.each_index {|index| block }  ->  array
 *  
 *  Same as <code>Array#each</code>, but passes the index of the element
 *  instead of the element itself.
 *     
 *     a = [ "a", "b", "c" ]
 *     a.each_index {|x| print x, " -- " }
 *     
 *  produces:
 *     
 *     0 -- 1 -- 2 --
 */

static VALUE
rb_ary_each_index(ary)
    VALUE ary;
{
    long i;

    RETURN_ENUMERATOR(ary, 0, 0);
    for (i=0; i<RARRAY(ary)->len; i++) {
    rb_yield(LONG2NUM(i));
    }
    return ary;
}

#empty? ⇒ Boolean

Returns true if self array contains no elements.

[].empty?   #=> true

Returns:

  • (Boolean) 



# File 'array.c'

/*
 *  call-seq:
 *     array.empty?   -> true or false
 *  
 *  Returns <code>true</code> if <i>self</i> array contains no elements.
 *     
 *     [].empty?   #=> true
 */

static VALUE
rb_ary_empty_p(ary)
    VALUE ary;
{
    if (RARRAY(ary)->len == 0)
    return Qtrue;
    return Qfalse;
}

#eql?(other) ⇒ Boolean

Returns true if array and other are the same object, or are both arrays with the same content.

Returns:

  • (Boolean) 



# File 'array.c'

/*
 *  call-seq:
 *     array.eql?(other)  -> true or false
 *
 *  Returns <code>true</code> if _array_ and _other_ are the same object,
 *  or are both arrays with the same content.
 */

static VALUE
rb_ary_eql(ary1, ary2)
    VALUE ary1, ary2;
{
    if (ary1 == ary2) return Qtrue;
    if (TYPE(ary2) != T_ARRAY) return Qfalse;
    if (RARRAY(ary1)->len != RARRAY(ary2)->len) return Qfalse;
    return rb_exec_recursive(recursive_eql, ary1, ary2);
}

#fetch(index) ⇒ Object #fetch(index, default) ⇒ Object #fetch(index) {|index| ... } ⇒ Object

Tries to return the element at position index. If the index lies outside the array, the first form throws an IndexError exception, the second form returns default, and the third form returns the value of invoking the block, passing in the index. Negative values of index count from the end of the array.

a = [ 11, 22, 33, 44 ]
a.fetch(1)               #=> 22
a.fetch(-1)              #=> 44
a.fetch(4, 'cat')        #=> "cat"
a.fetch(4) { |i| i*i }   #=> 16

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.fetch(index)                    -> obj
 *     array.fetch(index, default )          -> obj
 *     array.fetch(index) {|index| block }   -> obj
 *  
 *  Tries to return the element at position <i>index</i>. If the index
 *  lies outside the array, the first form throws an
 *  <code>IndexError</code> exception, the second form returns
 *  <i>default</i>, and the third form returns the value of invoking
 *  the block, passing in the index. Negative values of <i>index</i>
 *  count from the end of the array.
 *     
 *     a = [ 11, 22, 33, 44 ]
 *     a.fetch(1)               #=> 22
 *     a.fetch(-1)              #=> 44
 *     a.fetch(4, 'cat')        #=> "cat"
 *     a.fetch(4) { |i| i*i }   #=> 16
 */

static VALUE
rb_ary_fetch(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE pos, ifnone;
    long block_given;
    long idx;

    rb_scan_args(argc, argv, "11", &pos, &ifnone);
    block_given = rb_block_given_p();
    if (block_given && argc == 2) {
    rb_warn("block supersedes default value argument");
    }
    idx = NUM2LONG(pos);

    if (idx < 0) {
    idx +=  RARRAY(ary)->len;
    }
    if (idx < 0 || RARRAY(ary)->len <= idx) {
    if (block_given) return rb_yield(pos);
    if (argc == 1) {
        rb_raise(rb_eIndexError, "index %ld out of array", idx);
    }
    return ifnone;
    }
    return RARRAY(ary)->ptr[idx];
}

#fill(obj) ⇒ Array #fill(obj, start[, length]) ⇒ Array #fill(obj, range) ⇒ Array #fill {|index| ... } ⇒ Array #fill(start[, length]) {|index| ... } ⇒ Array #fill(range) {|index| ... } ⇒ Array

The first three forms set the selected elements of self (which may be the entire array) to obj. A start of nil is equivalent to zero. A length of nil is equivalent to self.length. The last three forms fill the array with the value of the block. The block is passed the absolute index of each element to be filled.

a = [ "a", "b", "c", "d" ]
a.fill("x")              #=> ["x", "x", "x", "x"]
a.fill("z", 2, 2)        #=> ["x", "x", "z", "z"]
a.fill("y", 0..1)        #=> ["y", "y", "z", "z"]
a.fill {|i| i*i}         #=> [0, 1, 4, 9]
a.fill(-2) {|i| i*i*i}   #=> [0, 1, 8, 27]

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.fill(obj)                                -> array
 *     array.fill(obj, start [, length])              -> array
 *     array.fill(obj, range )                        -> array
 *     array.fill {|index| block }                    -> array
 *     array.fill(start [, length] ) {|index| block } -> array
 *     array.fill(range) {|index| block }             -> array
 *  
 *  The first three forms set the selected elements of <i>self</i> (which
 *  may be the entire array) to <i>obj</i>. A <i>start</i> of
 *  <code>nil</code> is equivalent to zero. A <i>length</i> of
 *  <code>nil</code> is equivalent to <i>self.length</i>. The last three
 *  forms fill the array with the value of the block. The block is
 *  passed the absolute index of each element to be filled.
 *     
 *     a = [ "a", "b", "c", "d" ]
 *     a.fill("x")              #=> ["x", "x", "x", "x"]
 *     a.fill("z", 2, 2)        #=> ["x", "x", "z", "z"]
 *     a.fill("y", 0..1)        #=> ["y", "y", "z", "z"]
 *     a.fill {|i| i*i}         #=> [0, 1, 4, 9]
 *     a.fill(-2) {|i| i*i*i}   #=> [0, 1, 8, 27]
 */

static VALUE
rb_ary_fill(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE item, arg1, arg2;
    long beg = 0, end = 0, len = 0;
    VALUE *p, *pend;
    int block_p = Qfalse;

    if (rb_block_given_p()) {
    block_p = Qtrue;
    rb_scan_args(argc, argv, "02", &arg1, &arg2);
    argc += 1;     /* hackish */
    }
    else {
    rb_scan_args(argc, argv, "12", &item, &arg1, &arg2);
    }
    switch (argc) {
      case 1:
    beg = 0;
    len = RARRAY(ary)->len;
    break;
      case 2:
    if (rb_range_beg_len(arg1, &beg, &len, RARRAY(ary)->len, 1)) {
        break;
    }
    /* fall through */
      case 3:
    beg = NIL_P(arg1) ? 0 : NUM2LONG(arg1);
    if (beg < 0) {
        beg = RARRAY(ary)->len + beg;
        if (beg < 0) beg = 0;
    }
    len = NIL_P(arg2) ? RARRAY(ary)->len - beg : NUM2LONG(arg2);
    break;
    }
    rb_ary_modify(ary);
    if (len < 0) {
        return ary;
    }
    if (beg >= ARY_MAX_SIZE || len > ARY_MAX_SIZE - beg) {
    rb_raise(rb_eArgError, "argument too big");
    }
    end = beg + len;
    if (end > RARRAY(ary)->len) {
    if (end >= RARRAY(ary)->aux.capa) {
        REALLOC_N(RARRAY(ary)->ptr, VALUE, end);
        RARRAY(ary)->aux.capa = end;
    }
    rb_mem_clear(RARRAY(ary)->ptr + RARRAY(ary)->len, end - RARRAY(ary)->len);
    RARRAY(ary)->len = end;
    }

    if (block_p) {
    VALUE v;
    long i;

    for (i=beg; i<end; i++) {
        v = rb_yield(LONG2NUM(i));
        if (i>=RARRAY(ary)->len) break;
        RARRAY(ary)->ptr[i] = v;
    }
    }
    else {
    p = RARRAY(ary)->ptr + beg;
    pend = p + len;
    while (p < pend) {
        *p++ = item;
    }
    }
    return ary;
}

#index(obj) ⇒ Integer? #index {|item| ... } ⇒ Integer?

Returns the index of the first object in self such that is == to obj. If a block is given instead of an argument, returns first object for which block is true. Returns nil if no match is found.

a = [ "a", "b", "c" ]
a.index("b")        #=> 1
a.index("z")        #=> nil
a.index{|x|x=="b"}  #=> 1

This is an alias of #find_index.

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.index(obj)           ->  int or nil
 *     array.index {|item| block} ->  int or nil
 *  
 *  Returns the index of the first object in <i>self</i> such that is
 *  <code>==</code> to <i>obj</i>. If a block is given instead of an
 *  argument, returns first object for which <em>block</em> is true.
 *  Returns <code>nil</code> if no match is found.
 *     
 *     a = [ "a", "b", "c" ]
 *     a.index("b")        #=> 1
 *     a.index("z")        #=> nil
 *     a.index{|x|x=="b"}  #=> 1
 *
 *  This is an alias of <code>#find_index</code>.
 */

static VALUE
rb_ary_index(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE val;
    long i;

    if (argc  == 0) {
    RETURN_ENUMERATOR(ary, 0, 0);
    for (i=0; i<RARRAY(ary)->len; i++) {
        if (RTEST(rb_yield(RARRAY(ary)->ptr[i]))) {
        return LONG2NUM(i);
        }
    }
    return Qnil;
    }
    rb_scan_args(argc, argv, "01", &val);
    for (i=0; i<RARRAY(ary)->len; i++) {
    if (rb_equal(RARRAY(ary)->ptr[i], val))
        return LONG2NUM(i);
    }
    return Qnil;
}

#first ⇒ Object? #first(n) ⇒ Array

Returns the first element, or the first n elements, of the array. If the array is empty, the first form returns nil, and the second form returns an empty array.

a = [ "q", "r", "s", "t" ]
a.first    #=> "q"
a.first(1) #=> ["q"]
a.first(3) #=> ["q", "r", "s"]

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.first   ->   obj or nil
 *     array.first(n) -> an_array
 *
 *  Returns the first element, or the first +n+ elements, of the array.
 *  If the array is empty, the first form returns <code>nil</code>, and the
 *  second form returns an empty array.
 *
 *     a = [ "q", "r", "s", "t" ]
 *     a.first    #=> "q"
 *     a.first(1) #=> ["q"]
 *     a.first(3) #=> ["q", "r", "s"]
 */

static VALUE
rb_ary_first(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    if (argc == 0) {
    if (RARRAY(ary)->len == 0) return Qnil;
    return RARRAY(ary)->ptr[0];
    }
    else {
    return ary_shared_first(argc, argv, ary, Qfalse);
    }
}

#flatten ⇒ Array #flatten(level) ⇒ Array

Returns a new array that is a one-dimensional flattening of this array (recursively). That is, for every element that is an array, extract its elements into the new array. If the optional level argument determines the level of recursion to flatten.

s = [ 1, 2, 3 ]           #=> [1, 2, 3]
t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
a.flatten                 #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = [ 1, 2, [3, [4, 5] ] ]
a.flatten(1)              #=> [1, 2, 3, [4, 5]]

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.flatten -> an_array
 *     array.flatten(level) -> an_array
 *  
 *  Returns a new array that is a one-dimensional flattening of this
 *  array (recursively). That is, for every element that is an array,
 *  extract its elements into the new array.  If the optional
 *  <i>level</i> argument determines the level of recursion to flatten.
 *     
 *     s = [ 1, 2, 3 ]           #=> [1, 2, 3]
 *     t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
 *     a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
 *     a.flatten                 #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 *     a = [ 1, 2, [3, [4, 5] ] ]
 *     a.flatten(1)              #=> [1, 2, 3, [4, 5]]
 */

static VALUE
rb_ary_flatten(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    int mod = 0, level = -1;
    VALUE result, lv;

    rb_scan_args(argc, argv, "01", &lv);
    if (!NIL_P(lv)) level = NUM2INT(lv);
    if (level == 0) return ary;

    result = flatten(ary, level, &mod);
    if (OBJ_TAINTED(ary)) OBJ_TAINT(result);

    return result;
}

#flatten! ⇒ Array? #flatten!(level) ⇒ Array?

Flattens self in place. Returns nil if no modifications were made (i.e., array contains no subarrays.) If the optional level argument determines the level of recursion to flatten.

a = [ 1, 2, [3, [4, 5] ] ]
a.flatten!   #=> [1, 2, 3, 4, 5]
a.flatten!   #=> nil
a            #=> [1, 2, 3, 4, 5]
a = [ 1, 2, [3, [4, 5] ] ]
a.flatten!(1) #=> [1, 2, 3, [4, 5]]

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.flatten! -> array or nil
 *     array.flatten!(level) -> array or nil
 *  
 *  Flattens _self_ in place.
 *  Returns <code>nil</code> if no modifications were made (i.e.,
 *  <i>array</i> contains no subarrays.)  If the optional <i>level</i>
 *  argument determines the level of recursion to flatten.
 *     
 *     a = [ 1, 2, [3, [4, 5] ] ]
 *     a.flatten!   #=> [1, 2, 3, 4, 5]
 *     a.flatten!   #=> nil
 *     a            #=> [1, 2, 3, 4, 5]
 *     a = [ 1, 2, [3, [4, 5] ] ]
 *     a.flatten!(1) #=> [1, 2, 3, [4, 5]]
 */

static VALUE
rb_ary_flatten_bang(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    int mod = 0, level = -1;
    VALUE result, lv;

    rb_scan_args(argc, argv, "01", &lv);
    if (!NIL_P(lv)) level = NUM2INT(lv);
    if (level == 0) return ary;

    result = flatten(ary, level, &mod);
    if (mod == 0) return Qnil;
    rb_ary_replace(ary, result);

    return ary;
}

#frozen? ⇒ Boolean

Return true if this array is frozen (or temporarily frozen while being sorted).

Returns:

  • (Boolean) 



# File 'array.c'

/*
 *  call-seq:
 *     array.frozen?  -> true or false
 *
 *  Return <code>true</code> if this array is frozen (or temporarily frozen
 *  while being sorted).
 */

static VALUE
rb_ary_frozen_p(ary)
    VALUE ary;
{
    if (OBJ_FROZEN(ary)) return Qtrue;
    if (FL_TEST(ary, ARY_TMPLOCK)) return Qtrue;
    return Qfalse;
}

#hash ⇒ Fixnum

Compute a hash-code for this array. Two arrays with the same content will have the same hash code (and will compare using eql?).

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.hash   -> fixnum
 *
 *  Compute a hash-code for this array. Two arrays with the same content
 *  will have the same hash code (and will compare using <code>eql?</code>).
 */

static VALUE
rb_ary_hash(ary)
    VALUE ary;
{
    return rb_exec_recursive(recursive_hash, ary, 0);
}

#include?(obj) ⇒ Boolean

Returns true if the given object is present in self (that is, if any object == anObject), false otherwise.

a = [ "a", "b", "c" ]
a.include?("b")   #=> true
a.include?("z")   #=> false

Returns:

  • (Boolean) 



# File 'array.c'

/*
 *  call-seq:
 *     array.include?(obj)   -> true or false
 *  
 *  Returns <code>true</code> if the given object is present in
 *  <i>self</i> (that is, if any object <code>==</code> <i>anObject</i>),
 *  <code>false</code> otherwise.
 *     
 *     a = [ "a", "b", "c" ]
 *     a.include?("b")   #=> true
 *     a.include?("z")   #=> false
 */

VALUE
rb_ary_includes(ary, item)
    VALUE ary;
    VALUE item;
{
    long i;
    
    for (i=0; i<RARRAY(ary)->len; i++) {
    if (rb_equal(RARRAY(ary)->ptr[i], item)) {
        return Qtrue;
    }
    }
    return Qfalse;
}

#index(obj) ⇒ Integer? #index {|item| ... } ⇒ Integer?

Returns the index of the first object in self such that is == to obj. If a block is given instead of an argument, returns first object for which block is true. Returns nil if no match is found.

a = [ "a", "b", "c" ]
a.index("b")        #=> 1
a.index("z")        #=> nil
a.index{|x|x=="b"}  #=> 1

This is an alias of #find_index.

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.index(obj)           ->  int or nil
 *     array.index {|item| block} ->  int or nil
 *  
 *  Returns the index of the first object in <i>self</i> such that is
 *  <code>==</code> to <i>obj</i>. If a block is given instead of an
 *  argument, returns first object for which <em>block</em> is true.
 *  Returns <code>nil</code> if no match is found.
 *     
 *     a = [ "a", "b", "c" ]
 *     a.index("b")        #=> 1
 *     a.index("z")        #=> nil
 *     a.index{|x|x=="b"}  #=> 1
 *
 *  This is an alias of <code>#find_index</code>.
 */

static VALUE
rb_ary_index(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE val;
    long i;

    if (argc  == 0) {
    RETURN_ENUMERATOR(ary, 0, 0);
    for (i=0; i<RARRAY(ary)->len; i++) {
        if (RTEST(rb_yield(RARRAY(ary)->ptr[i]))) {
        return LONG2NUM(i);
        }
    }
    return Qnil;
    }
    rb_scan_args(argc, argv, "01", &val);
    for (i=0; i<RARRAY(ary)->len; i++) {
    if (rb_equal(RARRAY(ary)->ptr[i], val))
        return LONG2NUM(i);
    }
    return Qnil;
}

#indexes(i1, i2, ...iN) ⇒ Array #indices(i1, i2, ...iN) ⇒ Array

Deprecated; use Array#values_at.

Overloads:

  • #indexes(i1, i2, ...iN) ⇒ Array

    Returns:

  • #indices(i1, i2, ...iN) ⇒ Array

    Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.indexes( i1, i2, ... iN )   -> an_array
 *     array.indices( i1, i2, ... iN )   -> an_array
 *  
 *  Deprecated; use <code>Array#values_at</code>.
 */

static VALUE
rb_ary_indexes(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE new_ary;
    long i;

    rb_warn("Array#%s is deprecated; use Array#values_at", rb_id2name(rb_frame_last_func()));
    new_ary = rb_ary_new2(argc);
    for (i=0; i<argc; i++) {
    rb_ary_push(new_ary, rb_ary_aref(1, argv+i, ary));
    }

    return new_ary;
}

#indexes(i1, i2, ...iN) ⇒ Array #indices(i1, i2, ...iN) ⇒ Array

Deprecated; use Array#values_at.

Overloads:

  • #indexes(i1, i2, ...iN) ⇒ Array

    Returns:

  • #indices(i1, i2, ...iN) ⇒ Array

    Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.indexes( i1, i2, ... iN )   -> an_array
 *     array.indices( i1, i2, ... iN )   -> an_array
 *  
 *  Deprecated; use <code>Array#values_at</code>.
 */

static VALUE
rb_ary_indexes(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE new_ary;
    long i;

    rb_warn("Array#%s is deprecated; use Array#values_at", rb_id2name(rb_frame_last_func()));
    new_ary = rb_ary_new2(argc);
    for (i=0; i<argc; i++) {
    rb_ary_push(new_ary, rb_ary_aref(1, argv+i, ary));
    }

    return new_ary;
}

#replace(other_array) ⇒ Array

Replaces the contents of self with the contents of other_array, truncating or expanding if necessary.

a = [ "a", "b", "c", "d", "e" ]
a.replace([ "x", "y", "z" ])   #=> ["x", "y", "z"]
a                              #=> ["x", "y", "z"]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.replace(other_array)  -> array
 *  
 *  Replaces the contents of <i>self</i> with the contents of
 *  <i>other_array</i>, truncating or expanding if necessary.
 *     
 *     a = [ "a", "b", "c", "d", "e" ]
 *     a.replace([ "x", "y", "z" ])   #=> ["x", "y", "z"]
 *     a                              #=> ["x", "y", "z"]
 */

static VALUE
rb_ary_replace(copy, orig)
    VALUE copy, orig;
{
    VALUE shared;

    rb_ary_modify(copy);
    orig = to_ary(orig);
    if (copy == orig) return copy;
    shared = ary_make_shared(orig);
    if (RARRAY(copy)->ptr && !FL_TEST(copy, ELTS_SHARED))
    free(RARRAY(copy)->ptr);
    RARRAY(copy)->ptr = RARRAY(orig)->ptr;
    RARRAY(copy)->len = RARRAY(orig)->len;
    RARRAY(copy)->aux.shared = shared;
    FL_SET(copy, ELTS_SHARED);

    return copy;
}

#insert(index, obj...) ⇒ Array

Inserts the given values before the element with the given index (which may be negative).

a = %w{ a b c d }
a.insert(2, 99)         #=> ["a", "b", 99, "c", "d"]
a.insert(-2, 1, 2, 3)   #=> ["a", "b", 99, "c", 1, 2, 3, "d"]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.insert(index, obj...)  -> array
 *  
 *  Inserts the given values before the element with the given index
 *  (which may be negative).
 *     
 *     a = %w{ a b c d }
 *     a.insert(2, 99)         #=> ["a", "b", 99, "c", "d"]
 *     a.insert(-2, 1, 2, 3)   #=> ["a", "b", 99, "c", 1, 2, 3, "d"]
 */

static VALUE
rb_ary_insert(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    long pos;

    if (argc == 1) return ary;
    if (argc < 1) {
    rb_raise(rb_eArgError, "wrong number of arguments (at least 1)");
    }
    pos = NUM2LONG(argv[0]);
    if (pos == -1) {
    pos = RARRAY(ary)->len;
    }
    if (pos < 0) {
    pos++;
    }
    rb_ary_splice(ary, pos, 0, rb_ary_new4(argc - 1, argv + 1));
    return ary;
}

#inspect ⇒ String

Create a printable version of array.

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.inspect  -> string
 *
 *  Create a printable version of <i>array</i>.
 */

static VALUE
rb_ary_inspect(ary)
    VALUE ary;
{
    if (RARRAY(ary)->len == 0) return rb_str_new2("[]");
    if (rb_inspecting_p(ary)) return rb_str_new2("[...]");
    return rb_protect_inspect(inspect_ary, ary, 0);
}

#join(sep = $,) ⇒ String

Returns a string created by converting each element of the array to a string, separated by sep.

[ "a", "b", "c" ].join        #=> "abc"
[ "a", "b", "c" ].join("-")   #=> "a-b-c"

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.join(sep=$,)    -> str
 *  
 *  Returns a string created by converting each element of the array to
 *  a string, separated by <i>sep</i>.
 *     
 *     [ "a", "b", "c" ].join        #=> "abc"
 *     [ "a", "b", "c" ].join("-")   #=> "a-b-c"
 */

static VALUE
rb_ary_join_m(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE sep;

    rb_scan_args(argc, argv, "01", &sep);
    if (NIL_P(sep)) sep = rb_output_fs;
    
    return rb_ary_join(ary, sep);
}

#last ⇒ Object? #last(n) ⇒ Array

Returns the last element(s) of self. If the array is empty, the first form returns nil.

[ "w", "x", "y", "z" ].last   #=> "z"

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.last     ->  obj or nil
 *     array.last(n)  ->  an_array
 *  
 *  Returns the last element(s) of <i>self</i>. If the array is empty,
 *  the first form returns <code>nil</code>.
 *     
 *     [ "w", "x", "y", "z" ].last   #=> "z"
 */

static VALUE
rb_ary_last(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    if (argc == 0) {
    if (RARRAY(ary)->len == 0) return Qnil;
    return RARRAY(ary)->ptr[RARRAY(ary)->len-1];
    }
    else {
    return ary_shared_first(argc, argv, ary, Qtrue);
    }
}

#length ⇒ Integer

Returns the number of elements in self. May be zero.

[ 1, 2, 3, 4, 5 ].length   #=> 5

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.length -> int
 *  
 *  Returns the number of elements in <i>self</i>. May be zero.
 *     
 *     [ 1, 2, 3, 4, 5 ].length   #=> 5
 */

static VALUE
rb_ary_length(ary)
    VALUE ary;
{
    return LONG2NUM(RARRAY(ary)->len);
}

#collect {|item| ... } ⇒ Array #map {|item| ... } ⇒ Array

Invokes block once for each element of self. Creates a new array containing the values returned by the block. See also Enumerable#collect.

a = [ "a", "b", "c", "d" ]
a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]
a                          #=> ["a", "b", "c", "d"]

Overloads:

  • #collect {|item| ... } ⇒ Array

    Yields:

    • (item)

    Returns:

  • #map {|item| ... } ⇒ Array

    Yields:

    • (item)

    Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.collect {|item| block }  -> an_array
 *     array.map     {|item| block }  -> an_array
 *  
 *  Invokes <i>block</i> once for each element of <i>self</i>. Creates a 
 *  new array containing the values returned by the block.
 *  See also <code>Enumerable#collect</code>.
 *     
 *     a = [ "a", "b", "c", "d" ]
 *     a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]
 *     a                          #=> ["a", "b", "c", "d"]
 */

static VALUE
rb_ary_collect(ary)
    VALUE ary;
{
    long i;
    VALUE collect;

    if (!rb_block_given_p()) {
    return rb_ary_new4(RARRAY(ary)->len, RARRAY(ary)->ptr);
    }

    collect = rb_ary_new2(RARRAY(ary)->len);
    for (i = 0; i < RARRAY(ary)->len; i++) {
    rb_ary_push(collect, rb_yield(RARRAY(ary)->ptr[i]));
    }
    return collect;
}

#collect! {|item| ... } ⇒ Array #map! {|item| ... } ⇒ Array

Invokes the block once for each element of self, replacing the element with the value returned by block. See also Enumerable#collect.

a = [ "a", "b", "c", "d" ]
a.collect! {|x| x + "!" }
a             #=>  [ "a!", "b!", "c!", "d!" ]

Overloads:

  • #collect! {|item| ... } ⇒ Array

    Yields:

    • (item)

    Returns:

  • #map! {|item| ... } ⇒ Array

    Yields:

    • (item)

    Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.collect! {|item| block }   ->   array
 *     array.map!     {|item| block }   ->   array
 *
 *  Invokes the block once for each element of _self_, replacing the
 *  element with the value returned by _block_.
 *  See also <code>Enumerable#collect</code>.
 *   
 *     a = [ "a", "b", "c", "d" ]
 *     a.collect! {|x| x + "!" }
 *     a             #=>  [ "a!", "b!", "c!", "d!" ]
 */

static VALUE
rb_ary_collect_bang(ary)
    VALUE ary;
{
    long i;

    RETURN_ENUMERATOR(ary, 0, 0);
    rb_ary_modify(ary);
    for (i = 0; i < RARRAY(ary)->len; i++) {
    rb_ary_store(ary, i, rb_yield(RARRAY(ary)->ptr[i]));
    }
    return ary;
}

#nitems ⇒ Integer

Returns the number of non-nil elements in self.

May be zero.

[ 1, nil, 3, nil, 5 ].nitems   #=> 3

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.nitems -> int
 *  
 *  Returns the number of non-<code>nil</code> elements in _self_.
 *
 *  May be zero.
 *     
 *     [ 1, nil, 3, nil, 5 ].nitems   #=> 3
 */

static VALUE
rb_ary_nitems(ary)
    VALUE ary;
{
    long n = 0;
    VALUE *p, *pend;

    for (p = RARRAY(ary)->ptr, pend = p + RARRAY(ary)->len; p < pend; p++) {
    if (!NIL_P(*p)) n++;
    }
    return LONG2NUM(n);
}

#pack ⇒ Object

Packs the contents of arr into a binary sequence according to the directives in aTemplateString (see the table below) Directives "A," "a," and "Z" may be followed by a count, which gives the width of the resulting field. The remaining directives also may take a count, indicating the number of array elements to convert. If the count is an asterisk ("*"), all remaining array elements will be converted. Any of the directives "sSiIlL" may be followed by an underscore ("_") to use the underlying platform's native size for the specified type; otherwise, they use a platform-independent size. Spaces are ignored in the template string. See also String#unpack.

a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
a.pack("A3A3A3")   #=> "a  b  c  "
a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
n.pack("ccc")      #=> "ABC"

Directives for pack.

Integer   | Array   |
Directive | Element | Meaning
------------------------------------------------------------------------
   C      | Integer | 8-bit unsigned integer (unsigned char)
   S      | Integer | 16-bit unsigned integer, native endian (uint16_t)
   L      | Integer | 32-bit unsigned integer, native endian (uint32_t)
   Q      | Integer | 64-bit unsigned integer, native endian (uint64_t)
          |         |
   c      | Integer | 8-bit signed integer (char)
   s      | Integer | 16-bit signed integer, native endian (int16_t)
   l      | Integer | 32-bit signed integer, native endian (int32_t)
   q      | Integer | 64-bit signed integer, native endian (int64_t)
          |         |
   S_     | Integer | unsigned short, native endian
   I, I_  | Integer | unsigned int, native endian
   L_     | Integer | unsigned long, native endian
          |         |
   s_     | Integer | signed short, native endian
   i, i_  | Integer | signed int, native endian
   l_     | Integer | signed long, native endian
          |         |
   n      | Integer | 16-bit unsigned integer, network (big-endian) byte order
   N      | Integer | 32-bit unsigned integer, network (big-endian) byte order
   v      | Integer | 16-bit unsigned integer, VAX (little-endian) byte order
   V      | Integer | 32-bit unsigned integer, VAX (little-endian) byte order
          |         |
   U      | Integer | UTF-8 character
   w      | Integer | BER-compressed integer

Float     |         |
Directive |         | Meaning
------------------------------------------------------------------------
   D, d   | Float   | double-precision float, native format
   F, f   | Float   | single-precision float, native format
   E      | Float   | double-precision float, little-endian byte order
   e      | Float   | single-precision float, little-endian byte order
   G      | Float   | double-precision float, network (big-endian) byte order
   g      | Float   | single-precision float, network (big-endian) byte order

String    |         |
Directive |         | Meaning
------------------------------------------------------------------------
   A      | String  | arbitrary binary string (space padded, count is width)
   a      | String  | arbitrary binary string (null padded, count is width)
   Z      | String  | same as ``a'', except that null is added with *
   B      | String  | bit string (MSB first)
   b      | String  | bit string (LSB first)
   H      | String  | hex string (high nibble first)
   h      | String  | hex string (low nibble first)
   u      | String  | UU-encoded string
   M      | String  | quoted printable, MIME encoding (see RFC2045)
   m      | String  | base64 encoded string (see RFC 2045, count is width)
   P      | String  | pointer to a structure (fixed-length string)
   p      | String  | pointer to a null-terminated string

Misc.     |         |
Directive |         | Meaning
------------------------------------------------------------------------
   @      | ---     | moves to absolute position
   X      | ---     | back up a byte
   x      | ---     | null byte




# File 'pack.c'

/*
 *  call-seq:
 *     arr.pack ( aTemplateString ) -> aBinaryString
 *  
 *  Packs the contents of <i>arr</i> into a binary sequence according to
 *  the directives in <i>aTemplateString</i> (see the table below)
 *  Directives ``A,'' ``a,'' and ``Z'' may be followed by a count,
 *  which gives the width of the resulting field. The remaining
 *  directives also may take a count, indicating the number of array
 *  elements to convert. If the count is an asterisk
 *  (``<code>*</code>''), all remaining array elements will be
 *  converted. Any of the directives ``<code>sSiIlL</code>'' may be
 *  followed by an underscore (``<code>_</code>'') to use the underlying
 *  platform's native size for the specified type; otherwise, they use a
 *  platform-independent size. Spaces are ignored in the template
 *  string. See also <code>String#unpack</code>.
 *     
 *     a = [ "a", "b", "c" ]
 *     n = [ 65, 66, 67 ]
 *     a.pack("A3A3A3")   #=> "a  b  c  "
 *     a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
 *     n.pack("ccc")      #=> "ABC"
 *     
 *  Directives for +pack+.
 *
 *   Integer   | Array   |
 *   Directive | Element | Meaning
 *   ------------------------------------------------------------------------
 *      C      | Integer | 8-bit unsigned integer (unsigned char)
 *      S      | Integer | 16-bit unsigned integer, native endian (uint16_t)
 *      L      | Integer | 32-bit unsigned integer, native endian (uint32_t)
 *      Q      | Integer | 64-bit unsigned integer, native endian (uint64_t)
 *             |         |
 *      c      | Integer | 8-bit signed integer (char)
 *      s      | Integer | 16-bit signed integer, native endian (int16_t)
 *      l      | Integer | 32-bit signed integer, native endian (int32_t)
 *      q      | Integer | 64-bit signed integer, native endian (int64_t)
 *             |         | 
 *      S_     | Integer | unsigned short, native endian
 *      I, I_  | Integer | unsigned int, native endian
 *      L_     | Integer | unsigned long, native endian
 *             |         |
 *      s_     | Integer | signed short, native endian
 *      i, i_  | Integer | signed int, native endian
 *      l_     | Integer | signed long, native endian
 *             |         |
 *      n      | Integer | 16-bit unsigned integer, network (big-endian) byte order
 *      N      | Integer | 32-bit unsigned integer, network (big-endian) byte order
 *      v      | Integer | 16-bit unsigned integer, VAX (little-endian) byte order
 *      V      | Integer | 32-bit unsigned integer, VAX (little-endian) byte order
 *             |         |
 *      U      | Integer | UTF-8 character
 *      w      | Integer | BER-compressed integer
 *                        
 *   Float     |         |
 *   Directive |         | Meaning
 *   ------------------------------------------------------------------------
 *      D, d   | Float   | double-precision float, native format
 *      F, f   | Float   | single-precision float, native format
 *      E      | Float   | double-precision float, little-endian byte order
 *      e      | Float   | single-precision float, little-endian byte order
 *      G      | Float   | double-precision float, network (big-endian) byte order
 *      g      | Float   | single-precision float, network (big-endian) byte order
 *                        
 *   String    |         |
 *   Directive |         | Meaning
 *   ------------------------------------------------------------------------
 *      A      | String  | arbitrary binary string (space padded, count is width)
 *      a      | String  | arbitrary binary string (null padded, count is width)
 *      Z      | String  | same as ``a'', except that null is added with *
 *      B      | String  | bit string (MSB first)
 *      b      | String  | bit string (LSB first)
 *      H      | String  | hex string (high nibble first)
 *      h      | String  | hex string (low nibble first)
 *      u      | String  | UU-encoded string
 *      M      | String  | quoted printable, MIME encoding (see RFC2045)
 *      m      | String  | base64 encoded string (see RFC 2045, count is width)
 *      P      | String  | pointer to a structure (fixed-length string)
 *      p      | String  | pointer to a null-terminated string
 *                        
 *   Misc.     |         |
 *   Directive |         | Meaning
 *   ------------------------------------------------------------------------
 *      @      | ---     | moves to absolute position
 *      X      | ---     | back up a byte
 *      x      | ---     | null byte
 */

static VALUE
pack_pack(ary, fmt)
    VALUE ary, fmt;
{
    static const char nul10[] = "\0\0\0\0\0\0\0\0\0\0";
    static const char spc10[] = "          ";
    char *p, *pend;
    VALUE res, from, associates = 0;
    char type;
    long items, len, idx, plen;
    const char *ptr;
#ifdef NATINT_PACK
    int natint;     /* native integer */
#endif
    int signed_p, integer_size, bigendian_p;

    StringValue(fmt);
    p = RSTRING(fmt)->ptr;
    pend = p + RSTRING(fmt)->len;
    res = rb_str_buf_new(0);

    items = RARRAY(ary)->len;
    idx = 0;

#define TOO_FEW (rb_raise(rb_eArgError, toofew), 0)
#define THISFROM (items > 0 ? RARRAY(ary)->ptr[idx] : TOO_FEW)
#define NEXTFROM (items-- > 0 ? RARRAY(ary)->ptr[idx++] : TOO_FEW)

    while (p < pend) {
    if (RSTRING(fmt)->ptr + RSTRING(fmt)->len != pend) {
        rb_raise(rb_eRuntimeError, "format string modified");
    }
    type = *p++;       /* get data type */
#ifdef NATINT_PACK
    natint = 0;
#endif

    if (ISSPACE(type)) continue;
    if (type == '#') {
        while ((p < pend) && (*p != '\n')) {
        p++;
        }
        continue;
    }
        if (*p == '_' || *p == '!') {
        const char *natstr = "sSiIlL";

        if (strchr(natstr, type)) {
#ifdef NATINT_PACK
        natint = 1;
#endif
        p++;
        }
        else {
        rb_raise(rb_eArgError, "'%c' allowed only after types %s", *p, natstr);
        }
    }
    if (*p == '*') {   /* set data length */
        len = strchr("@Xxu", type) ? 0
                : strchr("PMm", type) ? 1
                : items;
        p++;
    }
    else if (ISDIGIT(*p)) {
        len = strtoul(p, (char**)&p, 10);
    }
    else {
        len = 1;
    }

    switch (type) {
      case 'A': case 'a': case 'Z':
      case 'B': case 'b':
      case 'H': case 'h':
        from = NEXTFROM;
        if (NIL_P(from)) {
        ptr = "";
        plen = 0;
        }
        else {
        StringValue(from);
        ptr = RSTRING(from)->ptr;
        plen = RSTRING(from)->len;
        OBJ_INFECT(res, from);
        }

        if (p[-1] == '*')
        len = plen;

        switch (type) {
          case 'a':        /* arbitrary binary string (null padded)  */
          case 'A':        /* ASCII string (space padded) */
          case 'Z':        /* null terminated ASCII string  */
        if (plen >= len) {
            rb_str_buf_cat(res, ptr, len);
            if (p[-1] == '*' && type == 'Z')
            rb_str_buf_cat(res, nul10, 1);
        }
        else {
            rb_str_buf_cat(res, ptr, plen);
            len -= plen;
            while (len >= 10) {
            rb_str_buf_cat(res, (type == 'A')?spc10:nul10, 10);
            len -= 10;
            }
            rb_str_buf_cat(res, (type == 'A')?spc10:nul10, len);
        }
        break;

          case 'b':        /* bit string (ascending) */
        {
            int byte = 0;
            long i, j = 0;

            if (len > plen) {
            j = (len - plen + 1)/2;
            len = plen;
            }
            for (i=0; i++ < len; ptr++) {
            if (*ptr & 1)
                byte |= 128;
            if (i & 7)
                byte >>= 1;
            else {
                char c = byte & 0xff;
                rb_str_buf_cat(res, &c, 1);
                byte = 0;
            }
            }
            if (len & 7) {
            char c;
            byte >>= 7 - (len & 7);
            c = byte & 0xff;
            rb_str_buf_cat(res, &c, 1);
            }
            len = j;
            goto grow;
        }
        break;

          case 'B':        /* bit string (descending) */
        {
            int byte = 0;
            long i, j = 0;

            if (len > plen) {
            j = (len - plen + 1)/2;
            len = plen;
            }
            for (i=0; i++ < len; ptr++) {
            byte |= *ptr & 1;
            if (i & 7)
                byte <<= 1;
            else {
                char c = byte & 0xff;
                rb_str_buf_cat(res, &c, 1);
                byte = 0;
            }
            }
            if (len & 7) {
            char c;
            byte <<= 7 - (len & 7);
            c = byte & 0xff;
            rb_str_buf_cat(res, &c, 1);
            }
            len = j;
            goto grow;
        }
        break;

          case 'h':        /* hex string (low nibble first) */
        {
            int byte = 0;
            long i, j = 0;

            if (len > plen) {
            j = (len + 1) / 2 - (plen + 1) / 2;
            len = plen;
            }
            for (i=0; i++ < len; ptr++) {
            if (ISALPHA(*ptr))
                byte |= (((*ptr & 15) + 9) & 15) << 4;
            else
                byte |= (*ptr & 15) << 4;
            if (i & 1)
                byte >>= 4;
            else {
                char c = byte & 0xff;
                rb_str_buf_cat(res, &c, 1);
                byte = 0;
            }
            }
            if (len & 1) {
            char c = byte & 0xff;
            rb_str_buf_cat(res, &c, 1);
            }
            len = j;
            goto grow;
        }
        break;

          case 'H':        /* hex string (high nibble first) */
        {
            int byte = 0;
            long i, j = 0;

            if (len > plen) {
            j = (len + 1) / 2 - (plen + 1) / 2;
            len = plen;
            }
            for (i=0; i++ < len; ptr++) {
            if (ISALPHA(*ptr))
                byte |= ((*ptr & 15) + 9) & 15;
            else
                byte |= *ptr & 15;
            if (i & 1)
                byte <<= 4;
            else {
                char c = byte & 0xff;
                rb_str_buf_cat(res, &c, 1);
                byte = 0;
            }
            }
            if (len & 1) {
            char c = byte & 0xff;
            rb_str_buf_cat(res, &c, 1);
            }
            len = j;
            goto grow;
        }
        break;
        }
        break;

      case 'c':        /* signed char */
      case 'C':        /* unsigned char */
        while (len-- > 0) {
        char c;

        from = NEXTFROM;
        c = num2i32(from);
        rb_str_buf_cat(res, &c, sizeof(char));
        }
        break;

      case 's':        /* signed short */
            signed_p = 1;
            integer_size = NATINT_LEN(short, 2);
            bigendian_p = BIGENDIAN_P();
            goto pack_integer;

      case 'S':        /* unsigned short */
            signed_p = 0;
            integer_size = NATINT_LEN(short, 2);
            bigendian_p = BIGENDIAN_P();
            goto pack_integer;

      case 'i':        /* signed int */
            signed_p = 1;
            integer_size = (int)sizeof(int);
            bigendian_p = BIGENDIAN_P();
            goto pack_integer;

      case 'I':        /* unsigned int */
            signed_p = 0;
            integer_size = (int)sizeof(int);
            bigendian_p = BIGENDIAN_P();
            goto pack_integer;

      case 'l':        /* signed long */
            signed_p = 1;
            integer_size = NATINT_LEN(long, 4);
            bigendian_p = BIGENDIAN_P();
            goto pack_integer;

      case 'L':        /* unsigned long */
            signed_p = 0;
            integer_size = NATINT_LEN(long, 4);
            bigendian_p = BIGENDIAN_P();
            goto pack_integer;

      case 'q':        /* signed quad (64bit) int */
            signed_p = 1;
            integer_size = 8;
            bigendian_p = BIGENDIAN_P();
            goto pack_integer;

      case 'Q':        /* unsigned quad (64bit) int */
            signed_p = 0;
            integer_size = 8;
            bigendian_p = BIGENDIAN_P();
            goto pack_integer;

      case 'n':        /* unsigned short (network byte-order)  */
            signed_p = 0;
            integer_size = 2;
            bigendian_p = 1;
            goto pack_integer;

      case 'N':        /* unsigned long (network byte-order) */
            signed_p = 0;
            integer_size = 4;
            bigendian_p = 1;
            goto pack_integer;

      case 'v':        /* unsigned short (VAX byte-order) */
            signed_p = 0;
            integer_size = 2;
            bigendian_p = 0;
            goto pack_integer;

      case 'V':        /* unsigned long (VAX byte-order) */
            signed_p = 0;
            integer_size = 4;
            bigendian_p = 0;
            goto pack_integer;

          pack_integer:
            switch (integer_size) {
#if defined(HAVE_INT16_T) && !defined(FORCE_BIG_PACK)
              case SIZEOF_INT16_T:
                while (len-- > 0) {
                    union {
                        int16_t i;
                        char a[sizeof(int16_t)];
                    } v;

                    from = NEXTFROM;
                    v.i = (int16_t)num2i32(from);
                    if (bigendian_p != BIGENDIAN_P()) v.i = swap16(v.i);
                    rb_str_buf_cat(res, v.a, sizeof(int16_t));
                }
                break;
#endif

#if defined(HAVE_INT32_T) && !defined(FORCE_BIG_PACK)
              case SIZEOF_INT32_T:
                while (len-- > 0) {
                    union {
                        int32_t i;
                        char a[sizeof(int32_t)];
                    } v;

                    from = NEXTFROM;
                    v.i = (int32_t)num2i32(from);
                    if (bigendian_p != BIGENDIAN_P()) v.i = swap32(v.i);
                    rb_str_buf_cat(res, v.a, sizeof(int32_t));
                }
                break;
#endif

#if defined(HAVE_INT64_T) && SIZEOF_LONG == SIZEOF_INT64_T && !defined(FORCE_BIG_PACK)
              case SIZEOF_INT64_T:
                while (len-- > 0) {
                    union {
                        int64_t i;
                        char a[sizeof(int64_t)];
                    } v;

                    from = NEXTFROM;
                    v.i = num2i32(from); /* can return 64bit value if SIZEOF_LONG == SIZEOF_INT64_T */
                    if (bigendian_p != BIGENDIAN_P()) v.i = swap64(v.i);
                    rb_str_buf_cat(res, v.a, sizeof(int64_t));
                }
                break;
#endif

              default:
                if (integer_size > MAX_INTEGER_PACK_SIZE)
                    rb_bug("unexpected intger size for pack: %d", integer_size);
                while (len-- > 0) {
                    union {
                        unsigned long i[(MAX_INTEGER_PACK_SIZE+SIZEOF_LONG-1)/SIZEOF_LONG];
                        char a[(MAX_INTEGER_PACK_SIZE+SIZEOF_LONG-1)/SIZEOF_LONG*SIZEOF_LONG];
                    } v;
                    int num_longs = (integer_size+SIZEOF_LONG-1)/SIZEOF_LONG;
                    int i;

                    from = NEXTFROM;
                    from = rb_to_int(from);
                    if (integer_size == QUAD_SIZE)
                        rb_quad_pack(v.a, from); /* RangeError compatibility for Ruby 1.8. */
                    rb_big_pack(from, v.i, num_longs);
                    if (bigendian_p) {
                        for (i = 0; i < num_longs/2; i++) {
                            unsigned long t = v.i[i];
                            v.i[i] = v.i[num_longs-1-i];
                            v.i[num_longs-1-i] = t;
                        }
                    }
                    if (bigendian_p != BIGENDIAN_P()) {
                        for (i = 0; i < num_longs; i++)
                            v.i[i] = swapl(v.i[i]);
                    }
                    rb_str_buf_cat(res,
                                   bigendian_p ?
                                     v.a + sizeof(long)*num_longs - integer_size :
                                     v.a,
                                   integer_size);
                }
                break;
            }
            break;

      case 'f':        /* single precision float in native format */
      case 'F':        /* ditto */
        while (len-- > 0) {
        float f;

        from = NEXTFROM;
        f = RFLOAT(rb_Float(from))->value;
        rb_str_buf_cat(res, (char*)&f, sizeof(float));
        }
        break;

      case 'e':        /* single precision float in VAX byte-order */
        while (len-- > 0) {
        float f;
        FLOAT_CONVWITH(ftmp);

        from = NEXTFROM;
        f = RFLOAT(rb_Float(from))->value;
        f = HTOVF(f,ftmp);
        rb_str_buf_cat(res, (char*)&f, sizeof(float));
        }
        break;

      case 'E':        /* double precision float in VAX byte-order */
        while (len-- > 0) {
        double d;
        DOUBLE_CONVWITH(dtmp);

        from = NEXTFROM;
        d = RFLOAT(rb_Float(from))->value;
        d = HTOVD(d,dtmp);
        rb_str_buf_cat(res, (char*)&d, sizeof(double));
        }
        break;

      case 'd':        /* double precision float in native format */
      case 'D':        /* ditto */
        while (len-- > 0) {
        double d;

        from = NEXTFROM;
        d = RFLOAT(rb_Float(from))->value;
        rb_str_buf_cat(res, (char*)&d, sizeof(double));
        }
        break;

      case 'g':        /* single precision float in network byte-order */
        while (len-- > 0) {
        float f;
        FLOAT_CONVWITH(ftmp);

        from = NEXTFROM;
        f = RFLOAT(rb_Float(from))->value;
        f = HTONF(f,ftmp);
        rb_str_buf_cat(res, (char*)&f, sizeof(float));
        }
        break;

      case 'G':        /* double precision float in network byte-order */
        while (len-- > 0) {
        double d;
        DOUBLE_CONVWITH(dtmp);

        from = NEXTFROM;
        d = RFLOAT(rb_Float(from))->value;
        d = HTOND(d,dtmp);
        rb_str_buf_cat(res, (char*)&d, sizeof(double));
        }
        break;

      case 'x':        /* null byte */
      grow:
        while (len >= 10) {
        rb_str_buf_cat(res, nul10, 10);
        len -= 10;
        }
        rb_str_buf_cat(res, nul10, len);
        break;

      case 'X':        /* back up byte */
      shrink:
        plen = RSTRING(res)->len;
        if (plen < len)
        rb_raise(rb_eArgError, "X outside of string");
        RSTRING(res)->len = plen - len;
        RSTRING(res)->ptr[plen - len] = '\0';
        break;

      case '@':        /* null fill to absolute position */
        len -= RSTRING(res)->len;
        if (len > 0) goto grow;
        len = -len;
        if (len > 0) goto shrink;
        break;

      case '%':
        rb_raise(rb_eArgError, "%% is not supported");
        break;

      case 'U':        /* Unicode character */
        while (len-- > 0) {
        long l;
        char buf[8];
        int le;

        from = NEXTFROM;
        from = rb_to_int(from);
        l = NUM2INT(from);
        if (l < 0) {
            rb_raise(rb_eRangeError, "pack(U): value out of range");
        }
        le = uv_to_utf8(buf, l);
        rb_str_buf_cat(res, (char*)buf, le);
        }
        break;

      case 'u':        /* uuencoded string */
      case 'm':        /* base64 encoded string */
        from = NEXTFROM;
        StringValue(from);
        ptr = RSTRING(from)->ptr;
        plen = RSTRING(from)->len;

        if (len <= 2)
        len = 45;
        else
        len = len / 3 * 3;
        while (plen > 0) {
        long todo;

        if (plen > len)
            todo = len;
        else
            todo = plen;
        encodes(res, ptr, todo, type);
        plen -= todo;
        ptr += todo;
        }
        break;

      case 'M':        /* quoted-printable encoded string */
        from = rb_obj_as_string(NEXTFROM);
        if (len <= 1)
        len = 72;
        qpencode(res, from, len);
        break;

      case 'P':        /* pointer to packed byte string */
        from = THISFROM;
        if (!NIL_P(from)) {
        StringValue(from);
        if (RSTRING(from)->len < len) {
            rb_raise(rb_eArgError, "too short buffer for P(%ld for %ld)",
                 RSTRING(from)->len, len);
        }
        }
        len = 1;
        /* FALL THROUGH */
      case 'p':        /* pointer to string */
        while (len-- > 0) {
        char *t;
        from = NEXTFROM;
        if (NIL_P(from)) {
            t = 0;
        }
        else {
            t = StringValuePtr(from);
        }
        if (!associates) {
            associates = rb_ary_new();
        }
        rb_ary_push(associates, from);
        rb_obj_taint(from);
        rb_str_buf_cat(res, (char*)&t, sizeof(char*));
        }
        break;

      case 'w':        /* BER compressed integer  */
        while (len-- > 0) {
        unsigned long ul;
        VALUE buf = rb_str_new(0, 0);
        char c, *bufs, *bufe;

        from = NEXTFROM;
        if (TYPE(from) == T_BIGNUM) {
            VALUE big128 = rb_uint2big(128);
            while (TYPE(from) == T_BIGNUM) {
            from = rb_big_divmod(from, big128);
            c = NUM2INT(RARRAY(from)->ptr[1]) | 0x80; /* mod */
            rb_str_buf_cat(buf, &c, sizeof(char));
            from = RARRAY(from)->ptr[0]; /* div */
            }
        }

        {
            long l = NUM2LONG(from);
            if (l < 0) {
            rb_raise(rb_eArgError, "can't compress negative numbers");
            }
            ul = l;
        }

        while (ul) {
            c = ((ul & 0x7f) | 0x80);
            rb_str_buf_cat(buf, &c, sizeof(char));
            ul >>=  7;
        }

        if (RSTRING(buf)->len) {
            bufs = RSTRING(buf)->ptr;
            bufe = bufs + RSTRING(buf)->len - 1;
            *bufs &= 0x7f; /* clear continue bit */
            while (bufs < bufe) { /* reverse */
            c = *bufs;
            *bufs++ = *bufe;
            *bufe-- = c;
            }
            rb_str_buf_cat(res, RSTRING(buf)->ptr, RSTRING(buf)->len);
        }
        else {
            c = 0;
            rb_str_buf_cat(res, &c, sizeof(char));
        }
        }
        break;

      default:
        break;
    }
    }

    if (associates) {
    rb_str_associate(res, associates);
    }
    OBJ_INFECT(res, fmt);
    return res;
}

#permutation {|p| ... } ⇒ Array #permutation ⇒ Object #permutation(n) {|p| ... } ⇒ Array #permutation(n) ⇒ Object

When invoked with a block, yield all permutations of length n of the elements of ary, then return the array itself. If n is not specified, yield all permutations of all elements. The implementation makes no guarantees about the order in which the permutations are yielded.

When invoked without a block, return an enumerator object instead.

Examples:

a = [1, 2, 3]
a.permutation.to_a     #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
a.permutation(1).to_a  #=> [[1],[2],[3]]
a.permutation(2).to_a  #=> [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]]
a.permutation(3).to_a  #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
a.permutation(0).to_a  #=> [[]] # one permutation of length 0
a.permutation(4).to_a  #=> []   # no permutations of length 4

Overloads:

  • #permutation {|p| ... } ⇒ Array

    Yields:

    • (p)

    Returns:

  • #permutation(n) {|p| ... } ⇒ Array

    Yields:

    • (p)

    Returns:




# File 'array.c'

/*
 *  call-seq:
 *     ary.permutation { |p| block }          -> array
 *     ary.permutation                        -> enumerator
 *     ary.permutation(n) { |p| block }       -> array
 *     ary.permutation(n)                     -> enumerator
 *  
 * When invoked with a block, yield all permutations of length <i>n</i>
 * of the elements of <i>ary</i>, then return the array itself.
 * If <i>n</i> is not specified, yield all permutations of all elements.
 * The implementation makes no guarantees about the order in which 
 * the permutations are yielded.
 *
 * When invoked without a block, return an enumerator object instead.
 * 
 * Examples:
 *
 *     a = [1, 2, 3]
 *     a.permutation.to_a     #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
 *     a.permutation(1).to_a  #=> [[1],[2],[3]]
 *     a.permutation(2).to_a  #=> [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]]
 *     a.permutation(3).to_a  #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
 *     a.permutation(0).to_a  #=> [[]] # one permutation of length 0
 *     a.permutation(4).to_a  #=> []   # no permutations of length 4
 */

static VALUE
rb_ary_permutation(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE num;
    long r, n, i;

    n = RARRAY(ary)->len;                  /* Array length */
    RETURN_ENUMERATOR(ary, argc, argv);   /* Return enumerator if no block */
    rb_scan_args(argc, argv, "01", &num);
    r = NIL_P(num) ? n : NUM2LONG(num);   /* Permutation size from argument */

    if (r < 0 || n < r) { 
    /* no permutations: yield nothing */
    }
    else if (r == 0) { /* exactly one permutation: the zero-length array */
    rb_yield(rb_ary_new2(0));
    }
    else if (r == 1) { /* this is a special, easy case */
    for (i = 0; i < RARRAY(ary)->len; i++) {
        rb_yield(rb_ary_new3(1, RARRAY(ary)->ptr[i]));
    }
    }
    else {             /* this is the general case */
    volatile VALUE t0 = tmpbuf(n,sizeof(long));
    long *p = (long*)RSTRING(t0)->ptr;
    volatile VALUE t1 = tmpbuf(n,sizeof(int));
    int *used = (int*)RSTRING(t1)->ptr;
    VALUE ary0 = ary_make_shared(ary); /* private defensive copy of ary */

    for (i = 0; i < n; i++) used[i] = 0; /* initialize array */

    permute0(n, r, p, 0, used, ary0); /* compute and yield permutations */
    RB_GC_GUARD(t0);
    RB_GC_GUARD(t1);
    }
    return ary;
}

#pop ⇒ Object? #pop(n) ⇒ Array

Removes the last element from self and returns it, or nil if the array is empty.

If a number n is given, returns an array of the last n elements (or less) just like array.slice!(-n, n) does.

a = [ "a", "b", "c", "d" ]
a.pop     #=> "d"
a.pop(2)  #=> ["b", "c"]
a         #=> ["a"]

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.pop    -> obj or nil
 *     array.pop(n) -> array
 *  
 *  Removes the last element from <i>self</i> and returns it, or
 *  <code>nil</code> if the array is empty.
 *
 *  If a number _n_ is given, returns an array of the last n elements
 *  (or less) just like <code>array.slice!(-n, n)</code> does.
 *     
 *     a = [ "a", "b", "c", "d" ]
 *     a.pop     #=> "d"
 *     a.pop(2)  #=> ["b", "c"]
 *     a         #=> ["a"]
 */

static VALUE
rb_ary_pop_m(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE result;

    if (argc == 0) {
    return rb_ary_pop(ary);
    }

    rb_ary_modify_check(ary);
    result = ary_shared_first(argc, argv, ary, Qtrue);
    RARRAY(ary)->len -= RARRAY(result)->len;
    return result;
}

#product(other_ary, ...) ⇒ Object

Returns an array of all combinations of elements from all arrays. The length of the returned array is the product of the length of ary and the argument arrays

[1,2,3].product([4,5])     # => [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]
[1,2].product([1,2])       # => [[1,1],[1,2],[2,1],[2,2]]
[1,2].product([3,4],[5,6]) # => [[1,3,5],[1,3,6],[1,4,5],[1,4,6],
                           #     [2,3,5],[2,3,6],[2,4,5],[2,4,6]]
[1,2].product()            # => [[1],[2]]
[1,2].product([])          # => []




# File 'array.c'

/*
 *  call-seq:
 *     ary.product(other_ary, ...)
 *  
 *  Returns an array of all combinations of elements from all arrays.
 *  The length of the returned array is the product of the length
 *  of ary and the argument arrays
 *     
 *     [1,2,3].product([4,5])     # => [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]
 *     [1,2].product([1,2])       # => [[1,1],[1,2],[2,1],[2,2]]
 *     [1,2].product([3,4],[5,6]) # => [[1,3,5],[1,3,6],[1,4,5],[1,4,6],
 *                                #     [2,3,5],[2,3,6],[2,4,5],[2,4,6]]
 *     [1,2].product()            # => [[1],[2]]
 *     [1,2].product([])          # => []
 */

static VALUE
rb_ary_product(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    int n = argc+1;    /* How many arrays we're operating on */
    volatile VALUE t0 = tmpbuf(n, sizeof(VALUE));
    volatile VALUE t1 = tmpbuf(n, sizeof(int));
    VALUE *arrays = (VALUE*)RSTRING(t0)->ptr; /* The arrays we're computing the product of */
    int *counters = (int*)RSTRING(t1)->ptr; /* The current position in each one */
    VALUE result;      /* The array we'll be returning */
    long i,j;
    long resultlen = 1;

    RBASIC(t0)->klass = 0;
    RBASIC(t1)->klass = 0;

    /* initialize the arrays of arrays */
    arrays[0] = ary;
    for (i = 1; i < n; i++) arrays[i] = to_ary(argv[i-1]);
    
    /* initialize the counters for the arrays */
    for (i = 0; i < n; i++) counters[i] = 0;

    /* Compute the length of the result array; return [] if any is empty */
    for (i = 0; i < n; i++) {
    long k = RARRAY(arrays[i])->len, l = resultlen;
    if (k == 0) return rb_ary_new2(0);
    resultlen *= k;
    if (resultlen < k || resultlen < l || resultlen / k != l) {
        rb_raise(rb_eRangeError, "too big to product");
    }
    }

    /* Otherwise, allocate and fill in an array of results */
    result = rb_ary_new2(resultlen);
    for (i = 0; i < resultlen; i++) {
    int m;
    /* fill in one subarray */
    VALUE subarray = rb_ary_new2(n);
    for (j = 0; j < n; j++) {
        rb_ary_push(subarray, rb_ary_entry(arrays[j], counters[j]));
    }

    /* put it on the result array */
    rb_ary_push(result, subarray);

    /*
     * Increment the last counter.  If it overflows, reset to 0
     * and increment the one before it.
     */
    m = n-1;
    counters[m]++;
    while (m > 0 && counters[m] == RARRAY(arrays[m])->len) {
        counters[m] = 0;
        m--;
        counters[m]++;
    }
    }

    return result;
}

#push(obj, ...) ⇒ Array

Append---Pushes the given object(s) on to the end of this array. This expression returns the array itself, so several appends may be chained together.

a = [ "a", "b", "c" ]
a.push("d", "e", "f")
        #=> ["a", "b", "c", "d", "e", "f"]

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.push(obj, ... )   -> array
 *  
 *  Append---Pushes the given object(s) on to the end of this array. This
 *  expression returns the array itself, so several appends
 *  may be chained together.
 *
 *     a = [ "a", "b", "c" ]
 *     a.push("d", "e", "f")  
 *             #=> ["a", "b", "c", "d", "e", "f"]
 */

static VALUE
rb_ary_push_m(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    while (argc--) {
    rb_ary_push(ary, *argv++);
    }
    return ary;
}

#rassoc(key) ⇒ Array?

Searches through the array whose elements are also arrays. Compares key with the second element of each contained array using ==. Returns the first contained array that matches. See also Array#assoc.

a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
a.rassoc("two")    #=> [2, "two"]
a.rassoc("four")   #=> nil

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.rassoc(key) -> an_array or nil
 *  
 *  Searches through the array whose elements are also arrays. Compares
 *  <em>key</em> with the second element of each contained array using
 *  <code>==</code>. Returns the first contained array that matches. See
 *  also <code>Array#assoc</code>.
 *     
 *     a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
 *     a.rassoc("two")    #=> [2, "two"]
 *     a.rassoc("four")   #=> nil
 */

VALUE
rb_ary_rassoc(ary, value)
    VALUE ary, value;
{
    long i;
    VALUE v;

    for (i = 0; i < RARRAY(ary)->len; ++i) {
    v = RARRAY(ary)->ptr[i];
    if (TYPE(v) == T_ARRAY &&
        RARRAY(v)->len > 1 &&
        rb_equal(RARRAY(v)->ptr[1], value))
        return v;
    }
    return Qnil;
}

#reject {|item| ... } ⇒ Array

Returns a new array containing the items in self for which the block is not true.

Yields:

  • (item)

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.reject {|item| block }  -> an_array
 *  
 *  Returns a new array containing the items in _self_
 *  for which the block is not true.
 */

static VALUE
rb_ary_reject(ary)
    VALUE ary;
{
    RETURN_ENUMERATOR(ary, 0, 0);
    ary = rb_ary_dup(ary);
    rb_ary_reject_bang(ary);
    return ary;
}

#reject! {|item| ... } ⇒ Array?

Equivalent to Array#delete_if, deleting elements from self for which the block evaluates to true, but returns nil if no changes were made. Also see Enumerable#reject.

Yields:

  • (item)

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.reject! {|item| block }  -> array or nil
 *  
 *  Equivalent to <code>Array#delete_if</code>, deleting elements from
 *  _self_ for which the block evaluates to true, but returns
 *  <code>nil</code> if no changes were made. Also see
 *  <code>Enumerable#reject</code>.
 */

static VALUE
rb_ary_reject_bang(ary)
    VALUE ary;
{
    long i1, i2;

    RETURN_ENUMERATOR(ary, 0, 0);
    rb_ary_modify(ary);
    for (i1 = i2 = 0; i1 < RARRAY(ary)->len; i1++) {
    VALUE v = RARRAY(ary)->ptr[i1];
    if (RTEST(rb_yield(v))) continue;
    if (i1 != i2) {
        rb_ary_store(ary, i2, v);
    }
    i2++;
    }
    if (RARRAY(ary)->len == i2) return Qnil;
    if (i2 < RARRAY(ary)->len)
    RARRAY(ary)->len = i2;

    return ary;
}

#replace(other_array) ⇒ Array

Replaces the contents of self with the contents of other_array, truncating or expanding if necessary.

a = [ "a", "b", "c", "d", "e" ]
a.replace([ "x", "y", "z" ])   #=> ["x", "y", "z"]
a                              #=> ["x", "y", "z"]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.replace(other_array)  -> array
 *  
 *  Replaces the contents of <i>self</i> with the contents of
 *  <i>other_array</i>, truncating or expanding if necessary.
 *     
 *     a = [ "a", "b", "c", "d", "e" ]
 *     a.replace([ "x", "y", "z" ])   #=> ["x", "y", "z"]
 *     a                              #=> ["x", "y", "z"]
 */

static VALUE
rb_ary_replace(copy, orig)
    VALUE copy, orig;
{
    VALUE shared;

    rb_ary_modify(copy);
    orig = to_ary(orig);
    if (copy == orig) return copy;
    shared = ary_make_shared(orig);
    if (RARRAY(copy)->ptr && !FL_TEST(copy, ELTS_SHARED))
    free(RARRAY(copy)->ptr);
    RARRAY(copy)->ptr = RARRAY(orig)->ptr;
    RARRAY(copy)->len = RARRAY(orig)->len;
    RARRAY(copy)->aux.shared = shared;
    FL_SET(copy, ELTS_SHARED);

    return copy;
}

#reverse ⇒ Array

Returns a new array containing self's elements in reverse order.

[ "a", "b", "c" ].reverse   #=> ["c", "b", "a"]
[ 1 ].reverse               #=> [1]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.reverse -> an_array
 *  
 *  Returns a new array containing <i>self</i>'s elements in reverse order.
 *     
 *     [ "a", "b", "c" ].reverse   #=> ["c", "b", "a"]
 *     [ 1 ].reverse               #=> [1]
 */

static VALUE
rb_ary_reverse_m(ary)
    VALUE ary;
{
    return rb_ary_reverse(rb_ary_dup(ary));
}

#reverse! ⇒ Array

Reverses self in place.

a = [ "a", "b", "c" ]
a.reverse!       #=> ["c", "b", "a"]
a                #=> ["c", "b", "a"]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.reverse!   -> array 
 *  
 *  Reverses _self_ in place.
 *     
 *     a = [ "a", "b", "c" ]
 *     a.reverse!       #=> ["c", "b", "a"]
 *     a                #=> ["c", "b", "a"]
 */

static VALUE
rb_ary_reverse_bang(ary)
    VALUE ary;
{
    return rb_ary_reverse(ary);
}

#reverse_each {|item| ... } ⇒ Object

Same as Array#each, but traverses self in reverse order.

a = [ "a", "b", "c" ]
a.reverse_each {|x| print x, " " }

produces:

c b a

Yields:

  • (item) 



# File 'array.c'

/*
 *  call-seq:
 *     array.reverse_each {|item| block } 
 *  
 *  Same as <code>Array#each</code>, but traverses <i>self</i> in reverse
 *  order.
 *     
 *     a = [ "a", "b", "c" ]
 *     a.reverse_each {|x| print x, " " }
 *     
 *  produces:
 *     
 *     c b a
 */

static VALUE
rb_ary_reverse_each(ary)
    VALUE ary;
{
    long len;

    RETURN_ENUMERATOR(ary, 0, 0);
    len = RARRAY(ary)->len;
    while (len--) {
    rb_yield(RARRAY(ary)->ptr[len]);
    if (RARRAY(ary)->len < len) {
        len = RARRAY(ary)->len;
    }
    }
    return ary;
}

#rindex(obj) ⇒ Integer?

Returns the index of the last object in array == to obj. If a block is given instead of an argument, returns first object for which block is true. Returns nil if no match is found.

a = [ "a", "b", "b", "b", "c" ]
a.rindex("b")        #=> 3
a.rindex("z")        #=> nil
a.rindex{|x|x=="b"}  #=> 3

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.rindex(obj)    ->  int or nil
 *  
 *  Returns the index of the last object in <i>array</i>
 *  <code>==</code> to <i>obj</i>. If a block is given instead of an
 *  argument, returns first object for which <em>block</em> is
 *  true. Returns <code>nil</code> if no match is found.
 *     
 *     a = [ "a", "b", "b", "b", "c" ]
 *     a.rindex("b")        #=> 3
 *     a.rindex("z")        #=> nil
 *     a.rindex{|x|x=="b"}  #=> 3
 */

static VALUE
rb_ary_rindex(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE val;
    long i = RARRAY(ary)->len;

    if (argc == 0) {
    RETURN_ENUMERATOR(ary, 0, 0);
    while (i--) {
        if (RTEST(rb_yield(RARRAY(ary)->ptr[i])))
        return LONG2NUM(i);
        if (i > RARRAY(ary)->len) {
        i = RARRAY(ary)->len;
        }
    }
    return Qnil;
    }
    rb_scan_args(argc, argv, "01", &val);
    while (i--) {
    if (rb_equal(RARRAY(ary)->ptr[i], val))
        return LONG2NUM(i);
    if (i > RARRAY(ary)->len) {
        i = RARRAY(ary)->len;
    }
    }
    return Qnil;
}

#select {|item| ... } ⇒ Array

Invokes the block passing in successive elements from array, returning an array containing those elements for which the block returns a true value (equivalent to Enumerable#select).

a = %w{ a b c d e f }
a.select {|v| v =~ /[aeiou]/}   #=> ["a", "e"]

Yields:

  • (item)

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.select {|item| block } -> an_array
 *  
 *  Invokes the block passing in successive elements from <i>array</i>,
 *  returning an array containing those elements for which the block
 *  returns a true value (equivalent to <code>Enumerable#select</code>).
 *     
 *     a = %w{ a b c d e f }
 *     a.select {|v| v =~ /[aeiou]/}   #=> ["a", "e"]
 */

static VALUE
rb_ary_select(ary)
    VALUE ary;
{
    VALUE result;
    long i;

    RETURN_ENUMERATOR(ary, 0, 0);
    result = rb_ary_new2(RARRAY(ary)->len);
    for (i = 0; i < RARRAY(ary)->len; i++) {
    if (RTEST(rb_yield(RARRAY(ary)->ptr[i]))) {
        rb_ary_push(result, rb_ary_elt(ary, i));
    }
    }
    return result;
}

#shift ⇒ Object? #shift(n) ⇒ Array

Returns the first element of self and removes it (shifting all other elements down by one). Returns nil if the array is empty.

If a number n is given, returns an array of the first n elements (or less) just like array.slice!(0, n) does.

args = [ "-m", "-q", "filename" ]
args.shift     #=> "-m"
args           #=> ["-q", "filename"]

args = [ "-m", "-q", "filename" ]
args.shift(2)  #=> ["-m", "-q"]
args           #=> ["filename"]

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.shift    -> obj or nil
 *     array.shift(n) -> array
 *  
 *  Returns the first element of <i>self</i> and removes it (shifting all
 *  other elements down by one). Returns <code>nil</code> if the array
 *  is empty.
 *
 *  If a number _n_ is given, returns an array of the first n elements
 *  (or less) just like <code>array.slice!(0, n)</code> does.
 *     
 *     args = [ "-m", "-q", "filename" ]
 *     args.shift     #=> "-m"
 *     args           #=> ["-q", "filename"]
 *
 *     args = [ "-m", "-q", "filename" ]
 *     args.shift(2)  #=> ["-m", "-q"]
 *     args           #=> ["filename"]
 */

static VALUE
rb_ary_shift_m(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE result;
    long n;

    if (argc == 0) {
    return rb_ary_shift(ary);
    }

    rb_ary_modify_check(ary);
    result = ary_shared_first(argc, argv, ary, Qfalse);
    n = RARRAY(result)->len;
    if (FL_TEST(ary, ELTS_SHARED)) {
    RARRAY(ary)->ptr += n;
    RARRAY(ary)->len -= n;
    }
    else {
    MEMMOVE(RARRAY(ary)->ptr, RARRAY(ary)->ptr+n, VALUE, RARRAY(ary)->len-n);
    RARRAY(ary)->len -= n;
    }

    return result;
}

#shuffle ⇒ Array

Returns a new array with elements of this array shuffled.

a = [ 1, 2, 3 ]           #=> [1, 2, 3]
a.shuffle                 #=> [2, 3, 1]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.shuffle -> an_array
 *  
 *  Returns a new array with elements of this array shuffled.
 *     
 *     a = [ 1, 2, 3 ]           #=> [1, 2, 3]
 *     a.shuffle                 #=> [2, 3, 1]
 */

static VALUE
rb_ary_shuffle(VALUE ary)
{
    ary = rb_ary_dup(ary);
    rb_ary_shuffle_bang(ary);
    return ary;
}

#shuffle! ⇒ Array?

Shuffles elements in self in place.

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.shuffle!        -> array or nil
 *  
 *  Shuffles elements in _self_ in place.
 */


static VALUE
rb_ary_shuffle_bang(ary)
    VALUE ary;
{
    long i = RARRAY(ary)->len;

    rb_ary_modify(ary);
    while (i) {
    long j = rb_genrand_real()*i;
    VALUE tmp = RARRAY(ary)->ptr[--i];
    RARRAY(ary)->ptr[i] = RARRAY(ary)->ptr[j];
    RARRAY(ary)->ptr[j] = tmp;
    }
    return ary;
}

#[](index) ⇒ Object? #[](start, length) ⇒ Array? #[](range) ⇒ Array? #slice(index) ⇒ Object? #slice(start, length) ⇒ Array? #slice(range) ⇒ Array?

Element Reference---Returns the element at index, or returns a subarray starting at start and continuing for length elements, or returns a subarray specified by range. Negative indices count backward from the end of the array (-1 is the last element). Returns nil if the index (or starting index) are out of range.

a = [ "a", "b", "c", "d", "e" ]
a[2] +  a[0] + a[1]    #=> "cab"
a[6]                   #=> nil
a[1, 2]                #=> [ "b", "c" ]
a[1..3]                #=> [ "b", "c", "d" ]
a[4..7]                #=> [ "e" ]
a[6..10]               #=> nil
a[-3, 3]               #=> [ "c", "d", "e" ]
# special cases
a[5]                   #=> nil
a[5, 1]                #=> []
a[5..10]               #=> []

Overloads:




# File 'array.c'

/* 
 *  call-seq:
 *     array[index]                -> obj      or nil
 *     array[start, length]        -> an_array or nil
 *     array[range]                -> an_array or nil
 *     array.slice(index)          -> obj      or nil
 *     array.slice(start, length)  -> an_array or nil
 *     array.slice(range)          -> an_array or nil
 *
 *  Element Reference---Returns the element at _index_,
 *  or returns a subarray starting at _start_ and
 *  continuing for _length_ elements, or returns a subarray
 *  specified by _range_.
 *  Negative indices count backward from the end of the
 *  array (-1 is the last element). Returns nil if the index
 *  (or starting index) are out of range.
 *
 *     a = [ "a", "b", "c", "d", "e" ]
 *     a[2] +  a[0] + a[1]    #=> "cab"
 *     a[6]                   #=> nil
 *     a[1, 2]                #=> [ "b", "c" ]
 *     a[1..3]                #=> [ "b", "c", "d" ]
 *     a[4..7]                #=> [ "e" ]
 *     a[6..10]               #=> nil
 *     a[-3, 3]               #=> [ "c", "d", "e" ]
 *     # special cases
 *     a[5]                   #=> nil
 *     a[5, 1]                #=> []
 *     a[5..10]               #=> []
 *
 */

VALUE
rb_ary_aref(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE arg;
    long beg, len;

    if (argc == 2) {
    if (SYMBOL_P(argv[0])) {
        rb_raise(rb_eTypeError, "Symbol as array index");
    }
    beg = NUM2LONG(argv[0]);
    len = NUM2LONG(argv[1]);
    if (beg < 0) {
        beg += RARRAY(ary)->len;
    }
    return rb_ary_subseq(ary, beg, len);
    }
    if (argc != 1) {
    rb_scan_args(argc, argv, "11", 0, 0);
    }
    arg = argv[0];
    /* special case - speeding up */
    if (FIXNUM_P(arg)) {
    return rb_ary_entry(ary, FIX2LONG(arg));
    }
    if (SYMBOL_P(arg)) {
    rb_raise(rb_eTypeError, "Symbol as array index");
    }
    /* check if idx is Range */
    switch (rb_range_beg_len(arg, &beg, &len, RARRAY(ary)->len, 0)) {
      case Qfalse:
    break;
      case Qnil:
    return Qnil;
      default:
    return rb_ary_subseq(ary, beg, len);
    }
    return rb_ary_entry(ary, NUM2LONG(arg));
}

#slice!(index) ⇒ Object? #slice!(start, length) ⇒ nil #slice!(range) ⇒ nil

Deletes the element(s) given by an index (optionally with a length) or by a range. Returns the deleted object, subarray, or nil if the index is out of range. Equivalent to:

def slice!(*args)
  result = self[*args]
  self[*args] = nil
  result
end

a = [ "a", "b", "c" ]
a.slice!(1)     #=> "b"
a               #=> ["a", "c"]
a.slice!(-1)    #=> "c"
a               #=> ["a"]
a.slice!(100)   #=> nil
a               #=> ["a"]

Overloads:

  • #slice!(index) ⇒ Object?

    Returns:

  • #slice!(start, length) ⇒ nil

    Returns:

    • (nil)
  • #slice!(range) ⇒ nil

    Returns:

    • (nil) 



# File 'array.c'

/*
 *  call-seq:
 *     array.slice!(index)         -> obj or nil
 *     array.slice!(start, length) -> sub_array or nil
 *     array.slice!(range)         -> sub_array or nil 
 *  
 *  Deletes the element(s) given by an index (optionally with a length)
 *  or by a range. Returns the deleted object, subarray, or
 *  <code>nil</code> if the index is out of range. Equivalent to:
 *     
 *     def slice!(*args)
 *       result = self[*args]
 *       self[*args] = nil
 *       result
 *     end
 *     
 *     a = [ "a", "b", "c" ]
 *     a.slice!(1)     #=> "b"
 *     a               #=> ["a", "c"]
 *     a.slice!(-1)    #=> "c"
 *     a               #=> ["a"]
 *     a.slice!(100)   #=> nil
 *     a               #=> ["a"]
 */

static VALUE
rb_ary_slice_bang(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    VALUE arg1, arg2;
    long pos, len, orig_len;

    rb_ary_modify_check(ary);
    if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2) {
    pos = NUM2LONG(arg1);
    len = NUM2LONG(arg2);
      delete_pos_len:
    if (len < 0) return Qnil;
    orig_len = RARRAY_LEN(ary);
    if (pos < 0) {
        pos += orig_len;
        if (pos < 0) return Qnil;
    }
    else if (orig_len < pos) return Qnil;
    if (orig_len < pos + len) {
        len = orig_len - pos;
    }
    if (len == 0) return rb_ary_new2(0);
    arg2 = rb_ary_new4(len, RARRAY_PTR(ary)+pos);
    RBASIC(arg2)->klass = rb_obj_class(ary);
    rb_ary_splice(ary, pos, len, Qnil);    /* Qundef in 1.9 */
    return arg2;
    }

    if (!FIXNUM_P(arg1)) {
    switch (rb_range_beg_len(arg1, &pos, &len, RARRAY_LEN(ary), 0)) {
      case Qtrue:
        /* valid range */
        goto delete_pos_len;
      case Qnil:
        /* invalid range */
        return Qnil;
      default:
        /* not a range */
        break;
    }
    }

    return rb_ary_delete_at(ary, NUM2LONG(arg1));
}

#sort ⇒ Array #sort {|a, b| ... } ⇒ Array

Returns a new array created by sorting self. Comparisons for the sort will be done using the <=> operator or using an optional code block. The block implements a comparison between a and b, returning -1, 0, or +1. See also Enumerable#sort_by.

a = [ "d", "a", "e", "c", "b" ]
a.sort                    #=> ["a", "b", "c", "d", "e"]
a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.sort                   -> an_array 
 *     array.sort {| a,b | block }  -> an_array 
 *  
 *  Returns a new array created by sorting <i>self</i>. Comparisons for
 *  the sort will be done using the <code><=></code> operator or using
 *  an optional code block. The block implements a comparison between
 *  <i>a</i> and <i>b</i>, returning -1, 0, or +1. See also
 *  <code>Enumerable#sort_by</code>.
 *     
 *     a = [ "d", "a", "e", "c", "b" ]
 *     a.sort                    #=> ["a", "b", "c", "d", "e"]
 *     a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]
 */

VALUE
rb_ary_sort(ary)
    VALUE ary;
{
    ary = rb_ary_dup(ary);
    rb_ary_sort_bang(ary);
    return ary;
}

#sort! ⇒ Array #sort! {|a, b| ... } ⇒ Array

Sorts self. Comparisons for the sort will be done using the <=> operator or using an optional code block. The block implements a comparison between a and b, returning -1, 0, or +1. See also Enumerable#sort_by.

a = [ "d", "a", "e", "c", "b" ]
a.sort                    #=> ["a", "b", "c", "d", "e"]
a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]

Overloads:




# File 'array.c'

/*
 *  call-seq:
 *     array.sort!                   -> array
 *     array.sort! {| a,b | block }  -> array 
 *  
 *  Sorts _self_. Comparisons for
 *  the sort will be done using the <code><=></code> operator or using
 *  an optional code block. The block implements a comparison between
 *  <i>a</i> and <i>b</i>, returning -1, 0, or +1. See also
 *  <code>Enumerable#sort_by</code>.
 *     
 *     a = [ "d", "a", "e", "c", "b" ]
 *     a.sort                    #=> ["a", "b", "c", "d", "e"]
 *     a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]
 */

VALUE
rb_ary_sort_bang(ary)
    VALUE ary;
{
    rb_ary_modify(ary);
    if (RARRAY(ary)->len > 1) {
    FL_SET(ary, ARY_TMPLOCK);  /* prohibit modification during sort */
    rb_ensure(sort_internal, ary, sort_unlock, ary);
    }
    return ary;
}

#take(n) ⇒ Array

Returns first n elements from ary.

a = [1, 2, 3, 4, 5, 0]
a.take(3)             # => [1, 2, 3]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     ary.take(n)               => array
 *  
 *  Returns first n elements from <i>ary</i>.
 *     
 *     a = [1, 2, 3, 4, 5, 0]
 *     a.take(3)             # => [1, 2, 3]
 *     
 */

static VALUE
rb_ary_take(obj, n)
    VALUE obj;
    VALUE n;
{
    long len = NUM2LONG(n);
    if (len < 0) {
    rb_raise(rb_eArgError, "attempt to take negative size");
    }

    return rb_ary_subseq(obj, 0, len);
}

#take_while {|arr| ... } ⇒ Array

Passes elements to the block until the block returns nil or false, then stops iterating and returns an array of all prior elements.

a = [1, 2, 3, 4, 5, 0]
a.take_while {|i| i < 3 }   # => [1, 2]

Yields:

  • (arr)

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     ary.take_while {|arr| block }   => array
 *  
 *  Passes elements to the block until the block returns nil or false,
 *  then stops iterating and returns an array of all prior elements.
 *     
 *     a = [1, 2, 3, 4, 5, 0]
 *     a.take_while {|i| i < 3 }   # => [1, 2]
 *     
 */

static VALUE
rb_ary_take_while(ary)
    VALUE ary;
{
    long i;

    RETURN_ENUMERATOR(ary, 0, 0);
    for (i = 0; i < RARRAY(ary)->len; i++) {
    if (!RTEST(rb_yield(RARRAY(ary)->ptr[i]))) break;
    }
    return rb_ary_take(ary, LONG2FIX(i));
}

#to_a ⇒ Array

Returns self. If called on a subclass of Array, converts the receiver to an Array object.

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.to_a     -> array
 *  
 *  Returns _self_. If called on a subclass of Array, converts
 *  the receiver to an Array object.
 */

static VALUE
rb_ary_to_a(ary)
    VALUE ary;
{
    if (rb_obj_class(ary) != rb_cArray) {
    VALUE dup = rb_ary_new2(RARRAY(ary)->len);
    rb_ary_replace(dup, ary);
    return dup;
    }
    return ary;
}

#to_ary ⇒ Array

Returns self.

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.to_ary -> array
 *  
 *  Returns _self_.
 */

static VALUE
rb_ary_to_ary_m(ary)
    VALUE ary;
{
    return ary;
}

#to_s ⇒ String

Returns self.join.

[ "a", "e", "i", "o" ].to_s   #=> "aeio"

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.to_s -> string
 *  
 *  Returns _self_<code>.join</code>.
 *     
 *     [ "a", "e", "i", "o" ].to_s   #=> "aeio"
 *
 */

VALUE
rb_ary_to_s(ary)
    VALUE ary;
{
    if (RARRAY(ary)->len == 0) return rb_str_new(0, 0);
    
    return rb_ary_join(ary, rb_output_fs);
}

#transpose ⇒ Array

Assumes that self is an array of arrays and transposes the rows and columns.

a = [[1,2], [3,4], [5,6]]
a.transpose   #=> [[1, 3, 5], [2, 4, 6]]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.transpose -> an_array
 *  
 *  Assumes that <i>self</i> is an array of arrays and transposes the
 *  rows and columns.
 *     
 *     a = [[1,2], [3,4], [5,6]]
 *     a.transpose   #=> [[1, 3, 5], [2, 4, 6]]
 */

static VALUE
rb_ary_transpose(ary)
    VALUE ary;
{
    long elen = -1, alen, i, j;
    VALUE tmp, result = 0;

    alen = RARRAY(ary)->len;
    if (alen == 0) return rb_ary_dup(ary);
    for (i=0; i<alen; i++) {
    tmp = to_ary(rb_ary_elt(ary, i));
    if (elen < 0) {        /* first element */
        elen = RARRAY(tmp)->len;
        result = rb_ary_new2(elen);
        for (j=0; j<elen; j++) {
        rb_ary_store(result, j, rb_ary_new2(alen));
        }
    }
    else if (elen != RARRAY(tmp)->len) {
        rb_raise(rb_eIndexError, "element size differs (%d should be %d)",
             RARRAY(tmp)->len, elen);
    }
    for (j=0; j<elen; j++) {
        rb_ary_store(rb_ary_elt(result, j), i, rb_ary_elt(tmp, j));
    }
    }
    return result;
}

#uniq ⇒ Array

Returns a new array by removing duplicate values in self.

a = [ "a", "a", "b", "b", "c" ]
a.uniq   #=> ["a", "b", "c"]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.uniq   -> an_array
 *  
 *  Returns a new array by removing duplicate values in <i>self</i>.
 *     
 *     a = [ "a", "a", "b", "b", "c" ]
 *     a.uniq   #=> ["a", "b", "c"]
 */

static VALUE
rb_ary_uniq(ary)
    VALUE ary;
{
    ary = rb_ary_dup(ary);
    rb_ary_uniq_bang(ary);
    return ary;
}

#uniq! ⇒ Array?

Removes duplicate elements from self. Returns nil if no changes are made (that is, no duplicates are found).

a = [ "a", "a", "b", "b", "c" ]
a.uniq!   #=> ["a", "b", "c"]
b = [ "a", "b", "c" ]
b.uniq!   #=> nil

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.uniq! -> array or nil
 *  
 *  Removes duplicate elements from _self_.
 *  Returns <code>nil</code> if no changes are made (that is, no
 *  duplicates are found).
 *     
 *     a = [ "a", "a", "b", "b", "c" ]
 *     a.uniq!   #=> ["a", "b", "c"]
 *     b = [ "a", "b", "c" ]
 *     b.uniq!   #=> nil
 */

static VALUE
rb_ary_uniq_bang(ary)
    VALUE ary;
{
    VALUE hash, v, vv;
    long i, j;

    hash = ary_make_hash(ary, 0);

    if (RARRAY(ary)->len == RHASH(hash)->tbl->num_entries) {
    return Qnil;
    }
    for (i=j=0; i<RARRAY(ary)->len; i++) {
    v = vv = rb_ary_elt(ary, i);
    if (st_delete(RHASH(hash)->tbl, (st_data_t*)&vv, 0)) {
        rb_ary_store(ary, j++, v);
    }
    }
    RARRAY(ary)->len = j;

    return ary;
}

#unshift(obj, ...) ⇒ Array

Prepends objects to the front of array. other elements up one.

a = [ "b", "c", "d" ]
a.unshift("a")   #=> ["a", "b", "c", "d"]
a.unshift(1, 2)  #=> [ 1, 2, "a", "b", "c", "d"]

Returns:




# File 'array.c'

/*
 *  call-seq:
 *     array.unshift(obj, ...)  -> array
 *  
 *  Prepends objects to the front of <i>array</i>.
 *  other elements up one.
 *     
 *     a = [ "b", "c", "d" ]
 *     a.unshift("a")   #=> ["a", "b", "c", "d"]
 *     a.unshift(1, 2)  #=> [ 1, 2, "a", "b", "c", "d"]
 */

static VALUE
rb_ary_unshift_m(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    long len = RARRAY(ary)->len;

    if (argc == 0) return ary;

    /* make rooms by setting the last item */
    rb_ary_store(ary, len + argc - 1, Qnil);

    /* sliding items */
    MEMMOVE(RARRAY(ary)->ptr + argc, RARRAY(ary)->ptr, VALUE, len);
    MEMCPY(RARRAY(ary)->ptr, argv, VALUE, argc);
    
    return ary;
}

#values_at(selector, ...) ⇒ Array

Returns an array containing the elements in self corresponding to the given selector(s). The selectors may be either integer indices or ranges. See also Array#select.

a = %w{ a b c d e f }
a.values_at(1, 3, 5)
a.values_at(1, 3, 5, 7)
a.values_at(-1, -3, -5, -7)
a.values_at(1..3, 2...5)

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array.values_at(selector,... )  -> an_array
 *
 *  Returns an array containing the elements in
 *  _self_ corresponding to the given selector(s). The selectors
 *  may be either integer indices or ranges. 
 *  See also <code>Array#select</code>.
 * 
 *     a = %w{ a b c d e f }
 *     a.values_at(1, 3, 5)
 *     a.values_at(1, 3, 5, 7)
 *     a.values_at(-1, -3, -5, -7)
 *     a.values_at(1..3, 2...5)
 */

static VALUE
rb_ary_values_at(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    return rb_values_at(ary, RARRAY(ary)->len, argc, argv, rb_ary_entry);
}

#zip(arg, ...) ⇒ Array #zip(arg, ...) {|arr| ... } ⇒ nil

Converts any arguments to arrays, then merges elements of self with corresponding elements from each argument. This generates a sequence of self.size n-element arrays, where n is one more that the count of arguments. If the size of any argument is less than enumObj.size, nil values are supplied. If a block given, it is invoked for each output array, otherwise an array of arrays is returned.

a = [ 4, 5, 6 ]
b = [ 7, 8, 9 ]

[1,2,3].zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1,2].zip(a,b)         #=> [[1, 4, 7], [2, 5, 8]]
a.zip([1,2],[8])       #=> [[4,1,8], [5,2,nil], [6,nil,nil]]

Overloads:

  • #zip(arg, ...) ⇒ Array

    Returns:

  • #zip(arg, ...) {|arr| ... } ⇒ nil

    Yields:

    • (arr)

    Returns:

    • (nil) 



# File 'array.c'

/*
 *  call-seq:
 *     array.zip(arg, ...)                   -> an_array
 *     array.zip(arg, ...) {| arr | block }  -> nil
 *  
 *  Converts any arguments to arrays, then merges elements of
 *  <i>self</i> with corresponding elements from each argument. This
 *  generates a sequence of <code>self.size</code> <em>n</em>-element
 *  arrays, where <em>n</em> is one more that the count of arguments. If
 *  the size of any argument is less than <code>enumObj.size</code>,
 *  <code>nil</code> values are supplied. If a block given, it is
 *  invoked for each output array, otherwise an array of arrays is
 *  returned.
 *     
 *     a = [ 4, 5, 6 ]
 *     b = [ 7, 8, 9 ]
 *     
 *     [1,2,3].zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
 *     [1,2].zip(a,b)         #=> [[1, 4, 7], [2, 5, 8]]
 *     a.zip([1,2],[8])       #=> [[4,1,8], [5,2,nil], [6,nil,nil]]
 */

static VALUE
rb_ary_zip(argc, argv, ary)
    int argc;
    VALUE *argv;
    VALUE ary;
{
    int i, j;
    long len;
    VALUE result;

    for (i=0; i<argc; i++) {
    argv[i] = to_ary(argv[i]);
    }
    if (rb_block_given_p()) {
    for (i=0; i<RARRAY(ary)->len; i++) {
        VALUE tmp = rb_ary_new2(argc+1);

        rb_ary_push(tmp, rb_ary_elt(ary, i));
        for (j=0; j<argc; j++) {
        rb_ary_push(tmp, rb_ary_elt(argv[j], i));
        }
        rb_yield(tmp);
    }
    return Qnil;
    }
    len = RARRAY(ary)->len;
    result = rb_ary_new2(len);
    for (i=0; i<len; i++) {
    VALUE tmp = rb_ary_new2(argc+1);

    rb_ary_push(tmp, rb_ary_elt(ary, i));
    for (j=0; j<argc; j++) {
        rb_ary_push(tmp, rb_ary_elt(argv[j], i));
    }
    rb_ary_push(result, tmp);
    }
    return result;
}

#|(other_array) ⇒ Array

Set Union---Returns a new array by joining this array with other_array, removing duplicates.

[ "a", "b", "c" ] | [ "c", "d", "a" ]
       #=> [ "a", "b", "c", "d" ]

Returns:




# File 'array.c'

/* 
 *  call-seq:
 *     array | other_array     ->  an_array
 *
 *  Set Union---Returns a new array by joining this array with
 *  other_array, removing duplicates.
 *
 *     [ "a", "b", "c" ] | [ "c", "d", "a" ]
 *            #=> [ "a", "b", "c", "d" ]
 */

static VALUE
rb_ary_or(ary1, ary2)
    VALUE ary1, ary2;
{
    VALUE hash, ary3;
    VALUE v, vv;
    long i;

    ary2 = to_ary(ary2);
    ary3 = rb_ary_new2(RARRAY(ary1)->len+RARRAY(ary2)->len);
    hash = ary_make_hash(ary1, ary2);

    for (i=0; i<RARRAY(ary1)->len; i++) {
    v = vv = rb_ary_elt(ary1, i);
    if (st_delete(RHASH(hash)->tbl, (st_data_t*)&vv, 0)) {
        rb_ary_push(ary3, v);
    }
    }
    for (i=0; i<RARRAY(ary2)->len; i++) {
    v = vv = rb_ary_elt(ary2, i);
    if (st_delete(RHASH(hash)->tbl, (st_data_t*)&vv, 0)) {
        rb_ary_push(ary3, v);
    }
    }
    return ary3;
}