torch 0.5 · OCaml Package

Parameters

module F : Cstubs.FOREIGN

Signature

type t = unit Ctypes.ptr

val t : t Ctypes.typ

type scalar = unit Ctypes.ptr

val scalar : scalar Ctypes.typ

val stubs_abs : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_abs_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_abs_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_acos : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_acos_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_acos_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_adaptive_avg_pool1d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_avg_pool2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_avg_pool2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_avg_pool3d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_avg_pool3d_backward : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_adaptive_avg_pool3d_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_adaptive_avg_pool3d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_max_pool1d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_max_pool2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_max_pool2d_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_adaptive_max_pool2d_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_adaptive_max_pool2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_max_pool3d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_adaptive_max_pool3d_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_adaptive_max_pool3d_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_adaptive_max_pool3d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_add : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_add1 : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_add_ : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_add_1 : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_add_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addbmm : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addbmm_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addbmm_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_addcdiv : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addcdiv_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addcdiv_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_addcmul : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addcmul_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addcmul_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_addmm : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addmm_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addmm_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_addmv : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addmv_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addmv_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_addr : (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addr_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_addr_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_affine_grid_generator : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_affine_grid_generator_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_alias : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_all : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_all1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_all_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int -> unit F.return) F.result

val stubs_alpha_dropout : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_alpha_dropout_ : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_any : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_any1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_any_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int -> unit F.return) F.result

val stubs_arange : 
  (t Ctypes_static.ptr -> scalar -> int -> int -> unit F.return) F.result

val stubs_arange1 : 
  (t Ctypes_static.ptr ->
    scalar ->
    scalar ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_arange2 : 
  (t Ctypes_static.ptr ->
    scalar ->
    scalar ->
    scalar ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_arange_out : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_arange_out1 : 
  (t Ctypes_static.ptr -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_argmax : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_argmin : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_argsort : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_as_strided : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_as_strided_ : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_asin : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_asin_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_asin_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_atan : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_atan2 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_atan2_ : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_atan2_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_atan_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_atan_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_avg_pool1d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_avg_pool2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_avg_pool2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_avg_pool2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_avg_pool2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_avg_pool3d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_avg_pool3d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_avg_pool3d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_avg_pool3d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_baddbmm : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_baddbmm_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_baddbmm_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_bartlett_window : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> unit F.return) F.result

val stubs_bartlett_window1 : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> int -> unit F.return) F.result

val stubs_batch_norm : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int ->
    float ->
    float ->
    int ->
    unit F.return)
    F.result

val stubs_batch_norm_backward_elemt : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    unit F.return)
    F.result

val stubs_batch_norm_backward_reduce : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_batch_norm_elemt : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    float ->
    unit F.return)
    F.result

val stubs_batch_norm_gather_stats : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    float ->
    float ->
    int64 ->
    unit F.return)
    F.result

val stubs_batch_norm_stats : 
  (t Ctypes_static.ptr -> t -> float -> unit F.return) F.result

val stubs_batch_norm_update_stats : 
  (t Ctypes_static.ptr -> t -> t -> t -> float -> unit F.return) F.result

val stubs_bernoulli : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_bernoulli1 : 
  (t Ctypes_static.ptr -> t -> float -> unit F.return) F.result

val stubs_bernoulli_ : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_bernoulli_1 : 
  (t Ctypes_static.ptr -> t -> float -> unit F.return) F.result

val stubs_bernoulli_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_bilinear : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_binary_cross_entropy : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_binary_cross_entropy_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_binary_cross_entropy_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    unit F.return)
    F.result

val stubs_binary_cross_entropy_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_binary_cross_entropy_with_logits : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_binary_cross_entropy_with_logits_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    unit F.return)
    F.result

val stubs_bincount : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_blackman_window : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> unit F.return) F.result

val stubs_blackman_window1 : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> int -> unit F.return) F.result

val stubs_bmm : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_bmm_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_broadcast_tensors : 
  (t Ctypes_static.ptr -> int -> t Ctypes_static.ptr F.return) F.result

val stubs_cartesian_prod : 
  (t Ctypes_static.ptr -> t Ctypes_static.ptr -> int -> unit F.return) F.result

