1 /* Copyright (C) 1996, 1998, 2000, 2001, 2004, 2005, 2006, 2008, 2009,
2 * 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public License
6 * as published by the Free Software Foundation; either version 3 of
7 * the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
29 #include "libguile/_scm.h"
30 #include "libguile/strings.h"
31 #include "libguile/arrays.h"
32 #include "libguile/smob.h"
33 #include "libguile/chars.h"
34 #include "libguile/eq.h"
35 #include "libguile/eval.h"
36 #include "libguile/feature.h"
37 #include "libguile/root.h"
38 #include "libguile/vectors.h"
39 #include "libguile/bitvectors.h"
40 #include "libguile/srfi-4.h"
41 #include "libguile/generalized-arrays.h"
43 #include "libguile/validate.h"
44 #include "libguile/array-map.h"
47 /* The WHAT argument for `scm_gc_malloc ()' et al. */
48 static const char vi_gc_hint
[] = "array-indices";
51 AREF (SCM v
, size_t pos
)
53 return scm_c_array_ref_1 (v
, pos
);
57 ASET (SCM v
, size_t pos
, SCM val
)
59 scm_c_array_set_1_x (v
, val
, pos
);
62 /* Checker for scm_array mapping functions, returns:
65 4 --> shapes, increments, and bases are the same;
66 3 --> shapes and increments are the same;
67 2 --> shapes are the same;
68 1 --> ras are at least as big as ra0;
73 scm_ra_matchp (SCM ra0
, SCM ras
)
75 int i
, exact
= 4, empty
= 0;
76 scm_t_array_handle h0
;
78 scm_array_get_handle (ra0
, &h0
);
79 for (i
= 0; i
< h0
.ndims
; ++i
)
81 empty
= empty
|| (h0
.dims
[i
].lbnd
> h0
.dims
[i
].ubnd
);
84 while (scm_is_pair (ras
))
86 scm_t_array_handle h1
;
88 scm_array_get_handle (SCM_CAR (ras
), &h1
);
90 if (h0
.ndims
!= h1
.ndims
)
92 scm_array_handle_release (&h0
);
93 scm_array_handle_release (&h1
);
96 if (h0
.base
!= h1
.base
)
97 exact
= min(3, exact
);
99 for (i
= 0; i
< h0
.ndims
; ++i
)
101 empty
= empty
|| (h1
.dims
[i
].lbnd
> h1
.dims
[i
].ubnd
);
106 if (h0
.dims
[i
].inc
!= h1
.dims
[i
].inc
)
109 if (h0
.dims
[i
].lbnd
== h1
.dims
[i
].lbnd
&& h0
.dims
[i
].ubnd
== h1
.dims
[i
].ubnd
)
113 if (h0
.dims
[i
].lbnd
< h1
.dims
[i
].lbnd
|| h0
.dims
[i
].ubnd
> h1
.dims
[i
].ubnd
)
115 scm_array_handle_release (&h0
);
116 scm_array_handle_release (&h1
);
121 scm_array_handle_release (&h1
);
124 scm_array_handle_release (&h0
);
125 return empty
? 5 : exact
;
129 make1array (SCM v
, ssize_t inc
)
131 SCM a
= scm_i_make_array (1);
132 SCM_I_ARRAY_BASE (a
) = 0;
133 SCM_I_ARRAY_DIMS (a
)->lbnd
= 0;
134 SCM_I_ARRAY_DIMS (a
)->ubnd
= scm_c_array_length (v
) - 1;
135 SCM_I_ARRAY_DIMS (a
)->inc
= inc
;
136 SCM_I_ARRAY_V (a
) = v
;
140 /* Find down to which rank the array is unrollable. 0 means fully
141 unrollable, which all rank-0 and rank-1 arrays are. */
143 find_unrollk (SCM ra
, int k
)
150 inc
= SCM_I_ARRAY_DIMS (ra
)[k
].inc
;
152 size_t lenk
= (SCM_I_ARRAY_DIMS (ra
)[k
].ubnd
153 - SCM_I_ARRAY_DIMS (ra
)[k
].lbnd
+ 1);
156 } while (k
>= 0 && inc
== SCM_I_ARRAY_DIMS (ra
)[k
].inc
);
161 /* Length of the unrolled index set. */
163 klen (SCM ra
, int kbegin
, int kend
)
167 for (k
= kbegin
; k
< kend
; ++k
)
168 len
*= (SCM_I_ARRAY_DIMS (ra
)[k
].ubnd
169 - SCM_I_ARRAY_DIMS (ra
)[k
].lbnd
+ 1);
173 /* Linear index of the NOT unrolled index set. */
175 cindk (SCM ra
, ssize_t
*ve
, int kend
)
177 if (!SCM_I_ARRAYP (ra
))
178 return 0; /* this is BASE */
182 size_t i
= SCM_I_ARRAY_BASE (ra
);
183 for (k
= 0; k
< kend
; ++k
)
184 i
+= (ve
[k
] - SCM_I_ARRAY_DIMS (ra
)[k
].lbnd
) * SCM_I_ARRAY_DIMS (ra
)[k
].inc
;
189 /* array mapper: apply cproc to each dimension of the given arrays?.
190 int (*cproc) (); procedure to call on unrolled arrays?
191 cproc (dest, source list) or
192 cproc (dest, data, source list).
193 SCM data; data to give to cproc or unbound.
194 SCM ra0; destination array.
195 SCM lra; list of source arrays.
196 const char *what; caller, for error reporting. */
198 scm_ramapc (void *cproc_ptr
, SCM data
, SCM ra0
, SCM lra
, const char *what
)
204 int k
, kmax
, unrollk
;
205 int (*cproc
) () = cproc_ptr
;
208 switch (scm_ra_matchp (ra0
, lra
))
212 scm_misc_error (what
, "array shape mismatch: ~S", scm_list_1 (ra0
));
218 /* Prepare reference argument */
219 if (SCM_I_ARRAYP (ra0
))
221 kmax
= SCM_I_ARRAY_NDIM (ra0
)-1;
222 vra0
= make1array (SCM_I_ARRAY_V (ra0
), SCM_I_ARRAY_DIMS (ra0
)[kmax
].inc
);
227 vra0
= ra0
= make1array(ra0
, 1);
230 /* Linear addressing for rest arguments */
233 for (z
= lra
; !scm_is_null (z
); z
= SCM_CDR (z
))
235 SCM ra1
= SCM_CAR (z
);
237 if (SCM_I_ARRAYP (ra1
))
238 vra1
= make1array (SCM_I_ARRAY_V (ra1
), SCM_I_ARRAY_DIMS (ra1
)[kmax
].inc
);
240 vra1
= make1array (ra1
, 1);
241 *plvra
= scm_cons (vra1
, SCM_EOL
);
242 plvra
= SCM_CDRLOC (*plvra
);
245 /* Find common unroll depth */
246 unrollk
= find_unrollk (ra0
, kmax
);
247 for (z
= lra
; !scm_is_null (z
); z
= SCM_CDR (z
))
249 SCM ra1
= SCM_CAR (z
);
250 unrollk
= max(unrollk
, find_unrollk (ra1
, kmax
));
252 unrolled_len
= klen (ra0
, unrollk
, kmax
+1);
254 /* Set inner loop size */
255 SCM_I_ARRAY_DIMS (vra0
)->lbnd
= 0;
256 SCM_I_ARRAY_DIMS (vra0
)->ubnd
= unrolled_len
- 1;
257 for (z
= lvra
; !scm_is_null (z
); z
= SCM_CDR (z
))
259 SCM_I_ARRAY_DIMS (SCM_CAR (z
))->lbnd
= 0;
260 SCM_I_ARRAY_DIMS (SCM_CAR (z
))->ubnd
= unrolled_len
- 1;
263 /* Set starting indices and go */
264 vi
= scm_gc_malloc_pointerless (sizeof(ssize_t
) * unrollk
, vi_gc_hint
);
265 for (k
= 0; k
< unrollk
; ++k
)
266 vi
[k
] = SCM_I_ARRAY_DIMS (ra0
)[k
].lbnd
;
272 SCM_I_ARRAY_BASE (vra0
) = cindk (ra0
, vi
, unrollk
);
273 for (z
= lvra
; !scm_is_null (z
); z
= SCM_CDR (z
), y
= SCM_CDR (y
))
274 SCM_I_ARRAY_BASE (SCM_CAR (z
)) = cindk (SCM_CAR (y
), vi
, unrollk
);
275 if (SCM_UNBNDP (data
))
278 cproc (vra0
, data
, lvra
);
281 else if (vi
[k
] < SCM_I_ARRAY_DIMS (ra0
)[k
].ubnd
)
288 vi
[k
] = SCM_I_ARRAY_DIMS (ra0
)[k
].lbnd
- 1;
300 rafill (SCM dst
, SCM fill
)
302 long n
= (SCM_I_ARRAY_DIMS (dst
)->ubnd
- SCM_I_ARRAY_DIMS (dst
)->lbnd
+ 1);
303 scm_t_array_handle h
;
306 scm_array_get_handle (SCM_I_ARRAY_V (dst
), &h
);
307 i
= SCM_I_ARRAY_BASE (dst
);
308 inc
= SCM_I_ARRAY_DIMS (dst
)->inc
;
310 for (; n
-- > 0; i
+= inc
)
311 h
.vset (h
.vector
, i
, fill
);
313 scm_array_handle_release (&h
);
317 SCM_DEFINE (scm_array_fill_x
, "array-fill!", 2, 0, 0,
319 "Store @var{fill} in every element of array @var{ra}. The value\n"
320 "returned is unspecified.")
321 #define FUNC_NAME s_scm_array_fill_x
323 scm_ramapc (rafill
, fill
, ra
, SCM_EOL
, FUNC_NAME
);
324 return SCM_UNSPECIFIED
;
330 racp (SCM src
, SCM dst
)
332 ssize_t n
= (SCM_I_ARRAY_DIMS (src
)->ubnd
- SCM_I_ARRAY_DIMS (src
)->lbnd
+ 1);
333 scm_t_array_handle h_s
, h_d
;
335 ssize_t inc_s
, inc_d
;
338 i_s
= SCM_I_ARRAY_BASE (src
);
339 i_d
= SCM_I_ARRAY_BASE (dst
);
340 inc_s
= SCM_I_ARRAY_DIMS (src
)->inc
;
341 inc_d
= SCM_I_ARRAY_DIMS (dst
)->inc
;
343 scm_array_get_handle (SCM_I_ARRAY_V (src
), &h_s
);
344 scm_array_get_handle (SCM_I_ARRAY_V (dst
), &h_d
);
346 if (h_s
.element_type
== SCM_ARRAY_ELEMENT_TYPE_SCM
347 && h_d
.element_type
== SCM_ARRAY_ELEMENT_TYPE_SCM
)
349 SCM
const * el_s
= h_s
.elements
;
350 SCM
* el_d
= h_d
.writable_elements
;
351 for (; n
-- > 0; i_s
+= inc_s
, i_d
+= inc_d
)
352 el_d
[i_d
] = el_s
[i_s
];
355 for (; n
-- > 0; i_s
+= inc_s
, i_d
+= inc_d
)
356 h_d
.vset (h_d
.vector
, i_d
, h_s
.vref (h_s
.vector
, i_s
));
358 scm_array_handle_release (&h_d
);
359 scm_array_handle_release (&h_s
);
364 SCM_REGISTER_PROC(s_array_copy_in_order_x
, "array-copy-in-order!", 2, 0, 0, scm_array_copy_x
);
367 SCM_DEFINE (scm_array_copy_x
, "array-copy!", 2, 0, 0,
369 "@deffnx {Scheme Procedure} array-copy-in-order! src dst\n"
370 "Copy every element from vector or array @var{src} to the\n"
371 "corresponding element of @var{dst}. @var{dst} must have the\n"
372 "same rank as @var{src}, and be at least as large in each\n"
373 "dimension. The order is unspecified.")
374 #define FUNC_NAME s_scm_array_copy_x
376 scm_ramapc (racp
, SCM_UNDEFINED
, src
, scm_cons (dst
, SCM_EOL
), FUNC_NAME
);
377 return SCM_UNSPECIFIED
;
382 #if SCM_ENABLE_DEPRECATED == 1
384 /* to be used as cproc in scm_ramapc to fill an array dimension with
387 scm_array_fill_int (SCM ra
, SCM fill
, SCM ignore SCM_UNUSED
)
390 unsigned long n
= SCM_I_ARRAY_DIMS (ra
)->ubnd
- SCM_I_ARRAY_DIMS (ra
)->lbnd
+ 1;
391 long inc
= SCM_I_ARRAY_DIMS (ra
)->inc
;
392 unsigned long base
= SCM_I_ARRAY_BASE (ra
);
394 ra
= SCM_I_ARRAY_V (ra
);
396 for (i
= base
; n
--; i
+= inc
)
402 /* Functions callable by ARRAY-MAP! */
405 scm_ra_eqp (SCM ra0
, SCM ras
)
407 SCM ra1
= SCM_CAR (ras
), ra2
= SCM_CAR (SCM_CDR (ras
));
408 scm_t_array_handle ra0_handle
;
409 scm_t_array_dim
*ra0_dims
;
413 unsigned long i1
= SCM_I_ARRAY_BASE (ra1
), i2
= SCM_I_ARRAY_BASE (ra2
);
414 long inc1
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
415 long inc2
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
416 ra1
= SCM_I_ARRAY_V (ra1
);
417 ra2
= SCM_I_ARRAY_V (ra2
);
419 scm_array_get_handle (ra0
, &ra0_handle
);
420 ra0_dims
= scm_array_handle_dims (&ra0_handle
);
421 n
= ra0_dims
[0].ubnd
- ra0_dims
[0].lbnd
+ 1;
422 inc0
= ra0_dims
[0].inc
;
425 for (; n
-- > 0; i0
+= inc0
, i1
+= inc1
, i2
+= inc2
)
426 if (scm_is_true (scm_array_handle_ref (&ra0_handle
, i0
)))
427 if (!scm_is_eq (AREF (ra1
, i1
), AREF (ra2
, i2
)))
428 scm_array_handle_set (&ra0_handle
, i0
, SCM_BOOL_F
);
431 scm_array_handle_release (&ra0_handle
);
435 /* opt 0 means <, nonzero means >= */
438 ra_compare (SCM ra0
, SCM ra1
, SCM ra2
, int opt
)
440 scm_t_array_handle ra0_handle
;
441 scm_t_array_dim
*ra0_dims
;
445 unsigned long i1
= SCM_I_ARRAY_BASE (ra1
), i2
= SCM_I_ARRAY_BASE (ra2
);
446 long inc1
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
447 long inc2
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
448 ra1
= SCM_I_ARRAY_V (ra1
);
449 ra2
= SCM_I_ARRAY_V (ra2
);
451 scm_array_get_handle (ra0
, &ra0_handle
);
452 ra0_dims
= scm_array_handle_dims (&ra0_handle
);
453 n
= ra0_dims
[0].ubnd
- ra0_dims
[0].lbnd
+ 1;
454 inc0
= ra0_dims
[0].inc
;
457 for (; n
-- > 0; i0
+= inc0
, i1
+= inc1
, i2
+= inc2
)
458 if (scm_is_true (scm_array_handle_ref (&ra0_handle
, i0
)))
460 scm_is_true (scm_less_p (AREF (ra1
, i1
), AREF (ra2
, i2
))) :
461 scm_is_false (scm_less_p (AREF (ra1
, i1
), AREF (ra2
, i2
))))
462 scm_array_handle_set (&ra0_handle
, i0
, SCM_BOOL_F
);
465 scm_array_handle_release (&ra0_handle
);
472 scm_ra_lessp (SCM ra0
, SCM ras
)
474 return ra_compare (ra0
, SCM_CAR (ras
), SCM_CAR (SCM_CDR (ras
)), 0);
479 scm_ra_leqp (SCM ra0
, SCM ras
)
481 return ra_compare (ra0
, SCM_CAR (SCM_CDR (ras
)), SCM_CAR (ras
), 1);
486 scm_ra_grp (SCM ra0
, SCM ras
)
488 return ra_compare (ra0
, SCM_CAR (SCM_CDR (ras
)), SCM_CAR (ras
), 0);
493 scm_ra_greqp (SCM ra0
, SCM ras
)
495 return ra_compare (ra0
, SCM_CAR (ras
), SCM_CAR (SCM_CDR (ras
)), 1);
500 scm_ra_sum (SCM ra0
, SCM ras
)
502 long n
= SCM_I_ARRAY_DIMS (ra0
)->ubnd
- SCM_I_ARRAY_DIMS (ra0
)->lbnd
+ 1;
503 unsigned long i0
= SCM_I_ARRAY_BASE (ra0
);
504 long inc0
= SCM_I_ARRAY_DIMS (ra0
)->inc
;
505 ra0
= SCM_I_ARRAY_V (ra0
);
506 if (!scm_is_null(ras
))
508 SCM ra1
= SCM_CAR (ras
);
509 unsigned long i1
= SCM_I_ARRAY_BASE (ra1
);
510 long inc1
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
511 ra1
= SCM_I_ARRAY_V (ra1
);
512 switch (SCM_TYP7 (ra0
) == SCM_TYP7 (ra1
) ? SCM_TYP7 (ra0
) : 0)
516 for (; n
-- > 0; i0
+= inc0
, i1
+= inc1
)
517 ASET (ra0
, i0
, scm_sum (AREF(ra0
, i0
), AREF(ra1
, i1
)));
528 scm_ra_difference (SCM ra0
, SCM ras
)
530 long n
= SCM_I_ARRAY_DIMS (ra0
)->ubnd
- SCM_I_ARRAY_DIMS (ra0
)->lbnd
+ 1;
531 unsigned long i0
= SCM_I_ARRAY_BASE (ra0
);
532 long inc0
= SCM_I_ARRAY_DIMS (ra0
)->inc
;
533 ra0
= SCM_I_ARRAY_V (ra0
);
534 if (scm_is_null (ras
))
536 switch (SCM_TYP7 (ra0
))
540 for (; n
-- > 0; i0
+= inc0
)
541 ASET (ra0
, i0
, scm_difference (AREF(ra0
, i0
), SCM_UNDEFINED
));
548 SCM ra1
= SCM_CAR (ras
);
549 unsigned long i1
= SCM_I_ARRAY_BASE (ra1
);
550 long inc1
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
551 ra1
= SCM_I_ARRAY_V (ra1
);
552 switch (SCM_TYP7 (ra0
) == SCM_TYP7 (ra1
) ? SCM_TYP7 (ra0
) : 0)
556 for (; n
-- > 0; i0
+= inc0
, i1
+= inc1
)
557 ASET (ra0
, i0
, scm_difference (AREF (ra0
, i0
), AREF (ra1
, i1
)));
568 scm_ra_product (SCM ra0
, SCM ras
)
570 long n
= SCM_I_ARRAY_DIMS (ra0
)->ubnd
- SCM_I_ARRAY_DIMS (ra0
)->lbnd
+ 1;
571 unsigned long i0
= SCM_I_ARRAY_BASE (ra0
);
572 long inc0
= SCM_I_ARRAY_DIMS (ra0
)->inc
;
573 ra0
= SCM_I_ARRAY_V (ra0
);
574 if (!scm_is_null (ras
))
576 SCM ra1
= SCM_CAR (ras
);
577 unsigned long i1
= SCM_I_ARRAY_BASE (ra1
);
578 long inc1
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
579 ra1
= SCM_I_ARRAY_V (ra1
);
580 switch (SCM_TYP7 (ra0
) == SCM_TYP7 (ra1
) ? SCM_TYP7 (ra0
) : 0)
584 for (; n
-- > 0; i0
+= inc0
, i1
+= inc1
)
585 ASET (ra0
, i0
, scm_product (AREF (ra0
, i0
), AREF (ra1
, i1
)));
594 scm_ra_divide (SCM ra0
, SCM ras
)
596 long n
= SCM_I_ARRAY_DIMS (ra0
)->ubnd
- SCM_I_ARRAY_DIMS (ra0
)->lbnd
+ 1;
597 unsigned long i0
= SCM_I_ARRAY_BASE (ra0
);
598 long inc0
= SCM_I_ARRAY_DIMS (ra0
)->inc
;
599 ra0
= SCM_I_ARRAY_V (ra0
);
600 if (scm_is_null (ras
))
602 switch (SCM_TYP7 (ra0
))
606 for (; n
-- > 0; i0
+= inc0
)
607 ASET (ra0
, i0
, scm_divide (AREF (ra0
, i0
), SCM_UNDEFINED
));
614 SCM ra1
= SCM_CAR (ras
);
615 unsigned long i1
= SCM_I_ARRAY_BASE (ra1
);
616 long inc1
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
617 ra1
= SCM_I_ARRAY_V (ra1
);
618 switch (SCM_TYP7 (ra0
) == SCM_TYP7 (ra1
) ? SCM_TYP7 (ra0
) : 0)
622 for (; n
-- > 0; i0
+= inc0
, i1
+= inc1
)
624 SCM res
= scm_divide (AREF (ra0
, i0
), AREF (ra1
, i1
));
636 scm_array_identity (SCM dst
, SCM src
)
638 return racp (SCM_CAR (src
), scm_cons (dst
, SCM_EOL
));
641 #endif /* SCM_ENABLE_DEPRECATED */
644 ramap (SCM ra0
, SCM proc
, SCM ras
)
646 ssize_t i
= SCM_I_ARRAY_DIMS (ra0
)->lbnd
;
647 size_t n
= SCM_I_ARRAY_DIMS (ra0
)->ubnd
- i
+ 1;
649 scm_t_array_handle h0
;
652 scm_array_get_handle (SCM_I_ARRAY_V (ra0
), &h0
);
653 i0
= SCM_I_ARRAY_BASE (ra0
);
654 inc0
= SCM_I_ARRAY_DIMS (ra0
)->inc
;
656 if (scm_is_null (ras
))
657 for (; i0
< i0end
; i0
+= inc0
)
658 h0
.vset (h0
.vector
, i0
, scm_call_0 (proc
));
661 SCM ra1
= SCM_CAR (ras
);
662 scm_t_array_handle h1
;
665 scm_array_get_handle (SCM_I_ARRAY_V (ra1
), &h1
);
666 i1
= SCM_I_ARRAY_BASE (ra1
);
667 inc1
= SCM_I_ARRAY_DIMS (ra1
)->inc
;
669 if (scm_is_null (ras
))
670 for (; i0
< i0end
; i0
+= inc0
, i1
+= inc1
)
671 h0
.vset (h0
.vector
, i0
, scm_call_1 (proc
, h1
.vref (h1
.vector
, i1
)));
674 ras
= scm_vector (ras
);
675 for (; i0
< i0end
; i0
+= inc0
, i1
+= inc1
, ++i
)
679 for (k
= scm_c_vector_length (ras
); k
--;)
680 args
= scm_cons (AREF (scm_c_vector_ref (ras
, k
), i
), args
);
681 h0
.vset (h0
.vector
, i0
,
682 scm_apply_1 (proc
, h1
.vref (h1
.vector
, i1
), args
));
685 scm_array_handle_release (&h1
);
687 scm_array_handle_release (&h0
);
692 SCM_REGISTER_PROC(s_array_map_in_order_x
, "array-map-in-order!", 2, 0, 1, scm_array_map_x
);
694 SCM_SYMBOL (sym_b
, "b");
696 SCM_DEFINE (scm_array_map_x
, "array-map!", 2, 0, 1,
697 (SCM ra0
, SCM proc
, SCM lra
),
698 "@deffnx {Scheme Procedure} array-map-in-order! ra0 proc . lra\n"
699 "@var{array1}, @dots{} must have the same number of dimensions\n"
700 "as @var{ra0} and have a range for each index which includes the\n"
701 "range for the corresponding index in @var{ra0}. @var{proc} is\n"
702 "applied to each tuple of elements of @var{array1}, @dots{} and\n"
703 "the result is stored as the corresponding element in @var{ra0}.\n"
704 "The value returned is unspecified. The order of application is\n"
706 #define FUNC_NAME s_scm_array_map_x
708 SCM_VALIDATE_PROC (2, proc
);
709 SCM_VALIDATE_REST_ARGUMENT (lra
);
711 scm_ramapc (ramap
, proc
, ra0
, lra
, FUNC_NAME
);
712 return SCM_UNSPECIFIED
;
718 rafe (SCM ra0
, SCM proc
, SCM ras
)
720 ssize_t i
= SCM_I_ARRAY_DIMS (ra0
)->lbnd
;
721 size_t n
= SCM_I_ARRAY_DIMS (ra0
)->ubnd
- i
+ 1;
723 scm_t_array_handle h0
;
726 scm_array_get_handle (SCM_I_ARRAY_V (ra0
), &h0
);
727 i0
= SCM_I_ARRAY_BASE (ra0
);
728 inc0
= SCM_I_ARRAY_DIMS (ra0
)->inc
;
730 if (scm_is_null (ras
))
731 for (; i0
< i0end
; i0
+= inc0
)
732 scm_call_1 (proc
, h0
.vref (h0
.vector
, i0
));
735 ras
= scm_vector (ras
);
736 for (; i0
< i0end
; i0
+= inc0
, ++i
)
740 for (k
= scm_c_vector_length (ras
); k
--;)
741 args
= scm_cons (AREF (scm_c_vector_ref (ras
, k
), i
), args
);
742 scm_apply_1 (proc
, h0
.vref (h0
.vector
, i0
), args
);
745 scm_array_handle_release (&h0
);
749 SCM_DEFINE (scm_array_for_each
, "array-for-each", 2, 0, 1,
750 (SCM proc
, SCM ra0
, SCM lra
),
751 "Apply @var{proc} to each tuple of elements of @var{ra0} @dots{}\n"
752 "in row-major order. The value returned is unspecified.")
753 #define FUNC_NAME s_scm_array_for_each
755 SCM_VALIDATE_PROC (1, proc
);
756 SCM_VALIDATE_REST_ARGUMENT (lra
);
757 scm_ramapc (rafe
, proc
, ra0
, lra
, FUNC_NAME
);
758 return SCM_UNSPECIFIED
;
763 array_index_map_1 (SCM ra
, SCM proc
)
765 scm_t_array_handle h
;
768 scm_array_get_handle (ra
, &h
);
770 for (i
= h
.dims
[0].lbnd
, p
= h
.base
; i
<= h
.dims
[0].ubnd
; ++i
, p
+= inc
)
771 h
.vset (h
.vector
, p
, scm_call_1 (proc
, scm_from_ssize_t (i
)));
772 scm_array_handle_release (&h
);
775 /* Here we assume that the array is a scm_tc7_array, as that is the only
776 kind of array in Guile that supports rank > 1. */
778 array_index_map_n (SCM ra
, SCM proc
)
781 int j
, k
, kmax
= SCM_I_ARRAY_NDIM (ra
) - 1;
784 vi
= scm_gc_malloc_pointerless (sizeof(ssize_t
) * (kmax
+ 1), vi_gc_hint
);
786 for (k
= 0; k
<= kmax
; k
++)
788 vi
[k
] = SCM_I_ARRAY_DIMS (ra
)[k
].lbnd
;
789 if (vi
[k
] > SCM_I_ARRAY_DIMS (ra
)[k
].ubnd
)
800 vi
[kmax
] = SCM_I_ARRAY_DIMS (ra
)[kmax
].lbnd
;
801 i
= cindk (ra
, vi
, kmax
+1);
802 for (j
= 0; j
<=kmax
; ++j
)
804 *p
= scm_cons (scm_from_ssize_t (vi
[j
]), SCM_EOL
);
808 for (; vi
[kmax
] <= SCM_I_ARRAY_DIMS (ra
)[kmax
].ubnd
;
809 *q
= scm_from_ssize_t (++vi
[kmax
]))
811 ASET (SCM_I_ARRAY_V (ra
), i
, scm_apply_0 (proc
, args
));
812 i
+= SCM_I_ARRAY_DIMS (ra
)[kmax
].inc
;
816 else if (vi
[k
] < SCM_I_ARRAY_DIMS (ra
)[k
].ubnd
)
823 vi
[k
] = SCM_I_ARRAY_DIMS (ra
)[k
].lbnd
- 1;
830 SCM_DEFINE (scm_array_index_map_x
, "array-index-map!", 2, 0, 0,
832 "Apply @var{proc} to the indices of each element of @var{ra} in\n"
833 "turn, storing the result in the corresponding element. The value\n"
834 "returned and the order of application are unspecified.\n\n"
835 "One can implement @var{array-indexes} as\n"
837 "(define (array-indexes array)\n"
838 " (let ((ra (apply make-array #f (array-shape array))))\n"
839 " (array-index-map! ra (lambda x x))\n"
844 "(define (apl:index-generator n)\n"
845 " (let ((v (make-uniform-vector n 1)))\n"
846 " (array-index-map! v (lambda (i) i))\n"
849 #define FUNC_NAME s_scm_array_index_map_x
851 SCM_VALIDATE_PROC (2, proc
);
853 switch (scm_c_array_rank (ra
))
856 scm_array_set_x (ra
, scm_call_0 (proc
), SCM_EOL
);
859 array_index_map_1 (ra
, proc
);
862 array_index_map_n (ra
, proc
);
866 return SCM_UNSPECIFIED
;
872 array_compare (scm_t_array_handle
*hx
, scm_t_array_handle
*hy
,
873 size_t dim
, unsigned long posx
, unsigned long posy
)
875 if (dim
== scm_array_handle_rank (hx
))
876 return scm_is_true (scm_equal_p (scm_array_handle_ref (hx
, posx
),
877 scm_array_handle_ref (hy
, posy
)));
883 if (hx
->dims
[dim
].lbnd
!= hy
->dims
[dim
].lbnd
884 || hx
->dims
[dim
].ubnd
!= hy
->dims
[dim
].ubnd
)
887 i
= hx
->dims
[dim
].ubnd
- hx
->dims
[dim
].lbnd
+ 1;
889 incx
= hx
->dims
[dim
].inc
;
890 incy
= hy
->dims
[dim
].inc
;
891 posx
+= (i
- 1) * incx
;
892 posy
+= (i
- 1) * incy
;
894 for (; i
> 0; i
--, posx
-= incx
, posy
-= incy
)
895 if (!array_compare (hx
, hy
, dim
+ 1, posx
, posy
))
902 scm_array_equal_p (SCM x
, SCM y
)
904 scm_t_array_handle hx
, hy
;
907 scm_array_get_handle (x
, &hx
);
908 scm_array_get_handle (y
, &hy
);
910 res
= scm_from_bool (hx
.ndims
== hy
.ndims
911 && hx
.element_type
== hy
.element_type
);
913 if (scm_is_true (res
))
914 res
= scm_from_bool (array_compare (&hx
, &hy
, 0, 0, 0));
916 scm_array_handle_release (&hy
);
917 scm_array_handle_release (&hx
);
922 static SCM
scm_i_array_equal_p (SCM
, SCM
, SCM
);
923 SCM_DEFINE (scm_i_array_equal_p
, "array-equal?", 0, 2, 1,
924 (SCM ra0
, SCM ra1
, SCM rest
),
925 "Return @code{#t} iff all arguments are arrays with the same\n"
926 "shape, the same type, and have corresponding elements which are\n"
927 "either @code{equal?} or @code{array-equal?}. This function\n"
928 "differs from @code{equal?} in that all arguments must be arrays.")
929 #define FUNC_NAME s_scm_i_array_equal_p
931 if (SCM_UNBNDP (ra0
) || SCM_UNBNDP (ra1
))
934 while (!scm_is_null (rest
))
935 { if (scm_is_false (scm_array_equal_p (ra0
, ra1
)))
938 ra1
= scm_car (rest
);
939 rest
= scm_cdr (rest
);
941 return scm_array_equal_p (ra0
, ra1
);
947 scm_init_array_map (void)
949 #include "libguile/array-map.x"
950 scm_add_feature (s_scm_array_for_each
);