Uniform vectors

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.