chickadee » srfi-160

SRFI-160: Homogeneous numeric vector libraries

Abstract

This SRFI describes a set of operations on SRFI 4 homogeneous vector types (plus a few additional types) that are closely analogous to the vector operations library, SRFI 133. An external representation is specified which may be supported by the read and write procedures and by the program parser so that programs can contain references to literal homogeneous vectors.

For more information see: SRFI-160: Homogeneous numeric vector libraries

Rationale

Like lists, Scheme vectors are a heterogeneous datatype which impose no restriction on the type of the elements. This generality is not needed for applications where all the elements are of the same type. The use of Scheme vectors is not ideal for such applications because, in the absence of a compiler with a fancy static analysis, the representation will typically use some form of boxing of the elements which means low space efficiency and slower access to the elements. Moreover, homogeneous vectors are convenient for interfacing with low-level libraries (e.g. binary block I/O) and to interface with foreign languages which support homogeneous vectors. Finally, the use of homogeneous vectors allows certain errors to be caught earlier.

This SRFI specifies a set of homogeneous vector datatypes which cover the most practical cases, that is where the type of the elements is numeric (exact integer or inexact real or complex) and the precision and representation is efficiently implemented on the hardware of most current computer architectures (8, 16, 32 and 64 bit integers, either signed or unsigned, and 32 and 64 bit floating point numbers).

This SRFI extends SRFI 4 by providing the additional c64vector and c128vector types, and by providing analogues for almost all of the heterogeneous vector procedures of SRFI 133. There are some additional procedures, most of which are closely analogous to the string procedures of SRFI 152.

Note that there are no conversions between homogeneous vectors and strings in this SRFI. In addition, there is no support for u1vectors (bitvectors) provided, not because they are not useful, but because they are different enough in both specification and implementation to be put into a future SRFI of their own.

Specification

There are eight datatypes of exact integer homogeneous vectors (which will be called integer vectors):

All are part of SRFI 4.

There are two datatypes of inexact real homogeneous vectors (which will be called float vectors):

These are also part of SRFI 4.

f64vectors must preserve at least as much precision and range as f32vectors. (See the implementation section for details.)

And there are two datatypes of inexact complex homogeneous vectors (which will be called complex vectors):

c64vectortype

inexact complex, typically 64 bits

c128vectortype

inexact complex, typically 128 bits

These are not part of SRFI 4.

c128vectors must preserve at least as much precision and range as c64vectors. (See the implementation section for details.)

Each element of a homogeneous vector must be valid. That is, for an integer vector, it must be an exact integer within the inclusive range specified above; for a float vector, it must be an inexact real number; and for a complex vector, it must be an inexact complex number. It is an error to try to use a constructor or mutator to set an element to an invalid value.

Additions to the specification

The CHICKEN implementation adds a couple of features to the SRFI specification. It prints c64vector and c128vector as #!c64(...) and #!c128(...), respectively, with the appropriate sharp-read-syntax '#!c64(...) and '#!c128(...).

It also exports the following two procedures for access to the underlying srfi-4 vectors that make up the body of complex vectors:

c128vector-body c128vecprocedure

Returns the f64vector body of c128vec.

c64vector-body c64vecprocedure

Returns the f32vector body of c64vec.

Notation

So as not to multiply the number of procedures described in this SRFI beyond necessity, a special notational convention is used. The description of the procedure make-@vector is really shorthand for the descriptions of the twelve procedures make-s8vector, make-u8vector, ... make-c128vector, all of which are exactly the same except that they construct different homogeneous vector types. Furthermore, except as otherwise noted, the semantics of each procedure are those of the corresponding SRFI 133 procedure, except that it is an error to attempt to insert an invalid value into a homogeneous vector. Consequently, only a brief description of each procedure is given, and SRFI 133 (or in some cases SRFI 152) should be consulted for the details. It is worth mentioning, however, that all the procedures that return one or more vectors (homogeneous or heterogeneous) invariably return newly allocated vectors specifically.

In the section containing specifications of procedures, the following notation is used to specify parameters and return values:

vec
Must be a heterogeneous vector, i.e. it must satisfy the predicate vector?.
@vec, @to, @from
Must be a homogeneous vector, i.e. it must satisfy the predicate @vector?. In @vector-copy! and reverse-@vector-copy!, @to is the destination and @from is the source.
i, j, start, at
Must be an exact-nonnegative-integer less than the length of the @vector. In @vector-copy! and reverse-@vector-copy!, at refers to the destination and start to the source.
end
Must be an exact-nonnegative-integer not less than start and not greater than the length of the vector. This indicates the index directly before which traversal will stop -- processing will occur until the index of the vector is one less than end. It is the open right side of a range.
f
Must be a procedure taking one or more arguments, which returns (except as noted otherwise) exactly one value.
pred
Must be a procedure taking one or more arguments that returns one value, which is treated as a boolean.
=
Must be an equivalence procedure.
obj, seed, knil
A scheme object.
fill, value
Any number that is valid with respect to the @vec.
[something]
An optional argument; it needn't necessarily be applied. Something needn't necessarily be one thing; for example, this usage of it is perfectly valid: [start [end]] and is indeed used quite often.
something ...
Zero or more somethings are allowed to be arguments.
something[1] something[2] ...
At least one something must be arguments.

Packaging

For each @vector type, there is a corresponding library named (srfi 160 @), and if an implementation provides a given type, it must provide that library as well. In addition, the library (srfi 160 base) provides a few basic procedures for all @vector types. If a particular type is not provided by an implementation, then it is an error to call the corresponding procedures in this library. Note that there is no library named (srfi 160).

Procedures

The procedures shared with SRFI 4 are marked with SRFI 4. The procedures with the same semantics as SRFI 133 are marked with SRFI 133. The procedures analogous to SRFI 152 string procedures are marked with SRFI 152.

Constructors

