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.
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
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 tovalue
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
value
s specified, and initialize it using thosevalue
s.
Return the length (in number of elements) of the uniform vector
v
.
Return the element at index
i
of the uniform vectorv
.
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 vectorv
to the valuex
, which must be a number coercible to the appropriate type.
Convert the uniform vetor
v
to a list containing the elments ofv
.
Create a uniform vector of the appropriate type, initializing it with the elements of the list
l
. The elements ofl
must be numbers coercible the new vector’s element type.
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
.