val stubs_cat : 
  (t Ctypes_static.ptr ->
    t Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_cat_out : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_cauchy_ : 
  (t Ctypes_static.ptr -> t -> float -> float -> unit F.return) F.result

val stubs_cdist : 
  (t Ctypes_static.ptr -> t -> t -> float -> unit F.return) F.result

val stubs_ceil : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_ceil_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_ceil_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_celu : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_celu_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_chain_matmul : 
  (t Ctypes_static.ptr -> t Ctypes_static.ptr -> int -> unit F.return) F.result

val stubs_cholesky : 
  (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_cholesky_inverse : 
  (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_cholesky_inverse_out : 
  (t Ctypes_static.ptr -> t -> t -> int -> unit F.return) F.result

val stubs_cholesky_out : 
  (t Ctypes_static.ptr -> t -> t -> int -> unit F.return) F.result

val stubs_cholesky_solve : 
  (t Ctypes_static.ptr -> t -> t -> int -> unit F.return) F.result

val stubs_cholesky_solve_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int -> unit F.return) F.result

val stubs_chunk : 
  (t -> int64 -> int64 -> t Ctypes_static.ptr F.return) F.result

val stubs_clamp : 
  (t Ctypes_static.ptr -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_clamp_ : 
  (t Ctypes_static.ptr -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_clamp_max : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_clamp_max_ : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_clamp_max_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_clamp_min : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_clamp_min_ : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_clamp_min_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_clamp_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_clone : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_coalesce : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_combinations : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_constant_pad_nd : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_contiguous : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_conv1d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_conv2d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_conv3d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_conv_tbc : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_conv_tbc_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_conv_transpose1d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_conv_transpose2d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_conv_transpose3d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_convolution : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_copy_sparse_to_sparse_ : 
  (t Ctypes_static.ptr -> t -> t -> int -> unit F.return) F.result

val stubs_cos : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_cos_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_cos_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_cosh : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_cosh_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_cosh_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_cosine_embedding_loss : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    float ->
    int64 ->
    unit F.return)
    F.result

val stubs_cosine_similarity : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> float -> unit F.return) F.result

val stubs_cross : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_cross_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_ctc_loss : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_ctc_loss1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_cudnn_affine_grid_generator : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_cudnn_affine_grid_generator_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_cudnn_batch_norm : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int ->
    float ->
    float ->
    unit F.return)
    F.result

val stubs_cudnn_batch_norm_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    float ->
    unit F.return)
    F.result

val stubs_cudnn_convolution : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_cudnn_convolution_backward_bias : 
  (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_cudnn_convolution_backward_input : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_cudnn_convolution_backward_weight : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_cudnn_convolution_transpose : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_cudnn_convolution_transpose_backward_bias : 
  (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_cudnn_convolution_transpose_backward_input : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_cudnn_convolution_transpose_backward_weight : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_cudnn_grid_sampler : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_cudnn_grid_sampler_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_cumprod : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_cumprod1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_cumprod_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_cumprod_out1 : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int -> unit F.return) F.result

val stubs_cumsum : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_cumsum1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_cumsum_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_cumsum_out1 : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int -> unit F.return) F.result

val stubs_dequantize : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_det : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_detach : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_detach_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_diag : (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_diag_embed : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_diag_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_diagflat : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_diagonal : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_digamma : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_digamma_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_digamma_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_dist : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_div : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_div1 : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_div_ : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_div_1 : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_div_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_dot : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_dot_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_dropout : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_dropout_ : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_eig : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_eig_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int -> unit F.return) F.result

val stubs_elu : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_elu_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_elu_backward : 
  (t Ctypes_static.ptr ->
    t ->
    scalar ->
    scalar ->
    scalar ->
    t ->
    unit F.return)
    F.result

val stubs_elu_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    scalar ->
    scalar ->
    scalar ->
    t ->
    unit F.return)
    F.result

val stubs_elu_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_embedding : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_embedding_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_embedding_bag : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int ->
    int64 ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_embedding_dense_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_embedding_renorm_ : 
  (t Ctypes_static.ptr -> t -> t -> float -> float -> unit F.return) F.result

