Модуль Float.Array

module Array: sig .. end

Массивы чисел с плавающей точкой с упакованным представлением.

type t = floatarray

Тип массивов чисел с плавающей точкой с упакованным представлением.

Since 4.08.0

val length : t -> int

Возвращает длину (количество элементов) заданного floatarray.

val get : t -> int -> float

get a n возвращает элемент с номером n floatarray a.

Raises Invalid_argument если n находится вне диапазона от 0 до (length a - 1).

val set : t -> int -> float -> unit

set a n x изменяет floatarray a на месте, заменяя элемент с номером n на x.

Raises Invalid_argument если n находится вне диапазона от 0 до (length a - 1).

val make : int -> float -> t

make n x возвращает новый floatarray длины n, инициализированный значением x.

Raises Invalid_argument если n < 0 или n > Sys.max_floatarray_length.

val create : int -> t

create n возвращает новый floatarray длины n, с неинициализированными данными.

Raises Invalid_argument если n < 0 или n > Sys.max_floatarray_length.

val init : int -> (int -> float) -> t

init n f возвращает новый floatarray длины n, с элементом с номером i инициализированным результатом f i. Другими словами, init n f табулирует результаты применения f к целым числам от 0 до n-1.

Raises Invalid_argument если n < 0 или n > Sys.max_floatarray_length.

val append : t -> t -> t

append v1 v2 возвращает новый floatarray, содержащий конкатенацию floatarrays v1 и v2.

Raises Invalid_argument если length v1 + length v2 > Sys.max_floatarray_length.

val concat : t list -> t

То же, что и Float.Array.append, но конкатенирует список floatarrays.

val sub : t -> int -> int -> t

sub a pos len возвращает новый floatarray длины len, содержащий элементы с номерами pos по pos + len - 1 floatarray a.

Raises Invalid_argument если pos и len не обозначают допустимый подмассив a; то есть, если pos < 0, или len < 0, или pos + len > length a.

val copy : t -> t

copy a возвращает копию a, то есть новый floatarray, содержащий те же элементы, что и a.

val fill : t -> int -> int -> float -> unit

fill a pos len x изменяет floatarray a на месте, сохраняя x в элементах с номерами pos по pos + len - 1.

Raises Invalid_argument если pos и len не обозначают допустимый подмассив a.

val blit : t -> int -> t -> int -> int -> unit

blit src src_pos dst dst_pos len копирует len элементов из floatarray src, начиная с элемента с номером src_pos, в floatarray dst, начиная с элемента с номером dst_pos.. Это работает корректно даже если src и dst — один и тот же floatarray, и фрагменты источника и назначения перекрываются.

Raises Invalid_argument если src_pos и len не обозначают допустимый подмассив src, или если dst_pos и len не обозначают допустимый подмассив dst.

val to_list : t -> float list

to_list a возвращает список всех элементов a.

val of_list : float list -> t

of_list l возвращает новый floatarray, содержащий элементы l.

Raises Invalid_argument если длина l больше Sys.max_floatarray_length.

Итераторы

val iter : (float -> unit) -> t -> unit

iter f a последовательно применяет функцию f ко всем элементам a. Эквивалентно f a.(0); f a.(1); ...; f a.(length a - 1); ().

val iteri : (int -> float -> unit) -> t -> unit

То же, что и Float.Array.iter, но функция применяется к индексу элемента в качестве первого аргумента, а к самому элементу — в качестве второго.

val map : (float -> float) -> t -> t

map f a применяет функцию f ко всем элементам a, и создаёт floatarray из результатов, возвращаемых f.

val mapi : (int -> float -> float) -> t -> t

То же, что и Float.Array.map, но функция применяется к индексу элемента в качестве первого аргумента, а к самому элементу — в качестве второго.

val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a

fold_left f x init вычисляет f (... (f (f x init.(0)) init.(1)) ...) init.(n-1), где n — длина floatarray init.

val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a