make-u8vector size #!optional fillprocedure
make-s8vector size #!optional fillprocedure
make-u16vector size #!optional fillprocedure
make-s16vector size #!optional fillprocedure
make-u32vector size #!optional fillprocedure
make-s32vector size #!optional fillprocedure
make-u64vector size #!optional fillprocedure
make-s64vector size #!optional fillprocedure
make-f32vector size #!optional fillprocedure
make-f64vector size #!optional fillprocedure
make-c64vector size #!optional fillprocedure
make-c128vector size #!optional fillprocedure

Returns a @vector whose length is size. If fill is provided, all the elements of the @vector are initialized to it.

SRFI 4

u8vector value ...procedure
s8vector value ...procedure
u16vector value ...procedure
s16vector value ...procedure
u32vector value ...procedure
s32vector value ...procedure
u64vector value ...procedure
s64vector value ...procedure
f32vector value ...procedure
f64vector value ...procedure
c64vector value ...procedure
c128vector value ...procedure

Returns a @vector initialized with values.

SRFI 4

u8vector-unfold f length seedprocedure
s8vector-unfold f length seedprocedure
u16vector-unfold f length seedprocedure
s16vector-unfold f length seedprocedure
u32vector-unfold f length seedprocedure
s32vector-unfold f length seedprocedure
u64vector-unfold f length seedprocedure
s64vector-unfold f length seedprocedure
f32vector-unfold f length seedprocedure
f64vector-unfold f length seedprocedure
c64vector-unfold f length seedprocedure
c128vector-unfold f length seedprocedure

Creates a vector whose length is length and iterates across each index k between 0 and length - 1, applying f at each iteration to the current index and current state, in that order, to receive two values: the element to put in the kth slot of the new vector and a new state for the next iteration. On the first call to f, the state's value is seed.

SRFI 133

u8vector-unfold-right f length seedprocedure
s8vector-unfold-right f length seedprocedure
u16vector-unfold-right f length seedprocedure
s16vector-unfold-right f length seedprocedure
u32vector-unfold-right f length seedprocedure
s32vector-unfold-right f length seedprocedure
u64vector-unfold-right f length seedprocedure
s64vector-unfold-right f length seedprocedure
f32vector-unfold-right f length seedprocedure
f64vector-unfold-right f length seedprocedure
c64vector-unfold-right f length seedprocedure
c128vector-unfold-right f length seedprocedure

The same as @vector-unfold, but initializes the @vector from right to left.

SRFI 133

u8vector-copy @vec #!optional start endprocedure
s8vector-copy @vec #!optional start endprocedure
u16vector-copy @vec #!optional start endprocedure
s16vector-copy @vec #!optional start endprocedure
u32vector-copy @vec #!optional start endprocedure
s32vector-copy @vec #!optional start endprocedure
u64vector-copy @vec #!optional start endprocedure
s64vector-copy @vec #!optional start endprocedure
f32vector-copy @vec #!optional start endprocedure
f64vector-copy @vec #!optional start endprocedure
c64vector-copy @vec #!optional start endprocedure
c128vector-copy @vec #!optional start endprocedure

Makes a copy of the portion of @vec from start to end and returns it.

SRFI 133

u8vector-reverse-copy @vec #!optional start endprocedure
s8vector-reverse-copy @vec #!optional start endprocedure
u16vector-reverse-copy @vec #!optional start endprocedure
s16vector-reverse-copy @vec #!optional start endprocedure
u32vector-reverse-copy @vec #!optional start endprocedure
s32vector-reverse-copy @vec #!optional start endprocedure
u64vector-reverse-copy @vec #!optional start endprocedure
s64vector-reverse-copy @vec #!optional start endprocedure
f32vector-reverse-copy @vec #!optional start endprocedure
f64vector-reverse-copy @vec #!optional start endprocedure
c64vector-reverse-copy @vec #!optional start endprocedure
c128vector-reverse-copy @vec #!optional start endprocedure

The same as @vector-copy, but in reverse order.

SRFI 133

u8vector-append @vec ...procedure
s8vector-append @vec ...procedure
u16vector-append @vec ...procedure
s16vector-append @vec ...procedure
u32vector-append @vec ...procedure
s32vector-append @vec ...procedure
u64vector-append @vec ...procedure
s64vector-append @vec ...procedure
f32vector-append @vec ...procedure
f64vector-append @vec ...procedure
c64vector-append @vec ...procedure
c128vector-append @vec ...procedure

Returns a @vector containing all the elements of the @vecs in order.

SRFI 133

u8vector-concatenate list-of-@vectorsprocedure
s8vector-concatenate list-of-@vectorsprocedure
u16vector-concatenate list-of-@vectorsprocedure
s16vector-concatenate list-of-@vectorsprocedure
u32vector-concatenate list-of-@vectorsprocedure
s32vector-concatenate list-of-@vectorsprocedure
u64vector-concatenate list-of-@vectorsprocedure
s64vector-concatenate list-of-@vectorsprocedure
f32vector-concatenate list-of-@vectorsprocedure
f64vector-concatenate list-of-@vectorsprocedure
c64vector-concatenate list-of-@vectorsprocedure
c128vector-concatenate list-of-@vectorsprocedure

SRFI 133

The same as @vector-append, but takes a list of @vectors rather than multiple arguments.

