module Vec:sig
..end
val random : ?rnd_state:Stdlib.Random.State.t ->
?from:float -> ?range:float -> int -> Lacaml_float32.vec
random ?rnd_state ?from ?range n
n
initialized with random elements sampled uniformly from
range
starting at from
. A random state rnd_state
can be passed.rnd_state
: default = Random.get_state ()from
: default = -1.0range
: default = 2.0val sqr : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
sqr ?n ?ofsy ?incy ?y ?ofsx ?incx x
computes the square
of n
elements of the vector x
using incx
as incremental
steps. If y
is given, the result will be stored in there
using increments of incy
, otherwise a fresh vector will be
used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val sqrt : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
sqrt ?n ?ofsy ?incy ?y ?ofsx ?incx x
computes the square root
of n
elements of the vector x
using incx
as incremental
steps. If y
is given, the result will be stored in there
using increments of incy
, otherwise a fresh vector will be
used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val exp : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
exp ?n ?ofsy ?incy ?y ?ofsx ?incx x
computes the exponential
of n
elements of the vector x
using incx
as incremental
steps. If y
is given, the result will be stored in there
using increments of incy
, otherwise a fresh vector will be
used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val log : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
log ?n ?ofsy ?incy ?y ?ofsx ?incx x
computes the logarithm
of n
elements of the vector x
using incx
as incremental
steps. If y
is given, the result will be stored in there
using increments of incy
, otherwise a fresh vector will be
used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val sin : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
sin ?n ?ofsy ?incy ?y ?ofsx ?incx x
computes the sine of n
elements
of the vector x
using incx
as incremental steps. If y
is given,
the result will be stored in there using increments of incy
, otherwise
a fresh vector will be used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val cos : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
cos ?n ?ofsy ?incy ?y ?ofsx ?incx x
computes the cosine of n
elements
of the vector x
using incx
as incremental steps. If y
is given,
the result will be stored in there using increments of incy
, otherwise
a fresh vector will be used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val create : int -> Lacaml_float32.vec
create n
n
rows (not initialized).val make : int -> Lacaml_float32.num_type -> Lacaml_float32.vec
make n x
n
rows initialized with value x
.val make0 : int -> Lacaml_float32.vec
make0 n x
n
rows initialized with the zero
element.val init : int -> (int -> Lacaml_float32.num_type) -> Lacaml_float32.vec
init n f
n
elements, where each
element at position i
is initialized by the result of calling
f i
.val of_array : Lacaml_float32.num_type array -> Lacaml_float32.vec
of_array ar
ar
.val to_array : Lacaml_float32.vec -> Lacaml_float32.num_type array
to_array v
v
.val of_list : Lacaml_float32.num_type list -> Lacaml_float32.vec
of_list l
l
.val to_list : Lacaml_float32.vec -> Lacaml_float32.num_type list
to_list v
v
.val append : Lacaml_float32.vec -> Lacaml_float32.vec -> Lacaml_float32.vec
append v1 v2
v2
to v1
.val concat : Lacaml_float32.vec list -> Lacaml_float32.vec
concat vs
vs
.val empty : Lacaml_float32.vec
empty
, the empty vector.
val linspace : ?y:Lacaml_float32.vec ->
Lacaml_float32.num_type ->
Lacaml_float32.num_type -> int -> Lacaml_float32.vec
linspace ?z a b n
y
overwritten with n
linearly spaced points between and including a
and b
.y
: default = fresh vector of dim n
val logspace : ?y:Lacaml_float32.vec ->
Lacaml_float32.num_type ->
Lacaml_float32.num_type -> ?base:float -> int -> Lacaml_float32.vec
logspace ?z a b base n
y
overwritten with n
points logarithmically spaced using base b
between and including
base
** a
and base
** b
.y
: default = fresh vector of dim n
base
: default = 10.0val dim : Lacaml_float32.vec -> int
dim x
x
.val map : (Lacaml_float32.num_type -> Lacaml_float32.num_type) ->
?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
map f ?n ?ofsx ?incx x
f
to each element of x
.n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
y
: default = new vector with ofsy+(n-1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val iter : (Lacaml_float32.num_type -> unit) ->
?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> unit
iter ?n ?ofsx ?incx f x
applies function f
in turn to all elements
of vector x
.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val iteri : (int -> Lacaml_float32.num_type -> unit) ->
?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> unit
iteri ?n ?ofsx ?incx f x
same as iter
but additionally passes
the index of the element as first argument and the element itself
as second argument.
val fold : ('a -> Lacaml_float32.num_type -> 'a) ->
'a -> ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> 'a
fold f a ?n ?ofsx ?incx x
is
f (... (f (f a x.{ofsx}) x.{ofsx + incx}) ...) x.{ofsx + (n-1)*incx}
if incx > 0
and the same in the reverse order of appearance of the
x
values if incx < 0
.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val fill : ?n:int ->
?ofsx:int ->
?incx:int -> Lacaml_float32.vec -> Lacaml_float32.num_type -> unit
fill ?n ?ofsx ?incx x a
fills vector x
with value a
in the
designated range.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val rev : Lacaml_float32.vec -> Lacaml_float32.vec
rev x
reverses vector x
(non-destructive).
val max : ?n:int ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.num_type
max ?n ?ofsx ?incx x
computes the greater of the n
elements
in vector x
(2-norm), separated by incx
incremental steps. NaNs
are ignored. If only NaNs are encountered, the negative infinity
value will be returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val min : ?n:int ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.num_type
min ?n ?ofsx ?incx x
computes the smaller of the n
elements
in vector x
(2-norm), separated by incx
incremental steps.
NaNs are ignored. If only NaNs are encountered, the infinity
value
will be returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val sum : ?n:int ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.num_type
sum ?n ?ofsx ?incx x
computes the sum of the n
elements in
vector x
, separated by incx
incremental steps.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val prod : ?n:int ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.num_type
prod ?n ?ofsx ?incx x
computes the product of the n
elements
in vector x
, separated by incx
incremental steps.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val add_const : Lacaml_float32.num_type ->
?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
add_const c ?n ?ofsy ?incy ?y ?ofsx ?incx x
adds constant c
to the n
elements of vector x
and stores the result in y
, using incx
and incy
as incremental steps respectively. If y
is given, the result will
be stored in there using increments of incy
, otherwise a fresh
vector will be used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val sqr_nrm2 : ?stable:bool ->
?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> float
sqr_nrm2 ?stable ?n ?c ?ofsx ?incx x
computes the square of
the 2-norm (Euclidean norm) of vector x
separated by incx
incremental steps. If stable
is true, this is equivalent to
squaring the result of calling the BLAS-function nrm2
, which
avoids over- and underflow if possible. If stable
is false
(default), dot
will be called instead for greatly improved
performance.
stable
: default = false
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val ssqr : ?n:int ->
?c:Lacaml_float32.num_type ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.num_type
ssqr ?n ?c ?ofsx ?incx x
computes the sum of squared differences
of the n
elements in vector x
from constant c
, separated
by incx
incremental steps. Please do not confuse with
Lacaml_S.Vec.sqr_nrm2
! The current function behaves differently with
complex numbers when zero is passed in for c
. It computes
the square for each entry then, whereas Lacaml_S.Vec.sqr_nrm2
uses the
conjugate transpose in the product. The latter will therefore
always return a real number.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
c
: default = zeroofsx
: default = 1incx
: default = 1val sort : ?cmp:(Lacaml_float32.num_type -> Lacaml_float32.num_type -> int) ->
?decr:bool ->
?n:int ->
?ofsp:int ->
?incp:int ->
?p:Lacaml_common.int_vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> unit
sort ?cmp ?n ?ofsx ?incx x
sorts the array x
in increasing
order according to the comparison function cmp
.
cmp
: a function such that cmp a b < 0
if a
is less than
b
, cmp a b = 0
if a
equal b
and cmp a b > 0
if a
is
greater than b
for the desired order. Default: the usual
order on floating point values or the lexicographic order on
complex ones (a special routine makes it fast). Whatever the
order you choose, NaNs (in any component for complex numbers)
are considered larger than any other value (so they will be
last, in no specified order, in the sorted vector). Therefore,
NaN are never passed to cmp
.decr
: sort in decreasing order (stays fast for the default cmp
).n
: default = greater n
s.t. ofsx+(n-1)(abs incx) <= dim x
ofsp
: default = 1incp
: default = 1p
: if you pass a vector of size ofsp+(n - 1)(abs incp)
,
the vector x
will be unchanged and the permutation to sort it
will be stored in p
. Thus x.{p.{ofsp + (i-1) * incp}}
will
give the elements of x
in increasing order. Default: no
vector is provided.ofsx
: default = 1incx
: default = 1val neg : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
neg ?n ?ofsy ?incy ?y ?ofsx ?incx x
negates n
elements of the
vector x
using incx
as incremental steps. If y
is given,
the result will be stored in there using increments of incy
,
otherwise a fresh vector will be used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val reci : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float32.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float32.vec -> Lacaml_float32.vec
reci ?n ?ofsy ?incy ?y ?ofsx ?incx x
computes the reciprocal value
of n
elements of the vector x
using incx
as incremental steps.
If y
is given, the result will be stored in there using increments of
incy
, otherwise a fresh vector will be used. The resulting vector
is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = fresh vector with ofsy+(n - 1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val add : ?n:int ->
?ofsz:int ->
?incz:int ->
?z:Lacaml_float32.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float32.vec ->
?ofsy:int -> ?incy:int -> Lacaml_float32.vec -> Lacaml_float32.vec
add ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y
adds n
elements of vectors x
and y
elementwise, using incx
and incy
as incremental steps respectively. If z
is given, the result will
be stored in there using increments of incz
, otherwise a fresh
vector will be used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsz
: default = 1incz
: default = 1z
: default = fresh vector with ofsz+(n - 1)(abs incz)
rowsofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val sub : ?n:int ->
?ofsz:int ->
?incz:int ->
?z:Lacaml_float32.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float32.vec ->
?ofsy:int -> ?incy:int -> Lacaml_float32.vec -> Lacaml_float32.vec
sub ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y
subtracts n
elements of vectors x
and y
elementwise, using incx
and incy
as incremental steps respectively. If z
is given, the result will
be stored in there using increments of incz
, otherwise a fresh
vector will be used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsz
: default = 1incz
: default = 1z
: default = fresh vector with ofsz+(n - 1)(abs incz)
rowsofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val mul : ?n:int ->
?ofsz:int ->
?incz:int ->
?z:Lacaml_float32.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float32.vec ->
?ofsy:int -> ?incy:int -> Lacaml_float32.vec -> Lacaml_float32.vec
mul ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y
multiplies
n
elements of vectors x
and y
elementwise, using incx
and incy
as incremental steps respectively. If z
is given, the
result will be stored in there using increments of incz
, otherwise
a fresh vector will be used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsz
: default = 1incz
: default = 1z
: default = fresh vector with ofsz+(n - 1)(abs incz)
rowsofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val div : ?n:int ->
?ofsz:int ->
?incz:int ->
?z:Lacaml_float32.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float32.vec ->
?ofsy:int -> ?incy:int -> Lacaml_float32.vec -> Lacaml_float32.vec
div ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y
divides n
elements of vectors x
and y
elementwise, using incx
and incy
as incremental steps respectively. If z
is given, the result will
be stored in there using increments of incz
, otherwise a fresh
vector will be used. The resulting vector is returned.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsz
: default = 1incz
: default = 1z
: default = fresh vector with ofsz+(n - 1)(abs incz)
rowsofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val zpxy : ?n:int ->
?ofsz:int ->
?incz:int ->
?z:Lacaml_float32.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float32.vec ->
?ofsy:int -> ?incy:int -> Lacaml_float32.vec -> Lacaml_float32.vec
zpxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y
multiplies n
elements of vectors x
and y
elementwise, using incx
and incy
as
incremental steps respectively, and adds the result to and stores it in
the specified range in z
if provided. If z
is given, the result will
be stored in there using increments of incz
, otherwise a fresh vector
will be used and assumed to be zero. The resulting vector is returned.
This function is useful for convolutions.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsz
: default = 1incz
: default = 1z
: default = fresh vector with ofsz+(n - 1)(abs incz)
rowsofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val zmxy : ?n:int ->
?ofsz:int ->
?incz:int ->
?z:Lacaml_float32.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float32.vec ->
?ofsy:int -> ?incy:int -> Lacaml_float32.vec -> Lacaml_float32.vec
zmxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y
multiplies n
elements of vectors x
and y
elementwise, using incx
and incy
as incremental steps respectively, and substracts the result from and
stores it in the specified range in z
if provided. If z
is given,
the result will be stored in there using increments of incz
, otherwise
a fresh vector will be used and assumed to be zero. The resulting vector
is returned. This function is useful for convolutions.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsz
: default = 1incz
: default = 1z
: default = fresh vector with ofsz+(n - 1)(abs incz)
rowsofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val ssqr_diff : ?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float32.vec ->
?ofsy:int -> ?incy:int -> Lacaml_float32.vec -> Lacaml_float32.num_type
ssqr_diff ?n ?ofsx ?incx x ?ofsy ?incy y
returns the sum of
squared differences of n
elements of vectors x
and y
, using
incx
and incy
as incremental steps respectively.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1