Uniform vectors are vectors whose elements are of the same numeric type.
The are defined by SRFI-4.
The type names (such as s8vector) are a Kawa extension.
uniform-vector ::= # uniform-tag list
uniform-tag ::= f32 | f64
| s8 | s16 | s32 | s64
| u8 | u16 | u32 | u64
This example is a literal for a 5-element vector of unsigned short (ushort) values:
(define uvec1 #u16(64000 3200 160 8 0))
Since a uniform vector is a sequence, you can use function-call
notation to index one. For example:
(uvec1 1) ⇒ 3200
In this case the result is a primitive unsigned short (ushort),
which is converted to a gnu.math.UShort if an object is needed.
Type: s8vector
The type of uniform vectors where each element can contain
a signed 8-bit integer. Represented using an array of byte.
Type: u8vector
The type of uniform vectors where each element can contain
an unsigned 8-bit integer. Represented using an array of <byte>,
but each element is treated as if unsigned.
This type is a synonym for bytevector,
which has extra functions.
Type: s16vector
The type of uniform vectors where each element can contain
a signed 16-bit integer. Represented using an array of short.
Type: u16vector
The type of uniform vectors where each element can contain
an unsigned 16-bit integer. Represented using an array of short,
but each element is treated as if unsigned.
Type: s32vector
The type of uniform vectors where each element can contain
a signed 32-bit integer. Represented using an array of int.
Type: u32vector
The type of uniform vectors where each element can contain
an unsigned 32-bit integer. Represented using an array of int,
but each element is treated as if unsigned.
Type: s64vector
The type of uniform vectors where each element can contain
a signed 64-bit integer. Represented using an array of long.
Type: u64vector
The type of uniform vectors where each element can contain
an unsigned 64-bit integer. Represented using an array of long,
but each element is treated as if unsigned.
Type: f32vector
The type of uniform vectors where each element can contain
a 32-bit floating-point real. Represented using an array of float.
Type: f64vector
The type of uniform vectors where each element can contain
a 64-bit floating-point real. Represented using an array of double.
Procedure: s8vector? value
Procedure: u8vector? value
Procedure: s16vector? value
Procedure: u16vector? value
Procedure: s32vector? value
Procedure: u32vector? value
Procedure: s64vector? value
Procedure: u64vector? value
Procedure: f32vector? value
Procedure: f64vector? value
Return true iff value is a uniform vector of the specified type.
Procedure: make-s8vector n [value]
Procedure: make-u8vector n [value]
Procedure: make-s16vector n [value]
Procedure: make-u16vector n [value]
Procedure: make-s32vector n [value]
Procedure: make-u32vector n [value]
Procedure: make-s64vector n [value]
Procedure: make-u64vector n [value]
Procedure: make-f32vector n [value]
Procedure: make-f64vector n [value]
Create a new uniform vector of the specified type,
having room for n elements.
Initialize each element to value if it is specified; zero otherwise.
Constructor: s8vector value ...
Constructor: u8vector value ...
Constructor: s16vector value ..
Constructor: u16vector value ...
Constructor: s32vector value ...
Constructor: u32vector value ...
Constructor: s64vector value ...
Constructor: u64vector value ...
Constructor: f32vector value ...
Constructor: f64vector value ...
Create a new uniform vector of the specified type,
whose length is the number of values specified,
and initialize it using those values.
Procedure: s8vector-length v
Procedure: u8vector-length v
Procedure: s16vector-length v
Procedure: u16vector-length v
Procedure: s32vector-length v
Procedure: u32vector-length v
Procedure: s64vector-length v
Procedure: u64vector-length v
Procedure: f32vector-length v
Procedure: f64vector-length v
Return the length (in number of elements) of the uniform vector v.
Procedure: s8vector-ref v i
Procedure: u8vector-ref v i
Procedure: s16vector-ref v i
Procedure: u16vector-ref v i
Procedure: s32vector-ref v i
Procedure: u32vector-ref v i
Procedure: s64vector-ref v i
Procedure: u64vector-ref v i
Procedure: f32vector-ref v i
Procedure: f64vector-ref v i
Return the element at index i of the uniform vector v.
Procedure: s8vector-set! v i x
Procedure: u8vector-set! v i x
Procedure: s16vector-set! v i x
Procedure: u16vector-set! v i x
Procedure: s32vector-set! v i x
Procedure: u32vector-set! v i x
Procedure: s64vector-set! v i x
Procedure: u64vector-set! v i x
Procedure: f32vector-set! v i x
Procedure: f64vector-set! v i x
Set the element at index i of uniform vector v
to the value x, which must be a number coercible
to the appropriate type.
Procedure: s8vector->list v
Procedure: u8vector->list v
Procedure: s16vector->list v
Procedure: u16vector->list v
Procedure: s32vector->list v
Procedure: u32vector->list v
Procedure: s64vector->list v
Procedure: u64vector->list v
Procedure: f32vector->list v
Procedure: f64vector->list v
Convert the uniform vetor v to a list containing the elments of v.
Procedure: list->s8vector l
Procedure: list->u8vector l
Procedure: list->s16vector l
Procedure: list->u16vector l
Procedure: list->s32vector l
Procedure: list->u32vector l
Procedure: list->s64vector l
Procedure: list->u64vector l
Procedure: list->f32vector l
Procedure: list->f64vector l
Create a uniform vector of the appropriate type, initializing it
with the elements of the list l. The elements of l
must be numbers coercible the new vector’s element type.
Relationship with Java arrays
Each uniform array type is implemented as an underlying Java array,
and a length field.
The underlying type is
byte[] for u8vector or s8vector;
short[] for u16vector or u16vector;
int[] for u32vector or s32vector;
long[] for u64vector or s64vector;
float[] for f32vector; and
double[] for f32vector.
The length field allows a uniform array to only use the
initial part of the underlying array. (This can be used
to support Common Lisp’s fill pointer feature.)
This also allows resizing a uniform vector. There is no
Scheme function for this, but you can use the setSize method:
(invoke some-vector 'setSize 200)
If you have a Java array, you can create a uniform vector
sharing with the Java array:
(define arr :: byte[] ((primitive-array-new byte) 10))
(define vec :: u8vector (make u8vector arr))
At this point vec uses arr for its underlying storage,
so changes to one affect the other.
It vec is re-sized so it needs a larger underlying array,
then it will no longer use arr.
