Модуль Float.ArrayLabels

module ArrayLabels: 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 -> f:(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.ArrayLabels.append, но конкатенирует список массивов floatarray.

val sub : t -> pos:int -> len: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 -> pos:int -> len:int -> float -> unit

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

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

val blit : src:t ->       src_pos:int -> dst:t -> dst_pos:int -> len: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 : f:(float -> unit) -> t -> unit

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

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

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

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

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

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

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

val fold_left : f:('a -> float -> 'a) -> init:'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 : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a

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

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

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

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

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

val map2 : f:(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 если массивы floatarray имеют разную длину.

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

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

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

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

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

val mem : float -> set:t -> bool

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

val mem_ieee : float -> set:t -> bool

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

Сортировка

val sort : cmp:(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 : cmp:(float -> float -> int) -> t -> unit

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

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

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

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

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

val to_seq : t -> float Seq.t

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

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

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

val of_seq : float Seq.t -> t

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

val map_to_array : f:(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 : f:('a -> float) -> 'a array -> t

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