package slap

The signature of modules containing dynamically-sized contiguous vectors.

The signature of modules containing dynamically-sized discrete vectors.

Recover polymorphism of the fourth type parameter.

An empty vector.

create n

• returns

  a fresh n-dimensional vector (not initialized).

make n a

• returns

  a fresh n-dimensional vector initialized with a.

zeros n

• returns

  a fresh n-dimensional vector initialized with 0.

make1 n

• returns

  a fresh n-dimensional vector initialized with 1.

init n f

• returns

  a fresh vector (f 1, ..., f n) with n elements.

dim x

• returns

  the dimension of the vector x.

get_dyn x i

• returns

  the i-th element of the vector x.

set_dyn x i a assigns a to the i-th element of the vector x.

Like get_dyn, but size checking is not always performed.

Like set_dyn, but size checking is not always performed.

replace_dyn v i f is set_dyn v i (f (get_dyn v i)).

cons ?y e x adds element e at the beginning of vector x, and copies it into y.

• returns

  the vector y, which is overwritten.

• parameter y

  default = a fresh vector.

• since 4.0.0

• returns

  the first element of a given vector. (typesafe)

• since 4.0.0

• returns

  the first element of a given vector.

• since 4.0.0

• returns

  the last element of a given vector. (typesafe)

• since 4.0.0

• returns

  the last element of a given vector.

• since 4.0.0

• returns

  a given vector without the first element. (typesafe)

• parameter share

  true if a returned subvector refers a given vector (default = false)

• since 4.0.0

• returns

  a given vector without the first element.

• parameter share

  true if a returned subvector refers a given vector (default = false)

• since 4.0.0

• returns

  a given vector without the first element. (typesafe) This is the same as init in Haskell.

• parameter share

  true if a returned subvector refers a given vector (default = false)

• since 4.0.0

• returns

  a given vector without the first element. This is the same as init in Haskell.

• parameter share

  true if a returned subvector refers a given vector (default = false)

• since 4.0.0

copy ?y x copies the vector x to the vector y with the BLAS-1 function [sdcz]copy.

• returns

  the vector y, which is overwritten.

• parameter y

  default = a fresh vector.

Fill the given vector with the given value.

Concatenate two vectors.

shared_rev (x1, x2, ..., xn)

• returns

  reversed vector (xn, ..., x2, x1). The data are shared.

rev (x1, x2, ..., xn)

• returns

  reversed vector (xn, ..., x2, x1). The data are NOT shared.

to_array x

• returns

  the array of all the elements of the vector x.

of_array_dyn n [|a1; ...; an|]

• raises Invalid_argument

  the length of the given array is not equal to n.

• returns

  a fresh vector (a1, ..., an).

module V = (val of_array [|a1; ...; an|] : CNTVEC)

• returns

  module V containing the vector V.value (= (a1, ..., an)) that has the type (V.n, 'cnt) vec with a generative phantom type V.n as a package of an existential quantified sized type like exists n. (n, 'cnt) vec.

A functor version of of_array.

Like of_array_dyn, but size checking is not always performed.

• since 1.0.0

to_list x

• returns

  the list of all the elements of the vector x.

of_list_dyn n [a1; ...; an]

• raises Invalid_argument

  the length of the given list is not equal to n.

• returns

  a fresh vector (a1, ..., an).

module V = (val of_list [a1; ...; an] : CNTVEC)

• returns

  module V containing the vector V.value (= (a1, ..., an)) that has the type (V.n, 'cnt) vec with a generative phantom type V.n as a package of an existential quantified sized type like exists n. (n, 'cnt) vec.

A functor version of of_list.

Like of_list_dyn, but size checking is not always performed.

• since 1.0.0

to_bigarray x

• returns

  the big array of all the elements of the vector x.

of_bigarray_dyn ?share n ba

• raises Invalid_argument

  the length of the given big array is not equal to n.

• returns

  a fresh vector of all the elements of big array ba.

• parameter share

  true if data are shared. (default = false)

module V = (val of_bigarray ?share n ba : CNTVEC)

• returns

  module V containing the vector V.value (of all elements of big array ba) that has the type (V.n, 'cnt) vec with a generative phantom type V.n as a package of an existential quantified sized type like exists n. (n, 'cnt) vec.

• parameter share

  true if data are shared. (default = false)

A functor version of of_bigarray.

Like of_bigarray_dyn, but size checking is not always performed.

• since 1.0.0

let Slap.Vec.VEC n = of_array_c [|a1; ...; an|]

