Lacaml_D.Vectype t = vecval random :
?rnd_state:Random.State.t ->
?from:float ->
?range:float ->
int ->
Lacaml_float64.vecrandom ?rnd_state ?from ?range n
val abs : Lacaml_float64.Types.Vec.unopabs ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the absolute 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 signum : Lacaml_float64.Types.Vec.unopsignum ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the sign value (-1 for negative numbers, 0 (or -0) for zero, 1 for positive numbers, nan for nan) 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 sqr : Lacaml_float64.Types.Vec.unopsqr ?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.
val sqrt : Lacaml_float64.Types.Vec.unopsqrt ?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.
val cbrt : Lacaml_float64.Types.Vec.unopcbrt ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the cubic 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.
val exp : Lacaml_float64.Types.Vec.unopexp ?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.
val exp2 : Lacaml_float64.Types.Vec.unopexp2 ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the base-2 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.
val expm1 : Lacaml_float64.Types.Vec.unopexpm1 ?n ?ofsy ?incy ?y ?ofsx ?incx x computes exp x -. 1. for 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 log : Lacaml_float64.Types.Vec.unoplog ?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.
val log10 : Lacaml_float64.Types.Vec.unoplog10 ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the base-10 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.
val log2 : Lacaml_float64.Types.Vec.unoplog2 ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the base-2 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.
val log1p : Lacaml_float64.Types.Vec.unoplog1p ?n ?ofsy ?incy ?y ?ofsx ?incx x computes log (1 + x) for 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 sin : Lacaml_float64.Types.Vec.unopsin ?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.
val cos : Lacaml_float64.Types.Vec.unopcos ?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.
val tan : Lacaml_float64.Types.Vec.unoptan ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the tangent 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 asin : Lacaml_float64.Types.Vec.unopasin ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the arc 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.
val acos : Lacaml_float64.Types.Vec.unopacos ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the arc 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.
val atan : Lacaml_float64.Types.Vec.unopatan ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the arc tangent 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 sinh : Lacaml_float64.Types.Vec.unopsinh ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the hyperbolic 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.
val cosh : Lacaml_float64.Types.Vec.unopcosh ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the hyperbolic 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.
val tanh : Lacaml_float64.Types.Vec.unoptanh ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the hyperbolic tangent 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 asinh : Lacaml_float64.Types.Vec.unopasinh ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the hyperbolic arc 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.
val acosh : Lacaml_float64.Types.Vec.unopcosh ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the hyperbolic arc 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.
val atanh : Lacaml_float64.Types.Vec.unopatanh ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the hyperbolic arc tangent 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 floor : Lacaml_float64.Types.Vec.unopfloor ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the floor 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 ceil : Lacaml_float64.Types.Vec.unopceil ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the ceiling 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 round : Lacaml_float64.Types.Vec.unopround ?n ?ofsy ?incy ?y ?ofsx ?incx x rounds the 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 trunc : Lacaml_float64.Types.Vec.unoptrunc ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the truncation of the 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 erf : Lacaml_float64.Types.Vec.unoperf ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the error function for 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 erfc : Lacaml_float64.Types.Vec.unoperfc ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the complementary error function for 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 logistic : Lacaml_float64.Types.Vec.unoplogistic ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the logistict function 1/(1 + exp(-a) for 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 relu : Lacaml_float64.Types.Vec.unoprelu ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the rectified linear unit function max(x, 0) for 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 softplus : Lacaml_float64.Types.Vec.unopsoftplus ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the softplus function log(1 + exp(x) for 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 softsign : Lacaml_float64.Types.Vec.unopsoftsign ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the softsign function x / (1 + abs(x)) for 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 pow : Lacaml_float64.Types.Vec.binoppow ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y computes pow(a, b) of 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 atan2 : Lacaml_float64.Types.Vec.binopatan2 ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y computes atan2(a, b) of 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 hypot : Lacaml_float64.Types.Vec.binophypot ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y computes sqrt(x*x + y*y) of 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 min2 : Lacaml_float64.Types.Vec.binopmin2 ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y computes the minimum of 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 max2 : Lacaml_float64.Types.Vec.binopmax2 ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y computes the maximum of 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 log_sum_exp :
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
Lacaml_float64.num_typelog_sum_exp ?n ?ofsx ?incx x computes the logarithm of the sum of exponentials of the n elements in vector x, separated by incx incremental steps.
val create : int -> Lacaml_float64.veccreate n
val make : int -> Lacaml_float64.num_type -> Lacaml_float64.vecmake n x
val make0 : int -> Lacaml_float64.vecmake0 n x
val init : int -> (int -> Lacaml_float64.num_type) -> Lacaml_float64.vecinit n f
val of_array : Lacaml_float64.num_type array -> Lacaml_float64.vecof_array ar
val to_array : Lacaml_float64.vec -> Lacaml_float64.num_type arrayto_array v
val of_list : Lacaml_float64.num_type list -> Lacaml_float64.vecof_list l
val to_list : Lacaml_float64.vec -> Lacaml_float64.num_type listto_list v
val append : Lacaml_float64.vec -> Lacaml_float64.vec -> Lacaml_float64.vecappend v1 v2
val concat : Lacaml_float64.vec list -> Lacaml_float64.vecconcat vs
val empty : Lacaml_float64.vecempty, the empty vector.
val linspace :
?y:Lacaml_float64.vec ->
Lacaml_float64.num_type ->
Lacaml_float64.num_type ->
int ->
Lacaml_float64.veclinspace ?z a b n
val logspace :
?y:Lacaml_float64.vec ->
Lacaml_float64.num_type ->
Lacaml_float64.num_type ->
?base:float ->
int ->
Lacaml_float64.veclogspace ?z a b base n
val dim : Lacaml_float64.vec -> intdim x
val map :
(Lacaml_float64.num_type -> Lacaml_float64.num_type) ->
?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float64.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
Lacaml_float64.vecmap f ?n ?ofsx ?incx x
val iter :
(Lacaml_float64.num_type -> unit) ->
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
unititer ?n ?ofsx ?incx f x applies function f in turn to all elements of vector x.
val iteri :
(int -> Lacaml_float64.num_type -> unit) ->
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
unititeri ?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_float64.num_type -> 'a) ->
'a ->
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
'afold 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.
val rev : Lacaml_float64.vec -> Lacaml_float64.vecrev x reverses vector x (non-destructive).
val max :
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
Lacaml_float64.num_typemax ?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.
val min :
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
Lacaml_float64.num_typemin ?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.
val sort :
?cmp:(Lacaml_float64.num_type -> Lacaml_float64.num_type -> int) ->
?decr:bool ->
?n:int ->
?ofsp:int ->
?incp:int ->
?p:Lacaml_common.int_vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
unitsort ?cmp ?n ?ofsx ?incx x sorts the array x in increasing order according to the comparison function cmp.
val fill :
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
Lacaml_float64.num_type ->
unitfill ?n ?ofsx ?incx x a fills vector x with value a in the designated range.
val sum :
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
Lacaml_float64.num_typesum ?n ?ofsx ?incx x computes the sum of the n elements in vector x, separated by incx incremental steps.
val prod :
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
Lacaml_float64.num_typeprod ?n ?ofsx ?incx x computes the product of the n elements in vector x, separated by incx incremental steps.
val add_const : Lacaml_float64.num_type -> Lacaml_float64.Types.Vec.unopadd_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_float64.vec ->
floatsqr_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.
val ssqr :
?n:int ->
?c:Lacaml_float64.num_type ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
Lacaml_float64.num_typessqr ?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 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 sqr_nrm2 uses the conjugate transpose in the product. The latter will therefore always return a real number.
val neg : Lacaml_float64.Types.Vec.unopneg ?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 : Lacaml_float64.Types.Vec.unopreci ?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 : Lacaml_float64.Types.Vec.binopadd ?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 : Lacaml_float64.Types.Vec.binopsub ?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 : Lacaml_float64.Types.Vec.binopmul ?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 : Lacaml_float64.Types.Vec.binopdiv ?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_float64.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
?ofsy:int ->
?incy:int ->
Lacaml_float64.vec ->
unitzpxy ?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.
val zmxy :
?n:int ->
?ofsz:int ->
?incz:int ->
Lacaml_float64.vec ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
?ofsy:int ->
?incy:int ->
Lacaml_float64.vec ->
unitzmxy ?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.
val ssqr_diff :
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
?ofsy:int ->
?incy:int ->
Lacaml_float64.vec ->
Lacaml_float64.num_typessqr_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.