fold_right f a init вычисляет f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), где n — длина floatarray a.

Итераторы по двум массивам

val iter2 : (float -> float -> unit) -> t -> t -> unit

Array.iter2 f a b применяет функцию f ко всем элементам a и b.

Raises Invalid_argument если floatarrays имеют разную длину.

val map2 : (float -> float -> float) -> t -> t -> t

map2 f a b применяет функцию f ко всем элементам a и b, и создаёт floatarray из результатов, возвращаемых f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].

Raises Invalid_argument если floatarrays имеют разную длину.

Сканирование массивов

val for_all : (float -> bool) -> t -> bool

for_all f [|a1; ...; an|] проверяет, удовлетворяют ли все элементы floatarray предикату f. То есть, возвращает (f a1) && (f a2) && ... && (f an).

val exists : (float -> bool) -> t -> bool

exists f [|a1; ...; an|] проверяет, удовлетворяет ли хотя бы один элемент floatarray предикату f. То есть, возвращает (f a1) || (f a2) || ... || (f an).

val mem : float -> t -> bool

mem a set истинно тогда и только тогда, когда существует элемент set структурно равный a, т. е. существует элемент x в set такой, что compare a x = 0.

val mem_ieee : float -> t -> bool

То же, что и Float.Array.mem, но использует IEEE равенство вместо структурного.

Сортировка

val sort : (float -> float -> int) -> t -> unit

Сортирует floatarray в порядке возрастания согласно функции сравнения. Функция сравнения должна возвращать 0, если её аргументы равны, положительное целое число, если первый больше, и отрицательное целое число, если первый меньше (см. полное описание ниже). Например, compare — подходящая функция сравнения. После вызова sort, массив сортируется на месте в порядке возрастания. sort гарантированно работает с постоянным объёмом памяти и (как максимум) логарифмическим объёмом стека.

Текущая реализация использует сортировку кучей. Она работает с постоянным объёмом стека.

Спецификация функции сравнения: Пусть a — floatarray, а cmp — функция сравнения. Следующее должно выполняться для всех x, y, z в a:

cmp x y > 0 тогда и только тогда, когда cmp y x < 0
если cmp x y >= 0 и cmp y z >= 0, то cmp x z >= 0

По завершении работы sort, a содержит те же элементы, что и раньше, но переупорядоченные таким образом, что для всех i и j, являющихся допустимыми индексами a:

cmp a.(i) a.(j) >= 0 тогда и только тогда, когда i >= j

val stable_sort : (float -> float -> int) -> t -> unit

То же, что и Float.Array.sort, но алгоритм сортировки стабильный (т. е. элементы, которые сравниваются как равные, сохраняют свой первоначальный порядок) и не гарантирует работы с постоянным объёмом памяти.

Текущая реализация использует сортировку слиянием. Она использует временный floatarray длиной n/2, где n — длина floatarray. Она обычно быстрее, чем текущая реализация Float.Array.sort.

val fast_sort : (float -> float -> int) -> t -> unit

То же, что и Float.Array.sort или Float.Array.stable_sort, что быстрее на типичном вводе.

Массивы с плавающей точкой и Последовательности

val to_seq : t -> float Seq.t

Итерироваться по floatarray в порядке возрастания. Изменения floatarray во время итерации будут отражены в последовательности.

val to_seqi : t -> (int * float) Seq.t

Итерироваться по floatarray в порядке возрастания, возвращая индексы вдоль элементов. Изменения floatarray во время итерации будут отражены в последовательности.

val of_seq : float Seq.t -> t

Создать массив из генератора.

val map_to_array : (float -> 'a) -> t -> 'a array

map_to_array f a применяет функцию f ко всем элементам a, и создаёт массив с результатами, возвращаемыми f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].

val map_from_array : ('a -> float) -> 'a array -> t

map_from_array f a применяет функцию f ко всем элементам a, и создаёт floatarray с результатами, возвращаемыми f.