• returns

  a constructor VEC that has a vector (a1, ..., an) that has the existential quantified sized type exists n. (n, 'num, 'prec, 'cnt_or_dsc) Vec.t. "c" of of_array_c means a "c"onstructor of GADT. This function is available in OCaml 4.00 or above.

• since 4.0.0

let Slap.Vec.VEC n = of_list_c [a1; ...; an]

• returns

  a constructor VEC that has a vector (a1, ..., an) that has the existential quantified sized type exists n. (n, 'num, 'prec, 'cnt_or_dsc) Vec.t. "c" of of_list_c means a "c"onstructor of GADT. This function is available in OCaml 4.00 or above.

• since 4.0.0

let Slap.Vec.VEC n = of_bigarray_c ?share ba

• returns

  a constructor VEC that has a vector (of all the elements of big array ba) that has the existential quantified sized type exists n. (n, 'num, 'prec, 'cnt_or_dsc) Vec.t. "c" of of_bigarray_c means a "c"onstructor of GADT. This function is available in OCaml 4.00 or above.

• parameter share

  true if data are shared. (default = false)

• since 4.0.0

map f ?y (x1, ..., xn) is (f x1, ..., f xn).

• returns

  the vector y, which is overwritten.

• parameter y

  default = a fresh vector.

mapi f ?y (x1, ..., xn) is (f 1 x1, ..., f n xn) with the vector's dimension n.

• returns

  the vector y, which is overwritten.

• parameter y

  default = a fresh vector.

fold_left f init (x1, x2, ..., xn) is f (... (f (f init x1) x2) ...) xn.

fold_lefti f init (x1, x2, ..., xn) is f n (... (f 2 (f 1 init x1) x2) ...) xn with the vector's dimension n.

fold_right f (x1, x2, ..., xn) init is f x1 (f x2 (... (f xn init) ...)).

fold_righti f (x1, x2, ..., xn) init is f 1 x1 (f 2 x2 (... (f n xn init) ...)) with the vector's dimension n.

replace_all x f modifies the vector x in place -- the i-th element xi of x will be set to f xi.

replace_alli x f modifies the vector x in place -- the i-th element xi of x will be set to f i xi.

iter f (x1, x2, ..., xn) is f x1; f x2; ...; f xn.

iteri f (x1, x2, ..., xn) is f 1 x1; f 2 x2; ...; f n xn.

map2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f x1 y1, f x2 y2, ..., f xn yn).

• returns

  the vector z, which is overwritten.

• parameter z

  default = a fresh vector.

mapi2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f 1 x1 y1, f 2 x2 y2, ..., f n xn yn) with the vectors' dimension n.

• returns

  the vector z, which is overwritten.

• parameter z

  default = a fresh vector.

fold_left2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f (... (f (f init x1 y1) x2 y2) ...) xn yn.

fold_lefti2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f n (... (f 2 (f 1 init x1 y1) x2 y2) ...) xn yn with the vectors' dimension n.

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f x1 y1 (f x2 y2 (... (f xn yn init) ...)).

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f 1 x1 y1 (f 2 x2 y2 (... (f n xn yn init) ...)) with the vectors' dimension n.

iter2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f x1 y1; f x2 y2; ...; f xn yn.

iteri2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f 1 x1 y1; f 2 x2 y2; ...; f n xn yn.

map3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f x1 y1 z1, f x2 y2 z2, ..., f xn yn zn).

• returns

  the vector w, which is overwritten.

• parameter w

  default = a fresh vector.

mapi3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f 1 x1 y1 z1, f 2 x2 y2 z2, ..., f n xn yn zn) with the vectors' dimension n.

• returns

  the vector w, which is overwritten.

• parameter w

  default = a fresh vector.

fold_left3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f (... (f (f init x1 y1 z1) x2 y2 z2) ...) xn yn zn.

fold_lefti3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f n (... (f 2 (f 1 init x1 y1 z1) x2 y2 z2) ...) xn yn zn with the vectors' dimension n.

fold_right3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f x1 y1 z1 (f x2 y2 z2 (... (f xn yn zn init) ...)).

fold_righti3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f 1 x1 y1 z1 (f 2 x2 y2 z2 (... (f n xn yn zn init) ...)) with the vectors' dimension n.

iter3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f x1 y1 z1; f x2 y2 z2; ...; f xn yn zn.

iteri3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f 1 x1 y1 z1; f 2 x2 y2 z2; ...; f n xn yn zn.

for_all p (x1, x2, ..., xn) is (p x1) && (p x2) && ... && (p xn).

• returns

  true if and only if all elements of the given vector satisfy the predicate p.

exists p (x1, x2, ..., xn) is (p x1) || (p x2) || ... || (p xn).

• returns

  true if and only if at least one element of the given vector satisfies the predicate p.

for_all2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) && (p x2 y2) && ... && (p xn yn).

• returns

  true if and only if all elements of the given two vectors satisfy the predicate p.

exists2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) || (p x2 y2) || ... || (p xn yn).