val stubs_embedding_sparse_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_empty : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_empty_like : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_empty_like1 : 
  (t Ctypes_static.ptr -> t -> int -> int -> unit F.return) F.result

val stubs_empty_out : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_empty_strided : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_eq : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_eq1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_eq_ : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_eq_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_eq_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_eq_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_erf : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_erf_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_erf_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_erfc : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_erfc_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_erfc_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_erfinv : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_erfinv_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_erfinv_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_exp : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_exp_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_exp_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_expand : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_expand_as : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_expm1 : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_expm1_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_expm1_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_exponential_ : 
  (t Ctypes_static.ptr -> t -> float -> unit F.return) F.result

val stubs_eye : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> unit F.return) F.result

val stubs_eye1 : 
  (t Ctypes_static.ptr ->
    int64 ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_eye_out : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_eye_out1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_fbgemm_linear_int8_weight : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    t ->
    unit F.return)
    F.result

val stubs_fbgemm_pack_quantized_matrix : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_feature_alpha_dropout : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_feature_alpha_dropout_ : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_feature_dropout : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_feature_dropout_ : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_fft : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_fill_ : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_fill_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_flatten : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_flip : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_floor : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_floor_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_floor_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_fmod : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_fmod1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_fmod_ : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_fmod_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_fmod_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_fmod_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_frac : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_frac_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_frac_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_fractional_max_pool2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_fractional_max_pool2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_fractional_max_pool2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_fractional_max_pool2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_fractional_max_pool3d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_fractional_max_pool3d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_fractional_max_pool3d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_fractional_max_pool3d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_frobenius_norm : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_frobenius_norm1 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_frobenius_norm_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_full : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    scalar ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_full_like : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_full_like1 : 
  (t Ctypes_static.ptr -> t -> scalar -> int -> int -> unit F.return) F.result

val stubs_full_out : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    scalar ->
    unit F.return)
    F.result

val stubs_gather : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> int -> unit F.return) F.result

val stubs_gather_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 ->
    t ->
    int ->
    unit F.return)
    F.result

val stubs_ge : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_ge1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_ge_ : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_ge_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_ge_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_ge_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_gels : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_gels_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_geometric_ : 
  (t Ctypes_static.ptr -> t -> float -> unit F.return) F.result

val stubs_geqrf : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_geqrf_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_ger : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_ger_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_glu : (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_glu_backward : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_glu_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_glu_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_grad : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_grid_sampler : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_grid_sampler_2d : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_grid_sampler_2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_grid_sampler_3d : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_grid_sampler_3d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_group_norm : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    t ->
    t ->
    float ->
    int ->
    unit F.return)
    F.result

val stubs_gru : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_gru1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_gru_cell : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> t -> t -> unit F.return) F.result

val stubs_gt : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_gt1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_gt_ : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_gt_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_gt_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_gt_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_hamming_window : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> unit F.return) F.result

val stubs_hamming_window1 : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> int -> unit F.return) F.result

val stubs_hamming_window2 : 
  (t Ctypes_static.ptr ->
    int64 ->
    int ->
    float ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_hamming_window3 : 
  (t Ctypes_static.ptr ->
    int64 ->
    int ->
    float ->
    float ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_hann_window : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> unit F.return) F.result

val stubs_hann_window1 : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> int -> unit F.return) F.result

val stubs_hardshrink : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_hardshrink_backward : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_hardtanh : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_hardtanh_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_hardtanh_backward : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_hardtanh_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    unit F.return)
    F.result

val stubs_hardtanh_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_hinge_embedding_loss : 
  (t Ctypes_static.ptr -> t -> t -> float -> int64 -> unit F.return) F.result

val stubs_histc : (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_histc_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_hspmm : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_hspmm_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_ifft : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_index : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_index_add : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_index_add_ : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_index_copy : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_index_copy_ : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_index_fill : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> scalar -> unit F.return) F.result

val stubs_index_fill1 : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_index_fill_ : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> scalar -> unit F.return) F.result

val stubs_index_fill_1 : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_index_put : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    t ->
    int ->
    unit F.return)
    F.result

val stubs_index_put_ : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    t ->
    int ->
    unit F.return)
    F.result

val stubs_index_select : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> unit F.return) F.result

