@code{(require 'array)} or @code{(require 'srfi-63)}
@ftindex array


@defun array? obj

Returns @code{#t} if the @var{obj} is an array, and @code{#f} if not.
@end defun

@noindent
@emph{Note:} Arrays are not disjoint from other Scheme types.
Vectors and possibly strings also satisfy @code{array?}.
A disjoint array predicate can be written:

@example
(define (strict-array? obj)
  (and (array? obj) (not (string? obj)) (not (vector? obj))))
@end example


@defun equal? obj1 obj2

Returns @code{#t} if @var{obj1} and @var{obj2} have the same rank and dimensions and the
corresponding elements of @var{obj1} and @var{obj2} are @code{equal?}.

@code{equal?} recursively compares the contents of pairs, vectors, strings, and
@emph{arrays}, applying @code{eqv?} on other objects such as numbers
and symbols.  A rule of thumb is that objects are generally @code{equal?} if
they print the same.  @code{equal?} may fail to terminate if its arguments are
circular data structures.

@example
(equal? 'a 'a)                             @result{}  #t
(equal? '(a) '(a))                         @result{}  #t
(equal? '(a (b) c)
        '(a (b) c))                        @result{}  #t
(equal? "abc" "abc")                       @result{}  #t
(equal? 2 2)                               @result{}  #t
(equal? (make-vector 5 'a)
        (make-vector 5 'a))                @result{}  #t
(equal? (make-array (A:fixN32b 4) 5 3)
        (make-array (A:fixN32b 4) 5 3))    @result{}  #t
(equal? (make-array '#(foo) 3 3)
        (make-array '#(foo) 3 3))          @result{}  #t
(equal? (lambda (x) x)
        (lambda (y) y))                    @result{}  @emph{unspecified}
@end example
@end defun


@defun array-rank obj

Returns the number of dimensions of @var{obj}.  If @var{obj} is not an array, 0 is
returned.
@end defun


@defun array-dimensions array

Returns a list of dimensions.

@example
(array-dimensions (make-array '#() 3 5))
   @result{} (3 5)
@end example
@end defun


@defun make-array prototype k1 @dots{}


Creates and returns an array of type @var{prototype} with dimensions @var{k1}, @dots{}
and filled with elements from @var{prototype}.  @var{prototype} must be an array, vector, or
string.  The implementation-dependent type of the returned array
will be the same as the type of @var{prototype}; except if that would be a vector
or string with rank not equal to one, in which case some variety of
array will be returned.

If the @var{prototype} has no elements, then the initial contents of the returned
array are unspecified.  Otherwise, the returned array will be filled
with the element at the origin of @var{prototype}.
@end defun


@defun create-array prototype k1 @dots{}

@code{create-array} is an alias for @code{make-array}.
@end defun


@defun make-shared-array array mapper k1 @dots{}

@code{make-shared-array} can be used to create shared subarrays of other
arrays.  The @var{mapper} is a function that translates coordinates in
the new array into coordinates in the old array.  A @var{mapper} must be
linear, and its range must stay within the bounds of the old array, but
it can be otherwise arbitrary.  A simple example:

@example
(define fred (make-array '#(#f) 8 8))
(define freds-diagonal
  (make-shared-array fred (lambda (i) (list i i)) 8))
(array-set! freds-diagonal 'foo 3)
(array-ref fred 3 3)
   @result{} FOO
(define freds-center
  (make-shared-array fred (lambda (i j) (list (+ 3 i) (+ 3 j)))
                     2 2))
(array-ref freds-center 0 0)
   @result{} FOO
@end example
@end defun


@defun list->array rank proto list

@var{list} must be a rank-nested list consisting of all the elements, in
row-major order, of the array to be created.

@code{list->array} returns an array of rank @var{rank} and type @var{proto} consisting of all the
elements, in row-major order, of @var{list}.  When @var{rank} is 0, @var{list} is the lone
array element; not necessarily a list.

@example
(list->array 2 '#() '((1 2) (3 4)))
                @result{} #2A((1 2) (3 4))
(list->array 0 '#() 3)
                @result{} #0A 3
@end example
@end defun


@defun array->list array

Returns a rank-nested list consisting of all the elements, in
row-major order, of @var{array}.  In the case of a rank-0 array, @code{array->list} returns
the single element.

@example
(array->list #2A((ho ho ho) (ho oh oh)))
                @result{} ((ho ho ho) (ho oh oh))
(array->list #0A ho)
                @result{} ho
@end example
@end defun


@defun vector->array vect proto dim1 @dots{}

@var{vect} must be a vector of length equal to the product of exact
nonnegative integers @var{dim1}, @dots{}.

@code{vector->array} returns an array of type @var{proto} consisting of all the elements, in
row-major order, of @var{vect}.  In the case of a rank-0 array, @var{vect} has a
single element.

@example
(vector->array #(1 2 3 4) #() 2 2)
                @result{} #2A((1 2) (3 4))
(vector->array '#(3) '#())
                @result{} #0A 3
@end example
@end defun


@defun array->vector array

Returns a new vector consisting of all the elements of @var{array} in
row-major order.

@example
(array->vector #2A ((1 2)( 3 4)))
                @result{} #(1 2 3 4)
(array->vector #0A ho)
                @result{} #(ho)
@end example
@end defun


@defun array-in-bounds? array index1 @dots{}

Returns @code{#t} if its arguments would be acceptable to
@code{array-ref}.
@end defun


@defun array-ref array k1 @dots{}

Returns the (@var{k1}, @dots{}) element of @var{array}.
@end defun


@deffn {Procedure} array-set! array obj k1 @dots{}

Stores @var{obj} in the (@var{k1}, @dots{}) element of @var{array}.  The value returned
by @code{array-set!} is unspecified.
@end deffn

@noindent
These functions return a prototypical uniform-array enclosing the
optional argument (which must be of the correct type).  If the
uniform-array type is supported by the implementation, then it is
returned; defaulting to the next larger precision type; resorting
finally to vector.

@defun A:floC128b z
@defunx A:floC128b
Returns an inexact 128.bit flonum complex uniform-array prototype.
@end defun

@defun A:floC64b z
@defunx A:floC64b
Returns an inexact 64.bit flonum complex uniform-array prototype.
@end defun

@defun A:floC32b z
@defunx A:floC32b
Returns an inexact 32.bit flonum complex uniform-array prototype.
@end defun

@defun A:floC16b z
@defunx A:floC16b
Returns an inexact 16.bit flonum complex uniform-array prototype.
@end defun

@defun A:floR128b x
@defunx A:floR128b
Returns an inexact 128.bit flonum real uniform-array prototype.
@end defun

@defun A:floR64b x
@defunx A:floR64b
Returns an inexact 64.bit flonum real uniform-array prototype.
@end defun

@defun A:floR32b x
@defunx A:floR32b
Returns an inexact 32.bit flonum real uniform-array prototype.
@end defun

@defun A:floR16b x
@defunx A:floR16b
Returns an inexact 16.bit flonum real uniform-array prototype.
@end defun

@defun A:floR128d q
@defunx A:floR128d
Returns an exact 128.bit decimal flonum rational uniform-array prototype.
@end defun

@defun A:floR64d q
@defunx A:floR64d
Returns an exact 64.bit decimal flonum rational uniform-array prototype.
@end defun

@defun A:floR32d q
@defunx A:floR32d
Returns an exact 32.bit decimal flonum rational uniform-array prototype.
@end defun

@defun A:fixZ64b n
@defunx A:fixZ64b
Returns an exact binary fixnum uniform-array prototype with at least
64 bits of precision.
@end defun

@defun A:fixZ32b n
@defunx A:fixZ32b
Returns an exact binary fixnum uniform-array prototype with at least
32 bits of precision.
@end defun

@defun A:fixZ16b n
@defunx A:fixZ16b
Returns an exact binary fixnum uniform-array prototype with at least
16 bits of precision.
@end defun

@defun A:fixZ8b n
@defunx A:fixZ8b
Returns an exact binary fixnum uniform-array prototype with at least
8 bits of precision.
@end defun

@defun A:fixN64b k
@defunx A:fixN64b
Returns an exact non-negative binary fixnum uniform-array prototype with at
least 64 bits of precision.
@end defun

@defun A:fixN32b k
@defunx A:fixN32b
Returns an exact non-negative binary fixnum uniform-array prototype with at
least 32 bits of precision.
@end defun

@defun A:fixN16b k
@defunx A:fixN16b
Returns an exact non-negative binary fixnum uniform-array prototype with at
least 16 bits of precision.
@end defun

@defun A:fixN8b k
@defunx A:fixN8b
Returns an exact non-negative binary fixnum uniform-array prototype with at
least 8 bits of precision.
@end defun

@defun A:bool bool
@defunx A:bool
Returns a boolean uniform-array prototype.
@end defun