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__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __iand__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __iand__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ilshift__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ilshift__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ior__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ior__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __irshift__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __irshift__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ixor__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __ixor__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __lshift__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __lshift__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __or__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __or__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __rshift__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __rshift__1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __xor__ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val __xor__1 : 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 _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 _addmv_impl_ : unit Ctypes.ptr -> self2:unit Ctypes.ptr -> mat:unit Ctypes.ptr -> vec:unit Ctypes.ptr -> C.TensorG.t
val _aminmax : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val _aminmax1 : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _amp_update_scale : growth_tracker:unit Ctypes.ptr -> current_scale:unit Ctypes.ptr -> found_inf:unit Ctypes.ptr -> scale_growth_factor:float -> scale_backoff_factor:float -> growth_interval:int -> C.TensorG.t
val _baddbmm_mkl_ : unit Ctypes.ptr -> batch1:unit Ctypes.ptr -> batch2:unit Ctypes.ptr -> C.TensorG.t
val _bmm : unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> deterministic:bool -> C.TensorG.t
val _bmm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> mat2:unit Ctypes.ptr -> deterministic:bool -> 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 _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 _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_helper : unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val _cholesky_solve_helper : unit Ctypes.ptr -> a:unit Ctypes.ptr -> upper:bool -> C.TensorG.t
val _coalesced_ : 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 _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 -> C.TensorG.t
val _convolution1 : 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_nogroup : 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 -> C.TensorG.t
val _copy_from : unit Ctypes.ptr -> dst:unit Ctypes.ptr -> non_blocking:bool -> 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 _cumprod : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val _cumprod_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val _cumsum : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val _cumsum_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> 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 _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_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 -> C.TensorG.t
val _embedding_bag_dense_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 -> per_sample_weights:unit Ctypes.ptr option -> 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 -> 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 -> 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 -> 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 _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 _fw_primal : 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 _index_copy_ : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> source:unit Ctypes.ptr -> 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 _indices : unit Ctypes.ptr -> C.TensorG.t
val _inverse_helper : 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_qr_helper : unit Ctypes.ptr -> mode:string -> C.TensorG.t * C.TensorG.t
val _linalg_solve_out_helper_ : unit Ctypes.ptr -> unit Ctypes.ptr -> infos:unit Ctypes.ptr -> 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 -> 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 _lu_solve_helper : unit Ctypes.ptr -> lu_data:unit Ctypes.ptr -> lu_pivots:unit Ctypes.ptr -> 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_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 _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 _mode : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _mode_out : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * 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 _nnpack_spatial_convolution_backward_input : unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> padding:int list -> C.TensorG.t
val _nnpack_spatial_convolution_backward_weight : unit Ctypes.ptr -> weightsize:int list -> grad_output:unit Ctypes.ptr -> padding: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_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 _remove_batch_dim : unit Ctypes.ptr -> level:int -> batch_size:int -> out_dim:int -> C.TensorG.t
val _reshape_from_tensor : unit Ctypes.ptr -> shape:unit Ctypes.ptr -> 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 _s_where : condition:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> 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 _shape_as_tensor : unit Ctypes.ptr -> 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 -> unit Ctypes.ptr -> C.TensorG.t
val _solve_helper : unit Ctypes.ptr -> a:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val _sparse_addmm : unit Ctypes.ptr -> sparse:unit Ctypes.ptr -> dense:unit Ctypes.ptr -> 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_log_softmax : unit Ctypes.ptr -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val _sparse_log_softmax1 : 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_matrix_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 -> dtype:Kind.packed -> C.TensorG.t
val _sparse_softmax1 : 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_sparse_matmul : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val _sparse_sum : unit Ctypes.ptr -> C.TensorG.t
val _sparse_sum1 : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val _sparse_sum2 : unit Ctypes.ptr -> dim:int list -> C.TensorG.t
val _sparse_sum3 : unit Ctypes.ptr -> dim:int list -> dtype:Kind.packed -> C.TensorG.t
val _sparse_sum_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> 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 _std : unit Ctypes.ptr -> unbiased:bool -> C.TensorG.t
val _svd_helper : unit Ctypes.ptr -> some:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _syevd_helper : unit Ctypes.ptr -> compute_eigenvectors:bool -> uplo:string -> C.TensorG.t * 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_defaults1 : dummy:unit Ctypes.ptr -> a:int -> b:string -> C.TensorG.t
val _test_optional_filled_intlist : values:unit Ctypes.ptr -> addends:int list -> C.TensorG.t
val _test_optional_intlist : values:unit Ctypes.ptr -> addends:int list -> 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 _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 _triangular_solve_helper : unit Ctypes.ptr -> a:unit Ctypes.ptr -> upper:bool -> transpose:bool -> unitriangular:bool -> C.TensorG.t * 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 _values : unit Ctypes.ptr -> C.TensorG.t
val _var : unit Ctypes.ptr -> unbiased:bool -> C.TensorG.t
val _weight_norm : v:unit Ctypes.ptr -> g:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val _weight_norm_cuda_interface : v:unit Ctypes.ptr -> g:unit Ctypes.ptr -> dim:int -> C.TensorG.t * C.TensorG.t
val _weight_norm_cuda_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 _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 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_output:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val adaptive_avg_pool3d_backward_out : 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_out : 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_out : 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 add1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val add_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val add_1 : 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 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 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 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 all1 : 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 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 any1 : 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 arange1 : start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val arange2 : start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> step: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_out1 : out:unit Ctypes.ptr -> start:unit Ctypes.ptr -> end_:unit Ctypes.ptr -> 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 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 -> keepdim:bool -> C.TensorG.t
val argmax_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val argmin : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val argmin_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val argsort : unit Ctypes.ptr -> dim:int -> descending:bool -> C.TensorG.t
val as_strided : unit Ctypes.ptr -> size:int list -> stride:int list -> storage_offset:int -> C.TensorG.t
val as_strided_ : unit Ctypes.ptr -> size:int list -> stride:int list -> storage_offset:int -> 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_1d1 : C.TensorG.t list -> unit Ctypes.ptr list
val atleast_2d : unit Ctypes.ptr -> C.TensorG.t
val atleast_2d1 : C.TensorG.t list -> unit Ctypes.ptr list
val atleast_3d : unit Ctypes.ptr -> C.TensorG.t
val atleast_3d1 : 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 -> 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 -> C.TensorG.t
val avg_pool2d_backward_out : 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 -> 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 -> 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 -> 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 -> C.TensorG.t
val avg_pool3d_backward_out : 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 -> 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 -> 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_window1 : 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 -> 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 bernoulli1 : unit Ctypes.ptr -> p:float -> C.TensorG.t
val bernoulli_ : unit Ctypes.ptr -> p:unit Ctypes.ptr -> C.TensorG.t
val bernoulli_1 : unit Ctypes.ptr -> p:float -> C.TensorG.t
val bernoulli_out : out:unit Ctypes.ptr -> 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_out : 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_and1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_and_out1 : 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_or1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_or_out1 : 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_xor1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val bitwise_xor_out1 : 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_window1 : 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 bucketize1 : unit Ctypes.ptr -> boundaries:unit Ctypes.ptr -> out_int32:bool -> right:bool -> C.TensorG.t
val bucketize_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_ : unit Ctypes.ptr -> median:float -> sigma:float -> C.TensorG.t
val cdist : x1:unit Ctypes.ptr -> x2:unit Ctypes.ptr -> p:float -> compute_mode:int -> 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 chain_matmul : matrices:C.TensorG.t list -> 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_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_out : out:unit Ctypes.ptr -> 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_ : 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 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_out : 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 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 conj : unit Ctypes.ptr -> C.TensorG.t
val conj_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 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 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 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_sparse_to_sparse_ : 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 copysign1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val copysign_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val copysign_1 : 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 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 cross : unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> C.TensorG.t
val cross_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> 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_loss1 : 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 -> C.TensorG.t
val cudnn_convolution1 : 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 cudnn_convolution2 : 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_backward_input : self_size:int list -> grad_output: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_backward_weight : weight_size:int list -> grad_output:unit Ctypes.ptr -> 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_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 -> C.TensorG.t
val cudnn_convolution_transpose1 : 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 cudnn_convolution_transpose2 : 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_convolution_transpose_backward_input : grad_output: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_transpose_backward_weight : weight_size:int list -> grad_output:unit Ctypes.ptr -> 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_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 -> 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 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 dequantize1 : 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 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:unit Ctypes.ptr -> input_sizes:int list -> 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 div1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div2 : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div3 : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_2 : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div_3 : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val div_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide2 : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide3 : 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_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide_2 : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide_3 : unit Ctypes.ptr -> unit Ctypes.ptr -> rounding_mode:string -> C.TensorG.t
val divide_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide_out1 : out:unit Ctypes.ptr -> 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 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_out : 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_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_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_ : 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_meta : size:int list -> options:(Kind.packed * Device.t) -> 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 -> 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 eq1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val eq_out1 : 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 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_ : unit Ctypes.ptr -> lambd:float -> C.TensorG.t
val eye : n:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val eye1 : n:int -> m:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val eye_out : out:unit Ctypes.ptr -> n:int -> C.TensorG.t
val eye_out1 : out:unit Ctypes.ptr -> n:int -> m: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 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_matrix1 : 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 -> dim:int -> norm:string -> C.TensorG.t
val fft_fft2 : unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_fft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_fft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> 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 -> dim:int list -> norm:string -> C.TensorG.t
val fft_fftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_fftshift : unit Ctypes.ptr -> dim:int list -> C.TensorG.t
val fft_hfft : unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_hfft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_ifft : unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_ifft2 : unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_ifft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_ifft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_ifftn : unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_ifftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_ifftshift : unit Ctypes.ptr -> dim:int list -> C.TensorG.t
val fft_ihfft : unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_ihfft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_irfft : unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_irfft2 : unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_irfft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_irfft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_irfftn : unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_irfftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_rfft : unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_rfft2 : unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_rfft2_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_rfft_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> n:int -> 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 -> dim:int list -> norm:string -> C.TensorG.t
val fft_rfftn_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fill_ : unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val fill_1 : 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 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 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_power1 : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power2 : 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_1 : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val float_power_out2 : 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_divide1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val floor_divide_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val floor_divide_1 : 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_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 fmod1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val fmod_out1 : 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_out : 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_out : 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_out : 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_out : 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 frobenius_norm : unit Ctypes.ptr -> C.TensorG.t
val frobenius_norm1 : 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 -> 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 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 ge1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ge_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gelu : unit Ctypes.ptr -> C.TensorG.t
val gelu_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val geometric_ : unit Ctypes.ptr -> p:float -> C.TensorG.t
val geqrf : unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val geqrf_out : 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_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> 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 greater1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_equal_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val greater_out1 : 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_2d_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 grid_sampler_3d : unit Ctypes.ptr -> grid:unit Ctypes.ptr -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t
val grid_sampler_3d_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 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 gru1 : 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 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 gt : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val gt_out1 : 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_window1 : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hamming_window2 : window_length:int -> periodic:bool -> alpha:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hamming_window3 : 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_window1 : 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 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_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_out : 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 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 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_out : 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_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_fill : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val index_fill1 : 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_1 : 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_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 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 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 -> win_length:int -> window:unit Ctypes.ptr option -> center:bool -> normalized:bool -> onesided:bool -> length:int -> return_complex:bool -> C.TensorG.t
val kaiser_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val kaiser_window1 : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val kaiser_window2 : window_length:int -> periodic:bool -> beta:float -> 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_out : 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_out : 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 le1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val le_out1 : 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_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 lerp1 : 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_1 : unit Ctypes.ptr -> end_:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val lerp_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> end_:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> C.TensorG.t
val lerp_out1 : 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 less1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_equal_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val less_out1 : 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 linalg_cholesky : unit Ctypes.ptr -> C.TensorG.t
val linalg_cholesky_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_cond : unit Ctypes.ptr -> p:unit Ctypes.ptr -> C.TensorG.t
val linalg_cond1 : unit Ctypes.ptr -> p:string -> C.TensorG.t
val linalg_cond_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:unit Ctypes.ptr -> C.TensorG.t
val linalg_cond_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:string -> C.TensorG.t
val linalg_det : unit Ctypes.ptr -> C.TensorG.t
val linalg_eigh : unit Ctypes.ptr -> uplo:string -> C.TensorG.t * C.TensorG.t
val linalg_eigh_out : eigvals:unit Ctypes.ptr -> eigvecs:unit Ctypes.ptr -> unit Ctypes.ptr -> uplo:string -> C.TensorG.t * 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_inv : unit Ctypes.ptr -> C.TensorG.t
val linalg_inv_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val linalg_matrix_rank : unit Ctypes.ptr -> tol:float -> 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_norm : unit Ctypes.ptr -> ord:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val linalg_norm1 : unit Ctypes.ptr -> ord:string -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val linalg_norm_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> ord:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val linalg_norm_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> ord:string -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val linalg_pinv : unit Ctypes.ptr -> rcond:float -> hermitian:bool -> C.TensorG.t
val linalg_pinv1 : unit Ctypes.ptr -> rcond:unit Ctypes.ptr -> 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_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> rcond:unit Ctypes.ptr -> hermitian:bool -> C.TensorG.t
val linalg_qr : unit Ctypes.ptr -> mode:string -> C.TensorG.t * C.TensorG.t
val linalg_qr_out : q:unit Ctypes.ptr -> r:unit Ctypes.ptr -> 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_svd : unit Ctypes.ptr -> full_matrices:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val linalg_svd_out : u:unit Ctypes.ptr -> s:unit Ctypes.ptr -> v:unit Ctypes.ptr -> unit Ctypes.ptr -> full_matrices:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * 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 -> C.TensorG.t
val linalg_tensorsolve_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> dims:int list -> C.TensorG.t
val linear : 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_ : 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_out : 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 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 -> C.TensorG.t
val logit_ : unit Ctypes.ptr -> eps:float -> C.TensorG.t
val logit_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> eps:float -> C.TensorG.t
val logit_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> eps:float -> C.TensorG.t
val logit_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> eps:float -> 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 lstm1 : 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 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 lstsq : unit Ctypes.ptr -> a:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val lstsq_out : 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 lt1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val lt_out1 : 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 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_fill1 : 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_1 : 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_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_power : unit Ctypes.ptr -> n:int -> C.TensorG.t
val matrix_rank : unit Ctypes.ptr -> symmetric:bool -> C.TensorG.t
val matrix_rank1 : unit Ctypes.ptr -> tol:float -> symmetric:bool -> C.TensorG.t
val max : unit Ctypes.ptr -> C.TensorG.t
val max1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val max2 : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val max_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val max_out1 : max:unit Ctypes.ptr -> max_values:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * 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_out : 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_out : 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_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> output_size:int list -> C.TensorG.t
val max_unpool2d_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> 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_backward : grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> indices:unit Ctypes.ptr -> output_size:int list -> stride:int list -> padding:int list -> C.TensorG.t
val max_unpool3d_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> 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 mean1 : 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 median1 : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val median_out : 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 min : unit Ctypes.ptr -> C.TensorG.t
val min1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val min2 : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val min_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val min_out1 : min:unit Ctypes.ptr -> min_indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * 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_backward_bias : grad_output:unit Ctypes.ptr -> C.TensorG.t
val miopen_convolution_backward_input : self_size:int list -> grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_convolution_backward_weight : weight_size:int list -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> 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_convolution_transpose_backward_input : grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_convolution_transpose_backward_weight : weight_size:int list -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> 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_depthwise_convolution_backward_input : self_size:int list -> grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_depthwise_convolution_backward_weight : weight_size:int list -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> 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 mkldnn_adaptive_avg_pool2d : unit Ctypes.ptr -> output_size:int list -> 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_convolution_backward_input : self_size:int list -> grad_output:unit Ctypes.ptr -> weight:unit Ctypes.ptr -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> bias_defined:bool -> C.TensorG.t
val mkldnn_convolution_backward_weights : weight_size:int list -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> bias_defined:bool -> C.TensorG.t * 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_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_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_out : 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 moveaxis1 : 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 movedim1 : unit Ctypes.ptr -> source:int -> destination:int -> 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_out : 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 mul : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mul1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mul_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val mul_1 : 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 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_out : 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_out : 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 multiply1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val multiply_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val multiply_1 : 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 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 nan_to_num : unit Ctypes.ptr -> nan:float -> posinf:float -> neginf:float -> C.TensorG.t
val nan_to_num_ : unit Ctypes.ptr -> nan:float -> posinf:float -> neginf:float -> C.TensorG.t
val nan_to_num_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> nan:float -> posinf:float -> neginf:float -> C.TensorG.t
val nanmedian : unit Ctypes.ptr -> C.TensorG.t
val nanmedian1 : unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val nanmedian_out : 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:float -> dim:int -> keepdim:bool -> C.TensorG.t
val nanquantile1 : unit Ctypes.ptr -> q:unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val nanquantile_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> q:float -> dim:int -> keepdim:bool -> C.TensorG.t
val nanquantile_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> q:unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val nansum : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val nansum1 : 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 narrow1 : unit Ctypes.ptr -> dim:int -> start:unit Ctypes.ptr -> 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 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_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_norm1 : 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 ne1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val ne_out1 : 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_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_out : 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_out : 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_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 norm1 : unit Ctypes.ptr -> p:unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val norm2 : unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> C.TensorG.t
val norm3 : 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_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> p:unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val normal_ : unit Ctypes.ptr -> mean:float -> std:float -> C.TensorG.t
val normal_out : out:unit Ctypes.ptr -> mean:unit Ctypes.ptr -> std:float -> C.TensorG.t
val normal_out1 : out:unit Ctypes.ptr -> mean:float -> std:unit Ctypes.ptr -> C.TensorG.t
val normal_out2 : out:unit Ctypes.ptr -> mean:unit Ctypes.ptr -> std:unit Ctypes.ptr -> C.TensorG.t
val normal_out3 : out:unit Ctypes.ptr -> mean:float -> std:float -> size:int list -> C.TensorG.t
val not_equal : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val not_equal_out1 : 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_norm1 : 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 nuclear_norm_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> 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 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 pin_memory : unit Ctypes.ptr -> 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 pow : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow1 : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow2 : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_ : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_1 : unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> exponent:unit Ctypes.ptr -> C.TensorG.t
val pow_out2 : 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 prod1 : unit Ctypes.ptr -> dim:int -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val prod_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 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_out : 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:float -> dim:int -> keepdim:bool -> C.TensorG.t
val quantile1 : unit Ctypes.ptr -> q:unit Ctypes.ptr -> dim:int -> keepdim:bool -> C.TensorG.t
val quantile_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> q:float -> dim:int -> keepdim:bool -> C.TensorG.t
val quantile_out1 : out:unit Ctypes.ptr -> unit Ctypes.ptr -> q:unit Ctypes.ptr -> dim:int -> keepdim:bool -> 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_tensor1 : 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 randint1 : low:int -> 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_like1 : unit Ctypes.ptr -> low:int -> high:int -> C.TensorG.t
val randint_out : out:unit Ctypes.ptr -> high:int -> size:int list -> C.TensorG.t
val randint_out1 : out:unit Ctypes.ptr -> low:int -> 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_ : unit Ctypes.ptr -> C.TensorG.t
val random_1 : unit Ctypes.ptr -> to_:int -> C.TensorG.t
val random_2 : unit Ctypes.ptr -> from:int -> 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 range1 : 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 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_out : 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_out : 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 relu : unit Ctypes.ptr -> C.TensorG.t
val relu_ : unit Ctypes.ptr -> C.TensorG.t
val remainder : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val remainder_out1 : 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 -> C.TensorG.t
val repeat_interleave1 : unit Ctypes.ptr -> repeats:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val repeat_interleave2 : unit Ctypes.ptr -> repeats:int -> dim:int -> 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_out : 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_out : 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_out : 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_ : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val resize_as_ : unit Ctypes.ptr -> the_template: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_relu1 : 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_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_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_tanh1 : 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_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 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_out : out:unit Ctypes.ptr -> 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 rsub1 : 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 scatter1 : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value: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_1 : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> C.TensorG.t
val scatter_2 : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> src:unit Ctypes.ptr -> reduce:string -> C.TensorG.t
val scatter_3 : unit Ctypes.ptr -> dim:int -> index:unit Ctypes.ptr -> value:unit Ctypes.ptr -> reduce:string -> 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 searchsorted : sorted_sequence:unit Ctypes.ptr -> unit Ctypes.ptr -> out_int32:bool -> right:bool -> C.TensorG.t
val searchsorted1 : sorted_sequence:unit Ctypes.ptr -> unit Ctypes.ptr -> out_int32:bool -> right:bool -> C.TensorG.t
val searchsorted_out : out:unit Ctypes.ptr -> sorted_sequence:unit Ctypes.ptr -> unit Ctypes.ptr -> out_int32:bool -> right:bool -> C.TensorG.t
val select : unit Ctypes.ptr -> dim:int -> index:int -> C.TensorG.t
val select_backward : grad:unit Ctypes.ptr -> input_sizes:int list -> 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_ : unit Ctypes.ptr -> C.TensorG.t
val set_1 : unit Ctypes.ptr -> source:unit Ctypes.ptr -> C.TensorG.t
val set_requires_grad : unit Ctypes.ptr -> r:bool -> 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_out : 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_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 -> end_:int -> step:int -> C.TensorG.t
val slice_backward : grad:unit Ctypes.ptr -> input_sizes:int list -> dim:int -> start:int -> end_:int -> 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_out : 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_out : 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 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 -> output:unit Ctypes.ptr -> C.TensorG.t
val softplus_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> unit Ctypes.ptr -> beta:unit Ctypes.ptr -> threshold:unit Ctypes.ptr -> output: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_out : 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 solve : unit Ctypes.ptr -> a:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val solve_out : solution:unit Ctypes.ptr -> lu:unit Ctypes.ptr -> unit Ctypes.ptr -> a:unit Ctypes.ptr -> C.TensorG.t * C.TensorG.t
val sort : unit Ctypes.ptr -> dim:int -> descending:bool -> C.TensorG.t * C.TensorG.t
val sort_out : values:unit Ctypes.ptr -> indices:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int -> descending:bool -> C.TensorG.t * C.TensorG.t
val sparse_coo_tensor : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_coo_tensor1 : indices:unit Ctypes.ptr -> values:unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_coo_tensor2 : 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_ : 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 split : unit Ctypes.ptr -> split_size:int -> dim:int -> unit Ctypes.ptr list
val split_with_sizes : unit Ctypes.ptr -> split_sizes:int list -> dim:int -> unit Ctypes.ptr list
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 squeeze : unit Ctypes.ptr -> C.TensorG.t
val squeeze1 : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val squeeze_ : unit Ctypes.ptr -> C.TensorG.t
val squeeze_1 : 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 std1 : 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_mean1 : 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 -> win_length:int -> window:unit Ctypes.ptr option -> normalized:bool -> onesided:bool -> return_complex:bool -> C.TensorG.t
val sub : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sub1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sub_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val sub_1 : 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 subtract : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val subtract1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val subtract_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val subtract_1 : 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 sum : unit Ctypes.ptr -> dtype:Kind.packed -> C.TensorG.t
val sum1 : unit Ctypes.ptr -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val sum_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_out : 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_out : 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 take : unit Ctypes.ptr -> index:unit Ctypes.ptr -> C.TensorG.t
val take_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> index:unit Ctypes.ptr -> 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_out : 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_split1 : unit Ctypes.ptr -> indices:int list -> dim:int -> unit Ctypes.ptr list
val tensor_split2 : 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_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 to1 : unit Ctypes.ptr -> options:(Kind.packed * Device.t) -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to2 : unit Ctypes.ptr -> dtype:Kind.packed -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to3 : unit Ctypes.ptr -> unit Ctypes.ptr -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to4 : unit Ctypes.ptr -> device:Device.t -> dtype:Kind.packed -> non_blocking:bool -> copy:bool -> 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_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_sparse : unit Ctypes.ptr -> C.TensorG.t
val to_sparse1 : 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_out : 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 trapz : y:unit Ctypes.ptr -> x:unit Ctypes.ptr -> dim:int -> C.TensorG.t
val trapz1 : 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_out : 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_divide1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val true_divide_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val true_divide_1 : 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 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 unflatten : unit Ctypes.ptr -> dim:int -> sizes:int list -> C.TensorG.t
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 uniform_ : unit Ctypes.ptr -> from:float -> to_:float -> C.TensorG.t
val unique_consecutive : unit Ctypes.ptr -> return_inverse:bool -> return_counts:bool -> dim:int -> 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 : C.TensorG.t -> dim:int -> C.TensorG.t
val unsqueeze_ : C.TensorG.t -> dim:int -> C.TensorG.t
val upsample_bicubic2d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bicubic2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bicubic2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bicubic2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> 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 -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_linear1d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales:float -> 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 -> C.TensorG.t
val upsample_linear1d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_linear1d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_nearest1d : C.TensorG.t -> output_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest2d : C.TensorG.t -> output_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d : C.TensorG.t -> output_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_trilinear3d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> 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 -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_trilinear3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_trilinear3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> 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 vander : x:C.TensorG.t -> n:int -> increasing:bool -> C.TensorG.t
val var : C.TensorG.t -> unbiased:bool -> C.TensorG.t
val var1 : 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_mean1 : 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 view1 : C.TensorG.t -> dtype:Kind.packed -> 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_real : C.TensorG.t -> C.TensorG.t
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 where1 : condition:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val where2 : condition:C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t -> C.TensorG.t
val where3 : condition:C.TensorG.t -> C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val xlogy_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val xlogy_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val xlogy_out1 : out:C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t -> C.TensorG.t
val xlogy_out2 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val zero_ : 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