val stubs_index_select_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> t -> unit F.return) F.result

val stubs_indices : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_instance_norm : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int ->
    float ->
    float ->
    int ->
    unit F.return)
    F.result

val stubs_int_repr : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_inverse : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_inverse_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_irfft : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_isclose : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    float ->
    float ->
    int ->
    unit F.return)
    F.result

val stubs_isnan : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_kl_div : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_kl_div_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_kthvalue : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> int -> unit F.return) F.result

val stubs_kthvalue_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_l1_loss : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_l1_loss_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_l1_loss_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_l1_loss_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_layer_norm : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    float ->
    int ->
    unit F.return)
    F.result

val stubs_le : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_le1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_le_ : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_le_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_le_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_le_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_leaky_relu : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_leaky_relu_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_leaky_relu_backward : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_leaky_relu_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> scalar -> unit F.return) F.result

val stubs_leaky_relu_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_lerp : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_lerp1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_lerp_ : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_lerp_1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_lerp_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> scalar -> unit F.return) F.result

val stubs_lerp_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_lgamma : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_lgamma_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_lgamma_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_linear : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_linspace : 
  (t Ctypes_static.ptr ->
    scalar ->
    scalar ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_linspace_out : 
  (t Ctypes_static.ptr ->
    t ->
    scalar ->
    scalar ->
    int64 ->
    unit F.return)
    F.result

val stubs_log : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log10 : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log10_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log10_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_log1p : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log1p_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log1p_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_log2 : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log2_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log2_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_log_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log_normal_ : 
  (t Ctypes_static.ptr -> t -> float -> float -> unit F.return) F.result

val stubs_log_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_log_sigmoid : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_log_sigmoid_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_log_sigmoid_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_log_sigmoid_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_log_softmax : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_log_softmax1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_logdet : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_logspace : 
  (t Ctypes_static.ptr ->
    scalar ->
    scalar ->
    int64 ->
    float ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_logspace_out : 
  (t Ctypes_static.ptr ->
    t ->
    scalar ->
    scalar ->
    int64 ->
    float ->
    unit F.return)
    F.result

val stubs_logsumexp : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_logsumexp_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_lstm : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_lstm1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_lstm_cell : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    t ->
    t ->
    unit F.return)
    F.result

val stubs_lt : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_lt1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_lt_ : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_lt_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_lt_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_lt_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_lu_solve : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_lu_solve_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_margin_ranking_loss : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    float ->
    int64 ->
    unit F.return)
    F.result

val stubs_masked_fill : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_masked_fill1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_masked_fill_ : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_masked_fill_1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_masked_scatter : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_masked_scatter_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_masked_select : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_masked_select_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_matmul : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_matmul_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_matrix_power : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_matrix_rank : 
  (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_matrix_rank1 : 
  (t Ctypes_static.ptr -> t -> float -> int -> unit F.return) F.result

val stubs_max : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_max1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_max2 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_max_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_max_out1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_max_pool1d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_max_pool1d_with_indices : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_max_pool2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_max_pool2d_with_indices : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_max_pool2d_with_indices_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_max_pool2d_with_indices_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_max_pool2d_with_indices_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_max_pool3d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_max_pool3d_with_indices : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_max_pool3d_with_indices_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_max_pool3d_with_indices_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    t ->
    unit F.return)
    F.result

val stubs_max_pool3d_with_indices_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_max_unpool2d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_max_unpool2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_max_unpool2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_max_unpool2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_max_unpool3d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_max_unpool3d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_max_unpool3d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_max_unpool3d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_max_values : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_mean : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_mean1 : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_mean2 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_mean3 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_mean4 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_mean_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_mean_out1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_mean_out2 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_median : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_median1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_median_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_meshgrid : 
  (t Ctypes_static.ptr -> int -> t Ctypes_static.ptr F.return) F.result

val stubs_min : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_min1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_min2 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_min_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_min_out1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_min_values : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_batch_norm : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int ->
    float ->
    float ->
    unit F.return)
    F.result

val stubs_miopen_batch_norm_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    float ->
    unit F.return)
    F.result

val stubs_miopen_convolution : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_convolution_backward_bias : 
  (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_miopen_convolution_backward_input : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_convolution_backward_weight : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_convolution_transpose : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_convolution_transpose_backward_input : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_convolution_transpose_backward_weight : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_depthwise_convolution : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_depthwise_convolution_backward_input : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_miopen_depthwise_convolution_backward_weight : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_mkldnn_convolution : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_mkldnn_convolution_backward_input : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_mkldnn_convolution_backward_weights : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_mkldnn_linear : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_mkldnn_max_pool2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_mkldnn_reorder_conv2d_weight : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_mkldnn_reshape : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_mm : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_mm_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_mode : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_mode_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_mse_loss : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_mse_loss_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_mse_loss_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_mse_loss_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_mul : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_mul1 : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_mul_ : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_mul_1 : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_mul_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_multi_margin_loss_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    t ->
    int64 ->
    unit F.return)
    F.result

val stubs_multi_margin_loss_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    t ->
    int64 ->
    unit F.return)
    F.result

val stubs_multilabel_margin_loss : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_multilabel_margin_loss_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> t -> unit F.return) F.result

val stubs_multilabel_margin_loss_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    t ->
    unit F.return)
    F.result

val stubs_multilabel_margin_loss_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_multinomial : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_multinomial_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int -> unit F.return) F.result

val stubs_mv : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_mv_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_mvlgamma : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_mvlgamma_ : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_narrow : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_narrow_copy : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_native_batch_norm : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int ->
    float ->
    float ->
    unit F.return)
    F.result

val stubs_native_norm : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_ne : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_ne1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_ne_ : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_ne_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_ne_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_ne_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_neg : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_neg_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_neg_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_nll_loss : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_nll_loss2d : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_nll_loss2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    t ->
    unit F.return)
    F.result

val stubs_nll_loss2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    t ->
    unit F.return)
    F.result

val stubs_nll_loss2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_nll_loss_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    t ->
    unit F.return)
    F.result

val stubs_nll_loss_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    t ->
    unit F.return)
    F.result

val stubs_nll_loss_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_nonzero : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_nonzero_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_norm : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_norm1 : 
  (t Ctypes_static.ptr -> t -> scalar -> int -> unit F.return) F.result

val stubs_norm2 : 
  (t Ctypes_static.ptr ->
    t ->
    scalar ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_norm3 : 
  (t Ctypes_static.ptr ->
    t ->
    scalar ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_norm_except_dim : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_norm_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    scalar ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_norm_out1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    scalar ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_normal : 
  (t Ctypes_static.ptr -> t -> float -> unit F.return) F.result

val stubs_normal1 : 
  (t Ctypes_static.ptr -> float -> t -> unit F.return) F.result

val stubs_normal2 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_normal_ : 
  (t Ctypes_static.ptr -> t -> float -> float -> unit F.return) F.result

val stubs_normal_out : 
  (t Ctypes_static.ptr -> t -> t -> float -> unit F.return) F.result

val stubs_normal_out1 : 
  (t Ctypes_static.ptr -> t -> float -> t -> unit F.return) F.result

val stubs_normal_out2 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_nuclear_norm : 
  (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_nuclear_norm_out : 
  (t Ctypes_static.ptr -> t -> t -> int -> unit F.return) F.result

val stubs_one_hot : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_ones : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_ones_like : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_ones_like1 : 
  (t Ctypes_static.ptr -> t -> int -> int -> unit F.return) F.result

val stubs_ones_out : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_orgqr : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_orgqr_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_ormqr : 
  (t Ctypes_static.ptr -> t -> t -> t -> int -> int -> unit F.return) F.result

val stubs_ormqr_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_pairwise_distance : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    float ->
    float ->
    int ->
    unit F.return)
    F.result

val stubs_pdist : (t Ctypes_static.ptr -> t -> float -> unit F.return) F.result

val stubs_permute : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_pin_memory : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_pinverse : 
  (t Ctypes_static.ptr -> t -> float -> unit F.return) F.result

val stubs_pixel_shuffle : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_poisson : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_polygamma : 
  (t Ctypes_static.ptr -> int64 -> t -> unit F.return) F.result

val stubs_polygamma_ : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_polygamma_out : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> unit F.return) F.result

val stubs_pow : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_pow1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_pow2 : (t Ctypes_static.ptr -> scalar -> t -> unit F.return) F.result

val stubs_pow_ : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_pow_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_pow_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_pow_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_pow_out2 : 
  (t Ctypes_static.ptr -> t -> scalar -> t -> unit F.return) F.result

val stubs_prelu : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_prelu_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_prod : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_prod1 : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_prod2 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_prod3 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_prod4 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> int -> unit F.return) F.result

