package torch

  1. Overview
  2. Docs
package torch
Legend:
Library
Module
Module type
Parameter
Class
Class type
module C : sig ... end
val to_tensor_list : unit Ctypes.ptr Ctypes.ptr -> unit Ctypes.ptr list
val __and__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __and__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __iand__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __iand__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ilshift__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ilshift__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ior__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ior__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __irshift__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __irshift__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ixor__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ixor__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __lshift__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __lshift__scalar_out_ : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __lshift__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __lshift__tensor_out_ : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __or__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __or__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __rshift__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __rshift__scalar_out_ : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __rshift__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __rshift__tensor_out_ : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __xor__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __xor__tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _adaptive_avg_pool2d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val _adaptive_avg_pool2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _adaptive_avg_pool3d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val _adaptive_avg_pool3d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _add_batch_dim : unit Ctypes.ptr -> batch_dim:int -> level:int -> C.TensorG.t
val _add_relu : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _add_relu_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _add_relu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _add_relu_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _add_relu_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _add_relu_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _addmm_activation : unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> use_gelu:bool -> C.TensorG.t
val _addmm_activation_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> use_gelu:bool -> C.TensorG.t
val _aminmax : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val _aminmax_dim : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _amp_update_scale : out:unit Ctypes.ptr -> unit Ctypes.ptr -> growth_tracker:unit Ctypes.ptr -> found_inf:unit Ctypes.ptr -> scale_growth_factor:float -> scale_backoff_factor:float -> growth_interval:int -> C.TensorG.t
val _amp_update_scale_ : unit Ctypes.ptr -> growth_tracker:unit Ctypes.ptr -> found_inf:unit Ctypes.ptr -> scale_growth_factor:float -> scale_backoff_factor:float -> growth_interval:int -> C.TensorG.t
val _amp_update_scale_functional : unit Ctypes.ptr -> growth_tracker:unit Ctypes.ptr -> found_inf:unit Ctypes.ptr -> scale_growth_factor:float -> scale_backoff_factor:float -> growth_interval:int -> C.TensorG.t * C.TensorG.t
val _autocast_to_full_precision : unit Ctypes.ptr -> cuda_enabled:bool -> cpu_enabled:bool -> C.TensorG.t
val _autocast_to_reduced_precision : unit Ctypes.ptr -> cuda_enabled:bool -> cpu_enabled:bool -> cuda_dtype:Kind.packed -> cpu_dtype:Kind.packed -> C.TensorG.t
val _cast_byte : unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _cast_char : unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _cast_double : unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _cast_float : unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _cast_half : unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _cast_int : unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _cast_long : unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _cast_short : unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _cdist_backward : grad:unit Ctypes.ptr -> x1:unit Ctypes.ptr -> x2:unit Ctypes.ptr -> p:float -> cdist:unit Ctypes.ptr -> C.TensorG.t
val _cholesky_solve_helper : unit Ctypes.ptr -> a:unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val _coalesce : unit Ctypes.ptr -> C.TensorG.t
val _coalesced : out:unit Ctypes.ptr -> unit Ctypes.ptr -> coalesced:bool -> C.TensorG.t
val _coalesced_ : unit Ctypes.ptr -> coalesced:bool -> C.TensorG.t
val _coalesced_functional : unit Ctypes.ptr -> coalesced:bool -> C.TensorG.t
val _compute_linear_combination : unit Ctypes.ptr -> coefficients:unit Ctypes.ptr -> C.TensorG.t
val _compute_linear_combination_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> coefficients:unit Ctypes.ptr -> C.TensorG.t
val _conj : unit Ctypes.ptr -> C.TensorG.t
val _conj_copy : unit Ctypes.ptr -> C.TensorG.t
val _conj_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _conj_physical : unit Ctypes.ptr -> C.TensorG.t
val _conv_depthwise2d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> C.TensorG.t
val _conv_depthwise2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> C.TensorG.t
val _convert_indices_from_coo_to_csr : unit Ctypes.ptr -> size:int -> out_int32:bool -> C.TensorG.t
val _convert_indices_from_coo_to_csr_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int -> out_int32:bool -> C.TensorG.t
val _convert_indices_from_csr_to_coo : crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> out_int32:bool -> transpose:bool -> C.TensorG.t
val _convert_indices_from_csr_to_coo_out : out:unit Ctypes.ptr -> crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> out_int32:bool -> transpose:bool -> C.TensorG.t
val _convolution : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> benchmark:bool -> deterministic:bool -> cudnn_enabled:bool -> allow_tf32:bool -> C.TensorG.t
val _convolution_deprecated : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> benchmark:bool -> deterministic:bool -> cudnn_enabled:bool -> C.TensorG.t
val _convolution_mode : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:string -> dilation:int list -> groups:int -> C.TensorG.t
val _copy_from : unit Ctypes.ptr -> dst:unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val _copy_from_and_resize : unit Ctypes.ptr -> dst:unit Ctypes.ptr -> C.TensorG.t
val _ctc_loss : log_probs:unit Ctypes.ptr -> targets:unit Ctypes.ptr -> input_lengths:int list -> target_lengths:int list -> blank:int -> zero_infinity:bool -> C.TensorG.t * C.TensorG.t
val _ctc_loss_backward : grad:unit Ctypes.ptr -> log_probs:unit Ctypes.ptr -> targets:unit Ctypes.ptr -> input_lengths:int list -> target_lengths:int list -> neg_log_likelihood:unit Ctypes.ptr -> log_alpha:unit Ctypes.ptr -> blank:int -> zero_infinity:bool -> C.TensorG.t
val _cudnn_ctc_loss : log_probs:unit Ctypes.ptr -> targets:unit Ctypes.ptr -> input_lengths:int list -> target_lengths:int list -> blank:int -> deterministic:bool -> zero_infinity:bool -> C.TensorG.t * C.TensorG.t
val _cudnn_init_dropout_state : dropout:float -> train:bool -> dropout_seed:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _cudnn_rnn : unit Ctypes.ptr -> weight:C.TensorG.t list -> weight_stride0:int -> weight_buf:unit Ctypes.ptr option -> hx:unit Ctypes.ptr -> cx:unit Ctypes.ptr option -> mode:int -> hidden_size:int -> proj_size:int -> num_layers:int -> batch_first:bool -> dropout:float -> train:bool -> bidirectional:bool -> batch_sizes:int list -> dropout_state:unit Ctypes.ptr option -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _cudnn_rnn_flatten_weight : weight_arr:C.TensorG.t list -> weight_stride0:int -> input_size:int -> mode:int -> hidden_size:int -> proj_size:int -> num_layers:int -> batch_first:bool -> bidirectional:bool -> C.TensorG.t
val _det_lu_based_helper : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _det_lu_based_helper_backward_helper : det_grad:unit Ctypes.ptr -> det:unit Ctypes.ptr -> unit Ctypes.ptr -> lu:unit Ctypes.ptr -> pivs:unit Ctypes.ptr -> C.TensorG.t
val _dim_arange : like:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val _dirichlet_grad : x:unit Ctypes.ptr -> alpha:unit Ctypes.ptr -> total:unit Ctypes.ptr -> C.TensorG.t
val _efficientzerotensor : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _embedding_bag : weight:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> offsets:unit Ctypes.ptr -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:unit Ctypes.ptr option -> include_last_offset:bool -> padding_idx:int -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _embedding_bag_backward : grad:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> offsets:unit Ctypes.ptr -> offset2bag:unit Ctypes.ptr -> bag_size:unit Ctypes.ptr -> maximum_indices:unit Ctypes.ptr -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:unit Ctypes.ptr option -> padding_idx:int -> C.TensorG.t
val _embedding_bag_dense_backward : grad:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> offset2bag:unit Ctypes.ptr -> bag_size:unit Ctypes.ptr -> maximum_indices:unit Ctypes.ptr -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> per_sample_weights:unit Ctypes.ptr option -> padding_idx:int -> C.TensorG.t
val _embedding_bag_forward_only : weight:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> offsets:unit Ctypes.ptr -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:unit Ctypes.ptr option -> include_last_offset:bool -> padding_idx:int -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _embedding_bag_per_sample_weights_backward : grad:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> offsets:unit Ctypes.ptr -> offset2bag:unit Ctypes.ptr -> mode:int -> padding_idx:int -> C.TensorG.t
val _embedding_bag_sparse_backward : grad:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> offsets:unit Ctypes.ptr -> offset2bag:unit Ctypes.ptr -> bag_size:unit Ctypes.ptr -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> per_sample_weights:unit Ctypes.ptr option -> padding_idx:int -> C.TensorG.t
val _empty_affine_quantized : size:int list -> options:(Kind.packed * Device.t) -> scale:float -> zero_point:int -> C.TensorG.t
val _empty_per_channel_affine_quantized : size:int list -> scales:unit Ctypes.ptr -> zero_points:unit Ctypes.ptr -> axis:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _euclidean_dist : x1:unit Ctypes.ptr -> x2:unit Ctypes.ptr -> C.TensorG.t
val _fake_quantize_learnable_per_channel_affine : unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> axis:int -> quant_min:int -> quant_max:int -> grad_factor:float -> C.TensorG.t
val _fake_quantize_learnable_per_channel_affine_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> axis:int -> quant_min:int -> quant_max:int -> grad_factor:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _fake_quantize_learnable_per_tensor_affine : unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> quant_min:int -> quant_max:int -> grad_factor:float -> C.TensorG.t
val _fake_quantize_learnable_per_tensor_affine_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> quant_min:int -> quant_max:int -> grad_factor:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _fake_quantize_per_tensor_affine_cachemask_tensor_qparams : unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> fake_quant_enabled:unit Ctypes.ptr -> quant_min:int -> quant_max:int -> C.TensorG.t * C.TensorG.t
val _fft_c2c : unit Ctypes.ptr -> dim:int list -> normalization:int -> forward:bool -> C.TensorG.t
val _fft_c2c_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> normalization:int -> forward:bool -> C.TensorG.t
val _fft_c2r : unit Ctypes.ptr -> dim:int list -> normalization:int -> last_dim_size:int -> C.TensorG.t
val _fft_c2r_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> normalization:int -> last_dim_size:int -> C.TensorG.t
val _fft_r2c : unit Ctypes.ptr -> dim:int list -> normalization:int -> onesided:bool -> C.TensorG.t
val _fft_r2c_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> normalization:int -> onesided:bool -> C.TensorG.t
val _fused_dropout : unit Ctypes.ptr -> p:float -> C.TensorG.t * C.TensorG.t
val _fused_moving_avg_obs_fq_helper : unit Ctypes.ptr -> observer_on:unit Ctypes.ptr -> fake_quant_on:unit Ctypes.ptr -> running_min:unit Ctypes.ptr -> running_max:unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> averaging_const:float -> quant_min:int -> quant_max:int -> ch_axis:int -> per_row_fake_quant:bool -> symmetric_quant:bool -> C.TensorG.t * C.TensorG.t
val _fused_moving_avg_obs_fq_helper_functional : unit Ctypes.ptr -> observer_on:unit Ctypes.ptr -> fake_quant_on:unit Ctypes.ptr -> running_min:unit Ctypes.ptr -> running_max:unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> averaging_const:float -> quant_min:int -> quant_max:int -> ch_axis:int -> per_row_fake_quant:bool -> symmetric_quant:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _fused_moving_avg_obs_fq_helper_out : out0:unit Ctypes.ptr -> out1:unit Ctypes.ptr -> unit Ctypes.ptr -> observer_on:unit Ctypes.ptr -> fake_quant_on:unit Ctypes.ptr -> running_min:unit Ctypes.ptr -> running_max:unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> averaging_const:float -> quant_min:int -> quant_max:int -> ch_axis:int -> per_row_fake_quant:bool -> symmetric_quant:bool -> C.TensorG.t * C.TensorG.t
val _fw_primal : unit Ctypes.ptr -> level:int -> C.TensorG.t
val _fw_primal_copy : unit Ctypes.ptr -> level:int -> C.TensorG.t
val _fw_primal_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> level:int -> C.TensorG.t
val _gather_sparse_backward : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> grad:unit Ctypes.ptr -> C.TensorG.t
val _grid_sampler_2d_cpu_fallback : unit Ctypes.ptr -> grid:unit Ctypes.ptr -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t
val _grid_sampler_2d_cpu_fallback_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> grid:unit Ctypes.ptr -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t * C.TensorG.t
val _histogramdd_bin_edges : unit Ctypes.ptr -> bins:int list -> range:float list -> weight:unit Ctypes.ptr option -> density:bool -> unit Ctypes.ptr list
val _histogramdd_from_bin_cts : unit Ctypes.ptr -> bins:int list -> range:float list -> weight:unit Ctypes.ptr option -> density:bool -> C.TensorG.t
val _histogramdd_from_bin_tensors : unit Ctypes.ptr -> bins:C.TensorG.t list -> weight:unit Ctypes.ptr option -> density:bool -> C.TensorG.t
val _index_put_impl : out:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr option list -> values:unit Ctypes.ptr -> accumulate:bool -> unsafe:bool -> C.TensorG.t
val _index_put_impl_ : unit Ctypes.ptr -> indices:unit Ctypes.ptr option list -> values:unit Ctypes.ptr -> accumulate:bool -> unsafe:bool -> C.TensorG.t
val _index_put_impl_functional : unit Ctypes.ptr -> indices:unit Ctypes.ptr option list -> values:unit Ctypes.ptr -> accumulate:bool -> unsafe:bool -> C.TensorG.t
val _indices : unit Ctypes.ptr -> C.TensorG.t
val _indices_copy : unit Ctypes.ptr -> C.TensorG.t
val _indices_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _linalg_check_errors : info:unit Ctypes.ptr -> api_name:string -> is_matrix:bool -> unit Torch_generated.return
val _linalg_inv_out_helper : out:unit Ctypes.ptr -> unit Ctypes.ptr -> infos_lu:unit Ctypes.ptr -> infos_getri:unit Ctypes.ptr -> C.TensorG.t
val _linalg_inv_out_helper_ : unit Ctypes.ptr -> infos_lu:unit Ctypes.ptr -> infos_getri:unit Ctypes.ptr -> C.TensorG.t
val _linalg_inv_out_helper_functional : unit Ctypes.ptr -> infos_lu:unit Ctypes.ptr -> infos_getri:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _linalg_qr_helper : unit Ctypes.ptr -> mode:string -> C.TensorG.t * C.TensorG.t
val _linalg_svd : a:unit Ctypes.ptr -> full_matrices:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _linalg_svd_u : u:unit Ctypes.ptr -> s:unit Ctypes.ptr -> vh:unit Ctypes.ptr -> a:unit Ctypes.ptr -> full_matrices:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _log_softmax : unit Ctypes.ptr -> dim:int -> half_to_float:bool -> C.TensorG.t
val _log_softmax_backward_data : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> dim:int -> input_dtype:Kind.packed -> C.TensorG.t
val _log_softmax_backward_data_out : out:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> dim:int -> input_dtype:Kind.packed -> C.TensorG.t
val _log_softmax_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> half_to_float:bool -> C.TensorG.t
val _logcumsumexp : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val _logcumsumexp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val _lstm_mps : unit Ctypes.ptr -> hx:C.TensorG.t list -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _lu_with_info : unit Ctypes.ptr -> pivot:bool -> check_errors:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _make_dual : primal:unit Ctypes.ptr -> tangent:unit Ctypes.ptr -> level:int -> C.TensorG.t
val _make_dual_copy : primal:unit Ctypes.ptr -> tangent:unit Ctypes.ptr -> level:int -> C.TensorG.t
val _make_dual_copy_out : out:unit Ctypes.ptr -> primal:unit Ctypes.ptr -> tangent:unit Ctypes.ptr -> level:int -> C.TensorG.t
val _make_per_channel_quantized_tensor : unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> axis:int -> C.TensorG.t
val _make_per_tensor_quantized_tensor : unit Ctypes.ptr -> scale:float -> zero_point:int -> C.TensorG.t
val _masked_scale : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> scale:float -> C.TensorG.t
val _masked_softmax : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> dim:int option -> C.TensorG.t
val _masked_softmax_backward : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> mask:unit Ctypes.ptr -> dim:int option -> C.TensorG.t
val _mkldnn_reshape : unit Ctypes.ptr -> shape:int list -> C.TensorG.t
val _mkldnn_transpose : unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val _mkldnn_transpose_ : unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val _mkldnn_transpose_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val _mps_convolution : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> C.TensorG.t
val _mps_convolution_transpose : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> C.TensorG.t
val _mps_linear : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> C.TensorG.t
val _mps_linear_backward_input : input_size:int list -> grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val _mps_linear_backward_weights : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias_defined:bool -> C.TensorG.t * C.TensorG.t
val _mps_max_pool2d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val _native_multi_head_attention : query:unit Ctypes.ptr -> key:unit Ctypes.ptr -> value:unit Ctypes.ptr -> embed_dim:int -> num_head:int -> qkv_weight:unit Ctypes.ptr -> qkv_bias:unit Ctypes.ptr -> proj_weight:unit Ctypes.ptr -> proj_bias:unit Ctypes.ptr -> mask:unit Ctypes.ptr option -> need_weights:bool -> average_attn_weights:bool -> C.TensorG.t * C.TensorG.t
val _neg_view : unit Ctypes.ptr -> C.TensorG.t
val _neg_view_copy : unit Ctypes.ptr -> C.TensorG.t
val _neg_view_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _nested_from_padded : padded:unit Ctypes.ptr -> cpu_nested_shape_example:unit Ctypes.ptr -> fuse_transform_0213:bool -> C.TensorG.t
val _nested_from_padded_and_nested_example : padded:unit Ctypes.ptr -> nt_example:unit Ctypes.ptr -> C.TensorG.t
val _nested_tensor_from_mask : tr:unit Ctypes.ptr -> mask:unit Ctypes.ptr -> C.TensorG.t
val _nested_tensor_layer_norm : unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> eps:float -> C.TensorG.t
val _new_zeros_with_same_feature_meta : unit Ctypes.ptr -> unit Ctypes.ptr -> self_num_batch_dims:int -> C.TensorG.t
val _nnpack_spatial_convolution : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> padding:int list -> stride:int list -> C.TensorG.t
val _pack_padded_sequence : unit Ctypes.ptr -> lengths:unit Ctypes.ptr -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val _pack_padded_sequence_backward : grad:unit Ctypes.ptr -> input_size:int list -> batch_sizes:unit Ctypes.ptr -> batch_first:bool -> C.TensorG.t
val _pad_circular : unit Ctypes.ptr -> pad:int list -> C.TensorG.t
val _pad_enum : unit Ctypes.ptr -> pad:int list -> mode:int -> value:float option -> C.TensorG.t
val _pad_packed_sequence : data:unit Ctypes.ptr -> batch_sizes:unit Ctypes.ptr -> batch_first:bool -> padding_value:unit Ctypes.ptr -> total_length:int -> C.TensorG.t * C.TensorG.t
val _pdist_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> p:float -> pdist:unit Ctypes.ptr -> C.TensorG.t
val _pin_memory : unit Ctypes.ptr -> device:Device.t -> C.TensorG.t
val _remove_batch_dim : unit Ctypes.ptr -> level:int -> batch_size:int -> out_dim:int -> C.TensorG.t
val _reshape_alias : unit Ctypes.ptr -> size:int list -> stride:int list -> C.TensorG.t
val _reshape_alias_copy : unit Ctypes.ptr -> size:int list -> stride:int list -> C.TensorG.t
val _reshape_alias_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int list -> stride:int list -> C.TensorG.t
val _reshape_from_tensor : unit Ctypes.ptr -> shape:unit Ctypes.ptr -> C.TensorG.t
val _resize_output : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int list -> device:Device.t -> C.TensorG.t
val _resize_output_ : unit Ctypes.ptr -> size:int list -> device:Device.t -> C.TensorG.t
val _resize_output_functional : unit Ctypes.ptr -> size:int list -> device:Device.t -> C.TensorG.t
val _rowwise_prune : weight:unit Ctypes.ptr -> mask:unit Ctypes.ptr -> compressed_indices_dtype:Kind.packed -> C.TensorG.t * C.TensorG.t
val _sample_dirichlet : unit Ctypes.ptr -> C.TensorG.t
val _saturate_weight_to_fp16 : weight:unit Ctypes.ptr -> C.TensorG.t
val _scatter_reduce : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> reduce:string -> include_self:bool -> C.TensorG.t
val _scatter_reduce_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> reduce:string -> include_self:bool -> C.TensorG.t
val _scatter_reduce_two_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> reduce:string -> include_self:bool -> C.TensorG.t
val _segment_reduce_backward : grad:unit Ctypes.ptr -> output:unit Ctypes.ptr -> data:unit Ctypes.ptr -> reduce:string -> lengths:unit Ctypes.ptr option -> axis:int -> C.TensorG.t
val _shape_as_tensor : unit Ctypes.ptr -> C.TensorG.t
val _slow_conv2d_backward : grad_input:unit Ctypes.ptr -> grad_weight:unit Ctypes.ptr -> grad_bias:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _sobol_engine_draw : quasi:unit Ctypes.ptr -> n:int -> sobolstate:unit Ctypes.ptr -> dimension:int -> num_generated:int -> dtype:Kind.packed -> C.TensorG.t * C.TensorG.t
val _sobol_engine_ff_ : unit Ctypes.ptr -> n:int -> sobolstate:unit Ctypes.ptr -> dimension:int -> num_generated:int -> C.TensorG.t
val _sobol_engine_initialize_state_ : unit Ctypes.ptr -> dimension:int -> C.TensorG.t
val _sobol_engine_scramble_ : unit Ctypes.ptr -> ltm:unit Ctypes.ptr -> dimension:int -> C.TensorG.t
val _softmax : unit Ctypes.ptr -> dim:int -> half_to_float:bool -> C.TensorG.t
val _softmax_backward_data : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> dim:int -> input_dtype:Kind.packed -> C.TensorG.t
val _softmax_backward_data_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> dim:int -> input_dtype:Kind.packed -> C.TensorG.t
val _softmax_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> half_to_float:bool -> C.TensorG.t
val _sparse_addmm : unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val _sparse_broadcast_to : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val _sparse_broadcast_to_copy : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val _sparse_broadcast_to_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int list -> C.TensorG.t
val _sparse_bsc_tensor_unsafe : ccol_indices:unit Ctypes.ptr -> row_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_bsr_tensor_unsafe : crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_compressed_tensor_unsafe : compressed_indices:unit Ctypes.ptr -> plain_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_coo_tensor_unsafe : indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_coo_tensor_with_dims : sparse_dim:int -> dense_dim:int -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_coo_tensor_with_dims_and_tensors : sparse_dim:int -> dense_dim:int -> size:int list -> indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_csc_tensor_unsafe : ccol_indices:unit Ctypes.ptr -> row_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_csr_prod : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val _sparse_csr_sum : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val _sparse_csr_tensor_unsafe : crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_log_softmax : unit Ctypes.ptr -> dim:int -> half_to_float:bool -> C.TensorG.t
val _sparse_log_softmax_backward_data : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> dim:int -> unit Ctypes.ptr -> C.TensorG.t
val _sparse_log_softmax_int : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val _sparse_mask_helper : tr:unit Ctypes.ptr -> mask_indices:unit Ctypes.ptr -> C.TensorG.t
val _sparse_mm : sparse:unit Ctypes.ptr -> dense:unit Ctypes.ptr -> C.TensorG.t
val _sparse_softmax : unit Ctypes.ptr -> dim:int -> half_to_float:bool -> C.TensorG.t
val _sparse_softmax_backward_data : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> dim:int -> unit Ctypes.ptr -> C.TensorG.t
val _sparse_softmax_int : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val _sparse_sparse_matmul : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _sparse_sum : unit Ctypes.ptr -> C.TensorG.t
val _sparse_sum_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> C.TensorG.t
val _sparse_sum_dim : unit Ctypes.ptr -> dim:int list -> C.TensorG.t
val _sparse_sum_dim_dtype : unit Ctypes.ptr -> dim:int list -> dtype:Kind.packed -> C.TensorG.t
val _sparse_sum_dtype : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val _stack : C.TensorG.t list -> dim:int -> C.TensorG.t
val _stack_out : out:unit Ctypes.ptr -> C.TensorG.t list -> dim:int -> C.TensorG.t
val _standard_gamma : unit Ctypes.ptr -> C.TensorG.t
val _standard_gamma_grad : unit Ctypes.ptr -> output:unit Ctypes.ptr -> C.TensorG.t
val _symeig_helper : unit Ctypes.ptr -> eigenvectors:bool -> upper:bool -> C.TensorG.t * C.TensorG.t
val _test_ambiguous_defaults : dummy:unit Ctypes.ptr -> a:int -> b:int -> C.TensorG.t
val _test_ambiguous_defaults_b : dummy:unit Ctypes.ptr -> a:int -> b:string -> C.TensorG.t
val _test_optional_filled_intlist : values:unit Ctypes.ptr -> addends:int list option -> C.TensorG.t
val _test_optional_floatlist : values:unit Ctypes.ptr -> addends:float list -> C.TensorG.t
val _test_optional_intlist : values:unit Ctypes.ptr -> addends:int list option -> C.TensorG.t
val _test_serialization_subcmul : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _test_string_default : dummy:unit Ctypes.ptr -> a:string -> b:string -> C.TensorG.t
val _test_warn_in_autograd : unit Ctypes.ptr -> C.TensorG.t
val _thnn_differentiable_gru_cell_backward : grad_hy:unit Ctypes.ptr -> input_gates:unit Ctypes.ptr -> hidden_gates:unit Ctypes.ptr -> hx:unit Ctypes.ptr -> input_bias:unit Ctypes.ptr option -> hidden_bias:unit Ctypes.ptr option -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_differentiable_lstm_cell_backward : grad_hy:unit Ctypes.ptr option -> grad_cy:unit Ctypes.ptr option -> input_gates:unit Ctypes.ptr -> hidden_gates:unit Ctypes.ptr -> input_bias:unit Ctypes.ptr option -> hidden_bias:unit Ctypes.ptr option -> cx:unit Ctypes.ptr -> cy:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_fused_gru_cell : input_gates:unit Ctypes.ptr -> hidden_gates:unit Ctypes.ptr -> hx:unit Ctypes.ptr -> input_bias:unit Ctypes.ptr option -> hidden_bias:unit Ctypes.ptr option -> C.TensorG.t * C.TensorG.t
val _thnn_fused_gru_cell_backward : grad_hy:unit Ctypes.ptr -> workspace:unit Ctypes.ptr -> has_bias:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_fused_lstm_cell : input_gates:unit Ctypes.ptr -> hidden_gates:unit Ctypes.ptr -> cx:unit Ctypes.ptr -> input_bias:unit Ctypes.ptr option -> hidden_bias:unit Ctypes.ptr option -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_fused_lstm_cell_backward : grad_hy:unit Ctypes.ptr option -> grad_cy:unit Ctypes.ptr option -> cx:unit Ctypes.ptr -> cy:unit Ctypes.ptr -> workspace:unit Ctypes.ptr -> has_bias:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_fused_lstm_cell_backward_impl : grad_hy:unit Ctypes.ptr option -> grad_cy:unit Ctypes.ptr option -> cx:unit Ctypes.ptr -> cy:unit Ctypes.ptr -> workspace:unit Ctypes.ptr -> has_bias:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _to_copy : unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> non_blocking:bool -> C.TensorG.t
val _to_cpu : C.TensorG.t list -> unit Ctypes.ptr list
val _to_dense : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val _torch_cuda_cu_linker_symbol_op : unit Ctypes.ptr -> C.TensorG.t
val _transform_bias_rescale_qkv : qkv:unit Ctypes.ptr -> qkv_bias:unit Ctypes.ptr -> num_heads:int -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _transformer_encoder_layer_fwd : src:unit Ctypes.ptr -> embed_dim:int -> num_heads:int -> qkv_weight:unit Ctypes.ptr -> qkv_bias:unit Ctypes.ptr -> proj_weight:unit Ctypes.ptr -> proj_bias:unit Ctypes.ptr -> use_gelu:bool -> norm_first:bool -> eps:float -> norm_weight_1:unit Ctypes.ptr -> norm_bias_1:unit Ctypes.ptr -> norm_weight_2:unit Ctypes.ptr -> norm_bias_2:unit Ctypes.ptr -> ffn_weight_1:unit Ctypes.ptr -> ffn_bias_1:unit Ctypes.ptr -> ffn_weight_2:unit Ctypes.ptr -> ffn_bias_2:unit Ctypes.ptr -> mask:unit Ctypes.ptr option -> C.TensorG.t
val _trilinear : i1:unit Ctypes.ptr -> i2:unit Ctypes.ptr -> i3:unit Ctypes.ptr -> expand1:int list -> expand2:int list -> expand3:int list -> sumdim:int list -> unroll_dim:int -> C.TensorG.t
val _unique : unit Ctypes.ptr -> sorted:bool -> return_inverse:bool -> C.TensorG.t * C.TensorG.t
val _unique2 : unit Ctypes.ptr -> sorted:bool -> return_inverse:bool -> return_counts:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _unpack_dual : dual:unit Ctypes.ptr -> level:int -> C.TensorG.t * C.TensorG.t
val _unsafe_view : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val _upsample_bicubic2d_aa : unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_bicubic2d_aa_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_bicubic2d_aa_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_bicubic2d_aa_backward_vec : grad_output:unit Ctypes.ptr -> output_size:int list option -> input_size:int list -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val _upsample_bicubic2d_aa_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_bicubic2d_aa_vec : unit Ctypes.ptr -> output_size:int list option -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val _upsample_bilinear2d_aa : unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_bilinear2d_aa_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_bilinear2d_aa_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_bilinear2d_aa_backward_vec : grad_output:unit Ctypes.ptr -> output_size:int list option -> input_size:int list -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val _upsample_bilinear2d_aa_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_bilinear2d_aa_vec : unit Ctypes.ptr -> output_size:int list option -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val _upsample_nearest_exact1d : unit Ctypes.ptr -> output_size:int list -> scales:float option -> C.TensorG.t
val _upsample_nearest_exact1d_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales:float option -> C.TensorG.t
val _upsample_nearest_exact1d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales:float option -> C.TensorG.t
val _upsample_nearest_exact1d_backward_vec : grad_output:unit Ctypes.ptr -> output_size:int list option -> input_size:int list -> scale_factors:float list -> C.TensorG.t
val _upsample_nearest_exact1d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> scales:float option -> C.TensorG.t
val _upsample_nearest_exact1d_vec : unit Ctypes.ptr -> output_size:int list option -> scale_factors:float list -> C.TensorG.t
val _upsample_nearest_exact2d : unit Ctypes.ptr -> output_size:int list -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_nearest_exact2d_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_nearest_exact2d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_nearest_exact2d_backward_vec : grad_output:unit Ctypes.ptr -> output_size:int list option -> input_size:int list -> scale_factors:float list -> C.TensorG.t
val _upsample_nearest_exact2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_nearest_exact2d_vec : unit Ctypes.ptr -> output_size:int list option -> scale_factors:float list -> C.TensorG.t
val _upsample_nearest_exact3d : unit Ctypes.ptr -> output_size:int list -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_nearest_exact3d_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_nearest_exact3d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_nearest_exact3d_backward_vec : grad_output:unit Ctypes.ptr -> output_size:int list option -> input_size:int list -> scale_factors:float list -> C.TensorG.t
val _upsample_nearest_exact3d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val _upsample_nearest_exact3d_vec : unit Ctypes.ptr -> output_size:int list option -> scale_factors:float list -> C.TensorG.t
val _validate_sparse_bsc_tensor_args : ccol_indices:unit Ctypes.ptr -> row_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> unit Torch_generated.return
val _validate_sparse_bsr_tensor_args : crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> unit Torch_generated.return
val _validate_sparse_csc_tensor_args : ccol_indices:unit Ctypes.ptr -> row_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> unit Torch_generated.return
val _values : unit Ctypes.ptr -> C.TensorG.t
val _values_copy : unit Ctypes.ptr -> C.TensorG.t
val _values_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _weight_norm : v:unit Ctypes.ptr -> g:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val _weight_norm_differentiable_backward : grad_w:unit Ctypes.ptr -> saved_v:unit Ctypes.ptr -> saved_g:unit Ctypes.ptr -> saved_norms:unit Ctypes.ptr -> dim:int -> C.TensorG.t * C.TensorG.t
val _weight_norm_interface : v:unit Ctypes.ptr -> g:unit Ctypes.ptr -> dim:int -> C.TensorG.t * C.TensorG.t
val _weight_norm_interface_backward : grad_w:unit Ctypes.ptr -> saved_v:unit Ctypes.ptr -> saved_g:unit Ctypes.ptr -> saved_norms:unit Ctypes.ptr -> dim:int -> C.TensorG.t * C.TensorG.t
val abs : unit Ctypes.ptr -> C.TensorG.t
val abs_ : unit Ctypes.ptr -> C.TensorG.t
val abs_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val absolute : unit Ctypes.ptr -> C.TensorG.t
val absolute_ : unit Ctypes.ptr -> C.TensorG.t
val absolute_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val acos : unit Ctypes.ptr -> C.TensorG.t
val acos_ : unit Ctypes.ptr -> C.TensorG.t
val acos_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val acosh : unit Ctypes.ptr -> C.TensorG.t
val acosh_ : unit Ctypes.ptr -> C.TensorG.t
val acosh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val adaptive_avg_pool1d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val adaptive_avg_pool2d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val adaptive_avg_pool2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val adaptive_avg_pool3d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val adaptive_avg_pool3d_backward : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val adaptive_avg_pool3d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val adaptive_max_pool1d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t * C.TensorG.t
val adaptive_max_pool2d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t * C.TensorG.t
val adaptive_max_pool2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> C.TensorG.t
val adaptive_max_pool2d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> C.TensorG.t
val adaptive_max_pool2d_out : out:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> C.TensorG.t * C.TensorG.t
val adaptive_max_pool3d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t * C.TensorG.t
val adaptive_max_pool3d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> C.TensorG.t
val adaptive_max_pool3d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> C.TensorG.t
val adaptive_max_pool3d_out : out:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> C.TensorG.t * C.TensorG.t
val add : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val add_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val add_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val add_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val add_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val add_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val addbmm : unit Ctypes.ptr -> batch1:unit Ctypes.ptr -> batch2:unit Ctypes.ptr -> C.TensorG.t
val addbmm_ : unit Ctypes.ptr -> batch1:unit Ctypes.ptr -> batch2:unit Ctypes.ptr -> C.TensorG.t
val addbmm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> batch1:unit Ctypes.ptr -> batch2:unit Ctypes.ptr -> C.TensorG.t
val addcdiv : unit Ctypes.ptr -> tensor1:unit Ctypes.ptr -> tensor2:unit Ctypes.ptr -> C.TensorG.t
val addcdiv_ : unit Ctypes.ptr -> tensor1:unit Ctypes.ptr -> tensor2:unit Ctypes.ptr -> C.TensorG.t
val addcdiv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> tensor1:unit Ctypes.ptr -> tensor2:unit Ctypes.ptr -> C.TensorG.t
val addcmul : unit Ctypes.ptr -> tensor1:unit Ctypes.ptr -> tensor2:unit Ctypes.ptr -> C.TensorG.t
val addcmul_ : unit Ctypes.ptr -> tensor1:unit Ctypes.ptr -> tensor2:unit Ctypes.ptr -> C.TensorG.t
val addcmul_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> tensor1:unit Ctypes.ptr -> tensor2:unit Ctypes.ptr -> C.TensorG.t
val addmm : unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val addmm_ : unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val addmm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val addmv : unit Ctypes.ptr -> mat:unit Ctypes.ptr -> vec:unit Ctypes.ptr -> C.TensorG.t
val addmv_ : unit Ctypes.ptr -> mat:unit Ctypes.ptr -> vec:unit Ctypes.ptr -> C.TensorG.t
val addmv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mat:unit Ctypes.ptr -> vec:unit Ctypes.ptr -> C.TensorG.t
val addr : unit Ctypes.ptr -> vec1:unit Ctypes.ptr -> vec2:unit Ctypes.ptr -> C.TensorG.t
val addr_ : unit Ctypes.ptr -> vec1:unit Ctypes.ptr -> vec2:unit Ctypes.ptr -> C.TensorG.t
val addr_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> vec1:unit Ctypes.ptr -> vec2:unit Ctypes.ptr -> C.TensorG.t
val adjoint : unit Ctypes.ptr -> C.TensorG.t
val affine_grid_generator : theta:unit Ctypes.ptr -> size:int list -> align_corners:bool -> C.TensorG.t
val affine_grid_generator_backward : grad:unit Ctypes.ptr -> size:int list -> align_corners:bool -> C.TensorG.t
val alias : unit Ctypes.ptr -> C.TensorG.t
val alias_copy : unit Ctypes.ptr -> C.TensorG.t
val alias_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val align_as : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val align_tensors : C.TensorG.t list -> unit Ctypes.ptr list
val all : unit Ctypes.ptr -> C.TensorG.t
val all_all_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val all_dim : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val all_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val alpha_dropout : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t
val alpha_dropout_ : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t
val amax : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val amax_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val amin : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val amin_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val aminmax : unit Ctypes.ptr -> dim:int option -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val aminmax_out : min:unit Ctypes.ptr -> max:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int option -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val angle : unit Ctypes.ptr -> C.TensorG.t
val angle_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val any : unit Ctypes.ptr -> C.TensorG.t
val any_all_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val any_dim : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val any_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val arange : end_:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val arange_out : out:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> C.TensorG.t
val arange_start : start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val arange_start_out : out:unit Ctypes.ptr -> start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> C.TensorG.t
val arange_start_step : start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> step:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val arccos : unit Ctypes.ptr -> C.TensorG.t
val arccos_ : unit Ctypes.ptr -> C.TensorG.t
val arccos_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val arccosh : unit Ctypes.ptr -> C.TensorG.t
val arccosh_ : unit Ctypes.ptr -> C.TensorG.t
val arccosh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val arcsin : unit Ctypes.ptr -> C.TensorG.t
val arcsin_ : unit Ctypes.ptr -> C.TensorG.t
val arcsin_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val arcsinh : unit Ctypes.ptr -> C.TensorG.t
val arcsinh_ : unit Ctypes.ptr -> C.TensorG.t
val arcsinh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val arctan : unit Ctypes.ptr -> C.TensorG.t
val arctan2 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val arctan2_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val arctan2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val arctan_ : unit Ctypes.ptr -> C.TensorG.t
val arctan_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val arctanh : unit Ctypes.ptr -> C.TensorG.t
val arctanh_ : unit Ctypes.ptr -> C.TensorG.t
val arctanh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val argmax : unit Ctypes.ptr -> dim:int option -> keepdim:bool -> C.TensorG.t
val argmax_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int option -> keepdim:bool -> C.TensorG.t
val argmin : unit Ctypes.ptr -> dim:int option -> keepdim:bool -> C.TensorG.t
val argmin_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int option -> keepdim:bool -> C.TensorG.t
val argsort : unit Ctypes.ptr -> dim:int -> descending:bool -> C.TensorG.t
val argwhere : unit Ctypes.ptr -> C.TensorG.t
val as_strided : unit Ctypes.ptr -> size:int list -> stride:int list -> storage_offset:int option -> C.TensorG.t
val as_strided_ : unit Ctypes.ptr -> size:int list -> stride:int list -> storage_offset:int option -> C.TensorG.t
val as_strided_copy : unit Ctypes.ptr -> size:int list -> stride:int list -> storage_offset:int option -> C.TensorG.t
val as_strided_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int list -> stride:int list -> storage_offset:int option -> C.TensorG.t
val asin : unit Ctypes.ptr -> C.TensorG.t
val asin_ : unit Ctypes.ptr -> C.TensorG.t
val asin_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val asinh : unit Ctypes.ptr -> C.TensorG.t
val asinh_ : unit Ctypes.ptr -> C.TensorG.t
val asinh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val atan : unit Ctypes.ptr -> C.TensorG.t
val atan2 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val atan2_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val atan2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val atan_ : unit Ctypes.ptr -> C.TensorG.t
val atan_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val atanh : unit Ctypes.ptr -> C.TensorG.t
val atanh_ : unit Ctypes.ptr -> C.TensorG.t
val atanh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val atleast_1d : unit Ctypes.ptr -> C.TensorG.t
val atleast_1d_sequence : C.TensorG.t list -> unit Ctypes.ptr list
val atleast_2d : unit Ctypes.ptr -> C.TensorG.t
val atleast_2d_sequence : C.TensorG.t list -> unit Ctypes.ptr list
val atleast_3d : unit Ctypes.ptr -> C.TensorG.t
val atleast_3d_sequence : C.TensorG.t list -> unit Ctypes.ptr list
val avg_pool1d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> C.TensorG.t
val avg_pool2d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int option -> C.TensorG.t
val avg_pool2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int option -> C.TensorG.t
val avg_pool2d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int option -> C.TensorG.t
val avg_pool2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int option -> C.TensorG.t
val avg_pool3d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int option -> C.TensorG.t
val avg_pool3d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int option -> C.TensorG.t
val avg_pool3d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int option -> C.TensorG.t
val avg_pool3d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int option -> C.TensorG.t
val baddbmm : unit Ctypes.ptr -> batch1:unit Ctypes.ptr -> batch2:unit Ctypes.ptr -> C.TensorG.t
val baddbmm_ : unit Ctypes.ptr -> batch1:unit Ctypes.ptr -> batch2:unit Ctypes.ptr -> C.TensorG.t
val baddbmm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> batch1:unit Ctypes.ptr -> batch2:unit Ctypes.ptr -> C.TensorG.t
val bartlett_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val bartlett_window_periodic : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val batch_norm : unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> training:bool -> momentum:float -> eps:float -> cudnn_enabled:bool -> C.TensorG.t
val batch_norm_backward_elemt : grad_out:unit Ctypes.ptr -> unit Ctypes.ptr -> mean:unit Ctypes.ptr -> invstd:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> mean_dy:unit Ctypes.ptr -> mean_dy_xmu:unit Ctypes.ptr -> count:unit Ctypes.ptr -> C.TensorG.t
val batch_norm_backward_reduce : grad_out:unit Ctypes.ptr -> unit Ctypes.ptr -> mean:unit Ctypes.ptr -> invstd:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> input_g:bool -> weight_g:bool -> bias_g:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val batch_norm_elemt : unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> mean:unit Ctypes.ptr -> invstd:unit Ctypes.ptr -> eps:float -> C.TensorG.t
val batch_norm_elemt_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> mean:unit Ctypes.ptr -> invstd:unit Ctypes.ptr -> eps:float -> C.TensorG.t
val batch_norm_gather_stats : unit Ctypes.ptr -> mean:unit Ctypes.ptr -> invstd:unit Ctypes.ptr -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> momentum:float -> eps:float -> count:int -> C.TensorG.t * C.TensorG.t
val batch_norm_gather_stats_with_counts : unit Ctypes.ptr -> mean:unit Ctypes.ptr -> invstd:unit Ctypes.ptr -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> momentum:float -> eps:float -> counts:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val batch_norm_stats : unit Ctypes.ptr -> eps:float -> C.TensorG.t * C.TensorG.t
val batch_norm_update_stats : unit Ctypes.ptr -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> momentum:float -> C.TensorG.t * C.TensorG.t
val bernoulli : unit Ctypes.ptr -> C.TensorG.t
val bernoulli_ : unit Ctypes.ptr -> p:unit Ctypes.ptr -> C.TensorG.t
val bernoulli_float_ : unit Ctypes.ptr -> p:float -> C.TensorG.t
val bernoulli_p : unit Ctypes.ptr -> p:float -> C.TensorG.t
val bernoulli_tensor_functional : unit Ctypes.ptr -> p:unit Ctypes.ptr -> C.TensorG.t
val bilinear : input1:unit Ctypes.ptr -> input2:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> C.TensorG.t
val binary_cross_entropy : unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_with_logits : unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> pos_weight:unit Ctypes.ptr option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_with_logits_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> pos_weight:unit Ctypes.ptr option -> reduction:Reduction.t -> C.TensorG.t
val bincount : unit Ctypes.ptr -> weights:unit Ctypes.ptr option -> minlength:int -> C.TensorG.t
val binomial : count:unit Ctypes.ptr -> prob:unit Ctypes.ptr -> C.TensorG.t
val bitwise_and : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_scalar_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_left_shift : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_left_shift_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_left_shift_scalar_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_left_shift_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_left_shift_tensor_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_left_shift_tensor_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_left_shift_tensor_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_not : unit Ctypes.ptr -> C.TensorG.t
val bitwise_not_ : unit Ctypes.ptr -> C.TensorG.t
val bitwise_not_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_scalar_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_right_shift : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_right_shift_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_right_shift_scalar_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_right_shift_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_right_shift_tensor_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_right_shift_tensor_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_right_shift_tensor_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_scalar_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val blackman_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val blackman_window_periodic : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val block_diag : C.TensorG.t list -> C.TensorG.t
val bmm : unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val bmm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val broadcast_tensors : C.TensorG.t list -> unit Ctypes.ptr list
val broadcast_to : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val bucketize : unit Ctypes.ptr -> boundaries:unit Ctypes.ptr -> out_int32:bool -> right:bool -> C.TensorG.t
val bucketize_scalar : unit Ctypes.ptr -> boundaries:unit Ctypes.ptr -> out_int32:bool -> right:bool -> C.TensorG.t
val bucketize_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> boundaries:unit Ctypes.ptr -> out_int32:bool -> right:bool -> C.TensorG.t
val cartesian_prod : C.TensorG.t list -> C.TensorG.t
val cat : C.TensorG.t list -> dim:int -> C.TensorG.t
val cat_out : out:unit Ctypes.ptr -> C.TensorG.t list -> dim:int -> C.TensorG.t
val cauchy : out:unit Ctypes.ptr -> unit Ctypes.ptr -> median:float -> sigma:float -> C.TensorG.t
val cauchy_ : unit Ctypes.ptr -> median:float -> sigma:float -> C.TensorG.t
val cauchy_functional : unit Ctypes.ptr -> median:float -> sigma:float -> C.TensorG.t
val ccol_indices : unit Ctypes.ptr -> C.TensorG.t
val ccol_indices_copy : unit Ctypes.ptr -> C.TensorG.t
val cdist : x1:unit Ctypes.ptr -> x2:unit Ctypes.ptr -> p:float -> compute_mode:int option -> C.TensorG.t
val ceil : unit Ctypes.ptr -> C.TensorG.t
val ceil_ : unit Ctypes.ptr -> C.TensorG.t
val ceil_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val celu : unit Ctypes.ptr -> C.TensorG.t
val celu_ : unit Ctypes.ptr -> C.TensorG.t
val celu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val chain_matmul : matrices:C.TensorG.t list -> C.TensorG.t
val chain_matmul_out : out:unit Ctypes.ptr -> matrices:C.TensorG.t list -> C.TensorG.t
val chalf : unit Ctypes.ptr -> C.TensorG.t
val channel_shuffle : unit Ctypes.ptr -> groups:int -> C.TensorG.t
val cholesky : unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val cholesky_inverse : unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val cholesky_inverse_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val cholesky_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val cholesky_solve : unit Ctypes.ptr -> input2:unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val cholesky_solve_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> input2:unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val choose_qparams_optimized : unit Ctypes.ptr -> numel:int -> n_bins:int -> ratio:float -> bit_width:int -> C.TensorG.t * C.TensorG.t
val chunk : unit Ctypes.ptr -> chunks:int -> dim:int -> unit Ctypes.ptr list
val clamp : unit Ctypes.ptr -> min:unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_ : unit Ctypes.ptr -> min:unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_max : unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_max_ : unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_max_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_max_tensor : unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_max_tensor_ : unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_max_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_min : unit Ctypes.ptr -> min:unit Ctypes.ptr -> C.TensorG.t
val clamp_min_ : unit Ctypes.ptr -> min:unit Ctypes.ptr -> C.TensorG.t
val clamp_min_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> min:unit Ctypes.ptr -> C.TensorG.t
val clamp_min_tensor : unit Ctypes.ptr -> min:unit Ctypes.ptr -> C.TensorG.t
val clamp_min_tensor_ : unit Ctypes.ptr -> min:unit Ctypes.ptr -> C.TensorG.t
val clamp_min_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> min:unit Ctypes.ptr -> C.TensorG.t
val clamp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> min:unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clamp_tensor : unit Ctypes.ptr -> min:unit Ctypes.ptr option -> max:unit Ctypes.ptr option -> C.TensorG.t
val clamp_tensor_ : unit Ctypes.ptr -> min:unit Ctypes.ptr option -> max:unit Ctypes.ptr option -> C.TensorG.t
val clamp_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> min:unit Ctypes.ptr option -> max:unit Ctypes.ptr option -> C.TensorG.t
val clip : unit Ctypes.ptr -> min:unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clip_ : unit Ctypes.ptr -> min:unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clip_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> min:unit Ctypes.ptr -> max:unit Ctypes.ptr -> C.TensorG.t
val clip_tensor : unit Ctypes.ptr -> min:unit Ctypes.ptr option -> max:unit Ctypes.ptr option -> C.TensorG.t
val clip_tensor_ : unit Ctypes.ptr -> min:unit Ctypes.ptr option -> max:unit Ctypes.ptr option -> C.TensorG.t
val clip_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> min:unit Ctypes.ptr option -> max:unit Ctypes.ptr option -> C.TensorG.t
val clone : unit Ctypes.ptr -> C.TensorG.t
val coalesce : unit Ctypes.ptr -> C.TensorG.t
val col2im : unit Ctypes.ptr -> output_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val col2im_backward : grad_output:unit Ctypes.ptr -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val col2im_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val col2im_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val col_indices : unit Ctypes.ptr -> C.TensorG.t
val col_indices_copy : unit Ctypes.ptr -> C.TensorG.t
val col_indices_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val column_stack : C.TensorG.t list -> C.TensorG.t
val column_stack_out : out:unit Ctypes.ptr -> C.TensorG.t list -> C.TensorG.t
val combinations : unit Ctypes.ptr -> r:int -> with_replacement:bool -> C.TensorG.t
val complex : real:unit Ctypes.ptr -> imag:unit Ctypes.ptr -> C.TensorG.t
val complex_out : out:unit Ctypes.ptr -> real:unit Ctypes.ptr -> imag:unit Ctypes.ptr -> C.TensorG.t
val concat : C.TensorG.t list -> dim:int -> C.TensorG.t
val concat_out : out:unit Ctypes.ptr -> C.TensorG.t list -> dim:int -> C.TensorG.t
val conj : unit Ctypes.ptr -> C.TensorG.t
val conj_physical : unit Ctypes.ptr -> C.TensorG.t
val conj_physical_ : unit Ctypes.ptr -> C.TensorG.t
val conj_physical_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val constant_pad_nd : unit Ctypes.ptr -> pad:int list -> C.TensorG.t
val contiguous : unit Ctypes.ptr -> C.TensorG.t
val conv1d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> C.TensorG.t
val conv1d_padding : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:string -> dilation:int list -> groups:int -> C.TensorG.t
val conv2d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> C.TensorG.t
val conv2d_padding : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:string -> dilation:int list -> groups:int -> C.TensorG.t
val conv3d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> C.TensorG.t
val conv3d_padding : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:string -> dilation:int list -> groups:int -> C.TensorG.t
val conv_depthwise3d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> C.TensorG.t
val conv_tbc : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> pad:int -> C.TensorG.t
val conv_tbc_backward : unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> pad:int -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val conv_transpose1d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> output_padding:int list -> groups:int -> dilation:int list -> C.TensorG.t
val conv_transpose2d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> output_padding:int list -> groups:int -> dilation:int list -> C.TensorG.t
val conv_transpose3d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> output_padding:int list -> groups:int -> dilation:int list -> C.TensorG.t
val convolution : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> C.TensorG.t
val convolution_overrideable : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> C.TensorG.t
val copy : unit Ctypes.ptr -> src:unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> src:unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val copy_sparse_to_sparse : out:unit Ctypes.ptr -> unit Ctypes.ptr -> src:unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val copy_sparse_to_sparse_ : unit Ctypes.ptr -> src:unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val copy_sparse_to_sparse_functional : unit Ctypes.ptr -> src:unit Ctypes.ptr -> non_blocking:bool -> C.TensorG.t
val copysign : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val copysign_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val copysign_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val copysign_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val copysign_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val copysign_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val corrcoef : unit Ctypes.ptr -> C.TensorG.t
val cos : unit Ctypes.ptr -> C.TensorG.t
val cos_ : unit Ctypes.ptr -> C.TensorG.t
val cos_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val cosh : unit Ctypes.ptr -> C.TensorG.t
val cosh_ : unit Ctypes.ptr -> C.TensorG.t
val cosh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val cosine_embedding_loss : input1:unit Ctypes.ptr -> input2:unit Ctypes.ptr -> target:unit Ctypes.ptr -> margin:float -> reduction:Reduction.t -> C.TensorG.t
val cosine_similarity : x1:unit Ctypes.ptr -> x2:unit Ctypes.ptr -> dim:int -> eps:float -> C.TensorG.t
val cov : unit Ctypes.ptr -> correction:int -> fweights:unit Ctypes.ptr option -> aweights:unit Ctypes.ptr option -> C.TensorG.t
val cross : unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int option -> C.TensorG.t
val cross_entropy_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> label_smoothing:float -> C.TensorG.t
val cross_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int option -> C.TensorG.t
val crow_indices : unit Ctypes.ptr -> C.TensorG.t
val crow_indices_copy : unit Ctypes.ptr -> C.TensorG.t
val crow_indices_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ctc_loss : log_probs:unit Ctypes.ptr -> targets:unit Ctypes.ptr -> input_lengths:int list -> target_lengths:int list -> blank:int -> reduction:Reduction.t -> zero_infinity:bool -> C.TensorG.t
val ctc_loss_tensor : log_probs:unit Ctypes.ptr -> targets:unit Ctypes.ptr -> input_lengths:unit Ctypes.ptr -> target_lengths:unit Ctypes.ptr -> blank:int -> reduction:Reduction.t -> zero_infinity:bool -> C.TensorG.t
val cudnn_affine_grid_generator : theta:unit Ctypes.ptr -> n:int -> c:int -> h:int -> w:int -> C.TensorG.t
val cudnn_affine_grid_generator_backward : grad:unit Ctypes.ptr -> n:int -> c:int -> h:int -> w:int -> C.TensorG.t
val cudnn_batch_norm : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> training:bool -> exponential_average_factor:float -> epsilon:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val cudnn_batch_norm_backward : unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> save_mean:unit Ctypes.ptr option -> save_var:unit Ctypes.ptr option -> epsilon:float -> reservespace:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val cudnn_convolution : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> allow_tf32:bool -> C.TensorG.t
val cudnn_convolution_add_relu : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> z:unit Ctypes.ptr -> alpha:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> C.TensorG.t
val cudnn_convolution_relu : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> C.TensorG.t
val cudnn_convolution_transpose : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> allow_tf32:bool -> C.TensorG.t
val cudnn_grid_sampler : unit Ctypes.ptr -> grid:unit Ctypes.ptr -> C.TensorG.t
val cudnn_grid_sampler_backward : unit Ctypes.ptr -> grid:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val cummax : unit Ctypes.ptr -> dim:int -> C.TensorG.t * C.TensorG.t
val cummax_out : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t * C.TensorG.t
val cummaxmin_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val cummin : unit Ctypes.ptr -> dim:int -> C.TensorG.t * C.TensorG.t
val cummin_out : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t * C.TensorG.t
val cumprod : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumprod_ : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumprod_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> output:unit Ctypes.ptr -> C.TensorG.t
val cumprod_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumsum : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumsum_ : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumsum_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumulative_trapezoid : y:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val cumulative_trapezoid_x : y:unit Ctypes.ptr -> x:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val data : unit Ctypes.ptr -> C.TensorG.t
val deg2rad : unit Ctypes.ptr -> C.TensorG.t
val deg2rad_ : unit Ctypes.ptr -> C.TensorG.t
val deg2rad_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val dequantize : unit Ctypes.ptr -> C.TensorG.t
val dequantize_tensors : C.TensorG.t list -> unit Ctypes.ptr list
val det : unit Ctypes.ptr -> C.TensorG.t
val detach : unit Ctypes.ptr -> C.TensorG.t
val detach_ : unit Ctypes.ptr -> C.TensorG.t
val detach_copy : unit Ctypes.ptr -> C.TensorG.t
val detach_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val diag : unit Ctypes.ptr -> diagonal:int -> C.TensorG.t
val diag_backward : grad:unit Ctypes.ptr -> input_sizes:int list -> diagonal:int -> C.TensorG.t
val diag_embed : unit Ctypes.ptr -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val diag_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> diagonal:int -> C.TensorG.t
val diagflat : unit Ctypes.ptr -> offset:int -> C.TensorG.t
val diagonal : unit Ctypes.ptr -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val diagonal_backward : grad_output:unit Ctypes.ptr -> input_sizes:int list -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val diagonal_copy : unit Ctypes.ptr -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val diagonal_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val diagonal_scatter : unit Ctypes.ptr -> src:unit Ctypes.ptr -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val diff : unit Ctypes.ptr -> n:int -> dim:int -> prepend:unit Ctypes.ptr option -> append:unit Ctypes.ptr option -> C.TensorG.t
val diff_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> dim:int -> prepend:unit Ctypes.ptr option -> append:unit Ctypes.ptr option -> C.TensorG.t
val digamma : unit Ctypes.ptr -> C.TensorG.t
val digamma_ : unit Ctypes.ptr -> C.TensorG.t
val digamma_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val dist : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_out_mode : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_scalar_mode : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div_scalar_mode_ : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div_scalar_mode_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_tensor_mode : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div_tensor_mode_ : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide_out_mode : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide_scalar_mode : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide_scalar_mode_ : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide_tensor_mode : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide_tensor_mode_ : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val dot : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val dot_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val dropout : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t
val dropout_ : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t
val dsplit : unit Ctypes.ptr -> sections:int -> unit Ctypes.ptr list
val dsplit_array : unit Ctypes.ptr -> indices:int list -> unit Ctypes.ptr list
val dstack : C.TensorG.t list -> C.TensorG.t
val dstack_out : out:unit Ctypes.ptr -> C.TensorG.t list -> C.TensorG.t
val eig : unit Ctypes.ptr -> eigenvectors:bool -> C.TensorG.t * C.TensorG.t
val eig_e : e:unit Ctypes.ptr -> v:unit Ctypes.ptr -> unit Ctypes.ptr -> eigenvectors:bool -> C.TensorG.t * C.TensorG.t
val einsum : equation:string -> C.TensorG.t list -> C.TensorG.t
val elu : unit Ctypes.ptr -> C.TensorG.t
val elu_ : unit Ctypes.ptr -> C.TensorG.t
val elu_backward : grad_output:unit Ctypes.ptr -> alpha:unit Ctypes.ptr -> scale:unit Ctypes.ptr -> input_scale:unit Ctypes.ptr -> is_result:bool -> self_or_result:unit Ctypes.ptr -> C.TensorG.t
val elu_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> alpha:unit Ctypes.ptr -> scale:unit Ctypes.ptr -> input_scale:unit Ctypes.ptr -> is_result:bool -> self_or_result:unit Ctypes.ptr -> C.TensorG.t
val elu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val embedding : weight:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> padding_idx:int -> scale_grad_by_freq:bool -> sparse:bool -> C.TensorG.t
val embedding_backward : grad:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> sparse:bool -> C.TensorG.t
val embedding_bag : weight:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> offsets:unit Ctypes.ptr -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:unit Ctypes.ptr option -> include_last_offset:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val embedding_bag_padding_idx : weight:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> offsets:unit Ctypes.ptr -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:unit Ctypes.ptr option -> include_last_offset:bool -> padding_idx:int option -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val embedding_dense_backward : grad_output:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> C.TensorG.t
val embedding_renorm : out:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> max_norm:float -> norm_type:float -> C.TensorG.t
val embedding_renorm_ : unit Ctypes.ptr -> indices:unit Ctypes.ptr -> max_norm:float -> norm_type:float -> C.TensorG.t
val embedding_renorm_functional : unit Ctypes.ptr -> indices:unit Ctypes.ptr -> max_norm:float -> norm_type:float -> C.TensorG.t
val embedding_sparse_backward : grad:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> C.TensorG.t
val empty : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val empty_like : unit Ctypes.ptr -> C.TensorG.t
val empty_out : out:unit Ctypes.ptr -> size:int list -> C.TensorG.t
val empty_quantized : size:int list -> qtensor:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val empty_strided : size:int list -> stride:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val eq : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val erf : unit Ctypes.ptr -> C.TensorG.t
val erf_ : unit Ctypes.ptr -> C.TensorG.t
val erf_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val erfc : unit Ctypes.ptr -> C.TensorG.t
val erfc_ : unit Ctypes.ptr -> C.TensorG.t
val erfc_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val erfinv : unit Ctypes.ptr -> C.TensorG.t
val erfinv_ : unit Ctypes.ptr -> C.TensorG.t
val erfinv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val exp : unit Ctypes.ptr -> C.TensorG.t
val exp2 : unit Ctypes.ptr -> C.TensorG.t
val exp2_ : unit Ctypes.ptr -> C.TensorG.t
val exp2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val exp_ : unit Ctypes.ptr -> C.TensorG.t
val exp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val expand : unit Ctypes.ptr -> size:int list -> implicit:bool -> C.TensorG.t
val expand_as : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val expand_copy : unit Ctypes.ptr -> size:int list -> implicit:bool -> C.TensorG.t
val expand_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int list -> implicit:bool -> C.TensorG.t
val expm1 : unit Ctypes.ptr -> C.TensorG.t
val expm1_ : unit Ctypes.ptr -> C.TensorG.t
val expm1_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val exponential : out:unit Ctypes.ptr -> unit Ctypes.ptr -> lambd:float -> C.TensorG.t
val exponential_ : unit Ctypes.ptr -> lambd:float -> C.TensorG.t
val exponential_functional : unit Ctypes.ptr -> lambd:float -> C.TensorG.t
val eye : n:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val eye_m : n:int -> m:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val eye_m_out : out:unit Ctypes.ptr -> n:int -> m:int -> C.TensorG.t
val eye_out : out:unit Ctypes.ptr -> n:int -> C.TensorG.t
val fake_quantize_per_channel_affine : unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> axis:int -> quant_min:int -> quant_max:int -> C.TensorG.t
val fake_quantize_per_channel_affine_cachemask : unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> axis:int -> quant_min:int -> quant_max:int -> C.TensorG.t * C.TensorG.t
val fake_quantize_per_channel_affine_cachemask_backward : grad:unit Ctypes.ptr -> mask:unit Ctypes.ptr -> C.TensorG.t
val fake_quantize_per_tensor_affine : unit Ctypes.ptr -> scale:float -> zero_point:int -> quant_min:int -> quant_max:int -> C.TensorG.t
val fake_quantize_per_tensor_affine_cachemask : unit Ctypes.ptr -> scale:float -> zero_point:int -> quant_min:int -> quant_max:int -> C.TensorG.t * C.TensorG.t
val fake_quantize_per_tensor_affine_cachemask_backward : grad:unit Ctypes.ptr -> mask:unit Ctypes.ptr -> C.TensorG.t
val fake_quantize_per_tensor_affine_tensor_qparams : unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> quant_min:int -> quant_max:int -> C.TensorG.t
val fbgemm_linear_fp16_weight : unit Ctypes.ptr -> packed_weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> C.TensorG.t
val fbgemm_linear_fp16_weight_fp32_activation : unit Ctypes.ptr -> packed_weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> C.TensorG.t
val fbgemm_linear_int8_weight : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> packed:unit Ctypes.ptr -> col_offsets:unit Ctypes.ptr -> weight_scale:unit Ctypes.ptr -> weight_zero_point:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> C.TensorG.t
val fbgemm_linear_int8_weight_fp32_activation : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> packed:unit Ctypes.ptr -> col_offsets:unit Ctypes.ptr -> weight_scale:unit Ctypes.ptr -> weight_zero_point:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> C.TensorG.t
val fbgemm_pack_gemm_matrix_fp16 : unit Ctypes.ptr -> C.TensorG.t
val fbgemm_pack_quantized_matrix : unit Ctypes.ptr -> C.TensorG.t
val fbgemm_pack_quantized_matrix_kn : unit Ctypes.ptr -> k:int -> n:int -> C.TensorG.t
val feature_alpha_dropout : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t
val feature_alpha_dropout_ : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t
val feature_dropout : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t
val feature_dropout_ : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t
val fft_fft : unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_fft2 : unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_fft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_fft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_fftfreq : n:int -> d:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val fft_fftfreq_out : out:unit Ctypes.ptr -> n:int -> d:float -> C.TensorG.t
val fft_fftn : unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_fftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_fftshift : unit Ctypes.ptr -> dim:int list option -> C.TensorG.t
val fft_hfft : unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_hfft2 : unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_hfft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_hfft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_hfftn : unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_hfftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_ifft : unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_ifft2 : unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_ifft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_ifft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_ifftn : unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_ifftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_ifftshift : unit Ctypes.ptr -> dim:int list option -> C.TensorG.t
val fft_ihfft : unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_ihfft2 : unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_ihfft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_ihfft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_ihfftn : unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_ihfftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_irfft : unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_irfft2 : unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_irfft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_irfft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_irfftn : unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_irfftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_rfft : unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_rfft2 : unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_rfft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list -> norm:string -> C.TensorG.t
val fft_rfft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int option -> dim:int -> norm:string -> C.TensorG.t
val fft_rfftfreq : n:int -> d:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val fft_rfftfreq_out : out:unit Ctypes.ptr -> n:int -> d:float -> C.TensorG.t
val fft_rfftn : unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fft_rfftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list option -> dim:int list option -> norm:string -> C.TensorG.t
val fill : unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val fill_ : unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val fill_diagonal_ : unit Ctypes.ptr -> fill_value:unit Ctypes.ptr -> wrap:bool -> C.TensorG.t
val fill_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val fill_tensor : unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val fill_tensor_ : unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val fill_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val fix : unit Ctypes.ptr -> C.TensorG.t
val fix_ : unit Ctypes.ptr -> C.TensorG.t
val fix_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val flatten : unit Ctypes.ptr -> start_dim:int -> end_dim:int -> C.TensorG.t
val flatten_dense_tensors : C.TensorG.t list -> C.TensorG.t
val flip : unit Ctypes.ptr -> dims:int list -> C.TensorG.t
val fliplr : unit Ctypes.ptr -> C.TensorG.t
val flipud : unit Ctypes.ptr -> C.TensorG.t
val float_power : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_ : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_scalar : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_tensor_ : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_tensor_scalar : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_tensor_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_tensor_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val floor : unit Ctypes.ptr -> C.TensorG.t
val floor_ : unit Ctypes.ptr -> C.TensorG.t
val floor_divide : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val floor_divide_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val floor_divide_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val floor_divide_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val floor_divide_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val floor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmax : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmax_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmin : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmin_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val frac : unit Ctypes.ptr -> C.TensorG.t
val frac_ : unit Ctypes.ptr -> C.TensorG.t
val frac_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fractional_max_pool2d : unit Ctypes.ptr -> kernel_size:int list -> output_size:int list -> random_samples:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val fractional_max_pool2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> output_size:int list -> indices:unit Ctypes.ptr -> C.TensorG.t
val fractional_max_pool2d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> output_size:int list -> indices:unit Ctypes.ptr -> C.TensorG.t
val fractional_max_pool2d_output : output:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> output_size:int list -> random_samples:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val fractional_max_pool3d : unit Ctypes.ptr -> kernel_size:int list -> output_size:int list -> random_samples:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val fractional_max_pool3d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> output_size:int list -> indices:unit Ctypes.ptr -> C.TensorG.t
val fractional_max_pool3d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> output_size:int list -> indices:unit Ctypes.ptr -> C.TensorG.t
val fractional_max_pool3d_output : output:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> output_size:int list -> random_samples:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val frexp : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val frexp_tensor_out : mantissa:unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val frobenius_norm : unit Ctypes.ptr -> C.TensorG.t
val frobenius_norm_dim : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val frobenius_norm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val from_file : filename:string -> shared:bool -> size:int option -> options:(Kind.packed * Device.t) -> C.TensorG.t
val full : size:int list -> fill_value:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val full_like : unit Ctypes.ptr -> fill_value:unit Ctypes.ptr -> C.TensorG.t
val full_out : out:unit Ctypes.ptr -> size:int list -> fill_value:unit Ctypes.ptr -> C.TensorG.t
val fused_moving_avg_obs_fake_quant : unit Ctypes.ptr -> observer_on:unit Ctypes.ptr -> fake_quant_on:unit Ctypes.ptr -> running_min:unit Ctypes.ptr -> running_max:unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> averaging_const:float -> quant_min:int -> quant_max:int -> ch_axis:int -> per_row_fake_quant:bool -> symmetric_quant:bool -> C.TensorG.t
val gather : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> sparse_grad:bool -> C.TensorG.t
val gather_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> sparse_grad:bool -> C.TensorG.t
val gather_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> sparse_grad:bool -> C.TensorG.t
val gcd : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gcd_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gcd_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gelu : unit Ctypes.ptr -> approximate:string -> C.TensorG.t
val gelu_ : unit Ctypes.ptr -> approximate:string -> C.TensorG.t
val gelu_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> approximate:string -> C.TensorG.t
val gelu_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> approximate:string -> C.TensorG.t
val gelu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> approximate:string -> C.TensorG.t
val geometric : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:float -> C.TensorG.t
val geometric_ : unit Ctypes.ptr -> p:float -> C.TensorG.t
val geometric_functional : unit Ctypes.ptr -> p:float -> C.TensorG.t
val geqrf : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val geqrf_a : a:unit Ctypes.ptr -> tau:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val ger : unit Ctypes.ptr -> vec2:unit Ctypes.ptr -> C.TensorG.t
val ger_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> vec2:unit Ctypes.ptr -> C.TensorG.t
val glu : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val glu_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val glu_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val glu_backward_jvp : grad_x:unit Ctypes.ptr -> grad_glu:unit Ctypes.ptr -> x:unit Ctypes.ptr -> dgrad_glu:unit Ctypes.ptr -> dx:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val glu_jvp : glu:unit Ctypes.ptr -> x:unit Ctypes.ptr -> dx:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val glu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val grad : unit Ctypes.ptr -> C.TensorG.t
val greater : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val grid_sampler : unit Ctypes.ptr -> grid:unit Ctypes.ptr -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t
val grid_sampler_2d : unit Ctypes.ptr -> grid:unit Ctypes.ptr -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t
val grid_sampler_3d : unit Ctypes.ptr -> grid:unit Ctypes.ptr -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t
val group_norm : unit Ctypes.ptr -> num_groups:int -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> eps:float -> cudnn_enabled:bool -> C.TensorG.t
val gru : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val gru_cell : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> w_ih:unit Ctypes.ptr -> w_hh:unit Ctypes.ptr -> b_ih:unit Ctypes.ptr option -> b_hh:unit Ctypes.ptr option -> C.TensorG.t
val gru_data : data:unit Ctypes.ptr -> batch_sizes:unit Ctypes.ptr -> hx:unit Ctypes.ptr -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t
val gt : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hamming_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hamming_window_periodic : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hamming_window_periodic_alpha : window_length:int -> periodic:bool -> alpha:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hamming_window_periodic_alpha_beta : window_length:int -> periodic:bool -> alpha:float -> beta:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hann_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hann_window_periodic : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hardshrink : unit Ctypes.ptr -> C.TensorG.t
val hardshrink_backward : grad_out:unit Ctypes.ptr -> unit Ctypes.ptr -> lambd:unit Ctypes.ptr -> C.TensorG.t
val hardshrink_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_out:unit Ctypes.ptr -> unit Ctypes.ptr -> lambd:unit Ctypes.ptr -> C.TensorG.t
val hardshrink_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hardsigmoid : unit Ctypes.ptr -> C.TensorG.t
val hardsigmoid_ : unit Ctypes.ptr -> C.TensorG.t
val hardsigmoid_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hardsigmoid_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hardsigmoid_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hardswish : unit Ctypes.ptr -> C.TensorG.t
val hardswish_ : unit Ctypes.ptr -> C.TensorG.t
val hardswish_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hardswish_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hardtanh : unit Ctypes.ptr -> C.TensorG.t
val hardtanh_ : unit Ctypes.ptr -> C.TensorG.t
val hardtanh_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> min_val:unit Ctypes.ptr -> max_val:unit Ctypes.ptr -> C.TensorG.t
val hardtanh_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> min_val:unit Ctypes.ptr -> max_val:unit Ctypes.ptr -> C.TensorG.t
val hardtanh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val heaviside : unit Ctypes.ptr -> values:unit Ctypes.ptr -> C.TensorG.t
val heaviside_ : unit Ctypes.ptr -> values:unit Ctypes.ptr -> C.TensorG.t
val heaviside_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> values:unit Ctypes.ptr -> C.TensorG.t
val hinge_embedding_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> margin:float -> reduction:Reduction.t -> C.TensorG.t
val histc : unit Ctypes.ptr -> bins:int -> C.TensorG.t
val histc_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> bins:int -> C.TensorG.t
val hsplit : unit Ctypes.ptr -> sections:int -> unit Ctypes.ptr list
val hsplit_array : unit Ctypes.ptr -> indices:int list -> unit Ctypes.ptr list
val hspmm : mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val hspmm_out : out:unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val hstack : C.TensorG.t list -> C.TensorG.t
val hstack_out : out:unit Ctypes.ptr -> C.TensorG.t list -> C.TensorG.t
val huber_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> delta:float -> C.TensorG.t
val huber_loss_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> delta:float -> C.TensorG.t
val huber_loss_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> delta:float -> C.TensorG.t
val huber_loss_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> delta:float -> C.TensorG.t
val hypot : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hypot_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val hypot_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val i0 : unit Ctypes.ptr -> C.TensorG.t
val i0_ : unit Ctypes.ptr -> C.TensorG.t
val i0_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val igamma : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val igamma_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val igamma_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val igammac : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val igammac_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val igammac_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val im2col : unit Ctypes.ptr -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val im2col_backward : grad_output:unit Ctypes.ptr -> input_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val im2col_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> input_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val im2col_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val imag : unit Ctypes.ptr -> C.TensorG.t
val index : unit Ctypes.ptr -> indices:unit Ctypes.ptr option list -> C.TensorG.t
val index_add : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val index_add_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val index_add_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val index_copy : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val index_copy_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val index_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val index_fill : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val index_fill_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val index_fill_int_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val index_fill_int_tensor : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val index_fill_int_tensor_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val index_fill_int_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val index_put : unit Ctypes.ptr -> indices:unit Ctypes.ptr option list -> values:unit Ctypes.ptr -> accumulate:bool -> C.TensorG.t
val index_put_ : unit Ctypes.ptr -> indices:unit Ctypes.ptr option list -> values:unit Ctypes.ptr -> accumulate:bool -> C.TensorG.t
val index_put_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr option list -> values:unit Ctypes.ptr -> accumulate:bool -> C.TensorG.t
val index_reduce : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> reduce:string -> include_self:bool -> C.TensorG.t
val index_reduce_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> reduce:string -> include_self:bool -> C.TensorG.t
val index_reduce_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> reduce:string -> include_self:bool -> C.TensorG.t
val index_select : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> C.TensorG.t
val index_select_backward : grad:unit Ctypes.ptr -> self_sizes:int list -> dim:int -> index:unit Ctypes.ptr -> C.TensorG.t
val index_select_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> C.TensorG.t
val indices : unit Ctypes.ptr -> C.TensorG.t
val indices_copy : unit Ctypes.ptr -> C.TensorG.t
val indices_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val infinitely_differentiable_gelu_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val inner : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val inner_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val instance_norm : unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> use_input_stats:bool -> momentum:float -> eps:float -> cudnn_enabled:bool -> C.TensorG.t
val int_repr : unit Ctypes.ptr -> C.TensorG.t
val inverse : unit Ctypes.ptr -> C.TensorG.t
val inverse_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val isclose : unit Ctypes.ptr -> unit Ctypes.ptr -> rtol:float -> atol:float -> equal_nan:bool -> C.TensorG.t
val isfinite : unit Ctypes.ptr -> C.TensorG.t
val isin : elements:unit Ctypes.ptr -> test_elements:unit Ctypes.ptr -> assume_unique:bool -> invert:bool -> C.TensorG.t
val isin_scalar_tensor : element:unit Ctypes.ptr -> test_elements:unit Ctypes.ptr -> assume_unique:bool -> invert:bool -> C.TensorG.t
val isin_scalar_tensor_out : out:unit Ctypes.ptr -> element:unit Ctypes.ptr -> test_elements:unit Ctypes.ptr -> assume_unique:bool -> invert:bool -> C.TensorG.t
val isin_tensor_scalar : elements:unit Ctypes.ptr -> test_element:unit Ctypes.ptr -> assume_unique:bool -> invert:bool -> C.TensorG.t
val isin_tensor_scalar_out : out:unit Ctypes.ptr -> elements:unit Ctypes.ptr -> test_element:unit Ctypes.ptr -> assume_unique:bool -> invert:bool -> C.TensorG.t
val isin_tensor_tensor_out : out:unit Ctypes.ptr -> elements:unit Ctypes.ptr -> test_elements:unit Ctypes.ptr -> assume_unique:bool -> invert:bool -> C.TensorG.t
val isinf : unit Ctypes.ptr -> C.TensorG.t
val isnan : unit Ctypes.ptr -> C.TensorG.t
val isneginf : unit Ctypes.ptr -> C.TensorG.t
val isneginf_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val isposinf : unit Ctypes.ptr -> C.TensorG.t
val isposinf_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val isreal : unit Ctypes.ptr -> C.TensorG.t
val istft : unit Ctypes.ptr -> n_fft:int -> hop_length:int option -> win_length:int option -> window:unit Ctypes.ptr option -> center:bool -> normalized:bool -> onesided:bool -> length:int option -> return_complex:bool -> C.TensorG.t
val kaiser_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val kaiser_window_beta : window_length:int -> periodic:bool -> beta:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val kaiser_window_periodic : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val kl_div : unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> log_target:bool -> C.TensorG.t
val kl_div_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> log_target:bool -> C.TensorG.t
val kron : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val kron_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val kthvalue : unit Ctypes.ptr -> k:int -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val kthvalue_values : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> k:int -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val l1_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val l1_loss_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val l1_loss_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val l1_loss_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val layer_norm : unit Ctypes.ptr -> normalized_shape:int list -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> eps:float -> cudnn_enable:bool -> C.TensorG.t
val lcm : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lcm_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lcm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ldexp : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ldexp_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ldexp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val leaky_relu : unit Ctypes.ptr -> C.TensorG.t
val leaky_relu_ : unit Ctypes.ptr -> C.TensorG.t
val leaky_relu_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> negative_slope:unit Ctypes.ptr -> self_is_result:bool -> C.TensorG.t
val leaky_relu_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> negative_slope:unit Ctypes.ptr -> self_is_result:bool -> C.TensorG.t
val leaky_relu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lerp : unit Ctypes.ptr -> end_:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val lerp_ : unit Ctypes.ptr -> end_:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val lerp_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> end_:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val lerp_tensor : unit Ctypes.ptr -> end_:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val lerp_tensor_ : unit Ctypes.ptr -> end_:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val lerp_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> end_:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val less : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lgamma : unit Ctypes.ptr -> C.TensorG.t
val lgamma_ : unit Ctypes.ptr -> C.TensorG.t
val lgamma_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lift : unit Ctypes.ptr -> C.TensorG.t
val linalg_cholesky : unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val linalg_cholesky_ex : unit Ctypes.ptr -> upper:bool -> check_errors:bool -> C.TensorG.t * C.TensorG.t
val linalg_cholesky_ex_l : l:unit Ctypes.ptr -> info:unit Ctypes.ptr -> unit Ctypes.ptr -> upper:bool -> check_errors:bool -> C.TensorG.t * C.TensorG.t
val linalg_cholesky_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val linalg_cond : unit Ctypes.ptr -> p:unit Ctypes.ptr -> C.TensorG.t
val linalg_cond_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:unit Ctypes.ptr -> C.TensorG.t
val linalg_cond_p_str : unit Ctypes.ptr -> p:string -> C.TensorG.t
val linalg_cond_p_str_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:string -> C.TensorG.t
val linalg_cross : unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val linalg_cross_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val linalg_det : unit Ctypes.ptr -> C.TensorG.t
val linalg_det_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_diagonal : a:unit Ctypes.ptr -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val linalg_eig : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val linalg_eig_out : eigenvalues:unit Ctypes.ptr -> eigenvectors:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val linalg_eigh : unit Ctypes.ptr -> uplo:string -> C.TensorG.t * C.TensorG.t
val linalg_eigh_eigvals : eigvals:unit Ctypes.ptr -> eigvecs:unit Ctypes.ptr -> unit Ctypes.ptr -> uplo:string -> C.TensorG.t * C.TensorG.t
val linalg_eigvals : unit Ctypes.ptr -> C.TensorG.t
val linalg_eigvals_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_eigvalsh : unit Ctypes.ptr -> uplo:string -> C.TensorG.t
val linalg_eigvalsh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> uplo:string -> C.TensorG.t
val linalg_householder_product : unit Ctypes.ptr -> tau:unit Ctypes.ptr -> C.TensorG.t
val linalg_householder_product_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> tau:unit Ctypes.ptr -> C.TensorG.t
val linalg_inv : unit Ctypes.ptr -> C.TensorG.t
val linalg_inv_ex : unit Ctypes.ptr -> check_errors:bool -> C.TensorG.t * C.TensorG.t
val linalg_inv_ex_inverse : inverse:unit Ctypes.ptr -> info:unit Ctypes.ptr -> unit Ctypes.ptr -> check_errors:bool -> C.TensorG.t * C.TensorG.t
val linalg_inv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_ldl_factor : unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t * C.TensorG.t
val linalg_ldl_factor_ex : unit Ctypes.ptr -> hermitian:bool -> check_errors:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_ldl_factor_ex_out : ld:unit Ctypes.ptr -> pivots:unit Ctypes.ptr -> info:unit Ctypes.ptr -> unit Ctypes.ptr -> hermitian:bool -> check_errors:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_ldl_factor_out : ld:unit Ctypes.ptr -> pivots:unit Ctypes.ptr -> unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t * C.TensorG.t
val linalg_ldl_solve : ld:unit Ctypes.ptr -> pivots:unit Ctypes.ptr -> b:unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t
val linalg_ldl_solve_out : out:unit Ctypes.ptr -> ld:unit Ctypes.ptr -> pivots:unit Ctypes.ptr -> b:unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t
val linalg_lstsq : unit Ctypes.ptr -> b:unit Ctypes.ptr -> rcond:float option -> driver:string -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_lstsq_out : solution:unit Ctypes.ptr -> residuals:unit Ctypes.ptr -> rank:unit Ctypes.ptr -> singular_values:unit Ctypes.ptr -> unit Ctypes.ptr -> b:unit Ctypes.ptr -> rcond:float option -> driver:string -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_lu : a:unit Ctypes.ptr -> pivot:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_lu_factor : a:unit Ctypes.ptr -> pivot:bool -> C.TensorG.t * C.TensorG.t
val linalg_lu_factor_ex : a:unit Ctypes.ptr -> pivot:bool -> check_errors:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_lu_factor_ex_out : lu:unit Ctypes.ptr -> pivots:unit Ctypes.ptr -> info:unit Ctypes.ptr -> a:unit Ctypes.ptr -> pivot:bool -> check_errors:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_lu_factor_out : lu:unit Ctypes.ptr -> pivots:unit Ctypes.ptr -> a:unit Ctypes.ptr -> pivot:bool -> C.TensorG.t * C.TensorG.t
val linalg_lu_out : p:unit Ctypes.ptr -> l:unit Ctypes.ptr -> u:unit Ctypes.ptr -> a:unit Ctypes.ptr -> pivot:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_matmul : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_matmul_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_matrix_exp : unit Ctypes.ptr -> C.TensorG.t
val linalg_matrix_power : unit Ctypes.ptr -> n:int -> C.TensorG.t
val linalg_matrix_power_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> C.TensorG.t
val linalg_matrix_rank : unit Ctypes.ptr -> tol:float -> hermitian:bool -> C.TensorG.t
val linalg_matrix_rank_atol_rtol_float : unit Ctypes.ptr -> atol:float option -> rtol:float option -> hermitian:bool -> C.TensorG.t
val linalg_matrix_rank_atol_rtol_float_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> atol:float option -> rtol:float option -> hermitian:bool -> C.TensorG.t
val linalg_matrix_rank_atol_rtol_tensor : unit Ctypes.ptr -> atol:unit Ctypes.ptr option -> rtol:unit Ctypes.ptr option -> hermitian:bool -> C.TensorG.t
val linalg_matrix_rank_atol_rtol_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> atol:unit Ctypes.ptr option -> rtol:unit Ctypes.ptr option -> hermitian:bool -> C.TensorG.t
val linalg_matrix_rank_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> tol:float -> hermitian:bool -> C.TensorG.t
val linalg_matrix_rank_out_tol_tensor : out:unit Ctypes.ptr -> unit Ctypes.ptr -> tol:unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t
val linalg_matrix_rank_tol_tensor : unit Ctypes.ptr -> tol:unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t
val linalg_multi_dot : C.TensorG.t list -> C.TensorG.t
val linalg_multi_dot_out : out:unit Ctypes.ptr -> C.TensorG.t list -> C.TensorG.t
val linalg_pinv : unit Ctypes.ptr -> rcond:float -> hermitian:bool -> C.TensorG.t
val linalg_pinv_atol_rtol_float : unit Ctypes.ptr -> atol:float option -> rtol:float option -> hermitian:bool -> C.TensorG.t
val linalg_pinv_atol_rtol_float_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> atol:float option -> rtol:float option -> hermitian:bool -> C.TensorG.t
val linalg_pinv_atol_rtol_tensor : unit Ctypes.ptr -> atol:unit Ctypes.ptr option -> rtol:unit Ctypes.ptr option -> hermitian:bool -> C.TensorG.t
val linalg_pinv_atol_rtol_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> atol:unit Ctypes.ptr option -> rtol:unit Ctypes.ptr option -> hermitian:bool -> C.TensorG.t
val linalg_pinv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> rcond:float -> hermitian:bool -> C.TensorG.t
val linalg_pinv_out_rcond_tensor : out:unit Ctypes.ptr -> unit Ctypes.ptr -> rcond:unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t
val linalg_pinv_rcond_tensor : unit Ctypes.ptr -> rcond:unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t
val linalg_qr : a:unit Ctypes.ptr -> mode:string -> C.TensorG.t * C.TensorG.t
val linalg_qr_out : q:unit Ctypes.ptr -> r:unit Ctypes.ptr -> a:unit Ctypes.ptr -> mode:string -> C.TensorG.t * C.TensorG.t
val linalg_slogdet : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val linalg_slogdet_out : sign:unit Ctypes.ptr -> logabsdet:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val linalg_solve : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_solve_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_solve_triangular : unit Ctypes.ptr -> b:unit Ctypes.ptr -> upper:bool -> left:bool -> unitriangular:bool -> C.TensorG.t
val linalg_solve_triangular_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> b:unit Ctypes.ptr -> upper:bool -> left:bool -> unitriangular:bool -> C.TensorG.t
val linalg_svd : a:unit Ctypes.ptr -> full_matrices:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_svd_u : u:unit Ctypes.ptr -> s:unit Ctypes.ptr -> vh:unit Ctypes.ptr -> a:unit Ctypes.ptr -> full_matrices:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_svdvals : a:unit Ctypes.ptr -> C.TensorG.t
val linalg_svdvals_out : out:unit Ctypes.ptr -> a:unit Ctypes.ptr -> C.TensorG.t
val linalg_tensorinv : unit Ctypes.ptr -> ind:int -> C.TensorG.t
val linalg_tensorinv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> ind:int -> C.TensorG.t
val linalg_tensorsolve : unit Ctypes.ptr -> unit Ctypes.ptr -> dims:int list option -> C.TensorG.t
val linalg_tensorsolve_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> dims:int list option -> C.TensorG.t
val linalg_vander : x:unit Ctypes.ptr -> n:int option -> C.TensorG.t
val linear : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> C.TensorG.t
val linear_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> C.TensorG.t
val linspace : start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> steps:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val linspace_out : out:unit Ctypes.ptr -> start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> steps:int -> C.TensorG.t
val log : unit Ctypes.ptr -> C.TensorG.t
val log10 : unit Ctypes.ptr -> C.TensorG.t
val log10_ : unit Ctypes.ptr -> C.TensorG.t
val log10_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val log1p : unit Ctypes.ptr -> C.TensorG.t
val log1p_ : unit Ctypes.ptr -> C.TensorG.t
val log1p_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val log2 : unit Ctypes.ptr -> C.TensorG.t
val log2_ : unit Ctypes.ptr -> C.TensorG.t
val log2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val log_ : unit Ctypes.ptr -> C.TensorG.t
val log_normal : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mean:float -> std:float -> C.TensorG.t
val log_normal_ : unit Ctypes.ptr -> mean:float -> std:float -> C.TensorG.t
val log_normal_functional : unit Ctypes.ptr -> mean:float -> std:float -> C.TensorG.t
val log_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val log_sigmoid : unit Ctypes.ptr -> C.TensorG.t
val log_sigmoid_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> buffer:unit Ctypes.ptr -> C.TensorG.t
val log_sigmoid_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> buffer:unit Ctypes.ptr -> C.TensorG.t
val log_sigmoid_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val log_softmax : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val log_softmax_int_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val logaddexp : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logaddexp2 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logaddexp2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logaddexp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logcumsumexp : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val logcumsumexp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val logdet : unit Ctypes.ptr -> C.TensorG.t
val logical_and : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_and_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_and_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_not : unit Ctypes.ptr -> C.TensorG.t
val logical_not_ : unit Ctypes.ptr -> C.TensorG.t
val logical_not_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_or : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_or_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_or_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_xor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_xor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logical_xor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val logit : unit Ctypes.ptr -> eps:float option -> C.TensorG.t
val logit_ : unit Ctypes.ptr -> eps:float option -> C.TensorG.t
val logit_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> eps:float option -> C.TensorG.t
val logit_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> eps:float option -> C.TensorG.t
val logit_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> eps:float option -> C.TensorG.t
val logspace : start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> steps:int -> base:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val logspace_out : out:unit Ctypes.ptr -> start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> steps:int -> base:float -> C.TensorG.t
val logsumexp : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val logsumexp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val lstm : unit Ctypes.ptr -> hx:C.TensorG.t list -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val lstm_cell : unit Ctypes.ptr -> hx:C.TensorG.t list -> w_ih:unit Ctypes.ptr -> w_hh:unit Ctypes.ptr -> b_ih:unit Ctypes.ptr option -> b_hh:unit Ctypes.ptr option -> C.TensorG.t * C.TensorG.t
val lstm_data : data:unit Ctypes.ptr -> batch_sizes:unit Ctypes.ptr -> hx:C.TensorG.t list -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val lstsq : unit Ctypes.ptr -> a:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val lstsq_x : x:unit Ctypes.ptr -> qr:unit Ctypes.ptr -> unit Ctypes.ptr -> a:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val lt : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lu_solve : unit Ctypes.ptr -> lu_data:unit Ctypes.ptr -> lu_pivots:unit Ctypes.ptr -> C.TensorG.t
val lu_solve_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> lu_data:unit Ctypes.ptr -> lu_pivots:unit Ctypes.ptr -> C.TensorG.t
val lu_unpack : lu_data:unit Ctypes.ptr -> lu_pivots:unit Ctypes.ptr -> unpack_data:bool -> unpack_pivots:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val lu_unpack_out : p:unit Ctypes.ptr -> l:unit Ctypes.ptr -> u:unit Ctypes.ptr -> lu_data:unit Ctypes.ptr -> lu_pivots:unit Ctypes.ptr -> unpack_data:bool -> unpack_pivots:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val margin_ranking_loss : input1:unit Ctypes.ptr -> input2:unit Ctypes.ptr -> target:unit Ctypes.ptr -> margin:float -> reduction:Reduction.t -> C.TensorG.t
val masked_fill : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val masked_fill_ : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val masked_fill_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mask:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val masked_fill_tensor : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val masked_fill_tensor_ : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val masked_fill_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mask:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val masked_scatter : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val masked_scatter_ : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val masked_scatter_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mask:unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val masked_select : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> C.TensorG.t
val masked_select_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> mask:unit Ctypes.ptr -> C.TensorG.t
val masked_select_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mask:unit Ctypes.ptr -> C.TensorG.t
val matmul : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val matmul_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val matrix_exp : unit Ctypes.ptr -> C.TensorG.t
val matrix_exp_backward : unit Ctypes.ptr -> grad:unit Ctypes.ptr -> C.TensorG.t
val matrix_h : unit Ctypes.ptr -> C.TensorG.t
val matrix_power : unit Ctypes.ptr -> n:int -> C.TensorG.t
val matrix_power_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> C.TensorG.t
val matrix_rank : unit Ctypes.ptr -> symmetric:bool -> C.TensorG.t
val matrix_rank_tol : unit Ctypes.ptr -> tol:float -> symmetric:bool -> C.TensorG.t
val max : unit Ctypes.ptr -> C.TensorG.t
val max_dim : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val max_dim_max : max:unit Ctypes.ptr -> max_values:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val max_other : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val max_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val max_pool1d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val max_pool1d_with_indices : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_pool2d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val max_pool2d_with_indices : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_pool2d_with_indices_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:unit Ctypes.ptr -> C.TensorG.t
val max_pool2d_with_indices_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:unit Ctypes.ptr -> C.TensorG.t
val max_pool2d_with_indices_out : out:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_pool3d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val max_pool3d_with_indices : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_pool3d_with_indices_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:unit Ctypes.ptr -> C.TensorG.t
val max_pool3d_with_indices_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:unit Ctypes.ptr -> C.TensorG.t
val max_pool3d_with_indices_out : out:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_unpool2d : unit Ctypes.ptr -> indices:unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val max_unpool2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val max_unpool3d : unit Ctypes.ptr -> indices:unit Ctypes.ptr -> output_size:int list -> stride:int list -> padding:int list -> C.TensorG.t
val max_unpool3d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> output_size:int list -> stride:int list -> padding:int list -> C.TensorG.t
val maximum : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val maximum_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mean : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val mean_dim : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val mean_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val median : unit Ctypes.ptr -> C.TensorG.t
val median_dim : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val median_dim_values : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val meshgrid : C.TensorG.t list -> unit Ctypes.ptr list
val meshgrid_indexing : C.TensorG.t list -> indexing:string -> unit Ctypes.ptr list
val mh : unit Ctypes.ptr -> C.TensorG.t
val min : unit Ctypes.ptr -> C.TensorG.t
val min_dim : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val min_dim_min : min:unit Ctypes.ptr -> min_indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val min_other : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val min_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val minimum : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val minimum_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val miopen_batch_norm : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> training:bool -> exponential_average_factor:float -> epsilon:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val miopen_batch_norm_backward : unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> save_mean:unit Ctypes.ptr option -> save_var:unit Ctypes.ptr option -> epsilon:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val miopen_convolution : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_convolution_transpose : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_depthwise_convolution : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_rnn : unit Ctypes.ptr -> weight:C.TensorG.t list -> weight_stride0:int -> hx:unit Ctypes.ptr -> cx:unit Ctypes.ptr option -> mode:int -> hidden_size:int -> num_layers:int -> batch_first:bool -> dropout:float -> train:bool -> bidirectional:bool -> batch_sizes:int list -> dropout_state:unit Ctypes.ptr option -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val mish : unit Ctypes.ptr -> C.TensorG.t
val mish_ : unit Ctypes.ptr -> C.TensorG.t
val mish_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mish_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mkldnn_adaptive_avg_pool2d : unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val mkldnn_adaptive_avg_pool2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mkldnn_convolution : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> C.TensorG.t
val mkldnn_linear : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr option -> C.TensorG.t
val mkldnn_linear_backward_input : input_size:int list -> grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val mkldnn_linear_backward_weights : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> bias_defined:bool -> C.TensorG.t * C.TensorG.t
val mkldnn_max_pool2d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val mkldnn_max_pool2d_backward : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val mkldnn_max_pool3d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val mkldnn_max_pool3d_backward : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val mkldnn_reorder_conv2d_weight : unit Ctypes.ptr -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> C.TensorG.t
val mkldnn_reorder_conv3d_weight : unit Ctypes.ptr -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> C.TensorG.t
val mm : unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val mm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val mode : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val mode_values : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val moveaxis : unit Ctypes.ptr -> source:int list -> destination:int list -> C.TensorG.t
val moveaxis_int : unit Ctypes.ptr -> source:int -> destination:int -> C.TensorG.t
val movedim : unit Ctypes.ptr -> source:int list -> destination:int list -> C.TensorG.t
val movedim_int : unit Ctypes.ptr -> source:int -> destination:int -> C.TensorG.t
val mps_max_pool2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val mse_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val mse_loss_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val mse_loss_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val mse_loss_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val msort : unit Ctypes.ptr -> C.TensorG.t
val msort_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mt : unit Ctypes.ptr -> C.TensorG.t
val mul : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mul_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mul_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mul_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mul_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mul_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val multi_margin_loss_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> p:unit Ctypes.ptr -> margin:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> C.TensorG.t
val multi_margin_loss_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> p:unit Ctypes.ptr -> margin:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> C.TensorG.t
val multilabel_margin_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val multilabel_margin_loss_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> is_target:unit Ctypes.ptr -> C.TensorG.t
val multilabel_margin_loss_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> is_target:unit Ctypes.ptr -> C.TensorG.t
val multilabel_margin_loss_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val multinomial : unit Ctypes.ptr -> num_samples:int -> replacement:bool -> C.TensorG.t
val multinomial_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> num_samples:int -> replacement:bool -> C.TensorG.t
val multiply : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val multiply_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val multiply_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val multiply_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val multiply_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mv : unit Ctypes.ptr -> vec:unit Ctypes.ptr -> C.TensorG.t
val mv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> vec:unit Ctypes.ptr -> C.TensorG.t
val mvlgamma : unit Ctypes.ptr -> p:int -> C.TensorG.t
val mvlgamma_ : unit Ctypes.ptr -> p:int -> C.TensorG.t
val mvlgamma_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:int -> C.TensorG.t
val nan_to_num : unit Ctypes.ptr -> nan:float option -> posinf:float option -> neginf:float option -> C.TensorG.t
val nan_to_num_ : unit Ctypes.ptr -> nan:float option -> posinf:float option -> neginf:float option -> C.TensorG.t
val nan_to_num_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> nan:float option -> posinf:float option -> neginf:float option -> C.TensorG.t
val nanmean : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val nanmean_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val nanmedian : unit Ctypes.ptr -> C.TensorG.t
val nanmedian_dim : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val nanmedian_dim_values : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val nanquantile : unit Ctypes.ptr -> q:unit Ctypes.ptr -> dim:int option -> keepdim:bool -> interpolation:string -> C.TensorG.t
val nanquantile_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> q:unit Ctypes.ptr -> dim:int option -> keepdim:bool -> interpolation:string -> C.TensorG.t
val nanquantile_scalar : unit Ctypes.ptr -> q:float -> dim:int option -> keepdim:bool -> interpolation:string -> C.TensorG.t
val nanquantile_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> q:float -> dim:int option -> keepdim:bool -> interpolation:string -> C.TensorG.t
val nansum : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val nansum_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val narrow : unit Ctypes.ptr -> dim:int -> start:int -> length:int -> C.TensorG.t
val narrow_copy : unit Ctypes.ptr -> dim:int -> start:int -> length:int -> C.TensorG.t
val narrow_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> start:int -> length:int -> C.TensorG.t
val narrow_tensor : unit Ctypes.ptr -> dim:int -> start:unit Ctypes.ptr -> length:int -> C.TensorG.t
val native_batch_norm : unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> training:bool -> momentum:float -> eps:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val native_batch_norm_out : out:unit Ctypes.ptr -> save_mean:unit Ctypes.ptr -> save_invstd:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> running_mean:unit Ctypes.ptr option -> running_var:unit Ctypes.ptr option -> training:bool -> momentum:float -> eps:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val native_channel_shuffle : unit Ctypes.ptr -> groups:int -> C.TensorG.t
val native_dropout : unit Ctypes.ptr -> p:float -> train:bool -> C.TensorG.t * C.TensorG.t
val native_dropout_backward : grad_output:unit Ctypes.ptr -> mask:unit Ctypes.ptr -> scale:float -> C.TensorG.t
val native_group_norm : unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> n:int -> c:int -> hxw:int -> group:int -> eps:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val native_layer_norm : unit Ctypes.ptr -> normalized_shape:int list -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> eps:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val native_norm : unit Ctypes.ptr -> C.TensorG.t
val native_norm_scalaropt_dim_dtype : unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val ne : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val neg : unit Ctypes.ptr -> C.TensorG.t
val neg_ : unit Ctypes.ptr -> C.TensorG.t
val neg_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val negative : unit Ctypes.ptr -> C.TensorG.t
val negative_ : unit Ctypes.ptr -> C.TensorG.t
val negative_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val new_empty : unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val new_empty_strided : unit Ctypes.ptr -> size:int list -> stride:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val new_full : unit Ctypes.ptr -> size:int list -> fill_value:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val new_ones : unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val new_zeros : unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val nextafter : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val nextafter_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val nextafter_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val nll_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nll_loss2d : unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nll_loss2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> total_weight:unit Ctypes.ptr -> C.TensorG.t
val nll_loss2d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> total_weight:unit Ctypes.ptr -> C.TensorG.t
val nll_loss2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nll_loss_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> total_weight:unit Ctypes.ptr -> C.TensorG.t
val nll_loss_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> total_weight:unit Ctypes.ptr -> C.TensorG.t
val nll_loss_nd : unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nll_loss_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nonzero : unit Ctypes.ptr -> C.TensorG.t
val nonzero_numpy : unit Ctypes.ptr -> unit Ctypes.ptr list
val nonzero_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val norm : unit Ctypes.ptr -> C.TensorG.t
val norm_dtype_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val norm_except_dim : v:unit Ctypes.ptr -> pow:int -> dim:int -> C.TensorG.t
val norm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val norm_scalaropt_dim : unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val norm_scalaropt_dim_dtype : unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val norm_scalaropt_dtype : unit Ctypes.ptr -> p:unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val normal : unit Ctypes.ptr -> mean:float -> std:float -> C.TensorG.t
val normal_ : unit Ctypes.ptr -> mean:float -> std:float -> C.TensorG.t
val not_equal : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val nuclear_norm : unit Ctypes.ptr -> keepdim:bool -> C.TensorG.t
val nuclear_norm_dim : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val nuclear_norm_dim_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val nuclear_norm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> keepdim:bool -> C.TensorG.t
val numpy_t : unit Ctypes.ptr -> C.TensorG.t
val one_hot : unit Ctypes.ptr -> num_classes:int -> C.TensorG.t
val ones : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val ones_like : unit Ctypes.ptr -> C.TensorG.t
val ones_out : out:unit Ctypes.ptr -> size:int list -> C.TensorG.t
val orgqr : unit Ctypes.ptr -> input2:unit Ctypes.ptr -> C.TensorG.t
val orgqr_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> input2:unit Ctypes.ptr -> C.TensorG.t
val ormqr : unit Ctypes.ptr -> input2:unit Ctypes.ptr -> input3:unit Ctypes.ptr -> left:bool -> transpose:bool -> C.TensorG.t
val ormqr_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> input2:unit Ctypes.ptr -> input3:unit Ctypes.ptr -> left:bool -> transpose:bool -> C.TensorG.t
val outer : unit Ctypes.ptr -> vec2:unit Ctypes.ptr -> C.TensorG.t
val outer_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> vec2:unit Ctypes.ptr -> C.TensorG.t
val pad : unit Ctypes.ptr -> pad:int list -> mode:string -> value:float option -> C.TensorG.t
val pad_sequence : sequences:C.TensorG.t list -> batch_first:bool -> padding_value:float -> C.TensorG.t
val pairwise_distance : x1:unit Ctypes.ptr -> x2:unit Ctypes.ptr -> p:float -> eps:float -> keepdim:bool -> C.TensorG.t
val pdist : unit Ctypes.ptr -> p:float -> C.TensorG.t
val permute : unit Ctypes.ptr -> dims:int list -> C.TensorG.t
val permute_copy : unit Ctypes.ptr -> dims:int list -> C.TensorG.t
val permute_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dims:int list -> C.TensorG.t
val pin_memory : unit Ctypes.ptr -> device:Device.t -> C.TensorG.t
val pinverse : unit Ctypes.ptr -> rcond:float -> C.TensorG.t
val pixel_shuffle : unit Ctypes.ptr -> upscale_factor:int -> C.TensorG.t
val pixel_unshuffle : unit Ctypes.ptr -> downscale_factor:int -> C.TensorG.t
val poisson : unit Ctypes.ptr -> C.TensorG.t
val poisson_nll_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> log_input:bool -> full:bool -> eps:float -> reduction:Reduction.t -> C.TensorG.t
val polar : abs:unit Ctypes.ptr -> angle:unit Ctypes.ptr -> C.TensorG.t
val polar_out : out:unit Ctypes.ptr -> abs:unit Ctypes.ptr -> angle:unit Ctypes.ptr -> C.TensorG.t
val polygamma : n:int -> unit Ctypes.ptr -> C.TensorG.t
val polygamma_ : unit Ctypes.ptr -> n:int -> C.TensorG.t
val polygamma_out : out:unit Ctypes.ptr -> n:int -> unit Ctypes.ptr -> C.TensorG.t
val positive : unit Ctypes.ptr -> C.TensorG.t
val pow : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_ : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_scalar : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_tensor_ : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_tensor_scalar : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_tensor_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_tensor_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val prelu : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val prelu_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val prod : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val prod_dim_int : unit Ctypes.ptr -> dim:int -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val prod_int_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val put : unit Ctypes.ptr -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> accumulate:bool -> C.TensorG.t
val put_ : unit Ctypes.ptr -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> accumulate:bool -> C.TensorG.t
val put_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> accumulate:bool -> C.TensorG.t
val q_per_channel_scales : unit Ctypes.ptr -> C.TensorG.t
val q_per_channel_zero_points : unit Ctypes.ptr -> C.TensorG.t
val qr : unit Ctypes.ptr -> some:bool -> C.TensorG.t * C.TensorG.t
val qr_q : q:unit Ctypes.ptr -> r:unit Ctypes.ptr -> unit Ctypes.ptr -> some:bool -> C.TensorG.t * C.TensorG.t
val quantile : unit Ctypes.ptr -> q:unit Ctypes.ptr -> dim:int option -> keepdim:bool -> interpolation:string -> C.TensorG.t
val quantile_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> q:unit Ctypes.ptr -> dim:int option -> keepdim:bool -> interpolation:string -> C.TensorG.t
val quantile_scalar : unit Ctypes.ptr -> q:float -> dim:int option -> keepdim:bool -> interpolation:string -> C.TensorG.t
val quantile_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> q:float -> dim:int option -> keepdim:bool -> interpolation:string -> C.TensorG.t
val quantize_per_channel : unit Ctypes.ptr -> scales:unit Ctypes.ptr -> zero_points:unit Ctypes.ptr -> axis:int -> dtype:Kind.packed -> C.TensorG.t
val quantize_per_tensor : unit Ctypes.ptr -> scale:float -> zero_point:int -> dtype:Kind.packed -> C.TensorG.t
val quantize_per_tensor_dynamic : unit Ctypes.ptr -> dtype:Kind.packed -> reduce_range:bool -> C.TensorG.t
val quantize_per_tensor_tensor_qparams : unit Ctypes.ptr -> scale:unit Ctypes.ptr -> zero_point:unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val quantize_per_tensor_tensors : C.TensorG.t list -> scales:unit Ctypes.ptr -> zero_points:unit Ctypes.ptr -> dtype:Kind.packed -> unit Ctypes.ptr list
val quantized_batch_norm : unit Ctypes.ptr -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> mean:unit Ctypes.ptr -> var:unit Ctypes.ptr -> eps:float -> output_scale:float -> output_zero_point:int -> C.TensorG.t
val quantized_gru_cell : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> w_ih:unit Ctypes.ptr -> w_hh:unit Ctypes.ptr -> b_ih:unit Ctypes.ptr -> b_hh:unit Ctypes.ptr -> packed_ih:unit Ctypes.ptr -> packed_hh:unit Ctypes.ptr -> col_offsets_ih:unit Ctypes.ptr -> col_offsets_hh:unit Ctypes.ptr -> scale_ih:unit Ctypes.ptr -> scale_hh:unit Ctypes.ptr -> zero_point_ih:unit Ctypes.ptr -> zero_point_hh:unit Ctypes.ptr -> C.TensorG.t
val quantized_lstm_cell : unit Ctypes.ptr -> hx:C.TensorG.t list -> w_ih:unit Ctypes.ptr -> w_hh:unit Ctypes.ptr -> b_ih:unit Ctypes.ptr -> b_hh:unit Ctypes.ptr -> packed_ih:unit Ctypes.ptr -> packed_hh:unit Ctypes.ptr -> col_offsets_ih:unit Ctypes.ptr -> col_offsets_hh:unit Ctypes.ptr -> scale_ih:unit Ctypes.ptr -> scale_hh:unit Ctypes.ptr -> zero_point_ih:unit Ctypes.ptr -> zero_point_hh:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val quantized_max_pool1d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val quantized_max_pool2d : unit Ctypes.ptr -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val quantized_rnn_relu_cell : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> w_ih:unit Ctypes.ptr -> w_hh:unit Ctypes.ptr -> b_ih:unit Ctypes.ptr -> b_hh:unit Ctypes.ptr -> packed_ih:unit Ctypes.ptr -> packed_hh:unit Ctypes.ptr -> col_offsets_ih:unit Ctypes.ptr -> col_offsets_hh:unit Ctypes.ptr -> scale_ih:unit Ctypes.ptr -> scale_hh:unit Ctypes.ptr -> zero_point_ih:unit Ctypes.ptr -> zero_point_hh:unit Ctypes.ptr -> C.TensorG.t
val quantized_rnn_tanh_cell : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> w_ih:unit Ctypes.ptr -> w_hh:unit Ctypes.ptr -> b_ih:unit Ctypes.ptr -> b_hh:unit Ctypes.ptr -> packed_ih:unit Ctypes.ptr -> packed_hh:unit Ctypes.ptr -> col_offsets_ih:unit Ctypes.ptr -> col_offsets_hh:unit Ctypes.ptr -> scale_ih:unit Ctypes.ptr -> scale_hh:unit Ctypes.ptr -> zero_point_ih:unit Ctypes.ptr -> zero_point_hh:unit Ctypes.ptr -> C.TensorG.t
val rad2deg : unit Ctypes.ptr -> C.TensorG.t
val rad2deg_ : unit Ctypes.ptr -> C.TensorG.t
val rad2deg_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val rand : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val rand_like : unit Ctypes.ptr -> C.TensorG.t
val rand_out : out:unit Ctypes.ptr -> size:int list -> C.TensorG.t
val randint : high:int -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val randint_like : unit Ctypes.ptr -> high:int -> C.TensorG.t
val randint_like_low_dtype : unit Ctypes.ptr -> low:int -> high:int -> C.TensorG.t
val randint_low : low:int -> high:int -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val randint_low_out : out:unit Ctypes.ptr -> low:int -> high:int -> size:int list -> C.TensorG.t
val randint_out : out:unit Ctypes.ptr -> high:int -> size:int list -> C.TensorG.t
val randn : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val randn_like : unit Ctypes.ptr -> C.TensorG.t
val randn_out : out:unit Ctypes.ptr -> size:int list -> C.TensorG.t
val random : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val random_ : unit Ctypes.ptr -> C.TensorG.t
val random_from_ : unit Ctypes.ptr -> from:int -> to_:int option -> C.TensorG.t
val random_from_functional : unit Ctypes.ptr -> from:int -> to_:int option -> C.TensorG.t
val random_from_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> from:int -> to_:int option -> C.TensorG.t
val random_functional : unit Ctypes.ptr -> C.TensorG.t
val random_to_ : unit Ctypes.ptr -> to_:int -> C.TensorG.t
val random_to_functional : unit Ctypes.ptr -> to_:int -> C.TensorG.t
val random_to_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> to_:int -> C.TensorG.t
val randperm : n:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val randperm_out : out:unit Ctypes.ptr -> n:int -> C.TensorG.t
val range : start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val range_out : out:unit Ctypes.ptr -> start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> C.TensorG.t
val range_step : start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val ravel : unit Ctypes.ptr -> C.TensorG.t
val real : unit Ctypes.ptr -> C.TensorG.t
val reciprocal : unit Ctypes.ptr -> C.TensorG.t
val reciprocal_ : unit Ctypes.ptr -> C.TensorG.t
val reciprocal_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val reflection_pad1d : unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad1d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad1d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad1d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad2d : unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad2d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad3d : unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad3d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad3d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val reflection_pad3d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val relu : unit Ctypes.ptr -> C.TensorG.t
val relu6 : unit Ctypes.ptr -> C.TensorG.t
val relu6_ : unit Ctypes.ptr -> C.TensorG.t
val relu_ : unit Ctypes.ptr -> C.TensorG.t
val relu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_scalar_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_tensor : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_tensor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val renorm : unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int -> maxnorm:unit Ctypes.ptr -> C.TensorG.t
val renorm_ : unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int -> maxnorm:unit Ctypes.ptr -> C.TensorG.t
val renorm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int -> maxnorm:unit Ctypes.ptr -> C.TensorG.t
val repeat : unit Ctypes.ptr -> repeats:int list -> C.TensorG.t
val repeat_interleave : repeats:unit Ctypes.ptr -> output_size:int option -> C.TensorG.t
val repeat_interleave_self_int : unit Ctypes.ptr -> repeats:int -> dim:int option -> output_size:int option -> C.TensorG.t
val repeat_interleave_self_tensor : unit Ctypes.ptr -> repeats:unit Ctypes.ptr -> dim:int option -> output_size:int option -> C.TensorG.t
val replication_pad1d : unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad1d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad1d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad1d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad2d : unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad2d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad2d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad3d : unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad3d_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad3d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val replication_pad3d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val requires_grad_ : unit Ctypes.ptr -> requires_grad:bool -> C.TensorG.t
val reshape : unit Ctypes.ptr -> shape:int list -> C.TensorG.t
val reshape_as : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val resize : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int list -> C.TensorG.t
val resize_ : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val resize_as : out:unit Ctypes.ptr -> unit Ctypes.ptr -> the_template:unit Ctypes.ptr -> C.TensorG.t
val resize_as_ : unit Ctypes.ptr -> the_template:unit Ctypes.ptr -> C.TensorG.t
val resize_as_functional : unit Ctypes.ptr -> the_template:unit Ctypes.ptr -> C.TensorG.t
val resize_as_sparse : out:unit Ctypes.ptr -> unit Ctypes.ptr -> the_template:unit Ctypes.ptr -> C.TensorG.t
val resize_as_sparse_ : unit Ctypes.ptr -> the_template:unit Ctypes.ptr -> C.TensorG.t
val resize_as_sparse_functional : unit Ctypes.ptr -> the_template:unit Ctypes.ptr -> C.TensorG.t
val resize_functional : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val resolve_conj : unit Ctypes.ptr -> C.TensorG.t
val resolve_neg : unit Ctypes.ptr -> C.TensorG.t
val rnn_relu : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val rnn_relu_cell : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> w_ih:unit Ctypes.ptr -> w_hh:unit Ctypes.ptr -> b_ih:unit Ctypes.ptr option -> b_hh:unit Ctypes.ptr option -> C.TensorG.t
val rnn_relu_data : data:unit Ctypes.ptr -> batch_sizes:unit Ctypes.ptr -> hx:unit Ctypes.ptr -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t
val rnn_tanh : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val rnn_tanh_cell : unit Ctypes.ptr -> hx:unit Ctypes.ptr -> w_ih:unit Ctypes.ptr -> w_hh:unit Ctypes.ptr -> b_ih:unit Ctypes.ptr option -> b_hh:unit Ctypes.ptr option -> C.TensorG.t
val rnn_tanh_data : data:unit Ctypes.ptr -> batch_sizes:unit Ctypes.ptr -> hx:unit Ctypes.ptr -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t
val roll : unit Ctypes.ptr -> shifts:int list -> dims:int list -> C.TensorG.t
val rot90 : unit Ctypes.ptr -> k:int -> dims:int list -> C.TensorG.t
val round : unit Ctypes.ptr -> C.TensorG.t
val round_ : unit Ctypes.ptr -> C.TensorG.t
val round_decimals : unit Ctypes.ptr -> decimals:int -> C.TensorG.t
val round_decimals_ : unit Ctypes.ptr -> decimals:int -> C.TensorG.t
val round_decimals_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> decimals:int -> C.TensorG.t
val round_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val row_indices : unit Ctypes.ptr -> C.TensorG.t
val row_indices_copy : unit Ctypes.ptr -> C.TensorG.t
val row_stack : C.TensorG.t list -> C.TensorG.t
val row_stack_out : out:unit Ctypes.ptr -> C.TensorG.t list -> C.TensorG.t
val rrelu : unit Ctypes.ptr -> training:bool -> C.TensorG.t
val rrelu_ : unit Ctypes.ptr -> training:bool -> C.TensorG.t
val rrelu_with_noise : unit Ctypes.ptr -> noise:unit Ctypes.ptr -> training:bool -> C.TensorG.t
val rrelu_with_noise_ : unit Ctypes.ptr -> noise:unit Ctypes.ptr -> training:bool -> C.TensorG.t
val rrelu_with_noise_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> noise:unit Ctypes.ptr -> lower:unit Ctypes.ptr -> upper:unit Ctypes.ptr -> training:bool -> self_is_result:bool -> C.TensorG.t
val rrelu_with_noise_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> noise:unit Ctypes.ptr -> training:bool -> C.TensorG.t
val rsqrt : unit Ctypes.ptr -> C.TensorG.t
val rsqrt_ : unit Ctypes.ptr -> C.TensorG.t
val rsqrt_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val rsub : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val rsub_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val scalar_tensor : s:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val scatter : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> C.TensorG.t
val scatter_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> C.TensorG.t
val scatter_add : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> C.TensorG.t
val scatter_add_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> C.TensorG.t
val scatter_add_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> C.TensorG.t
val scatter_reduce : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> reduce:string -> C.TensorG.t
val scatter_reduce_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> reduce:string -> C.TensorG.t
val scatter_reduce_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> reduce:string -> C.TensorG.t
val scatter_src_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> C.TensorG.t
val scatter_value : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val scatter_value_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val scatter_value_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val scatter_value_reduce : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> reduce:string -> C.TensorG.t
val scatter_value_reduce_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> reduce:string -> C.TensorG.t
val scatter_value_reduce_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> reduce:string -> C.TensorG.t
val searchsorted : sorted_sequence:unit Ctypes.ptr -> unit Ctypes.ptr -> out_int32:bool -> right:bool -> side:string -> sorter:unit Ctypes.ptr option -> C.TensorG.t
val searchsorted_scalar : sorted_sequence:unit Ctypes.ptr -> unit Ctypes.ptr -> out_int32:bool -> right:bool -> side:string -> sorter:unit Ctypes.ptr option -> C.TensorG.t
val searchsorted_tensor_out : out:unit Ctypes.ptr -> sorted_sequence:unit Ctypes.ptr -> unit Ctypes.ptr -> out_int32:bool -> right:bool -> side:string -> sorter:unit Ctypes.ptr option -> C.TensorG.t
val segment_reduce : data:unit Ctypes.ptr -> reduce:string -> lengths:unit Ctypes.ptr option -> indices:unit Ctypes.ptr option -> axis:int -> unsafe:bool -> initial:unit Ctypes.ptr -> C.TensorG.t
val select : unit Ctypes.ptr -> dim:int -> index:int -> C.TensorG.t
val select_backward : grad_output:unit Ctypes.ptr -> input_sizes:int list -> dim:int -> index:int -> C.TensorG.t
val select_copy : unit Ctypes.ptr -> dim:int -> index:int -> C.TensorG.t
val select_copy_int_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> index:int -> C.TensorG.t
val select_scatter : unit Ctypes.ptr -> src:unit Ctypes.ptr -> dim:int -> index:int -> C.TensorG.t
val selu : unit Ctypes.ptr -> C.TensorG.t
val selu_ : unit Ctypes.ptr -> C.TensorG.t
val set : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val set_ : unit Ctypes.ptr -> C.TensorG.t
val set_functional : unit Ctypes.ptr -> C.TensorG.t
val set_requires_grad : unit Ctypes.ptr -> r:bool -> C.TensorG.t
val set_source_tensor_ : unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val set_source_tensor_functional : unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val set_source_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val set_source_tensor_storage_offset_ : unit Ctypes.ptr -> source:unit Ctypes.ptr -> storage_offset:int -> size:int list -> stride:int list -> C.TensorG.t
val sgn : unit Ctypes.ptr -> C.TensorG.t
val sgn_ : unit Ctypes.ptr -> C.TensorG.t
val sgn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sigmoid : unit Ctypes.ptr -> C.TensorG.t
val sigmoid_ : unit Ctypes.ptr -> C.TensorG.t
val sigmoid_backward : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> C.TensorG.t
val sigmoid_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> C.TensorG.t
val sigmoid_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sign : unit Ctypes.ptr -> C.TensorG.t
val sign_ : unit Ctypes.ptr -> C.TensorG.t
val sign_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val signbit : unit Ctypes.ptr -> C.TensorG.t
val signbit_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val silu : unit Ctypes.ptr -> C.TensorG.t
val silu_ : unit Ctypes.ptr -> C.TensorG.t
val silu_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val silu_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val silu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sin : unit Ctypes.ptr -> C.TensorG.t
val sin_ : unit Ctypes.ptr -> C.TensorG.t
val sin_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sinc : unit Ctypes.ptr -> C.TensorG.t
val sinc_ : unit Ctypes.ptr -> C.TensorG.t
val sinc_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sinh : unit Ctypes.ptr -> C.TensorG.t
val sinh_ : unit Ctypes.ptr -> C.TensorG.t
val sinh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val slice : unit Ctypes.ptr -> dim:int -> start:int option -> end_:int option -> step:int -> C.TensorG.t
val slice_backward : grad_output:unit Ctypes.ptr -> input_sizes:int list -> dim:int -> start:int -> end_:int -> step:int -> C.TensorG.t
val slice_copy : unit Ctypes.ptr -> dim:int -> start:int option -> end_:int option -> step:int -> C.TensorG.t
val slice_copy_tensor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> start:int option -> end_:int option -> step:int -> C.TensorG.t
val slice_scatter : unit Ctypes.ptr -> src:unit Ctypes.ptr -> dim:int -> start:int option -> end_:int option -> step:int -> C.TensorG.t
val slogdet : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val slow_conv3d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> C.TensorG.t
val slow_conv3d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> C.TensorG.t
val slow_conv_dilated2d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_dilated3d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_transpose2d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_transpose2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_transpose3d : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_transpose3d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> weight:unit Ctypes.ptr -> kernel_size:int list -> bias:unit Ctypes.ptr option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> C.TensorG.t
val smm : unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val smooth_l1_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> beta:float -> C.TensorG.t
val smooth_l1_loss_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> beta:float -> C.TensorG.t
val smooth_l1_loss_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> beta:float -> C.TensorG.t
val smooth_l1_loss_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> beta:float -> C.TensorG.t
val soft_margin_loss : unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val soft_margin_loss_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val soft_margin_loss_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val soft_margin_loss_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> target:unit Ctypes.ptr -> reduction:Reduction.t -> C.TensorG.t
val softmax : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val softmax_int_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val softplus : unit Ctypes.ptr -> C.TensorG.t
val softplus_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> beta:unit Ctypes.ptr -> threshold:unit Ctypes.ptr -> C.TensorG.t
val softplus_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> beta:unit Ctypes.ptr -> threshold:unit Ctypes.ptr -> C.TensorG.t
val softplus_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val softshrink : unit Ctypes.ptr -> C.TensorG.t
val softshrink_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> lambd:unit Ctypes.ptr -> C.TensorG.t
val softshrink_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> lambd:unit Ctypes.ptr -> C.TensorG.t
val softshrink_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sort : unit Ctypes.ptr -> dim:int -> descending:bool -> C.TensorG.t * C.TensorG.t
val sort_stable : unit Ctypes.ptr -> stable:bool -> dim:int -> descending:bool -> C.TensorG.t * C.TensorG.t
val sort_values : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> descending:bool -> C.TensorG.t * C.TensorG.t
val sort_values_stable : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> stable:bool -> dim:int -> descending:bool -> C.TensorG.t * C.TensorG.t
val sparse_bsc_tensor : ccol_indices:unit Ctypes.ptr -> row_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_bsc_tensor_ccol_row_value_size : ccol_indices:unit Ctypes.ptr -> row_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_bsr_tensor : crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_bsr_tensor_crow_col_value_size : crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_compressed_tensor : compressed_indices:unit Ctypes.ptr -> plain_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_compressed_tensor_comp_plain_value_size : compressed_indices:unit Ctypes.ptr -> plain_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_coo_tensor : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_coo_tensor_indices : indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_coo_tensor_indices_size : indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_csc_tensor : ccol_indices:unit Ctypes.ptr -> row_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_csc_tensor_ccol_row_value_size : ccol_indices:unit Ctypes.ptr -> row_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_csr_tensor : crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_csr_tensor_crow_col_value_size : crow_indices:unit Ctypes.ptr -> col_indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_mask : unit Ctypes.ptr -> mask:unit Ctypes.ptr -> C.TensorG.t
val sparse_resize : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int list -> sparse_dim:int -> dense_dim:int -> C.TensorG.t
val sparse_resize_ : unit Ctypes.ptr -> size:int list -> sparse_dim:int -> dense_dim:int -> C.TensorG.t
val sparse_resize_and_clear : out:unit Ctypes.ptr -> unit Ctypes.ptr -> size:int list -> sparse_dim:int -> dense_dim:int -> C.TensorG.t
val sparse_resize_and_clear_ : unit Ctypes.ptr -> size:int list -> sparse_dim:int -> dense_dim:int -> C.TensorG.t
val sparse_resize_and_clear_functional : unit Ctypes.ptr -> size:int list -> sparse_dim:int -> dense_dim:int -> C.TensorG.t
val sparse_resize_functional : unit Ctypes.ptr -> size:int list -> sparse_dim:int -> dense_dim:int -> C.TensorG.t
val sparse_sampled_addmm : unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val sparse_sampled_addmm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val special_digamma : unit Ctypes.ptr -> C.TensorG.t
val special_digamma_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_entr : unit Ctypes.ptr -> C.TensorG.t
val special_entr_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_erf : unit Ctypes.ptr -> C.TensorG.t
val special_erf_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_erfc : unit Ctypes.ptr -> C.TensorG.t
val special_erfc_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_erfcx : unit Ctypes.ptr -> C.TensorG.t
val special_erfcx_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_erfinv : unit Ctypes.ptr -> C.TensorG.t
val special_erfinv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_exp2 : unit Ctypes.ptr -> C.TensorG.t
val special_exp2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_expit : unit Ctypes.ptr -> C.TensorG.t
val special_expit_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_expm1 : unit Ctypes.ptr -> C.TensorG.t
val special_expm1_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_gammainc : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_gammainc_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_gammaincc : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_gammaincc_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_gammaln : unit Ctypes.ptr -> C.TensorG.t
val special_gammaln_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_i0 : unit Ctypes.ptr -> C.TensorG.t
val special_i0_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_i0e : unit Ctypes.ptr -> C.TensorG.t
val special_i0e_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_i1 : unit Ctypes.ptr -> C.TensorG.t
val special_i1_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_i1e : unit Ctypes.ptr -> C.TensorG.t
val special_i1e_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_log1p : unit Ctypes.ptr -> C.TensorG.t
val special_log1p_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_log_ndtr : unit Ctypes.ptr -> C.TensorG.t
val special_log_ndtr_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_log_softmax : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val special_logit : unit Ctypes.ptr -> eps:float option -> C.TensorG.t
val special_logit_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> eps:float option -> C.TensorG.t
val special_logsumexp : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val special_logsumexp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val special_multigammaln : unit Ctypes.ptr -> p:int -> C.TensorG.t
val special_multigammaln_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:int -> C.TensorG.t
val special_ndtr : unit Ctypes.ptr -> C.TensorG.t
val special_ndtr_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_ndtri : unit Ctypes.ptr -> C.TensorG.t
val special_ndtri_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_polygamma : n:int -> unit Ctypes.ptr -> C.TensorG.t
val special_polygamma_out : out:unit Ctypes.ptr -> n:int -> unit Ctypes.ptr -> C.TensorG.t
val special_psi : unit Ctypes.ptr -> C.TensorG.t
val special_psi_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_round : unit Ctypes.ptr -> decimals:int -> C.TensorG.t
val special_round_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> decimals:int -> C.TensorG.t
val special_sinc : unit Ctypes.ptr -> C.TensorG.t
val special_sinc_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_softmax : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val special_xlog1py : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlog1py_other_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlog1py_other_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlog1py_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlog1py_self_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlog1py_self_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlogy : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlogy_other_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlogy_other_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlogy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlogy_self_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_xlogy_self_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_zeta : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_zeta_other_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_zeta_other_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_zeta_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_zeta_self_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val special_zeta_self_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val split : unit Ctypes.ptr -> split_size:int -> dim:int -> unit Ctypes.ptr list
val split_copy : unit Ctypes.ptr -> split_size:int -> dim:int -> unit Ctypes.ptr list
val split_copy_tensor_out : out:C.TensorG.t list -> unit Ctypes.ptr -> split_size:int -> dim:int -> unit Torch_generated.return
val split_sizes : unit Ctypes.ptr -> split_size:int list -> dim:int -> unit Ctypes.ptr list
val split_with_sizes : unit Ctypes.ptr -> split_sizes:int list -> dim:int -> unit Ctypes.ptr list
val split_with_sizes_copy : unit Ctypes.ptr -> split_sizes:int list -> dim:int -> unit Ctypes.ptr list
val split_with_sizes_copy_out : out:C.TensorG.t list -> unit Ctypes.ptr -> split_sizes:int list -> dim:int -> unit Torch_generated.return
val sqrt : unit Ctypes.ptr -> C.TensorG.t
val sqrt_ : unit Ctypes.ptr -> C.TensorG.t
val sqrt_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val square : unit Ctypes.ptr -> C.TensorG.t
val square_ : unit Ctypes.ptr -> C.TensorG.t
val square_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val squeeze : unit Ctypes.ptr -> C.TensorG.t
val squeeze_ : unit Ctypes.ptr -> C.TensorG.t
val squeeze_copy : unit Ctypes.ptr -> C.TensorG.t
val squeeze_copy_dim : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val squeeze_copy_dim_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val squeeze_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val squeeze_dim : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val squeeze_dim_ : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val sspaddmm : unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val sspaddmm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mat1:unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> C.TensorG.t
val stack : C.TensorG.t list -> dim:int -> C.TensorG.t
val stack_out : out:unit Ctypes.ptr -> C.TensorG.t list -> dim:int -> C.TensorG.t
val std : unit Ctypes.ptr -> unbiased:bool -> C.TensorG.t
val std_correction : unit Ctypes.ptr -> dim:int list option -> correction:int option -> keepdim:bool -> C.TensorG.t
val std_correction_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list option -> correction:int option -> keepdim:bool -> C.TensorG.t
val std_dim : unit Ctypes.ptr -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val std_mean : unit Ctypes.ptr -> unbiased:bool -> C.TensorG.t * C.TensorG.t
val std_mean_correction : unit Ctypes.ptr -> dim:int list option -> correction:int option -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val std_mean_dim : unit Ctypes.ptr -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val std_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val stft : unit Ctypes.ptr -> n_fft:int -> hop_length:int option -> win_length:int option -> window:unit Ctypes.ptr option -> normalized:bool -> onesided:bool -> return_complex:bool -> C.TensorG.t
val stft_center : unit Ctypes.ptr -> n_fft:int -> hop_length:int option -> win_length:int option -> window:unit Ctypes.ptr option -> center:bool -> pad_mode:string -> normalized:bool -> onesided:bool -> return_complex:bool -> C.TensorG.t
val sub : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sub_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sub_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sub_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sub_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sub_scalar_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val subtract : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val subtract_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val subtract_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val subtract_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val subtract_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sum : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val sum_dim_intlist : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val sum_intlist_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val sum_to_size : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val svd : unit Ctypes.ptr -> some:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val svd_u : u:unit Ctypes.ptr -> s:unit Ctypes.ptr -> v:unit Ctypes.ptr -> unit Ctypes.ptr -> some:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val swapaxes : unit Ctypes.ptr -> axis0:int -> axis1:int -> C.TensorG.t
val swapaxes_ : unit Ctypes.ptr -> axis0:int -> axis1:int -> C.TensorG.t
val swapdims : unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val swapdims_ : unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val symeig : unit Ctypes.ptr -> eigenvectors:bool -> upper:bool -> C.TensorG.t * C.TensorG.t
val symeig_e : e:unit Ctypes.ptr -> v:unit Ctypes.ptr -> unit Ctypes.ptr -> eigenvectors:bool -> upper:bool -> C.TensorG.t * C.TensorG.t
val tr : unit Ctypes.ptr -> C.TensorG.t
val t_ : unit Ctypes.ptr -> C.TensorG.t
val t_copy : unit Ctypes.ptr -> C.TensorG.t
val t_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val take : unit Ctypes.ptr -> index:unit Ctypes.ptr -> C.TensorG.t
val take_along_dim : unit Ctypes.ptr -> indices:unit Ctypes.ptr -> dim:int option -> C.TensorG.t
val take_along_dim_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> dim:int option -> C.TensorG.t
val take_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> index:unit Ctypes.ptr -> C.TensorG.t
val tan : unit Ctypes.ptr -> C.TensorG.t
val tan_ : unit Ctypes.ptr -> C.TensorG.t
val tan_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val tanh : unit Ctypes.ptr -> C.TensorG.t
val tanh_ : unit Ctypes.ptr -> C.TensorG.t
val tanh_backward : grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> C.TensorG.t
val tanh_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output:unit Ctypes.ptr -> C.TensorG.t
val tanh_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val tensor_split : unit Ctypes.ptr -> sections:int -> dim:int -> unit Ctypes.ptr list
val tensor_split_indices : unit Ctypes.ptr -> indices:int list -> dim:int -> unit Ctypes.ptr list
val tensor_split_tensor_indices_or_sections : unit Ctypes.ptr -> tensor_indices_or_sections:unit Ctypes.ptr -> dim:int -> unit Ctypes.ptr list
val tensordot : unit Ctypes.ptr -> unit Ctypes.ptr -> dims_self:int list -> dims_other:int list -> C.TensorG.t
val tensordot_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> dims_self:int list -> dims_other:int list -> C.TensorG.t
val threshold : unit Ctypes.ptr -> threshold:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val threshold_ : unit Ctypes.ptr -> threshold:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val threshold_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> threshold:unit Ctypes.ptr -> C.TensorG.t
val threshold_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> threshold:unit Ctypes.ptr -> C.TensorG.t
val threshold_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> threshold:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val tile : unit Ctypes.ptr -> dims:int list -> C.TensorG.t
val to_ : unit Ctypes.ptr -> device:Device.t -> C.TensorG.t
val to_dense : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val to_dense_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val to_device : unit Ctypes.ptr -> device:Device.t -> dtype:Kind.packed -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to_dtype : unit Ctypes.ptr -> dtype:Kind.packed -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to_dtype_layout : unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to_mkldnn : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val to_mkldnn_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val to_other : unit Ctypes.ptr -> unit Ctypes.ptr -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to_padded_tensor : unit Ctypes.ptr -> padding:float -> output_size:int list option -> C.TensorG.t
val to_sparse : unit Ctypes.ptr -> C.TensorG.t
val to_sparse_bsc : unit Ctypes.ptr -> blocksize:int list -> C.TensorG.t
val to_sparse_bsr : unit Ctypes.ptr -> blocksize:int list -> C.TensorG.t
val to_sparse_csc : unit Ctypes.ptr -> C.TensorG.t
val to_sparse_csr : unit Ctypes.ptr -> C.TensorG.t
val to_sparse_sparse_dim : unit Ctypes.ptr -> sparse_dim:int -> C.TensorG.t
val topk : unit Ctypes.ptr -> k:int -> dim:int -> largest:bool -> sorted:bool -> C.TensorG.t * C.TensorG.t
val topk_values : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> k:int -> dim:int -> largest:bool -> sorted:bool -> C.TensorG.t * C.TensorG.t
val totype : unit Ctypes.ptr -> scalar_type:Kind.packed -> C.TensorG.t
val trace : unit Ctypes.ptr -> C.TensorG.t
val trace_backward : grad:unit Ctypes.ptr -> sizes:int list -> C.TensorG.t
val transpose : unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val transpose_ : unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val transpose_copy : unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val transpose_copy_int_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim0:int -> dim1:int -> C.TensorG.t
val trapezoid : y:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val trapezoid_x : y:unit Ctypes.ptr -> x:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val trapz : y:unit Ctypes.ptr -> x:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val trapz_dx : y:unit Ctypes.ptr -> dx:float -> dim:int -> C.TensorG.t
val triangular_solve : unit Ctypes.ptr -> a:unit Ctypes.ptr -> upper:bool -> transpose:bool -> unitriangular:bool -> C.TensorG.t * C.TensorG.t
val triangular_solve_x : x:unit Ctypes.ptr -> m:unit Ctypes.ptr -> unit Ctypes.ptr -> a:unit Ctypes.ptr -> upper:bool -> transpose:bool -> unitriangular:bool -> C.TensorG.t * C.TensorG.t
val tril : unit Ctypes.ptr -> diagonal:int -> C.TensorG.t
val tril_ : unit Ctypes.ptr -> diagonal:int -> C.TensorG.t
val tril_indices : row:int -> col:int -> offset:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val tril_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> diagonal:int -> C.TensorG.t
val triplet_margin_loss : anchor:unit Ctypes.ptr -> positive:unit Ctypes.ptr -> negative:unit Ctypes.ptr -> margin:float -> p:float -> eps:float -> swap:bool -> reduction:Reduction.t -> C.TensorG.t
val triu : unit Ctypes.ptr -> diagonal:int -> C.TensorG.t
val triu_ : unit Ctypes.ptr -> diagonal:int -> C.TensorG.t
val triu_indices : row:int -> col:int -> offset:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val triu_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> diagonal:int -> C.TensorG.t
val true_divide : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val true_divide_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val true_divide_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val true_divide_scalar : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val true_divide_scalar_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val trunc : unit Ctypes.ptr -> C.TensorG.t
val trunc_ : unit Ctypes.ptr -> C.TensorG.t
val trunc_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val type_as : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val unbind : unit Ctypes.ptr -> dim:int -> unit Ctypes.ptr list
val unbind_copy : unit Ctypes.ptr -> dim:int -> unit Ctypes.ptr list
val unbind_copy_int_out : out:C.TensorG.t list -> unit Ctypes.ptr -> dim:int -> unit Torch_generated.return
val unflatten : unit Ctypes.ptr -> dim:int -> sizes:int list -> C.TensorG.t
val unflatten_dense_tensors : flat:unit Ctypes.ptr -> C.TensorG.t list -> unit Ctypes.ptr list
val unfold : unit Ctypes.ptr -> dimension:int -> size:int -> step:int -> C.TensorG.t
val unfold_backward : grad_in:unit Ctypes.ptr -> input_sizes:int list -> dim:int -> size:int -> step:int -> C.TensorG.t
val unfold_copy : unit Ctypes.ptr -> dimension:int -> size:int -> step:int -> C.TensorG.t
val unfold_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dimension:int -> size:int -> step:int -> C.TensorG.t
val uniform : out:unit Ctypes.ptr -> unit Ctypes.ptr -> from:float -> to_:float -> C.TensorG.t
val uniform_ : unit Ctypes.ptr -> from:float -> to_:float -> C.TensorG.t
val uniform_functional : unit Ctypes.ptr -> from:float -> to_:float -> C.TensorG.t
val unique_consecutive : unit Ctypes.ptr -> return_inverse:bool -> return_counts:bool -> dim:int option -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val unique_dim : unit Ctypes.ptr -> dim:int -> sorted:bool -> return_inverse:bool -> return_counts:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val unique_dim_consecutive : unit Ctypes.ptr -> dim:int -> return_inverse:bool -> return_counts:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val unsafe_chunk : unit Ctypes.ptr -> chunks:int -> dim:int -> unit Ctypes.ptr list
val unsafe_split : unit Ctypes.ptr -> split_size:int -> dim:int -> unit Ctypes.ptr list
val unsafe_split_with_sizes : unit Ctypes.ptr -> split_sizes:int list -> dim:int -> unit Ctypes.ptr list
val unsqueeze : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val unsqueeze_ : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val unsqueeze_copy : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val unsqueeze_copy_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val upsample_bicubic2d : unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_bicubic2d_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_bicubic2d_backward_grad_input : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_bicubic2d_backward_vec : grad_output:unit Ctypes.ptr -> output_size:int list option -> input_size:int list -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val upsample_bicubic2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_bicubic2d_vec : C.TensorG.t -> output_size:int list option -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val upsample_bilinear2d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_bilinear2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_bilinear2d_backward_grad_input : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_bilinear2d_backward_vec : grad_output:C.TensorG.t -> output_size:int list option -> input_size:int list -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val upsample_bilinear2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_bilinear2d_vec : C.TensorG.t -> output_size:int list option -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val upsample_linear1d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales:float option -> C.TensorG.t
val upsample_linear1d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float option -> C.TensorG.t
val upsample_linear1d_backward_grad_input : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float option -> C.TensorG.t
val upsample_linear1d_backward_vec : grad_output:C.TensorG.t -> output_size:int list option -> input_size:int list -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val upsample_linear1d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales:float option -> C.TensorG.t
val upsample_linear1d_vec : C.TensorG.t -> output_size:int list option -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val upsample_nearest1d : C.TensorG.t -> output_size:int list -> scales:float option -> C.TensorG.t
val upsample_nearest1d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales:float option -> C.TensorG.t
val upsample_nearest1d_backward_grad_input : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales:float option -> C.TensorG.t
val upsample_nearest1d_backward_vec : grad_output:C.TensorG.t -> output_size:int list option -> input_size:int list -> scale_factors:float list -> C.TensorG.t
val upsample_nearest1d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales:float option -> C.TensorG.t
val upsample_nearest1d_vec : C.TensorG.t -> output_size:int list option -> scale_factors:float list -> C.TensorG.t
val upsample_nearest2d : C.TensorG.t -> output_size:int list -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_nearest2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_nearest2d_backward_grad_input : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_nearest2d_backward_vec : grad_output:C.TensorG.t -> output_size:int list option -> input_size:int list -> scale_factors:float list -> C.TensorG.t
val upsample_nearest2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_nearest2d_vec : C.TensorG.t -> output_size:int list option -> scale_factors:float list -> C.TensorG.t
val upsample_nearest3d : C.TensorG.t -> output_size:int list -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_nearest3d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_nearest3d_backward_grad_input : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_nearest3d_backward_vec : grad_output:C.TensorG.t -> output_size:int list option -> input_size:int list -> scale_factors:float list -> C.TensorG.t
val upsample_nearest3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_nearest3d_vec : C.TensorG.t -> output_size:int list option -> scale_factors:float list -> C.TensorG.t
val upsample_trilinear3d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_trilinear3d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_trilinear3d_backward_grad_input : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_trilinear3d_backward_vec : grad_output:C.TensorG.t -> output_size:int list option -> input_size:int list -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val upsample_trilinear3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_d:float option -> scales_h:float option -> scales_w:float option -> C.TensorG.t
val upsample_trilinear3d_vec : C.TensorG.t -> output_size:int list option -> align_corners:bool -> scale_factors:float list -> C.TensorG.t
val value_selecting_reduction_backward : grad:C.TensorG.t -> dim:int -> indices:C.TensorG.t -> sizes:int list -> keepdim:bool -> C.TensorG.t
val values : C.TensorG.t -> C.TensorG.t
val values_copy : C.TensorG.t -> C.TensorG.t
val values_copy_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val vander : x:C.TensorG.t -> n:int option -> increasing:bool -> C.TensorG.t
val var : C.TensorG.t -> unbiased:bool -> C.TensorG.t
val var_correction : C.TensorG.t -> dim:int list option -> correction:int option -> keepdim:bool -> C.TensorG.t
val var_correction_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list option -> correction:int option -> keepdim:bool -> C.TensorG.t
val var_dim : C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val var_mean : C.TensorG.t -> unbiased:bool -> C.TensorG.t * C.TensorG.t
val var_mean_correction : C.TensorG.t -> dim:int list option -> correction:int option -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val var_mean_dim : C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val var_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val vdot_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val view : C.TensorG.t -> size:int list -> C.TensorG.t
val view_as : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val view_as_complex : C.TensorG.t -> C.TensorG.t
val view_as_complex_copy : C.TensorG.t -> C.TensorG.t
val view_as_complex_copy_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val view_as_real : C.TensorG.t -> C.TensorG.t
val view_as_real_copy : C.TensorG.t -> C.TensorG.t
val view_as_real_copy_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val view_copy : C.TensorG.t -> size:int list -> C.TensorG.t
val view_copy_dtype : C.TensorG.t -> dtype:Kind.packed -> C.TensorG.t
val view_copy_dtype_out : out:C.TensorG.t -> C.TensorG.t -> dtype:Kind.packed -> C.TensorG.t
val view_copy_out : out:C.TensorG.t -> C.TensorG.t -> size:int list -> C.TensorG.t
val view_dtype : C.TensorG.t -> dtype:Kind.packed -> C.TensorG.t
val vsplit : C.TensorG.t -> sections:int -> unit Ctypes.ptr list
val vsplit_array : C.TensorG.t -> indices:int list -> unit Ctypes.ptr list
val vstack : C.TensorG.t list -> C.TensorG.t
val vstack_out : out:C.TensorG.t -> C.TensorG.t list -> C.TensorG.t
val where : condition:C.TensorG.t -> unit Ctypes.ptr list
val where_scalar : condition:C.TensorG.t -> C.TensorG.scalar -> C.TensorG.scalar -> C.TensorG.t
val where_scalarother : condition:C.TensorG.t -> C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val where_scalarself : condition:C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t -> C.TensorG.t
val where_self : condition:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val where_self_out : out:C.TensorG.t -> condition:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val xlogy_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val xlogy_outscalar_other : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val xlogy_outscalar_self : out:C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t -> C.TensorG.t
val xlogy_outtensor : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val xlogy_scalar_other : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val xlogy_scalar_other_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val xlogy_scalar_self : C.TensorG.scalar -> C.TensorG.t -> C.TensorG.t
val zero : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val zero_ : C.TensorG.t -> C.TensorG.t
val zero_functional : C.TensorG.t -> C.TensorG.t
val zeros : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val zeros_like : C.TensorG.t -> C.TensorG.t
val zeros_out : out:C.TensorG.t -> size:int list -> C.TensorG.t
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct