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.

The type of uniform vectors where each element can contain a signed 8-bit integer. Represented using an array of

`byte`

.

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.

The type of uniform vectors where each element can contain a signed 16-bit integer. Represented using an array of

`short`

.

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.

The type of uniform vectors where each element can contain a signed 32-bit integer. Represented using an array of

`int`

.

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.

The type of uniform vectors where each element can contain a signed 64-bit integer. Represented using an array of

`long`

.

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.

The type of uniform vectors where each element can contain a 32-bit floating-point real. Represented using an array of

`float`

.

The type of uniform vectors where each element can contain a 64-bit floating-point real. Represented using an array of

`double`

.

Return true iff

is a uniform vector of the specified type.`value`

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

elements. Initialize each element to`n`

if it is specified; zero otherwise.`value`

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

s specified, and initialize it using those`value`

s.`value`

Return the length (in number of elements) of the uniform vector

.`v`

Return the element at index

of the uniform vector`i`

.`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

of uniform vector`i`

to the value`v`

, which must be a number coercible to the appropriate type.`x`

Convert the uniform vetor

to a list containing the elments of`v`

.`v`

Create a uniform vector of the appropriate type, initializing it with the elements of the list

. The elements of`l`

must be numbers coercible the new vector’s element type.`l`

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`

.