package torch

  1. Overview
  2. Docs
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 -> 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 -> 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 -> 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 -> 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 -> 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 -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _fft_with_size : unit Ctypes.ptr -> signal_ndim:int -> complex_input:bool -> complex_output:bool -> inverse:bool -> checked_signal_sizes:int list -> normalized:bool -> onesided:bool -> output_sizes:int list -> C.TensorG.t
val _fft_with_size1 : unit Ctypes.ptr -> signal_ndim:int -> complex_input:bool -> complex_output:bool -> inverse:bool -> checked_signal_sizes:int list -> normalization:int -> onesided:bool -> output_sizes:int list -> C.TensorG.t
val _fused_dropout : unit Ctypes.ptr -> p:float -> C.TensorG.t * 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:C.TensorG.t 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 _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_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 _multinomial_alias_draw : j:unit Ctypes.ptr -> q:unit Ctypes.ptr -> num_samples:int -> C.TensorG.t
val _multinomial_alias_setup : probs:unit Ctypes.ptr -> 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 _qr_helper : unit Ctypes.ptr -> some:bool -> C.TensorG.t * 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 _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_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_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 _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 _symeig_helper : unit Ctypes.ptr -> eigenvectors:bool -> upper:bool -> C.TensorG.t * 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 _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 _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 argmin : 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 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 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 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 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_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_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 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 div_ : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_1 : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val div_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val divide1 : unit Ctypes.ptr -> unit Ctypes.ptr -> 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_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> 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 -> output:unit Ctypes.ptr -> C.TensorG.t
val elu_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> alpha:unit Ctypes.ptr -> scale:unit Ctypes.ptr -> input_scale:unit Ctypes.ptr -> output: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_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 -> 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_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> scale:float -> zero_point:int -> quant_min:int -> quant_max:int -> C.TensorG.t
val fbgemm_linear_fp16_weight : unit Ctypes.ptr -> packed_weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> C.TensorG.t
val fbgemm_linear_fp16_weight_fp32_activation : unit Ctypes.ptr -> packed_weight:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> C.TensorG.t
val fbgemm_linear_int8_weight : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> packed:unit Ctypes.ptr -> col_offsets:unit Ctypes.ptr -> weight_scale:unit Ctypes.ptr -> weight_zero_point:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> C.TensorG.t
val fbgemm_linear_int8_weight_fp32_activation : unit Ctypes.ptr -> weight:unit Ctypes.ptr -> packed:unit Ctypes.ptr -> col_offsets:unit Ctypes.ptr -> weight_scale:unit Ctypes.ptr -> weight_zero_point:unit Ctypes.ptr -> bias:unit Ctypes.ptr -> C.TensorG.t
val fbgemm_pack_gemm_matrix_fp16 : unit Ctypes.ptr -> C.TensorG.t
val fbgemm_pack_quantized_matrix : unit Ctypes.ptr -> C.TensorG.t
val fbgemm_pack_quantized_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 : unit Ctypes.ptr -> signal_ndim:int -> normalized:bool -> C.TensorG.t
val fft_fft : unit Ctypes.ptr -> n:int -> dim:int -> norm:string -> C.TensorG.t
val fft_fftn : unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_hfft : 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_ifftn : unit Ctypes.ptr -> s:int list -> dim:int list -> norm:string -> C.TensorG.t
val fft_ihfft : 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_irfftn : 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_rfftn : 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 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 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 ifft : unit Ctypes.ptr -> signal_ndim:int -> normalized:bool -> 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:C.TensorG.t 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:C.TensorG.t list -> values:unit Ctypes.ptr -> accumulate:bool -> C.TensorG.t
val index_put_ : unit Ctypes.ptr -> indices:C.TensorG.t 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 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 irfft : unit Ctypes.ptr -> signal_ndim:int -> normalized:bool -> onesided:bool -> signal_sizes:int list -> 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 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 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_det : unit Ctypes.ptr -> 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 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_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 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 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 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 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 -> weight:unit Ctypes.ptr option -> bias:unit Ctypes.ptr option -> m:int -> n:int -> 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_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 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 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 rfft : unit Ctypes.ptr -> signal_ndim:int -> normalized:bool -> onesided:bool -> 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 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 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 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 tensordot : 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 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 -> C.TensorG.t
val to_dense_backward : grad:unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val to_mkldnn : unit Ctypes.ptr -> 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 : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val unsqueeze_ : unit Ctypes.ptr -> dim:int -> C.TensorG.t
val upsample_bicubic2d : unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bicubic2d_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bicubic2d_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> 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:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d : unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d_backward : grad_output:unit Ctypes.ptr -> 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:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> 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:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_linear1d : unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_linear1d_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_linear1d_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_linear1d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_nearest1d : unit Ctypes.ptr -> output_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest2d : unit Ctypes.ptr -> output_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_backward : grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_backward_out : grad_input:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> output_size:int list -> input_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d : unit Ctypes.ptr -> output_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d_backward : grad_output:unit Ctypes.ptr -> 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:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> 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:unit Ctypes.ptr -> unit Ctypes.ptr -> output_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_trilinear3d : unit Ctypes.ptr -> 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:unit Ctypes.ptr -> 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:unit Ctypes.ptr -> grad_output:unit Ctypes.ptr -> 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:unit Ctypes.ptr -> unit Ctypes.ptr -> 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:unit Ctypes.ptr -> dim:int -> indices:unit Ctypes.ptr -> sizes:int list -> keepdim:bool -> C.TensorG.t
val values : unit Ctypes.ptr -> C.TensorG.t
val vander : x:unit Ctypes.ptr -> n:int -> increasing:bool -> C.TensorG.t
val var : unit Ctypes.ptr -> unbiased:bool -> C.TensorG.t
val var1 : unit Ctypes.ptr -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val var_mean : unit Ctypes.ptr -> unbiased:bool -> C.TensorG.t * C.TensorG.t
val var_mean1 : unit Ctypes.ptr -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val var_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val vdot : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val vdot_out : out:unit Ctypes.ptr -> unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val view : unit Ctypes.ptr -> size:int list -> C.TensorG.t
val view_as : unit Ctypes.ptr -> unit Ctypes.ptr -> C.TensorG.t
val view_as_complex : unit Ctypes.ptr -> C.TensorG.t
val view_as_real : unit Ctypes.ptr -> C.TensorG.t
val vstack : C.TensorG.t list -> C.TensorG.t
val vstack_out : out:unit Ctypes.ptr -> C.TensorG.t list -> C.TensorG.t
val where : condition:unit Ctypes.ptr -> 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 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.