Next: Bytevectors, Previous: Vectors, Up: Data structures [Contents][Index]
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.
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.
Create a new uniform vector of the specified type, whose length is the number of values specified, and initialize it using those values.
Return the length (in number of elements) of the uniform vector v.
Return the element at index i of the uniform vector v.
Set the element at index i of uniform vector v to the value x, which must be a number coercible to the appropriate type.
Convert the uniform vetor v to a list containing the elments of v.
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.
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
.
Next: Bytevectors, Previous: Vectors, Up: Data structures [Contents][Index]