1 /* Copyright (C) 1995,1996,1997,1998 Free Software Foundation, Inc.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2, or (at your option)
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this software; see the file COPYING. If not, write to
15 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
16 * Boston, MA 02111-1307 USA
18 * As a special exception, the Free Software Foundation gives permission
19 * for additional uses of the text contained in its release of GUILE.
21 * The exception is that, if you link the GUILE library with other files
22 * to produce an executable, this does not by itself cause the
23 * resulting executable to be covered by the GNU General Public License.
24 * Your use of that executable is in no way restricted on account of
25 * linking the GUILE library code into it.
27 * This exception does not however invalidate any other reasons why
28 * the executable file might be covered by the GNU General Public License.
30 * This exception applies only to the code released by the
31 * Free Software Foundation under the name GUILE. If you copy
32 * code from other Free Software Foundation releases into a copy of
33 * GUILE, as the General Public License permits, the exception does
34 * not apply to the code that you add in this way. To avoid misleading
35 * anyone as to the status of such modified files, you must delete
36 * this exception notice from them.
38 * If you write modifications of your own for GUILE, it is your choice
39 * whether to permit this exception to apply to your modifications.
40 * If you do not wish that, delete this exception notice. */
60 /* The set of uniform scm_vector types is:
62 * unsigned char string
69 * complex double cvect
76 /* return the size of an element in a uniform array or 0 if type not
79 scm_uniform_element_size (SCM obj
)
83 switch (SCM_TYP7 (obj
))
88 result
= sizeof (long);
92 result
= sizeof (char);
96 result
= sizeof (short);
99 #ifdef HAVE_LONG_LONGS
101 result
= sizeof (long_long
);
108 result
= sizeof (float);
113 result
= sizeof (double);
117 result
= 2 * sizeof (double);
140 SCM_SETCAR (z
, scm_tc_flo
);
150 scm_make_uve (k
, prot
)
156 if (SCM_BOOL_T
== prot
)
158 i
= sizeof (long) * ((k
+ SCM_LONG_BIT
- 1) / SCM_LONG_BIT
);
159 type
= scm_tc7_bvect
;
161 else if (SCM_ICHRP (prot
) && (prot
== SCM_MAKICHR ('\0')))
163 i
= sizeof (char) * k
;
164 type
= scm_tc7_byvect
;
166 else if (SCM_ICHRP (prot
))
168 i
= sizeof (char) * k
;
169 type
= scm_tc7_string
;
171 else if (SCM_INUMP (prot
))
173 i
= sizeof (long) * k
;
174 if (SCM_INUM (prot
) > 0)
175 type
= scm_tc7_uvect
;
177 type
= scm_tc7_ivect
;
179 else if (SCM_NIMP (prot
) && SCM_SYMBOLP (prot
) && (1 == SCM_LENGTH (prot
)))
183 s
= SCM_CHARS (prot
)[0];
186 i
= sizeof (short) * k
;
187 type
= scm_tc7_svect
;
189 #ifdef HAVE_LONG_LONGS
192 i
= sizeof (long_long
) * k
;
193 type
= scm_tc7_llvect
;
198 return scm_make_vector (SCM_MAKINUM (k
), SCM_UNDEFINED
);
203 if (SCM_IMP (prot
) || !SCM_INEXP (prot
))
205 /* Huge non-unif vectors are NOT supported. */
206 /* no special scm_vector */
207 return scm_make_vector (SCM_MAKINUM (k
), SCM_UNDEFINED
);
210 else if (SCM_SINGP (prot
))
213 i
= sizeof (float) * k
;
214 type
= scm_tc7_fvect
;
217 else if (SCM_CPLXP (prot
))
219 i
= 2 * sizeof (double) * k
;
220 type
= scm_tc7_cvect
;
224 i
= sizeof (double) * k
;
225 type
= scm_tc7_dvect
;
231 SCM_SETCHARS (v
, (char *) scm_must_malloc (i
? i
: 1, "vector"));
232 SCM_SETLENGTH (v
, (k
< SCM_LENGTH_MAX
? k
: SCM_LENGTH_MAX
), type
);
237 SCM_PROC(s_uniform_vector_length
, "uniform-vector-length", 1, 0, 0, scm_uniform_vector_length
);
240 scm_uniform_vector_length (v
)
243 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
248 badarg1
:scm_wta (v
, (char *) SCM_ARG1
, s_uniform_vector_length
);
260 #ifdef HAVE_LONG_LONGS
263 return SCM_MAKINUM (SCM_LENGTH (v
));
267 SCM_PROC(s_array_p
, "array?", 1, 1, 0, scm_array_p
);
270 scm_array_p (v
, prot
)
276 nprot
= SCM_UNBNDP (prot
);
281 switch (SCM_TYP7 (v
))
293 return nprot
|| SCM_BOOL_T
==prot
? SCM_BOOL_T
: SCM_BOOL_F
;
295 return nprot
|| (SCM_ICHRP(prot
) && (prot
!= SCM_MAKICHR('\0'))) ? SCM_BOOL_T
: SCM_BOOL_F
;
297 return nprot
|| (prot
== SCM_MAKICHR('\0')) ? SCM_BOOL_T
: SCM_BOOL_F
;
299 return nprot
|| (SCM_INUMP(prot
) && SCM_INUM(prot
)>0) ? SCM_BOOL_T
: SCM_BOOL_F
;
301 return nprot
|| (SCM_INUMP(prot
) && SCM_INUM(prot
)<=0) ? SCM_BOOL_T
: SCM_BOOL_F
;
305 && SCM_SYMBOLP (prot
)
306 && (1 == SCM_LENGTH (prot
))
307 && ('s' == SCM_CHARS (prot
)[0])));
308 #ifdef HAVE_LONG_LONGS
312 && SCM_SYMBOLP (prot
)
313 && (1 == SCM_LENGTH (prot
))
314 && ('s' == SCM_CHARS (prot
)[0])));
319 return nprot
|| (SCM_NIMP(prot
) && SCM_SINGP(prot
)) ? SCM_BOOL_T
: SCM_BOOL_F
;
322 return nprot
|| (SCM_NIMP(prot
) && SCM_REALP(prot
)) ? SCM_BOOL_T
: SCM_BOOL_F
;
324 return nprot
|| (SCM_NIMP(prot
) && SCM_CPLXP(prot
)) ? SCM_BOOL_T
: SCM_BOOL_F
;
328 return nprot
|| SCM_NULLP(prot
) ? SCM_BOOL_T
: SCM_BOOL_F
;
335 SCM_PROC(s_array_rank
, "array-rank", 1, 0, 0, scm_array_rank
);
343 switch (SCM_TYP7 (ra
))
356 #ifdef HAVE_LONG_LONGS
360 return SCM_MAKINUM (1L);
363 return SCM_MAKINUM (SCM_ARRAY_NDIM (ra
));
369 SCM_PROC(s_array_dimensions
, "array-dimensions", 1, 0, 0, scm_array_dimensions
);
372 scm_array_dimensions (ra
)
380 switch (SCM_TYP7 (ra
))
395 #ifdef HAVE_LONG_LONGS
398 return scm_cons (SCM_MAKINUM (SCM_LENGTH (ra
)), SCM_EOL
);
400 if (!SCM_ARRAYP (ra
))
402 k
= SCM_ARRAY_NDIM (ra
);
403 s
= SCM_ARRAY_DIMS (ra
);
405 res
= scm_cons (s
[k
].lbnd
? scm_cons2 (SCM_MAKINUM (s
[k
].lbnd
), SCM_MAKINUM (s
[k
].ubnd
), SCM_EOL
) :
406 SCM_MAKINUM (1 + (s
[k
].ubnd
))
413 static char s_bad_ind
[] = "Bad scm_array index";
417 scm_aind (ra
, args
, what
)
424 register scm_sizet pos
= SCM_ARRAY_BASE (ra
);
425 register scm_sizet k
= SCM_ARRAY_NDIM (ra
);
426 scm_array_dim
*s
= SCM_ARRAY_DIMS (ra
);
427 if (SCM_INUMP (args
))
429 SCM_ASSERT (1 == k
, scm_makfrom0str (what
), SCM_WNA
, NULL
);
430 return pos
+ (SCM_INUM (args
) - s
->lbnd
) * (s
->inc
);
432 while (k
&& SCM_NIMP (args
))
434 ind
= SCM_CAR (args
);
435 args
= SCM_CDR (args
);
436 SCM_ASSERT (SCM_INUMP (ind
), ind
, s_bad_ind
, what
);
438 SCM_ASSERT (j
>= (s
->lbnd
) && j
<= (s
->ubnd
), ind
, SCM_OUTOFRANGE
, what
);
439 pos
+= (j
- s
->lbnd
) * (s
->inc
);
443 SCM_ASSERT (0 == k
&& SCM_NULLP (args
), scm_makfrom0str (what
), SCM_WNA
,
457 SCM_NEWSMOB(ra
, ((long) ndim
<< 17) + scm_tc16_array
,
458 scm_must_malloc ((long) (sizeof (scm_array
) + ndim
* sizeof (scm_array_dim
)),
460 SCM_ARRAY_V (ra
) = scm_nullvect
;
465 static char s_bad_spec
[] = "Bad scm_array dimension";
466 /* Increments will still need to be set. */
470 scm_shap2ra (args
, what
)
476 int ndim
= scm_ilength (args
);
477 SCM_ASSERT (0 <= ndim
, args
, s_bad_spec
, what
);
478 ra
= scm_make_ra (ndim
);
479 SCM_ARRAY_BASE (ra
) = 0;
480 s
= SCM_ARRAY_DIMS (ra
);
481 for (; SCM_NIMP (args
); s
++, args
= SCM_CDR (args
))
483 spec
= SCM_CAR (args
);
487 SCM_ASSERT (SCM_INUMP (spec
) && SCM_INUM (spec
) >= 0, spec
,
490 s
->ubnd
= SCM_INUM (spec
) - 1;
495 SCM_ASSERT (SCM_CONSP (spec
) && SCM_INUMP (SCM_CAR (spec
)), spec
,
497 s
->lbnd
= SCM_INUM (SCM_CAR (spec
));
499 SCM_ASSERT (SCM_NIMP (sp
) && SCM_CONSP (sp
)
500 && SCM_INUMP (SCM_CAR (sp
)) && SCM_NULLP (SCM_CDR (sp
)),
501 spec
, s_bad_spec
, what
);
502 s
->ubnd
= SCM_INUM (SCM_CAR (sp
));
509 SCM_PROC(s_dimensions_to_uniform_array
, "dimensions->uniform-array", 2, 1, 0, scm_dimensions_to_uniform_array
);
512 scm_dimensions_to_uniform_array (dims
, prot
, fill
)
517 scm_sizet k
, vlen
= 1;
521 if (SCM_INUMP (dims
))
523 if (SCM_INUM (dims
) < SCM_LENGTH_MAX
)
525 SCM answer
= scm_make_uve (SCM_INUM (dims
), prot
);
527 if (!SCM_UNBNDP (fill
))
528 scm_array_fill_x (answer
, fill
);
529 else if (SCM_NIMP (prot
) && SCM_SYMBOLP (prot
))
530 scm_array_fill_x (answer
, SCM_MAKINUM (0));
532 scm_array_fill_x (answer
, prot
);
536 dims
= scm_cons (dims
, SCM_EOL
);
538 SCM_ASSERT (SCM_NULLP (dims
) || (SCM_NIMP (dims
) && SCM_CONSP (dims
)),
539 dims
, SCM_ARG1
, s_dimensions_to_uniform_array
);
540 ra
= scm_shap2ra (dims
, s_dimensions_to_uniform_array
);
541 SCM_SETOR_CAR (ra
, SCM_ARRAY_CONTIGUOUS
);
542 s
= SCM_ARRAY_DIMS (ra
);
543 k
= SCM_ARRAY_NDIM (ra
);
546 s
[k
].inc
= (rlen
> 0 ? rlen
: 0);
547 rlen
= (s
[k
].ubnd
- s
[k
].lbnd
+ 1) * s
[k
].inc
;
548 vlen
*= (s
[k
].ubnd
- s
[k
].lbnd
+ 1);
550 if (rlen
< SCM_LENGTH_MAX
)
551 SCM_ARRAY_V (ra
) = scm_make_uve ((rlen
> 0 ? rlen
: 0L), prot
);
555 switch (SCM_TYP7 (scm_make_uve (0L, prot
)))
567 bit
= sizeof (float) * SCM_CHAR_BIT
/ sizeof (char);
570 bit
= sizeof (double) * SCM_CHAR_BIT
/ sizeof (char);
573 bit
= 2 * sizeof (double) * SCM_CHAR_BIT
/ sizeof (char);
576 SCM_ARRAY_BASE (ra
) = (SCM_LONG_BIT
+ bit
- 1) / bit
;
577 rlen
+= SCM_ARRAY_BASE (ra
);
578 SCM_ARRAY_V (ra
) = scm_make_uve (rlen
, prot
);
579 *((long *) SCM_VELTS (SCM_ARRAY_V (ra
))) = rlen
;
581 if (!SCM_UNBNDP (fill
))
583 scm_array_fill_x (ra
, fill
);
585 else if (SCM_NIMP (prot
) && SCM_SYMBOLP (prot
))
586 scm_array_fill_x (ra
, SCM_MAKINUM (0));
588 scm_array_fill_x (ra
, prot
);
589 if (1 == SCM_ARRAY_NDIM (ra
) && 0 == SCM_ARRAY_BASE (ra
))
590 if (s
->ubnd
< s
->lbnd
|| (0 == s
->lbnd
&& 1 == s
->inc
))
591 return SCM_ARRAY_V (ra
);
597 scm_ra_set_contp (ra
)
600 scm_sizet k
= SCM_ARRAY_NDIM (ra
);
603 long inc
= SCM_ARRAY_DIMS (ra
)[k
- 1].inc
;
606 if (inc
!= SCM_ARRAY_DIMS (ra
)[k
].inc
)
608 SCM_SETAND_CAR (ra
, ~SCM_ARRAY_CONTIGUOUS
);
611 inc
*= (SCM_ARRAY_DIMS (ra
)[k
].ubnd
612 - SCM_ARRAY_DIMS (ra
)[k
].lbnd
+ 1);
615 SCM_SETOR_CAR (ra
, SCM_ARRAY_CONTIGUOUS
);
619 SCM_PROC(s_make_shared_array
, "make-shared-array", 2, 0, 1, scm_make_shared_array
);
622 scm_make_shared_array (oldra
, mapfunc
, dims
)
631 long old_min
, new_min
, old_max
, new_max
;
633 SCM_ASSERT (SCM_BOOL_T
== scm_procedure_p (mapfunc
), mapfunc
, SCM_ARG2
, s_make_shared_array
);
634 SCM_ASSERT (SCM_NIMP (oldra
) && (SCM_BOOL_F
!= scm_array_p (oldra
, SCM_UNDEFINED
)), oldra
, SCM_ARG1
, s_make_shared_array
);
635 ra
= scm_shap2ra (dims
, s_make_shared_array
);
636 if (SCM_ARRAYP (oldra
))
638 SCM_ARRAY_V (ra
) = SCM_ARRAY_V (oldra
);
639 old_min
= old_max
= SCM_ARRAY_BASE (oldra
);
640 s
= SCM_ARRAY_DIMS (oldra
);
641 k
= SCM_ARRAY_NDIM (oldra
);
645 old_max
+= (s
[k
].ubnd
- s
[k
].lbnd
) * s
[k
].inc
;
647 old_min
+= (s
[k
].ubnd
- s
[k
].lbnd
) * s
[k
].inc
;
652 SCM_ARRAY_V (ra
) = oldra
;
654 old_max
= (long) SCM_LENGTH (oldra
) - 1;
657 s
= SCM_ARRAY_DIMS (ra
);
658 for (k
= 0; k
< SCM_ARRAY_NDIM (ra
); k
++)
660 inds
= scm_cons (SCM_MAKINUM (s
[k
].lbnd
), inds
);
661 if (s
[k
].ubnd
< s
[k
].lbnd
)
663 if (1 == SCM_ARRAY_NDIM (ra
))
664 ra
= scm_make_uve (0L, scm_array_prototype (ra
));
666 SCM_ARRAY_V (ra
) = scm_make_uve (0L, scm_array_prototype (ra
));
670 imap
= scm_apply (mapfunc
, scm_reverse (inds
), SCM_EOL
);
671 if (SCM_ARRAYP (oldra
))
672 i
= (scm_sizet
) scm_aind (oldra
, imap
, s_make_shared_array
);
675 if (SCM_NINUMP (imap
))
678 SCM_ASSERT (1 == scm_ilength (imap
) && SCM_INUMP (SCM_CAR (imap
)),
679 imap
, s_bad_ind
, s_make_shared_array
);
680 imap
= SCM_CAR (imap
);
684 SCM_ARRAY_BASE (ra
) = new_min
= new_max
= i
;
686 k
= SCM_ARRAY_NDIM (ra
);
689 if (s
[k
].ubnd
> s
[k
].lbnd
)
691 SCM_SETCAR (indptr
, SCM_MAKINUM (SCM_INUM (SCM_CAR (indptr
)) + 1));
692 imap
= scm_apply (mapfunc
, scm_reverse (inds
), SCM_EOL
);
693 if (SCM_ARRAYP (oldra
))
695 s
[k
].inc
= scm_aind (oldra
, imap
, s_make_shared_array
) - i
;
698 if (SCM_NINUMP (imap
))
701 SCM_ASSERT (1 == scm_ilength (imap
) && SCM_INUMP (SCM_CAR (imap
)),
702 imap
, s_bad_ind
, s_make_shared_array
);
703 imap
= SCM_CAR (imap
);
705 s
[k
].inc
= (long) SCM_INUM (imap
) - i
;
709 new_max
+= (s
[k
].ubnd
- s
[k
].lbnd
) * s
[k
].inc
;
711 new_min
+= (s
[k
].ubnd
- s
[k
].lbnd
) * s
[k
].inc
;
714 s
[k
].inc
= new_max
- new_min
+ 1; /* contiguous by default */
715 indptr
= SCM_CDR (indptr
);
717 SCM_ASSERT (old_min
<= new_min
&& old_max
>= new_max
, SCM_UNDEFINED
,
718 "mapping out of range", s_make_shared_array
);
719 if (1 == SCM_ARRAY_NDIM (ra
) && 0 == SCM_ARRAY_BASE (ra
))
721 if (1 == s
->inc
&& 0 == s
->lbnd
722 && SCM_LENGTH (SCM_ARRAY_V (ra
)) == 1 + s
->ubnd
)
723 return SCM_ARRAY_V (ra
);
724 if (s
->ubnd
< s
->lbnd
)
725 return scm_make_uve (0L, scm_array_prototype (ra
));
727 scm_ra_set_contp (ra
);
732 /* args are RA . DIMS */
733 SCM_PROC(s_transpose_array
, "transpose-array", 0, 0, 1, scm_transpose_array
);
736 scm_transpose_array (args
)
739 SCM ra
, res
, vargs
, *ve
= &vargs
;
740 scm_array_dim
*s
, *r
;
742 SCM_ASSERT (SCM_NNULLP (args
), scm_makfrom0str (s_transpose_array
),
745 SCM_ASSERT (SCM_NIMP (ra
), ra
, SCM_ARG1
, s_transpose_array
);
746 args
= SCM_CDR (args
);
747 switch (SCM_TYP7 (ra
))
750 badarg
:scm_wta (ra
, (char *) SCM_ARG1
, s_transpose_array
);
760 #ifdef HAVE_LONG_LONGS
763 SCM_ASSERT (SCM_NIMP (args
) && SCM_NULLP (SCM_CDR (args
)),
764 scm_makfrom0str (s_transpose_array
), SCM_WNA
, NULL
);
765 SCM_ASSERT (SCM_INUMP (SCM_CAR (args
)), SCM_CAR (args
), SCM_ARG2
,
767 SCM_ASSERT (SCM_INUM0
== SCM_CAR (args
), SCM_CAR (args
), SCM_OUTOFRANGE
,
771 SCM_ASRTGO (SCM_ARRAYP (ra
), badarg
);
772 vargs
= scm_vector (args
);
773 SCM_ASSERT (SCM_LENGTH (vargs
) == SCM_ARRAY_NDIM (ra
),
774 scm_makfrom0str (s_transpose_array
), SCM_WNA
, NULL
);
775 ve
= SCM_VELTS (vargs
);
777 for (k
= 0; k
< SCM_ARRAY_NDIM (ra
); k
++)
779 SCM_ASSERT (SCM_INUMP (ve
[k
]), ve
[k
], (SCM_ARG2
+ k
),
781 i
= SCM_INUM (ve
[k
]);
782 SCM_ASSERT (i
>= 0 && i
< SCM_ARRAY_NDIM (ra
), ve
[k
],
783 SCM_OUTOFRANGE
, s_transpose_array
);
788 res
= scm_make_ra (ndim
);
789 SCM_ARRAY_V (res
) = SCM_ARRAY_V (ra
);
790 SCM_ARRAY_BASE (res
) = SCM_ARRAY_BASE (ra
);
793 SCM_ARRAY_DIMS (res
)[k
].lbnd
= 0;
794 SCM_ARRAY_DIMS (res
)[k
].ubnd
= -1;
796 for (k
= SCM_ARRAY_NDIM (ra
); k
--;)
798 i
= SCM_INUM (ve
[k
]);
799 s
= &(SCM_ARRAY_DIMS (ra
)[k
]);
800 r
= &(SCM_ARRAY_DIMS (res
)[i
]);
801 if (r
->ubnd
< r
->lbnd
)
810 if (r
->ubnd
> s
->ubnd
)
812 if (r
->lbnd
< s
->lbnd
)
814 SCM_ARRAY_BASE (res
) += (s
->lbnd
- r
->lbnd
) * r
->inc
;
820 SCM_ASSERT (ndim
<= 0, args
, "bad argument list", s_transpose_array
);
821 scm_ra_set_contp (res
);
826 /* args are RA . AXES */
827 SCM_PROC(s_enclose_array
, "enclose-array", 0, 0, 1, scm_enclose_array
);
830 scm_enclose_array (axes
)
833 SCM axv
, ra
, res
, ra_inr
;
834 scm_array_dim vdim
, *s
= &vdim
;
835 int ndim
, j
, k
, ninr
, noutr
;
836 SCM_ASSERT (SCM_NIMP (axes
), scm_makfrom0str (s_enclose_array
), SCM_WNA
,
839 axes
= SCM_CDR (axes
);
840 if (SCM_NULLP (axes
))
842 axes
= scm_cons ((SCM_ARRAYP (ra
) ? SCM_MAKINUM (SCM_ARRAY_NDIM (ra
) - 1) : SCM_INUM0
), SCM_EOL
);
843 ninr
= scm_ilength (axes
);
844 ra_inr
= scm_make_ra (ninr
);
845 SCM_ASRTGO (SCM_NIMP (ra
), badarg1
);
850 badarg1
:scm_wta (ra
, (char *) SCM_ARG1
, s_enclose_array
);
862 #ifdef HAVE_LONG_LONGS
866 s
->ubnd
= SCM_LENGTH (ra
) - 1;
868 SCM_ARRAY_V (ra_inr
) = ra
;
869 SCM_ARRAY_BASE (ra_inr
) = 0;
873 SCM_ASRTGO (SCM_ARRAYP (ra
), badarg1
);
874 s
= SCM_ARRAY_DIMS (ra
);
875 SCM_ARRAY_V (ra_inr
) = SCM_ARRAY_V (ra
);
876 SCM_ARRAY_BASE (ra_inr
) = SCM_ARRAY_BASE (ra
);
877 ndim
= SCM_ARRAY_NDIM (ra
);
881 axv
= scm_make_string (SCM_MAKINUM (ndim
), SCM_MAKICHR (0));
882 SCM_ASSERT (0 <= noutr
&& 0 <= ninr
, scm_makfrom0str (s_enclose_array
),
884 res
= scm_make_ra (noutr
);
885 SCM_ARRAY_BASE (res
) = SCM_ARRAY_BASE (ra_inr
);
886 SCM_ARRAY_V (res
) = ra_inr
;
887 for (k
= 0; k
< ninr
; k
++, axes
= SCM_CDR (axes
))
889 SCM_ASSERT (SCM_INUMP (SCM_CAR (axes
)), SCM_CAR (axes
), "bad axis", s_enclose_array
);
890 j
= SCM_INUM (SCM_CAR (axes
));
891 SCM_ARRAY_DIMS (ra_inr
)[k
].lbnd
= s
[j
].lbnd
;
892 SCM_ARRAY_DIMS (ra_inr
)[k
].ubnd
= s
[j
].ubnd
;
893 SCM_ARRAY_DIMS (ra_inr
)[k
].inc
= s
[j
].inc
;
894 SCM_CHARS (axv
)[j
] = 1;
896 for (j
= 0, k
= 0; k
< noutr
; k
++, j
++)
898 while (SCM_CHARS (axv
)[j
])
900 SCM_ARRAY_DIMS (res
)[k
].lbnd
= s
[j
].lbnd
;
901 SCM_ARRAY_DIMS (res
)[k
].ubnd
= s
[j
].ubnd
;
902 SCM_ARRAY_DIMS (res
)[k
].inc
= s
[j
].inc
;
904 scm_ra_set_contp (ra_inr
);
905 scm_ra_set_contp (res
);
911 SCM_PROC(s_array_in_bounds_p
, "array-in-bounds?", 0, 0, 1, scm_array_in_bounds_p
);
914 scm_array_in_bounds_p (args
)
917 SCM v
, ind
= SCM_EOL
;
919 register scm_sizet k
;
922 SCM_ASSERT (SCM_NIMP (args
), scm_makfrom0str (s_array_in_bounds_p
),
925 args
= SCM_CDR (args
);
926 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
930 ind
= SCM_CAR (args
);
931 args
= SCM_CDR (args
);
932 SCM_ASSERT (SCM_INUMP (ind
), ind
, SCM_ARG2
, s_array_in_bounds_p
);
933 pos
= SCM_INUM (ind
);
940 badarg1
:scm_wta (v
, (char *) SCM_ARG1
, s_array_in_bounds_p
);
941 wna
: scm_wrong_num_args (scm_makfrom0str (s_array_in_bounds_p
));
943 k
= SCM_ARRAY_NDIM (v
);
944 s
= SCM_ARRAY_DIMS (v
);
945 pos
= SCM_ARRAY_BASE (v
);
948 SCM_ASRTGO (SCM_NULLP (ind
), wna
);
955 if (!(j
>= (s
->lbnd
) && j
<= (s
->ubnd
)))
957 SCM_ASRTGO (--k
== scm_ilength (args
), wna
);
960 pos
+= (j
- s
->lbnd
) * (s
->inc
);
961 if (!(--k
&& SCM_NIMP (args
)))
963 ind
= SCM_CAR (args
);
964 args
= SCM_CDR (args
);
966 SCM_ASSERT (SCM_INUMP (ind
), ind
, s_bad_ind
, s_array_in_bounds_p
);
968 SCM_ASRTGO (0 == k
, wna
);
980 #ifdef HAVE_LONG_LONGS
985 SCM_ASRTGO (SCM_NULLP (args
) && SCM_INUMP (ind
), wna
);
986 return pos
>= 0 && pos
< SCM_LENGTH (v
) ? SCM_BOOL_T
: SCM_BOOL_F
;
991 SCM_PROC(s_array_ref
, "array-ref", 1, 0, 1, scm_uniform_vector_ref
);
992 SCM_PROC(s_uniform_vector_ref
, "uniform-vector-ref", 2, 0, 0, scm_uniform_vector_ref
);
995 scm_uniform_vector_ref (v
, args
)
1003 SCM_ASRTGO (SCM_NULLP (args
), badarg
);
1006 else if (SCM_ARRAYP (v
))
1008 pos
= scm_aind (v
, args
, s_uniform_vector_ref
);
1009 v
= SCM_ARRAY_V (v
);
1013 if (SCM_NIMP (args
))
1016 SCM_ASSERT (SCM_CONSP (args
) && SCM_INUMP (SCM_CAR (args
)), args
, SCM_ARG2
, s_uniform_vector_ref
);
1017 pos
= SCM_INUM (SCM_CAR (args
));
1018 SCM_ASRTGO (SCM_NULLP (SCM_CDR (args
)), wna
);
1022 SCM_ASSERT (SCM_INUMP (args
), args
, SCM_ARG2
, s_uniform_vector_ref
);
1023 pos
= SCM_INUM (args
);
1025 SCM_ASRTGO (pos
>= 0 && pos
< SCM_LENGTH (v
), outrng
);
1031 if (SCM_NULLP (args
))
1034 scm_wta (v
, (char *) SCM_ARG1
, s_uniform_vector_ref
);
1036 outrng
:scm_out_of_range (s_uniform_vector_ref
, SCM_MAKINUM (pos
));
1037 wna
: scm_wrong_num_args (scm_makfrom0str (s_uniform_vector_ref
));
1040 int k
= SCM_ARRAY_NDIM (v
);
1041 SCM res
= scm_make_ra (k
);
1042 SCM_ARRAY_V (res
) = SCM_ARRAY_V (v
);
1043 SCM_ARRAY_BASE (res
) = pos
;
1046 SCM_ARRAY_DIMS (res
)[k
].lbnd
= SCM_ARRAY_DIMS (v
)[k
].lbnd
;
1047 SCM_ARRAY_DIMS (res
)[k
].ubnd
= SCM_ARRAY_DIMS (v
)[k
].ubnd
;
1048 SCM_ARRAY_DIMS (res
)[k
].inc
= SCM_ARRAY_DIMS (v
)[k
].inc
;
1053 if (SCM_VELTS (v
)[pos
/ SCM_LONG_BIT
] & (1L << (pos
% SCM_LONG_BIT
)))
1057 case scm_tc7_string
:
1058 return SCM_MAKICHR (SCM_UCHARS (v
)[pos
]);
1059 case scm_tc7_byvect
:
1060 return SCM_MAKINUM (((char *)SCM_CHARS (v
))[pos
]);
1061 # ifdef SCM_INUMS_ONLY
1064 return SCM_MAKINUM (SCM_VELTS (v
)[pos
]);
1067 return scm_ulong2num(SCM_VELTS(v
)[pos
]);
1069 return scm_long2num(SCM_VELTS(v
)[pos
]);
1073 return SCM_MAKINUM (((short *) SCM_CDR (v
))[pos
]);
1074 #ifdef HAVE_LONG_LONGS
1075 case scm_tc7_llvect
:
1076 return scm_long_long2num (((long_long
*) SCM_CDR (v
))[pos
]);
1082 return scm_makflo (((float *) SCM_CDR (v
))[pos
]);
1085 return scm_makdbl (((double *) SCM_CDR (v
))[pos
], 0.0);
1087 return scm_makdbl (((double *) SCM_CDR (v
))[2 * pos
],
1088 ((double *) SCM_CDR (v
))[2 * pos
+ 1]);
1090 case scm_tc7_vector
:
1092 return SCM_VELTS (v
)[pos
];
1096 /* Internal version of scm_uniform_vector_ref for uves that does no error checking and
1097 tries to recycle conses. (Make *sure* you want them recycled.) */
1100 scm_cvref (v
, pos
, last
)
1108 scm_wta (v
, (char *) SCM_ARG1
, "PROGRAMMING ERROR: scm_cvref");
1110 if (SCM_VELTS (v
)[pos
/ SCM_LONG_BIT
] & (1L << (pos
% SCM_LONG_BIT
)))
1114 case scm_tc7_string
:
1115 return SCM_MAKICHR (SCM_UCHARS (v
)[pos
]);
1116 case scm_tc7_byvect
:
1117 return SCM_MAKINUM (((char *)SCM_CHARS (v
))[pos
]);
1118 # ifdef SCM_INUMS_ONLY
1121 return SCM_MAKINUM (SCM_VELTS (v
)[pos
]);
1124 return scm_ulong2num(SCM_VELTS(v
)[pos
]);
1126 return scm_long2num(SCM_VELTS(v
)[pos
]);
1129 return SCM_MAKINUM (((short *) SCM_CDR (v
))[pos
]);
1130 #ifdef HAVE_LONG_LONGS
1131 case scm_tc7_llvect
:
1132 return scm_long_long2num (((long_long
*) SCM_CDR (v
))[pos
]);
1137 if (SCM_NIMP (last
) && (last
!= scm_flo0
) && (scm_tc_flo
== SCM_CAR (last
)))
1139 SCM_FLO (last
) = ((float *) SCM_CDR (v
))[pos
];
1142 return scm_makflo (((float *) SCM_CDR (v
))[pos
]);
1146 if (SCM_NIMP (last
) && scm_tc_dblr
== SCM_CAR (last
))
1148 if (SCM_NIMP (last
) && (last
!= scm_flo0
) && (scm_tc_dblr
== SCM_CAR (last
)))
1151 SCM_REAL (last
) = ((double *) SCM_CDR (v
))[pos
];
1154 return scm_makdbl (((double *) SCM_CDR (v
))[pos
], 0.0);
1156 if (SCM_NIMP (last
) && scm_tc_dblc
== SCM_CAR (last
))
1158 SCM_REAL (last
) = ((double *) SCM_CDR (v
))[2 * pos
];
1159 SCM_IMAG (last
) = ((double *) SCM_CDR (v
))[2 * pos
+ 1];
1162 return scm_makdbl (((double *) SCM_CDR (v
))[2 * pos
],
1163 ((double *) SCM_CDR (v
))[2 * pos
+ 1]);
1165 case scm_tc7_vector
:
1167 return SCM_VELTS (v
)[pos
];
1169 { /* enclosed scm_array */
1170 int k
= SCM_ARRAY_NDIM (v
);
1171 SCM res
= scm_make_ra (k
);
1172 SCM_ARRAY_V (res
) = SCM_ARRAY_V (v
);
1173 SCM_ARRAY_BASE (res
) = pos
;
1176 SCM_ARRAY_DIMS (res
)[k
].ubnd
= SCM_ARRAY_DIMS (v
)[k
].ubnd
;
1177 SCM_ARRAY_DIMS (res
)[k
].lbnd
= SCM_ARRAY_DIMS (v
)[k
].lbnd
;
1178 SCM_ARRAY_DIMS (res
)[k
].inc
= SCM_ARRAY_DIMS (v
)[k
].inc
;
1185 SCM_PROC(s_uniform_array_set1_x
, "uniform-array-set1!", 3, 0, 0, scm_array_set_x
);
1186 SCM_PROC(s_array_set_x
, "array-set!", 2, 0, 1, scm_array_set_x
);
1188 /* Note that args may be a list or an immediate object, depending which
1189 PROC is used (and it's called from C too). */
1191 scm_array_set_x (v
, obj
, args
)
1197 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
1200 pos
= scm_aind (v
, args
, s_array_set_x
);
1201 v
= SCM_ARRAY_V (v
);
1205 if (SCM_NIMP (args
))
1207 SCM_ASSERT (SCM_CONSP(args
) && SCM_INUMP (SCM_CAR (args
)), args
,
1208 SCM_ARG3
, s_array_set_x
);
1209 SCM_ASRTGO (SCM_NULLP (SCM_CDR (args
)), wna
);
1210 pos
= SCM_INUM (SCM_CAR (args
));
1214 SCM_ASSERT (SCM_INUMP (args
), args
, SCM_ARG3
, s_array_set_x
);
1215 pos
= SCM_INUM (args
);
1217 SCM_ASRTGO (pos
>= 0 && pos
< SCM_LENGTH (v
), outrng
);
1219 switch (SCM_TYP7 (v
))
1222 scm_wta (v
, (char *) SCM_ARG1
, s_array_set_x
);
1224 outrng
:scm_out_of_range (s_array_set_x
, SCM_MAKINUM (pos
));
1225 wna
: scm_wrong_num_args (scm_makfrom0str (s_array_set_x
));
1226 case scm_tc7_smob
: /* enclosed */
1229 if (SCM_BOOL_F
== obj
)
1230 SCM_VELTS (v
)[pos
/ SCM_LONG_BIT
] &= ~(1L << (pos
% SCM_LONG_BIT
));
1231 else if (SCM_BOOL_T
== obj
)
1232 SCM_VELTS (v
)[pos
/ SCM_LONG_BIT
] |= (1L << (pos
% SCM_LONG_BIT
));
1234 badobj
:scm_wta (obj
, (char *) SCM_ARG2
, s_array_set_x
);
1236 case scm_tc7_string
:
1237 SCM_ASRTGO (SCM_ICHRP (obj
), badobj
);
1238 SCM_UCHARS (v
)[pos
] = SCM_ICHR (obj
);
1240 case scm_tc7_byvect
:
1241 if (SCM_ICHRP (obj
))
1242 obj
= SCM_MAKINUM ((char) SCM_ICHR (obj
));
1243 SCM_ASRTGO (SCM_INUMP (obj
), badobj
);
1244 ((char *)SCM_CHARS (v
))[pos
] = SCM_INUM (obj
);
1246 # ifdef SCM_INUMS_ONLY
1248 SCM_ASRTGO (SCM_INUM (obj
) >= 0, badobj
);
1250 SCM_ASRTGO(SCM_INUMP(obj
), badobj
); SCM_VELTS(v
)[pos
] = SCM_INUM(obj
); break;
1253 SCM_VELTS(v
)[pos
] = scm_num2ulong(obj
, (char *)SCM_ARG2
, s_array_set_x
); break;
1255 SCM_VELTS(v
)[pos
] = scm_num2long(obj
, (char *)SCM_ARG2
, s_array_set_x
); break;
1260 SCM_ASRTGO (SCM_INUMP (obj
), badobj
);
1261 ((short *) SCM_CDR (v
))[pos
] = SCM_INUM (obj
);
1263 #ifdef HAVE_LONG_LONGS
1264 case scm_tc7_llvect
:
1265 ((long_long
*) SCM_CDR (v
))[pos
] = scm_num2long_long (obj
, (char *)SCM_ARG2
, s_array_set_x
);
1273 ((float *) SCM_CDR (v
))[pos
] = (float)scm_num2dbl(obj
, s_array_set_x
); break;
1277 ((double *) SCM_CDR (v
))[pos
] = scm_num2dbl(obj
, s_array_set_x
); break;
1280 SCM_ASRTGO (SCM_NIMP (obj
) && SCM_INEXP (obj
), badobj
);
1281 ((double *) SCM_CDR (v
))[2 * pos
] = SCM_REALPART (obj
);
1282 ((double *) SCM_CDR (v
))[2 * pos
+ 1] = SCM_CPLXP (obj
) ? SCM_IMAG (obj
) : 0.0;
1285 case scm_tc7_vector
:
1287 SCM_VELTS (v
)[pos
] = obj
;
1290 return SCM_UNSPECIFIED
;
1293 /* attempts to unroll an array into a one-dimensional array.
1294 returns the unrolled array or #f if it can't be done. */
1295 SCM_PROC(s_array_contents
, "array-contents", 1, 1, 0, scm_array_contents
);
1298 scm_array_contents (ra
, strict
)
1300 SCM strict
; /* if not SCM_UNDEFINED, return #f if returned array
1301 wouldn't have contiguous elements. */
1306 switch SCM_TYP7 (ra
)
1310 case scm_tc7_vector
:
1312 case scm_tc7_string
:
1314 case scm_tc7_byvect
:
1321 #ifdef HAVE_LONG_LONGS
1322 case scm_tc7_llvect
:
1327 scm_sizet k
, ndim
= SCM_ARRAY_NDIM (ra
), len
= 1;
1328 if (!SCM_ARRAYP (ra
) || !SCM_ARRAY_CONTP (ra
))
1330 for (k
= 0; k
< ndim
; k
++)
1331 len
*= SCM_ARRAY_DIMS (ra
)[k
].ubnd
- SCM_ARRAY_DIMS (ra
)[k
].lbnd
+ 1;
1332 if (!SCM_UNBNDP (strict
))
1334 if (ndim
&& (1 != SCM_ARRAY_DIMS (ra
)[ndim
- 1].inc
))
1336 if (scm_tc7_bvect
== SCM_TYP7 (SCM_ARRAY_V (ra
)))
1338 if (len
!= SCM_LENGTH (SCM_ARRAY_V (ra
)) ||
1339 SCM_ARRAY_BASE (ra
) % SCM_LONG_BIT
||
1344 if ((len
== SCM_LENGTH (SCM_ARRAY_V (ra
))) && 0 == SCM_ARRAY_BASE (ra
) && SCM_ARRAY_DIMS (ra
)->inc
)
1345 return SCM_ARRAY_V (ra
);
1346 sra
= scm_make_ra (1);
1347 SCM_ARRAY_DIMS (sra
)->lbnd
= 0;
1348 SCM_ARRAY_DIMS (sra
)->ubnd
= len
- 1;
1349 SCM_ARRAY_V (sra
) = SCM_ARRAY_V (ra
);
1350 SCM_ARRAY_BASE (sra
) = SCM_ARRAY_BASE (ra
);
1351 SCM_ARRAY_DIMS (sra
)->inc
= (ndim
? SCM_ARRAY_DIMS (ra
)[ndim
- 1].inc
: 1);
1359 scm_ra2contig (ra
, copy
)
1365 scm_sizet k
, len
= 1;
1366 for (k
= SCM_ARRAY_NDIM (ra
); k
--;)
1367 len
*= SCM_ARRAY_DIMS (ra
)[k
].ubnd
- SCM_ARRAY_DIMS (ra
)[k
].lbnd
+ 1;
1368 k
= SCM_ARRAY_NDIM (ra
);
1369 if (SCM_ARRAY_CONTP (ra
) && ((0 == k
) || (1 == SCM_ARRAY_DIMS (ra
)[k
- 1].inc
)))
1371 if (scm_tc7_bvect
!= SCM_TYP7 (ra
))
1373 if ((len
== SCM_LENGTH (SCM_ARRAY_V (ra
)) &&
1374 0 == SCM_ARRAY_BASE (ra
) % SCM_LONG_BIT
&&
1375 0 == len
% SCM_LONG_BIT
))
1378 ret
= scm_make_ra (k
);
1379 SCM_ARRAY_BASE (ret
) = 0;
1382 SCM_ARRAY_DIMS (ret
)[k
].lbnd
= SCM_ARRAY_DIMS (ra
)[k
].lbnd
;
1383 SCM_ARRAY_DIMS (ret
)[k
].ubnd
= SCM_ARRAY_DIMS (ra
)[k
].ubnd
;
1384 SCM_ARRAY_DIMS (ret
)[k
].inc
= inc
;
1385 inc
*= SCM_ARRAY_DIMS (ra
)[k
].ubnd
- SCM_ARRAY_DIMS (ra
)[k
].lbnd
+ 1;
1387 SCM_ARRAY_V (ret
) = scm_make_uve ((inc
- 1), scm_array_prototype (ra
));
1389 scm_array_copy_x (ra
, ret
);
1395 SCM_PROC(s_uniform_array_read_x
, "uniform-array-read!", 1, 3, 0, scm_uniform_array_read_x
);
1398 scm_uniform_array_read_x (ra
, port_or_fd
, start
, end
)
1404 SCM cra
= SCM_UNDEFINED
, v
= ra
;
1410 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
1411 if (SCM_UNBNDP (port_or_fd
))
1412 port_or_fd
= scm_cur_inp
;
1414 SCM_ASSERT (SCM_INUMP (port_or_fd
)
1415 || (SCM_NIMP (port_or_fd
) && SCM_OPINPORTP (port_or_fd
)),
1416 port_or_fd
, SCM_ARG2
, s_uniform_array_read_x
);
1417 vlen
= SCM_LENGTH (v
);
1423 badarg1
:scm_wta (v
, (char *) SCM_ARG1
, s_uniform_array_read_x
);
1425 SCM_ASRTGO (SCM_ARRAYP (v
), badarg1
);
1426 cra
= scm_ra2contig (ra
, 0);
1427 cstart
+= SCM_ARRAY_BASE (cra
);
1428 vlen
= SCM_ARRAY_DIMS (cra
)->inc
*
1429 (SCM_ARRAY_DIMS (cra
)->ubnd
- SCM_ARRAY_DIMS (cra
)->lbnd
+ 1);
1430 v
= SCM_ARRAY_V (cra
);
1432 case scm_tc7_string
:
1433 case scm_tc7_byvect
:
1437 vlen
= (vlen
+ SCM_LONG_BIT
- 1) / SCM_LONG_BIT
;
1438 cstart
/= SCM_LONG_BIT
;
1444 sz
= sizeof (short);
1446 #ifdef HAVE_LONG_LONGS
1447 case scm_tc7_llvect
:
1448 sz
= sizeof (long_long
);
1454 sz
= sizeof (float);
1458 sz
= sizeof (double);
1461 sz
= 2 * sizeof (double);
1467 if (!SCM_UNBNDP (start
))
1470 scm_num2long (start
, (char *) SCM_ARG3
, s_uniform_array_read_x
);
1472 if (offset
< 0 || offset
>= cend
)
1473 scm_out_of_range (s_uniform_array_read_x
, start
);
1475 if (!SCM_UNBNDP (end
))
1478 scm_num2long (end
, (char *) SCM_ARG4
, s_uniform_array_read_x
);
1480 if (tend
<= offset
|| tend
> cend
)
1481 scm_out_of_range (s_uniform_array_read_x
, end
);
1486 if (SCM_NIMP (port_or_fd
))
1488 scm_port
*pt
= SCM_PTAB_ENTRY (port_or_fd
);
1489 int remaining
= (cend
- offset
) * sz
;
1490 char *dest
= SCM_CHARS (v
) + (cstart
+ offset
) * sz
;
1492 if (pt
->rw_active
== SCM_PORT_WRITE
)
1493 scm_flush (port_or_fd
);
1495 ans
= cend
- offset
;
1496 while (remaining
> 0)
1498 if (pt
->read_pos
< pt
->read_end
)
1500 int to_copy
= min (pt
->read_end
- pt
->read_pos
,
1503 memcpy (dest
, pt
->read_pos
, to_copy
);
1504 pt
->read_pos
+= to_copy
;
1505 remaining
-= to_copy
;
1510 if (scm_fill_input (port_or_fd
) == EOF
)
1512 if (remaining
% sz
!= 0)
1514 scm_misc_error (s_uniform_array_read_x
,
1518 ans
-= remaining
/ sz
;
1525 pt
->rw_active
= SCM_PORT_READ
;
1527 else /* file descriptor. */
1529 SCM_SYSCALL (ans
= read (SCM_INUM (port_or_fd
),
1530 SCM_CHARS (v
) + (cstart
+ offset
) * sz
,
1531 (scm_sizet
) (sz
* (cend
- offset
))));
1533 scm_syserror (s_uniform_array_read_x
);
1535 if (SCM_TYP7 (v
) == scm_tc7_bvect
)
1536 ans
*= SCM_LONG_BIT
;
1538 if (v
!= ra
&& cra
!= ra
)
1539 scm_array_copy_x (cra
, ra
);
1541 return SCM_MAKINUM (ans
);
1544 SCM_PROC(s_uniform_array_write
, "uniform-array-write", 1, 3, 0, scm_uniform_array_write
);
1547 scm_uniform_array_write (v
, port_or_fd
, start
, end
)
1558 port_or_fd
= SCM_COERCE_OUTPORT (port_or_fd
);
1560 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
1561 if (SCM_UNBNDP (port_or_fd
))
1562 port_or_fd
= scm_cur_outp
;
1564 SCM_ASSERT (SCM_INUMP (port_or_fd
)
1565 || (SCM_NIMP (port_or_fd
) && SCM_OPOUTPORTP (port_or_fd
)),
1566 port_or_fd
, SCM_ARG2
, s_uniform_array_write
);
1567 vlen
= SCM_LENGTH (v
);
1573 badarg1
:scm_wta (v
, (char *) SCM_ARG1
, s_uniform_array_write
);
1575 SCM_ASRTGO (SCM_ARRAYP (v
), badarg1
);
1576 v
= scm_ra2contig (v
, 1);
1577 cstart
= SCM_ARRAY_BASE (v
);
1578 vlen
= SCM_ARRAY_DIMS (v
)->inc
1579 * (SCM_ARRAY_DIMS (v
)->ubnd
- SCM_ARRAY_DIMS (v
)->lbnd
+ 1);
1580 v
= SCM_ARRAY_V (v
);
1582 case scm_tc7_string
:
1583 case scm_tc7_byvect
:
1587 vlen
= (vlen
+ SCM_LONG_BIT
- 1) / SCM_LONG_BIT
;
1588 cstart
/= SCM_LONG_BIT
;
1594 sz
= sizeof (short);
1596 #ifdef HAVE_LONG_LONGS
1597 case scm_tc7_llvect
:
1598 sz
= sizeof (long_long
);
1604 sz
= sizeof (float);
1608 sz
= sizeof (double);
1611 sz
= 2 * sizeof (double);
1617 if (!SCM_UNBNDP (start
))
1620 scm_num2long (start
, (char *) SCM_ARG3
, s_uniform_array_write
);
1622 if (offset
< 0 || offset
>= cend
)
1623 scm_out_of_range (s_uniform_array_write
, start
);
1625 if (!SCM_UNBNDP (end
))
1628 scm_num2long (end
, (char *) SCM_ARG4
, s_uniform_array_write
);
1630 if (tend
<= offset
|| tend
> cend
)
1631 scm_out_of_range (s_uniform_array_write
, end
);
1636 if (SCM_NIMP (port_or_fd
))
1638 char *source
= SCM_CHARS (v
) + (cstart
+ offset
) * sz
;
1640 ans
= cend
- offset
;
1641 scm_lfwrite (source
, ans
* sz
, port_or_fd
);
1643 else /* file descriptor. */
1645 SCM_SYSCALL (ans
= write (SCM_INUM (port_or_fd
),
1646 SCM_CHARS (v
) + (cstart
+ offset
) * sz
,
1647 (scm_sizet
) (sz
* (cend
- offset
))));
1649 scm_syserror (s_uniform_array_write
);
1651 if (SCM_TYP7 (v
) == scm_tc7_bvect
)
1652 ans
*= SCM_LONG_BIT
;
1654 return SCM_MAKINUM (ans
);
1658 static char cnt_tab
[16] =
1659 {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1661 SCM_PROC(s_bit_count
, "bit-count", 2, 0, 0, scm_bit_count
);
1664 scm_bit_count (item
, seq
)
1669 register unsigned long cnt
= 0, w
;
1670 SCM_ASSERT (SCM_NIMP (seq
), seq
, SCM_ARG2
, s_bit_count
);
1671 switch SCM_TYP7 (seq
)
1674 scm_wta (seq
, (char *) SCM_ARG2
, s_bit_count
);
1676 if (0 == SCM_LENGTH (seq
))
1678 i
= (SCM_LENGTH (seq
) - 1) / SCM_LONG_BIT
;
1679 w
= SCM_VELTS (seq
)[i
];
1680 if (SCM_FALSEP (item
))
1682 w
<<= SCM_LONG_BIT
- 1 - ((SCM_LENGTH (seq
) - 1) % SCM_LONG_BIT
);
1686 cnt
+= cnt_tab
[w
& 0x0f];
1688 return SCM_MAKINUM (cnt
);
1689 w
= SCM_VELTS (seq
)[i
];
1690 if (SCM_FALSEP (item
))
1697 SCM_PROC(s_bit_position
, "bit-position", 3, 0, 0, scm_bit_position
);
1700 scm_bit_position (item
, v
, k
)
1705 long i
, lenw
, xbits
, pos
= SCM_INUM (k
);
1706 register unsigned long w
;
1707 SCM_ASSERT (SCM_NIMP (v
), v
, SCM_ARG2
, s_bit_position
);
1708 SCM_ASSERT (SCM_INUMP (k
), k
, SCM_ARG3
, s_bit_position
);
1709 SCM_ASSERT ((pos
<= SCM_LENGTH (v
)) && (pos
>= 0),
1710 k
, SCM_OUTOFRANGE
, s_bit_position
);
1711 if (pos
== SCM_LENGTH (v
))
1716 scm_wta (v
, (char *) SCM_ARG2
, s_bit_position
);
1718 if (0 == SCM_LENGTH (v
))
1719 return SCM_MAKINUM (-1L);
1720 lenw
= (SCM_LENGTH (v
) - 1) / SCM_LONG_BIT
; /* watch for part words */
1721 i
= pos
/ SCM_LONG_BIT
;
1722 w
= SCM_VELTS (v
)[i
];
1723 if (SCM_FALSEP (item
))
1725 xbits
= (pos
% SCM_LONG_BIT
);
1727 w
= ((w
>> xbits
) << xbits
);
1728 xbits
= SCM_LONG_BIT
- 1 - (SCM_LENGTH (v
) - 1) % SCM_LONG_BIT
;
1731 if (w
&& (i
== lenw
))
1732 w
= ((w
<< xbits
) >> xbits
);
1738 return SCM_MAKINUM (pos
);
1743 return SCM_MAKINUM (pos
+ 1);
1746 return SCM_MAKINUM (pos
+ 2);
1748 return SCM_MAKINUM (pos
+ 3);
1755 pos
+= SCM_LONG_BIT
;
1756 w
= SCM_VELTS (v
)[i
];
1757 if (SCM_FALSEP (item
))
1765 SCM_PROC(s_bit_set_star_x
, "bit-set*!", 3, 0, 0, scm_bit_set_star_x
);
1768 scm_bit_set_star_x (v
, kv
, obj
)
1773 register long i
, k
, vlen
;
1774 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
1775 SCM_ASRTGO (SCM_NIMP (kv
), badarg2
);
1776 switch SCM_TYP7 (kv
)
1779 badarg2
:scm_wta (kv
, (char *) SCM_ARG2
, s_bit_set_star_x
);
1784 badarg1
:scm_wta (v
, (char *) SCM_ARG1
, s_bit_set_star_x
);
1786 vlen
= SCM_LENGTH (v
);
1787 if (SCM_BOOL_F
== obj
)
1788 for (i
= SCM_LENGTH (kv
); i
;)
1790 k
= SCM_VELTS (kv
)[--i
];
1791 SCM_ASSERT ((k
< vlen
), SCM_MAKINUM (k
), SCM_OUTOFRANGE
, s_bit_set_star_x
);
1792 SCM_VELTS (v
)[k
/ SCM_LONG_BIT
] &= ~(1L << (k
% SCM_LONG_BIT
));
1794 else if (SCM_BOOL_T
== obj
)
1795 for (i
= SCM_LENGTH (kv
); i
;)
1797 k
= SCM_VELTS (kv
)[--i
];
1798 SCM_ASSERT ((k
< vlen
), SCM_MAKINUM (k
), SCM_OUTOFRANGE
, s_bit_set_star_x
);
1799 SCM_VELTS (v
)[k
/ SCM_LONG_BIT
] |= (1L << (k
% SCM_LONG_BIT
));
1802 badarg3
:scm_wta (obj
, (char *) SCM_ARG3
, s_bit_set_star_x
);
1806 SCM_ASRTGO (SCM_TYP7 (v
) == scm_tc7_bvect
&& SCM_LENGTH (v
) == SCM_LENGTH (kv
), badarg1
);
1807 if (SCM_BOOL_F
== obj
)
1808 for (k
= (SCM_LENGTH (v
) + SCM_LONG_BIT
- 1) / SCM_LONG_BIT
; k
--;)
1809 SCM_VELTS (v
)[k
] &= ~(SCM_VELTS (kv
)[k
]);
1810 else if (SCM_BOOL_T
== obj
)
1811 for (k
= (SCM_LENGTH (v
) + SCM_LONG_BIT
- 1) / SCM_LONG_BIT
; k
--;)
1812 SCM_VELTS (v
)[k
] |= SCM_VELTS (kv
)[k
];
1817 return SCM_UNSPECIFIED
;
1821 SCM_PROC(s_bit_count_star
, "bit-count*", 3, 0, 0, scm_bit_count_star
);
1824 scm_bit_count_star (v
, kv
, obj
)
1829 register long i
, vlen
, count
= 0;
1830 register unsigned long k
;
1831 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
1832 SCM_ASRTGO (SCM_NIMP (kv
), badarg2
);
1833 switch SCM_TYP7 (kv
)
1836 badarg2
:scm_wta (kv
, (char *) SCM_ARG2
, s_bit_count_star
);
1842 badarg1
:scm_wta (v
, (char *) SCM_ARG1
, s_bit_count_star
);
1844 vlen
= SCM_LENGTH (v
);
1845 if (SCM_BOOL_F
== obj
)
1846 for (i
= SCM_LENGTH (kv
); i
;)
1848 k
= SCM_VELTS (kv
)[--i
];
1849 SCM_ASSERT ((k
< vlen
), SCM_MAKINUM (k
), SCM_OUTOFRANGE
, s_bit_count_star
);
1850 if (!(SCM_VELTS (v
)[k
/ SCM_LONG_BIT
] & (1L << (k
% SCM_LONG_BIT
))))
1853 else if (SCM_BOOL_T
== obj
)
1854 for (i
= SCM_LENGTH (kv
); i
;)
1856 k
= SCM_VELTS (kv
)[--i
];
1857 SCM_ASSERT ((k
< vlen
), SCM_MAKINUM (k
), SCM_OUTOFRANGE
, s_bit_count_star
);
1858 if (SCM_VELTS (v
)[k
/ SCM_LONG_BIT
] & (1L << (k
% SCM_LONG_BIT
)))
1862 badarg3
:scm_wta (obj
, (char *) SCM_ARG3
, s_bit_count_star
);
1866 SCM_ASRTGO (SCM_TYP7 (v
) == scm_tc7_bvect
&& SCM_LENGTH (v
) == SCM_LENGTH (kv
), badarg1
);
1867 if (0 == SCM_LENGTH (v
))
1869 SCM_ASRTGO (SCM_BOOL_T
== obj
|| SCM_BOOL_F
== obj
, badarg3
);
1870 obj
= (SCM_BOOL_T
== obj
);
1871 i
= (SCM_LENGTH (v
) - 1) / SCM_LONG_BIT
;
1872 k
= SCM_VELTS (kv
)[i
] & (obj
? SCM_VELTS (v
)[i
] : ~SCM_VELTS (v
)[i
]);
1873 k
<<= SCM_LONG_BIT
- 1 - ((SCM_LENGTH (v
) - 1) % SCM_LONG_BIT
);
1877 count
+= cnt_tab
[k
& 0x0f];
1879 return SCM_MAKINUM (count
);
1880 k
= SCM_VELTS (kv
)[i
] & (obj
? SCM_VELTS (v
)[i
] : ~SCM_VELTS (v
)[i
]);
1883 return SCM_MAKINUM (count
);
1887 SCM_PROC(s_bit_invert_x
, "bit-invert!", 1, 0, 0, scm_bit_invert_x
);
1890 scm_bit_invert_x (v
)
1894 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
1900 for (k
= (k
+ SCM_LONG_BIT
- 1) / SCM_LONG_BIT
; k
--;)
1901 SCM_VELTS (v
)[k
] = ~SCM_VELTS (v
)[k
];
1904 badarg1
:scm_wta (v
, (char *) SCM_ARG1
, s_bit_invert_x
);
1906 return SCM_UNSPECIFIED
;
1911 scm_istr2bve (str
, len
)
1915 SCM v
= scm_make_uve (len
, SCM_BOOL_T
);
1916 long *data
= (long *) SCM_VELTS (v
);
1917 register unsigned long mask
;
1920 for (k
= 0; k
< (len
+ SCM_LONG_BIT
- 1) / SCM_LONG_BIT
; k
++)
1923 j
= len
- k
* SCM_LONG_BIT
;
1924 if (j
> SCM_LONG_BIT
)
1926 for (mask
= 1L; j
--; mask
<<= 1)
1943 static SCM ra2l
SCM_P ((SCM ra
, scm_sizet base
, scm_sizet k
));
1951 register SCM res
= SCM_EOL
;
1952 register long inc
= SCM_ARRAY_DIMS (ra
)[k
].inc
;
1953 register scm_sizet i
;
1954 if (SCM_ARRAY_DIMS (ra
)[k
].ubnd
< SCM_ARRAY_DIMS (ra
)[k
].lbnd
)
1956 i
= base
+ (1 + SCM_ARRAY_DIMS (ra
)[k
].ubnd
- SCM_ARRAY_DIMS (ra
)[k
].lbnd
) * inc
;
1957 if (k
< SCM_ARRAY_NDIM (ra
) - 1)
1962 res
= scm_cons (ra2l (ra
, i
, k
+ 1), res
);
1970 res
= scm_cons (scm_uniform_vector_ref (SCM_ARRAY_V (ra
), SCM_MAKINUM (i
)), res
);
1977 SCM_PROC(s_array_to_list
, "array->list", 1, 0, 0, scm_array_to_list
);
1980 scm_array_to_list (v
)
1985 SCM_ASRTGO (SCM_NIMP (v
), badarg1
);
1990 badarg1
:scm_wta (v
, (char *) SCM_ARG1
, s_array_to_list
);
1992 SCM_ASRTGO (SCM_ARRAYP (v
), badarg1
);
1993 return ra2l (v
, SCM_ARRAY_BASE (v
), 0);
1994 case scm_tc7_vector
:
1996 return scm_vector_to_list (v
);
1997 case scm_tc7_string
:
1998 return scm_string_to_list (v
);
2001 long *data
= (long *) SCM_VELTS (v
);
2002 register unsigned long mask
;
2003 for (k
= (SCM_LENGTH (v
) - 1) / SCM_LONG_BIT
; k
> 0; k
--)
2004 for (mask
= 1UL << (SCM_LONG_BIT
- 1); mask
; mask
>>= 1)
2005 res
= scm_cons (((long *) data
)[k
] & mask
? SCM_BOOL_T
: SCM_BOOL_F
, res
);
2006 for (mask
= 1L << ((SCM_LENGTH (v
) % SCM_LONG_BIT
) - 1); mask
; mask
>>= 1)
2007 res
= scm_cons (((long *) data
)[k
] & mask
? SCM_BOOL_T
: SCM_BOOL_F
, res
);
2010 # ifdef SCM_INUMS_ONLY
2014 long *data
= (long *) SCM_VELTS (v
);
2015 for (k
= SCM_LENGTH (v
) - 1; k
>= 0; k
--)
2016 res
= scm_cons (SCM_MAKINUM (data
[k
]), res
);
2020 case scm_tc7_uvect
: {
2021 long *data
= (long *)SCM_VELTS(v
);
2022 for (k
= SCM_LENGTH(v
) - 1; k
>= 0; k
--)
2023 res
= scm_cons(scm_ulong2num(data
[k
]), res
);
2026 case scm_tc7_ivect
: {
2027 long *data
= (long *)SCM_VELTS(v
);
2028 for (k
= SCM_LENGTH(v
) - 1; k
>= 0; k
--)
2029 res
= scm_cons(scm_long2num(data
[k
]), res
);
2033 case scm_tc7_svect
: {
2035 data
= (short *)SCM_VELTS(v
);
2036 for (k
= SCM_LENGTH(v
) - 1; k
>= 0; k
--)
2037 res
= scm_cons(SCM_MAKINUM (data
[k
]), res
);
2040 #ifdef HAVE_LONG_LONGS
2041 case scm_tc7_llvect
: {
2043 data
= (long_long
*)SCM_VELTS(v
);
2044 for (k
= SCM_LENGTH(v
) - 1; k
>= 0; k
--)
2045 res
= scm_cons(scm_long_long2num(data
[k
]), res
);
2055 float *data
= (float *) SCM_VELTS (v
);
2056 for (k
= SCM_LENGTH (v
) - 1; k
>= 0; k
--)
2057 res
= scm_cons (scm_makflo (data
[k
]), res
);
2060 #endif /*SCM_SINGLES*/
2063 double *data
= (double *) SCM_VELTS (v
);
2064 for (k
= SCM_LENGTH (v
) - 1; k
>= 0; k
--)
2065 res
= scm_cons (scm_makdbl (data
[k
], 0.0), res
);
2070 double (*data
)[2] = (double (*)[2]) SCM_VELTS (v
);
2071 for (k
= SCM_LENGTH (v
) - 1; k
>= 0; k
--)
2072 res
= scm_cons (scm_makdbl (data
[k
][0], data
[k
][1]), res
);
2075 #endif /*SCM_FLOATS*/
2080 static char s_bad_ralst
[] = "Bad scm_array contents list";
2082 static int l2ra
SCM_P ((SCM lst
, SCM ra
, scm_sizet base
, scm_sizet k
));
2084 SCM_PROC(s_list_to_uniform_array
, "list->uniform-array", 3, 0, 0, scm_list_to_uniform_array
);
2087 scm_list_to_uniform_array (ndim
, prot
, lst
)
2097 SCM_ASSERT (SCM_INUMP (ndim
), ndim
, SCM_ARG1
, s_list_to_uniform_array
);
2098 k
= SCM_INUM (ndim
);
2101 n
= scm_ilength (row
);
2102 SCM_ASSERT (n
>= 0, lst
, SCM_ARG3
, s_list_to_uniform_array
);
2103 shp
= scm_cons (SCM_MAKINUM (n
), shp
);
2105 row
= SCM_CAR (row
);
2107 ra
= scm_dimensions_to_uniform_array (scm_reverse (shp
), prot
,
2109 if (SCM_NULLP (shp
))
2112 SCM_ASRTGO (1 == scm_ilength (lst
), badlst
);
2113 scm_array_set_x (ra
, SCM_CAR (lst
), SCM_EOL
);
2116 if (!SCM_ARRAYP (ra
))
2118 for (k
= 0; k
< SCM_LENGTH (ra
); k
++, lst
= SCM_CDR (lst
))
2119 scm_array_set_x (ra
, SCM_CAR (lst
), SCM_MAKINUM (k
));
2122 if (l2ra (lst
, ra
, SCM_ARRAY_BASE (ra
), 0))
2125 badlst
:scm_wta (lst
, s_bad_ralst
, s_list_to_uniform_array
);
2130 l2ra (lst
, ra
, base
, k
)
2136 register long inc
= SCM_ARRAY_DIMS (ra
)[k
].inc
;
2137 register long n
= (1 + SCM_ARRAY_DIMS (ra
)[k
].ubnd
- SCM_ARRAY_DIMS (ra
)[k
].lbnd
);
2140 return (SCM_EOL
== lst
);
2141 if (k
< SCM_ARRAY_NDIM (ra
) - 1)
2145 if (SCM_IMP (lst
) || SCM_NCONSP (lst
))
2147 ok
= ok
&& l2ra (SCM_CAR (lst
), ra
, base
, k
+ 1);
2149 lst
= SCM_CDR (lst
);
2151 if (SCM_NNULLP (lst
))
2158 if (SCM_IMP (lst
) || SCM_NCONSP (lst
))
2160 ok
= ok
&& scm_array_set_x (SCM_ARRAY_V (ra
), SCM_CAR (lst
), SCM_MAKINUM (base
));
2162 lst
= SCM_CDR (lst
);
2164 if (SCM_NNULLP (lst
))
2171 static void rapr1
SCM_P ((SCM ra
, scm_sizet j
, scm_sizet k
, SCM port
, scm_print_state
*pstate
));
2174 rapr1 (ra
, j
, k
, port
, pstate
)
2179 scm_print_state
*pstate
;
2182 long n
= SCM_LENGTH (ra
);
2185 switch SCM_TYP7 (ra
)
2190 SCM_ARRAY_BASE (ra
) = j
;
2192 scm_iprin1 (ra
, port
, pstate
);
2193 for (j
+= inc
; n
-- > 0; j
+= inc
)
2195 scm_putc (' ', port
);
2196 SCM_ARRAY_BASE (ra
) = j
;
2197 scm_iprin1 (ra
, port
, pstate
);
2201 if (k
+ 1 < SCM_ARRAY_NDIM (ra
))
2204 inc
= SCM_ARRAY_DIMS (ra
)[k
].inc
;
2205 for (i
= SCM_ARRAY_DIMS (ra
)[k
].lbnd
; i
< SCM_ARRAY_DIMS (ra
)[k
].ubnd
; i
++)
2207 scm_putc ('(', port
);
2208 rapr1 (ra
, j
, k
+ 1, port
, pstate
);
2209 scm_puts (") ", port
);
2212 if (i
== SCM_ARRAY_DIMS (ra
)[k
].ubnd
)
2213 { /* could be zero size. */
2214 scm_putc ('(', port
);
2215 rapr1 (ra
, j
, k
+ 1, port
, pstate
);
2216 scm_putc (')', port
);
2222 { /* Could be zero-dimensional */
2223 inc
= SCM_ARRAY_DIMS (ra
)[k
].inc
;
2224 n
= (SCM_ARRAY_DIMS (ra
)[k
].ubnd
- SCM_ARRAY_DIMS (ra
)[k
].lbnd
+ 1);
2228 ra
= SCM_ARRAY_V (ra
);
2231 /* scm_tc7_bvect and scm_tc7_llvect only? */
2233 scm_iprin1 (scm_uniform_vector_ref (ra
, SCM_MAKINUM (j
)), port
, pstate
);
2234 for (j
+= inc
; n
-- > 0; j
+= inc
)
2236 scm_putc (' ', port
);
2237 scm_iprin1 (scm_cvref (ra
, j
, SCM_UNDEFINED
), port
, pstate
);
2240 case scm_tc7_string
:
2242 scm_iprin1 (SCM_MAKICHR (SCM_UCHARS (ra
)[j
]), port
, pstate
);
2243 if (SCM_WRITINGP (pstate
))
2244 for (j
+= inc
; n
-- > 0; j
+= inc
)
2246 scm_putc (' ', port
);
2247 scm_iprin1 (SCM_MAKICHR (SCM_UCHARS (ra
)[j
]), port
, pstate
);
2250 for (j
+= inc
; n
-- > 0; j
+= inc
)
2251 scm_putc (SCM_CHARS (ra
)[j
], port
);
2253 case scm_tc7_byvect
:
2255 scm_intprint (((char *)SCM_CDR (ra
))[j
], 10, port
);
2256 for (j
+= inc
; n
-- > 0; j
+= inc
)
2258 scm_putc (' ', port
);
2259 scm_intprint (((char *)SCM_CDR (ra
))[j
], 10, port
);
2269 /* intprint can't handle >= 2^31. */
2270 sprintf (str
, "%lu", (unsigned long) SCM_VELTS (ra
)[j
]);
2271 scm_puts (str
, port
);
2273 for (j
+= inc
; n
-- > 0; j
+= inc
)
2275 scm_putc (' ', port
);
2276 sprintf (str
, "%lu", (unsigned long) SCM_VELTS (ra
)[j
]);
2277 scm_puts (str
, port
);
2282 scm_intprint (SCM_VELTS (ra
)[j
], 10, port
);
2283 for (j
+= inc
; n
-- > 0; j
+= inc
)
2285 scm_putc (' ', port
);
2286 scm_intprint (SCM_VELTS (ra
)[j
], 10, port
);
2292 scm_intprint (((short *)SCM_CDR (ra
))[j
], 10, port
);
2293 for (j
+= inc
; n
-- > 0; j
+= inc
)
2295 scm_putc (' ', port
);
2296 scm_intprint (((short *)SCM_CDR (ra
))[j
], 10, port
);
2305 SCM z
= scm_makflo (1.0);
2306 SCM_FLO (z
) = ((float *) SCM_VELTS (ra
))[j
];
2307 scm_floprint (z
, port
, pstate
);
2308 for (j
+= inc
; n
-- > 0; j
+= inc
)
2310 scm_putc (' ', port
);
2311 SCM_FLO (z
) = ((float *) SCM_VELTS (ra
))[j
];
2312 scm_floprint (z
, port
, pstate
);
2316 #endif /*SCM_SINGLES*/
2320 SCM z
= scm_makdbl (1.0 / 3.0, 0.0);
2321 SCM_REAL (z
) = ((double *) SCM_VELTS (ra
))[j
];
2322 scm_floprint (z
, port
, pstate
);
2323 for (j
+= inc
; n
-- > 0; j
+= inc
)
2325 scm_putc (' ', port
);
2326 SCM_REAL (z
) = ((double *) SCM_VELTS (ra
))[j
];
2327 scm_floprint (z
, port
, pstate
);
2334 SCM cz
= scm_makdbl (0.0, 1.0), z
= scm_makdbl (1.0 / 3.0, 0.0);
2335 SCM_REAL (z
) = SCM_REAL (cz
) = (((double *) SCM_VELTS (ra
))[2 * j
]);
2336 SCM_IMAG (cz
) = ((double *) SCM_VELTS (ra
))[2 * j
+ 1];
2337 scm_floprint ((0.0 == SCM_IMAG (cz
) ? z
: cz
), port
, pstate
);
2338 for (j
+= inc
; n
-- > 0; j
+= inc
)
2340 scm_putc (' ', port
);
2341 SCM_REAL (z
) = SCM_REAL (cz
) = ((double *) SCM_VELTS (ra
))[2 * j
];
2342 SCM_IMAG (cz
) = ((double *) SCM_VELTS (ra
))[2 * j
+ 1];
2343 scm_floprint ((0.0 == SCM_IMAG (cz
) ? z
: cz
), port
, pstate
);
2347 #endif /*SCM_FLOATS*/
2354 scm_raprin1 (exp
, port
, pstate
)
2357 scm_print_state
*pstate
;
2361 scm_putc ('#', port
);
2367 long ndim
= SCM_ARRAY_NDIM (v
);
2368 base
= SCM_ARRAY_BASE (v
);
2369 v
= SCM_ARRAY_V (v
);
2373 scm_puts ("<enclosed-array ", port
);
2374 rapr1 (exp
, base
, 0, port
, pstate
);
2375 scm_putc ('>', port
);
2380 scm_intprint (ndim
, 10, port
);
2386 { /* a uve, not an scm_array */
2387 register long i
, j
, w
;
2388 scm_putc ('*', port
);
2389 for (i
= 0; i
< (SCM_LENGTH (exp
)) / SCM_LONG_BIT
; i
++)
2391 w
= SCM_VELTS (exp
)[i
];
2392 for (j
= SCM_LONG_BIT
; j
; j
--)
2394 scm_putc (w
& 1 ? '1' : '0', port
);
2398 j
= SCM_LENGTH (exp
) % SCM_LONG_BIT
;
2401 w
= SCM_VELTS (exp
)[SCM_LENGTH (exp
) / SCM_LONG_BIT
];
2404 scm_putc (w
& 1 ? '1' : '0', port
);
2411 scm_putc ('b', port
);
2413 case scm_tc7_string
:
2414 scm_putc ('a', port
);
2416 case scm_tc7_byvect
:
2417 scm_putc ('y', port
);
2420 scm_putc ('u', port
);
2423 scm_putc ('e', port
);
2426 scm_putc ('h', port
);
2428 #ifdef HAVE_LONG_LONGS
2429 case scm_tc7_llvect
:
2430 scm_putc ('l', port
);
2436 scm_putc ('s', port
);
2438 #endif /*SCM_SINGLES*/
2440 scm_putc ('i', port
);
2443 scm_putc ('c', port
);
2445 #endif /*SCM_FLOATS*/
2447 scm_putc ('(', port
);
2448 rapr1 (exp
, base
, 0, port
, pstate
);
2449 scm_putc (')', port
);
2453 SCM_PROC(s_array_prototype
, "array-prototype", 1, 0, 0, scm_array_prototype
);
2456 scm_array_prototype (ra
)
2460 SCM_ASRTGO (SCM_NIMP (ra
), badarg
);
2466 badarg
:scm_wta (ra
, (char *) SCM_ARG1
, s_array_prototype
);
2468 SCM_ASRTGO (SCM_ARRAYP (ra
), badarg
);
2470 return SCM_UNSPECIFIED
;
2471 ra
= SCM_ARRAY_V (ra
);
2473 case scm_tc7_vector
:
2478 case scm_tc7_string
:
2479 return SCM_MAKICHR ('a');
2480 case scm_tc7_byvect
:
2481 return SCM_MAKICHR ('\0');
2483 return SCM_MAKINUM (1L);
2485 return SCM_MAKINUM (-1L);
2487 return SCM_CDR (scm_intern ("s", 1));
2488 #ifdef HAVE_LONG_LONGS
2489 case scm_tc7_llvect
:
2490 return SCM_CDR (scm_intern ("l", 1));
2495 return scm_makflo (1.0);
2498 return scm_makdbl (1.0 / 3.0, 0.0);
2500 return scm_makdbl (0.0, 1.0);
2506 static SCM markra
SCM_P ((SCM ptr
));
2512 return SCM_ARRAY_V (ptr
);
2516 static scm_sizet freera
SCM_P ((SCM ptr
));
2522 scm_must_free (SCM_CHARS (ptr
));
2523 return sizeof (scm_array
) + SCM_ARRAY_NDIM (ptr
) * sizeof (scm_array_dim
);
2529 scm_tc16_array
= scm_make_smob_type_mfpe ("array", 0,
2534 scm_add_feature ("array");