val stubs_prod_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int -> unit F.return) F.result

val stubs_prod_out1 : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> int -> unit F.return) F.result

val stubs_prod_out2 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_pstrf : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_pstrf_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int -> unit F.return) F.result

val stubs_put_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> int -> unit F.return) F.result

val stubs_qr : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_qr_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_quantize_linear : 
  (t Ctypes_static.ptr -> t -> float -> int64 -> unit F.return) F.result

val stubs_quantized_gru_cell : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    scalar ->
    scalar ->
    unit F.return)
    F.result

val stubs_quantized_lstm : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_quantized_lstm_cell : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    scalar ->
    scalar ->
    unit F.return)
    F.result

val stubs_quantized_rnn_relu_cell : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    scalar ->
    scalar ->
    unit F.return)
    F.result

val stubs_quantized_rnn_tanh_cell : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    scalar ->
    scalar ->
    unit F.return)
    F.result

val stubs_rand : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_rand_like : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_rand_like1 : 
  (t Ctypes_static.ptr -> t -> int -> int -> unit F.return) F.result

val stubs_rand_out : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_randint : 
  (t Ctypes_static.ptr ->
    int64 ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_randint1 : 
  (t Ctypes_static.ptr ->
    int64 ->
    int64 ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_randint_like : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_randint_like1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_randint_like2 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> int -> unit F.return) F.result

val stubs_randint_like3 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_randint_out : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_randint_out1 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_randn : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_randn_like : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_randn_like1 : 
  (t Ctypes_static.ptr -> t -> int -> int -> unit F.return) F.result

val stubs_randn_out : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_random_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_random_1 : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_random_2 : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_randperm : 
  (t Ctypes_static.ptr -> int64 -> int -> int -> unit F.return) F.result

val stubs_randperm_out : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_range : 
  (t Ctypes_static.ptr ->
    scalar ->
    scalar ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_range1 : 
  (t Ctypes_static.ptr ->
    scalar ->
    scalar ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_range_out : 
  (t Ctypes_static.ptr -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_reciprocal : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_reciprocal_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_reciprocal_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_reflection_pad1d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reflection_pad1d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reflection_pad1d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reflection_pad1d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reflection_pad2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reflection_pad2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reflection_pad2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reflection_pad2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_relu : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_relu_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_remainder : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_remainder1 : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_remainder_ : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_remainder_1 : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_remainder_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_remainder_out1 : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_renorm : 
  (t Ctypes_static.ptr ->
    t ->
    scalar ->
    int64 ->
    scalar ->
    unit F.return)
    F.result

val stubs_renorm_ : 
  (t Ctypes_static.ptr ->
    t ->
    scalar ->
    int64 ->
    scalar ->
    unit F.return)
    F.result

val stubs_renorm_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    scalar ->
    int64 ->
    scalar ->
    unit F.return)
    F.result

val stubs_repeat : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_repeat_interleave : 
  (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_repeat_interleave1 : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_repeat_interleave2 : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_replication_pad1d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad1d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad1d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad1d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad3d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad3d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad3d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_replication_pad3d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reshape : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_reshape_as : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_resize_ : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_resize_as_ : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_rfft : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> int -> unit F.return) F.result

val stubs_rnn_relu : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_rnn_relu1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_rnn_relu_cell : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> t -> t -> unit F.return) F.result

val stubs_rnn_tanh : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_rnn_tanh1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    int ->
    int64 ->
    float ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_rnn_tanh_cell : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> t -> t -> unit F.return) F.result

val stubs_roll : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_rot90 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_round : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_round_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_round_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_rrelu : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_rrelu_ : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_rrelu_with_noise : 
  (t Ctypes_static.ptr -> t -> t -> int -> unit F.return) F.result

val stubs_rrelu_with_noise_ : 
  (t Ctypes_static.ptr -> t -> t -> int -> unit F.return) F.result

val stubs_rrelu_with_noise_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    int ->
    unit F.return)
    F.result

