module Vec:sig
..end
typet =
Lacaml__C.vec
val random : ?rnd_state:Stdlib.Random.State.t ->
?re_from:float ->
?re_range:float -> ?im_from:float -> ?im_range:float -> int -> Lacaml__C.vec
random ?rnd_state ?re_from ?re_range ?im_from ?im_range n
n
initialized with random elements sampled
uniformly from re_range
and im_range
starting at re_from
and
im_from
for real and imaginary numbers respectively. A random state
rnd_state
can be passed.rnd_state
: default = Random.get_state ()re_from
: default = -1.0re_range
: default = 2.0im_from
: default = -1.0im_range
: default = 2.0typeunop =
?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml__C.vec -> ?ofsx:int -> ?incx:int -> Lacaml__C.vec -> Lacaml__C.vec
typebinop =
?n:int ->
?ofsz:int ->
?incz:int ->
?z:Lacaml__C.vec ->
?ofsx:int ->
?incx:int ->
Lacaml__C.vec -> ?ofsy:int -> ?incy:int -> Lacaml__C.vec -> Lacaml__C.vec
val create : int -> Lacaml__C.vec
create n
n
rows (not initialized).val make : int -> Stdlib.Complex.t -> Lacaml__C.vec
make n x
n
rows initialized with value x
.val make0 : int -> Lacaml__C.vec
make0 n x
n
rows initialized with the zero
element.val init : int -> (int -> Stdlib.Complex.t) -> Lacaml__C.vec
init n f
n
elements, where each
element at position i
is initialized by the result of calling
f i
.val of_array : Stdlib.Complex.t array -> Lacaml__C.vec
of_array ar
ar
.val to_array : Lacaml__C.vec -> Stdlib.Complex.t array
to_array v
v
.val of_list : Stdlib.Complex.t list -> Lacaml__C.vec
of_list l
l
.val to_list : Lacaml__C.vec -> Stdlib.Complex.t list
to_list v
v
.val append : Lacaml__C.vec -> Lacaml__C.vec -> Lacaml__C.vec
append v1 v2
v2
to v1
.val concat : Lacaml__C.vec list -> Lacaml__C.vec
concat vs
vs
.val empty : Lacaml__C.vec
empty
, the empty vector.
val linspace : ?y:Lacaml__C.vec ->
Stdlib.Complex.t -> Stdlib.Complex.t -> int -> Lacaml__C.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__C.vec ->
Stdlib.Complex.t -> Stdlib.Complex.t -> ?base:float -> int -> Lacaml__C.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__C.vec -> int
dim x
x
.val has_zero_dim : Lacaml__C.vec -> bool
has_zero_dim vec
checks whether vector vec
has a dimension of size
zero
. In this case it cannot contain data.
val map : (Stdlib.Complex.t -> Stdlib.Complex.t) ->
?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml__C.vec -> ?ofsx:int -> ?incx:int -> Lacaml__C.vec -> Lacaml__C.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 : (Stdlib.Complex.t -> unit) ->
?n:int -> ?ofsx:int -> ?incx:int -> Lacaml__C.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 -> Stdlib.Complex.t -> unit) ->
?n:int -> ?ofsx:int -> ?incx:int -> Lacaml__C.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 -> Stdlib.Complex.t -> 'a) ->
'a -> ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml__C.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 rev : Lacaml__C.vec -> Lacaml__C.vec
rev x
reverses vector x
(non-destructive).
val max : ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml__C.vec -> Stdlib.Complex.t
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__C.vec -> Stdlib.Complex.t
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 sort : ?cmp:(Stdlib.Complex.t -> Stdlib.Complex.t -> int) ->
?decr:bool ->
?n:int ->
?ofsp:int ->
?incp:int ->
?p:Lacaml__common.int_vec -> ?ofsx:int -> ?incx:int -> Lacaml__C.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 fill : ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml__C.vec -> Stdlib.Complex.t -> 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 sum : ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml__C.vec -> Stdlib.Complex.t
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__C.vec -> Stdlib.Complex.t
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 : Stdlib.Complex.t -> unop
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.
val sqr_nrm2 : ?stable:bool -> ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml__C.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:Stdlib.Complex.t ->
?ofsx:int -> ?incx:int -> Lacaml__C.vec -> Stdlib.Complex.t
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__C.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__C.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 neg : unop
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.
val reci : unop
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.
val add : binop
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.
val sub : binop
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.
val mul : binop
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.
val div : binop
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.
val zpxy : ?n:int ->
?ofsz:int ->
?incz:int ->
Lacaml__C.vec ->
?ofsx:int ->
?incx:int -> Lacaml__C.vec -> ?ofsy:int -> ?incy:int -> Lacaml__C.vec -> unit
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
. This function is useful for convolutions.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsz
: default = 1incz
: default = 1ofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val zmxy : ?n:int ->
?ofsz:int ->
?incz:int ->
Lacaml__C.vec ->
?ofsx:int ->
?incx:int -> Lacaml__C.vec -> ?ofsy:int -> ?incy:int -> Lacaml__C.vec -> unit
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
. This function is
useful for convolutions.
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsz
: default = 1incz
: default = 1ofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val ssqr_diff : ?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml__C.vec -> ?ofsy:int -> ?incy:int -> Lacaml__C.vec -> Stdlib.Complex.t
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