• returns

  true if and only if at least one pair of elements of the given two vectors satisfies the predicate p.

max x

• returns

  the largest element in x. NaNs is ignored. If only NaNs are encountered, the negative infinity value is returned.

min x

• returns

  the smallest element in x. NaNs is ignored. If only NaNs are encountered, the positive infinity value is returned.

sum x

• returns

  the sum of all elements in x.

prod x

• returns

  the product of all elements in x.

add_const c ?y x adds constant value c to all elements in vector x.

• returns

  the vector y, which is overwritten.

• since 0.1.0

sqr_nrm2 ?stable x computes the square of the 2-norm (Euclidean norm) of vector x.

• parameter stable

  default = false.

  • If stable = true, BLAS function nrm2 is used;
  • If stable = false, BLAS function dot is used instead for greatly improved performance.

ssqr ?c (x1, x2, ..., xn) computes the sum of squared differences of the elements in the given vector from scalar value c: (x1 - c)^2 + (x2 - c)^2 + ... + (xn - c)^2.

• parameter c

  default = 0.0.

sort ?cmp ?decr ?p x sorts the elements in vector x in increasing order according to the comparison function cmp.

• parameter cmp

  default = the usual order (on real numbers) or the lexicographic order (on complex numbers).

  • cmp a b < 0 iff a < b;
  • cmp a b = 0 iff a = b;
  • cmp a b > 0 iff a > b.
  • NaNs must be considered larger than any other value.

• parameter decr

  sort in decreasing order.

• parameter p

  If p is passed, x is unchanged and the permutation is stored into p. (default = None.)

neg ?y (x1, x2, ..., xn) returns (-x1, -x2, ..., -xn).

• returns

  the vector y, which is overwritten.

reci ?y (x1, x2, ..., xn) returns (1 / x1, 1 / x2, ..., 1 / xn).

• returns

  the vector y, which is overwritten.

• since 0.1.0

add ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 + y1, x2 + y2, ..., xn + yn).

• returns

  the vector z, which is overwritten.

sub ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 - y1, x2 - y2, ..., xn - yn).

• returns

  the vector z, which is overwritten.

mul ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 * y1, x2 * y2, ..., xn * yn).

• returns

  the vector z, which is overwritten.

div ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 / y1, x2 / y2, ..., xn / yn).

• returns

  the vector z, which is overwritten.

zpxy (z1, z2, ..., zn) (x1, x2, ..., xn) (y1, y2, ..., yn) returns (z1 + x1 * y1, z2 + x2 * y2, ..., zn + xn * yn). This function is useful for convolutions.

• returns

  the vector z, which is overwritten.

• since 0.1.0

zmxy (z1, z2, ..., zn) (x1, x2, ..., xn) (y1, y2, ..., yn) returns (z1 - x1 * y1, z2 - x2 * y2, ..., zn - xn * yn). This function is useful for convolutions.

• returns

  the vector z, which is overwritten.

• since 0.1.0

ssqr_diff x yreturns the sum of squared differences of the elements of vectors x and y.

subcntvec_dyn m ?ofsx x

• returns

  a subvector of the contiguous vector x. The i-th element of it refers (ofsx+i-1)-th element of x. The data are shared.

• parameter ofsx

  default = 1

• raises Invalid_argument

  m and ofsx do not designate a valid subvector of x.

subdscvec_dyn m ?ofsx ?incx x

• returns

  a subvector of the vector x. The i-th element of it refers (ofsx+(i-1)*incx)-th element of x. The data are shared.

• parameter ofs

  default = 1

• parameter inc

  default = 1

• raises Invalid_argument

  m, ofsx and incx do not designate a valid subvector of x.

An alias of subdscvec_dyn.

random ?rnd_state ?from ?range n creates a n-dimensional vector randomly initialized with the uniform distribution between from and from + range.

• parameter rnd_state

  default = Random.get_state ().

• parameter from

  default = -1.0.

• parameter range

  default = 2.0.

sqr ?y x computes the square of elements of the vector x.

• returns

  the vector y, which is overwritten.

sqr ?y x computes the square root of elements of the vector x.

• returns

  the vector y, which is overwritten.

exp ?y (x1, x2, ..., xn) returns (exp x1, exp x2, ..., exp xn).

• returns

  the vector y, which is overwritten.

• since 0.1.0

log ?y (x1, x2, ..., xn) returns (log x1, log x2, ..., log xn).

• returns

  the vector y, which is overwritten.

• since 0.1.0

sin ?y (x1, x2, ..., xn) returns (sin x1, sin x2, ..., sin xn).

• returns

  the vector y, which is overwritten.

• since 0.1.0

cos ?y (x1, x2, ..., xn) returns (cos x1, cos x2, ..., cos xn).

• returns

  the vector y, which is overwritten.

• since 0.1.0