blob: ce082a66605b326df34a5c8878d38f851163d545 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
@code{(require 'array-for-each)}
@ftindex array-for-each
@deffn {Procedure} array-map! array0 proc array1 @dots{}
@var{array1}, @dots{} must have the same number of dimensions as
@var{array0} and have a range for each index which includes the range
for the corresponding index in @var{array0}. @var{proc} is applied to
each tuple of elements of @var{array1} @dots{} and the result is stored
as the corresponding element in @var{array0}. The value returned is
unspecified. The order of application is unspecified.
@end deffn
@defun array-map prototype proc array1 array2 @dots{}
@var{array2}, @dots{} must have the same number of dimensions as
@var{array1} and have a range for each index which includes the
range for the corresponding index in @var{array1}. @var{proc} is
applied to each tuple of elements of @var{array1}, @var{array2},
@dots{} and the result is stored as the corresponding element in a
new array of type @var{prototype}. The new array is returned. The
order of application is unspecified.
@end defun
@defun array-for-each proc array0 @dots{}
@var{proc} is applied to each tuple of elements of @var{array0} @dots{}
in row-major order. The value returned is unspecified.
@end defun
@defun array-indexes array
Returns an array of lists of indexes for @var{array} such that, if
@var{li} is a list of indexes for which @var{array} is defined,
(equal? @var{li} (apply array-ref (array-indexes @var{array})
@var{li})).
@end defun
@defun array-index-for-each array proc
applies @var{proc} to the indices of each element of @var{array} in
turn. The value returned and the order of application are
unspecified.
One can implement @var{array-index-map!} as
@example
(define (array-index-map! ra fun)
(array-index-for-each
ra
(lambda is (apply array-set! ra (apply fun is) is))))
@end example
@end defun
@deffn {Procedure} array-index-map! array proc
applies @var{proc} to the indices of each element of @var{array} in
turn, storing the result in the corresponding element. The value
returned and the order of application are unspecified.
One can implement @var{array-indexes} as
@example
(define (array-indexes array)
(let ((ra (apply make-array '#() (array-dimensions array))))
(array-index-map! ra (lambda x x))
ra))
@end example
Another example:
@example
(define (apl:index-generator n)
(let ((v (make-vector n 1)))
(array-index-map! v (lambda (i) i))
v))
@end example
@end deffn
@deffn {Procedure} array:copy! destination source
Copies every element from vector or array @var{source} to the
corresponding element of @var{destination}. @var{destination} must
have the same rank as @var{source}, and be at least as large in each
dimension. The order of copying is unspecified.
@end deffn
|
