Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
ArrayLabels(3)			 OCaml library			ArrayLabels(3)

NAME
       ArrayLabels - Array operations.

Module
       Module	ArrayLabels

Documentation
       Module ArrayLabels
	: sig end

       Array operations.

       val length : 'a array ->	int

       Return the length (number of elements) of the given array.

       val get : 'a array -> int -> 'a

       ArrayLabels.get	a  n  returns  the  element number n of	array a	.  The
       first element has number	0.   The  last	element	 has  number  ArrayLa-
       bels.length  a  -  1  .	 You  can also write a.(n) instead of ArrayLa-
       bels.get	a n .

       Raise Invalid_argument index out	of bounds if n is outside the range  0
       to (ArrayLabels.length a	- 1) .

       val set : 'a array -> int -> 'a -> unit

       ArrayLabels.set a n x modifies array a in place,	replacing element num-
       ber n with x .  You can also write  a.(n)  <-  x	 instead  of  ArrayLa-
       bels.set	a n x .

       Raise  Invalid_argument index out of bounds if n	is outside the range 0
       to ArrayLabels.length a - 1 .

       val make	: int -> 'a -> 'a array

       ArrayLabels.make	n x returns a fresh array of length  n	,  initialized
       with  x	.  All the elements of this new	array are initially physically
       equal to	x (in the sense	of the == predicate).  Consequently, if	 x  is
       mutable,	 it is shared among all	elements of the	array, and modifying x
       through one of the array	entries	will modify all	other entries  at  the
       same time.

       Raise  Invalid_argument	if n < 0 or n >	Sys.max_array_length .	If the
       value of	x is a floating-point number, then the maximum	size  is  only
       Sys.max_array_length / 2	.

       val create : int	-> 'a -> 'a array

       Deprecated.

       ArrayLabels.create is an	alias for ArrayLabels.make .

       val init	: int -> f:(int	-> 'a) -> 'a array

       ArrayLabels.init	 n  f returns a	fresh array of length n	, with element
       number i	initialized to the result of f i .  In other  terms,  ArrayLa-
       bels.init  n  f tabulates the results of	f applied to the integers 0 to
       n-1 .

       Raise Invalid_argument if n < 0 or n > Sys.max_array_length .   If  the
       return  type  of	f is float , then the maximum size is only Sys.max_ar-
       ray_length / 2 .

       val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array	array

       ArrayLabels.make_matrix dimx dimy e returns a two-dimensional array (an
       array  of arrays) with first dimension dimx and second dimension	dimy .
       All the elements	of this	new matrix are initially physically equal to e
       .   The	element	 (  x,y	 ) of a	matrix m is accessed with the notation
       m.(x).(y) .

       Raise Invalid_argument if dimx or dimy  is  negative  or	 greater  than
       Sys.max_array_length  .	 If the	value of e is a	floating-point number,
       then the	maximum	size is	only Sys.max_array_length / 2 .

       val create_matrix : dimx:int -> dimy:int	-> 'a -> 'a array array

       Deprecated.

       ArrayLabels.create_matrix is an alias for ArrayLabels.make_matrix .

       val append : 'a array ->	'a array -> 'a array

       ArrayLabels.append v1 v2	returns	a fresh	array containing the  concate-
       nation of the arrays v1 and v2 .

       val concat : 'a array list -> 'a	array

       Same as ArrayLabels.append , but	concatenates a list of arrays.

       val sub : 'a array -> pos:int ->	len:int	-> 'a array

       ArrayLabels.sub	a start	len returns a fresh array of length len	, con-
       taining the elements number start to start + len	- 1 of array a .

       Raise Invalid_argument Array.sub	if start and len do  not  designate  a
       valid  subarray	of a ; that is,	if start < 0 , or len <	0 , or start +
       len > ArrayLabels.length	a .

       val copy	: 'a array -> 'a array

       ArrayLabels.copy	a returns a copy of a ,	that is, a  fresh  array  con-
       taining the same	elements as a .

       val fill	: 'a array -> pos:int -> len:int -> 'a -> unit

       ArrayLabels.fill	 a  ofs	len x modifies the array a in place, storing x
       in elements number ofs to ofs + len - 1 .

       Raise Invalid_argument Array.fill if ofs	and len	 do  not  designate  a
       valid subarray of a .

       val  blit  : src:'a array -> src_pos:int	-> dst:'a array	-> dst_pos:int
       -> len:int -> unit

       ArrayLabels.blit	v1 o1 v2 o2 len	copies len elements from  array	 v1  ,
       starting	 at element number o1 ,	to array v2 , starting at element num-
       ber o2 .	It works correctly even	if v1 and v2 are the same  array,  and
       the source and destination chunks overlap.

       Raise  Invalid_argument	Array.blit  if	o1  and	len do not designate a
       valid subarray of v1 , or if o2 and len do not designate	a valid	subar-
       ray of v2 .

       val to_list : 'a	array -> 'a list

       ArrayLabels.to_list a returns the list of all the elements of a .

       val of_list : 'a	list ->	'a array

       ArrayLabels.of_list  l returns a	fresh array containing the elements of
       l .

       val iter	: f:('a	-> unit) -> 'a array ->	unit

       ArrayLabels.iter	f a applies function f in turn to all the elements  of
       a .  It is equivalent to	f a.(0); f a.(1); ...; f a.(ArrayLabels.length
       a - 1); () .

       val map : f:('a -> 'b) -> 'a array -> 'b	array

       ArrayLabels.map f a applies function f to all the elements of a	,  and
       builds  an  array with the results returned by f	: [| f a.(0); f	a.(1);
       ...; f a.(ArrayLabels.length a -	1) |] .

       val iteri : f:(int -> 'a	-> unit) -> 'a array ->	unit

       Same as ArrayLabels.iter	, but the function is applied to the index  of
       the  element  as	first argument,	and the	element	itself as second argu-
       ment.

       val mapi	: f:(int -> 'a -> 'b) -> 'a array -> 'b	array

       Same as ArrayLabels.map , but the function is applied to	the  index  of
       the  element  as	first argument,	and the	element	itself as second argu-
       ment.

       val fold_left : f:('a ->	'b -> 'a) -> init:'a ->	'b array -> 'a

       ArrayLabels.fold_left f x a computes f (... (f (f x a.(0)) a.(1))  ...)
       a.(n-1) , where n is the	length of the array a .

       val fold_right :	f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a

       ArrayLabels.fold_right f	a x computes f a.(0) (f	a.(1) (	... (f a.(n-1)
       x) ...))	 , where n is the length of the	array a	.

       === Sorting ===

       val sort	: cmp:('a -> 'a	-> int)	-> 'a array -> unit

       Sort an array in	increasing order according to a	 comparison  function.
       The  comparison	function  must	return	0  if its arguments compare as
       equal, a	positive integer if the	first is greater, and a	negative inte-
       ger  if	the first is smaller (see below	for a complete specification).
       For example, Pervasives.compare is a suitable comparison	function, pro-
       vided  there are	no floating-point NaN values in	the data.  After call-
       ing ArrayLabels.sort , the array	is sorted in place in  increasing  or-
       der.   ArrayLabels.sort is guaranteed to	run in constant	heap space and
       (at most) logarithmic stack space.

       The current implementation uses Heap Sort.  It runs in  constant	 stack
       space.

       Specification  of  the  comparison function: Let	a be the array and cmp
       the comparison function.	 The following must be true for	all x, y, z in
       a :

       - cmp x y > 0 if	and only if cmp	y x < 0

       -  if cmp x y >=	0 and cmp y z >= 0 then	cmp x z	>= 0

       When  ArrayLabels.sort returns, a contains the same elements as before,
       reordered in such a way that for	all i and j valid indices of a :

       - cmp a.(i) a.(j) >= 0 if and only if i >= j

       val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit

       Same as ArrayLabels.sort	, but the sorting algorithm  is	 stable	 (i.e.
       elements	 that  compare equal are kept in their original	order) and not
       guaranteed to run in constant heap space.

       The current implementation uses Merge Sort. It uses n/2 words  of  heap
       space,  where  n	is the length of the array.  It	is usually faster than
       the current implementation of ArrayLabels.sort .

       val fast_sort : cmp:('a -> 'a ->	int) ->	'a array -> unit

       Same as ArrayLabels.sort	 or  ArrayLabels.stable_sort  ,	 whichever  is
       faster on typical input.

       === Undocumented	functions ===

       val unsafe_get :	'a array -> int	-> 'a

       val unsafe_set :	'a array -> int	-> 'a -> unit

OCamldoc			  2017-04-30			ArrayLabels(3)

NAME | Module | Documentation

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=ArrayLabels&sektion=3o&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help