(u8vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(s8vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(u16vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(s16vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(u32vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(s32vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(u64vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(s64vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(f32vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(f64vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(c64vector-append-subvectors [@vec start end] ...) -> @vectorprocedure
(c128vector-append-subvectors [@vec start end] ...) -> @vectorprocedure

Concatenates the result of applying @vector-copy to each triplet of @vec, start, end arguments, but may be implemented more efficiently.

SRFI 133

Predicates

u8? objprocedure
s8? objprocedure
u16? objprocedure
s16? objprocedure
u32? objprocedure
s32? objprocedure
u64? objprocedure
s64? objprocedure
f32? objprocedure
f64? objprocedure
c64? objprocedure
c128? objprocedure

Returns #t if obj is a valid element of an @vector, and #f otherwise.

u8vector? objprocedure
s8vector? objprocedure
u16vector? objprocedure
s16vector? objprocedure
u32vector? objprocedure
s32vector? objprocedure
u64vector? objprocedure
s64vector? objprocedure
f32vector? objprocedure
f64vector? objprocedure
c64vector? objprocedure
c128vector? objprocedure

Returns #t if obj is a @vector, and #f otherwise.

SRFI 4

u8vector-empty? @vecprocedure
s8vector-empty? @vecprocedure
u16vector-empty? @vecprocedure
s16vector-empty? @vecprocedure
u32vector-empty? @vecprocedure
s32vector-empty? @vecprocedure
u64vector-empty? @vecprocedure
s64vector-empty? @vecprocedure
f32vector-empty? @vecprocedure
f64vector-empty? @vecprocedure
c64vector-empty? @vecprocedure
c128vector-empty? @vecprocedure

Returns #t if @vec has a length of zero, and #f otherwise.

SRFI 133

u8vector= @vec ...procedure
s8vector= @vec ...procedure
u16vector= @vec ...procedure
s16vector= @vec ...procedure
u32vector= @vec ...procedure
s32vector= @vec ...procedure
u64vector= @vec ...procedure
s64vector= @vec ...procedure
f32vector= @vec ...procedure
f64vector= @vec ...procedure
c64vector= @vec ...procedure
c128vector= @vec ...procedure

Compares the @vecs for elementwise equality, using = to do the comparisons. Returns #f unless all @vectors are the same length.

SRFI 133

Selectors

u8vector-ref @vec iprocedure
s8vector-ref @vec iprocedure
u16vector-ref @vec iprocedure
s16vector-ref @vec iprocedure
u32vector-ref @vec iprocedure
s32vector-ref @vec iprocedure
u64vector-ref @vec iprocedure
s64vector-ref @vec iprocedure
f32vector-ref @vec iprocedure
f64vector-ref @vec iprocedure
c64vector-ref @vec iprocedure
c128vector-ref @vec iprocedure

Returns the ith element of @vec.

SRFI 4

u8vector-length @vecprocedure
s8vector-length @vecprocedure
u16vector-length @vecprocedure
s16vector-length @vecprocedure
u32vector-length @vecprocedure
s32vector-length @vecprocedure
u64vector-length @vecprocedure
s64vector-length @vecprocedure
f32vector-length @vecprocedure
f64vector-length @vecprocedure
c64vector-length @vecprocedure
c128vector-length @vecprocedure

Returns the length of @vec

SRFI 4

Iteration

u8vector-take @vec nprocedure
s8vector-take @vec nprocedure
u16vector-take @vec nprocedure
s16vector-take @vec nprocedure
u32vector-take @vec nprocedure
s32vector-take @vec nprocedure
u64vector-take @vec nprocedure
s64vector-take @vec nprocedure
f32vector-take @vec nprocedure
f64vector-take @vec nprocedure
c64vector-take @vec nprocedure
c128vector-take @vec nprocedure

Returns a @vector containing the first n elements of @vec.

SRFI 152

u8vector-take-right @vec nprocedure
s8vector-take-right @vec nprocedure
u16vector-take-right @vec nprocedure
s16vector-take-right @vec nprocedure
u32vector-take-right @vec nprocedure
s32vector-take-right @vec nprocedure
u64vector-take-right @vec nprocedure
s64vector-take-right @vec nprocedure
f32vector-take-right @vec nprocedure
f64vector-take-right @vec nprocedure
c64vector-take-right @vec nprocedure
c128vector-take-right @vec nprocedure

Returns a @vector containing the last n elements of @vec.

SRFI 152

u8vector-drop @vec nprocedure
s8vector-drop @vec nprocedure
u16vector-drop @vec nprocedure
s16vector-drop @vec nprocedure
u32vector-drop @vec nprocedure
s32vector-drop @vec nprocedure
u64vector-drop @vec nprocedure
s64vector-drop @vec nprocedure
f32vector-drop @vec nprocedure
f64vector-drop @vec nprocedure
c64vector-drop @vec nprocedure
c128vector-drop @vec nprocedure

Returns a @vector containing all except the first n elements of @vec.

SRFI 152

u8vector-drop-right @vec nprocedure
s8vector-drop-right @vec nprocedure
u16vector-drop-right @vec nprocedure
s16vector-drop-right @vec nprocedure
u32vector-drop-right @vec nprocedure
s32vector-drop-right @vec nprocedure
u64vector-drop-right @vec nprocedure
s64vector-drop-right @vec nprocedure
f32vector-drop-right @vec nprocedure
f64vector-drop-right @vec nprocedure
c64vector-drop-right @vec nprocedure
c128vector-drop-right @vec nprocedure

Returns a @vector containing all except the last n elements of @vec.

SRFI 152

u8vector-segment @vec nprocedure
s8vector-segment @vec nprocedure
u16vector-segment @vec nprocedure
s16vector-segment @vec nprocedure
u32vector-segment @vec nprocedure
s32vector-segment @vec nprocedure
u64vector-segment @vec nprocedure
s64vector-segment @vec nprocedure
f32vector-segment @vec nprocedure
f64vector-segment @vec nprocedure
c64vector-segment @vec nprocedure
c128vector-segment @vec nprocedure

Returns a list of @vectors, each of which contains n consecutive elements of @vec. The last @vector may be shorter than n.

SRFI 152

u8vector-fold kons knil @vec @vec2 ...procedure
s8vector-fold kons knil @vec @vec2 ...procedure
u16vector-fold kons knil @vec @vec2 ...procedure
s16vector-fold kons knil @vec @vec2 ...procedure
u32vector-fold kons knil @vec @vec2 ...procedure
s32vector-fold kons knil @vec @vec2 ...procedure
u64vector-fold kons knil @vec @vec2 ...procedure
s64vector-fold kons knil @vec @vec2 ...procedure
f32vector-fold kons knil @vec @vec2 ...procedure
f64vector-fold kons knil @vec @vec2 ...procedure
c64vector-fold kons knil @vec @vec2 ...procedure
c128vector-fold kons knil @vec @vec2 ...procedure

When one @vector argument @vec is given, folds kons over the elements of @vec in increasing order using knil as the initial value. The kons procedure is called with the state first and the element second, as in SRFIs 43 and 133 (heterogeneous vectors). This is the opposite order to that used in SRFI 1 (lists) and the various string SRFIs.

When multiple @vector arguments are given, kons is called with the current state value and each value from all the vectors; @vector-fold scans elements from left to right. If the lengths of vectors differ, only the portion of each vector up to the length of the shortest vector is scanned.

SRFI 133

u8vector-fold-right kons knil @vec @vec2 ...procedure
s8vector-fold-right kons knil @vec @vec2 ...procedure
u16vector-fold-right kons knil @vec @vec2 ...procedure
s16vector-fold-right kons knil @vec @vec2 ...procedure
u32vector-fold-right kons knil @vec @vec2 ...procedure
s32vector-fold-right kons knil @vec @vec2 ...procedure
u64vector-fold-right kons knil @vec @vec2 ...procedure
s64vector-fold-right kons knil @vec @vec2 ...procedure
f32vector-fold-right kons knil @vec @vec2 ...procedure
f64vector-fold-right kons knil @vec @vec2 ...procedure
c64vector-fold-right kons knil @vec @vec2 ...procedure
c128vector-fold-right kons knil @vec @vec2 ...procedure

When one @vector argument @vec is given, folds kons over the elements of @vec in decreasing order using knil as the initial value. The kons procedure is called with the state first and the element second, as in SRFIs 43 and 133 (heterogeneous vectors). This is the opposite order to that used in SRFI 1 (lists) and the various string SRFIs.

When multiple @vector arguments are given, kons is called with the current state value and each value from all the vectors; @vector-fold-right scans elements from right to left. If the lengths of vectors differ, only the portion of each vector up to the length of the shortest vector is scanned.

SRFI 133

u8vector-map f @vec @vec2 ...procedure
s8vector-map f @vec @vec2 ...procedure
u16vector-map f @vec @vec2 ...procedure
s16vector-map f @vec @vec2 ...procedure
u32vector-map f @vec @vec2 ...procedure
s32vector-map f @vec @vec2 ...procedure
u64vector-map f @vec @vec2 ...procedure
s64vector-map f @vec @vec2 ...procedure
f32vector-map f @vec @vec2 ...procedure
f64vector-map f @vec @vec2 ...procedure
c64vector-map f @vec @vec2 ...procedure
c128vector-map f @vec @vec2 ...procedure

Iterate over the elements of @vec and apply f to each, returning a @vector of the results.

If more than one vector is passed, f gets one element from each vector as arguments. If the lengths of the vectors differ, iteration stops at the end of the shortest vector.

If @vector-map returns more than once (i.e. because of a continuation captured by f), the values returned or stored by earlier returns may be mutated.

SRFI 133

u8vector-map! f @vec @vec2 ...procedure
s8vector-map! f @vec @vec2 ...procedure
u16vector-map! f @vec @vec2 ...procedure
s16vector-map! f @vec @vec2 ...procedure
u32vector-map! f @vec @vec2 ...procedure
s32vector-map! f @vec @vec2 ...procedure
u64vector-map! f @vec @vec2 ...procedure
s64vector-map! f @vec @vec2 ...procedure
f32vector-map! f @vec @vec2 ...procedure
f64vector-map! f @vec @vec2 ...procedure
c64vector-map! f @vec @vec2 ...procedure
c128vector-map! f @vec @vec2 ...procedure

Iterate over the elements of @vec and apply f to each, returning an undefined value with the results placed back in @vec.

If more than one vector is passed, f gets one element from each vector as arguments. If the lengths of the vectors differ, iteration stops at the end of the shortest vector. Only @vec is modified even when multiple vectors are passed.

If @vector-map! returns more than once (i.e. because of a continuation captured by f), the values returned or stored by earlier returns may be mutated.

SRFI 133

u8vector-for-each f @vec @vec2 ...procedure
s8vector-for-each f @vec @vec2 ...procedure
u16vector-for-each f @vec @vec2 ...procedure
s16vector-for-each f @vec @vec2 ...procedure
u32vector-for-each f @vec @vec2 ...procedure
s32vector-for-each f @vec @vec2 ...procedure
u64vector-for-each f @vec @vec2 ...procedure
s64vector-for-each f @vec @vec2 ...procedure
f32vector-for-each f @vec @vec2 ...procedure
f64vector-for-each f @vec @vec2 ...procedure
c64vector-for-each f @vec @vec2 ...procedure
c128vector-for-each f @vec @vec2 ...procedure

Iterate over the elements of @vec and apply f to each, returning an undefined value with no change to the passed @vecs.

If more than one vector is passed, f gets one element from each vector as arguments. If the lengths of the vectors differ, iteration stops at the end of the shortest vector.

SRFI 133

u8vector-count pred? @vec @vec2 ...procedure
s8vector-count pred? @vec @vec2 ...procedure
u16vector-count pred? @vec @vec2 ...procedure
s16vector-count pred? @vec @vec2 ...procedure
u32vector-count pred? @vec @vec2 ...procedure
s32vector-count pred? @vec @vec2 ...procedure
u64vector-count pred? @vec @vec2 ...procedure
s64vector-count pred? @vec @vec2 ...procedure
f32vector-count pred? @vec @vec2 ...procedure
f64vector-count pred? @vec @vec2 ...procedure
c64vector-count pred? @vec @vec2 ...procedure
c128vector-count pred? @vec @vec2 ...procedure

Call pred? on each element of @vec and return the number of calls that return true.

When multiple vectors are given, pred? must take the same number of arguments as the number of vectors, and corresponding elements from each vector are given for each iteration, which stops at the end of the shortest vector.

SRFI 133

u8vector-cumulate f knil @vecprocedure
s8vector-cumulate f knil @vecprocedure
u16vector-cumulate f knil @vecprocedure
s16vector-cumulate f knil @vecprocedure
u32vector-cumulate f knil @vecprocedure
s32vector-cumulate f knil @vecprocedure
u64vector-cumulate f knil @vecprocedure
s64vector-cumulate f knil @vecprocedure
f32vector-cumulate f knil @vecprocedure
f64vector-cumulate f knil @vecprocedure
c64vector-cumulate f knil @vecprocedure
c128vector-cumulate f knil @vecprocedure

Like @vector-fold, but returns an @vector of partial results rather than just the final result.

SRFI 133

Searching

u8vector-take-while pred? @vecprocedure
s8vector-take-while pred? @vecprocedure
u16vector-take-while pred? @vecprocedure
s16vector-take-while pred? @vecprocedure
u32vector-take-while pred? @vecprocedure
s32vector-take-while pred? @vecprocedure
u64vector-take-while pred? @vecprocedure
s64vector-take-while pred? @vecprocedure
f32vector-take-while pred? @vecprocedure
f64vector-take-while pred? @vecprocedure
c64vector-take-while pred? @vecprocedure
c128vector-take-while pred? @vecprocedure

Return the shortest prefix of @vec all of whose elements satisfy pred?.

SRFI 152

u8vector-take-while-right pred? @vecprocedure
s8vector-take-while-right pred? @vecprocedure
u16vector-take-while-right pred? @vecprocedure
s16vector-take-while-right pred? @vecprocedure
u32vector-take-while-right pred? @vecprocedure
s32vector-take-while-right pred? @vecprocedure
u64vector-take-while-right pred? @vecprocedure
s64vector-take-while-right pred? @vecprocedure
f32vector-take-while-right pred? @vecprocedure
f64vector-take-while-right pred? @vecprocedure
c64vector-take-while-right pred? @vecprocedure
c128vector-take-while-right pred? @vecprocedure

Return the shortest suffix of @vec all of whose elements satisfy pred?.

SRFI 152

u8vector-drop-while pred? @vecprocedure
s8vector-drop-while pred? @vecprocedure
u16vector-drop-while pred? @vecprocedure
s16vector-drop-while pred? @vecprocedure
u32vector-drop-while pred? @vecprocedure
s32vector-drop-while pred? @vecprocedure
u64vector-drop-while pred? @vecprocedure
s64vector-drop-while pred? @vecprocedure
f32vector-drop-while pred? @vecprocedure
f64vector-drop-while pred? @vecprocedure
c64vector-drop-while pred? @vecprocedure
c128vector-drop-while pred? @vecprocedure

Drops the longest initial prefix of @vec such that all its elements satisfy pred.

SRFI 152

u8vector-drop-while-right pred? @vecprocedure
s8vector-drop-while-right pred? @vecprocedure
u16vector-drop-while-right pred? @vecprocedure
s16vector-drop-while-right pred? @vecprocedure
u32vector-drop-while-right pred? @vecprocedure
s32vector-drop-while-right pred? @vecprocedure
u64vector-drop-while-right pred? @vecprocedure
s64vector-drop-while-right pred? @vecprocedure
f32vector-drop-while-right pred? @vecprocedure
f64vector-drop-while-right pred? @vecprocedure
c64vector-drop-while-right pred? @vecprocedure
c128vector-drop-while-right pred? @vecprocedure

Drops the longest initial suffix of @vec such that all its elements satisfy pred.

SRFI 152

u8vector-index pred? @vec @vec2 ...procedure
s8vector-index pred? @vec @vec2 ...procedure
u16vector-index pred? @vec @vec2 ...procedure
s16vector-index pred? @vec @vec2 ...procedure
u32vector-index pred? @vec @vec2 ...procedure
s32vector-index pred? @vec @vec2 ...procedure
u64vector-index pred? @vec @vec2 ...procedure
s64vector-index pred? @vec @vec2 ...procedure
f32vector-index pred? @vec @vec2 ...procedure
f64vector-index pred? @vec @vec2 ...procedure
c64vector-index pred? @vec @vec2 ...procedure
c128vector-index pred? @vec @vec2 ...procedure

Return the index of the first element of @vec that satisfies pred?.

When multiple vectors are passed, pred? must take the same number of arguments as the number of vectors, and corresponding elements from each vector are passed for each iteration. If the lengths of vectors differ, iteration stops at the end of the shortest one.

SRFI 133

u8vector-index-right pred? @vec @vec2 ...procedure
s8vector-index-right pred? @vec @vec2 ...procedure
u16vector-index-right pred? @vec @vec2 ...procedure
s16vector-index-right pred? @vec @vec2 ...procedure
u32vector-index-right pred? @vec @vec2 ...procedure
s32vector-index-right pred? @vec @vec2 ...procedure
u64vector-index-right pred? @vec @vec2 ...procedure
s64vector-index-right pred? @vec @vec2 ...procedure
f32vector-index-right pred? @vec @vec2 ...procedure
f64vector-index-right pred? @vec @vec2 ...procedure
c64vector-index-right pred? @vec @vec2 ...procedure
c128vector-index-right pred? @vec @vec2 ...procedure

Return the index of the last element of @vec that satisfies pred?.

When multiple vectors are passed, pred? must take the same number of arguments as the number of vectors, and corresponding elements from each vector are passed for each iteration. Lengths of vectors must be the same.

SRFI 133

u8vector-skip pred? @vec @vec2 ...procedure
s8vector-skip pred? @vec @vec2 ...procedure
u16vector-skip pred? @vec @vec2 ...procedure
s16vector-skip pred? @vec @vec2 ...procedure
u32vector-skip pred? @vec @vec2 ...procedure
s32vector-skip pred? @vec @vec2 ...procedure
u64vector-skip pred? @vec @vec2 ...procedure
s64vector-skip pred? @vec @vec2 ...procedure
f32vector-skip pred? @vec @vec2 ...procedure
f64vector-skip pred? @vec @vec2 ...procedure
c64vector-skip pred? @vec @vec2 ...procedure
c128vector-skip pred? @vec @vec2 ...procedure

Returns the index of the first element of @vec that does not satisfy pred?.

When multiple vectors are passed, pred? must take the same number of arguments as the number of vectors, and corresponding elements from each vector are passed for each iteration. If the lengths of vectors differ, iteration stops at the end of the shortest one.

SRFI 133

u8vector-skip-right pred? @vec @vec2 ...procedure
s8vector-skip-right pred? @vec @vec2 ...procedure
u16vector-skip-right pred? @vec @vec2 ...procedure
s16vector-skip-right pred? @vec @vec2 ...procedure
u32vector-skip-right pred? @vec @vec2 ...procedure
s32vector-skip-right pred? @vec @vec2 ...procedure
u64vector-skip-right pred? @vec @vec2 ...procedure
s64vector-skip-right pred? @vec @vec2 ...procedure
f32vector-skip-right pred? @vec @vec2 ...procedure
f64vector-skip-right pred? @vec @vec2 ...procedure
c64vector-skip-right pred? @vec @vec2 ...procedure
c128vector-skip-right pred? @vec @vec2 ...procedure

Returns the index of the last element of @vec that does not satisfy pred?.

When multiple vectors are passed, pred? must take the same number of arguments as the number of vectors, and corresponding elements from each vector are passed for each iteration. Lengths of vectors must be the same.

SRFI 133

u8vector-any pred? @vec @vec2 ...procedure
s8vector-any pred? @vec @vec2 ...procedure
u16vector-any pred? @vec @vec2 ...procedure
s16vector-any pred? @vec @vec2 ...procedure
u32vector-any pred? @vec @vec2 ...procedure
s32vector-any pred? @vec @vec2 ...procedure
u64vector-any pred? @vec @vec2 ...procedure
s64vector-any pred? @vec @vec2 ...procedure
f32vector-any pred? @vec @vec2 ...procedure
f64vector-any pred? @vec @vec2 ...procedure
c64vector-any pred? @vec @vec2 ...procedure
c128vector-any pred? @vec @vec2 ...procedure

Returns first non-false result of applying pred? on a element from the @vec, or #f if there is no such element. If @vec is empty, returns #t

When multiple vectors are passed, pred? must take the same number of arguments as the number of vectors, and corresponding elements from each vector are passed for each iteration. If the lengths of vectors differ, it stops at the end of the shortest one.

SRFI 133

u8vector-every pred? @vec @vec2 ...procedure
s8vector-every pred? @vec @vec2 ...procedure
u16vector-every pred? @vec @vec2 ...procedure
s16vector-every pred? @vec @vec2 ...procedure
u32vector-every pred? @vec @vec2 ...procedure
s32vector-every pred? @vec @vec2 ...procedure
u64vector-every pred? @vec @vec2 ...procedure
s64vector-every pred? @vec @vec2 ...procedure
f32vector-every pred? @vec @vec2 ...procedure
f64vector-every pred? @vec @vec2 ...procedure
c64vector-every pred? @vec @vec2 ...procedure
c128vector-every pred? @vec @vec2 ...procedure

If all elements from @vec satisfy pred?, return the last result of pred?. If not all do, return #f. If @vec is empty, return #t

When multiple vectors are passed, pred? must take the same number of arguments as the number of vectors, and corresponding elements from each vector is passed for each iteration. If the lengths of vectors differ, it stops at the end of the shortest one.

SRFI 133

u8vector-partition pred? @vecprocedure
s8vector-partition pred? @vecprocedure
u16vector-partition pred? @vecprocedure
s16vector-partition pred? @vecprocedure
u32vector-partition pred? @vecprocedure
s32vector-partition pred? @vecprocedure
u64vector-partition pred? @vecprocedure
s64vector-partition pred? @vecprocedure
f32vector-partition pred? @vecprocedure
f64vector-partition pred? @vecprocedure
c64vector-partition pred? @vecprocedure
c128vector-partition pred? @vecprocedure

Returns an @vector of the same type as @vec, but with all elements satisfying pred? in the leftmost part of the vector and the other elements in the remaining part. The order of elements is otherwise preserved. Returns two values, the new @vector and the number of elements satisfying pred?.

SRFI 133

u8vector-filter pred? @vecprocedure
s8vector-filter pred? @vecprocedure
u16vector-filter pred? @vecprocedure
s16vector-filter pred? @vecprocedure
u32vector-filter pred? @vecprocedure
s32vector-filter pred? @vecprocedure
u64vector-filter pred? @vecprocedure
s64vector-filter pred? @vecprocedure
f32vector-filter pred? @vecprocedure
f64vector-filter pred? @vecprocedure
c64vector-filter pred? @vecprocedure
c128vector-filter pred? @vecprocedure

Return an @vector containing the elements of @vec that satisfy pred?.

SRFI 152

u8vector-remove pred? @vecprocedure
s8vector-remove pred? @vecprocedure
u16vector-remove pred? @vecprocedure
s16vector-remove pred? @vecprocedure
u32vector-remove pred? @vecprocedure
s32vector-remove pred? @vecprocedure
u64vector-remove pred? @vecprocedure
s64vector-remove pred? @vecprocedure
f32vector-remove pred? @vecprocedure
f64vector-remove pred? @vecprocedure
c64vector-remove pred? @vecprocedure
c128vector-remove pred? @vecprocedure

Return an @vector containing the elements of @vec that do not satisfy pred?.

SRFI 152

Mutators

u8vector-set! @vec i valueprocedure
s8vector-set! @vec i valueprocedure
u16vector-set! @vec i valueprocedure
s16vector-set! @vec i valueprocedure
u32vector-set! @vec i valueprocedure
s32vector-set! @vec i valueprocedure
u64vector-set! @vec i valueprocedure
s64vector-set! @vec i valueprocedure
f32vector-set! @vec i valueprocedure
f64vector-set! @vec i valueprocedure
c64vector-set! @vec i valueprocedure
c128vector-set! @vec i valueprocedure

Sets the ith element of @vec to value.

SRFI 4

u8vector-swap! @vec i jprocedure
s8vector-swap! @vec i jprocedure
u16vector-swap! @vec i jprocedure
s16vector-swap! @vec i jprocedure
u32vector-swap! @vec i jprocedure
s32vector-swap! @vec i jprocedure
u64vector-swap! @vec i jprocedure
s64vector-swap! @vec i jprocedure
f32vector-swap! @vec i jprocedure
f64vector-swap! @vec i jprocedure
c64vector-swap! @vec i jprocedure
c128vector-swap! @vec i jprocedure

Interchanges the ith and jth elements of @vec.

u8vector-fill! @vec fill #!optional start endprocedure
s8vector-fill! @vec fill #!optional start endprocedure
u16vector-fill! @vec fill #!optional start endprocedure
s16vector-fill! @vec fill #!optional start endprocedure
u32vector-fill! @vec fill #!optional start endprocedure
s32vector-fill! @vec fill #!optional start endprocedure
u64vector-fill! @vec fill #!optional start endprocedure
s64vector-fill! @vec fill #!optional start endprocedure
f32vector-fill! @vec fill #!optional start endprocedure
f64vector-fill! @vec fill #!optional start endprocedure
c64vector-fill! @vec fill #!optional start endprocedure
c128vector-fill! @vec fill #!optional start endprocedure

Fills the portion of @vec from start to end with the value fill.

SRFI 133

u8vector-reverse! @vec #!optional start endprocedure
s8vector-reverse! @vec #!optional start endprocedure
u16vector-reverse! @vec #!optional start endprocedure
s16vector-reverse! @vec #!optional start endprocedure
u32vector-reverse! @vec #!optional start endprocedure
s32vector-reverse! @vec #!optional start endprocedure
u64vector-reverse! @vec #!optional start endprocedure
s64vector-reverse! @vec #!optional start endprocedure
f32vector-reverse! @vec #!optional start endprocedure
f64vector-reverse! @vec #!optional start endprocedure
c64vector-reverse! @vec #!optional start endprocedure
c128vector-reverse! @vec #!optional start endprocedure

Reverses the portion of @vec from start to end.

SRFI 133

u8vector-copy! @to at @from #!optional start endprocedure
s8vector-copy! @to at @from #!optional start endprocedure
u16vector-copy! @to at @from #!optional start endprocedure
s16vector-copy! @to at @from #!optional start endprocedure
u32vector-copy! @to at @from #!optional start endprocedure
s32vector-copy! @to at @from #!optional start endprocedure
u64vector-copy! @to at @from #!optional start endprocedure
s64vector-copy! @to at @from #!optional start endprocedure
f32vector-copy! @to at @from #!optional start endprocedure
f64vector-copy! @to at @from #!optional start endprocedure
c64vector-copy! @to at @from #!optional start endprocedure
c128vector-copy! @to at @from #!optional start endprocedure

Copies the portion of @from from start to end onto @to, starting at index at.

SRFI 133

u8vector-reverse-copy! @to at @from #!optional start endprocedure
s8vector-reverse-copy! @to at @from #!optional start endprocedure
u16vector-reverse-copy! @to at @from #!optional start endprocedure
s16vector-reverse-copy! @to at @from #!optional start endprocedure
u32vector-reverse-copy! @to at @from #!optional start endprocedure
s32vector-reverse-copy! @to at @from #!optional start endprocedure
u64vector-reverse-copy! @to at @from #!optional start endprocedure
s64vector-reverse-copy! @to at @from #!optional start endprocedure
f32vector-reverse-copy! @to at @from #!optional start endprocedure
f64vector-reverse-copy! @to at @from #!optional start endprocedure
c64vector-reverse-copy! @to at @from #!optional start endprocedure
c128vector-reverse-copy! @to at @from #!optional start endprocedure

The same as @vector-copy!, but copies in reverse.

SRFI 133

u8vector-unfold! f @vec start end seedprocedure
s8vector-unfold! f @vec start end seedprocedure
u16vector-unfold! f @vec start end seedprocedure
s16vector-unfold! f @vec start end seedprocedure
u32vector-unfold! f @vec start end seedprocedure
s32vector-unfold! f @vec start end seedprocedure
u64vector-unfold! f @vec start end seedprocedure
s64vector-unfold! f @vec start end seedprocedure
f32vector-unfold! f @vec start end seedprocedure
f64vector-unfold! f @vec start end seedprocedure
c64vector-unfold! f @vec start end seedprocedure
c128vector-unfold! f @vec start end seedprocedure

Like vector-unfold, but the elements are copied into the vector @vec starting at element start rather than into a newly allocated vector. Terminates when end - start elements have been generated.

SRFI 133

u8vector-unfold-right! f @vec start end seedprocedure
s8vector-unfold-right! f @vec start end seedprocedure
u16vector-unfold-right! f @vec start end seedprocedure
s16vector-unfold-right! f @vec start end seedprocedure
u32vector-unfold-right! f @vec start end seedprocedure
s32vector-unfold-right! f @vec start end seedprocedure
u64vector-unfold-right! f @vec start end seedprocedure
s64vector-unfold-right! f @vec start end seedprocedure
f32vector-unfold-right! f @vec start end seedprocedure
f64vector-unfold-right! f @vec start end seedprocedure
c64vector-unfold-right! f @vec start end seedprocedure
c128vector-unfold-right! f @vec start end seedprocedure

The same as @vector-unfold!, but initializes the @vector from right to left.

SRFI 133

Conversion

u8vector->list @vec #!optional start endprocedure
s8vector->list @vec #!optional start endprocedure
u16vector->list @vec #!optional start endprocedure
s16vector->list @vec #!optional start endprocedure
u32vector->list @vec #!optional start endprocedure
s32vector->list @vec #!optional start endprocedure
u64vector->list @vec #!optional start endprocedure
s64vector->list @vec #!optional start endprocedure
f32vector->list @vec #!optional start endprocedure
f64vector->list @vec #!optional start endprocedure
c64vector->list @vec #!optional start endprocedure
c128vector->list @vec #!optional start endprocedure

Returns a list, with the same elements as the argument.

SRFI 4

reverse-u8vector->list @vec #!optional start endprocedure
reverse-s8vector->list @vec #!optional start endprocedure
reverse-u16vector->list @vec #!optional start endprocedure
reverse-s16vector->list @vec #!optional start endprocedure
reverse-u32vector->list @vec #!optional start endprocedure
reverse-s32vector->list @vec #!optional start endprocedure
reverse-u64vector->list @vec #!optional start endprocedure
reverse-s64vector->list @vec #!optional start endprocedure
reverse-f32vector->list @vec #!optional start endprocedure
reverse-f64vector->list @vec #!optional start endprocedure
reverse-c64vector->list @vec #!optional start endprocedure
reverse-c128vector->list @vec #!optional start endprocedure

Returns a list, with the same elements as the argument in reverse order.

SRFI 133

list->u8vector proper-listprocedure
list->s8vector proper-listprocedure
list->u16vector proper-listprocedure
list->s16vector proper-listprocedure
list->u32vector proper-listprocedure
list->s32vector proper-listprocedure
list->u64vector proper-listprocedure
list->s64vector proper-listprocedure
list->f32vector proper-listprocedure
list->f64vector proper-listprocedure
list->c64vector proper-listprocedure
list->c128vector proper-listprocedure

Returns an @vector with the same elements as the argument.

SRFI 4

reverse-list->u8vector proper-listprocedure
reverse-list->s8vector proper-listprocedure
reverse-list->u16vector proper-listprocedure
reverse-list->s16vector proper-listprocedure
reverse-list->u32vector proper-listprocedure
reverse-list->s32vector proper-listprocedure
reverse-list->u64vector proper-listprocedure
reverse-list->s64vector proper-listprocedure
reverse-list->f32vector proper-listprocedure
reverse-list->f64vector proper-listprocedure
reverse-list->c64vector proper-listprocedure
reverse-list->c128vector proper-listprocedure

Returns an @vector with the same elements as the argument in reverse order.

SRFI 133

u8vector->vector @vec #!optional start endprocedure
s8vector->vector @vec #!optional start endprocedure
u16vector->vector @vec #!optional start endprocedure
s16vector->vector @vec #!optional start endprocedure
u32vector->vector @vec #!optional start endprocedure
s32vector->vector @vec #!optional start endprocedure
u64vector->vector @vec #!optional start endprocedure
s64vector->vector @vec #!optional start endprocedure
f32vector->vector @vec #!optional start endprocedure
f64vector->vector @vec #!optional start endprocedure
c64vector->vector @vec #!optional start endprocedure
c128vector->vector @vec #!optional start endprocedure

Returns a heterogeneous vector with the same elements as the argument.

vector->u8vector vec #!optional start endprocedure
vector->s8vector vec #!optional start endprocedure
vector->u16vector vec #!optional start endprocedure
vector->s16vector vec #!optional start endprocedure
vector->u32vector vec #!optional start endprocedure
vector->s32vector vec #!optional start endprocedure
vector->u64vector vec #!optional start endprocedure
vector->s64vector vec #!optional start endprocedure
vector->f32vector vec #!optional start endprocedure
vector->f64vector vec #!optional start endprocedure
vector->c64vector vec #!optional start endprocedure
vector->c128vector vec #!optional start endprocedure

Returns an @vector with the same elements as the argument.

Generators

make-u8vector-generator @vectorprocedure
make-s8vector-generator @vectorprocedure
make-u16vector-generator @vectorprocedure
make-s16vector-generator @vectorprocedure
make-u32vector-generator @vectorprocedure
make-s32vector-generator @vectorprocedure
make-u64vector-generator @vectorprocedure
make-s64vector-generator @vectorprocedure
make-f32vector-generator @vectorprocedure
make-f64vector-generator @vectorprocedure
make-c64vector-generator @vectorprocedure
make-c128vector-generator @vectorprocedure

Returns a SRFI 121 generator that generates all the values of @vector in order. Note that the generator is finite.

Comparators

u8vector-comparatorconstant
s8vector-comparatorconstant
u16vector-comparatorconstant
s16vector-comparatorconstant
u32vector-comparatorconstant
s32vector-comparatorconstant
u64vector-comparatorconstant
s64vector-comparatorconstant
f32vector-comparatorconstant
f64vector-comparatorconstant
c64vector-comparatorconstant
c128vector-comparatorconstant

Variable containing a SRFI 128 comparator whose components provide ordering and hashing of @vectors.

Output

write-u8vector @vec #!optional portprocedure
write-s8vector @vec #!optional portprocedure
write-u16vector @vec #!optional portprocedure
write-s16vector @vec #!optional portprocedure
write-u32vector @vec #!optional portprocedure
write-s32vector @vec #!optional portprocedure
write-u64vector @vec #!optional portprocedure
write-s64vector @vec #!optional portprocedure
write-f32vector @vec #!optional portprocedure
write-f64vector @vec #!optional portprocedure
write-c64vector @vec #!optional portprocedure
write-c128vector @vec #!optional portprocedure

Prints to port (the current output port by default) a representation of @vec in the lexical syntax explained below.

The SRFI 160 base library

The library (srfi 160 base) is in the repository of this SRFI. It supports the eight procedures of SRFI 4, namely make-@vector, @vector, @vector?, @vector-length, @vector-ref, @vector-set!, @vector->list, and list->@vector, not only for the ten homogeneous vector types supported by SRFI 4, but also for the two homogeneous vector types beyond the scope of SRFI 4, namely c64vectors and c128vectors. In addition, the @? procedure, which is not in SRFI 4, is available for all types.

Acknowledgements

Thanks to all participants in the SRFI 160 mailing list over the unconscionably long time it took me to get this proposal to finalization. Special thanks to Shiro Kawai for bringing up many issues and contributing the code that extended many procedures from one @vector to many.

Authors

Maintainer

Diego A. Mundo

Repository

https://code.dieggsy.com/srfi-160/

Copyright

Copyright © John Cowan 2018.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice (including the next
paragraph) shall be included in all copies or substantial portions of the
Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Version history

0.5.3
Revert breaking build changes in 0.5.2
0.5.2
Build enhancements
0.5.1
Add a record printer/reader, handle non-fixnum length passed to make-c*vector
0.5
Optimize performance using fixnum operations and move-memory!, export c*vector-body
0.4
Fix bugs in @vector-fold-right and @vector-reverse!
0.3
Ensure correct result for @vector= with more than 2 vectors
0.2
Ensure start and end arguments to copy! procedures are optional
0.1
Ported to Chicken Scheme 5

Contents »