val stubs_rrelu_with_noise_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    int ->
    unit F.return)
    F.result

val stubs_rrelu_with_noise_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int -> unit F.return) F.result

val stubs_rsqrt : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_rsqrt_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_rsqrt_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_rsub : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_rsub1 : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_s_copy_ : 
  (t Ctypes_static.ptr -> t -> t -> int -> unit F.return) F.result

val stubs_s_native_addmm : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_s_native_addmm_ : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_s_native_addmm_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_scalar_tensor : 
  (t Ctypes_static.ptr -> scalar -> int -> int -> unit F.return) F.result

val stubs_scatter : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_scatter1 : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> scalar -> unit F.return) F.result

val stubs_scatter_ : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_scatter_1 : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> scalar -> unit F.return) F.result

val stubs_scatter_add : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_scatter_add_ : 
  (t Ctypes_static.ptr -> t -> int64 -> t -> t -> unit F.return) F.result

val stubs_select : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_selu : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_selu_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_set_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_set_1 : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_set_requires_grad : 
  (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_sigmoid : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sigmoid_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sigmoid_backward : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_sigmoid_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_sigmoid_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_sign : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sign_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sign_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_sin : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sin_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sin_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_sinh : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sinh_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sinh_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_slice : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_slogdet : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_smm : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_smooth_l1_loss : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_smooth_l1_loss_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_smooth_l1_loss_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_smooth_l1_loss_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_soft_margin_loss : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_soft_margin_loss_backward : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_soft_margin_loss_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_soft_margin_loss_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int64 -> unit F.return) F.result

val stubs_softmax : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_softmax1 : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_softplus : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_softplus_backward : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    scalar ->
    scalar ->
    t ->
    unit F.return)
    F.result

val stubs_softplus_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    scalar ->
    scalar ->
    t ->
    unit F.return)
    F.result

val stubs_softplus_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_softshrink : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_softshrink_backward : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_softshrink_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> scalar -> unit F.return) F.result

val stubs_softshrink_out : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_solve : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_solve_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_sort : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> unit F.return) F.result

val stubs_sort_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int ->
    unit F.return)
    F.result

val stubs_sparse_coo_tensor : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sparse_coo_tensor1 : 
  (t Ctypes_static.ptr -> t -> t -> int -> int -> unit F.return) F.result

val stubs_sparse_coo_tensor2 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sparse_resize_ : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_sparse_resize_and_clear_ : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_split : 
  (t -> int64 -> int64 -> t Ctypes_static.ptr F.return) F.result

val stubs_split_with_sizes : 
  (t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 ->
    t Ctypes_static.ptr F.return)
    F.result

val stubs_sqrt : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sqrt_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sqrt_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_squeeze : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_squeeze1 : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_squeeze_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_squeeze_1 : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_sspaddmm : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_sspaddmm_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> t -> unit F.return) F.result

