API / Js / Typed_array / Float32array

Float32Array

elt

RESCRIPT
type elt = float

typed_array

RESCRIPT
type typed_array< 'a, > = Js_typed_array2.Float32Array.typed_array<'a>

t

RESCRIPT
type t = typed_array<elt>

unsafe_get

RESCRIPT
let unsafe_get: (t, int) => elt

unsafe_set

RESCRIPT
let unsafe_set: (t, int, elt) => unit

buffer

RESCRIPT
let buffer: t => array_buffer

byteLength

RESCRIPT
let byteLength: t => int

byteOffset

RESCRIPT
let byteOffset: t => int

setArray

RESCRIPT
let setArray: (array<elt>, t) => unit

setArrayOffset

RESCRIPT
let setArrayOffset: (array<elt>, int, t) => unit

length

RESCRIPT
let length: t => int

copyWithin

RESCRIPT
let copyWithin: (~to_: int, t) => t

copyWithinFrom

RESCRIPT
let copyWithinFrom: (~to_: int, ~from: int, t) => t

copyWithinFromRange

RESCRIPT
let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t

fillInPlace

RESCRIPT
let fillInPlace: (elt, t) => t

fillFromInPlace

RESCRIPT
let fillFromInPlace: (elt, ~from: int, t) => t

fillRangeInPlace

RESCRIPT
let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t

reverseInPlace

RESCRIPT
let reverseInPlace: t => t

sortInPlace

RESCRIPT
let sortInPlace: t => t

sortInPlaceWith

RESCRIPT
let sortInPlaceWith: ((elt, elt) => int, t) => t

includes

RESCRIPT
let includes: (elt, t) => bool

indexOf

RESCRIPT
let indexOf: (elt, t) => int

indexOfFrom

RESCRIPT
let indexOfFrom: (elt, ~from: int, t) => int

join

RESCRIPT
let join: t => string

joinWith

RESCRIPT
let joinWith: (string, t) => string

lastIndexOf

RESCRIPT
let lastIndexOf: (elt, t) => int

lastIndexOfFrom

RESCRIPT
let lastIndexOfFrom: (elt, ~from: int, t) => int

slice

RESCRIPT
let slice: (~start: int, ~end_: int, t) => t

copy

RESCRIPT
let copy: t => t

sliceFrom

RESCRIPT
let sliceFrom: (int, t) => t

subarray

RESCRIPT
let subarray: (~start: int, ~end_: int, t) => t

subarrayFrom

RESCRIPT
let subarrayFrom: (int, t) => t

toString

RESCRIPT
let toString: t => string

toLocaleString

RESCRIPT
let toLocaleString: t => string

every

RESCRIPT
let every: (elt => bool, t) => bool

everyi

RESCRIPT
let everyi: ((elt, int) => bool, t) => bool

filter

RESCRIPT
let filter: (elt => bool, t) => t

filteri

RESCRIPT
let filteri: ((elt, int) => bool, t) => t

find

RESCRIPT
let find: (elt => bool, t) => Js.undefined<elt>

findi

RESCRIPT
let findi: ((elt, int) => bool, t) => Js.undefined<elt>

findIndex

RESCRIPT
let findIndex: (elt => bool, t) => int

findIndexi

RESCRIPT
let findIndexi: ((elt, int) => bool, t) => int

forEach

RESCRIPT
let forEach: (elt => unit, t) => unit

forEachi

RESCRIPT
let forEachi: ((elt, int) => unit, t) => unit

map

RESCRIPT
let map: (elt => 'a, t) => typed_array<'a>

mapi

RESCRIPT
let mapi: ((elt, int) => 'a, t) => typed_array<'a>

reduce

RESCRIPT
let reduce: (('a, elt) => 'a, 'a, t) => 'a

reducei

RESCRIPT
let reducei: (('a, elt, int) => 'a, 'a, t) => 'a

reduceRight

RESCRIPT
let reduceRight: (('a, elt) => 'a, 'a, t) => 'a

reduceRighti

RESCRIPT
let reduceRighti: (('a, elt, int) => 'a, 'a, t) => 'a

some

RESCRIPT
let some: (elt => bool, t) => bool

somei

RESCRIPT
let somei: ((elt, int) => bool, t) => bool

_BYTES_PER_ELEMENT

RESCRIPT
let _BYTES_PER_ELEMENT: int

make

RESCRIPT
let make: array<elt> => t

fromBuffer

RESCRIPT
let fromBuffer: array_buffer => t

can throw

fromBufferOffset

RESCRIPT
let fromBufferOffset: (array_buffer, int) => t

raise Js.Exn.Error raise Js exception

param offset is in bytes

fromBufferRange

RESCRIPT
let fromBufferRange: (array_buffer, ~offset: int, ~length: int) => t

raise Js.Exn.Error raises Js exception

param offset is in bytes, length in elements

fromLength

RESCRIPT
let fromLength: int => t

from

RESCRIPT
let from: array_like<elt> => t

create

Deprecated

use make instead

RESCRIPT
let create: array<float> => t

of_buffer

Deprecated

use fromBuffer instead

RESCRIPT
let of_buffer: array_buffer => t