### 0.1. Array Mapping: `(import (slib array-for-each))`

This library provides implementations of `for-each` and `map` for matrices, as well as functions to work on the indices of a matrix.

#### 0.1.1. array-for-each

`array-for-each` takes a procedure and one or more matrices. The procedure is applied to the equivalent elements of each matrix in row-major order.

The example below simply displays each element in the given array and returns `#t`.

```sash[r7rs]> (define x (list->array 2 #() '((1 2) (3 4))))
#<unspecified>
sash[r7rs]> (array-for-each display x)
1234#t```

#### 0.1.2. array-indexes

`array-indexes` takes a matrix as an argument and returns a new matrix of the same dimensions with lists of indexes in each element position.

```sash[r7rs]> (define x (list->array 2 #() '((1 2) (3 4))))
#<unspecified>
sash[r7rs]> (array-indexes x)
#<<array> 0x2b52960>
sash[r7rs]> (matrix->lists (array-indexes x))
(((0 0) (0 1)) ((1 0) (1 1)))```

#### 0.1.3. array-index-for-each

`array-index-for-each` takes a matrix and a procedure and applies the procedure to the indices of each element in the matrix.

```sash[r7rs]> (define x (list->array 2 #() '((1 2) (3 4))))
#<unspecified>
sash[r7rs]> (array-index-for-each x (lambda args (map display args)))
11011000#t```

Notice the order of application is not specified.

#### 0.1.4. array-index-map!

`array-index-map!` takes a matrix and a procedure and applies the procedure to the indices of each element in the matrix storing the return value in the corresponding element of the matrix.

```sash[r7rs]> (define a (vector 0 0 0))
#<unspecified>
sash[r7rs]> a
#(0 0 0)
sash[r7rs]> (array-index-map! a (lambda args (apply + args)))
#t
sash[r7rs]> a
#(0 1 2)```

In this case, the original matrix `a` has the sum of its indices placed into its elements.

#### 0.1.5. array-map!

`array-map!` takes a result matrix, a procedure and one or more source matrices. The procedure is applied to the equivalent elements of each suorce matrix in row-major order. The return values of the procedure are placed into the respective element of the result matrix.

In the example below `x` is used as both the result matrix and the first source matrix.

```sash[r7rs]> (define x (list->array 2 #() '((1 2) (3 4))))
#<unspecified>
sash[r7rs]> (define y (list->array 2 #() '((5 6) (7 8))))
#<unspecified>
sash[r7rs]> (array-map! x + x y)
#t
sash[r7rs]> (matrix->lists x)                             ; <1>
((6 8) (10 12))```
1. `matrix→lists` is from `(slib determinant)`

#### 0.1.6. array-map

`array-map` takes a matrix prototype, a procedure and one or more matrices. The procedure is applied to the equivalent elements of each matrix in row-major order. The return values of the procedure are placed into the respective element of a new matrix built using the type of the given prototype.

```sash[r7rs]> (define x (list->array 2 #() '((1 2) (3 4))))
#<unspecified>
sash[r7rs]> (define y (list->array 2 #() '((5 6) (7 8))))
#<unspecified>
sash[r7rs]> (matrix->lists (array-map #() + x y))           ; <1>
((6 8) (10 12))```
1. `matrix→lists` is from `(slib determinant)`

#### 0.1.7. array:copy!

`array:copy!` copies the elements of the second vector or matrix into the corresponding positions of the first vector or matrix; the destination must be at least as large as the source in each dimension.

```sash[r7rs]> (define v (vector 1 2 3))
#<unspecified>
sash[r7rs]> (define w (vector 4 5 6))
#<unspecified>
sash[r7rs]> v
#(1 2 3)
sash[r7rs]> (array:copy! v w)
#t
sash[r7rs]> v
#(4 5 6)```