val stubs_stack : 
  (t Ctypes_static.ptr ->
    t Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_stack_out : 
  (t Ctypes_static.ptr ->
    t ->
    t Ctypes_static.ptr ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_std : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_std1 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_std_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_stft : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    t ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sub : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_sub1 : (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_sub_ : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_sub_1 : 
  (t Ctypes_static.ptr -> t -> scalar -> unit F.return) F.result

val stubs_sub_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_sum : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_sum1 : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_sum2 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sum3 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sum4 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sum_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sum_out1 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sum_out2 : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_sum_to_size : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_svd : 
  (t Ctypes_static.ptr -> t -> int -> int -> unit F.return) F.result

val stubs_svd_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_symeig : 
  (t Ctypes_static.ptr -> t -> int -> int -> unit F.return) F.result

val stubs_symeig_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> int -> int -> unit F.return) F.result

val stubs_tr : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_t_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_take : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_take_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_tan : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_tan_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_tan_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_tanh : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_tanh_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_tanh_backward : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_tanh_backward_out : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_tanh_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_tensordot : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_threshold : 
  (t Ctypes_static.ptr -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_threshold_ : 
  (t Ctypes_static.ptr -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_threshold_backward : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> unit F.return) F.result

val stubs_threshold_out : 
  (t Ctypes_static.ptr -> t -> t -> scalar -> scalar -> unit F.return) F.result

val stubs_to_ : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_to1 : 
  (t Ctypes_static.ptr ->
    t ->
    int ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_to2 : 
  (t Ctypes_static.ptr -> t -> int -> int -> int -> unit F.return) F.result

val stubs_to3 : 
  (t Ctypes_static.ptr -> t -> t -> int -> int -> unit F.return) F.result

val stubs_to4 : 
  (t Ctypes_static.ptr ->
    t ->
    int ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_to_dense : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_to_dense_backward : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_to_mkldnn : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_to_mkldnn_backward : 
  (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_to_sparse : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_to_sparse1 : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_topk : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_topk_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    int64 ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_totype : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_trace : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_transpose : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_transpose_ : 
  (t Ctypes_static.ptr -> t -> int64 -> int64 -> unit F.return) F.result

val stubs_triangular_solve : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_triangular_solve_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    t ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_tril : (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_tril_ : (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_tril_indices : 
  (t Ctypes_static.ptr ->
    int64 ->
    int64 ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_tril_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_triplet_margin_loss : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    t ->
    float ->
    float ->
    float ->
    int ->
    int64 ->
    unit F.return)
    F.result

val stubs_triu : (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_triu_ : (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_triu_indices : 
  (t Ctypes_static.ptr ->
    int64 ->
    int64 ->
    int64 ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_triu_out : 
  (t Ctypes_static.ptr -> t -> t -> int64 -> unit F.return) F.result

val stubs_trunc : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_trunc_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_trunc_out : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_type_as : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_unbind : (t -> int64 -> t Ctypes_static.ptr F.return) F.result

val stubs_unfold : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int64 ->
    int64 ->
    unit F.return)
    F.result

val stubs_uniform_ : 
  (t Ctypes_static.ptr -> t -> float -> float -> unit F.return) F.result

val stubs_unique_consecutive : 
  (t Ctypes_static.ptr -> t -> int -> int -> int64 -> unit F.return) F.result

val stubs_unique_dim : 
  (t Ctypes_static.ptr ->
    t ->
    int64 ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_unique_dim_consecutive : 
  (t Ctypes_static.ptr -> t -> int64 -> int -> int -> unit F.return) F.result

val stubs_unsqueeze : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_unsqueeze_ : 
  (t Ctypes_static.ptr -> t -> int64 -> unit F.return) F.result

val stubs_upsample_bicubic2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_bicubic2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_bicubic2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_bicubic2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_bilinear2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_bilinear2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_bilinear2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_bilinear2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_linear1d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_linear1d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_linear1d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_linear1d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest1d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest1d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest1d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest1d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest2d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest2d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest2d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest2d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest3d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest3d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest3d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_nearest3d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_trilinear3d : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_trilinear3d_backward : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_trilinear3d_backward_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_upsample_trilinear3d_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_values : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_var : (t Ctypes_static.ptr -> t -> int -> unit F.return) F.result

val stubs_var1 : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_var_out : 
  (t Ctypes_static.ptr ->
    t ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_view : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

val stubs_view_as : (t Ctypes_static.ptr -> t -> t -> unit F.return) F.result

val stubs_where : 
  (t Ctypes_static.ptr -> t -> t -> t -> unit F.return) F.result

val stubs_zero_ : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_zeros : 
  (t Ctypes_static.ptr ->
    int64 Ctypes_static.ptr ->
    int ->
    int ->
    int ->
    unit F.return)
    F.result

val stubs_zeros_like : (t Ctypes_static.ptr -> t -> unit F.return) F.result

val stubs_zeros_like1 : 
  (t Ctypes_static.ptr -> t -> int -> int -> unit F.return) F.result

val stubs_zeros_out : 
  (t Ctypes_static.ptr ->
    t ->
    int64 Ctypes_static.ptr ->
    int ->
    unit F.return)
    F.result

package torch

Parameters

Signature