Module `Nx_effect`Source

Sourcetype context = Nx_backend.context

Sourcetype ('a, 'b) t =

| T : ('a, 'b) Nx_backend.t -> ('a, 'b) t

Sourcetype Effect.t +=

| E_view : ('a, 'b) t -> Nx_core.View.t Effect.t
| E_buffer : {
1. context : context;
2. dtype : ('a0, 'b0) Nx_core.Dtype.t;
3. size_in_elements : int;
} -> ('a0, 'b0) t Effect.t
| E_const_scalar : {
1. context : context;
2. value : 'a1;
3. dtype : ('a1, 'b1) Nx_core.Dtype.t;
} -> ('a1, 'b1) t Effect.t
| E_from_host : {
1. context : context;
2. array : ('a2, 'b2) Nx_buffer.t;
} -> ('a2, 'b2) t Effect.t
| E_add : {
1. out : ('a3, 'b3) t;
2. a : ('a3, 'b3) t;
3. b : ('a3, 'b3) t;
} -> unit Effect.t
| E_sub : {
1. out : ('a4, 'b4) t;
2. a : ('a4, 'b4) t;
3. b : ('a4, 'b4) t;
} -> unit Effect.t
| E_mul : {
1. out : ('a5, 'b5) t;
2. a : ('a5, 'b5) t;
3. b : ('a5, 'b5) t;
} -> unit Effect.t
| E_idiv : {
1. out : ('a6, 'b6) t;
2. a : ('a6, 'b6) t;
3. b : ('a6, 'b6) t;
} -> unit Effect.t
| E_fdiv : {
1. out : ('a7, 'b7) t;
2. a : ('a7, 'b7) t;
3. b : ('a7, 'b7) t;
} -> unit Effect.t
| E_max : {
1. out : ('a8, 'b8) t;
2. a : ('a8, 'b8) t;
3. b : ('a8, 'b8) t;
} -> unit Effect.t
| E_min : {
1. out : ('a9, 'b9) t;
2. a : ('a9, 'b9) t;
3. b : ('a9, 'b9) t;
} -> unit Effect.t
| E_mod : {
1. out : ('a10, 'b10) t;
2. a : ('a10, 'b10) t;
3. b : ('a10, 'b10) t;
} -> unit Effect.t
| E_pow : {
1. out : ('a11, 'b11) t;
2. a : ('a11, 'b11) t;
3. b : ('a11, 'b11) t;
} -> unit Effect.t
| E_xor : {
1. out : ('a12, 'b12) t;
2. a : ('a12, 'b12) t;
3. b : ('a12, 'b12) t;
} -> unit Effect.t
| E_or : {
1. out : ('a13, 'b13) t;
2. a : ('a13, 'b13) t;
3. b : ('a13, 'b13) t;
} -> unit Effect.t
| E_and : {
1. out : ('a14, 'b14) t;
2. a : ('a14, 'b14) t;
3. b : ('a14, 'b14) t;
} -> unit Effect.t
| E_atan2 : {
1. out : ('a15, 'b15) t;
2. a : ('a15, 'b15) t;
3. b : ('a15, 'b15) t;
} -> unit Effect.t
| E_cmpeq : {
1. out : (bool, Nx_core.Dtype.bool_elt) t;
2. a : ('a16, 'b16) t;
3. b : ('a16, 'b16) t;
} -> unit Effect.t
| E_cmpne : {
1. out : (bool, Nx_core.Dtype.bool_elt) t;
2. a : ('a17, 'b17) t;
3. b : ('a17, 'b17) t;
} -> unit Effect.t
| E_cmplt : {
1. out : (bool, Nx_core.Dtype.bool_elt) t;
2. a : ('a18, 'b18) t;
3. b : ('a18, 'b18) t;
} -> unit Effect.t
| E_cmple : {
1. out : (bool, Nx_core.Dtype.bool_elt) t;
2. a : ('a19, 'b19) t;
3. b : ('a19, 'b19) t;
} -> unit Effect.t
| E_neg : {
1. out : ('a20, 'b20) t;
2. t_in : ('a20, 'b20) t;
} -> unit Effect.t
| E_sin : {
1. out : ('a21, 'b21) t;
2. t_in : ('a21, 'b21) t;
} -> unit Effect.t
| E_sqrt : {
1. out : ('a22, 'b22) t;
2. t_in : ('a22, 'b22) t;
} -> unit Effect.t
| E_recip : {
1. out : ('a23, 'b23) t;
2. t_in : ('a23, 'b23) t;
} -> unit Effect.t
| E_log : {
1. out : ('a24, 'b24) t;
2. t_in : ('a24, 'b24) t;
} -> unit Effect.t
| E_exp : {
1. out : ('a25, 'b25) t;
2. t_in : ('a25, 'b25) t;
} -> unit Effect.t
| E_cos : {
1. out : ('a26, 'b26) t;
2. t_in : ('a26, 'b26) t;
} -> unit Effect.t
| E_abs : {
1. out : ('a27, 'b27) t;
2. t_in : ('a27, 'b27) t;
} -> unit Effect.t
| E_sign : {
1. out : ('a28, 'b28) t;
2. t_in : ('a28, 'b28) t;
} -> unit Effect.t
| E_tan : {
1. out : ('a29, 'b29) t;
2. t_in : ('a29, 'b29) t;
} -> unit Effect.t
| E_asin : {
1. out : ('a30, 'b30) t;
2. t_in : ('a30, 'b30) t;
} -> unit Effect.t
| E_acos : {
1. out : ('a31, 'b31) t;
2. t_in : ('a31, 'b31) t;
} -> unit Effect.t
| E_atan : {
1. out : ('a32, 'b32) t;
2. t_in : ('a32, 'b32) t;
} -> unit Effect.t
| E_sinh : {
1. out : ('a33, 'b33) t;
2. t_in : ('a33, 'b33) t;
} -> unit Effect.t
| E_cosh : {
1. out : ('a34, 'b34) t;
2. t_in : ('a34, 'b34) t;
} -> unit Effect.t
| E_tanh : {
1. out : ('a35, 'b35) t;
2. t_in : ('a35, 'b35) t;
} -> unit Effect.t
| E_trunc : {
1. out : ('a36, 'b36) t;
2. t_in : ('a36, 'b36) t;
} -> unit Effect.t
| E_ceil : {
1. out : ('a37, 'b37) t;
2. t_in : ('a37, 'b37) t;
} -> unit Effect.t
| E_floor : {
1. out : ('a38, 'b38) t;
2. t_in : ('a38, 'b38) t;
} -> unit Effect.t
| E_round : {
1. out : ('a39, 'b39) t;
2. t_in : ('a39, 'b39) t;
} -> unit Effect.t
| E_erf : {
1. out : ('a40, 'b40) t;
2. t_in : ('a40, 'b40) t;
} -> unit Effect.t
| E_where : {
1. out : ('a41, 'b41) t;
2. condition : (bool, Nx_core.Dtype.bool_elt) t;
3. if_true : ('a41, 'b41) t;
4. if_false : ('a41, 'b41) t;
} -> unit Effect.t
| E_reduce_sum : {
1. out : ('a42, 'b42) t;
2. t_in : ('a42, 'b42) t;
3. axes : int array;
4. keepdims : bool;
} -> unit Effect.t
| E_reduce_max : {
1. out : ('a43, 'b43) t;
2. t_in : ('a43, 'b43) t;
3. axes : int array;
4. keepdims : bool;
} -> unit Effect.t
| E_reduce_min : {
1. out : ('a44, 'b44) t;
2. t_in : ('a44, 'b44) t;
3. axes : int array;
4. keepdims : bool;
} -> unit Effect.t
| E_reduce_prod : {
1. out : ('a45, 'b45) t;
2. t_in : ('a45, 'b45) t;
3. axes : int array;
4. keepdims : bool;
} -> unit Effect.t
| E_argmax : {
1. out : (int32, Nx_core.Dtype.int32_elt) t;
2. t_in : ('a46, 'b46) t;
3. axis : int;
4. keepdims : bool;
} -> unit Effect.t
| E_argmin : {
1. out : (int32, Nx_core.Dtype.int32_elt) t;
2. t_in : ('a47, 'b47) t;
3. axis : int;
4. keepdims : bool;
} -> unit Effect.t
| E_sort : {
1. out : ('a48, 'b48) t;
2. t_in : ('a48, 'b48) t;
3. axis : int;
4. descending : bool;
} -> unit Effect.t
| E_argsort : {
1. out : (int32, Nx_core.Dtype.int32_elt) t;
2. t_in : ('a49, 'b49) t;
3. axis : int;
4. descending : bool;
} -> unit Effect.t
| E_associative_scan : {
1. t_in : ('a50, 'b50) t;
2. axis : int;
3. op : [ `Max | `Min | `Prod | `Sum ];
} -> ('a50, 'b50) t Effect.t
| E_permute : {
1. t_in : ('a51, 'b51) t;
2. axes : int array;
} -> ('a51, 'b51) t Effect.t
| E_reshape : {
1. t_in : ('a52, 'b52) t;
2. new_shape : int array;
} -> ('a52, 'b52) t Effect.t
| E_expand : {
1. t_in : ('a53, 'b53) t;
2. new_target_shape : int array;
} -> ('a53, 'b53) t Effect.t
| E_pad : {
1. t_in : ('a54, 'b54) t;
2. padding_config : (int * int) array;
3. fill_value : 'a54;
} -> ('a54, 'b54) t Effect.t
| E_shrink : {
1. t_in : ('a55, 'b55) t;
2. limits : (int * int) array;
} -> ('a55, 'b55) t Effect.t
| E_flip : {
1. t_in : ('a56, 'b56) t;
2. dims_to_flip : bool array;
} -> ('a56, 'b56) t Effect.t
| E_cat : {
1. t_list : ('a57, 'b57) t list;
2. axis : int;
} -> ('a57, 'b57) t Effect.t
| E_cast : {
1. t_in : ('a58, 'b58) t;
2. target_dtype : ('c, 'd) Nx_core.Dtype.t;
} -> ('c, 'd) t Effect.t
| E_contiguous : {
1. t_in : ('a59, 'b59) t;
} -> ('a59, 'b59) t Effect.t
| E_copy : {
1. t_in : ('a60, 'b60) t;
} -> ('a60, 'b60) t Effect.t
| E_assign : {
1. dst : ('a61, 'b61) t;
2. src : ('a61, 'b61) t;
} -> unit Effect.t
| E_threefry : {
1. key : (int32, Nx_core.Dtype.int32_elt) t;
2. ctr : (int32, Nx_core.Dtype.int32_elt) t;
} -> (int32, Nx_core.Dtype.int32_elt) t Effect.t
| E_gather : {
1. data : ('a62, 'b62) t;
2. indices : (int32, Nx_core.Dtype.int32_elt) t;
3. axis : int;
} -> ('a62, 'b62) t Effect.t
| E_scatter : {
1. data_template : ('a63, 'b63) t;
2. indices : (int32, Nx_core.Dtype.int32_elt) t;
3. updates : ('a63, 'b63) t;
4. axis : int;
} -> ('a63, 'b63) t Effect.t
| E_to_device : {
1. context : context;
2. t_in : ('a64, 'b64) t;
} -> ('a64, 'b64) t Effect.t
| E_unfold : {
1. t_in : ('a65, 'b65) t;
2. kernel_size : int array;
3. stride : int array;
4. dilation : int array;
5. padding : (int * int) array;
} -> ('a65, 'b65) t Effect.t
| E_fold : {
1. t_in : ('a66, 'b66) t;
2. output_size : int array;
3. kernel_size : int array;
4. stride : int array;
5. dilation : int array;
6. padding : (int * int) array;
} -> ('a66, 'b66) t Effect.t
| E_matmul : {
1. out : ('a67, 'b67) t;
2. a : ('a67, 'b67) t;
3. b : ('a67, 'b67) t;
} -> unit Effect.t
| E_fft : {
1. t : (Complex.t, 'b68) t;
2. axes : int array;
} -> (Complex.t, 'b68) t Effect.t
| E_ifft : {
1. t : (Complex.t, 'b69) t;
2. axes : int array;
} -> (Complex.t, 'b69) t Effect.t
| E_rfft : {
1. t : (float, 'b70) t;
2. axes : int array;
} -> (Complex.t, Nx_core.Dtype.complex64_elt) t Effect.t
| E_irfft : {
1. t : (Complex.t, 'b71) t;
2. axes : int array;
3. s : int array option;
} -> (float, Nx_core.Dtype.float64_elt) t Effect.t
| E_psum : {
1. t_in : ('a68, 'b72) t;
} -> ('a68, 'b72) t Effect.t
| E_cholesky : {
1. t_in : ('a69, 'b73) t;
2. upper : bool;
} -> ('a69, 'b73) t Effect.t
| E_qr : {
1. t_in : ('a70, 'b74) t;
2. reduced : bool;
} -> (('a70, 'b74) t * ('a70, 'b74) t) Effect.t
| E_svd : {
1. t_in : ('a71, 'b75) t;
2. full_matrices : bool;
} -> (('a71, 'b75) t * (float, Nx_core.Dtype.float64_elt) t * ('a71, 'b75) t) Effect.t
| E_eig : {
1. t_in : ('a72, 'b76) t;
2. vectors : bool;
} -> ((Complex.t, Nx_core.Dtype.complex64_elt) t * (Complex.t, Nx_core.Dtype.complex64_elt) t option) Effect.t
| E_eigh : {
1. t_in : ('a73, 'b77) t;
2. vectors : bool;
} -> ((float, Nx_core.Dtype.float64_elt) t * ('a73, 'b77) t option) Effect.t
| E_triangular_solve : {
1. a : ('a74, 'b78) t;
2. b : ('a74, 'b78) t;
3. upper : bool;
4. transpose : bool;
5. unit_diag : bool;
} -> ('a74, 'b78) t Effect.t

Sourceval unwrap : ('a, 'b) t -> ('a, 'b) Nx_backend.t

Sourceval create_context : unit -> context

Sourceval context : ('a, 'b) t -> Nx_backend.context

Sourceval to_device : context -> ('a, 'b) t -> ('a, 'b) t

Sourceval view : ('a, 'b) t -> Nx_core.View.t

Sourceval dtype : ('a, 'b) t -> ('a, 'b) Nx_core.Dtype.t

Sourceval to_host : ('a, 'b) t -> ('a, 'b) Nx_buffer.t

Source

val binary_op : 
  out:('a, 'b) t ->
  (unit -> 'c Effect.t) ->
  (out:('a, 'b) Nx_backend.t ->
    ('d, 'e) Nx_backend.t ->
    ('f, 'g) Nx_backend.t ->
    'c) ->
  ('d, 'e) t ->
  ('f, 'g) t ->
  'c

Source

val unary_op : 
  out:('a, 'b) t ->
  (unit -> 'c Effect.t) ->
  (out:('a, 'b) Nx_backend.t -> ('d, 'e) Nx_backend.t -> 'c) ->
  ('d, 'e) t ->
  'c

Source

val reduce_op : 
  out:('a, 'b) t ->
  (unit -> 'c Effect.t) ->
  (out:('a, 'b) Nx_backend.t ->
    axes:'d ->
    keepdims:'e ->
    ('f, 'g) Nx_backend.t ->
    'c) ->
  axes:'d ->
  keepdims:'e ->
  ('f, 'g) t ->
  'c

Source

val movement_op : 
  (unit -> ('a, 'b) t Effect.t) ->
  (('c, 'd) Nx_backend.t -> 'e -> ('a, 'b) Nx_backend.t) ->
  ('c, 'd) t ->
  'e ->
  ('a, 'b) t

Sourceval assign : ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval add : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval sub : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval mul : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval max : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval min : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval mod_ : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval pow : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval xor : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval or_ : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval and_ : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval atan2 : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Sourceval div : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Source

val cmpeq : 
  out:(bool, Nx_core.Dtype.bool_elt) t ->
  ('a, 'b) t ->
  ('a, 'b) t ->
  unit

Source

val cmpne : 
  out:(bool, Nx_core.Dtype.bool_elt) t ->
  ('a, 'b) t ->
  ('a, 'b) t ->
  unit

Source

val cmplt : 
  out:(bool, Nx_core.Dtype.bool_elt) t ->
  ('a, 'b) t ->
  ('a, 'b) t ->
  unit

Source

val cmple : 
  out:(bool, Nx_core.Dtype.bool_elt) t ->
  ('a, 'b) t ->
  ('a, 'b) t ->
  unit

Sourceval neg : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval sin : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval sqrt : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval recip : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval log : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval exp : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval cos : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval abs : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval sign : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval tan : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval asin : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval acos : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval atan : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval sinh : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval cosh : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval tanh : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval trunc : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval ceil : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval floor : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval round : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval erf : out:('a, 'b) t -> ('a, 'b) t -> unit

Sourceval op_psum : ('a, 'b) t -> ('a, 'b) t

Source

val reduce_sum : 
  out:('a, 'b) t ->
  axes:int array ->
  keepdims:bool ->
  ('a, 'b) t ->
  unit

Source

val reduce_max : 
  out:('a, 'b) t ->
  axes:int array ->
  keepdims:bool ->
  ('a, 'b) t ->
  unit

Source

val reduce_min : 
  out:('a, 'b) t ->
  axes:int array ->
  keepdims:bool ->
  ('a, 'b) t ->
  unit

Source

val reduce_prod : 
  out:('a, 'b) t ->
  axes:int array ->
  keepdims:bool ->
  ('a, 'b) t ->
  unit

Source

val argmax : 
  out:(int32, Nx_core.Dtype.int32_elt) t ->
  axis:int ->
  keepdims:bool ->
  ('a, 'b) t ->
  unit

Source

val argmin : 
  out:(int32, Nx_core.Dtype.int32_elt) t ->
  axis:int ->
  keepdims:bool ->
  ('a, 'b) t ->
  unit

Source

val associative_scan : 
  out:('a, 'b) t ->
  axis:int ->
  op:[ `Max | `Min | `Prod | `Sum ] ->
  ('a, 'b) t ->
  unit

Sourceval sort : out:('a, 'b) t -> axis:int -> descending:bool -> ('a, 'b) t -> unit

Source

val argsort : 
  out:(int32, Nx_core.Dtype.int32_elt) t ->
  axis:int ->
  descending:bool ->
  ('a, 'b) t ->
  unit

Sourceval reshape : ('a, 'b) t -> int array -> ('a, 'b) t

Sourceval expand : ('a, 'b) t -> int array -> ('a, 'b) t

Sourceval permute : ('a, 'b) t -> int array -> ('a, 'b) t

Sourceval shrink : ('a, 'b) t -> (int * int) array -> ('a, 'b) t

Sourceval flip : ('a, 'b) t -> bool array -> ('a, 'b) t

Sourceval pad : ('a, 'b) t -> (int * int) array -> 'a -> ('a, 'b) t

Sourceval buffer : context -> ('a, 'b) Nx_core.Dtype.t -> int array -> ('a, 'b) t

Sourceval const_scalar : context -> 'a -> ('a, 'b) Nx_core.Dtype.t -> ('a, 'b) t

Source

val full : 
  Nx_backend.context ->
  ('a, 'b) Nx_core.Dtype.t ->
  int array ->
  'a ->
  ('a, 'b) t

Sourceval from_host : context -> ('a, 'b) Nx_buffer.t -> ('a, 'b) t

Sourceval contiguous : ('a, 'b) t -> ('a, 'b) t

Sourceval copy : ('a, 'b) t -> ('a, 'b) t

Source

val where : 
  out:('a, 'b) t ->
  (bool, Nx_core.Dtype.bool_elt) t ->
  ('a, 'b) t ->
  ('a, 'b) t ->
  unit

Sourceval cat : out:('a, 'b) t -> ('a, 'b) t list -> axis:int -> unit

Sourceval cast : 'a 'b 'c 'd. out:('c, 'd) t -> ('a, 'b) t -> unit

Source

val gather : 
  out:('a, 'b) t ->
  ('a, 'b) t ->
  (int32, Nx_core.Dtype.int32_elt) t ->
  axis:int ->
  unit

Source

val scatter : 
  ?mode:[ `Add | `Set ] ->
  ?unique_indices:bool ->
  ('a, 'b) t ->
  indices:(int32, Nx_core.Dtype.int32_elt) t ->
  updates:('a, 'b) t ->
  axis:int ->
  ('a, 'b) t

Source

val threefry : 
  out:(int32, Nx_core.Dtype.int32_elt) t ->
  (int32, Nx_core.Dtype.int32_elt) t ->
  (int32, Nx_core.Dtype.int32_elt) t ->
  unit

Source

val unfold : 
  ('a, 'b) t ->
  kernel_size:int array ->
  stride:int array ->
  dilation:int array ->
  padding:(int * int) array ->
  ('a, 'b) t

Source

val fold : 
  ('a, 'b) t ->
  output_size:int array ->
  kernel_size:int array ->
  stride:int array ->
  dilation:int array ->
  padding:(int * int) array ->
  ('a, 'b) t

Sourceval matmul : out:('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t -> unit

Source

val fft : 
  ?out:(Complex.t, 'a) t ->
  (Complex.t, 'a) t ->
  axes:int array ->
  (Complex.t, 'a) t

Source

val ifft : 
  ?out:(Complex.t, 'a) t ->
  (Complex.t, 'a) t ->
  axes:int array ->
  (Complex.t, 'a) t

Source

val rfft : 
  ?out:(Complex.t, 'c) t ->
  (float, 'a) t ->
  dtype:(Complex.t, 'c) Nx_core.Dtype.t ->
  axes:int array ->
  (Complex.t, 'c) t

Source

val irfft : 
  ?out:(float, 'c) t ->
  ?s:int array ->
  (Complex.t, 'a) t ->
  dtype:(float, 'c) Nx_core.Dtype.t ->
  axes:int array ->
  (float, 'c) t

Sourceval cholesky : upper:bool -> ('a, 'b) t -> ('a, 'b) t

Sourceval qr : reduced:bool -> ('a, 'b) t -> ('a, 'b) t * ('a, 'b) t

Source

val svd : 
  full_matrices:bool ->
  ('a, 'b) t ->
  ('a, 'b) t * (float, Nx_core.Dtype.float64_elt) t * ('a, 'b) t

Source

val eig : 
  vectors:bool ->
  ('a, 'b) t ->
  (Complex.t, Nx_core.Dtype.complex64_elt) t
  * (Complex.t, Nx_core.Dtype.complex64_elt) t option

Source

val eigh : 
  vectors:bool ->
  ('a, 'b) t ->
  (float, Nx_core.Dtype.float64_elt) t * ('a, 'b) t option

Source

val triangular_solve : 
  upper:bool ->
  transpose:bool ->
  unit_diag:bool ->
  ('a, 'b) t ->
  ('a, 'b) t ->
  ('a, 'b) t

Install

dune-project
Dependency

Authors

Maintainers

Sources

doc/nx.effect/Nx_effect/index.html

Module `Nx_effect`Source

package nx

Install

dune-project Dependency

Authors

Maintainers

Sources

doc/nx.effect/Nx_effect/index.html

Module Nx_effectSource

dune-project
Dependency

Module `Nx_effect`Source