Package aten

Class ATen

java.lang.Object

aten.ATen

public class ATen
extends Object

Constructor Summary

Constructors

Constructor	Description
ATen()

Method Summary

Modifier and Type	Method	Description
static Tensor	__and___0(Tensor self, double other)
static Tensor	__and___0_l(Tensor self, long other)
static Tensor	__and___1(Tensor self, Tensor other)
static boolean	__dispatch_is_complex(Tensor self)
static boolean	__dispatch_is_floating_point(Tensor self)
static boolean	__dispatch_is_signed(Tensor self)
static long	__dispatch_size(Tensor self, long dim)
static long	__dispatch_stride(Tensor self, long dim)
static Tensor	__lshift___0(Tensor self, double other)
static Tensor	__lshift___0_l(Tensor self, long other)
static Tensor	__lshift___1(Tensor self, Tensor other)
static Tensor	__or___0(Tensor self, double other)
static Tensor	__or___0_l(Tensor self, long other)
static Tensor	__or___1(Tensor self, Tensor other)
static Tensor	__rshift___0(Tensor self, double other)
static Tensor	__rshift___0_l(Tensor self, long other)
static Tensor	__rshift___1(Tensor self, Tensor other)
static Tensor	__xor___0(Tensor self, double other)
static Tensor	__xor___0_l(Tensor self, long other)
static Tensor	__xor___1(Tensor self, Tensor other)
static Tensor	_adaptive_avg_pool2d(Tensor self, long[] output_size)
static Tensor	_adaptive_avg_pool2d_backward(Tensor grad_output, Tensor self)
static Tensor	_adaptive_avg_pool3d(Tensor self, long[] output_size)
static Tensor	_adaptive_avg_pool3d_backward(Tensor grad_output, Tensor self)
static Tensor	_add_batch_dim(Tensor self, long batch_dim, long level)
static Tensor	_add_relu(Tensor self, Tensor other, double alpha)
static void	_add_relu_(Tensor self, Tensor other, double alpha)
static void	_add_relu__l(Tensor self, Tensor other, long alpha)
static Tensor	_add_relu_l(Tensor self, Tensor other, long alpha)
static void	_add_relu_out(Tensor out, Tensor self, Tensor other, double alpha)
static void	_add_relu_out_l(Tensor out, Tensor self, Tensor other, long alpha)
static scala.Tuple2<Tensor,Tensor>	_aminmax_0(Tensor self)
static scala.Tuple2<Tensor,Tensor>	_aminmax_1(Tensor self, long dim, boolean keepdim)
static void	_amp_foreach_non_finite_check_and_unscale_(Tensor[] self, Tensor found_inf, Tensor inv_scale)
static void	_amp_update_scale_(Tensor self, Tensor growth_tracker, Tensor found_inf, double scale_growth_factor, double scale_backoff_factor, long growth_interval)
static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Long>	_batch_norm_impl_index(Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, boolean training, double momentum, double eps, boolean cudnn_enabled)
static scala.Tuple3<Tensor,Tensor,Tensor>	_batch_norm_impl_index_backward(long impl_index, Tensor input, Tensor grad_output, scala.Option<Tensor> weight, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, scala.Option<Tensor> save_mean, scala.Option<Tensor> save_var_transform, boolean train, double eps, boolean[] output_mask, Tensor reservedSpace)
static Tensor	_cast_Byte(Tensor self, boolean non_blocking)
static Tensor	_cast_Char(Tensor self, boolean non_blocking)
static Tensor	_cast_Double(Tensor self, boolean non_blocking)
static Tensor	_cast_Float(Tensor self, boolean non_blocking)
static Tensor	_cast_Half(Tensor self, boolean non_blocking)
static Tensor	_cast_Int(Tensor self, boolean non_blocking)
static Tensor	_cast_Long(Tensor self, boolean non_blocking)
static Tensor	_cast_Short(Tensor self, boolean non_blocking)
static Tensor	_cdist_backward(Tensor grad, Tensor x1, Tensor x2, double p, Tensor cdist)
static Tensor	_cdist_forward(Tensor x1, Tensor x2, double p, long compute_mode)
static Tensor	_cholesky_solve_helper(Tensor self, Tensor A, boolean upper)
static scala.Tuple2<Double,Long>	_choose_qparams_per_tensor(Tensor self, boolean reduce_range)
static Tensor	_coalesce(Tensor self)
static Tensor	_compute_linear_combination(Tensor input, Tensor coefficients)
static void	_compute_linear_combination_out(Tensor out, Tensor input, Tensor coefficients)
static Tensor	_conj(Tensor self)
static Tensor	_copy_from(Tensor self, Tensor dst, boolean non_blocking)
static scala.Tuple2<Tensor,Tensor>	_ctc_loss(Tensor log_probs, Tensor targets, long[] input_lengths, long[] target_lengths, long blank, boolean zero_infinity)
static Tensor	_ctc_loss_backward(Tensor grad, Tensor log_probs, Tensor targets, long[] input_lengths, long[] target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, long blank, boolean zero_infinity)
static void	_cufft_clear_plan_cache(long device_index)
static long	_cufft_get_plan_cache_max_size(long device_index)
static long	_cufft_get_plan_cache_size(long device_index)
static void	_cufft_set_plan_cache_max_size(long device_index, long max_size)
static void	_cummax_helper(Tensor self, Tensor values, Tensor indices, long dim)
static void	_cummin_helper(Tensor self, Tensor values, Tensor indices, long dim)
static long	_debug_has_internal_overlap(Tensor self)
static Tensor	_dim_arange(Tensor like, long dim)
static Tensor	_dirichlet_grad(Tensor x, Tensor alpha, Tensor total)
static scala.Tuple4<Tensor,Tensor,Tensor,Tensor>	_embedding_bag(Tensor weight, Tensor indices, Tensor offsets, boolean scale_grad_by_freq, long mode, boolean sparse, scala.Option<Tensor> per_sample_weights, boolean include_last_offset, long padding_idx)
static Tensor	_embedding_bag_backward(Tensor grad, Tensor indices, Tensor offsets, Tensor offset2bag, Tensor bag_size, Tensor maximum_indices, long num_weights, boolean scale_grad_by_freq, long mode, boolean sparse, scala.Option<Tensor> per_sample_weights, long padding_idx)
static Tensor	_embedding_bag_dense_backward(Tensor grad, Tensor indices, Tensor offset2bag, Tensor bag_size, Tensor maximum_indices, long num_weights, boolean scale_grad_by_freq, long mode, scala.Option<Tensor> per_sample_weights, long padding_idx)
static scala.Tuple4<Tensor,Tensor,Tensor,Tensor>	_embedding_bag_forward_only(Tensor weight, Tensor indices, Tensor offsets, boolean scale_grad_by_freq, long mode, boolean sparse, scala.Option<Tensor> per_sample_weights, boolean include_last_offset, long padding_idx)
static Tensor	_embedding_bag_per_sample_weights_backward(Tensor grad, Tensor weight, Tensor indices, Tensor offsets, Tensor offset2bag, long mode, long padding_idx)
static Tensor	_embedding_bag_sparse_backward(Tensor grad, Tensor indices, Tensor offsets, Tensor offset2bag, Tensor bag_size, long num_weights, boolean scale_grad_by_freq, long mode, scala.Option<Tensor> per_sample_weights, long padding_idx)
static Tensor	_empty_affine_quantized(long[] size, TensorOptions options, double scale, long zero_point)
static Tensor	_empty_per_channel_affine_quantized(long[] size, Tensor scales, Tensor zero_points, long axis, TensorOptions options)
static Tensor	_euclidean_dist(Tensor x1, Tensor x2)
static Tensor	_fake_quantize_learnable_per_channel_affine(Tensor self, Tensor scale, Tensor zero_point, long axis, long quant_min, long quant_max, double grad_factor)
static scala.Tuple3<Tensor,Tensor,Tensor>	_fake_quantize_learnable_per_channel_affine_backward(Tensor grad, Tensor self, Tensor scale, Tensor zero_point, long axis, long quant_min, long quant_max, double grad_factor)
static Tensor	_fake_quantize_learnable_per_tensor_affine(Tensor self, Tensor scale, Tensor zero_point, long quant_min, long quant_max, double grad_factor)
static scala.Tuple3<Tensor,Tensor,Tensor>	_fake_quantize_learnable_per_tensor_affine_backward(Tensor grad, Tensor self, Tensor scale, Tensor zero_point, long quant_min, long quant_max, double grad_factor)
static Tensor	_fft_c2c(Tensor self, long[] dim, long normalization, boolean forward)
static void	_fft_c2c_out(Tensor out, Tensor self, long[] dim, long normalization, boolean forward)
static Tensor	_fft_c2r(Tensor self, long[] dim, long normalization, long last_dim_size)
static void	_fft_c2r_out(Tensor out, Tensor self, long[] dim, long normalization, long last_dim_size)
static Tensor[]	_foreach_abs(Tensor[] tensors)
static void	_foreach_abs_(Tensor[] self)
static Tensor[]	_foreach_acos(Tensor[] tensors)
static void	_foreach_acos_(Tensor[] self)
static void	_foreach_add__0(Tensor[] self, double scalar)
static void	_foreach_add__0_l(Tensor[] self, long scalar)
static void	_foreach_add__1(Tensor[] self, Tensor[] other, double alpha)
static void	_foreach_add__1_l(Tensor[] self, Tensor[] other, long alpha)
static Tensor[]	_foreach_add_0(Tensor[] tensors, double scalar)
static Tensor[]	_foreach_add_0_l(Tensor[] tensors, long scalar)
static Tensor[]	_foreach_add_1(Tensor[] tensors1, Tensor[] tensors2, double alpha)
static Tensor[]	_foreach_add_1_l(Tensor[] tensors1, Tensor[] tensors2, long alpha)
static Tensor[]	_foreach_addcdiv(Tensor[] input, Tensor[] tensor1, Tensor[] tensor2, double value)
static void	_foreach_addcdiv_(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, double value)
static void	_foreach_addcdiv__l(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, long value)
static Tensor[]	_foreach_addcdiv_l(Tensor[] input, Tensor[] tensor1, Tensor[] tensor2, long value)
static Tensor[]	_foreach_addcmul(Tensor[] input, Tensor[] tensor1, Tensor[] tensor2, double value)
static void	_foreach_addcmul_(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, double value)
static void	_foreach_addcmul__l(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, long value)
static Tensor[]	_foreach_addcmul_l(Tensor[] input, Tensor[] tensor1, Tensor[] tensor2, long value)
static Tensor[]	_foreach_asin(Tensor[] tensors)
static void	_foreach_asin_(Tensor[] self)
static Tensor[]	_foreach_atan(Tensor[] tensors)
static void	_foreach_atan_(Tensor[] self)
static Tensor[]	_foreach_ceil(Tensor[] tensors)
static void	_foreach_ceil_(Tensor[] self)
static Tensor[]	_foreach_cos(Tensor[] tensors)
static void	_foreach_cos_(Tensor[] self)
static Tensor[]	_foreach_cosh(Tensor[] tensors)
static void	_foreach_cosh_(Tensor[] self)
static void	_foreach_div__0(Tensor[] self, double scalar)
static void	_foreach_div__0_l(Tensor[] self, long scalar)
static void	_foreach_div__1(Tensor[] self, Tensor[] other)
static Tensor[]	_foreach_div_0(Tensor[] tensors, double scalar)
static Tensor[]	_foreach_div_0_l(Tensor[] tensors, long scalar)
static Tensor[]	_foreach_div_1(Tensor[] tensors1, Tensor[] tensors2)
static Tensor[]	_foreach_erf(Tensor[] tensors)
static void	_foreach_erf_(Tensor[] self)
static Tensor[]	_foreach_erfc(Tensor[] tensors)
static void	_foreach_erfc_(Tensor[] self)
static Tensor[]	_foreach_exp(Tensor[] tensors)
static void	_foreach_exp_(Tensor[] self)
static Tensor[]	_foreach_expm1(Tensor[] tensors)
static void	_foreach_expm1_(Tensor[] self)
static Tensor[]	_foreach_floor(Tensor[] tensors)
static void	_foreach_floor_(Tensor[] self)
static Tensor[]	_foreach_frac(Tensor[] tensors)
static void	_foreach_frac_(Tensor[] self)
static Tensor[]	_foreach_lgamma(Tensor[] tensors)
static void	_foreach_lgamma_(Tensor[] self)
static Tensor[]	_foreach_log(Tensor[] tensors)
static void	_foreach_log_(Tensor[] self)
static Tensor[]	_foreach_log10(Tensor[] tensors)
static void	_foreach_log10_(Tensor[] self)
static Tensor[]	_foreach_log1p(Tensor[] tensors)
static void	_foreach_log1p_(Tensor[] self)
static Tensor[]	_foreach_log2(Tensor[] tensors)
static void	_foreach_log2_(Tensor[] self)
static Tensor[]	_foreach_maximum(Tensor[] tensors1, Tensor[] tensors2)
static Tensor[]	_foreach_minimum(Tensor[] tensors1, Tensor[] tensors2)
static void	_foreach_mul__0(Tensor[] self, double scalar)
static void	_foreach_mul__0_l(Tensor[] self, long scalar)
static void	_foreach_mul__1(Tensor[] self, Tensor[] other)
static Tensor[]	_foreach_mul_0(Tensor[] tensors, double scalar)
static Tensor[]	_foreach_mul_0_l(Tensor[] tensors, long scalar)
static Tensor[]	_foreach_mul_1(Tensor[] tensors1, Tensor[] tensors2)
static Tensor[]	_foreach_neg(Tensor[] tensors)
static void	_foreach_neg_(Tensor[] self)
static Tensor[]	_foreach_reciprocal(Tensor[] tensors)
static void	_foreach_reciprocal_(Tensor[] self)
static Tensor[]	_foreach_round(Tensor[] tensors)
static void	_foreach_round_(Tensor[] self)
static Tensor[]	_foreach_sigmoid(Tensor[] tensors)
static void	_foreach_sigmoid_(Tensor[] self)
static Tensor[]	_foreach_sin(Tensor[] tensors)
static void	_foreach_sin_(Tensor[] self)
static Tensor[]	_foreach_sinh(Tensor[] tensors)
static void	_foreach_sinh_(Tensor[] self)
static Tensor[]	_foreach_sqrt(Tensor[] tensors)
static void	_foreach_sqrt_(Tensor[] self)
static void	_foreach_sub__0(Tensor[] self, double scalar)
static void	_foreach_sub__0_l(Tensor[] self, long scalar)
static void	_foreach_sub__1(Tensor[] self, Tensor[] other, double alpha)
static void	_foreach_sub__1_l(Tensor[] self, Tensor[] other, long alpha)
static Tensor[]	_foreach_sub_0(Tensor[] tensors, double scalar)
static Tensor[]	_foreach_sub_0_l(Tensor[] tensors, long scalar)
static Tensor[]	_foreach_sub_1(Tensor[] tensors1, Tensor[] tensors2, double alpha)
static Tensor[]	_foreach_sub_1_l(Tensor[] tensors1, Tensor[] tensors2, long alpha)
static Tensor[]	_foreach_tan(Tensor[] tensors)
static void	_foreach_tan_(Tensor[] self)
static Tensor[]	_foreach_tanh(Tensor[] tensors)
static void	_foreach_tanh_(Tensor[] self)
static Tensor[]	_foreach_trunc(Tensor[] tensors)
static void	_foreach_trunc_(Tensor[] self)
static void	_foreach_zero_(Tensor[] self)
static scala.Tuple2<Tensor,Tensor>	_fused_dropout(Tensor self, double p)
static Tensor	_gather_sparse_backward(Tensor self, long dim, Tensor index, Tensor grad)
static boolean	_has_compatible_shallow_copy_type(Tensor self, Tensor from)
static void	_index_put_impl_(Tensor self, Tensor[] indices, Tensor values, boolean accumulate, boolean unsafe)
static double	_local_scalar_dense(Tensor self)
static Tensor	_log_softmax(Tensor self, long dim, boolean half_to_float)
static Tensor	_log_softmax_backward_data(Tensor grad_output, Tensor output, long dim, byte input_dtype)
static Tensor	_logcumsumexp(Tensor self, long dim)
static void	_logcumsumexp_out(Tensor out, Tensor self, long dim)
static scala.Tuple3<Tensor,Tensor,Tensor>	_lu_with_info(Tensor self, boolean pivot, boolean check_errors)
static Tensor	_make_per_channel_quantized_tensor(Tensor self, Tensor scale, Tensor zero_point, long axis)
static Tensor	_make_per_tensor_quantized_tensor(Tensor self, double scale, long zero_point)
static Tensor	_masked_scale(Tensor self, Tensor mask, double scale)
static boolean	_nnpack_available()
static scala.Tuple2<Tensor,Tensor>	_pack_padded_sequence(Tensor input, Tensor lengths, boolean batch_first)
static Tensor	_pack_padded_sequence_backward(Tensor grad, long[] input_size, Tensor batch_sizes, boolean batch_first)
static scala.Tuple2<Tensor,Tensor>	_pad_packed_sequence(Tensor data, Tensor batch_sizes, boolean batch_first, double padding_value, long total_length)
static scala.Tuple2<Tensor,Tensor>	_pad_packed_sequence_l(Tensor data, Tensor batch_sizes, boolean batch_first, long padding_value, long total_length)
static Tensor	_pdist_backward(Tensor grad, Tensor self, double p, Tensor pdist)
static Tensor	_pdist_forward(Tensor self, double p)
static Tensor	_remove_batch_dim(Tensor self, long level, long batch_size, long out_dim)
static Tensor	_reshape_from_tensor(Tensor self, Tensor shape)
static scala.Tuple2<Tensor,Tensor>	_rowwise_prune(Tensor weight, Tensor mask, byte compressed_indices_dtype)
static Tensor	_sample_dirichlet(Tensor self)
static Tensor	_saturate_weight_to_fp16(Tensor weight)
static scala.Tuple2<Tensor,Tensor>	_scaled_dot_product_efficient_attention(Tensor query, Tensor key, Tensor value, boolean compute_log_sumexp, boolean is_causal)
static scala.Tuple3<Tensor,Tensor,Tensor>	_scaled_dot_product_efficient_attention_backward(Tensor grad_out_, Tensor query, Tensor key, Tensor value, Tensor out, Tensor logsumexp, boolean is_causal, boolean chunk_grad_outputs)
static Tensor	_shape_as_tensor(Tensor self)
static scala.Tuple2<Tensor,Tensor>	_sobol_engine_draw(Tensor quasi, long n, Tensor sobolstate, long dimension, long num_generated)
static void	_sobol_engine_ff_(Tensor self, long n, Tensor sobolstate, long dimension, long num_generated)
static void	_sobol_engine_initialize_state_(Tensor self, long dimension)
static void	_sobol_engine_scramble_(Tensor self, Tensor ltm, long dimension)
static Tensor	_softmax(Tensor self, long dim, boolean half_to_float)
static Tensor	_softmax_backward_data(Tensor grad_output, Tensor output, long dim, byte input_dtype)
static Tensor	_sparse_addmm(Tensor self, Tensor sparse, Tensor dense, double beta, double alpha)
static Tensor	_sparse_addmm_l(Tensor self, Tensor sparse, Tensor dense, long beta, long alpha)
static Tensor	_sparse_coo_tensor_unsafe(Tensor indices, Tensor values, long[] size, TensorOptions options)
static Tensor	_sparse_coo_tensor_with_dims(long sparse_dim, long dense_dim, long[] size, TensorOptions options)
static Tensor	_sparse_coo_tensor_with_dims_and_tensors(long sparse_dim, long dense_dim, long[] size, Tensor indices, Tensor values, TensorOptions options)
static Tensor	_sparse_log_softmax_0(Tensor self, long dim)
static Tensor	_sparse_log_softmax_1(Tensor self, long dim, boolean half_to_float)
static Tensor	_sparse_log_softmax_backward_data(Tensor grad_output, Tensor output, long dim, Tensor self)
static Tensor	_sparse_mm(Tensor sparse, Tensor dense)
static Tensor	_sparse_softmax_0(Tensor self, long dim)
static Tensor	_sparse_softmax_1(Tensor self, long dim, boolean half_to_float)
static Tensor	_sparse_softmax_backward_data(Tensor grad_output, Tensor output, long dim, Tensor self)
static Tensor	_sparse_sparse_matmul(Tensor self, Tensor other)
static Tensor	_sparse_sum_0(Tensor self)
static Tensor	_sparse_sum_1(Tensor self, byte dtype)
static Tensor	_sparse_sum_2(Tensor self, long[] dim)
static Tensor	_sparse_sum_3(Tensor self, long[] dim, byte dtype)
static Tensor	_sparse_sum_backward(Tensor grad, Tensor self, long[] dim)
static Tensor	_stack(Tensor[] tensors, long dim)
static void	_stack_out(Tensor out, Tensor[] tensors, long dim)
static Tensor	_standard_gamma(Tensor self)
static Tensor	_standard_gamma_grad(Tensor self, Tensor output)
static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Tensor>	_thnn_differentiable_gru_cell_backward(Tensor grad_hy, Tensor input_gates, Tensor hidden_gates, Tensor hx, scala.Option<Tensor> input_bias, scala.Option<Tensor> hidden_bias)
static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Tensor>	_thnn_differentiable_lstm_cell_backward(scala.Option<Tensor> grad_hy, scala.Option<Tensor> grad_cy, Tensor input_gates, Tensor hidden_gates, scala.Option<Tensor> input_bias, scala.Option<Tensor> hidden_bias, Tensor cx, Tensor cy)
static scala.Tuple2<Tensor,Tensor>	_thnn_fused_gru_cell(Tensor input_gates, Tensor hidden_gates, Tensor hx, scala.Option<Tensor> input_bias, scala.Option<Tensor> hidden_bias)
static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Tensor>	_thnn_fused_gru_cell_backward(Tensor grad_hy, Tensor workspace, boolean has_bias)
static scala.Tuple3<Tensor,Tensor,Tensor>	_thnn_fused_lstm_cell(Tensor input_gates, Tensor hidden_gates, Tensor cx, scala.Option<Tensor> input_bias, scala.Option<Tensor> hidden_bias)
static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Tensor>	_thnn_fused_lstm_cell_backward(scala.Option<Tensor> grad_hy, scala.Option<Tensor> grad_cy, Tensor cx, Tensor cy, Tensor workspace, boolean has_bias)
static Tensor	_trilinear(Tensor i1, Tensor i2, Tensor i3, long[] expand1, long[] expand2, long[] expand3, long[] sumdim, long unroll_dim)
static scala.Tuple2<Tensor,Tensor>	_unique(Tensor self, boolean sorted, boolean return_inverse)
static scala.Tuple3<Tensor,Tensor,Tensor>	_unique2(Tensor self, boolean sorted, boolean return_inverse, boolean return_counts)
static Tensor	_unsafe_view(Tensor self, long[] size)
static void	_validate_sparse_coo_tensor_args(Tensor indices, Tensor values, long[] size)
static Tensor	_weight_norm(Tensor v, Tensor g, long dim)
static scala.Tuple2<Tensor,Tensor>	_weight_norm_differentiable_backward(Tensor grad_w, Tensor saved_v, Tensor saved_g, Tensor saved_norms, long dim)
static Tensor	abs(Tensor self)
static void	abs_(Tensor self)
static void	abs_out(Tensor out, Tensor self)
static Tensor	absolute(Tensor self)
static void	absolute_out(Tensor out, Tensor self)
static Tensor	acos(Tensor self)
static void	acos_(Tensor self)
static void	acos_out(Tensor out, Tensor self)
static Tensor	acosh(Tensor self)
static void	acosh_(Tensor self)
static void	acosh_out(Tensor out, Tensor self)
static Tensor	adaptive_avg_pool1d(Tensor self, long[] output_size)
static Tensor	adaptive_avg_pool2d(Tensor self, long[] output_size)
static void	adaptive_avg_pool2d_out(Tensor out, Tensor self, long[] output_size)
static Tensor	adaptive_avg_pool3d(Tensor self, long[] output_size)
static void	adaptive_avg_pool3d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self)
static void	adaptive_avg_pool3d_out(Tensor out, Tensor self, long[] output_size)
static scala.Tuple2<Tensor,Tensor>	adaptive_max_pool1d(Tensor self, long[] output_size)
static scala.Tuple2<Tensor,Tensor>	adaptive_max_pool2d(Tensor self, long[] output_size)
static Tensor	adaptive_max_pool2d_backward(Tensor grad_output, Tensor self, Tensor indices)
static void	adaptive_max_pool2d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor indices)
static scala.Tuple2<Tensor,Tensor>	adaptive_max_pool2d_out(Tensor out, Tensor indices, Tensor self, long[] output_size)
static scala.Tuple2<Tensor,Tensor>	adaptive_max_pool3d(Tensor self, long[] output_size)
static Tensor	adaptive_max_pool3d_backward(Tensor grad_output, Tensor self, Tensor indices)
static void	adaptive_max_pool3d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor indices)
static scala.Tuple2<Tensor,Tensor>	adaptive_max_pool3d_out(Tensor out, Tensor indices, Tensor self, long[] output_size)
static Tensor	add_0(Tensor self, Tensor other, double alpha)
static Tensor	add_0_l(Tensor self, Tensor other, long alpha)
static Tensor	add_1(Tensor self, double other, double alpha)
static Tensor	add_1_l(Tensor self, long other, long alpha)
static void	add_out(Tensor out, Tensor self, Tensor other, double alpha)
static void	add_out_l(Tensor out, Tensor self, Tensor other, long alpha)
static Tensor	addbmm(Tensor self, Tensor batch1, Tensor batch2, double beta, double alpha)
static Tensor	addbmm_l(Tensor self, Tensor batch1, Tensor batch2, long beta, long alpha)
static void	addbmm_out(Tensor out, Tensor self, Tensor batch1, Tensor batch2, double beta, double alpha)
static void	addbmm_out_l(Tensor out, Tensor self, Tensor batch1, Tensor batch2, long beta, long alpha)
static Tensor	addcdiv(Tensor self, Tensor tensor1, Tensor tensor2, double value)
static Tensor	addcdiv_l(Tensor self, Tensor tensor1, Tensor tensor2, long value)
static void	addcdiv_out(Tensor out, Tensor self, Tensor tensor1, Tensor tensor2, double value)
static void	addcdiv_out_l(Tensor out, Tensor self, Tensor tensor1, Tensor tensor2, long value)
static Tensor	addcmul(Tensor self, Tensor tensor1, Tensor tensor2, double value)
static Tensor	addcmul_l(Tensor self, Tensor tensor1, Tensor tensor2, long value)
static void	addcmul_out(Tensor out, Tensor self, Tensor tensor1, Tensor tensor2, double value)
static void	addcmul_out_l(Tensor out, Tensor self, Tensor tensor1, Tensor tensor2, long value)
static Tensor	addmm(Tensor self, Tensor mat1, Tensor mat2, double beta, double alpha)
static Tensor	addmm_l(Tensor self, Tensor mat1, Tensor mat2, long beta, long alpha)
static void	addmm_out(Tensor out, Tensor self, Tensor mat1, Tensor mat2, double beta, double alpha)
static void	addmm_out_l(Tensor out, Tensor self, Tensor mat1, Tensor mat2, long beta, long alpha)
static Tensor	addmv(Tensor self, Tensor mat, Tensor vec, double beta, double alpha)
static void	addmv_(Tensor self, Tensor mat, Tensor vec, double beta, double alpha)
static void	addmv__l(Tensor self, Tensor mat, Tensor vec, long beta, long alpha)
static Tensor	addmv_l(Tensor self, Tensor mat, Tensor vec, long beta, long alpha)
static void	addmv_out(Tensor out, Tensor self, Tensor mat, Tensor vec, double beta, double alpha)
static void	addmv_out_l(Tensor out, Tensor self, Tensor mat, Tensor vec, long beta, long alpha)
static Tensor	addr(Tensor self, Tensor vec1, Tensor vec2, double beta, double alpha)
static Tensor	addr_l(Tensor self, Tensor vec1, Tensor vec2, long beta, long alpha)
static void	addr_out(Tensor out, Tensor self, Tensor vec1, Tensor vec2, double beta, double alpha)
static void	addr_out_l(Tensor out, Tensor self, Tensor vec1, Tensor vec2, long beta, long alpha)
static Tensor	affine_grid_generator(Tensor theta, long[] size, boolean align_corners)
static Tensor	affine_grid_generator_backward(Tensor grad, long[] size, boolean align_corners)
static Tensor	alias(Tensor self)
static Tensor[]	align_tensors(Tensor[] tensors)
static Tensor	all_0(Tensor self, long dim, boolean keepdim)
static Tensor	all_1(Tensor self)
static void	all_out(Tensor out, Tensor self, long dim, boolean keepdim)
static boolean	allclose(Tensor self, Tensor other, double rtol, double atol, boolean equal_nan)
static Tensor	alpha_dropout(Tensor input, double p, boolean train)
static void	alpha_dropout_(Tensor self, double p, boolean train)
static Tensor	amax(Tensor self, long[] dim, boolean keepdim)
static void	amax_out(Tensor out, Tensor self, long[] dim, boolean keepdim)
static Tensor	amin(Tensor self, long[] dim, boolean keepdim)
static void	amin_out(Tensor out, Tensor self, long[] dim, boolean keepdim)
static Tensor	angle(Tensor self)
static void	angle_out(Tensor out, Tensor self)
static Tensor	any_0(Tensor self, long dim, boolean keepdim)
static Tensor	any_1(Tensor self)
static void	any_out(Tensor out, Tensor self, long dim, boolean keepdim)
static Tensor	arange_0(double end, TensorOptions options)
static Tensor	arange_0_l(long end, TensorOptions options)
static Tensor	arange_1(double start, double end, TensorOptions options)
static Tensor	arange_1_l(long start, long end, TensorOptions options)
static Tensor	arange_2(double start, double end, double step, TensorOptions options)
static Tensor	arange_2_l(long start, long end, long step, TensorOptions options)
static void	arange_out_0(Tensor out, double end)
static void	arange_out_0_l(Tensor out, long end)
static void	arange_out_1(Tensor out, double start, double end, double step)
static void	arange_out_1_l(Tensor out, long start, long end, long step)
static Tensor	arccos(Tensor self)
static void	arccos_(Tensor self)
static void	arccos_out(Tensor out, Tensor self)
static Tensor	arccosh(Tensor self)
static void	arccosh_(Tensor self)
static void	arccosh_out(Tensor out, Tensor self)
static Tensor	arcsin(Tensor self)
static void	arcsin_(Tensor self)
static void	arcsin_out(Tensor out, Tensor self)
static Tensor	arcsinh(Tensor self)
static void	arcsinh_(Tensor self)
static void	arcsinh_out(Tensor out, Tensor self)
static Tensor	arctan(Tensor self)
static void	arctan_(Tensor self)
static void	arctan_out(Tensor out, Tensor self)
static Tensor	arctanh(Tensor self)
static void	arctanh_(Tensor self)
static void	arctanh_out(Tensor out, Tensor self)
static Tensor	argmax(Tensor self, long dim, boolean keepdim)
static void	argmax_out(Tensor out, Tensor self, long dim, boolean keepdim)
static Tensor	argmin(Tensor self, long dim, boolean keepdim)
static void	argmin_out(Tensor out, Tensor self, long dim, boolean keepdim)
static Tensor	argsort(Tensor self, boolean stable, long dim, boolean descending)
static Tensor	as_strided(Tensor self, long[] size, long[] stride, long storage_offset)
static void	as_strided_(Tensor self, long[] size, long[] stride, long storage_offset)
static Tensor	asin(Tensor self)
static void	asin_(Tensor self)
static void	asin_out(Tensor out, Tensor self)
static Tensor	asinh(Tensor self)
static void	asinh_(Tensor self)
static void	asinh_out(Tensor out, Tensor self)
static Tensor	atan(Tensor self)
static void	atan_(Tensor self)
static void	atan_out(Tensor out, Tensor self)
static Tensor	atan2(Tensor self, Tensor other)
static void	atan2_out(Tensor out, Tensor self, Tensor other)
static Tensor	atanh(Tensor self)
static void	atanh_(Tensor self)
static void	atanh_out(Tensor out, Tensor self)
static Tensor	atleast_1d_0(Tensor self)
static Tensor[]	atleast_1d_1(Tensor[] tensors)
static Tensor	atleast_2d_0(Tensor self)
static Tensor[]	atleast_2d_1(Tensor[] tensors)
static Tensor	atleast_3d_0(Tensor self)
static Tensor[]	atleast_3d_1(Tensor[] tensors)
static Tensor	avg_pool1d(Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad)
static Tensor	avg_pool2d(Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad, long divisor_override)
static Tensor	avg_pool2d_backward(Tensor grad_output, Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad, long divisor_override)
static void	avg_pool2d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad, long divisor_override)
static void	avg_pool2d_out(Tensor out, Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad, long divisor_override)
static Tensor	avg_pool3d(Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad, long divisor_override)
static Tensor	avg_pool3d_backward(Tensor grad_output, Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad, long divisor_override)
static void	avg_pool3d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad, long divisor_override)
static void	avg_pool3d_out(Tensor out, Tensor self, long[] kernel_size, long[] stride, long[] padding, boolean ceil_mode, boolean count_include_pad, long divisor_override)
static Tensor	baddbmm(Tensor self, Tensor batch1, Tensor batch2, double beta, double alpha)
static Tensor	baddbmm_l(Tensor self, Tensor batch1, Tensor batch2, long beta, long alpha)
static void	baddbmm_out(Tensor out, Tensor self, Tensor batch1, Tensor batch2, double beta, double alpha)
static void	baddbmm_out_l(Tensor out, Tensor self, Tensor batch1, Tensor batch2, long beta, long alpha)
static Tensor	bartlett_window_0(long window_length, TensorOptions options)
static Tensor	bartlett_window_1(long window_length, boolean periodic, TensorOptions options)
static Tensor	batch_norm(Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, boolean training, double momentum, double eps, boolean cudnn_enabled)
static Tensor	batch_norm_backward_elemt(Tensor grad_out, Tensor input, Tensor mean, Tensor invstd, scala.Option<Tensor> weight, Tensor mean_dy, Tensor mean_dy_xmu, Tensor count)
static scala.Tuple4<Tensor,Tensor,Tensor,Tensor>	batch_norm_backward_reduce(Tensor grad_out, Tensor input, Tensor mean, Tensor invstd, scala.Option<Tensor> weight, boolean input_g, boolean weight_g, boolean bias_g)
static Tensor	batch_norm_elemt(Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, Tensor mean, Tensor invstd, double eps)
static void	batch_norm_elemt_out(Tensor out, Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, Tensor mean, Tensor invstd, double eps)
static scala.Tuple2<Tensor,Tensor>	batch_norm_gather_stats(Tensor input, Tensor mean, Tensor invstd, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, double momentum, double eps, long count)
static scala.Tuple2<Tensor,Tensor>	batch_norm_gather_stats_with_counts(Tensor input, Tensor mean, Tensor invstd, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, double momentum, double eps, Tensor counts)
static scala.Tuple2<Tensor,Tensor>	batch_norm_stats(Tensor input, double eps)
static scala.Tuple2<Tensor,Tensor>	batch_norm_update_stats(Tensor input, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, double momentum)
static Tensor	bernoulli_0(Tensor self)
static Tensor	bernoulli_1(Tensor self, double p)
static void	bernoulli_out(Tensor out, Tensor self)
static Tensor	bilinear(Tensor input1, Tensor input2, Tensor weight, scala.Option<Tensor> bias)
static Tensor	binary_cross_entropy(Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction)
static Tensor	binary_cross_entropy_backward(Tensor grad_output, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction)
static void	binary_cross_entropy_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction)
static void	binary_cross_entropy_out(Tensor out, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction)
static Tensor	binary_cross_entropy_with_logits(Tensor self, Tensor target, scala.Option<Tensor> weight, scala.Option<Tensor> pos_weight, long reduction)
static Tensor	bincount(Tensor self, scala.Option<Tensor> weights, long minlength)
static Tensor	binomial(Tensor count, Tensor prob)
static Tensor	bitwise_and_0(Tensor self, double other)
static Tensor	bitwise_and_0_l(Tensor self, long other)
static Tensor	bitwise_and_1(Tensor self, Tensor other)
static void	bitwise_and_out_0(Tensor out, Tensor self, Tensor other)
static void	bitwise_and_out_1(Tensor out, Tensor self, double other)
static void	bitwise_and_out_1_l(Tensor out, Tensor self, long other)
static Tensor	bitwise_not(Tensor self)
static void	bitwise_not_out(Tensor out, Tensor self)
static Tensor	bitwise_or_0(Tensor self, double other)
static Tensor	bitwise_or_0_l(Tensor self, long other)
static Tensor	bitwise_or_1(Tensor self, Tensor other)
static void	bitwise_or_out_0(Tensor out, Tensor self, Tensor other)
static void	bitwise_or_out_1(Tensor out, Tensor self, double other)
static void	bitwise_or_out_1_l(Tensor out, Tensor self, long other)
static Tensor	bitwise_xor_0(Tensor self, double other)
static Tensor	bitwise_xor_0_l(Tensor self, long other)
static Tensor	bitwise_xor_1(Tensor self, Tensor other)
static void	bitwise_xor_out_0(Tensor out, Tensor self, Tensor other)
static void	bitwise_xor_out_1(Tensor out, Tensor self, double other)
static void	bitwise_xor_out_1_l(Tensor out, Tensor self, long other)
static Tensor	blackman_window_0(long window_length, TensorOptions options)
static Tensor	blackman_window_1(long window_length, boolean periodic, TensorOptions options)
static Tensor	block_diag(Tensor[] tensors)
static Tensor	bmm(Tensor self, Tensor mat2)
static void	bmm_out(Tensor out, Tensor self, Tensor mat2)
static Tensor[]	broadcast_tensors(Tensor[] tensors)
static Tensor	broadcast_to(Tensor self, long[] size)
static Tensor	bucketize_0(Tensor self, Tensor boundaries, boolean out_int32, boolean right)
static Tensor	bucketize_1(double self, Tensor boundaries, boolean out_int32, boolean right)
static Tensor	bucketize_1_l(long self, Tensor boundaries, boolean out_int32, boolean right)
static void	bucketize_out(Tensor out, Tensor self, Tensor boundaries, boolean out_int32, boolean right)
static boolean	can_cast(byte from, byte to)
static Tensor	cartesian_prod(Tensor[] tensors)
static Tensor	cat(Tensor[] tensors, long dim)
static void	cat_out(Tensor out, Tensor[] tensors, long dim)
static Tensor	cdist(Tensor x1, Tensor x2, double p, long compute_mode)
static Tensor	ceil(Tensor self)
static void	ceil_(Tensor self)
static void	ceil_out(Tensor out, Tensor self)
static Tensor	celu(Tensor self, double alpha)
static void	celu_(Tensor self, double alpha)
static void	celu__l(Tensor self, long alpha)
static Tensor	celu_l(Tensor self, long alpha)
static Tensor	chain_matmul(Tensor[] matrices)
static void	chain_matmul_out(Tensor out, Tensor[] matrices)
static Tensor	channel_shuffle(Tensor self, long groups)
static Tensor	cholesky(Tensor self, boolean upper)
static Tensor	cholesky_inverse(Tensor self, boolean upper)
static void	cholesky_inverse_out(Tensor out, Tensor self, boolean upper)
static void	cholesky_out(Tensor out, Tensor self, boolean upper)
static Tensor	cholesky_solve(Tensor self, Tensor input2, boolean upper)
static void	cholesky_solve_out(Tensor out, Tensor self, Tensor input2, boolean upper)
static scala.Tuple2<Tensor,Tensor>	choose_qparams_optimized(Tensor input, long numel, long n_bins, double ratio, long bit_width)
static Tensor[]	chunk(Tensor self, long chunks, long dim)
static void	clamp__0(Tensor self, double min, double max)
static void	clamp__1(Tensor self, scala.Option<Tensor> min, scala.Option<Tensor> max)
static Tensor	clamp_0(Tensor self, double min, double max)
static Tensor	clamp_1(Tensor self, scala.Option<Tensor> min, scala.Option<Tensor> max)
static void	clamp_max__0(Tensor self, double max)
static void	clamp_max__0_l(Tensor self, long max)
static void	clamp_max__1(Tensor self, Tensor max)
static Tensor	clamp_max_0(Tensor self, double max)
static Tensor	clamp_max_0_l(Tensor self, long max)
static Tensor	clamp_max_1(Tensor self, Tensor max)
static void	clamp_max_out_0(Tensor out, Tensor self, double max)
static void	clamp_max_out_0_l(Tensor out, Tensor self, long max)
static void	clamp_max_out_1(Tensor out, Tensor self, Tensor max)
static void	clamp_min__0(Tensor self, double min)
static void	clamp_min__0_l(Tensor self, long min)
static void	clamp_min__1(Tensor self, Tensor min)
static Tensor	clamp_min_0(Tensor self, double min)
static Tensor	clamp_min_0_l(Tensor self, long min)
static Tensor	clamp_min_1(Tensor self, Tensor min)
static void	clamp_min_out_0(Tensor out, Tensor self, double min)
static void	clamp_min_out_0_l(Tensor out, Tensor self, long min)
static void	clamp_min_out_1(Tensor out, Tensor self, Tensor min)
static void	clamp_out_0(Tensor out, Tensor self, double min, double max)
static void	clamp_out_1(Tensor out, Tensor self, scala.Option<Tensor> min, scala.Option<Tensor> max)
static void	clip__0(Tensor self, double min, double max)
static void	clip__1(Tensor self, scala.Option<Tensor> min, scala.Option<Tensor> max)
static Tensor	clip_0(Tensor self, double min, double max)
static Tensor	clip_1(Tensor self, scala.Option<Tensor> min, scala.Option<Tensor> max)
static void	clip_out_0(Tensor out, Tensor self, double min, double max)
static void	clip_out_1(Tensor out, Tensor self, scala.Option<Tensor> min, scala.Option<Tensor> max)
static Tensor	clone(Tensor self)
static Tensor	col2im(Tensor self, long[] output_size, long[] kernel_size, long[] dilation, long[] padding, long[] stride)
static void	col2im_out(Tensor out, Tensor self, long[] output_size, long[] kernel_size, long[] dilation, long[] padding, long[] stride)
static Tensor	column_stack(Tensor[] tensors)
static void	column_stack_out(Tensor out, Tensor[] tensors)
static Tensor	combinations(Tensor self, long r, boolean with_replacement)
static Tensor	complex(Tensor real, Tensor imag)
static void	complex_out(Tensor out, Tensor real, Tensor imag)
static Tensor	conj(Tensor self)
static Tensor	constant_pad_nd(Tensor self, long[] pad, double value)
static Tensor	constant_pad_nd_l(Tensor self, long[] pad, long value)
static Tensor	conv_tbc(Tensor self, Tensor weight, Tensor bias, long pad)
static scala.Tuple3<Tensor,Tensor,Tensor>	conv_tbc_backward(Tensor self, Tensor input, Tensor weight, Tensor bias, long pad)
static Tensor	conv_transpose1d(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, long[] padding, long[] output_padding, long groups, long[] dilation)
static Tensor	conv_transpose2d(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, long[] padding, long[] output_padding, long groups, long[] dilation)
static Tensor	conv_transpose3d(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, long[] padding, long[] output_padding, long groups, long[] dilation)
static Tensor	conv1d_0(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, long[] padding, long[] dilation, long groups)
static Tensor	conv1d_1(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, String padding, long[] dilation, long groups)
static Tensor	conv2d_0(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, long[] padding, long[] dilation, long groups)
static Tensor	conv2d_1(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, String padding, long[] dilation, long groups)
static Tensor	conv3d_0(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, long[] padding, long[] dilation, long groups)
static Tensor	conv3d_1(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, String padding, long[] dilation, long groups)
static Tensor	convolution(Tensor input, Tensor weight, scala.Option<Tensor> bias, long[] stride, long[] padding, long[] dilation, boolean transposed, long[] output_padding, long groups)
static scala.Tuple3<Tensor,Tensor,Tensor>	convolution_backward(Tensor grad_output, Tensor input, Tensor weight, scala.Option<long[]> bias_sizes, long[] stride, long[] padding, long[] dilation, boolean transposed, long[] output_padding, long groups, boolean[] output_mask)
static void	copy_sparse_to_sparse_(Tensor self, Tensor src, boolean non_blocking)
static Tensor	copysign_0(Tensor self, Tensor other)
static Tensor	copysign_1(Tensor self, double other)
static Tensor	copysign_1_l(Tensor self, long other)
static void	copysign_out_0(Tensor out, Tensor self, Tensor other)
static void	copysign_out_1(Tensor out, Tensor self, double other)
static void	copysign_out_1_l(Tensor out, Tensor self, long other)
static Tensor	cos(Tensor self)
static void	cos_(Tensor self)
static void	cos_out(Tensor out, Tensor self)
static Tensor	cosh(Tensor self)
static void	cosh_(Tensor self)
static void	cosh_out(Tensor out, Tensor self)
static Tensor	cosine_embedding_loss(Tensor input1, Tensor input2, Tensor target, double margin, long reduction)
static Tensor	cosine_similarity(Tensor x1, Tensor x2, long dim, double eps)
static Tensor	count_nonzero_0(Tensor self, long[] dim)
static Tensor	count_nonzero_1(Tensor self, long dim)
static Tensor	cross(Tensor self, Tensor other, long dim)
static Tensor	cross_entropy_loss(Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static void	cross_out(Tensor out, Tensor self, Tensor other, long dim)
static Tensor	ctc_loss_0(Tensor log_probs, Tensor targets, long[] input_lengths, long[] target_lengths, long blank, long reduction, boolean zero_infinity)
static Tensor	ctc_loss_1(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, long blank, long reduction, boolean zero_infinity)
static Tensor	cudnn_affine_grid_generator(Tensor theta, long N, long C, long H, long W)
static Tensor	cudnn_affine_grid_generator_backward(Tensor grad, long N, long C, long H, long W)
static scala.Tuple4<Tensor,Tensor,Tensor,Tensor>	cudnn_batch_norm(Tensor input, Tensor weight, scala.Option<Tensor> bias, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, boolean training, double exponential_average_factor, double epsilon)
static scala.Tuple3<Tensor,Tensor,Tensor>	cudnn_batch_norm_backward(Tensor input, Tensor grad_output, Tensor weight, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, scala.Option<Tensor> save_mean, scala.Option<Tensor> save_var, double epsilon, Tensor reserveSpace)
static Tensor	cudnn_grid_sampler(Tensor self, Tensor grid)
static scala.Tuple2<Tensor,Tensor>	cudnn_grid_sampler_backward(Tensor self, Tensor grid, Tensor grad_output)
static boolean	cudnn_is_acceptable(Tensor self)
static scala.Tuple2<Tensor,Tensor>	cummax(Tensor self, long dim)
static scala.Tuple2<Tensor,Tensor>	cummax_out(Tensor values, Tensor indices, Tensor self, long dim)
static Tensor	cummaxmin_backward(Tensor grad, Tensor input, Tensor indices, long dim)
static scala.Tuple2<Tensor,Tensor>	cummin(Tensor self, long dim)
static scala.Tuple2<Tensor,Tensor>	cummin_out(Tensor values, Tensor indices, Tensor self, long dim)
static Tensor	cumprod(Tensor self, long dim)
static Tensor	cumprod_backward(Tensor grad, Tensor input, long dim, Tensor output)
static void	cumprod_out(Tensor out, Tensor self, long dim)
static Tensor	cumsum(Tensor self, long dim)
static void	cumsum_out(Tensor out, Tensor self, long dim)
static Tensor	deg2rad(Tensor self)
static void	deg2rad_(Tensor self)
static void	deg2rad_out(Tensor out, Tensor self)
static Tensor	dequantize_0(Tensor self)
static Tensor[]	dequantize_1(Tensor[] tensors)
static Tensor	det(Tensor self)
static Tensor	detach(Tensor self)
static void	detach_(Tensor self)
static Tensor	diag(Tensor self, long diagonal)
static Tensor	diag_embed(Tensor self, long offset, long dim1, long dim2)
static void	diag_out(Tensor out, Tensor self, long diagonal)
static Tensor	diagflat(Tensor self, long offset)
static Tensor	diagonal(Tensor self, long offset, long dim1, long dim2)
static Tensor	diagonal_backward(Tensor grad, long[] input_sizes, long offset, long dim1, long dim2)
static Tensor	diff(Tensor self, long n, long dim, scala.Option<Tensor> prepend, scala.Option<Tensor> append)
static void	diff_out(Tensor out, Tensor self, long n, long dim, scala.Option<Tensor> prepend, scala.Option<Tensor> append)
static Tensor	digamma(Tensor self)
static void	digamma_out(Tensor out, Tensor self)
static Tensor	dist(Tensor self, Tensor other, double p)
static Tensor	dist_l(Tensor self, Tensor other, long p)
static Tensor	div_0(Tensor self, Tensor other)
static Tensor	div_1(Tensor self, double other)
static Tensor	div_1_l(Tensor self, long other)
static Tensor	div_2(Tensor self, double other)
static Tensor	div_2_l(Tensor self, long other)
static void	div_out(Tensor out, Tensor self, Tensor other)
static Tensor	divide_0(Tensor self, Tensor other)
static Tensor	divide_1(Tensor self, double other)
static Tensor	divide_1_l(Tensor self, long other)
static void	divide_out(Tensor out, Tensor self, Tensor other)
static Tensor	dot(Tensor self, Tensor tensor)
static void	dot_out(Tensor out, Tensor self, Tensor tensor)
static Tensor	dropout(Tensor input, double p, boolean train)
static void	dropout_(Tensor self, double p, boolean train)
static Tensor[]	dsplit_0(Tensor self, long sections)
static Tensor[]	dsplit_1(Tensor self, long[] indices)
static Tensor	dstack(Tensor[] tensors)
static void	dstack_out(Tensor out, Tensor[] tensors)
static Tensor	einsum(String equation, Tensor[] tensors)
static Tensor	elu(Tensor self, double alpha, double scale, double input_scale)
static void	elu_(Tensor self, double alpha, double scale, double input_scale)
static void	elu__l(Tensor self, long alpha, long scale, long input_scale)
static Tensor	elu_backward(Tensor grad_output, double alpha, double scale, double input_scale, boolean is_result, Tensor self_or_result)
static Tensor	elu_backward_l(Tensor grad_output, long alpha, long scale, long input_scale, boolean is_result, Tensor self_or_result)
static Tensor	elu_l(Tensor self, long alpha, long scale, long input_scale)
static void	elu_out(Tensor out, Tensor self, double alpha, double scale, double input_scale)
static void	elu_out_l(Tensor out, Tensor self, long alpha, long scale, long input_scale)
static Tensor	embedding(Tensor weight, Tensor indices, long padding_idx, boolean scale_grad_by_freq, boolean sparse)
static Tensor	embedding_backward(Tensor grad, Tensor indices, long num_weights, long padding_idx, boolean scale_grad_by_freq, boolean sparse)
static scala.Tuple4<Tensor,Tensor,Tensor,Tensor>	embedding_bag_0(Tensor weight, Tensor indices, Tensor offsets, boolean scale_grad_by_freq, long mode, boolean sparse, scala.Option<Tensor> per_sample_weights, boolean include_last_offset)
static scala.Tuple4<Tensor,Tensor,Tensor,Tensor>	embedding_bag_1(Tensor weight, Tensor indices, Tensor offsets, boolean scale_grad_by_freq, long mode, boolean sparse, scala.Option<Tensor> per_sample_weights, boolean include_last_offset, long padding_idx)
static Tensor	embedding_dense_backward(Tensor grad_output, Tensor indices, long num_weights, long padding_idx, boolean scale_grad_by_freq)
static void	embedding_renorm_(Tensor self, Tensor indices, double max_norm, double norm_type)
static Tensor	embedding_sparse_backward(Tensor grad, Tensor indices, long num_weights, long padding_idx, boolean scale_grad_by_freq)
static Tensor	empty(long[] size, TensorOptions options)
static Tensor	empty_like(Tensor self, TensorOptions options)
static void	empty_out(Tensor out, long[] size)
static Tensor	empty_quantized(long[] size, Tensor qtensor)
static Tensor	empty_strided(long[] size, long[] stride, TensorOptions options)
static Tensor	eq_0(Tensor self, double other)
static Tensor	eq_0_l(Tensor self, long other)
static Tensor	eq_1(Tensor self, Tensor other)
static void	eq_out_0(Tensor out, Tensor self, double other)
static void	eq_out_0_l(Tensor out, Tensor self, long other)
static void	eq_out_1(Tensor out, Tensor self, Tensor other)
static boolean	equal(Tensor self, Tensor other)
static Tensor	erf(Tensor self)
static void	erf_(Tensor self)
static void	erf_out(Tensor out, Tensor self)
static Tensor	erfc(Tensor self)
static void	erfc_(Tensor self)
static void	erfc_out(Tensor out, Tensor self)
static Tensor	erfinv(Tensor self)
static void	erfinv_out(Tensor out, Tensor self)
static Tensor	exp(Tensor self)
static void	exp_(Tensor self)
static void	exp_out(Tensor out, Tensor self)
static Tensor	exp2(Tensor self)
static void	exp2_(Tensor self)
static void	exp2_out(Tensor out, Tensor self)
static Tensor	expm1(Tensor self)
static void	expm1_(Tensor self)
static void	expm1_out(Tensor out, Tensor self)
static Tensor	eye_0(long n, TensorOptions options)
static Tensor	eye_1(long n, long m, TensorOptions options)
static void	eye_out_0(Tensor out, long n)
static void	eye_out_1(Tensor out, long n, long m)
static Tensor	fake_quantize_per_channel_affine(Tensor self, Tensor scale, Tensor zero_point, long axis, long quant_min, long quant_max)
static scala.Tuple2<Tensor,Tensor>	fake_quantize_per_channel_affine_cachemask(Tensor self, Tensor scale, Tensor zero_point, long axis, long quant_min, long quant_max)
static Tensor	fake_quantize_per_channel_affine_cachemask_backward(Tensor grad, Tensor mask)
static Tensor	fake_quantize_per_tensor_affine(Tensor self, double scale, long zero_point, long quant_min, long quant_max)
static scala.Tuple2<Tensor,Tensor>	fake_quantize_per_tensor_affine_cachemask(Tensor self, double scale, long zero_point, long quant_min, long quant_max)
static Tensor	fake_quantize_per_tensor_affine_cachemask_backward(Tensor grad, Tensor mask)
static Tensor	fbgemm_linear_fp16_weight(Tensor input, Tensor packed_weight, Tensor bias)
static Tensor	fbgemm_linear_fp16_weight_fp32_activation(Tensor input, Tensor packed_weight, Tensor bias)
static Tensor	fbgemm_linear_int8_weight(Tensor input, Tensor weight, Tensor packed, Tensor col_offsets, double weight_scale, double weight_zero_point, Tensor bias)
static Tensor	fbgemm_linear_int8_weight_fp32_activation(Tensor input, Tensor weight, Tensor packed, Tensor col_offsets, double weight_scale, double weight_zero_point, Tensor bias)
static Tensor	fbgemm_linear_int8_weight_fp32_activation_l(Tensor input, Tensor weight, Tensor packed, Tensor col_offsets, long weight_scale, long weight_zero_point, Tensor bias)
static Tensor	fbgemm_linear_int8_weight_l(Tensor input, Tensor weight, Tensor packed, Tensor col_offsets, long weight_scale, long weight_zero_point, Tensor bias)
static scala.Tuple4<Tensor,Tensor,Double,Long>	fbgemm_linear_quantize_weight(Tensor input)
static Tensor	fbgemm_pack_gemm_matrix_fp16(Tensor input)
static Tensor	fbgemm_pack_quantized_matrix_0(Tensor input)
static Tensor	fbgemm_pack_quantized_matrix_1(Tensor input, long K, long N)
static Tensor	feature_alpha_dropout(Tensor input, double p, boolean train)
static void	feature_alpha_dropout_(Tensor self, double p, boolean train)
static Tensor	feature_dropout(Tensor input, double p, boolean train)
static void	feature_dropout_(Tensor self, double p, boolean train)
static Tensor	fft_fft(Tensor self, long n, long dim)
static void	fft_fft_out(Tensor out, Tensor self, long n, long dim)
static Tensor	fft_fft2(Tensor self, long[] dim)
static void	fft_fft2_out(Tensor out, Tensor self, long[] dim)
static Tensor	fft_fftfreq(long n, double d, TensorOptions options)
static void	fft_fftfreq_out(Tensor out, long n, double d)
static Tensor	fft_fftn(Tensor self)
static void	fft_fftn_out(Tensor out, Tensor self)
static Tensor	fft_fftshift(Tensor self)
static Tensor	fft_hfft(Tensor self, long n, long dim)
static void	fft_hfft_out(Tensor out, Tensor self, long n, long dim)
static Tensor	fft_ifft(Tensor self, long n, long dim)
static void	fft_ifft_out(Tensor out, Tensor self, long n, long dim)
static Tensor	fft_ifft2(Tensor self, long[] dim)
static void	fft_ifft2_out(Tensor out, Tensor self, long[] dim)
static Tensor	fft_ifftn(Tensor self)
static void	fft_ifftn_out(Tensor out, Tensor self)
static Tensor	fft_ifftshift(Tensor self)
static Tensor	fft_ihfft(Tensor self, long n, long dim)
static void	fft_ihfft_out(Tensor out, Tensor self, long n, long dim)
static Tensor	fft_irfft(Tensor self, long n, long dim)
static void	fft_irfft_out(Tensor out, Tensor self, long n, long dim)
static Tensor	fft_irfft2(Tensor self, long[] dim)
static void	fft_irfft2_out(Tensor out, Tensor self, long[] dim)
static Tensor	fft_irfftn(Tensor self)
static void	fft_irfftn_out(Tensor out, Tensor self)
static Tensor	fft_rfft(Tensor self, long n, long dim)
static void	fft_rfft_out(Tensor out, Tensor self, long n, long dim)
static Tensor	fft_rfft2(Tensor self, long[] dim)
static void	fft_rfft2_out(Tensor out, Tensor self, long[] dim)
static Tensor	fft_rfftfreq(long n, double d, TensorOptions options)
static void	fft_rfftfreq_out(Tensor out, long n, double d)
static Tensor	fft_rfftn(Tensor self)
static void	fft_rfftn_out(Tensor out, Tensor self)
static void	fill__0(Tensor self, double value)
static void	fill__0_l(Tensor self, long value)
static void	fill__1(Tensor self, Tensor value)
static Tensor	fix(Tensor self)
static void	fix_(Tensor self)
static void	fix_out(Tensor out, Tensor self)
static Tensor	flatten(Tensor self, long start_dim, long end_dim)
static Tensor	flatten_dense_tensors(Tensor[] tensors)
static Tensor	flip(Tensor self, long[] dims)
static Tensor	fliplr(Tensor self)
static Tensor	flipud(Tensor self)
static Tensor	float_power_0(Tensor self, Tensor exponent)
static Tensor	float_power_1(double self, Tensor exponent)
static Tensor	float_power_1_l(long self, Tensor exponent)
static Tensor	float_power_2(Tensor self, double exponent)
static Tensor	float_power_2_l(Tensor self, long exponent)
static void	float_power_out_0(Tensor out, Tensor self, Tensor exponent)
static void	float_power_out_1(Tensor out, double self, Tensor exponent)
static void	float_power_out_1_l(Tensor out, long self, Tensor exponent)
static void	float_power_out_2(Tensor out, Tensor self, double exponent)
static void	float_power_out_2_l(Tensor out, Tensor self, long exponent)
static Tensor	floor(Tensor self)
static void	floor_(Tensor self)
static Tensor	floor_divide_0(Tensor self, Tensor other)
static Tensor	floor_divide_1(Tensor self, double other)
static Tensor	floor_divide_1_l(Tensor self, long other)
static void	floor_divide_out(Tensor out, Tensor self, Tensor other)
static void	floor_out(Tensor out, Tensor self)
static Tensor	fmax(Tensor self, Tensor other)
static void	fmax_out(Tensor out, Tensor self, Tensor other)
static Tensor	fmin(Tensor self, Tensor other)
static void	fmin_out(Tensor out, Tensor self, Tensor other)
static Tensor	fmod_0(Tensor self, double other)
static Tensor	fmod_0_l(Tensor self, long other)
static Tensor	fmod_1(Tensor self, Tensor other)
static void	fmod_out_0(Tensor out, Tensor self, double other)
static void	fmod_out_0_l(Tensor out, Tensor self, long other)
static void	fmod_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	frac(Tensor self)
static void	frac_(Tensor self)
static void	frac_out(Tensor out, Tensor self)
static scala.Tuple2<Tensor,Tensor>	fractional_max_pool2d(Tensor self, long[] kernel_size, long[] output_size, Tensor random_samples)
static Tensor	fractional_max_pool2d_backward(Tensor grad_output, Tensor self, long[] kernel_size, long[] output_size, Tensor indices)
static void	fractional_max_pool2d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] kernel_size, long[] output_size, Tensor indices)
static scala.Tuple2<Tensor,Tensor>	fractional_max_pool2d_out(Tensor output, Tensor indices, Tensor self, long[] kernel_size, long[] output_size, Tensor random_samples)
static scala.Tuple2<Tensor,Tensor>	fractional_max_pool3d(Tensor self, long[] kernel_size, long[] output_size, Tensor random_samples)
static Tensor	fractional_max_pool3d_backward(Tensor grad_output, Tensor self, long[] kernel_size, long[] output_size, Tensor indices)
static void	fractional_max_pool3d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] kernel_size, long[] output_size, Tensor indices)
static scala.Tuple2<Tensor,Tensor>	fractional_max_pool3d_out(Tensor output, Tensor indices, Tensor self, long[] kernel_size, long[] output_size, Tensor random_samples)
static scala.Tuple2<Tensor,Tensor>	frexp(Tensor self)
static scala.Tuple2<Tensor,Tensor>	frexp_out(Tensor mantissa, Tensor exponent, Tensor self)
static Tensor	frobenius_norm(Tensor self, long[] dim, boolean keepdim)
static void	frobenius_norm_out(Tensor out, Tensor self, long[] dim, boolean keepdim)
static Tensor	from_file(String filename, long size, TensorOptions options)
static Tensor	full(long[] size, double fill_value, TensorOptions options)
static Tensor	full_l(long[] size, long fill_value, TensorOptions options)
static Tensor	full_like(Tensor self, double fill_value, TensorOptions options)
static Tensor	full_like_l(Tensor self, long fill_value, TensorOptions options)
static void	full_out(Tensor out, long[] size, double fill_value)
static void	full_out_l(Tensor out, long[] size, long fill_value)
static Tensor	gather(Tensor self, long dim, Tensor index, boolean sparse_grad)
static Tensor	gather_backward(Tensor grad, Tensor self, long dim, Tensor index, boolean sparse_grad)
static void	gather_out(Tensor out, Tensor self, long dim, Tensor index, boolean sparse_grad)
static Tensor	gcd(Tensor self, Tensor other)
static void	gcd_(Tensor self, Tensor other)
static void	gcd_out(Tensor out, Tensor self, Tensor other)
static Tensor	ge_0(Tensor self, double other)
static Tensor	ge_0_l(Tensor self, long other)
static Tensor	ge_1(Tensor self, Tensor other)
static void	ge_out_0(Tensor out, Tensor self, double other)
static void	ge_out_0_l(Tensor out, Tensor self, long other)
static void	ge_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	gelu(Tensor self)
static Tensor	gelu_backward(Tensor grad, Tensor self)
static scala.Tuple2<Tensor,Tensor>	geqrf(Tensor self)
static scala.Tuple2<Tensor,Tensor>	geqrf_out(Tensor a, Tensor tau, Tensor self)
static Tensor	ger(Tensor self, Tensor vec2)
static void	ger_out(Tensor out, Tensor self, Tensor vec2)
static Tensor	glu(Tensor self, long dim)
static Tensor	glu_backward(Tensor grad_output, Tensor self, long dim)
static void	glu_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long dim)
static void	glu_out(Tensor out, Tensor self, long dim)
static Tensor[]	gradient_0(Tensor self, double spacing, long dim, long edge_order)
static Tensor[]	gradient_1(Tensor self, double spacing, long[] dim, long edge_order)
static Tensor[]	gradient_1_l(Tensor self, long spacing, long[] dim, long edge_order)
static Tensor[]	gradient_2(Tensor self, long[] dim, long edge_order)
static Tensor[]	gradient_3(Tensor self, Tensor[] spacing, long dim, long edge_order)
static Tensor[]	gradient_4(Tensor self, Tensor[] spacing, long[] dim, long edge_order)
static Tensor	greater_0(Tensor self, double other)
static Tensor	greater_0_l(Tensor self, long other)
static Tensor	greater_1(Tensor self, Tensor other)
static Tensor	greater_equal_0(Tensor self, double other)
static Tensor	greater_equal_0_l(Tensor self, long other)
static Tensor	greater_equal_1(Tensor self, Tensor other)
static void	greater_equal_out_0(Tensor out, Tensor self, double other)
static void	greater_equal_out_0_l(Tensor out, Tensor self, long other)
static void	greater_equal_out_1(Tensor out, Tensor self, Tensor other)
static void	greater_out_0(Tensor out, Tensor self, double other)
static void	greater_out_0_l(Tensor out, Tensor self, long other)
static void	greater_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	group_norm(Tensor input, long num_groups, scala.Option<Tensor> weight, scala.Option<Tensor> bias, double eps, boolean cudnn_enabled)
static scala.Tuple2<Tensor,Tensor>	gru_0(Tensor input, Tensor hx, Tensor[] params, boolean has_biases, long num_layers, double dropout, boolean train, boolean bidirectional, boolean batch_first)
static scala.Tuple2<Tensor,Tensor>	gru_1(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, boolean has_biases, long num_layers, double dropout, boolean train, boolean bidirectional)
static Tensor	gru_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, scala.Option<Tensor> b_ih, scala.Option<Tensor> b_hh)
static Tensor	gt_0(Tensor self, double other)
static Tensor	gt_0_l(Tensor self, long other)
static Tensor	gt_1(Tensor self, Tensor other)
static void	gt_out_0(Tensor out, Tensor self, double other)
static void	gt_out_0_l(Tensor out, Tensor self, long other)
static void	gt_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	hamming_window_0(long window_length, TensorOptions options)
static Tensor	hamming_window_1(long window_length, boolean periodic, TensorOptions options)
static Tensor	hamming_window_2(long window_length, boolean periodic, double alpha, TensorOptions options)
static Tensor	hamming_window_3(long window_length, boolean periodic, double alpha, double beta, TensorOptions options)
static Tensor	hann_window_0(long window_length, TensorOptions options)
static Tensor	hann_window_1(long window_length, boolean periodic, TensorOptions options)
static Tensor	hardshrink(Tensor self, double lambd)
static Tensor	hardshrink_backward(Tensor grad_out, Tensor self, double lambd)
static Tensor	hardshrink_backward_l(Tensor grad_out, Tensor self, long lambd)
static Tensor	hardshrink_l(Tensor self, long lambd)
static Tensor	hardsigmoid(Tensor self)
static void	hardsigmoid_(Tensor self)
static Tensor	hardsigmoid_backward(Tensor grad_output, Tensor self)
static void	hardsigmoid_out(Tensor out, Tensor self)
static Tensor	hardswish(Tensor self)
static void	hardswish_(Tensor self)
static Tensor	hardswish_backward(Tensor grad_output, Tensor self)
static void	hardswish_out(Tensor out, Tensor self)
static Tensor	hardtanh(Tensor self, double min_val, double max_val)
static void	hardtanh_(Tensor self, double min_val, double max_val)
static void	hardtanh__l(Tensor self, long min_val, long max_val)
static Tensor	hardtanh_backward(Tensor grad_output, Tensor self, double min_val, double max_val)
static Tensor	hardtanh_backward_l(Tensor grad_output, Tensor self, long min_val, long max_val)
static void	hardtanh_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, double min_val, double max_val)
static void	hardtanh_backward_out_l(Tensor grad_input, Tensor grad_output, Tensor self, long min_val, long max_val)
static Tensor	hardtanh_l(Tensor self, long min_val, long max_val)
static void	hardtanh_out(Tensor out, Tensor self, double min_val, double max_val)
static void	hardtanh_out_l(Tensor out, Tensor self, long min_val, long max_val)
static Tensor	heaviside(Tensor self, Tensor values)
static void	heaviside_out(Tensor out, Tensor self, Tensor values)
static Tensor	hinge_embedding_loss(Tensor self, Tensor target, double margin, long reduction)
static Tensor	histc(Tensor self, long bins, double min, double max)
static Tensor	histc_l(Tensor self, long bins, long min, long max)
static void	histc_out(Tensor out, Tensor self, long bins, double min, double max)
static void	histc_out_l(Tensor out, Tensor self, long bins, long min, long max)
static Tensor[]	hsplit_0(Tensor self, long sections)
static Tensor[]	hsplit_1(Tensor self, long[] indices)
static Tensor	hspmm(Tensor mat1, Tensor mat2)
static void	hspmm_out(Tensor out, Tensor mat1, Tensor mat2)
static Tensor	hstack(Tensor[] tensors)
static void	hstack_out(Tensor out, Tensor[] tensors)
static Tensor	huber_loss(Tensor self, Tensor target, long reduction, double delta)
static Tensor	huber_loss_backward(Tensor grad_output, Tensor self, Tensor target, long reduction, double delta)
static void	huber_loss_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, long reduction, double delta)
static void	huber_loss_out(Tensor out, Tensor self, Tensor target, long reduction, double delta)
static Tensor	hypot(Tensor self, Tensor other)
static void	hypot_out(Tensor out, Tensor self, Tensor other)
static Tensor	i0(Tensor self)
static void	i0_(Tensor self)
static void	i0_out(Tensor out, Tensor self)
static Tensor	igamma(Tensor self, Tensor other)
static void	igamma_out(Tensor out, Tensor self, Tensor other)
static Tensor	igammac(Tensor self, Tensor other)
static void	igammac_out(Tensor out, Tensor self, Tensor other)
static Tensor	im2col(Tensor self, long[] kernel_size, long[] dilation, long[] padding, long[] stride)
static void	im2col_out(Tensor out, Tensor self, long[] kernel_size, long[] dilation, long[] padding, long[] stride)
static Tensor	imag(Tensor self)
static Tensor	index(Tensor self, Tensor[] indices)
static Tensor	index_add_0(Tensor self, long dim, Tensor index, Tensor source)
static Tensor	index_add_1(Tensor self, long dim, Tensor index, Tensor source, double alpha)
static Tensor	index_add_1_l(Tensor self, long dim, Tensor index, Tensor source, long alpha)
static Tensor	index_copy(Tensor self, long dim, Tensor index, Tensor source)
static void	index_copy_out(Tensor out, Tensor self, long dim, Tensor index, Tensor source)
static Tensor	index_fill_0(Tensor self, long dim, Tensor index, double value)
static Tensor	index_fill_0_l(Tensor self, long dim, Tensor index, long value)
static Tensor	index_fill_1(Tensor self, long dim, Tensor index, Tensor value)
static Tensor	index_put(Tensor self, Tensor[] indices, Tensor values, boolean accumulate)
static void	index_put_(Tensor self, Tensor[] indices, Tensor values, boolean accumulate)
static Tensor	index_select(Tensor self, long dim, Tensor index)
static Tensor	index_select_backward(Tensor grad, long[] self_sizes, long dim, Tensor index)
static void	index_select_out(Tensor out, Tensor self, long dim, Tensor index)
static Tensor	infinitely_differentiable_gelu_backward(Tensor grad, Tensor self)
static Tensor	inner(Tensor self, Tensor other)
static void	inner_out(Tensor out, Tensor self, Tensor other)
static Tensor	instance_norm(Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, boolean use_input_stats, double momentum, double eps, boolean cudnn_enabled)
static Tensor	int_repr(Tensor self)
static Tensor	inverse(Tensor self)
static void	inverse_out(Tensor out, Tensor self)
static boolean	is_distributed(Tensor self)
static boolean	is_nonzero(Tensor self)
static boolean	is_same_size(Tensor self, Tensor other)
static boolean	is_vulkan_available()
static Tensor	isclose(Tensor self, Tensor other, double rtol, double atol, boolean equal_nan)
static Tensor	isfinite(Tensor self)
static Tensor	isinf(Tensor self)
static Tensor	isnan(Tensor self)
static Tensor	isneginf(Tensor self)
static void	isneginf_out(Tensor out, Tensor self)
static Tensor	isposinf(Tensor self)
static void	isposinf_out(Tensor out, Tensor self)
static Tensor	isreal(Tensor self)
static Tensor	istft(Tensor self, long n_fft, long hop_length, long win_length, scala.Option<Tensor> window, boolean center, boolean normalized, long length, boolean return_complex)
static Tensor	kaiser_window_0(long window_length, TensorOptions options)
static Tensor	kaiser_window_1(long window_length, boolean periodic, TensorOptions options)
static Tensor	kaiser_window_2(long window_length, boolean periodic, double beta, TensorOptions options)
static Tensor	kl_div(Tensor self, Tensor target, long reduction, boolean log_target)
static Tensor	kron(Tensor self, Tensor other)
static void	kron_out(Tensor out, Tensor self, Tensor other)
static scala.Tuple2<Tensor,Tensor>	kthvalue(Tensor self, long k, long dim, boolean keepdim)
static scala.Tuple2<Tensor,Tensor>	kthvalue_out(Tensor values, Tensor indices, Tensor self, long k, long dim, boolean keepdim)
static Tensor	layer_norm(Tensor input, long[] normalized_shape, scala.Option<Tensor> weight, scala.Option<Tensor> bias, double eps, boolean cudnn_enable)
static Tensor	lcm(Tensor self, Tensor other)
static void	lcm_(Tensor self, Tensor other)
static void	lcm_out(Tensor out, Tensor self, Tensor other)
static Tensor	ldexp(Tensor self, Tensor other)
static void	ldexp_(Tensor self, Tensor other)
static void	ldexp_out(Tensor out, Tensor self, Tensor other)
static Tensor	le_0(Tensor self, double other)
static Tensor	le_0_l(Tensor self, long other)
static Tensor	le_1(Tensor self, Tensor other)
static void	le_out_0(Tensor out, Tensor self, double other)
static void	le_out_0_l(Tensor out, Tensor self, long other)
static void	le_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	leaky_relu(Tensor self, double negative_slope)
static void	leaky_relu_(Tensor self, double negative_slope)
static void	leaky_relu__l(Tensor self, long negative_slope)
static Tensor	leaky_relu_backward(Tensor grad_output, Tensor self, double negative_slope, boolean self_is_result)
static Tensor	leaky_relu_backward_l(Tensor grad_output, Tensor self, long negative_slope, boolean self_is_result)
static Tensor	leaky_relu_l(Tensor self, long negative_slope)
static void	leaky_relu_out(Tensor out, Tensor self, double negative_slope)
static void	leaky_relu_out_l(Tensor out, Tensor self, long negative_slope)
static Tensor	lerp_0(Tensor self, Tensor end, double weight)
static Tensor	lerp_0_l(Tensor self, Tensor end, long weight)
static Tensor	lerp_1(Tensor self, Tensor end, Tensor weight)
static void	lerp_out_0(Tensor out, Tensor self, Tensor end, double weight)
static void	lerp_out_0_l(Tensor out, Tensor self, Tensor end, long weight)
static void	lerp_out_1(Tensor out, Tensor self, Tensor end, Tensor weight)
static Tensor	less_0(Tensor self, double other)
static Tensor	less_0_l(Tensor self, long other)
static Tensor	less_1(Tensor self, Tensor other)
static Tensor	less_equal_0(Tensor self, double other)
static Tensor	less_equal_0_l(Tensor self, long other)
static Tensor	less_equal_1(Tensor self, Tensor other)
static void	less_equal_out_0(Tensor out, Tensor self, double other)
static void	less_equal_out_0_l(Tensor out, Tensor self, long other)
static void	less_equal_out_1(Tensor out, Tensor self, Tensor other)
static void	less_out_0(Tensor out, Tensor self, double other)
static void	less_out_0_l(Tensor out, Tensor self, long other)
static void	less_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	lgamma(Tensor self)
static void	lgamma_out(Tensor out, Tensor self)
static Tensor	linalg_cholesky(Tensor self, boolean upper)
static scala.Tuple2<Tensor,Tensor>	linalg_cholesky_ex(Tensor self, boolean check_errors)
static scala.Tuple2<Tensor,Tensor>	linalg_cholesky_ex_out(Tensor L, Tensor info, Tensor self, boolean check_errors)
static void	linalg_cholesky_out(Tensor out, Tensor self, boolean upper)
static Tensor	linalg_cond_0(Tensor self, double p)
static Tensor	linalg_cond_1(Tensor self, String p)
static void	linalg_cond_out_0(Tensor out, Tensor self, double p)
static void	linalg_cond_out_1(Tensor out, Tensor self, String p)
static Tensor	linalg_det(Tensor self)
static void	linalg_det_out(Tensor out, Tensor self)
static scala.Tuple2<Tensor,Tensor>	linalg_eig(Tensor self)
static scala.Tuple2<Tensor,Tensor>	linalg_eig_out(Tensor eigenvalues, Tensor eigenvectors, Tensor self)
static scala.Tuple2<Tensor,Tensor>	linalg_eigh(Tensor self, String UPLO)
static scala.Tuple2<Tensor,Tensor>	linalg_eigh_out(Tensor eigvals, Tensor eigvecs, Tensor self, String UPLO)
static Tensor	linalg_eigvals(Tensor self)
static void	linalg_eigvals_out(Tensor out, Tensor self)
static Tensor	linalg_eigvalsh(Tensor self, String UPLO)
static void	linalg_eigvalsh_out(Tensor out, Tensor self, String UPLO)
static Tensor	linalg_householder_product(Tensor input, Tensor tau)
static void	linalg_householder_product_out(Tensor out, Tensor input, Tensor tau)
static Tensor	linalg_inv(Tensor self)
static scala.Tuple2<Tensor,Tensor>	linalg_inv_ex(Tensor self, boolean check_errors)
static scala.Tuple2<Tensor,Tensor>	linalg_inv_ex_out(Tensor inverse, Tensor info, Tensor self, boolean check_errors)
static void	linalg_inv_out(Tensor out, Tensor self)
static scala.Tuple4<Tensor,Tensor,Tensor,Tensor>	linalg_lstsq(Tensor self, Tensor b)
static scala.Tuple4<Tensor,Tensor,Tensor,Tensor>	linalg_lstsq_out(Tensor solution, Tensor residuals, Tensor rank, Tensor singular_values, Tensor self, Tensor b)
static Tensor	linalg_matrix_norm_0(Tensor self, double ord, long[] dim, boolean keepdim)
static Tensor	linalg_matrix_norm_0_l(Tensor self, long ord, long[] dim, boolean keepdim)
static Tensor	linalg_matrix_norm_1(Tensor self, String ord, long[] dim, boolean keepdim)
static void	linalg_matrix_norm_out_0(Tensor out, Tensor self, double ord, long[] dim, boolean keepdim)
static void	linalg_matrix_norm_out_0_l(Tensor out, Tensor self, long ord, long[] dim, boolean keepdim)
static void	linalg_matrix_norm_out_1(Tensor out, Tensor self, String ord, long[] dim, boolean keepdim)
static Tensor	linalg_matrix_power(Tensor self, long n)
static void	linalg_matrix_power_out(Tensor out, Tensor self, long n)
static Tensor	linalg_matrix_rank_0(Tensor self, boolean hermitian)
static Tensor	linalg_matrix_rank_1(Tensor input, Tensor tol, boolean hermitian)
static void	linalg_matrix_rank_out_0(Tensor out, Tensor self, boolean hermitian)
static void	linalg_matrix_rank_out_1(Tensor out, Tensor input, Tensor tol, boolean hermitian)
static Tensor	linalg_multi_dot(Tensor[] tensors)
static void	linalg_multi_dot_out(Tensor out, Tensor[] tensors)
static Tensor	linalg_norm_0(Tensor self, double ord, boolean keepdim)
static Tensor	linalg_norm_1(Tensor self, String ord, boolean keepdim)
static void	linalg_norm_out_0(Tensor out, Tensor self, double ord, boolean keepdim)
static void	linalg_norm_out_1(Tensor out, Tensor self, String ord, boolean keepdim)
static Tensor	linalg_pinv_0(Tensor self, double rcond, boolean hermitian)
static Tensor	linalg_pinv_1(Tensor self, Tensor rcond, boolean hermitian)
static void	linalg_pinv_out_0(Tensor out, Tensor self, double rcond, boolean hermitian)
static void	linalg_pinv_out_1(Tensor out, Tensor self, Tensor rcond, boolean hermitian)
static scala.Tuple2<Tensor,Tensor>	linalg_qr(Tensor self, String mode)
static scala.Tuple2<Tensor,Tensor>	linalg_qr_out(Tensor Q, Tensor R, Tensor self, String mode)
static scala.Tuple2<Tensor,Tensor>	linalg_slogdet(Tensor self)
static scala.Tuple2<Tensor,Tensor>	linalg_slogdet_out(Tensor sign, Tensor logabsdet, Tensor self)
static Tensor	linalg_solve(Tensor input, Tensor other)
static void	linalg_solve_out(Tensor out, Tensor input, Tensor other)
static scala.Tuple3<Tensor,Tensor,Tensor>	linalg_svd(Tensor self, boolean full_matrices)
static scala.Tuple3<Tensor,Tensor,Tensor>	linalg_svd_out(Tensor U, Tensor S, Tensor Vh, Tensor self, boolean full_matrices)
static Tensor	linalg_svdvals(Tensor input)
static void	linalg_svdvals_out(Tensor out, Tensor input)
static Tensor	linalg_tensorinv(Tensor self, long ind)
static void	linalg_tensorinv_out(Tensor out, Tensor self, long ind)
static Tensor	linalg_tensorsolve(Tensor self, Tensor other)
static void	linalg_tensorsolve_out(Tensor out, Tensor self, Tensor other)
static Tensor	linalg_vector_norm(Tensor self, double ord, boolean keepdim)
static Tensor	linalg_vector_norm_l(Tensor self, long ord, boolean keepdim)
static void	linalg_vector_norm_out(Tensor out, Tensor self, double ord, boolean keepdim)
static void	linalg_vector_norm_out_l(Tensor out, Tensor self, long ord, boolean keepdim)
static Tensor	linear(Tensor input, Tensor weight, scala.Option<Tensor> bias)
static Tensor	linspace_0(double start, double end, long steps, TensorOptions options)
static Tensor	linspace_0_l(long start, long end, long steps, TensorOptions options)
static Tensor	linspace_1(double start, double end, long steps)
static Tensor	linspace_1_l(long start, long end, long steps)
static Tensor	linspace_2(double start, double end, long steps)
static Tensor	linspace_2_l(long start, long end, long steps)
static void	linspace_out(Tensor out, double start, double end, long steps)
static void	linspace_out_l(Tensor out, long start, long end, long steps)
static Tensor	log(Tensor self)
static void	log_(Tensor self)
static void	log_out(Tensor out, Tensor self)
static Tensor	log_sigmoid(Tensor self)
static Tensor	log_sigmoid_backward(Tensor grad_output, Tensor self, Tensor buffer)
static void	log_sigmoid_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor buffer)
static scala.Tuple2<Tensor,Tensor>	log_sigmoid_forward(Tensor self)
static scala.Tuple2<Tensor,Tensor>	log_sigmoid_forward_out(Tensor output, Tensor buffer, Tensor self)
static void	log_sigmoid_out(Tensor out, Tensor self)
static Tensor	log_softmax(Tensor self, long dim)
static Tensor	log10(Tensor self)
static void	log10_(Tensor self)
static void	log10_out(Tensor out, Tensor self)
static Tensor	log1p(Tensor self)
static void	log1p_(Tensor self)
static void	log1p_out(Tensor out, Tensor self)
static Tensor	log2(Tensor self)
static void	log2_(Tensor self)
static void	log2_out(Tensor out, Tensor self)
static Tensor	logaddexp(Tensor self, Tensor other)
static void	logaddexp_out(Tensor out, Tensor self, Tensor other)
static Tensor	logaddexp2(Tensor self, Tensor other)
static void	logaddexp2_out(Tensor out, Tensor self, Tensor other)
static Tensor	logcumsumexp(Tensor self, long dim)
static void	logcumsumexp_out(Tensor out, Tensor self, long dim)
static Tensor	logdet(Tensor self)
static Tensor	logical_and(Tensor self, Tensor other)
static void	logical_and_out(Tensor out, Tensor self, Tensor other)
static Tensor	logical_not(Tensor self)
static void	logical_not_out(Tensor out, Tensor self)
static Tensor	logical_or(Tensor self, Tensor other)
static void	logical_or_out(Tensor out, Tensor self, Tensor other)
static Tensor	logical_xor(Tensor self, Tensor other)
static void	logical_xor_out(Tensor out, Tensor self, Tensor other)
static Tensor	logit(Tensor self)
static void	logit_(Tensor self)
static Tensor	logit_backward(Tensor grad_output, Tensor self)
static void	logit_backward_out(Tensor grad_input, Tensor grad_output, Tensor self)
static void	logit_out(Tensor out, Tensor self)
static Tensor	logspace(double start, double end, long steps, double base)
static Tensor	logspace_l(long start, long end, long steps, double base)
static void	logspace_out(Tensor out, double start, double end, long steps, double base)
static void	logspace_out_l(Tensor out, long start, long end, long steps, double base)
static Tensor	logsumexp(Tensor self, long[] dim, boolean keepdim)
static void	logsumexp_out(Tensor out, Tensor self, long[] dim, boolean keepdim)
static scala.Tuple3<Tensor,Tensor,Tensor>	lstm_0(Tensor input, Tensor[] hx, Tensor[] params, boolean has_biases, long num_layers, double dropout, boolean train, boolean bidirectional, boolean batch_first)
static scala.Tuple3<Tensor,Tensor,Tensor>	lstm_1(Tensor data, Tensor batch_sizes, Tensor[] hx, Tensor[] params, boolean has_biases, long num_layers, double dropout, boolean train, boolean bidirectional)
static scala.Tuple2<Tensor,Tensor>	lstm_cell(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, scala.Option<Tensor> b_ih, scala.Option<Tensor> b_hh)
static Tensor	lt_0(Tensor self, double other)
static Tensor	lt_0_l(Tensor self, long other)
static Tensor	lt_1(Tensor self, Tensor other)
static void	lt_out_0(Tensor out, Tensor self, double other)
static void	lt_out_0_l(Tensor out, Tensor self, long other)
static void	lt_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	lu_solve(Tensor self, Tensor LU_data, Tensor LU_pivots)
static void	lu_solve_out(Tensor out, Tensor self, Tensor LU_data, Tensor LU_pivots)
static scala.Tuple3<Tensor,Tensor,Tensor>	lu_unpack(Tensor LU_data, Tensor LU_pivots, boolean unpack_data, boolean unpack_pivots)
static scala.Tuple3<Tensor,Tensor,Tensor>	lu_unpack_out(Tensor P, Tensor L, Tensor U, Tensor LU_data, Tensor LU_pivots, boolean unpack_data, boolean unpack_pivots)
static Tensor	margin_ranking_loss(Tensor input1, Tensor input2, Tensor target, double margin, long reduction)
static Tensor	masked_fill_0(Tensor self, Tensor mask, double value)
static Tensor	masked_fill_0_l(Tensor self, Tensor mask, long value)
static Tensor	masked_fill_1(Tensor self, Tensor mask, Tensor value)
static Tensor	masked_scatter(Tensor self, Tensor mask, Tensor source)
static Tensor	masked_select(Tensor self, Tensor mask)
static Tensor	masked_select_backward(Tensor grad, Tensor input, Tensor mask)
static void	masked_select_out(Tensor out, Tensor self, Tensor mask)
static Tensor	matmul(Tensor self, Tensor other)
static void	matmul_out(Tensor out, Tensor self, Tensor other)
static Tensor	matrix_exp(Tensor self)
static Tensor	matrix_exp_backward(Tensor self, Tensor grad)
static Tensor	matrix_power(Tensor self, long n)
static void	matrix_power_out(Tensor out, Tensor self, long n)
static scala.Tuple2<Tensor,Tensor>	max_0(Tensor self, long dim, boolean keepdim)
static Tensor	max_1(Tensor self)
static Tensor	max_2(Tensor self, Tensor other)
static scala.Tuple2<Tensor,Tensor>	max_out_0(Tensor max, Tensor max_values, Tensor self, long dim, boolean keepdim)
static void	max_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	max_pool1d(Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static scala.Tuple2<Tensor,Tensor>	max_pool1d_with_indices(Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static Tensor	max_pool2d(Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static scala.Tuple2<Tensor,Tensor>	max_pool2d_with_indices(Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static Tensor	max_pool2d_with_indices_backward(Tensor grad_output, Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode, Tensor indices)
static void	max_pool2d_with_indices_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode, Tensor indices)
static scala.Tuple2<Tensor,Tensor>	max_pool2d_with_indices_out(Tensor out, Tensor indices, Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static Tensor	max_pool3d(Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static scala.Tuple2<Tensor,Tensor>	max_pool3d_with_indices(Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static Tensor	max_pool3d_with_indices_backward(Tensor grad_output, Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode, Tensor indices)
static void	max_pool3d_with_indices_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode, Tensor indices)
static scala.Tuple2<Tensor,Tensor>	max_pool3d_with_indices_out(Tensor out, Tensor indices, Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static Tensor	max_unpool2d(Tensor self, Tensor indices, long[] output_size)
static void	max_unpool2d_out(Tensor out, Tensor self, Tensor indices, long[] output_size)
static Tensor	max_unpool3d(Tensor self, Tensor indices, long[] output_size, long[] stride, long[] padding)
static void	max_unpool3d_out(Tensor out, Tensor self, Tensor indices, long[] output_size, long[] stride, long[] padding)
static Tensor	maximum(Tensor self, Tensor other)
static void	maximum_out(Tensor out, Tensor self, Tensor other)
static Tensor	mean_0(Tensor self)
static Tensor	mean_1(Tensor self, long[] dim, boolean keepdim)
static void	mean_out(Tensor out, Tensor self, long[] dim, boolean keepdim)
static Tensor	median_0(Tensor self)
static scala.Tuple2<Tensor,Tensor>	median_1(Tensor self, long dim, boolean keepdim)
static scala.Tuple2<Tensor,Tensor>	median_out(Tensor values, Tensor indices, Tensor self, long dim, boolean keepdim)
static Tensor[]	meshgrid(Tensor[] tensors)
static scala.Tuple2<Tensor,Tensor>	min_0(Tensor self, long dim, boolean keepdim)
static Tensor	min_1(Tensor self)
static Tensor	min_2(Tensor self, Tensor other)
static scala.Tuple2<Tensor,Tensor>	min_out_0(Tensor min, Tensor min_indices, Tensor self, long dim, boolean keepdim)
static void	min_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	minimum(Tensor self, Tensor other)
static void	minimum_out(Tensor out, Tensor self, Tensor other)
static Tensor	mish(Tensor self)
static void	mish_(Tensor self)
static Tensor	mish_backward(Tensor grad_output, Tensor self)
static void	mish_out(Tensor out, Tensor self)
static Tensor	mm(Tensor self, Tensor mat2)
static void	mm_out(Tensor out, Tensor self, Tensor mat2)
static scala.Tuple2<Tensor,Tensor>	mode(Tensor self, long dim, boolean keepdim)
static scala.Tuple2<Tensor,Tensor>	mode_out(Tensor values, Tensor indices, Tensor self, long dim, boolean keepdim)
static Tensor	moveaxis_0(Tensor self, long[] source, long[] destination)
static Tensor	moveaxis_1(Tensor self, long source, long destination)
static Tensor	movedim_0(Tensor self, long[] source, long[] destination)
static Tensor	movedim_1(Tensor self, long source, long destination)
static Tensor	mse_loss(Tensor self, Tensor target, long reduction)
static Tensor	mse_loss_backward(Tensor grad_output, Tensor self, Tensor target, long reduction)
static void	mse_loss_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, long reduction)
static void	mse_loss_out(Tensor out, Tensor self, Tensor target, long reduction)
static Tensor	msort(Tensor self)
static void	msort_out(Tensor out, Tensor self)
static Tensor	mul_0(Tensor self, Tensor other)
static Tensor	mul_1(Tensor self, double other)
static Tensor	mul_1_l(Tensor self, long other)
static void	mul_out(Tensor out, Tensor self, Tensor other)
static Tensor	multi_margin_loss(Tensor self, Tensor target, double p, double margin, scala.Option<Tensor> weight, long reduction)
static Tensor	multi_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, double p, double margin, scala.Option<Tensor> weight, long reduction)
static Tensor	multi_margin_loss_backward_l(Tensor grad_output, Tensor self, Tensor target, long p, long margin, scala.Option<Tensor> weight, long reduction)
static void	multi_margin_loss_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, double p, double margin, scala.Option<Tensor> weight, long reduction)
static void	multi_margin_loss_backward_out_l(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, long p, long margin, scala.Option<Tensor> weight, long reduction)
static Tensor	multi_margin_loss_l(Tensor self, Tensor target, long p, long margin, scala.Option<Tensor> weight, long reduction)
static void	multi_margin_loss_out(Tensor out, Tensor self, Tensor target, double p, double margin, scala.Option<Tensor> weight, long reduction)
static void	multi_margin_loss_out_l(Tensor out, Tensor self, Tensor target, long p, long margin, scala.Option<Tensor> weight, long reduction)
static Tensor	multilabel_margin_loss(Tensor self, Tensor target, long reduction)
static Tensor	multilabel_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, long reduction, Tensor is_target)
static void	multilabel_margin_loss_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, long reduction, Tensor is_target)
static scala.Tuple2<Tensor,Tensor>	multilabel_margin_loss_forward(Tensor self, Tensor target, long reduction)
static scala.Tuple2<Tensor,Tensor>	multilabel_margin_loss_forward_out(Tensor output, Tensor is_target, Tensor self, Tensor target, long reduction)
static void	multilabel_margin_loss_out(Tensor out, Tensor self, Tensor target, long reduction)
static Tensor	multinomial(Tensor self, long num_samples, boolean replacement)
static void	multinomial_out(Tensor out, Tensor self, long num_samples, boolean replacement)
static Tensor	multiply_0(Tensor self, Tensor other)
static Tensor	multiply_1(Tensor self, double other)
static Tensor	multiply_1_l(Tensor self, long other)
static void	multiply_out(Tensor out, Tensor self, Tensor other)
static Tensor	mv(Tensor self, Tensor vec)
static void	mv_out(Tensor out, Tensor self, Tensor vec)
static Tensor	mvlgamma(Tensor self, long p)
static Tensor	nan_to_num(Tensor self)
static void	nan_to_num_(Tensor self)
static void	nan_to_num_out(Tensor out, Tensor self)
static Tensor	nanmedian_0(Tensor self)
static scala.Tuple2<Tensor,Tensor>	nanmedian_1(Tensor self, long dim, boolean keepdim)
static scala.Tuple2<Tensor,Tensor>	nanmedian_out(Tensor values, Tensor indices, Tensor self, long dim, boolean keepdim)
static Tensor	nanquantile_0(Tensor self, double q, long dim, boolean keepdim, String interpolation)
static Tensor	nanquantile_1(Tensor self, Tensor q, long dim, boolean keepdim, String interpolation)
static void	nanquantile_out_0(Tensor out, Tensor self, double q, long dim, boolean keepdim)
static void	nanquantile_out_1(Tensor out, Tensor self, double q, long dim, boolean keepdim, String interpolation)
static void	nanquantile_out_2(Tensor out, Tensor self, Tensor q, long dim, boolean keepdim, String interpolation)
static Tensor	narrow_0(Tensor self, long dim, long start, long length)
static Tensor	narrow_1(Tensor self, long dim, Tensor start, long length)
static Tensor	narrow_copy(Tensor self, long dim, long start, long length)
static void	narrow_copy_out(Tensor out, Tensor self, long dim, long start, long length)
static scala.Tuple3<Tensor,Tensor,Tensor>	native_batch_norm(Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, boolean training, double momentum, double eps)
static scala.Tuple3<Tensor,Tensor,Tensor>	native_batch_norm_backward(Tensor grad_out, Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, scala.Option<Tensor> save_mean, scala.Option<Tensor> save_invstd, boolean train, double eps, boolean[] output_mask)
static scala.Tuple3<Tensor,Tensor,Tensor>	native_batch_norm_out(Tensor out, Tensor save_mean, Tensor save_invstd, Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, scala.Option<Tensor> running_mean, scala.Option<Tensor> running_var, boolean training, double momentum, double eps)
static scala.Tuple3<Tensor,Tensor,Tensor>	native_group_norm(Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, long N, long C, long HxW, long group, double eps)
static scala.Tuple3<Tensor,Tensor,Tensor>	native_group_norm_backward(Tensor grad_out, Tensor input, Tensor mean, Tensor rstd, scala.Option<Tensor> weight, long N, long C, long HxW, long group, boolean[] output_mask)
static scala.Tuple3<Tensor,Tensor,Tensor>	native_layer_norm(Tensor input, long[] normalized_shape, scala.Option<Tensor> weight, scala.Option<Tensor> bias, double eps)
static scala.Tuple3<Tensor,Tensor,Tensor>	native_layer_norm_backward(Tensor grad_out, Tensor input, long[] normalized_shape, Tensor mean, Tensor rstd, scala.Option<Tensor> weight, scala.Option<Tensor> bias, boolean[] output_mask)
static Tensor	native_norm_0(Tensor self, double p)
static Tensor	native_norm_0_l(Tensor self, long p)
static Tensor	native_norm_1(Tensor self, double p, long[] dim, boolean keepdim)
static Tensor	ne_0(Tensor self, double other)
static Tensor	ne_0_l(Tensor self, long other)
static Tensor	ne_1(Tensor self, Tensor other)
static void	ne_out_0(Tensor out, Tensor self, double other)
static void	ne_out_0_l(Tensor out, Tensor self, long other)
static void	ne_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	neg(Tensor self)
static void	neg_(Tensor self)
static void	neg_out(Tensor out, Tensor self)
static Tensor	negative(Tensor self)
static void	negative_(Tensor self)
static void	negative_out(Tensor out, Tensor self)
static Tensor	nextafter(Tensor self, Tensor other)
static void	nextafter_out(Tensor out, Tensor self, Tensor other)
static Tensor	nll_loss(Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static Tensor	nll_loss_backward(Tensor grad_output, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index, Tensor total_weight)
static void	nll_loss_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index, Tensor total_weight)
static scala.Tuple2<Tensor,Tensor>	nll_loss_forward(Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static scala.Tuple2<Tensor,Tensor>	nll_loss_forward_out(Tensor output, Tensor total_weight, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static Tensor	nll_loss_nd(Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static void	nll_loss_out(Tensor out, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static Tensor	nll_loss2d(Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static Tensor	nll_loss2d_backward(Tensor grad_output, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index, Tensor total_weight)
static void	nll_loss2d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index, Tensor total_weight)
static scala.Tuple2<Tensor,Tensor>	nll_loss2d_forward(Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static scala.Tuple2<Tensor,Tensor>	nll_loss2d_forward_out(Tensor output, Tensor total_weight, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static void	nll_loss2d_out(Tensor out, Tensor self, Tensor target, scala.Option<Tensor> weight, long reduction, long ignore_index)
static Tensor	nonzero(Tensor self)
static Tensor[]	nonzero_numpy(Tensor self)
static void	nonzero_out(Tensor out, Tensor self)
static Tensor	norm_0(Tensor self, double p, byte dtype)
static Tensor	norm_1(Tensor self, double p)
static Tensor	norm_1_l(Tensor self, long p)
static Tensor	norm_2(Tensor self, double p, long[] dim, boolean keepdim, byte dtype)
static Tensor	norm_3(Tensor self, double p, long[] dim, boolean keepdim)
static Tensor	norm_except_dim(Tensor v, long pow, long dim)
static void	norm_out_0(Tensor out, Tensor self, double p, long[] dim, boolean keepdim, byte dtype)
static void	norm_out_1(Tensor out, Tensor self, double p, long[] dim, boolean keepdim)
static Tensor	normal_0(Tensor mean, double std)
static Tensor	normal_1(double mean, Tensor std)
static Tensor	normal_2(Tensor mean, Tensor std)
static Tensor	normal_3(double mean, double std, long[] size, TensorOptions options)
static void	normal_out_0(Tensor out, Tensor mean, double std)
static void	normal_out_1(Tensor out, double mean, Tensor std)
static void	normal_out_2(Tensor out, Tensor mean, Tensor std)
static void	normal_out_3(Tensor out, double mean, double std, long[] size)
static Tensor	not_equal_0(Tensor self, double other)
static Tensor	not_equal_0_l(Tensor self, long other)
static Tensor	not_equal_1(Tensor self, Tensor other)
static void	not_equal_out_0(Tensor out, Tensor self, double other)
static void	not_equal_out_0_l(Tensor out, Tensor self, long other)
static void	not_equal_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	nuclear_norm_0(Tensor self, boolean keepdim)
static Tensor	nuclear_norm_1(Tensor self, long[] dim, boolean keepdim)
static void	nuclear_norm_out_0(Tensor out, Tensor self, boolean keepdim)
static void	nuclear_norm_out_1(Tensor out, Tensor self, long[] dim, boolean keepdim)
static Tensor	one_hot(Tensor self, long num_classes)
static Tensor	ones(long[] size, TensorOptions options)
static Tensor	ones_like(Tensor self, TensorOptions options)
static void	ones_out(Tensor out, long[] size)
static Tensor	orgqr(Tensor self, Tensor input2)
static void	orgqr_out(Tensor out, Tensor self, Tensor input2)
static Tensor	ormqr(Tensor self, Tensor input2, Tensor input3, boolean left, boolean transpose)
static void	ormqr_out(Tensor out, Tensor self, Tensor input2, Tensor input3, boolean left, boolean transpose)
static Tensor	outer(Tensor self, Tensor vec2)
static void	outer_out(Tensor out, Tensor self, Tensor vec2)
static Tensor	pad_sequence(Tensor[] sequences, boolean batch_first, double padding_value)
static Tensor	pairwise_distance(Tensor x1, Tensor x2, double p, double eps, boolean keepdim)
static Tensor	pdist(Tensor self, double p)
static Tensor	permute(Tensor self, long[] dims)
static Tensor	pinverse(Tensor self, double rcond)
static Tensor	pixel_shuffle(Tensor self, long upscale_factor)
static Tensor	pixel_unshuffle(Tensor self, long downscale_factor)
static Tensor	poisson(Tensor self)
static Tensor	poisson_nll_loss(Tensor input, Tensor target, boolean log_input, boolean full, double eps, long reduction)
static Tensor	polar(Tensor abs, Tensor angle)
static void	polar_out(Tensor out, Tensor abs, Tensor angle)
static Tensor	polygamma(long n, Tensor self)
static void	polygamma_out(Tensor out, long n, Tensor self)
static Tensor	positive(Tensor self)
static Tensor	pow_0(Tensor self, Tensor exponent)
static Tensor	pow_1(double self, Tensor exponent)
static Tensor	pow_1_l(long self, Tensor exponent)
static Tensor	pow_2(Tensor self, double exponent)
static Tensor	pow_2_l(Tensor self, long exponent)
static void	pow_out_0(Tensor out, Tensor self, Tensor exponent)
static void	pow_out_1(Tensor out, double self, Tensor exponent)
static void	pow_out_1_l(Tensor out, long self, Tensor exponent)
static void	pow_out_2(Tensor out, Tensor self, double exponent)
static void	pow_out_2_l(Tensor out, Tensor self, long exponent)
static Tensor	prelu(Tensor self, Tensor weight)
static Tensor	prod_0(Tensor self)
static Tensor	prod_1(Tensor self, long dim, boolean keepdim)
static void	prod_out(Tensor out, Tensor self, long dim, boolean keepdim)
static byte	promote_types(byte type1, byte type2)
static Tensor	put(Tensor self, Tensor index, Tensor source, boolean accumulate)
static long	q_per_channel_axis(Tensor self)
static Tensor	q_per_channel_scales(Tensor self)
static Tensor	q_per_channel_zero_points(Tensor self)
static double	q_scale(Tensor self)
static long	q_zero_point(Tensor self)
static scala.Tuple2<Tensor,Tensor>	qr(Tensor self, boolean some)
static scala.Tuple2<Tensor,Tensor>	qr_out(Tensor Q, Tensor R, Tensor self, boolean some)
static Tensor	quantile_0(Tensor self, double q, long dim, boolean keepdim)
static Tensor	quantile_1(Tensor self, Tensor q, long dim, boolean keepdim)
static Tensor	quantile_2(Tensor self, double q, long dim, boolean keepdim, String interpolation)
static Tensor	quantile_3(Tensor self, Tensor q, long dim, boolean keepdim, String interpolation)
static void	quantile_out_0(Tensor out, Tensor self, double q, long dim, boolean keepdim)
static void	quantile_out_1(Tensor out, Tensor self, Tensor q, long dim, boolean keepdim)
static void	quantile_out_2(Tensor out, Tensor self, double q, long dim, boolean keepdim, String interpolation)
static void	quantile_out_3(Tensor out, Tensor self, Tensor q, long dim, boolean keepdim, String interpolation)
static Tensor	quantize_per_channel(Tensor self, Tensor scales, Tensor zero_points, long axis, byte dtype)
static Tensor	quantize_per_tensor_0(Tensor self, double scale, long zero_point, byte dtype)
static Tensor[]	quantize_per_tensor_1(Tensor[] tensors, Tensor scales, Tensor zero_points, byte dtype)
static Tensor	quantized_batch_norm(Tensor input, scala.Option<Tensor> weight, scala.Option<Tensor> bias, Tensor mean, Tensor var, double eps, double output_scale, long output_zero_point)
static Tensor	quantized_gru_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, double scale_ih, double scale_hh, double zero_point_ih, double zero_point_hh)
static Tensor	quantized_gru_cell_l(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, long scale_ih, long scale_hh, long zero_point_ih, long zero_point_hh)
static scala.Tuple2<Tensor,Tensor>	quantized_lstm_cell(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, double scale_ih, double scale_hh, double zero_point_ih, double zero_point_hh)
static scala.Tuple2<Tensor,Tensor>	quantized_lstm_cell_l(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, long scale_ih, long scale_hh, long zero_point_ih, long zero_point_hh)
static Tensor	quantized_max_pool1d(Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static Tensor	quantized_max_pool2d(Tensor self, long[] kernel_size, long[] stride, long[] padding, long[] dilation, boolean ceil_mode)
static Tensor	quantized_rnn_relu_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, double scale_ih, double scale_hh, double zero_point_ih, double zero_point_hh)
static Tensor	quantized_rnn_relu_cell_l(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, long scale_ih, long scale_hh, long zero_point_ih, long zero_point_hh)
static Tensor	quantized_rnn_tanh_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, double scale_ih, double scale_hh, double zero_point_ih, double zero_point_hh)
static Tensor	quantized_rnn_tanh_cell_l(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, long scale_ih, long scale_hh, long zero_point_ih, long zero_point_hh)
static Tensor	rad2deg(Tensor self)
static void	rad2deg_(Tensor self)
static void	rad2deg_out(Tensor out, Tensor self)
static Tensor	rand(long[] size, TensorOptions options)
static Tensor	rand_like(Tensor self, TensorOptions options)
static void	rand_out_0(Tensor out, long[] size)
static void	rand_out_1(Tensor out, long[] size)
static Tensor	randint_0(long high, long[] size, TensorOptions options)
static Tensor	randint_1(long high, long[] size, TensorOptions options)
static Tensor	randint_2(long low, long high, long[] size, TensorOptions options)
static Tensor	randint_3(long low, long high, long[] size, TensorOptions options)
static Tensor	randint_like_0(Tensor self, long high, TensorOptions options)
static Tensor	randint_like_1(Tensor self, long low, long high, TensorOptions options)
static void	randint_out_0(Tensor out, long high, long[] size)
static void	randint_out_1(Tensor out, long high, long[] size)
static void	randint_out_2(Tensor out, long low, long high, long[] size)
static void	randint_out_3(Tensor out, long low, long high, long[] size)
static Tensor	randn(long[] size, TensorOptions options)
static Tensor	randn_like(Tensor self, TensorOptions options)
static void	randn_out_0(Tensor out, long[] size)
static void	randn_out_1(Tensor out, long[] size)
static Tensor	randperm_0(long n, TensorOptions options)
static Tensor	randperm_1(long n, TensorOptions options)
static void	randperm_out_0(Tensor out, long n)
static void	randperm_out_1(Tensor out, long n)
static Tensor	range_0(double start, double end, double step, TensorOptions options)
static Tensor	range_0_l(long start, long end, long step, TensorOptions options)
static Tensor	range_1(double start, double end, TensorOptions options)
static Tensor	range_1_l(long start, long end, TensorOptions options)
static void	range_out(Tensor out, double start, double end, double step)
static void	range_out_l(Tensor out, long start, long end, long step)
static Tensor	ravel(Tensor self)
static Tensor	real(Tensor self)
static Tensor	reciprocal(Tensor self)
static void	reciprocal_(Tensor self)
static void	reciprocal_out(Tensor out, Tensor self)
static Tensor	reflection_pad1d(Tensor self, long[] padding)
static Tensor	reflection_pad1d_backward(Tensor grad_output, Tensor self, long[] padding)
static void	reflection_pad1d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] padding)
static void	reflection_pad1d_out(Tensor out, Tensor self, long[] padding)
static Tensor	reflection_pad2d(Tensor self, long[] padding)
static Tensor	reflection_pad2d_backward(Tensor grad_output, Tensor self, long[] padding)
static void	reflection_pad2d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] padding)
static void	reflection_pad2d_out(Tensor out, Tensor self, long[] padding)
static Tensor	relu(Tensor self)
static void	relu_(Tensor self)
static Tensor	relu6(Tensor self)
static void	relu6_(Tensor self)
static Tensor	remainder_0(Tensor self, double other)
static Tensor	remainder_0_l(Tensor self, long other)
static Tensor	remainder_1(Tensor self, Tensor other)
static void	remainder_out_0(Tensor out, Tensor self, double other)
static void	remainder_out_0_l(Tensor out, Tensor self, long other)
static void	remainder_out_1(Tensor out, Tensor self, Tensor other)
static Tensor	renorm(Tensor self, double p, long dim, double maxnorm)
static Tensor	renorm_l(Tensor self, long p, long dim, long maxnorm)
static void	renorm_out(Tensor out, Tensor self, double p, long dim, double maxnorm)
static void	renorm_out_l(Tensor out, Tensor self, long p, long dim, long maxnorm)
static Tensor	repeat_interleave_0(Tensor repeats)
static Tensor	repeat_interleave_1(Tensor self, Tensor repeats, long dim)
static Tensor	repeat_interleave_2(Tensor self, long repeats, long dim)
static Tensor	replication_pad1d(Tensor self, long[] padding)
static Tensor	replication_pad1d_backward(Tensor grad_output, Tensor self, long[] padding)
static void	replication_pad1d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] padding)
static void	replication_pad1d_out(Tensor out, Tensor self, long[] padding)
static Tensor	replication_pad2d(Tensor self, long[] padding)
static Tensor	replication_pad2d_backward(Tensor grad_output, Tensor self, long[] padding)
static void	replication_pad2d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] padding)
static void	replication_pad2d_out(Tensor out, Tensor self, long[] padding)
static Tensor	replication_pad3d(Tensor self, long[] padding)
static Tensor	replication_pad3d_backward(Tensor grad_output, Tensor self, long[] padding)
static void	replication_pad3d_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, long[] padding)
static void	replication_pad3d_out(Tensor out, Tensor self, long[] padding)
static Tensor	reshape(Tensor self, long[] shape)
static void	resize_as_(Tensor self, Tensor the_template)
static void	resize_as_sparse_(Tensor self, Tensor the_template)
static byte	result_type_0(Tensor tensor, Tensor other)
static byte	result_type_1(Tensor tensor, double other)
static byte	result_type_1_l(Tensor tensor, long other)
static byte	result_type_2(double scalar, Tensor tensor)
static byte	result_type_2_l(long scalar, Tensor tensor)
static byte	result_type_3(double scalar1, double scalar2)
static byte	result_type_3_l(long scalar1, long scalar2)
static scala.Tuple2<Tensor,Tensor>	rnn_relu_0(Tensor input, Tensor hx, Tensor[] params, boolean has_biases, long num_layers, double dropout, boolean train, boolean bidirectional, boolean batch_first)
static scala.Tuple2<Tensor,Tensor>	rnn_relu_1(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, boolean has_biases, long num_layers, double dropout, boolean train, boolean bidirectional)
static Tensor	rnn_relu_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, scala.Option<Tensor> b_ih, scala.Option<Tensor> b_hh)
static scala.Tuple2<Tensor,Tensor>	rnn_tanh_0(Tensor input, Tensor hx, Tensor[] params, boolean has_biases, long num_layers, double dropout, boolean train, boolean bidirectional, boolean batch_first)
static scala.Tuple2<Tensor,Tensor>	rnn_tanh_1(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, boolean has_biases, long num_layers, double dropout, boolean train, boolean bidirectional)
static Tensor	rnn_tanh_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, scala.Option<Tensor> b_ih, scala.Option<Tensor> b_hh)
static Tensor	roll(Tensor self, long[] shifts, long[] dims)
static Tensor	rot90(Tensor self, long k, long[] dims)
static Tensor	round(Tensor self)
static void	round_(Tensor self)
static void	round_out(Tensor out, Tensor self)
static Tensor	row_stack(Tensor[] tensors)
static void	row_stack_out(Tensor out, Tensor[] tensors)
static Tensor	rrelu(Tensor self, double lower, double upper, boolean training)
static void	rrelu_(Tensor self, double lower, double upper, boolean training)
static void	rrelu__l(Tensor self, long lower, long upper, boolean training)
static Tensor	rrelu_l(Tensor self, long lower, long upper, boolean training)
static Tensor	rrelu_with_noise(Tensor self, Tensor noise, double lower, double upper, boolean training)
static void	rrelu_with_noise_(Tensor self, Tensor noise, double lower, double upper, boolean training)
static void	rrelu_with_noise__l(Tensor self, Tensor noise, long lower, long upper, boolean training)
static Tensor	rrelu_with_noise_backward(Tensor grad_output, Tensor self, Tensor noise, double lower, double upper, boolean training, boolean self_is_result)
static Tensor	rrelu_with_noise_backward_l(Tensor grad_output, Tensor self, Tensor noise, long lower, long upper, boolean training, boolean self_is_result)
static Tensor	rrelu_with_noise_l(Tensor self, Tensor noise, long lower, long upper, boolean training)
static void	rrelu_with_noise_out(Tensor out, Tensor self, Tensor noise, double lower, double upper, boolean training)
static void	rrelu_with_noise_out_l(Tensor out, Tensor self, Tensor noise, long lower, long upper, boolean training)
static Tensor	rsqrt(Tensor self)
static void	rsqrt_(Tensor self)
static void	rsqrt_out(Tensor out, Tensor self)
static Tensor	rsub_0(Tensor self, Tensor other, double alpha)
static Tensor	rsub_0_l(Tensor self, Tensor other, long alpha)
static Tensor	rsub_1(Tensor self, double other, double alpha)
static Tensor	rsub_1_l(Tensor self, long other, long alpha)
static Tensor	scalar_tensor(double s, TensorOptions options)
static Tensor	scalar_tensor_l(long s, TensorOptions options)
static Tensor	scatter_0(Tensor self, long dim, Tensor index, Tensor src)
static Tensor	scatter_1(Tensor self, long dim, Tensor index, double value)
static Tensor	scatter_1_l(Tensor self, long dim, Tensor index, long value)
static Tensor	scatter_add(Tensor self, long dim, Tensor index, Tensor src)
static Tensor	searchsorted_0(Tensor sorted_sequence, Tensor self, boolean out_int32, boolean right)
static Tensor	searchsorted_1(Tensor sorted_sequence, double self, boolean out_int32, boolean right)
static Tensor	searchsorted_1_l(Tensor sorted_sequence, long self, boolean out_int32, boolean right)
static void	searchsorted_out(Tensor out, Tensor sorted_sequence, Tensor self, boolean out_int32, boolean right)
static Tensor	select(Tensor self, long dim, long index)
static Tensor	select_backward(Tensor grad, long[] input_sizes, long dim, long index)
static Tensor	selu(Tensor self)
static void	selu_(Tensor self)
static Tensor	sgn(Tensor self)
static void	sgn_out(Tensor out, Tensor self)
static Tensor	sigmoid(Tensor self)
static void	sigmoid_(Tensor self)
static Tensor	sigmoid_backward(Tensor grad_output, Tensor output)
static void	sigmoid_backward_out(Tensor grad_input, Tensor grad_output, Tensor output)
static void	sigmoid_out(Tensor out, Tensor self)
static Tensor	sign(Tensor self)
static void	sign_out(Tensor out, Tensor self)
static Tensor	signbit(Tensor self)
static void	signbit_out(Tensor out, Tensor self)
static Tensor	silu(Tensor self)
static void	silu_(Tensor self)
static Tensor	silu_backward(Tensor grad_output, Tensor self)
static void	silu_out(Tensor out, Tensor self)
static Tensor	sin(Tensor self)
static void	sin_(Tensor self)
static void	sin_out(Tensor out, Tensor self)
static Tensor	sinc(Tensor self)
static void	sinc_(Tensor self)
static void	sinc_out(Tensor out, Tensor self)
static Tensor	sinh(Tensor self)
static void	sinh_(Tensor self)
static void	sinh_out(Tensor out, Tensor self)
static Tensor	slice(Tensor self, long dim, long start, long end, long step)
static Tensor	slice_backward(Tensor grad, long[] input_sizes, long dim, long start, long end, long step)
static scala.Tuple2<Tensor,Tensor>	slogdet(Tensor self)
static Tensor	smm(Tensor self, Tensor mat2)
static Tensor	smooth_l1_loss_0(Tensor self, Tensor target, long reduction, double beta)
static Tensor	smooth_l1_loss_1(Tensor self, Tensor target, long reduction, double beta)
static Tensor	smooth_l1_loss_backward_0(Tensor grad_output, Tensor self, Tensor target, long reduction, double beta)
static Tensor	smooth_l1_loss_backward_1(Tensor grad_output, Tensor self, Tensor target, long reduction, double beta)
static void	smooth_l1_loss_backward_out_0(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, long reduction, double beta)
static void	smooth_l1_loss_backward_out_1(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, long reduction, double beta)
static void	smooth_l1_loss_out_0(Tensor out, Tensor self, Tensor target, long reduction, double beta)
static void	smooth_l1_loss_out_1(Tensor out, Tensor self, Tensor target, long reduction, double beta)
static Tensor	soft_margin_loss(Tensor self, Tensor target, long reduction)
static Tensor	soft_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, long reduction)
static void	soft_margin_loss_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, Tensor target, long reduction)
static void	soft_margin_loss_out(Tensor out, Tensor self, Tensor target, long reduction)
static Tensor	softmax(Tensor self, long dim)
static Tensor	softplus(Tensor self, double beta, double threshold)
static Tensor	softplus_backward(Tensor grad_output, Tensor self, double beta, double threshold)
static Tensor	softplus_backward_l(Tensor grad_output, Tensor self, long beta, long threshold)
static void	softplus_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, double beta, double threshold)
static void	softplus_backward_out_l(Tensor grad_input, Tensor grad_output, Tensor self, long beta, long threshold)
static Tensor	softplus_l(Tensor self, long beta, long threshold)
static void	softplus_out(Tensor out, Tensor self, double beta, double threshold)
static void	softplus_out_l(Tensor out, Tensor self, long beta, long threshold)
static Tensor	softshrink(Tensor self, double lambd)
static Tensor	softshrink_backward(Tensor grad_output, Tensor self, double lambd)
static Tensor	softshrink_backward_l(Tensor grad_output, Tensor self, long lambd)
static void	softshrink_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, double lambd)
static void	softshrink_backward_out_l(Tensor grad_input, Tensor grad_output, Tensor self, long lambd)
static Tensor	softshrink_l(Tensor self, long lambd)
static void	softshrink_out(Tensor out, Tensor self, double lambd)
static void	softshrink_out_l(Tensor out, Tensor self, long lambd)
static scala.Tuple2<Tensor,Tensor>	sort(Tensor self, long dim, boolean descending)
static scala.Tuple2<Tensor,Tensor>	sort_out_0(Tensor values, Tensor indices, Tensor self, long dim, boolean descending)
static scala.Tuple2<Tensor,Tensor>	sort_out_1(Tensor values, Tensor indices, Tensor self, long dim, boolean descending)
static Tensor	sparse_coo_tensor(Tensor indices, Tensor values, long[] size, TensorOptions options)
static Tensor	sparse_csr_tensor(Tensor crow_indices, Tensor col_indices, Tensor values, long[] size)
static Tensor	special_entr(Tensor self)
static void	special_entr_out(Tensor out, Tensor self)
static Tensor	special_erf(Tensor self)
static void	special_erf_out(Tensor out, Tensor self)
static Tensor	special_erfc(Tensor self)
static void	special_erfc_out(Tensor out, Tensor self)
static Tensor	special_erfinv(Tensor self)
static void	special_erfinv_out(Tensor out, Tensor self)
static Tensor	special_exp2(Tensor self)
static void	special_exp2_out(Tensor out, Tensor self)
static Tensor	special_expit(Tensor self)
static void	special_expit_out(Tensor out, Tensor self)
static Tensor	special_expm1(Tensor self)
static void	special_expm1_out(Tensor out, Tensor self)
static Tensor	special_gammaln(Tensor self)
static void	special_gammaln_out(Tensor out, Tensor self)
static Tensor	special_i0e(Tensor self)
static void	special_i0e_out(Tensor out, Tensor self)
static Tensor	special_logit(Tensor self)
static void	special_logit_out(Tensor out, Tensor self)
static Tensor	special_xlog1py_0(Tensor self, Tensor other)
static Tensor	special_xlog1py_1(double self, Tensor other)
static Tensor	special_xlog1py_1_l(long self, Tensor other)
static Tensor	special_xlog1py_2(Tensor self, double other)
static Tensor	special_xlog1py_2_l(Tensor self, long other)
static void	special_xlog1py_out_0(Tensor out, Tensor self, Tensor other)
static void	special_xlog1py_out_1(Tensor out, double self, Tensor other)
static void	special_xlog1py_out_1_l(Tensor out, long self, Tensor other)
static void	special_xlog1py_out_2(Tensor out, Tensor self, double other)
static void	special_xlog1py_out_2_l(Tensor out, Tensor self, long other)
static Tensor[]	split(Tensor self, long split_size, long dim)
static Tensor[]	split_with_sizes(Tensor self, long[] split_sizes, long dim)
static Tensor	sqrt(Tensor self)
static void	sqrt_(Tensor self)
static void	sqrt_out(Tensor out, Tensor self)
static Tensor	square(Tensor self)
static void	square_(Tensor self)
static void	square_out(Tensor out, Tensor self)
static Tensor	squeeze_0(Tensor self)
static Tensor	squeeze_1(Tensor self, long dim)
static Tensor	sspaddmm(Tensor self, Tensor mat1, Tensor mat2, double beta, double alpha)
static Tensor	sspaddmm_l(Tensor self, Tensor mat1, Tensor mat2, long beta, long alpha)
static void	sspaddmm_out(Tensor out, Tensor self, Tensor mat1, Tensor mat2, double beta, double alpha)
static void	sspaddmm_out_l(Tensor out, Tensor self, Tensor mat1, Tensor mat2, long beta, long alpha)
static Tensor	stack(Tensor[] tensors, long dim)
static void	stack_out(Tensor out, Tensor[] tensors, long dim)
static Tensor	std_0(Tensor self, boolean unbiased)
static Tensor	std_1(Tensor self, long[] dim, boolean unbiased, boolean keepdim)
static Tensor	std_2(Tensor self, long correction, boolean keepdim)
static scala.Tuple2<Tensor,Tensor>	std_mean_0(Tensor self, boolean unbiased)
static scala.Tuple2<Tensor,Tensor>	std_mean_1(Tensor self, long[] dim, boolean unbiased, boolean keepdim)
static scala.Tuple2<Tensor,Tensor>	std_mean_2(Tensor self, long correction, boolean keepdim)
static void	std_out_0(Tensor out, Tensor self, long[] dim, boolean unbiased, boolean keepdim)
static void	std_out_1(Tensor out, Tensor self, long correction, boolean keepdim)
static Tensor	stft(Tensor self, long n_fft, long hop_length, long win_length, scala.Option<Tensor> window, boolean normalized)
static Tensor	sub_0(Tensor self, Tensor other, double alpha)
static Tensor	sub_0_l(Tensor self, Tensor other, long alpha)
static Tensor	sub_1(Tensor self, double other, double alpha)
static Tensor	sub_1_l(Tensor self, long other, long alpha)
static void	sub_out(Tensor out, Tensor self, Tensor other, double alpha)
static void	sub_out_l(Tensor out, Tensor self, Tensor other, long alpha)
static Tensor	subtract_0(Tensor self, Tensor other, double alpha)
static Tensor	subtract_0_l(Tensor self, Tensor other, long alpha)
static Tensor	subtract_1(Tensor self, double other, double alpha)
static Tensor	subtract_1_l(Tensor self, long other, long alpha)
static void	subtract_out(Tensor out, Tensor self, Tensor other, double alpha)
static void	subtract_out_l(Tensor out, Tensor self, Tensor other, long alpha)
static Tensor	sum_0(Tensor self)
static Tensor	sum_1(Tensor self, long[] dim, boolean keepdim)
static void	sum_out(Tensor out, Tensor self, long[] dim, boolean keepdim)
static scala.Tuple3<Tensor,Tensor,Tensor>	svd(Tensor self, boolean some, boolean compute_uv)
static scala.Tuple3<Tensor,Tensor,Tensor>	svd_out(Tensor U, Tensor S, Tensor V, Tensor self, boolean some, boolean compute_uv)
static Tensor	swapaxes(Tensor self, long axis0, long axis1)
static Tensor	swapdims(Tensor self, long dim0, long dim1)
static Tensor	t(Tensor self)
static Tensor	take(Tensor self, Tensor index)
static Tensor	take_along_dim(Tensor self, Tensor indices, long dim)
static void	take_along_dim_out(Tensor out, Tensor self, Tensor indices, long dim)
static void	take_out(Tensor out, Tensor self, Tensor index)
static Tensor	tan(Tensor self)
static void	tan_(Tensor self)
static void	tan_out(Tensor out, Tensor self)
static Tensor	tanh(Tensor self)
static void	tanh_(Tensor self)
static Tensor	tanh_backward(Tensor grad_output, Tensor output)
static void	tanh_backward_out(Tensor grad_input, Tensor grad_output, Tensor output)
static void	tanh_out(Tensor out, Tensor self)
static Tensor[]	tensor_split_0(Tensor self, long sections, long dim)
static Tensor[]	tensor_split_1(Tensor self, long[] indices, long dim)
static Tensor[]	tensor_split_2(Tensor self, Tensor tensor_indices_or_sections, long dim)
static Tensor	tensordot(Tensor self, Tensor other, long[] dims_self, long[] dims_other)
static void	tensordot_out(Tensor out, Tensor self, Tensor other, long[] dims_self, long[] dims_other)
static Tensor	threshold(Tensor self, double threshold, double value)
static void	threshold_(Tensor self, double threshold, double value)
static void	threshold__l(Tensor self, long threshold, long value)
static Tensor	threshold_backward(Tensor grad_output, Tensor self, double threshold)
static Tensor	threshold_backward_l(Tensor grad_output, Tensor self, long threshold)
static void	threshold_backward_out(Tensor grad_input, Tensor grad_output, Tensor self, double threshold)
static void	threshold_backward_out_l(Tensor grad_input, Tensor grad_output, Tensor self, long threshold)
static Tensor	threshold_l(Tensor self, long threshold, long value)
static void	threshold_out(Tensor out, Tensor self, double threshold, double value)
static void	threshold_out_l(Tensor out, Tensor self, long threshold, long value)
static Tensor	tile(Tensor self, long[] dims)
static Tensor	to_dense_backward(Tensor grad, Tensor input)
static scala.Tuple2<Tensor,Tensor>	topk(Tensor self, long k, long dim, boolean largest, boolean sorted)
static scala.Tuple2<Tensor,Tensor>	topk_out(Tensor values, Tensor indices, Tensor self, long k, long dim, boolean largest, boolean sorted)
static Tensor	trace(Tensor self)
static Tensor	trace_backward(Tensor grad, long[] sizes)
static Tensor	transpose(Tensor self, long dim0, long dim1)
static Tensor	trapz_0(Tensor y, Tensor x, long dim)
static Tensor	trapz_1(Tensor y, double dx, long dim)
static scala.Tuple2<Tensor,Tensor>	triangular_solve(Tensor self, Tensor A, boolean upper, boolean transpose, boolean unitriangular)
static scala.Tuple2<Tensor,Tensor>	triangular_solve_out(Tensor X, Tensor M, Tensor self, Tensor A, boolean upper, boolean transpose, boolean unitriangular)
static Tensor	tril(Tensor self, long diagonal)
static Tensor	tril_indices(long row, long col, long offset, TensorOptions options)
static void	tril_out(Tensor out, Tensor self, long diagonal)
static Tensor	triplet_margin_loss(Tensor anchor, Tensor positive, Tensor negative, double margin, double p, double eps, boolean swap, long reduction)
static Tensor	triu(Tensor self, long diagonal)
static Tensor	triu_indices(long row, long col, long offset, TensorOptions options)
static void	triu_out(Tensor out, Tensor self, long diagonal)
static Tensor	true_divide_0(Tensor self, Tensor other)
static Tensor	true_divide_1(Tensor self, double other)
static Tensor	true_divide_1_l(Tensor self, long other)
static void	true_divide_out(Tensor out, Tensor self, Tensor other)
static Tensor	trunc(Tensor self)
static void	trunc_(Tensor self)
static void	trunc_out(Tensor out, Tensor self)
static Tensor[]	unbind(Tensor self, long dim)
static Tensor[]	unflatten_dense_tensors(Tensor flat, Tensor[] tensors)
static Tensor	unfold_backward(Tensor grad_in, long[] input_sizes, long dim, long size, long step)
static scala.Tuple3<Tensor,Tensor,Tensor>	unique_consecutive(Tensor self, boolean return_inverse, boolean return_counts, long dim)
static scala.Tuple3<Tensor,Tensor,Tensor>	unique_dim(Tensor self, long dim, boolean sorted, boolean return_inverse, boolean return_counts)
static scala.Tuple3<Tensor,Tensor,Tensor>	unique_dim_consecutive(Tensor self, long dim, boolean return_inverse, boolean return_counts)
static Tensor[]	unsafe_chunk(Tensor self, long chunks, long dim)
static Tensor[]	unsafe_split(Tensor self, long split_size, long dim)
static Tensor[]	unsafe_split_with_sizes(Tensor self, long[] split_sizes, long dim)
static Tensor	unsqueeze(Tensor self, long dim)
static Tensor	upsample_bicubic2d(Tensor self, long[] output_size, boolean align_corners)
static Tensor	upsample_bicubic2d_backward(Tensor grad_output, long[] output_size, long[] input_size, boolean align_corners)
static void	upsample_bicubic2d_backward_out(Tensor grad_input, Tensor grad_output, long[] output_size, long[] input_size, boolean align_corners)
static void	upsample_bicubic2d_out(Tensor out, Tensor self, long[] output_size, boolean align_corners)
static Tensor	upsample_bilinear2d(Tensor self, long[] output_size, boolean align_corners)
static Tensor	upsample_bilinear2d_backward(Tensor grad_output, long[] output_size, long[] input_size, boolean align_corners)
static void	upsample_bilinear2d_backward_out(Tensor grad_input, Tensor grad_output, long[] output_size, long[] input_size, boolean align_corners)
static void	upsample_bilinear2d_out(Tensor out, Tensor self, long[] output_size, boolean align_corners)
static Tensor	upsample_linear1d(Tensor self, long[] output_size, boolean align_corners)
static Tensor	upsample_linear1d_backward(Tensor grad_output, long[] output_size, long[] input_size, boolean align_corners)
static void	upsample_linear1d_backward_out(Tensor grad_input, Tensor grad_output, long[] output_size, long[] input_size, boolean align_corners)
static void	upsample_linear1d_out(Tensor out, Tensor self, long[] output_size, boolean align_corners)
static Tensor	upsample_nearest1d(Tensor self, long[] output_size)
static Tensor	upsample_nearest1d_backward(Tensor grad_output, long[] output_size, long[] input_size)
static void	upsample_nearest1d_backward_out(Tensor grad_input, Tensor grad_output, long[] output_size, long[] input_size)
static void	upsample_nearest1d_out(Tensor out, Tensor self, long[] output_size)
static Tensor	upsample_nearest2d(Tensor self, long[] output_size)
static Tensor	upsample_nearest2d_backward(Tensor grad_output, long[] output_size, long[] input_size)
static void	upsample_nearest2d_backward_out(Tensor grad_input, Tensor grad_output, long[] output_size, long[] input_size)
static void	upsample_nearest2d_out(Tensor out, Tensor self, long[] output_size)
static Tensor	upsample_nearest3d(Tensor self, long[] output_size)
static Tensor	upsample_nearest3d_backward(Tensor grad_output, long[] output_size, long[] input_size)
static void	upsample_nearest3d_backward_out(Tensor grad_input, Tensor grad_output, long[] output_size, long[] input_size)
static void	upsample_nearest3d_out(Tensor out, Tensor self, long[] output_size)
static Tensor	upsample_trilinear3d(Tensor self, long[] output_size, boolean align_corners)
static Tensor	upsample_trilinear3d_backward(Tensor grad_output, long[] output_size, long[] input_size, boolean align_corners)
static void	upsample_trilinear3d_backward_out(Tensor grad_input, Tensor grad_output, long[] output_size, long[] input_size, boolean align_corners)
static void	upsample_trilinear3d_out(Tensor out, Tensor self, long[] output_size, boolean align_corners)
static Tensor	value_selecting_reduction_backward(Tensor grad, long dim, Tensor indices, long[] sizes, boolean keepdim)
static Tensor	vander(Tensor x, long N, boolean increasing)
static Tensor	var_0(Tensor self, boolean unbiased)
static Tensor	var_1(Tensor self, long[] dim, boolean unbiased, boolean keepdim)
static Tensor	var_2(Tensor self, long correction, boolean keepdim)
static scala.Tuple2<Tensor,Tensor>	var_mean_0(Tensor self, boolean unbiased)
static scala.Tuple2<Tensor,Tensor>	var_mean_1(Tensor self, long[] dim, boolean unbiased, boolean keepdim)
static scala.Tuple2<Tensor,Tensor>	var_mean_2(Tensor self, long correction, boolean keepdim)
static void	var_out_0(Tensor out, Tensor self, long[] dim, boolean unbiased, boolean keepdim)
static void	var_out_1(Tensor out, Tensor self, long correction, boolean keepdim)
static Tensor	vdot(Tensor self, Tensor other)
static void	vdot_out(Tensor out, Tensor self, Tensor other)
static Tensor	view_as_complex(Tensor self)
static Tensor	view_as_real(Tensor self)
static Tensor[]	vsplit_0(Tensor self, long sections)
static Tensor[]	vsplit_1(Tensor self, long[] indices)
static Tensor	vstack(Tensor[] tensors)
static void	vstack_out(Tensor out, Tensor[] tensors)
static Tensor	where_0(Tensor condition, Tensor self, Tensor other)
static Tensor	where_1(Tensor condition, double self, Tensor other)
static Tensor	where_1_l(Tensor condition, long self, Tensor other)
static Tensor	where_2(Tensor condition, Tensor self, double other)
static Tensor	where_2_l(Tensor condition, Tensor self, long other)
static Tensor	where_3(Tensor condition, double self, double other)
static Tensor	where_3_l(Tensor condition, long self, long other)
static Tensor[]	where_4(Tensor condition)
static void	xlogy__0(Tensor self, Tensor other)
static void	xlogy__1(Tensor self, double other)
static void	xlogy__1_l(Tensor self, long other)
static Tensor	xlogy_0(Tensor self, Tensor other)
static Tensor	xlogy_1(double self, Tensor other)
static Tensor	xlogy_1_l(long self, Tensor other)
static Tensor	xlogy_2(Tensor self, double other)
static Tensor	xlogy_2_l(Tensor self, long other)
static void	xlogy_out_0(Tensor out, Tensor self, Tensor other)
static void	xlogy_out_1(Tensor out, double self, Tensor other)
static void	xlogy_out_1_l(Tensor out, long self, Tensor other)
static void	xlogy_out_2(Tensor out, Tensor self, double other)
static void	xlogy_out_2_l(Tensor out, Tensor self, long other)
static void	zero_(Tensor self)
static Tensor	zeros(long[] size, TensorOptions options)
static Tensor	zeros_like(Tensor self, TensorOptions options)
static void	zeros_out(Tensor out, long[] size)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

ATen

public ATen()

Method Details

__and___0

public static Tensor __and___0(Tensor self,
 double other)

__and___0_l

public static Tensor __and___0_l(Tensor self,
 long other)

__and___1

public static Tensor __and___1(Tensor self,
 Tensor other)

__dispatch_is_complex

public static boolean __dispatch_is_complex(Tensor self)

__dispatch_is_floating_point

public static boolean __dispatch_is_floating_point(Tensor self)

__dispatch_is_signed

public static boolean __dispatch_is_signed(Tensor self)

__dispatch_size

public static long __dispatch_size(Tensor self,
 long dim)

__dispatch_stride

public static long __dispatch_stride(Tensor self,
 long dim)

__lshift___0

public static Tensor __lshift___0(Tensor self,
 double other)

__lshift___0_l

public static Tensor __lshift___0_l(Tensor self,
 long other)

__lshift___1

public static Tensor __lshift___1(Tensor self,
 Tensor other)

__or___0

public static Tensor __or___0(Tensor self,
 double other)

__or___0_l

public static Tensor __or___0_l(Tensor self,
 long other)

__or___1

public static Tensor __or___1(Tensor self,
 Tensor other)

__rshift___0

public static Tensor __rshift___0(Tensor self,
 double other)

__rshift___0_l

public static Tensor __rshift___0_l(Tensor self,
 long other)

__rshift___1

public static Tensor __rshift___1(Tensor self,
 Tensor other)

__xor___0

public static Tensor __xor___0(Tensor self,
 double other)

__xor___0_l

public static Tensor __xor___0_l(Tensor self,
 long other)

__xor___1

public static Tensor __xor___1(Tensor self,
 Tensor other)

_adaptive_avg_pool2d

public static Tensor _adaptive_avg_pool2d(Tensor self,
 long[] output_size)

_adaptive_avg_pool2d_backward

public static Tensor _adaptive_avg_pool2d_backward(Tensor grad_output,
 Tensor self)

_adaptive_avg_pool3d

public static Tensor _adaptive_avg_pool3d(Tensor self,
 long[] output_size)

_adaptive_avg_pool3d_backward

public static Tensor _adaptive_avg_pool3d_backward(Tensor grad_output,
 Tensor self)

_add_batch_dim

public static Tensor _add_batch_dim(Tensor self,
 long batch_dim,
 long level)

_add_relu

public static Tensor _add_relu(Tensor self,
 Tensor other,
 double alpha)

_add_relu_l

public static Tensor _add_relu_l(Tensor self,
 Tensor other,
 long alpha)

_add_relu_

public static void _add_relu_(Tensor self,
 Tensor other,
 double alpha)

_add_relu__l

public static void _add_relu__l(Tensor self,
 Tensor other,
 long alpha)

_add_relu_out

public static void _add_relu_out(Tensor out,
 Tensor self,
 Tensor other,
 double alpha)

_add_relu_out_l

public static void _add_relu_out_l(Tensor out,
 Tensor self,
 Tensor other,
 long alpha)

_aminmax_0

public static scala.Tuple2<Tensor,Tensor> _aminmax_0(Tensor self)

_aminmax_1

public static scala.Tuple2<Tensor,Tensor> _aminmax_1(Tensor self,
 long dim,
 boolean keepdim)

_amp_foreach_non_finite_check_and_unscale_

public static void _amp_foreach_non_finite_check_and_unscale_(Tensor[] self,
 Tensor found_inf,
 Tensor inv_scale)

_amp_update_scale_

public static void _amp_update_scale_(Tensor self,
 Tensor growth_tracker,
 Tensor found_inf,
 double scale_growth_factor,
 double scale_backoff_factor,
 long growth_interval)

_batch_norm_impl_index

public static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Long> _batch_norm_impl_index(Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 boolean training,
 double momentum,
 double eps,
 boolean cudnn_enabled)

_batch_norm_impl_index_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> _batch_norm_impl_index_backward(long impl_index,
 Tensor input,
 Tensor grad_output,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 scala.Option<Tensor> save_mean,
 scala.Option<Tensor> save_var_transform,
 boolean train,
 double eps,
 boolean[] output_mask,
 Tensor reservedSpace)

_cast_Byte

public static Tensor _cast_Byte(Tensor self,
 boolean non_blocking)

_cast_Char

public static Tensor _cast_Char(Tensor self,
 boolean non_blocking)

_cast_Double

public static Tensor _cast_Double(Tensor self,
 boolean non_blocking)

_cast_Float

public static Tensor _cast_Float(Tensor self,
 boolean non_blocking)

_cast_Half

public static Tensor _cast_Half(Tensor self,
 boolean non_blocking)

_cast_Int

public static Tensor _cast_Int(Tensor self,
 boolean non_blocking)

_cast_Long

public static Tensor _cast_Long(Tensor self,
 boolean non_blocking)

_cast_Short

public static Tensor _cast_Short(Tensor self,
 boolean non_blocking)

_cdist_backward

public static Tensor _cdist_backward(Tensor grad,
 Tensor x1,
 Tensor x2,
 double p,
 Tensor cdist)

_cdist_forward

public static Tensor _cdist_forward(Tensor x1,
 Tensor x2,
 double p,
 long compute_mode)

_cholesky_solve_helper

public static Tensor _cholesky_solve_helper(Tensor self,
 Tensor A,
 boolean upper)

_choose_qparams_per_tensor

public static scala.Tuple2<Double,Long> _choose_qparams_per_tensor(Tensor self,
 boolean reduce_range)

_coalesce

public static Tensor _coalesce(Tensor self)

_compute_linear_combination

public static Tensor _compute_linear_combination(Tensor input,
 Tensor coefficients)

_compute_linear_combination_out

public static void _compute_linear_combination_out(Tensor out,
 Tensor input,
 Tensor coefficients)

_conj

public static Tensor _conj(Tensor self)

_copy_from

public static Tensor _copy_from(Tensor self,
 Tensor dst,
 boolean non_blocking)

_ctc_loss

public static scala.Tuple2<Tensor,Tensor> _ctc_loss(Tensor log_probs,
 Tensor targets,
 long[] input_lengths,
 long[] target_lengths,
 long blank,
 boolean zero_infinity)

_ctc_loss_backward

public static Tensor _ctc_loss_backward(Tensor grad,
 Tensor log_probs,
 Tensor targets,
 long[] input_lengths,
 long[] target_lengths,
 Tensor neg_log_likelihood,
 Tensor log_alpha,
 long blank,
 boolean zero_infinity)

_cufft_clear_plan_cache

public static void _cufft_clear_plan_cache(long device_index)

_cufft_get_plan_cache_max_size

public static long _cufft_get_plan_cache_max_size(long device_index)

_cufft_get_plan_cache_size

public static long _cufft_get_plan_cache_size(long device_index)

_cufft_set_plan_cache_max_size

public static void _cufft_set_plan_cache_max_size(long device_index,
 long max_size)

_cummax_helper

public static void _cummax_helper(Tensor self,
 Tensor values,
 Tensor indices,
 long dim)

_cummin_helper

public static void _cummin_helper(Tensor self,
 Tensor values,
 Tensor indices,
 long dim)

_debug_has_internal_overlap

public static long _debug_has_internal_overlap(Tensor self)

_dim_arange

public static Tensor _dim_arange(Tensor like,
 long dim)

_dirichlet_grad

public static Tensor _dirichlet_grad(Tensor x,
 Tensor alpha,
 Tensor total)

_embedding_bag

public static scala.Tuple4<Tensor,Tensor,Tensor,Tensor> _embedding_bag(Tensor weight,
 Tensor indices,
 Tensor offsets,
 boolean scale_grad_by_freq,
 long mode,
 boolean sparse,
 scala.Option<Tensor> per_sample_weights,
 boolean include_last_offset,
 long padding_idx)

_embedding_bag_backward

public static Tensor _embedding_bag_backward(Tensor grad,
 Tensor indices,
 Tensor offsets,
 Tensor offset2bag,
 Tensor bag_size,
 Tensor maximum_indices,
 long num_weights,
 boolean scale_grad_by_freq,
 long mode,
 boolean sparse,
 scala.Option<Tensor> per_sample_weights,
 long padding_idx)

_embedding_bag_dense_backward

public static Tensor _embedding_bag_dense_backward(Tensor grad,
 Tensor indices,
 Tensor offset2bag,
 Tensor bag_size,
 Tensor maximum_indices,
 long num_weights,
 boolean scale_grad_by_freq,
 long mode,
 scala.Option<Tensor> per_sample_weights,
 long padding_idx)

_embedding_bag_forward_only

public static scala.Tuple4<Tensor,Tensor,Tensor,Tensor> _embedding_bag_forward_only(Tensor weight,
 Tensor indices,
 Tensor offsets,
 boolean scale_grad_by_freq,
 long mode,
 boolean sparse,
 scala.Option<Tensor> per_sample_weights,
 boolean include_last_offset,
 long padding_idx)

_embedding_bag_per_sample_weights_backward

public static Tensor _embedding_bag_per_sample_weights_backward(Tensor grad,
 Tensor weight,
 Tensor indices,
 Tensor offsets,
 Tensor offset2bag,
 long mode,
 long padding_idx)

_embedding_bag_sparse_backward

public static Tensor _embedding_bag_sparse_backward(Tensor grad,
 Tensor indices,
 Tensor offsets,
 Tensor offset2bag,
 Tensor bag_size,
 long num_weights,
 boolean scale_grad_by_freq,
 long mode,
 scala.Option<Tensor> per_sample_weights,
 long padding_idx)

_empty_affine_quantized

public static Tensor _empty_affine_quantized(long[] size,
 TensorOptions options,
 double scale,
 long zero_point)

_empty_per_channel_affine_quantized

public static Tensor _empty_per_channel_affine_quantized(long[] size,
 Tensor scales,
 Tensor zero_points,
 long axis,
 TensorOptions options)

_euclidean_dist

public static Tensor _euclidean_dist(Tensor x1,
 Tensor x2)

_fake_quantize_learnable_per_channel_affine

public static Tensor _fake_quantize_learnable_per_channel_affine(Tensor self,
 Tensor scale,
 Tensor zero_point,
 long axis,
 long quant_min,
 long quant_max,
 double grad_factor)

_fake_quantize_learnable_per_channel_affine_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> _fake_quantize_learnable_per_channel_affine_backward(Tensor grad,
 Tensor self,
 Tensor scale,
 Tensor zero_point,
 long axis,
 long quant_min,
 long quant_max,
 double grad_factor)

_fake_quantize_learnable_per_tensor_affine

public static Tensor _fake_quantize_learnable_per_tensor_affine(Tensor self,
 Tensor scale,
 Tensor zero_point,
 long quant_min,
 long quant_max,
 double grad_factor)

_fake_quantize_learnable_per_tensor_affine_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> _fake_quantize_learnable_per_tensor_affine_backward(Tensor grad,
 Tensor self,
 Tensor scale,
 Tensor zero_point,
 long quant_min,
 long quant_max,
 double grad_factor)

_fft_c2c

public static Tensor _fft_c2c(Tensor self,
 long[] dim,
 long normalization,
 boolean forward)

_fft_c2c_out

public static void _fft_c2c_out(Tensor out,
 Tensor self,
 long[] dim,
 long normalization,
 boolean forward)

_fft_c2r

public static Tensor _fft_c2r(Tensor self,
 long[] dim,
 long normalization,
 long last_dim_size)

_fft_c2r_out

public static void _fft_c2r_out(Tensor out,
 Tensor self,
 long[] dim,
 long normalization,
 long last_dim_size)

_foreach_abs

public static Tensor[] _foreach_abs(Tensor[] tensors)

_foreach_abs_

public static void _foreach_abs_(Tensor[] self)

_foreach_acos

public static Tensor[] _foreach_acos(Tensor[] tensors)

_foreach_acos_

public static void _foreach_acos_(Tensor[] self)

_foreach_add_0

public static Tensor[] _foreach_add_0(Tensor[] tensors,
 double scalar)

_foreach_add_0_l

public static Tensor[] _foreach_add_0_l(Tensor[] tensors,
 long scalar)

_foreach_add_1

public static Tensor[] _foreach_add_1(Tensor[] tensors1,
 Tensor[] tensors2,
 double alpha)

_foreach_add_1_l

public static Tensor[] _foreach_add_1_l(Tensor[] tensors1,
 Tensor[] tensors2,
 long alpha)

_foreach_add__0

public static void _foreach_add__0(Tensor[] self,
 double scalar)

_foreach_add__0_l

public static void _foreach_add__0_l(Tensor[] self,
 long scalar)

_foreach_add__1

public static void _foreach_add__1(Tensor[] self,
 Tensor[] other,
 double alpha)

_foreach_add__1_l

public static void _foreach_add__1_l(Tensor[] self,
 Tensor[] other,
 long alpha)

_foreach_addcdiv

public static Tensor[] _foreach_addcdiv(Tensor[] input,
 Tensor[] tensor1,
 Tensor[] tensor2,
 double value)

_foreach_addcdiv_l

public static Tensor[] _foreach_addcdiv_l(Tensor[] input,
 Tensor[] tensor1,
 Tensor[] tensor2,
 long value)

_foreach_addcdiv_

public static void _foreach_addcdiv_(Tensor[] self,
 Tensor[] tensor1,
 Tensor[] tensor2,
 double value)

_foreach_addcdiv__l

public static void _foreach_addcdiv__l(Tensor[] self,
 Tensor[] tensor1,
 Tensor[] tensor2,
 long value)

_foreach_addcmul

public static Tensor[] _foreach_addcmul(Tensor[] input,
 Tensor[] tensor1,
 Tensor[] tensor2,
 double value)

_foreach_addcmul_l

public static Tensor[] _foreach_addcmul_l(Tensor[] input,
 Tensor[] tensor1,
 Tensor[] tensor2,
 long value)

_foreach_addcmul_

public static void _foreach_addcmul_(Tensor[] self,
 Tensor[] tensor1,
 Tensor[] tensor2,
 double value)

_foreach_addcmul__l

public static void _foreach_addcmul__l(Tensor[] self,
 Tensor[] tensor1,
 Tensor[] tensor2,
 long value)

_foreach_asin

public static Tensor[] _foreach_asin(Tensor[] tensors)

_foreach_asin_

public static void _foreach_asin_(Tensor[] self)

_foreach_atan

public static Tensor[] _foreach_atan(Tensor[] tensors)

_foreach_atan_

public static void _foreach_atan_(Tensor[] self)

_foreach_ceil

public static Tensor[] _foreach_ceil(Tensor[] tensors)

_foreach_ceil_

public static void _foreach_ceil_(Tensor[] self)

_foreach_cos

public static Tensor[] _foreach_cos(Tensor[] tensors)

_foreach_cos_

public static void _foreach_cos_(Tensor[] self)

_foreach_cosh

public static Tensor[] _foreach_cosh(Tensor[] tensors)

_foreach_cosh_

public static void _foreach_cosh_(Tensor[] self)

_foreach_div_0

public static Tensor[] _foreach_div_0(Tensor[] tensors,
 double scalar)

_foreach_div_0_l

public static Tensor[] _foreach_div_0_l(Tensor[] tensors,
 long scalar)

_foreach_div_1

public static Tensor[] _foreach_div_1(Tensor[] tensors1,
 Tensor[] tensors2)

_foreach_div__0

public static void _foreach_div__0(Tensor[] self,
 double scalar)

_foreach_div__0_l

public static void _foreach_div__0_l(Tensor[] self,
 long scalar)

_foreach_div__1

public static void _foreach_div__1(Tensor[] self,
 Tensor[] other)

_foreach_erf

public static Tensor[] _foreach_erf(Tensor[] tensors)

_foreach_erf_

public static void _foreach_erf_(Tensor[] self)

_foreach_erfc

public static Tensor[] _foreach_erfc(Tensor[] tensors)

_foreach_erfc_

public static void _foreach_erfc_(Tensor[] self)

_foreach_exp

public static Tensor[] _foreach_exp(Tensor[] tensors)

_foreach_exp_

public static void _foreach_exp_(Tensor[] self)

_foreach_expm1

public static Tensor[] _foreach_expm1(Tensor[] tensors)

_foreach_expm1_

public static void _foreach_expm1_(Tensor[] self)

_foreach_floor

public static Tensor[] _foreach_floor(Tensor[] tensors)

_foreach_floor_

public static void _foreach_floor_(Tensor[] self)

_foreach_frac

public static Tensor[] _foreach_frac(Tensor[] tensors)

_foreach_frac_

public static void _foreach_frac_(Tensor[] self)

_foreach_lgamma

public static Tensor[] _foreach_lgamma(Tensor[] tensors)

_foreach_lgamma_

public static void _foreach_lgamma_(Tensor[] self)

_foreach_log

public static Tensor[] _foreach_log(Tensor[] tensors)

_foreach_log10

public static Tensor[] _foreach_log10(Tensor[] tensors)

_foreach_log10_

public static void _foreach_log10_(Tensor[] self)

_foreach_log1p

public static Tensor[] _foreach_log1p(Tensor[] tensors)

_foreach_log1p_

public static void _foreach_log1p_(Tensor[] self)

_foreach_log2

public static Tensor[] _foreach_log2(Tensor[] tensors)

_foreach_log2_

public static void _foreach_log2_(Tensor[] self)

_foreach_log_

public static void _foreach_log_(Tensor[] self)

_foreach_maximum

public static Tensor[] _foreach_maximum(Tensor[] tensors1,
 Tensor[] tensors2)

_foreach_minimum

public static Tensor[] _foreach_minimum(Tensor[] tensors1,
 Tensor[] tensors2)

_foreach_mul_0

public static Tensor[] _foreach_mul_0(Tensor[] tensors,
 double scalar)

_foreach_mul_0_l

public static Tensor[] _foreach_mul_0_l(Tensor[] tensors,
 long scalar)

_foreach_mul_1

public static Tensor[] _foreach_mul_1(Tensor[] tensors1,
 Tensor[] tensors2)

_foreach_mul__0

public static void _foreach_mul__0(Tensor[] self,
 double scalar)

_foreach_mul__0_l

public static void _foreach_mul__0_l(Tensor[] self,
 long scalar)

_foreach_mul__1

public static void _foreach_mul__1(Tensor[] self,
 Tensor[] other)

_foreach_neg

public static Tensor[] _foreach_neg(Tensor[] tensors)

_foreach_neg_

public static void _foreach_neg_(Tensor[] self)

_foreach_reciprocal

public static Tensor[] _foreach_reciprocal(Tensor[] tensors)

_foreach_reciprocal_

public static void _foreach_reciprocal_(Tensor[] self)

_foreach_round

public static Tensor[] _foreach_round(Tensor[] tensors)

_foreach_round_

public static void _foreach_round_(Tensor[] self)

_foreach_sigmoid

public static Tensor[] _foreach_sigmoid(Tensor[] tensors)

_foreach_sigmoid_

public static void _foreach_sigmoid_(Tensor[] self)

_foreach_sin

public static Tensor[] _foreach_sin(Tensor[] tensors)

_foreach_sin_

public static void _foreach_sin_(Tensor[] self)

_foreach_sinh

public static Tensor[] _foreach_sinh(Tensor[] tensors)

_foreach_sinh_

public static void _foreach_sinh_(Tensor[] self)

_foreach_sqrt

public static Tensor[] _foreach_sqrt(Tensor[] tensors)

_foreach_sqrt_

public static void _foreach_sqrt_(Tensor[] self)

_foreach_sub_0

public static Tensor[] _foreach_sub_0(Tensor[] tensors,
 double scalar)

_foreach_sub_0_l

public static Tensor[] _foreach_sub_0_l(Tensor[] tensors,
 long scalar)

_foreach_sub_1

public static Tensor[] _foreach_sub_1(Tensor[] tensors1,
 Tensor[] tensors2,
 double alpha)

_foreach_sub_1_l

public static Tensor[] _foreach_sub_1_l(Tensor[] tensors1,
 Tensor[] tensors2,
 long alpha)

_foreach_sub__0

public static void _foreach_sub__0(Tensor[] self,
 double scalar)

_foreach_sub__0_l

public static void _foreach_sub__0_l(Tensor[] self,
 long scalar)

_foreach_sub__1

public static void _foreach_sub__1(Tensor[] self,
 Tensor[] other,
 double alpha)

_foreach_sub__1_l

public static void _foreach_sub__1_l(Tensor[] self,
 Tensor[] other,
 long alpha)

_foreach_tan

public static Tensor[] _foreach_tan(Tensor[] tensors)

_foreach_tan_

public static void _foreach_tan_(Tensor[] self)

_foreach_tanh

public static Tensor[] _foreach_tanh(Tensor[] tensors)

_foreach_tanh_

public static void _foreach_tanh_(Tensor[] self)

_foreach_trunc

public static Tensor[] _foreach_trunc(Tensor[] tensors)

_foreach_trunc_

public static void _foreach_trunc_(Tensor[] self)

_foreach_zero_

public static void _foreach_zero_(Tensor[] self)

_fused_dropout

public static scala.Tuple2<Tensor,Tensor> _fused_dropout(Tensor self,
 double p)

_gather_sparse_backward

public static Tensor _gather_sparse_backward(Tensor self,
 long dim,
 Tensor index,
 Tensor grad)

_has_compatible_shallow_copy_type

public static boolean _has_compatible_shallow_copy_type(Tensor self,
 Tensor from)

_index_put_impl_

public static void _index_put_impl_(Tensor self,
 Tensor[] indices,
 Tensor values,
 boolean accumulate,
 boolean unsafe)

_local_scalar_dense

public static double _local_scalar_dense(Tensor self)

_log_softmax

public static Tensor _log_softmax(Tensor self,
 long dim,
 boolean half_to_float)

_log_softmax_backward_data

public static Tensor _log_softmax_backward_data(Tensor grad_output,
 Tensor output,
 long dim,
 byte input_dtype)

_logcumsumexp

public static Tensor _logcumsumexp(Tensor self,
 long dim)

_logcumsumexp_out

public static void _logcumsumexp_out(Tensor out,
 Tensor self,
 long dim)

_lu_with_info

public static scala.Tuple3<Tensor,Tensor,Tensor> _lu_with_info(Tensor self,
 boolean pivot,
 boolean check_errors)

_make_per_channel_quantized_tensor

public static Tensor _make_per_channel_quantized_tensor(Tensor self,
 Tensor scale,
 Tensor zero_point,
 long axis)

_make_per_tensor_quantized_tensor

public static Tensor _make_per_tensor_quantized_tensor(Tensor self,
 double scale,
 long zero_point)

_masked_scale

public static Tensor _masked_scale(Tensor self,
 Tensor mask,
 double scale)

_nnpack_available

public static boolean _nnpack_available()

_pack_padded_sequence

public static scala.Tuple2<Tensor,Tensor> _pack_padded_sequence(Tensor input,
 Tensor lengths,
 boolean batch_first)

_pack_padded_sequence_backward

public static Tensor _pack_padded_sequence_backward(Tensor grad,
 long[] input_size,
 Tensor batch_sizes,
 boolean batch_first)

_pad_packed_sequence

public static scala.Tuple2<Tensor,Tensor> _pad_packed_sequence(Tensor data,
 Tensor batch_sizes,
 boolean batch_first,
 double padding_value,
 long total_length)

_pad_packed_sequence_l

public static scala.Tuple2<Tensor,Tensor> _pad_packed_sequence_l(Tensor data,
 Tensor batch_sizes,
 boolean batch_first,
 long padding_value,
 long total_length)

_pdist_backward

public static Tensor _pdist_backward(Tensor grad,
 Tensor self,
 double p,
 Tensor pdist)

_pdist_forward

public static Tensor _pdist_forward(Tensor self,
 double p)

_remove_batch_dim

public static Tensor _remove_batch_dim(Tensor self,
 long level,
 long batch_size,
 long out_dim)

_reshape_from_tensor

public static Tensor _reshape_from_tensor(Tensor self,
 Tensor shape)

_rowwise_prune

public static scala.Tuple2<Tensor,Tensor> _rowwise_prune(Tensor weight,
 Tensor mask,
 byte compressed_indices_dtype)

_sample_dirichlet

public static Tensor _sample_dirichlet(Tensor self)

_saturate_weight_to_fp16

public static Tensor _saturate_weight_to_fp16(Tensor weight)

_scaled_dot_product_efficient_attention

public static scala.Tuple2<Tensor,Tensor> _scaled_dot_product_efficient_attention(Tensor query,
 Tensor key,
 Tensor value,
 boolean compute_log_sumexp,
 boolean is_causal)

_scaled_dot_product_efficient_attention_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> _scaled_dot_product_efficient_attention_backward(Tensor grad_out_,
 Tensor query,
 Tensor key,
 Tensor value,
 Tensor out,
 Tensor logsumexp,
 boolean is_causal,
 boolean chunk_grad_outputs)

_shape_as_tensor

public static Tensor _shape_as_tensor(Tensor self)

_sobol_engine_draw

public static scala.Tuple2<Tensor,Tensor> _sobol_engine_draw(Tensor quasi,
 long n,
 Tensor sobolstate,
 long dimension,
 long num_generated)

_sobol_engine_ff_

public static void _sobol_engine_ff_(Tensor self,
 long n,
 Tensor sobolstate,
 long dimension,
 long num_generated)

_sobol_engine_initialize_state_

public static void _sobol_engine_initialize_state_(Tensor self,
 long dimension)

_sobol_engine_scramble_

public static void _sobol_engine_scramble_(Tensor self,
 Tensor ltm,
 long dimension)

_softmax

public static Tensor _softmax(Tensor self,
 long dim,
 boolean half_to_float)

_softmax_backward_data

public static Tensor _softmax_backward_data(Tensor grad_output,
 Tensor output,
 long dim,
 byte input_dtype)

_sparse_addmm

public static Tensor _sparse_addmm(Tensor self,
 Tensor sparse,
 Tensor dense,
 double beta,
 double alpha)

_sparse_addmm_l

public static Tensor _sparse_addmm_l(Tensor self,
 Tensor sparse,
 Tensor dense,
 long beta,
 long alpha)

_sparse_coo_tensor_unsafe

public static Tensor _sparse_coo_tensor_unsafe(Tensor indices,
 Tensor values,
 long[] size,
 TensorOptions options)

_sparse_coo_tensor_with_dims

public static Tensor _sparse_coo_tensor_with_dims(long sparse_dim,
 long dense_dim,
 long[] size,
 TensorOptions options)

_sparse_coo_tensor_with_dims_and_tensors

public static Tensor _sparse_coo_tensor_with_dims_and_tensors(long sparse_dim,
 long dense_dim,
 long[] size,
 Tensor indices,
 Tensor values,
 TensorOptions options)

_sparse_log_softmax_0

public static Tensor _sparse_log_softmax_0(Tensor self,
 long dim)

_sparse_log_softmax_1

public static Tensor _sparse_log_softmax_1(Tensor self,
 long dim,
 boolean half_to_float)

_sparse_log_softmax_backward_data

public static Tensor _sparse_log_softmax_backward_data(Tensor grad_output,
 Tensor output,
 long dim,
 Tensor self)

_sparse_mm

public static Tensor _sparse_mm(Tensor sparse,
 Tensor dense)

_sparse_softmax_0

public static Tensor _sparse_softmax_0(Tensor self,
 long dim)

_sparse_softmax_1

public static Tensor _sparse_softmax_1(Tensor self,
 long dim,
 boolean half_to_float)

_sparse_softmax_backward_data

public static Tensor _sparse_softmax_backward_data(Tensor grad_output,
 Tensor output,
 long dim,
 Tensor self)

_sparse_sparse_matmul

public static Tensor _sparse_sparse_matmul(Tensor self,
 Tensor other)

_sparse_sum_0

public static Tensor _sparse_sum_0(Tensor self)

_sparse_sum_1

public static Tensor _sparse_sum_1(Tensor self,
 byte dtype)

_sparse_sum_2

public static Tensor _sparse_sum_2(Tensor self,
 long[] dim)

_sparse_sum_3

public static Tensor _sparse_sum_3(Tensor self,
 long[] dim,
 byte dtype)

_sparse_sum_backward

public static Tensor _sparse_sum_backward(Tensor grad,
 Tensor self,
 long[] dim)

_stack

public static Tensor _stack(Tensor[] tensors,
 long dim)

_stack_out

public static void _stack_out(Tensor out,
 Tensor[] tensors,
 long dim)

_standard_gamma

public static Tensor _standard_gamma(Tensor self)

_standard_gamma_grad

public static Tensor _standard_gamma_grad(Tensor self,
 Tensor output)

_thnn_differentiable_gru_cell_backward

public static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_differentiable_gru_cell_backward(Tensor grad_hy,
 Tensor input_gates,
 Tensor hidden_gates,
 Tensor hx,
 scala.Option<Tensor> input_bias,
 scala.Option<Tensor> hidden_bias)

_thnn_differentiable_lstm_cell_backward

public static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_differentiable_lstm_cell_backward(scala.Option<Tensor> grad_hy,
 scala.Option<Tensor> grad_cy,
 Tensor input_gates,
 Tensor hidden_gates,
 scala.Option<Tensor> input_bias,
 scala.Option<Tensor> hidden_bias,
 Tensor cx,
 Tensor cy)

_thnn_fused_gru_cell

public static scala.Tuple2<Tensor,Tensor> _thnn_fused_gru_cell(Tensor input_gates,
 Tensor hidden_gates,
 Tensor hx,
 scala.Option<Tensor> input_bias,
 scala.Option<Tensor> hidden_bias)

_thnn_fused_gru_cell_backward

public static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_fused_gru_cell_backward(Tensor grad_hy,
 Tensor workspace,
 boolean has_bias)

_thnn_fused_lstm_cell

public static scala.Tuple3<Tensor,Tensor,Tensor> _thnn_fused_lstm_cell(Tensor input_gates,
 Tensor hidden_gates,
 Tensor cx,
 scala.Option<Tensor> input_bias,
 scala.Option<Tensor> hidden_bias)

_thnn_fused_lstm_cell_backward

public static scala.Tuple5<Tensor,Tensor,Tensor,Tensor,Tensor> _thnn_fused_lstm_cell_backward(scala.Option<Tensor> grad_hy,
 scala.Option<Tensor> grad_cy,
 Tensor cx,
 Tensor cy,
 Tensor workspace,
 boolean has_bias)

_trilinear

public static Tensor _trilinear(Tensor i1,
 Tensor i2,
 Tensor i3,
 long[] expand1,
 long[] expand2,
 long[] expand3,
 long[] sumdim,
 long unroll_dim)

_unique

public static scala.Tuple2<Tensor,Tensor> _unique(Tensor self,
 boolean sorted,
 boolean return_inverse)

_unique2

public static scala.Tuple3<Tensor,Tensor,Tensor> _unique2(Tensor self,
 boolean sorted,
 boolean return_inverse,
 boolean return_counts)

_unsafe_view

public static Tensor _unsafe_view(Tensor self,
 long[] size)

_validate_sparse_coo_tensor_args

public static void _validate_sparse_coo_tensor_args(Tensor indices,
 Tensor values,
 long[] size)

_weight_norm

public static Tensor _weight_norm(Tensor v,
 Tensor g,
 long dim)

_weight_norm_differentiable_backward

public static scala.Tuple2<Tensor,Tensor> _weight_norm_differentiable_backward(Tensor grad_w,
 Tensor saved_v,
 Tensor saved_g,
 Tensor saved_norms,
 long dim)

abs

public static Tensor abs(Tensor self)

abs_

public static void abs_(Tensor self)

abs_out

public static void abs_out(Tensor out,
 Tensor self)

absolute

public static Tensor absolute(Tensor self)

absolute_out

public static void absolute_out(Tensor out,
 Tensor self)

acos

public static Tensor acos(Tensor self)

acos_

public static void acos_(Tensor self)

acos_out

public static void acos_out(Tensor out,
 Tensor self)

acosh

public static Tensor acosh(Tensor self)

acosh_

public static void acosh_(Tensor self)

acosh_out

public static void acosh_out(Tensor out,
 Tensor self)

adaptive_avg_pool1d

public static Tensor adaptive_avg_pool1d(Tensor self,
 long[] output_size)

adaptive_avg_pool2d

public static Tensor adaptive_avg_pool2d(Tensor self,
 long[] output_size)

adaptive_avg_pool2d_out

public static void adaptive_avg_pool2d_out(Tensor out,
 Tensor self,
 long[] output_size)

adaptive_avg_pool3d

public static Tensor adaptive_avg_pool3d(Tensor self,
 long[] output_size)

adaptive_avg_pool3d_backward_out

public static void adaptive_avg_pool3d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self)

adaptive_avg_pool3d_out

public static void adaptive_avg_pool3d_out(Tensor out,
 Tensor self,
 long[] output_size)

adaptive_max_pool1d

public static scala.Tuple2<Tensor,Tensor> adaptive_max_pool1d(Tensor self,
 long[] output_size)

adaptive_max_pool2d

public static scala.Tuple2<Tensor,Tensor> adaptive_max_pool2d(Tensor self,
 long[] output_size)

adaptive_max_pool2d_backward

public static Tensor adaptive_max_pool2d_backward(Tensor grad_output,
 Tensor self,
 Tensor indices)

adaptive_max_pool2d_backward_out

public static void adaptive_max_pool2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor indices)

adaptive_max_pool2d_out

public static scala.Tuple2<Tensor,Tensor> adaptive_max_pool2d_out(Tensor out,
 Tensor indices,
 Tensor self,
 long[] output_size)

adaptive_max_pool3d

public static scala.Tuple2<Tensor,Tensor> adaptive_max_pool3d(Tensor self,
 long[] output_size)

adaptive_max_pool3d_backward

public static Tensor adaptive_max_pool3d_backward(Tensor grad_output,
 Tensor self,
 Tensor indices)

adaptive_max_pool3d_backward_out

public static void adaptive_max_pool3d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor indices)

adaptive_max_pool3d_out

public static scala.Tuple2<Tensor,Tensor> adaptive_max_pool3d_out(Tensor out,
 Tensor indices,
 Tensor self,
 long[] output_size)

add_0

public static Tensor add_0(Tensor self,
 Tensor other,
 double alpha)

add_0_l

public static Tensor add_0_l(Tensor self,
 Tensor other,
 long alpha)

add_1

public static Tensor add_1(Tensor self,
 double other,
 double alpha)

add_1_l

public static Tensor add_1_l(Tensor self,
 long other,
 long alpha)

add_out

public static void add_out(Tensor out,
 Tensor self,
 Tensor other,
 double alpha)

add_out_l

public static void add_out_l(Tensor out,
 Tensor self,
 Tensor other,
 long alpha)

addbmm

public static Tensor addbmm(Tensor self,
 Tensor batch1,
 Tensor batch2,
 double beta,
 double alpha)

addbmm_l

public static Tensor addbmm_l(Tensor self,
 Tensor batch1,
 Tensor batch2,
 long beta,
 long alpha)

addbmm_out

public static void addbmm_out(Tensor out,
 Tensor self,
 Tensor batch1,
 Tensor batch2,
 double beta,
 double alpha)

addbmm_out_l

public static void addbmm_out_l(Tensor out,
 Tensor self,
 Tensor batch1,
 Tensor batch2,
 long beta,
 long alpha)

addcdiv

public static Tensor addcdiv(Tensor self,
 Tensor tensor1,
 Tensor tensor2,
 double value)

addcdiv_l

public static Tensor addcdiv_l(Tensor self,
 Tensor tensor1,
 Tensor tensor2,
 long value)

addcdiv_out

public static void addcdiv_out(Tensor out,
 Tensor self,
 Tensor tensor1,
 Tensor tensor2,
 double value)

addcdiv_out_l

public static void addcdiv_out_l(Tensor out,
 Tensor self,
 Tensor tensor1,
 Tensor tensor2,
 long value)

addcmul

public static Tensor addcmul(Tensor self,
 Tensor tensor1,
 Tensor tensor2,
 double value)

addcmul_l

public static Tensor addcmul_l(Tensor self,
 Tensor tensor1,
 Tensor tensor2,
 long value)

addcmul_out

public static void addcmul_out(Tensor out,
 Tensor self,
 Tensor tensor1,
 Tensor tensor2,
 double value)

addcmul_out_l

public static void addcmul_out_l(Tensor out,
 Tensor self,
 Tensor tensor1,
 Tensor tensor2,
 long value)

addmm

public static Tensor addmm(Tensor self,
 Tensor mat1,
 Tensor mat2,
 double beta,
 double alpha)

addmm_l

public static Tensor addmm_l(Tensor self,
 Tensor mat1,
 Tensor mat2,
 long beta,
 long alpha)

addmm_out

public static void addmm_out(Tensor out,
 Tensor self,
 Tensor mat1,
 Tensor mat2,
 double beta,
 double alpha)

addmm_out_l

public static void addmm_out_l(Tensor out,
 Tensor self,
 Tensor mat1,
 Tensor mat2,
 long beta,
 long alpha)

addmv

public static Tensor addmv(Tensor self,
 Tensor mat,
 Tensor vec,
 double beta,
 double alpha)

addmv_l

public static Tensor addmv_l(Tensor self,
 Tensor mat,
 Tensor vec,
 long beta,
 long alpha)

addmv_

public static void addmv_(Tensor self,
 Tensor mat,
 Tensor vec,
 double beta,
 double alpha)

addmv__l

public static void addmv__l(Tensor self,
 Tensor mat,
 Tensor vec,
 long beta,
 long alpha)

addmv_out

public static void addmv_out(Tensor out,
 Tensor self,
 Tensor mat,
 Tensor vec,
 double beta,
 double alpha)

addmv_out_l

public static void addmv_out_l(Tensor out,
 Tensor self,
 Tensor mat,
 Tensor vec,
 long beta,
 long alpha)

addr

public static Tensor addr(Tensor self,
 Tensor vec1,
 Tensor vec2,
 double beta,
 double alpha)

addr_l

public static Tensor addr_l(Tensor self,
 Tensor vec1,
 Tensor vec2,
 long beta,
 long alpha)

addr_out

public static void addr_out(Tensor out,
 Tensor self,
 Tensor vec1,
 Tensor vec2,
 double beta,
 double alpha)

addr_out_l

public static void addr_out_l(Tensor out,
 Tensor self,
 Tensor vec1,
 Tensor vec2,
 long beta,
 long alpha)

affine_grid_generator

public static Tensor affine_grid_generator(Tensor theta,
 long[] size,
 boolean align_corners)

affine_grid_generator_backward

public static Tensor affine_grid_generator_backward(Tensor grad,
 long[] size,
 boolean align_corners)

alias

public static Tensor alias(Tensor self)

align_tensors

public static Tensor[] align_tensors(Tensor[] tensors)

all_0

public static Tensor all_0(Tensor self,
 long dim,
 boolean keepdim)

all_1

public static Tensor all_1(Tensor self)

all_out

public static void all_out(Tensor out,
 Tensor self,
 long dim,
 boolean keepdim)

allclose

public static boolean allclose(Tensor self,
 Tensor other,
 double rtol,
 double atol,
 boolean equal_nan)

alpha_dropout

public static Tensor alpha_dropout(Tensor input,
 double p,
 boolean train)

alpha_dropout_

public static void alpha_dropout_(Tensor self,
 double p,
 boolean train)

amax

public static Tensor amax(Tensor self,
 long[] dim,
 boolean keepdim)

amax_out

public static void amax_out(Tensor out,
 Tensor self,
 long[] dim,
 boolean keepdim)

amin

public static Tensor amin(Tensor self,
 long[] dim,
 boolean keepdim)

amin_out

public static void amin_out(Tensor out,
 Tensor self,
 long[] dim,
 boolean keepdim)

angle

public static Tensor angle(Tensor self)

angle_out

public static void angle_out(Tensor out,
 Tensor self)

any_0

public static Tensor any_0(Tensor self,
 long dim,
 boolean keepdim)

any_1

public static Tensor any_1(Tensor self)

any_out

public static void any_out(Tensor out,
 Tensor self,
 long dim,
 boolean keepdim)

arange_0

public static Tensor arange_0(double end,
 TensorOptions options)

arange_0_l

public static Tensor arange_0_l(long end,
 TensorOptions options)

arange_1

public static Tensor arange_1(double start,
 double end,
 TensorOptions options)

arange_1_l

public static Tensor arange_1_l(long start,
 long end,
 TensorOptions options)

arange_2

public static Tensor arange_2(double start,
 double end,
 double step,
 TensorOptions options)

arange_2_l

public static Tensor arange_2_l(long start,
 long end,
 long step,
 TensorOptions options)

arange_out_0

public static void arange_out_0(Tensor out,
 double end)

arange_out_0_l

public static void arange_out_0_l(Tensor out,
 long end)

arange_out_1

public static void arange_out_1(Tensor out,
 double start,
 double end,
 double step)

arange_out_1_l

public static void arange_out_1_l(Tensor out,
 long start,
 long end,
 long step)

arccos

public static Tensor arccos(Tensor self)

arccos_

public static void arccos_(Tensor self)

arccos_out

public static void arccos_out(Tensor out,
 Tensor self)

arccosh

public static Tensor arccosh(Tensor self)

arccosh_

public static void arccosh_(Tensor self)

arccosh_out

public static void arccosh_out(Tensor out,
 Tensor self)

arcsin

public static Tensor arcsin(Tensor self)

arcsin_

public static void arcsin_(Tensor self)

arcsin_out

public static void arcsin_out(Tensor out,
 Tensor self)

arcsinh

public static Tensor arcsinh(Tensor self)

arcsinh_

public static void arcsinh_(Tensor self)

arcsinh_out

public static void arcsinh_out(Tensor out,
 Tensor self)

arctan

public static Tensor arctan(Tensor self)

arctan_

public static void arctan_(Tensor self)

arctan_out

public static void arctan_out(Tensor out,
 Tensor self)

arctanh

public static Tensor arctanh(Tensor self)

arctanh_

public static void arctanh_(Tensor self)

arctanh_out

public static void arctanh_out(Tensor out,
 Tensor self)

argmax

public static Tensor argmax(Tensor self,
 long dim,
 boolean keepdim)

argmax_out

public static void argmax_out(Tensor out,
 Tensor self,
 long dim,
 boolean keepdim)

argmin

public static Tensor argmin(Tensor self,
 long dim,
 boolean keepdim)

argmin_out

public static void argmin_out(Tensor out,
 Tensor self,
 long dim,
 boolean keepdim)

argsort

public static Tensor argsort(Tensor self,
 boolean stable,
 long dim,
 boolean descending)

as_strided

public static Tensor as_strided(Tensor self,
 long[] size,
 long[] stride,
 long storage_offset)

as_strided_

public static void as_strided_(Tensor self,
 long[] size,
 long[] stride,
 long storage_offset)

asin

public static Tensor asin(Tensor self)

asin_

public static void asin_(Tensor self)

asin_out

public static void asin_out(Tensor out,
 Tensor self)

asinh

public static Tensor asinh(Tensor self)

asinh_

public static void asinh_(Tensor self)

asinh_out

public static void asinh_out(Tensor out,
 Tensor self)

atan

public static Tensor atan(Tensor self)

atan2

public static Tensor atan2(Tensor self,
 Tensor other)

atan2_out

public static void atan2_out(Tensor out,
 Tensor self,
 Tensor other)

atan_

public static void atan_(Tensor self)

atan_out

public static void atan_out(Tensor out,
 Tensor self)

atanh

public static Tensor atanh(Tensor self)

atanh_

public static void atanh_(Tensor self)

atanh_out

public static void atanh_out(Tensor out,
 Tensor self)

atleast_1d_0

public static Tensor atleast_1d_0(Tensor self)

atleast_1d_1

public static Tensor[] atleast_1d_1(Tensor[] tensors)

atleast_2d_0

public static Tensor atleast_2d_0(Tensor self)

atleast_2d_1

public static Tensor[] atleast_2d_1(Tensor[] tensors)

atleast_3d_0

public static Tensor atleast_3d_0(Tensor self)

atleast_3d_1

public static Tensor[] atleast_3d_1(Tensor[] tensors)

avg_pool1d

public static Tensor avg_pool1d(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad)

avg_pool2d

public static Tensor avg_pool2d(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad,
 long divisor_override)

avg_pool2d_backward

public static Tensor avg_pool2d_backward(Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad,
 long divisor_override)

avg_pool2d_backward_out

public static void avg_pool2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad,
 long divisor_override)

avg_pool2d_out

public static void avg_pool2d_out(Tensor out,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad,
 long divisor_override)

avg_pool3d

public static Tensor avg_pool3d(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad,
 long divisor_override)

avg_pool3d_backward

public static Tensor avg_pool3d_backward(Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad,
 long divisor_override)

avg_pool3d_backward_out

public static void avg_pool3d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad,
 long divisor_override)

avg_pool3d_out

public static void avg_pool3d_out(Tensor out,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 boolean ceil_mode,
 boolean count_include_pad,
 long divisor_override)

baddbmm

public static Tensor baddbmm(Tensor self,
 Tensor batch1,
 Tensor batch2,
 double beta,
 double alpha)

baddbmm_l

public static Tensor baddbmm_l(Tensor self,
 Tensor batch1,
 Tensor batch2,
 long beta,
 long alpha)

baddbmm_out

public static void baddbmm_out(Tensor out,
 Tensor self,
 Tensor batch1,
 Tensor batch2,
 double beta,
 double alpha)

baddbmm_out_l

public static void baddbmm_out_l(Tensor out,
 Tensor self,
 Tensor batch1,
 Tensor batch2,
 long beta,
 long alpha)

bartlett_window_0

public static Tensor bartlett_window_0(long window_length,
 TensorOptions options)

bartlett_window_1

public static Tensor bartlett_window_1(long window_length,
 boolean periodic,
 TensorOptions options)

batch_norm

public static Tensor batch_norm(Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 boolean training,
 double momentum,
 double eps,
 boolean cudnn_enabled)

batch_norm_backward_elemt

public static Tensor batch_norm_backward_elemt(Tensor grad_out,
 Tensor input,
 Tensor mean,
 Tensor invstd,
 scala.Option<Tensor> weight,
 Tensor mean_dy,
 Tensor mean_dy_xmu,
 Tensor count)

batch_norm_backward_reduce

public static scala.Tuple4<Tensor,Tensor,Tensor,Tensor> batch_norm_backward_reduce(Tensor grad_out,
 Tensor input,
 Tensor mean,
 Tensor invstd,
 scala.Option<Tensor> weight,
 boolean input_g,
 boolean weight_g,
 boolean bias_g)

batch_norm_elemt

public static Tensor batch_norm_elemt(Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 Tensor mean,
 Tensor invstd,
 double eps)

batch_norm_elemt_out

public static void batch_norm_elemt_out(Tensor out,
 Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 Tensor mean,
 Tensor invstd,
 double eps)

batch_norm_gather_stats

public static scala.Tuple2<Tensor,Tensor> batch_norm_gather_stats(Tensor input,
 Tensor mean,
 Tensor invstd,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 double momentum,
 double eps,
 long count)

batch_norm_gather_stats_with_counts

public static scala.Tuple2<Tensor,Tensor> batch_norm_gather_stats_with_counts(Tensor input,
 Tensor mean,
 Tensor invstd,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 double momentum,
 double eps,
 Tensor counts)

batch_norm_stats

public static scala.Tuple2<Tensor,Tensor> batch_norm_stats(Tensor input,
 double eps)

batch_norm_update_stats

public static scala.Tuple2<Tensor,Tensor> batch_norm_update_stats(Tensor input,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 double momentum)

bernoulli_0

public static Tensor bernoulli_0(Tensor self)

bernoulli_1

public static Tensor bernoulli_1(Tensor self,
 double p)

bernoulli_out

public static void bernoulli_out(Tensor out,
 Tensor self)

bilinear

public static Tensor bilinear(Tensor input1,
 Tensor input2,
 Tensor weight,
 scala.Option<Tensor> bias)

binary_cross_entropy

public static Tensor binary_cross_entropy(Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction)

binary_cross_entropy_backward

public static Tensor binary_cross_entropy_backward(Tensor grad_output,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction)

binary_cross_entropy_backward_out

public static void binary_cross_entropy_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction)

binary_cross_entropy_out

public static void binary_cross_entropy_out(Tensor out,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction)

binary_cross_entropy_with_logits

public static Tensor binary_cross_entropy_with_logits(Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> pos_weight,
 long reduction)

bincount

public static Tensor bincount(Tensor self,
 scala.Option<Tensor> weights,
 long minlength)

binomial

public static Tensor binomial(Tensor count,
 Tensor prob)

bitwise_and_0

public static Tensor bitwise_and_0(Tensor self,
 double other)

bitwise_and_0_l

public static Tensor bitwise_and_0_l(Tensor self,
 long other)

bitwise_and_1

public static Tensor bitwise_and_1(Tensor self,
 Tensor other)

bitwise_and_out_0

public static void bitwise_and_out_0(Tensor out,
 Tensor self,
 Tensor other)

bitwise_and_out_1

public static void bitwise_and_out_1(Tensor out,
 Tensor self,
 double other)

bitwise_and_out_1_l

public static void bitwise_and_out_1_l(Tensor out,
 Tensor self,
 long other)

bitwise_not

public static Tensor bitwise_not(Tensor self)

bitwise_not_out

public static void bitwise_not_out(Tensor out,
 Tensor self)

bitwise_or_0

public static Tensor bitwise_or_0(Tensor self,
 double other)

bitwise_or_0_l

public static Tensor bitwise_or_0_l(Tensor self,
 long other)

bitwise_or_1

public static Tensor bitwise_or_1(Tensor self,
 Tensor other)

bitwise_or_out_0

public static void bitwise_or_out_0(Tensor out,
 Tensor self,
 Tensor other)

bitwise_or_out_1

public static void bitwise_or_out_1(Tensor out,
 Tensor self,
 double other)

bitwise_or_out_1_l

public static void bitwise_or_out_1_l(Tensor out,
 Tensor self,
 long other)

bitwise_xor_0

public static Tensor bitwise_xor_0(Tensor self,
 double other)

bitwise_xor_0_l

public static Tensor bitwise_xor_0_l(Tensor self,
 long other)

bitwise_xor_1

public static Tensor bitwise_xor_1(Tensor self,
 Tensor other)

bitwise_xor_out_0

public static void bitwise_xor_out_0(Tensor out,
 Tensor self,
 Tensor other)

bitwise_xor_out_1

public static void bitwise_xor_out_1(Tensor out,
 Tensor self,
 double other)

bitwise_xor_out_1_l

public static void bitwise_xor_out_1_l(Tensor out,
 Tensor self,
 long other)

blackman_window_0

public static Tensor blackman_window_0(long window_length,
 TensorOptions options)

blackman_window_1

public static Tensor blackman_window_1(long window_length,
 boolean periodic,
 TensorOptions options)

block_diag

public static Tensor block_diag(Tensor[] tensors)

bmm

public static Tensor bmm(Tensor self,
 Tensor mat2)

bmm_out

public static void bmm_out(Tensor out,
 Tensor self,
 Tensor mat2)

broadcast_tensors

public static Tensor[] broadcast_tensors(Tensor[] tensors)

broadcast_to

public static Tensor broadcast_to(Tensor self,
 long[] size)

bucketize_0

public static Tensor bucketize_0(Tensor self,
 Tensor boundaries,
 boolean out_int32,
 boolean right)

bucketize_1

public static Tensor bucketize_1(double self,
 Tensor boundaries,
 boolean out_int32,
 boolean right)

bucketize_1_l

public static Tensor bucketize_1_l(long self,
 Tensor boundaries,
 boolean out_int32,
 boolean right)

bucketize_out

public static void bucketize_out(Tensor out,
 Tensor self,
 Tensor boundaries,
 boolean out_int32,
 boolean right)

can_cast

public static boolean can_cast(byte from,
 byte to)

cartesian_prod

public static Tensor cartesian_prod(Tensor[] tensors)

cat

public static Tensor cat(Tensor[] tensors,
 long dim)

cat_out

public static void cat_out(Tensor out,
 Tensor[] tensors,
 long dim)

cdist

public static Tensor cdist(Tensor x1,
 Tensor x2,
 double p,
 long compute_mode)

ceil

public static Tensor ceil(Tensor self)

ceil_

public static void ceil_(Tensor self)

ceil_out

public static void ceil_out(Tensor out,
 Tensor self)

celu

public static Tensor celu(Tensor self,
 double alpha)

celu_l

public static Tensor celu_l(Tensor self,
 long alpha)

celu_

public static void celu_(Tensor self,
 double alpha)

celu__l

public static void celu__l(Tensor self,
 long alpha)

chain_matmul

public static Tensor chain_matmul(Tensor[] matrices)

chain_matmul_out

public static void chain_matmul_out(Tensor out,
 Tensor[] matrices)

channel_shuffle

public static Tensor channel_shuffle(Tensor self,
 long groups)

cholesky

public static Tensor cholesky(Tensor self,
 boolean upper)

cholesky_inverse

public static Tensor cholesky_inverse(Tensor self,
 boolean upper)

cholesky_inverse_out

public static void cholesky_inverse_out(Tensor out,
 Tensor self,
 boolean upper)

cholesky_out

public static void cholesky_out(Tensor out,
 Tensor self,
 boolean upper)

cholesky_solve

public static Tensor cholesky_solve(Tensor self,
 Tensor input2,
 boolean upper)

cholesky_solve_out

public static void cholesky_solve_out(Tensor out,
 Tensor self,
 Tensor input2,
 boolean upper)

choose_qparams_optimized

public static scala.Tuple2<Tensor,Tensor> choose_qparams_optimized(Tensor input,
 long numel,
 long n_bins,
 double ratio,
 long bit_width)

chunk

public static Tensor[] chunk(Tensor self,
 long chunks,
 long dim)

clamp_0

public static Tensor clamp_0(Tensor self,
 double min,
 double max)

clamp_1

public static Tensor clamp_1(Tensor self,
 scala.Option<Tensor> min,
 scala.Option<Tensor> max)

clamp__0

public static void clamp__0(Tensor self,
 double min,
 double max)

clamp__1

public static void clamp__1(Tensor self,
 scala.Option<Tensor> min,
 scala.Option<Tensor> max)

clamp_max_0

public static Tensor clamp_max_0(Tensor self,
 double max)

clamp_max_0_l

public static Tensor clamp_max_0_l(Tensor self,
 long max)

clamp_max_1

public static Tensor clamp_max_1(Tensor self,
 Tensor max)

clamp_max__0

public static void clamp_max__0(Tensor self,
 double max)

clamp_max__0_l

public static void clamp_max__0_l(Tensor self,
 long max)

clamp_max__1

public static void clamp_max__1(Tensor self,
 Tensor max)

clamp_max_out_0

public static void clamp_max_out_0(Tensor out,
 Tensor self,
 double max)

clamp_max_out_0_l

public static void clamp_max_out_0_l(Tensor out,
 Tensor self,
 long max)

clamp_max_out_1

public static void clamp_max_out_1(Tensor out,
 Tensor self,
 Tensor max)

clamp_min_0

public static Tensor clamp_min_0(Tensor self,
 double min)

clamp_min_0_l

public static Tensor clamp_min_0_l(Tensor self,
 long min)

clamp_min_1

public static Tensor clamp_min_1(Tensor self,
 Tensor min)

clamp_min__0

public static void clamp_min__0(Tensor self,
 double min)

clamp_min__0_l

public static void clamp_min__0_l(Tensor self,
 long min)

clamp_min__1

public static void clamp_min__1(Tensor self,
 Tensor min)

clamp_min_out_0

public static void clamp_min_out_0(Tensor out,
 Tensor self,
 double min)

clamp_min_out_0_l

public static void clamp_min_out_0_l(Tensor out,
 Tensor self,
 long min)

clamp_min_out_1

public static void clamp_min_out_1(Tensor out,
 Tensor self,
 Tensor min)

clamp_out_0

public static void clamp_out_0(Tensor out,
 Tensor self,
 double min,
 double max)

clamp_out_1

public static void clamp_out_1(Tensor out,
 Tensor self,
 scala.Option<Tensor> min,
 scala.Option<Tensor> max)

clip_0

public static Tensor clip_0(Tensor self,
 double min,
 double max)

clip_1

public static Tensor clip_1(Tensor self,
 scala.Option<Tensor> min,
 scala.Option<Tensor> max)

clip__0

public static void clip__0(Tensor self,
 double min,
 double max)

clip__1

public static void clip__1(Tensor self,
 scala.Option<Tensor> min,
 scala.Option<Tensor> max)

clip_out_0

public static void clip_out_0(Tensor out,
 Tensor self,
 double min,
 double max)

clip_out_1

public static void clip_out_1(Tensor out,
 Tensor self,
 scala.Option<Tensor> min,
 scala.Option<Tensor> max)

clone

public static Tensor clone(Tensor self)

col2im

public static Tensor col2im(Tensor self,
 long[] output_size,
 long[] kernel_size,
 long[] dilation,
 long[] padding,
 long[] stride)

col2im_out

public static void col2im_out(Tensor out,
 Tensor self,
 long[] output_size,
 long[] kernel_size,
 long[] dilation,
 long[] padding,
 long[] stride)

column_stack

public static Tensor column_stack(Tensor[] tensors)

column_stack_out

public static void column_stack_out(Tensor out,
 Tensor[] tensors)

combinations

public static Tensor combinations(Tensor self,
 long r,
 boolean with_replacement)

complex

public static Tensor complex(Tensor real,
 Tensor imag)

complex_out

public static void complex_out(Tensor out,
 Tensor real,
 Tensor imag)

conj

public static Tensor conj(Tensor self)

constant_pad_nd

public static Tensor constant_pad_nd(Tensor self,
 long[] pad,
 double value)

constant_pad_nd_l

public static Tensor constant_pad_nd_l(Tensor self,
 long[] pad,
 long value)

conv1d_0

public static Tensor conv1d_0(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 long[] padding,
 long[] dilation,
 long groups)

conv1d_1

public static Tensor conv1d_1(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 String padding,
 long[] dilation,
 long groups)

conv2d_0

public static Tensor conv2d_0(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 long[] padding,
 long[] dilation,
 long groups)

conv2d_1

public static Tensor conv2d_1(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 String padding,
 long[] dilation,
 long groups)

conv3d_0

public static Tensor conv3d_0(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 long[] padding,
 long[] dilation,
 long groups)

conv3d_1

public static Tensor conv3d_1(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 String padding,
 long[] dilation,
 long groups)

conv_tbc

public static Tensor conv_tbc(Tensor self,
 Tensor weight,
 Tensor bias,
 long pad)

conv_tbc_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> conv_tbc_backward(Tensor self,
 Tensor input,
 Tensor weight,
 Tensor bias,
 long pad)

conv_transpose1d

public static Tensor conv_transpose1d(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 long[] padding,
 long[] output_padding,
 long groups,
 long[] dilation)

conv_transpose2d

public static Tensor conv_transpose2d(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 long[] padding,
 long[] output_padding,
 long groups,
 long[] dilation)

conv_transpose3d

public static Tensor conv_transpose3d(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 long[] padding,
 long[] output_padding,
 long groups,
 long[] dilation)

convolution

public static Tensor convolution(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean transposed,
 long[] output_padding,
 long groups)

convolution_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> convolution_backward(Tensor grad_output,
 Tensor input,
 Tensor weight,
 scala.Option<long[]> bias_sizes,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean transposed,
 long[] output_padding,
 long groups,
 boolean[] output_mask)

copy_sparse_to_sparse_

public static void copy_sparse_to_sparse_(Tensor self,
 Tensor src,
 boolean non_blocking)

copysign_0

public static Tensor copysign_0(Tensor self,
 Tensor other)

copysign_1

public static Tensor copysign_1(Tensor self,
 double other)

copysign_1_l

public static Tensor copysign_1_l(Tensor self,
 long other)

copysign_out_0

public static void copysign_out_0(Tensor out,
 Tensor self,
 Tensor other)

copysign_out_1

public static void copysign_out_1(Tensor out,
 Tensor self,
 double other)

copysign_out_1_l

public static void copysign_out_1_l(Tensor out,
 Tensor self,
 long other)

cos

public static Tensor cos(Tensor self)

cos_

public static void cos_(Tensor self)

cos_out

public static void cos_out(Tensor out,
 Tensor self)

cosh

public static Tensor cosh(Tensor self)

cosh_

public static void cosh_(Tensor self)

cosh_out

public static void cosh_out(Tensor out,
 Tensor self)

cosine_embedding_loss

public static Tensor cosine_embedding_loss(Tensor input1,
 Tensor input2,
 Tensor target,
 double margin,
 long reduction)

cosine_similarity

public static Tensor cosine_similarity(Tensor x1,
 Tensor x2,
 long dim,
 double eps)

count_nonzero_0

public static Tensor count_nonzero_0(Tensor self,
 long[] dim)

count_nonzero_1

public static Tensor count_nonzero_1(Tensor self,
 long dim)

cross

public static Tensor cross(Tensor self,
 Tensor other,
 long dim)

cross_entropy_loss

public static Tensor cross_entropy_loss(Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

cross_out

public static void cross_out(Tensor out,
 Tensor self,
 Tensor other,
 long dim)

ctc_loss_0

public static Tensor ctc_loss_0(Tensor log_probs,
 Tensor targets,
 long[] input_lengths,
 long[] target_lengths,
 long blank,
 long reduction,
 boolean zero_infinity)

ctc_loss_1

public static Tensor ctc_loss_1(Tensor log_probs,
 Tensor targets,
 Tensor input_lengths,
 Tensor target_lengths,
 long blank,
 long reduction,
 boolean zero_infinity)

cudnn_affine_grid_generator

public static Tensor cudnn_affine_grid_generator(Tensor theta,
 long N,
 long C,
 long H,
 long W)

cudnn_affine_grid_generator_backward

public static Tensor cudnn_affine_grid_generator_backward(Tensor grad,
 long N,
 long C,
 long H,
 long W)

cudnn_batch_norm

public static scala.Tuple4<Tensor,Tensor,Tensor,Tensor> cudnn_batch_norm(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 boolean training,
 double exponential_average_factor,
 double epsilon)

cudnn_batch_norm_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> cudnn_batch_norm_backward(Tensor input,
 Tensor grad_output,
 Tensor weight,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 scala.Option<Tensor> save_mean,
 scala.Option<Tensor> save_var,
 double epsilon,
 Tensor reserveSpace)

cudnn_grid_sampler

public static Tensor cudnn_grid_sampler(Tensor self,
 Tensor grid)

cudnn_grid_sampler_backward

public static scala.Tuple2<Tensor,Tensor> cudnn_grid_sampler_backward(Tensor self,
 Tensor grid,
 Tensor grad_output)

cudnn_is_acceptable

public static boolean cudnn_is_acceptable(Tensor self)

cummax

public static scala.Tuple2<Tensor,Tensor> cummax(Tensor self,
 long dim)

cummax_out

public static scala.Tuple2<Tensor,Tensor> cummax_out(Tensor values,
 Tensor indices,
 Tensor self,
 long dim)

cummaxmin_backward

public static Tensor cummaxmin_backward(Tensor grad,
 Tensor input,
 Tensor indices,
 long dim)

cummin

public static scala.Tuple2<Tensor,Tensor> cummin(Tensor self,
 long dim)

cummin_out

public static scala.Tuple2<Tensor,Tensor> cummin_out(Tensor values,
 Tensor indices,
 Tensor self,
 long dim)

cumprod

public static Tensor cumprod(Tensor self,
 long dim)

cumprod_backward

public static Tensor cumprod_backward(Tensor grad,
 Tensor input,
 long dim,
 Tensor output)

cumprod_out

public static void cumprod_out(Tensor out,
 Tensor self,
 long dim)

cumsum

public static Tensor cumsum(Tensor self,
 long dim)

cumsum_out

public static void cumsum_out(Tensor out,
 Tensor self,
 long dim)

deg2rad

public static Tensor deg2rad(Tensor self)

deg2rad_

public static void deg2rad_(Tensor self)

deg2rad_out

public static void deg2rad_out(Tensor out,
 Tensor self)

dequantize_0

public static Tensor dequantize_0(Tensor self)

dequantize_1

public static Tensor[] dequantize_1(Tensor[] tensors)

det

public static Tensor det(Tensor self)

detach

public static Tensor detach(Tensor self)

detach_

public static void detach_(Tensor self)

diag

public static Tensor diag(Tensor self,
 long diagonal)

diag_embed

public static Tensor diag_embed(Tensor self,
 long offset,
 long dim1,
 long dim2)

diag_out

public static void diag_out(Tensor out,
 Tensor self,
 long diagonal)

diagflat

public static Tensor diagflat(Tensor self,
 long offset)

diagonal

public static Tensor diagonal(Tensor self,
 long offset,
 long dim1,
 long dim2)

diagonal_backward

public static Tensor diagonal_backward(Tensor grad,
 long[] input_sizes,
 long offset,
 long dim1,
 long dim2)

diff

public static Tensor diff(Tensor self,
 long n,
 long dim,
 scala.Option<Tensor> prepend,
 scala.Option<Tensor> append)

diff_out

public static void diff_out(Tensor out,
 Tensor self,
 long n,
 long dim,
 scala.Option<Tensor> prepend,
 scala.Option<Tensor> append)

digamma

public static Tensor digamma(Tensor self)

digamma_out

public static void digamma_out(Tensor out,
 Tensor self)

dist

public static Tensor dist(Tensor self,
 Tensor other,
 double p)

dist_l

public static Tensor dist_l(Tensor self,
 Tensor other,
 long p)

div_0

public static Tensor div_0(Tensor self,
 Tensor other)

div_1

public static Tensor div_1(Tensor self,
 double other)

div_1_l

public static Tensor div_1_l(Tensor self,
 long other)

div_2

public static Tensor div_2(Tensor self,
 double other)

div_2_l

public static Tensor div_2_l(Tensor self,
 long other)

div_out

public static void div_out(Tensor out,
 Tensor self,
 Tensor other)

divide_0

public static Tensor divide_0(Tensor self,
 Tensor other)

divide_1

public static Tensor divide_1(Tensor self,
 double other)

divide_1_l

public static Tensor divide_1_l(Tensor self,
 long other)

divide_out

public static void divide_out(Tensor out,
 Tensor self,
 Tensor other)

dot

public static Tensor dot(Tensor self,
 Tensor tensor)

dot_out

public static void dot_out(Tensor out,
 Tensor self,
 Tensor tensor)

dropout

public static Tensor dropout(Tensor input,
 double p,
 boolean train)

dropout_

public static void dropout_(Tensor self,
 double p,
 boolean train)

dsplit_0

public static Tensor[] dsplit_0(Tensor self,
 long sections)

dsplit_1

public static Tensor[] dsplit_1(Tensor self,
 long[] indices)

dstack

public static Tensor dstack(Tensor[] tensors)

dstack_out

public static void dstack_out(Tensor out,
 Tensor[] tensors)

einsum

public static Tensor einsum(String equation,
 Tensor[] tensors)

elu

public static Tensor elu(Tensor self,
 double alpha,
 double scale,
 double input_scale)

elu_l

public static Tensor elu_l(Tensor self,
 long alpha,
 long scale,
 long input_scale)

elu_

public static void elu_(Tensor self,
 double alpha,
 double scale,
 double input_scale)

elu__l

public static void elu__l(Tensor self,
 long alpha,
 long scale,
 long input_scale)

elu_backward

public static Tensor elu_backward(Tensor grad_output,
 double alpha,
 double scale,
 double input_scale,
 boolean is_result,
 Tensor self_or_result)

elu_backward_l

public static Tensor elu_backward_l(Tensor grad_output,
 long alpha,
 long scale,
 long input_scale,
 boolean is_result,
 Tensor self_or_result)

elu_out

public static void elu_out(Tensor out,
 Tensor self,
 double alpha,
 double scale,
 double input_scale)

elu_out_l

public static void elu_out_l(Tensor out,
 Tensor self,
 long alpha,
 long scale,
 long input_scale)

embedding

public static Tensor embedding(Tensor weight,
 Tensor indices,
 long padding_idx,
 boolean scale_grad_by_freq,
 boolean sparse)

embedding_backward

public static Tensor embedding_backward(Tensor grad,
 Tensor indices,
 long num_weights,
 long padding_idx,
 boolean scale_grad_by_freq,
 boolean sparse)

embedding_bag_0

public static scala.Tuple4<Tensor,Tensor,Tensor,Tensor> embedding_bag_0(Tensor weight,
 Tensor indices,
 Tensor offsets,
 boolean scale_grad_by_freq,
 long mode,
 boolean sparse,
 scala.Option<Tensor> per_sample_weights,
 boolean include_last_offset)

embedding_bag_1

public static scala.Tuple4<Tensor,Tensor,Tensor,Tensor> embedding_bag_1(Tensor weight,
 Tensor indices,
 Tensor offsets,
 boolean scale_grad_by_freq,
 long mode,
 boolean sparse,
 scala.Option<Tensor> per_sample_weights,
 boolean include_last_offset,
 long padding_idx)

embedding_dense_backward

public static Tensor embedding_dense_backward(Tensor grad_output,
 Tensor indices,
 long num_weights,
 long padding_idx,
 boolean scale_grad_by_freq)

embedding_renorm_

public static void embedding_renorm_(Tensor self,
 Tensor indices,
 double max_norm,
 double norm_type)

embedding_sparse_backward

public static Tensor embedding_sparse_backward(Tensor grad,
 Tensor indices,
 long num_weights,
 long padding_idx,
 boolean scale_grad_by_freq)

empty

public static Tensor empty(long[] size,
 TensorOptions options)

empty_like

public static Tensor empty_like(Tensor self,
 TensorOptions options)

empty_out

public static void empty_out(Tensor out,
 long[] size)

empty_quantized

public static Tensor empty_quantized(long[] size,
 Tensor qtensor)

empty_strided

public static Tensor empty_strided(long[] size,
 long[] stride,
 TensorOptions options)

eq_0

public static Tensor eq_0(Tensor self,
 double other)

eq_0_l

public static Tensor eq_0_l(Tensor self,
 long other)

eq_1

public static Tensor eq_1(Tensor self,
 Tensor other)

eq_out_0

public static void eq_out_0(Tensor out,
 Tensor self,
 double other)

eq_out_0_l

public static void eq_out_0_l(Tensor out,
 Tensor self,
 long other)

eq_out_1

public static void eq_out_1(Tensor out,
 Tensor self,
 Tensor other)

equal

public static boolean equal(Tensor self,
 Tensor other)

erf

public static Tensor erf(Tensor self)

erf_

public static void erf_(Tensor self)

erf_out

public static void erf_out(Tensor out,
 Tensor self)

erfc

public static Tensor erfc(Tensor self)

erfc_

public static void erfc_(Tensor self)

erfc_out

public static void erfc_out(Tensor out,
 Tensor self)

erfinv

public static Tensor erfinv(Tensor self)

erfinv_out

public static void erfinv_out(Tensor out,
 Tensor self)

exp

public static Tensor exp(Tensor self)

exp2

public static Tensor exp2(Tensor self)

exp2_

public static void exp2_(Tensor self)

exp2_out

public static void exp2_out(Tensor out,
 Tensor self)

exp_

public static void exp_(Tensor self)

exp_out

public static void exp_out(Tensor out,
 Tensor self)

expm1

public static Tensor expm1(Tensor self)

expm1_

public static void expm1_(Tensor self)

expm1_out

public static void expm1_out(Tensor out,
 Tensor self)

eye_0

public static Tensor eye_0(long n,
 TensorOptions options)

eye_1

public static Tensor eye_1(long n,
 long m,
 TensorOptions options)

eye_out_0

public static void eye_out_0(Tensor out,
 long n)

eye_out_1

public static void eye_out_1(Tensor out,
 long n,
 long m)

fake_quantize_per_channel_affine

public static Tensor fake_quantize_per_channel_affine(Tensor self,
 Tensor scale,
 Tensor zero_point,
 long axis,
 long quant_min,
 long quant_max)

fake_quantize_per_channel_affine_cachemask

public static scala.Tuple2<Tensor,Tensor> fake_quantize_per_channel_affine_cachemask(Tensor self,
 Tensor scale,
 Tensor zero_point,
 long axis,
 long quant_min,
 long quant_max)

fake_quantize_per_channel_affine_cachemask_backward

public static Tensor fake_quantize_per_channel_affine_cachemask_backward(Tensor grad,
 Tensor mask)

fake_quantize_per_tensor_affine

public static Tensor fake_quantize_per_tensor_affine(Tensor self,
 double scale,
 long zero_point,
 long quant_min,
 long quant_max)

fake_quantize_per_tensor_affine_cachemask

public static scala.Tuple2<Tensor,Tensor> fake_quantize_per_tensor_affine_cachemask(Tensor self,
 double scale,
 long zero_point,
 long quant_min,
 long quant_max)

fake_quantize_per_tensor_affine_cachemask_backward

public static Tensor fake_quantize_per_tensor_affine_cachemask_backward(Tensor grad,
 Tensor mask)

fbgemm_linear_fp16_weight

public static Tensor fbgemm_linear_fp16_weight(Tensor input,
 Tensor packed_weight,
 Tensor bias)

fbgemm_linear_fp16_weight_fp32_activation

public static Tensor fbgemm_linear_fp16_weight_fp32_activation(Tensor input,
 Tensor packed_weight,
 Tensor bias)

fbgemm_linear_int8_weight

public static Tensor fbgemm_linear_int8_weight(Tensor input,
 Tensor weight,
 Tensor packed,
 Tensor col_offsets,
 double weight_scale,
 double weight_zero_point,
 Tensor bias)

fbgemm_linear_int8_weight_l

public static Tensor fbgemm_linear_int8_weight_l(Tensor input,
 Tensor weight,
 Tensor packed,
 Tensor col_offsets,
 long weight_scale,
 long weight_zero_point,
 Tensor bias)

fbgemm_linear_int8_weight_fp32_activation

public static Tensor fbgemm_linear_int8_weight_fp32_activation(Tensor input,
 Tensor weight,
 Tensor packed,
 Tensor col_offsets,
 double weight_scale,
 double weight_zero_point,
 Tensor bias)

fbgemm_linear_int8_weight_fp32_activation_l

public static Tensor fbgemm_linear_int8_weight_fp32_activation_l(Tensor input,
 Tensor weight,
 Tensor packed,
 Tensor col_offsets,
 long weight_scale,
 long weight_zero_point,
 Tensor bias)

fbgemm_linear_quantize_weight

public static scala.Tuple4<Tensor,Tensor,Double,Long> fbgemm_linear_quantize_weight(Tensor input)

fbgemm_pack_gemm_matrix_fp16

public static Tensor fbgemm_pack_gemm_matrix_fp16(Tensor input)

fbgemm_pack_quantized_matrix_0

public static Tensor fbgemm_pack_quantized_matrix_0(Tensor input)

fbgemm_pack_quantized_matrix_1

public static Tensor fbgemm_pack_quantized_matrix_1(Tensor input,
 long K,
 long N)

feature_alpha_dropout

public static Tensor feature_alpha_dropout(Tensor input,
 double p,
 boolean train)

feature_alpha_dropout_

public static void feature_alpha_dropout_(Tensor self,
 double p,
 boolean train)

feature_dropout

public static Tensor feature_dropout(Tensor input,
 double p,
 boolean train)

feature_dropout_

public static void feature_dropout_(Tensor self,
 double p,
 boolean train)

fft_fft

public static Tensor fft_fft(Tensor self,
 long n,
 long dim)

fft_fft2

public static Tensor fft_fft2(Tensor self,
 long[] dim)

fft_fft2_out

public static void fft_fft2_out(Tensor out,
 Tensor self,
 long[] dim)

fft_fft_out

public static void fft_fft_out(Tensor out,
 Tensor self,
 long n,
 long dim)

fft_fftfreq

public static Tensor fft_fftfreq(long n,
 double d,
 TensorOptions options)

fft_fftfreq_out

public static void fft_fftfreq_out(Tensor out,
 long n,
 double d)

fft_fftn

public static Tensor fft_fftn(Tensor self)

fft_fftn_out

public static void fft_fftn_out(Tensor out,
 Tensor self)

fft_fftshift

public static Tensor fft_fftshift(Tensor self)

fft_hfft

public static Tensor fft_hfft(Tensor self,
 long n,
 long dim)

fft_hfft_out

public static void fft_hfft_out(Tensor out,
 Tensor self,
 long n,
 long dim)

fft_ifft

public static Tensor fft_ifft(Tensor self,
 long n,
 long dim)

fft_ifft2

public static Tensor fft_ifft2(Tensor self,
 long[] dim)

fft_ifft2_out

public static void fft_ifft2_out(Tensor out,
 Tensor self,
 long[] dim)

fft_ifft_out

public static void fft_ifft_out(Tensor out,
 Tensor self,
 long n,
 long dim)

fft_ifftn

public static Tensor fft_ifftn(Tensor self)

fft_ifftn_out

public static void fft_ifftn_out(Tensor out,
 Tensor self)

fft_ifftshift

public static Tensor fft_ifftshift(Tensor self)

fft_ihfft

public static Tensor fft_ihfft(Tensor self,
 long n,
 long dim)

fft_ihfft_out

public static void fft_ihfft_out(Tensor out,
 Tensor self,
 long n,
 long dim)

fft_irfft

public static Tensor fft_irfft(Tensor self,
 long n,
 long dim)

fft_irfft2

public static Tensor fft_irfft2(Tensor self,
 long[] dim)

fft_irfft2_out

public static void fft_irfft2_out(Tensor out,
 Tensor self,
 long[] dim)

fft_irfft_out

public static void fft_irfft_out(Tensor out,
 Tensor self,
 long n,
 long dim)

fft_irfftn

public static Tensor fft_irfftn(Tensor self)

fft_irfftn_out

public static void fft_irfftn_out(Tensor out,
 Tensor self)

fft_rfft

public static Tensor fft_rfft(Tensor self,
 long n,
 long dim)

fft_rfft2

public static Tensor fft_rfft2(Tensor self,
 long[] dim)

fft_rfft2_out

public static void fft_rfft2_out(Tensor out,
 Tensor self,
 long[] dim)

fft_rfft_out

public static void fft_rfft_out(Tensor out,
 Tensor self,
 long n,
 long dim)

fft_rfftfreq

public static Tensor fft_rfftfreq(long n,
 double d,
 TensorOptions options)

fft_rfftfreq_out

public static void fft_rfftfreq_out(Tensor out,
 long n,
 double d)

fft_rfftn

public static Tensor fft_rfftn(Tensor self)

fft_rfftn_out

public static void fft_rfftn_out(Tensor out,
 Tensor self)

fill__0

public static void fill__0(Tensor self,
 double value)

fill__0_l

public static void fill__0_l(Tensor self,
 long value)

fill__1

public static void fill__1(Tensor self,
 Tensor value)

fix

public static Tensor fix(Tensor self)

fix_

public static void fix_(Tensor self)

fix_out

public static void fix_out(Tensor out,
 Tensor self)

flatten

public static Tensor flatten(Tensor self,
 long start_dim,
 long end_dim)

flatten_dense_tensors

public static Tensor flatten_dense_tensors(Tensor[] tensors)

flip

public static Tensor flip(Tensor self,
 long[] dims)

fliplr

public static Tensor fliplr(Tensor self)

flipud

public static Tensor flipud(Tensor self)

float_power_0

public static Tensor float_power_0(Tensor self,
 Tensor exponent)

float_power_1

public static Tensor float_power_1(double self,
 Tensor exponent)

float_power_1_l

public static Tensor float_power_1_l(long self,
 Tensor exponent)

float_power_2

public static Tensor float_power_2(Tensor self,
 double exponent)

float_power_2_l

public static Tensor float_power_2_l(Tensor self,
 long exponent)

float_power_out_0

public static void float_power_out_0(Tensor out,
 Tensor self,
 Tensor exponent)

float_power_out_1

public static void float_power_out_1(Tensor out,
 double self,
 Tensor exponent)

float_power_out_1_l

public static void float_power_out_1_l(Tensor out,
 long self,
 Tensor exponent)

float_power_out_2

public static void float_power_out_2(Tensor out,
 Tensor self,
 double exponent)

float_power_out_2_l

public static void float_power_out_2_l(Tensor out,
 Tensor self,
 long exponent)

floor

public static Tensor floor(Tensor self)

floor_

public static void floor_(Tensor self)

floor_divide_0

public static Tensor floor_divide_0(Tensor self,
 Tensor other)

floor_divide_1

public static Tensor floor_divide_1(Tensor self,
 double other)

floor_divide_1_l

public static Tensor floor_divide_1_l(Tensor self,
 long other)

floor_divide_out

public static void floor_divide_out(Tensor out,
 Tensor self,
 Tensor other)

floor_out

public static void floor_out(Tensor out,
 Tensor self)

fmax

public static Tensor fmax(Tensor self,
 Tensor other)

fmax_out

public static void fmax_out(Tensor out,
 Tensor self,
 Tensor other)

fmin

public static Tensor fmin(Tensor self,
 Tensor other)

fmin_out

public static void fmin_out(Tensor out,
 Tensor self,
 Tensor other)

fmod_0

public static Tensor fmod_0(Tensor self,
 double other)

fmod_0_l

public static Tensor fmod_0_l(Tensor self,
 long other)

fmod_1

public static Tensor fmod_1(Tensor self,
 Tensor other)

fmod_out_0

public static void fmod_out_0(Tensor out,
 Tensor self,
 double other)

fmod_out_0_l

public static void fmod_out_0_l(Tensor out,
 Tensor self,
 long other)

fmod_out_1

public static void fmod_out_1(Tensor out,
 Tensor self,
 Tensor other)

frac

public static Tensor frac(Tensor self)

frac_

public static void frac_(Tensor self)

frac_out

public static void frac_out(Tensor out,
 Tensor self)

fractional_max_pool2d

public static scala.Tuple2<Tensor,Tensor> fractional_max_pool2d(Tensor self,
 long[] kernel_size,
 long[] output_size,
 Tensor random_samples)

fractional_max_pool2d_backward

public static Tensor fractional_max_pool2d_backward(Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] output_size,
 Tensor indices)

fractional_max_pool2d_backward_out

public static void fractional_max_pool2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] output_size,
 Tensor indices)

fractional_max_pool2d_out

public static scala.Tuple2<Tensor,Tensor> fractional_max_pool2d_out(Tensor output,
 Tensor indices,
 Tensor self,
 long[] kernel_size,
 long[] output_size,
 Tensor random_samples)

fractional_max_pool3d

public static scala.Tuple2<Tensor,Tensor> fractional_max_pool3d(Tensor self,
 long[] kernel_size,
 long[] output_size,
 Tensor random_samples)

fractional_max_pool3d_backward

public static Tensor fractional_max_pool3d_backward(Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] output_size,
 Tensor indices)

fractional_max_pool3d_backward_out

public static void fractional_max_pool3d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] output_size,
 Tensor indices)

fractional_max_pool3d_out

public static scala.Tuple2<Tensor,Tensor> fractional_max_pool3d_out(Tensor output,
 Tensor indices,
 Tensor self,
 long[] kernel_size,
 long[] output_size,
 Tensor random_samples)

frexp

public static scala.Tuple2<Tensor,Tensor> frexp(Tensor self)

frexp_out

public static scala.Tuple2<Tensor,Tensor> frexp_out(Tensor mantissa,
 Tensor exponent,
 Tensor self)

frobenius_norm

public static Tensor frobenius_norm(Tensor self,
 long[] dim,
 boolean keepdim)

frobenius_norm_out

public static void frobenius_norm_out(Tensor out,
 Tensor self,
 long[] dim,
 boolean keepdim)

from_file

public static Tensor from_file(String filename,
 long size,
 TensorOptions options)

full

public static Tensor full(long[] size,
 double fill_value,
 TensorOptions options)

full_l

public static Tensor full_l(long[] size,
 long fill_value,
 TensorOptions options)

full_like

public static Tensor full_like(Tensor self,
 double fill_value,
 TensorOptions options)

full_like_l

public static Tensor full_like_l(Tensor self,
 long fill_value,
 TensorOptions options)

full_out

public static void full_out(Tensor out,
 long[] size,
 double fill_value)

full_out_l

public static void full_out_l(Tensor out,
 long[] size,
 long fill_value)

gather

public static Tensor gather(Tensor self,
 long dim,
 Tensor index,
 boolean sparse_grad)

gather_backward

public static Tensor gather_backward(Tensor grad,
 Tensor self,
 long dim,
 Tensor index,
 boolean sparse_grad)

gather_out

public static void gather_out(Tensor out,
 Tensor self,
 long dim,
 Tensor index,
 boolean sparse_grad)

gcd

public static Tensor gcd(Tensor self,
 Tensor other)

gcd_

public static void gcd_(Tensor self,
 Tensor other)

gcd_out

public static void gcd_out(Tensor out,
 Tensor self,
 Tensor other)

ge_0

public static Tensor ge_0(Tensor self,
 double other)

ge_0_l

public static Tensor ge_0_l(Tensor self,
 long other)

ge_1

public static Tensor ge_1(Tensor self,
 Tensor other)

ge_out_0

public static void ge_out_0(Tensor out,
 Tensor self,
 double other)

ge_out_0_l

public static void ge_out_0_l(Tensor out,
 Tensor self,
 long other)

ge_out_1

public static void ge_out_1(Tensor out,
 Tensor self,
 Tensor other)

gelu

public static Tensor gelu(Tensor self)

gelu_backward

public static Tensor gelu_backward(Tensor grad,
 Tensor self)

geqrf

public static scala.Tuple2<Tensor,Tensor> geqrf(Tensor self)

geqrf_out

public static scala.Tuple2<Tensor,Tensor> geqrf_out(Tensor a,
 Tensor tau,
 Tensor self)

ger

public static Tensor ger(Tensor self,
 Tensor vec2)

ger_out

public static void ger_out(Tensor out,
 Tensor self,
 Tensor vec2)

glu

public static Tensor glu(Tensor self,
 long dim)

glu_backward

public static Tensor glu_backward(Tensor grad_output,
 Tensor self,
 long dim)

glu_backward_out

public static void glu_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long dim)

glu_out

public static void glu_out(Tensor out,
 Tensor self,
 long dim)

gradient_0

public static Tensor[] gradient_0(Tensor self,
 double spacing,
 long dim,
 long edge_order)

gradient_1

public static Tensor[] gradient_1(Tensor self,
 double spacing,
 long[] dim,
 long edge_order)

gradient_1_l

public static Tensor[] gradient_1_l(Tensor self,
 long spacing,
 long[] dim,
 long edge_order)

gradient_2

public static Tensor[] gradient_2(Tensor self,
 long[] dim,
 long edge_order)

gradient_3

public static Tensor[] gradient_3(Tensor self,
 Tensor[] spacing,
 long dim,
 long edge_order)

gradient_4

public static Tensor[] gradient_4(Tensor self,
 Tensor[] spacing,
 long[] dim,
 long edge_order)

greater_0

public static Tensor greater_0(Tensor self,
 double other)

greater_0_l

public static Tensor greater_0_l(Tensor self,
 long other)

greater_1

public static Tensor greater_1(Tensor self,
 Tensor other)

greater_equal_0

public static Tensor greater_equal_0(Tensor self,
 double other)

greater_equal_0_l

public static Tensor greater_equal_0_l(Tensor self,
 long other)

greater_equal_1

public static Tensor greater_equal_1(Tensor self,
 Tensor other)

greater_equal_out_0

public static void greater_equal_out_0(Tensor out,
 Tensor self,
 double other)

greater_equal_out_0_l

public static void greater_equal_out_0_l(Tensor out,
 Tensor self,
 long other)

greater_equal_out_1

public static void greater_equal_out_1(Tensor out,
 Tensor self,
 Tensor other)

greater_out_0

public static void greater_out_0(Tensor out,
 Tensor self,
 double other)

greater_out_0_l

public static void greater_out_0_l(Tensor out,
 Tensor self,
 long other)

greater_out_1

public static void greater_out_1(Tensor out,
 Tensor self,
 Tensor other)

group_norm

public static Tensor group_norm(Tensor input,
 long num_groups,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 double eps,
 boolean cudnn_enabled)

gru_0

public static scala.Tuple2<Tensor,Tensor> gru_0(Tensor input,
 Tensor hx,
 Tensor[] params,
 boolean has_biases,
 long num_layers,
 double dropout,
 boolean train,
 boolean bidirectional,
 boolean batch_first)

gru_1

public static scala.Tuple2<Tensor,Tensor> gru_1(Tensor data,
 Tensor batch_sizes,
 Tensor hx,
 Tensor[] params,
 boolean has_biases,
 long num_layers,
 double dropout,
 boolean train,
 boolean bidirectional)

gru_cell

public static Tensor gru_cell(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 scala.Option<Tensor> b_ih,
 scala.Option<Tensor> b_hh)

gt_0

public static Tensor gt_0(Tensor self,
 double other)

gt_0_l

public static Tensor gt_0_l(Tensor self,
 long other)

gt_1

public static Tensor gt_1(Tensor self,
 Tensor other)

gt_out_0

public static void gt_out_0(Tensor out,
 Tensor self,
 double other)

gt_out_0_l

public static void gt_out_0_l(Tensor out,
 Tensor self,
 long other)

gt_out_1

public static void gt_out_1(Tensor out,
 Tensor self,
 Tensor other)

hamming_window_0

public static Tensor hamming_window_0(long window_length,
 TensorOptions options)

hamming_window_1

public static Tensor hamming_window_1(long window_length,
 boolean periodic,
 TensorOptions options)

hamming_window_2

public static Tensor hamming_window_2(long window_length,
 boolean periodic,
 double alpha,
 TensorOptions options)

hamming_window_3

public static Tensor hamming_window_3(long window_length,
 boolean periodic,
 double alpha,
 double beta,
 TensorOptions options)

hann_window_0

public static Tensor hann_window_0(long window_length,
 TensorOptions options)

hann_window_1

public static Tensor hann_window_1(long window_length,
 boolean periodic,
 TensorOptions options)

hardshrink

public static Tensor hardshrink(Tensor self,
 double lambd)

hardshrink_l

public static Tensor hardshrink_l(Tensor self,
 long lambd)

hardshrink_backward

public static Tensor hardshrink_backward(Tensor grad_out,
 Tensor self,
 double lambd)

hardshrink_backward_l

public static Tensor hardshrink_backward_l(Tensor grad_out,
 Tensor self,
 long lambd)

hardsigmoid

public static Tensor hardsigmoid(Tensor self)

hardsigmoid_

public static void hardsigmoid_(Tensor self)

hardsigmoid_backward

public static Tensor hardsigmoid_backward(Tensor grad_output,
 Tensor self)

hardsigmoid_out

public static void hardsigmoid_out(Tensor out,
 Tensor self)

hardswish

public static Tensor hardswish(Tensor self)

hardswish_

public static void hardswish_(Tensor self)

hardswish_backward

public static Tensor hardswish_backward(Tensor grad_output,
 Tensor self)

hardswish_out

public static void hardswish_out(Tensor out,
 Tensor self)

hardtanh

public static Tensor hardtanh(Tensor self,
 double min_val,
 double max_val)

hardtanh_l

public static Tensor hardtanh_l(Tensor self,
 long min_val,
 long max_val)

hardtanh_

public static void hardtanh_(Tensor self,
 double min_val,
 double max_val)

hardtanh__l

public static void hardtanh__l(Tensor self,
 long min_val,
 long max_val)

hardtanh_backward

public static Tensor hardtanh_backward(Tensor grad_output,
 Tensor self,
 double min_val,
 double max_val)

hardtanh_backward_l

public static Tensor hardtanh_backward_l(Tensor grad_output,
 Tensor self,
 long min_val,
 long max_val)

hardtanh_backward_out

public static void hardtanh_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 double min_val,
 double max_val)

hardtanh_backward_out_l

public static void hardtanh_backward_out_l(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long min_val,
 long max_val)

hardtanh_out

public static void hardtanh_out(Tensor out,
 Tensor self,
 double min_val,
 double max_val)

hardtanh_out_l

public static void hardtanh_out_l(Tensor out,
 Tensor self,
 long min_val,
 long max_val)

heaviside

public static Tensor heaviside(Tensor self,
 Tensor values)

heaviside_out

public static void heaviside_out(Tensor out,
 Tensor self,
 Tensor values)

hinge_embedding_loss

public static Tensor hinge_embedding_loss(Tensor self,
 Tensor target,
 double margin,
 long reduction)

histc

public static Tensor histc(Tensor self,
 long bins,
 double min,
 double max)

histc_l

public static Tensor histc_l(Tensor self,
 long bins,
 long min,
 long max)

histc_out

public static void histc_out(Tensor out,
 Tensor self,
 long bins,
 double min,
 double max)

histc_out_l

public static void histc_out_l(Tensor out,
 Tensor self,
 long bins,
 long min,
 long max)

hsplit_0

public static Tensor[] hsplit_0(Tensor self,
 long sections)

hsplit_1

public static Tensor[] hsplit_1(Tensor self,
 long[] indices)

hspmm

public static Tensor hspmm(Tensor mat1,
 Tensor mat2)

hspmm_out

public static void hspmm_out(Tensor out,
 Tensor mat1,
 Tensor mat2)

hstack

public static Tensor hstack(Tensor[] tensors)

hstack_out

public static void hstack_out(Tensor out,
 Tensor[] tensors)

huber_loss

public static Tensor huber_loss(Tensor self,
 Tensor target,
 long reduction,
 double delta)

huber_loss_backward

public static Tensor huber_loss_backward(Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction,
 double delta)

huber_loss_backward_out

public static void huber_loss_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction,
 double delta)

huber_loss_out

public static void huber_loss_out(Tensor out,
 Tensor self,
 Tensor target,
 long reduction,
 double delta)

hypot

public static Tensor hypot(Tensor self,
 Tensor other)

hypot_out

public static void hypot_out(Tensor out,
 Tensor self,
 Tensor other)

i0

public static Tensor i0(Tensor self)

i0_

public static void i0_(Tensor self)

i0_out

public static void i0_out(Tensor out,
 Tensor self)

igamma

public static Tensor igamma(Tensor self,
 Tensor other)

igamma_out

public static void igamma_out(Tensor out,
 Tensor self,
 Tensor other)

igammac

public static Tensor igammac(Tensor self,
 Tensor other)

igammac_out

public static void igammac_out(Tensor out,
 Tensor self,
 Tensor other)

im2col

public static Tensor im2col(Tensor self,
 long[] kernel_size,
 long[] dilation,
 long[] padding,
 long[] stride)

im2col_out

public static void im2col_out(Tensor out,
 Tensor self,
 long[] kernel_size,
 long[] dilation,
 long[] padding,
 long[] stride)

imag

public static Tensor imag(Tensor self)

index

public static Tensor index(Tensor self,
 Tensor[] indices)

index_add_0

public static Tensor index_add_0(Tensor self,
 long dim,
 Tensor index,
 Tensor source)

index_add_1

public static Tensor index_add_1(Tensor self,
 long dim,
 Tensor index,
 Tensor source,
 double alpha)

index_add_1_l

public static Tensor index_add_1_l(Tensor self,
 long dim,
 Tensor index,
 Tensor source,
 long alpha)

index_copy

public static Tensor index_copy(Tensor self,
 long dim,
 Tensor index,
 Tensor source)

index_copy_out

public static void index_copy_out(Tensor out,
 Tensor self,
 long dim,
 Tensor index,
 Tensor source)

index_fill_0

public static Tensor index_fill_0(Tensor self,
 long dim,
 Tensor index,
 double value)

index_fill_0_l

public static Tensor index_fill_0_l(Tensor self,
 long dim,
 Tensor index,
 long value)

index_fill_1

public static Tensor index_fill_1(Tensor self,
 long dim,
 Tensor index,
 Tensor value)

index_put

public static Tensor index_put(Tensor self,
 Tensor[] indices,
 Tensor values,
 boolean accumulate)

index_put_

public static void index_put_(Tensor self,
 Tensor[] indices,
 Tensor values,
 boolean accumulate)

index_select

public static Tensor index_select(Tensor self,
 long dim,
 Tensor index)

index_select_backward

public static Tensor index_select_backward(Tensor grad,
 long[] self_sizes,
 long dim,
 Tensor index)

index_select_out

public static void index_select_out(Tensor out,
 Tensor self,
 long dim,
 Tensor index)

infinitely_differentiable_gelu_backward

public static Tensor infinitely_differentiable_gelu_backward(Tensor grad,
 Tensor self)

inner

public static Tensor inner(Tensor self,
 Tensor other)

inner_out

public static void inner_out(Tensor out,
 Tensor self,
 Tensor other)

instance_norm

public static Tensor instance_norm(Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 boolean use_input_stats,
 double momentum,
 double eps,
 boolean cudnn_enabled)

int_repr

public static Tensor int_repr(Tensor self)

inverse

public static Tensor inverse(Tensor self)

inverse_out

public static void inverse_out(Tensor out,
 Tensor self)

is_distributed

public static boolean is_distributed(Tensor self)

is_nonzero

public static boolean is_nonzero(Tensor self)

is_same_size

public static boolean is_same_size(Tensor self,
 Tensor other)

is_vulkan_available

public static boolean is_vulkan_available()

isclose

public static Tensor isclose(Tensor self,
 Tensor other,
 double rtol,
 double atol,
 boolean equal_nan)

isfinite

public static Tensor isfinite(Tensor self)

isinf

public static Tensor isinf(Tensor self)

isnan

public static Tensor isnan(Tensor self)

isneginf

public static Tensor isneginf(Tensor self)

isneginf_out

public static void isneginf_out(Tensor out,
 Tensor self)

isposinf

public static Tensor isposinf(Tensor self)

isposinf_out

public static void isposinf_out(Tensor out,
 Tensor self)

isreal

public static Tensor isreal(Tensor self)

istft

public static Tensor istft(Tensor self,
 long n_fft,
 long hop_length,
 long win_length,
 scala.Option<Tensor> window,
 boolean center,
 boolean normalized,
 long length,
 boolean return_complex)

kaiser_window_0

public static Tensor kaiser_window_0(long window_length,
 TensorOptions options)

kaiser_window_1

public static Tensor kaiser_window_1(long window_length,
 boolean periodic,
 TensorOptions options)

kaiser_window_2

public static Tensor kaiser_window_2(long window_length,
 boolean periodic,
 double beta,
 TensorOptions options)

kl_div

public static Tensor kl_div(Tensor self,
 Tensor target,
 long reduction,
 boolean log_target)

kron

public static Tensor kron(Tensor self,
 Tensor other)

kron_out

public static void kron_out(Tensor out,
 Tensor self,
 Tensor other)

kthvalue

public static scala.Tuple2<Tensor,Tensor> kthvalue(Tensor self,
 long k,
 long dim,
 boolean keepdim)

kthvalue_out

public static scala.Tuple2<Tensor,Tensor> kthvalue_out(Tensor values,
 Tensor indices,
 Tensor self,
 long k,
 long dim,
 boolean keepdim)

layer_norm

public static Tensor layer_norm(Tensor input,
 long[] normalized_shape,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 double eps,
 boolean cudnn_enable)

lcm

public static Tensor lcm(Tensor self,
 Tensor other)

lcm_

public static void lcm_(Tensor self,
 Tensor other)

lcm_out

public static void lcm_out(Tensor out,
 Tensor self,
 Tensor other)

ldexp

public static Tensor ldexp(Tensor self,
 Tensor other)

ldexp_

public static void ldexp_(Tensor self,
 Tensor other)

ldexp_out

public static void ldexp_out(Tensor out,
 Tensor self,
 Tensor other)

le_0

public static Tensor le_0(Tensor self,
 double other)

le_0_l

public static Tensor le_0_l(Tensor self,
 long other)

le_1

public static Tensor le_1(Tensor self,
 Tensor other)

le_out_0

public static void le_out_0(Tensor out,
 Tensor self,
 double other)

le_out_0_l

public static void le_out_0_l(Tensor out,
 Tensor self,
 long other)

le_out_1

public static void le_out_1(Tensor out,
 Tensor self,
 Tensor other)

leaky_relu

public static Tensor leaky_relu(Tensor self,
 double negative_slope)

leaky_relu_l

public static Tensor leaky_relu_l(Tensor self,
 long negative_slope)

leaky_relu_

public static void leaky_relu_(Tensor self,
 double negative_slope)

leaky_relu__l

public static void leaky_relu__l(Tensor self,
 long negative_slope)

leaky_relu_backward

public static Tensor leaky_relu_backward(Tensor grad_output,
 Tensor self,
 double negative_slope,
 boolean self_is_result)

leaky_relu_backward_l

public static Tensor leaky_relu_backward_l(Tensor grad_output,
 Tensor self,
 long negative_slope,
 boolean self_is_result)

leaky_relu_out

public static void leaky_relu_out(Tensor out,
 Tensor self,
 double negative_slope)

leaky_relu_out_l

public static void leaky_relu_out_l(Tensor out,
 Tensor self,
 long negative_slope)

lerp_0

public static Tensor lerp_0(Tensor self,
 Tensor end,
 double weight)

lerp_0_l

public static Tensor lerp_0_l(Tensor self,
 Tensor end,
 long weight)

lerp_1

public static Tensor lerp_1(Tensor self,
 Tensor end,
 Tensor weight)

lerp_out_0

public static void lerp_out_0(Tensor out,
 Tensor self,
 Tensor end,
 double weight)

lerp_out_0_l

public static void lerp_out_0_l(Tensor out,
 Tensor self,
 Tensor end,
 long weight)

lerp_out_1

public static void lerp_out_1(Tensor out,
 Tensor self,
 Tensor end,
 Tensor weight)

less_0

public static Tensor less_0(Tensor self,
 double other)

less_0_l

public static Tensor less_0_l(Tensor self,
 long other)

less_1

public static Tensor less_1(Tensor self,
 Tensor other)

less_equal_0

public static Tensor less_equal_0(Tensor self,
 double other)

less_equal_0_l

public static Tensor less_equal_0_l(Tensor self,
 long other)

less_equal_1

public static Tensor less_equal_1(Tensor self,
 Tensor other)

less_equal_out_0

public static void less_equal_out_0(Tensor out,
 Tensor self,
 double other)

less_equal_out_0_l

public static void less_equal_out_0_l(Tensor out,
 Tensor self,
 long other)

less_equal_out_1

public static void less_equal_out_1(Tensor out,
 Tensor self,
 Tensor other)

less_out_0

public static void less_out_0(Tensor out,
 Tensor self,
 double other)

less_out_0_l

public static void less_out_0_l(Tensor out,
 Tensor self,
 long other)

less_out_1

public static void less_out_1(Tensor out,
 Tensor self,
 Tensor other)

lgamma

public static Tensor lgamma(Tensor self)

lgamma_out

public static void lgamma_out(Tensor out,
 Tensor self)

linalg_cholesky

public static Tensor linalg_cholesky(Tensor self,
 boolean upper)

linalg_cholesky_ex

public static scala.Tuple2<Tensor,Tensor> linalg_cholesky_ex(Tensor self,
 boolean check_errors)

linalg_cholesky_ex_out

public static scala.Tuple2<Tensor,Tensor> linalg_cholesky_ex_out(Tensor L,
 Tensor info,
 Tensor self,
 boolean check_errors)

linalg_cholesky_out

public static void linalg_cholesky_out(Tensor out,
 Tensor self,
 boolean upper)

linalg_cond_0

public static Tensor linalg_cond_0(Tensor self,
 double p)

linalg_cond_1

public static Tensor linalg_cond_1(Tensor self,
 String p)

linalg_cond_out_0

public static void linalg_cond_out_0(Tensor out,
 Tensor self,
 double p)

linalg_cond_out_1

public static void linalg_cond_out_1(Tensor out,
 Tensor self,
 String p)

linalg_det

public static Tensor linalg_det(Tensor self)

linalg_det_out

public static void linalg_det_out(Tensor out,
 Tensor self)

linalg_eig

public static scala.Tuple2<Tensor,Tensor> linalg_eig(Tensor self)

linalg_eig_out

public static scala.Tuple2<Tensor,Tensor> linalg_eig_out(Tensor eigenvalues,
 Tensor eigenvectors,
 Tensor self)

linalg_eigh

public static scala.Tuple2<Tensor,Tensor> linalg_eigh(Tensor self,
 String UPLO)

linalg_eigh_out

public static scala.Tuple2<Tensor,Tensor> linalg_eigh_out(Tensor eigvals,
 Tensor eigvecs,
 Tensor self,
 String UPLO)

linalg_eigvals

public static Tensor linalg_eigvals(Tensor self)

linalg_eigvals_out

public static void linalg_eigvals_out(Tensor out,
 Tensor self)

linalg_eigvalsh

public static Tensor linalg_eigvalsh(Tensor self,
 String UPLO)

linalg_eigvalsh_out

public static void linalg_eigvalsh_out(Tensor out,
 Tensor self,
 String UPLO)

linalg_householder_product

public static Tensor linalg_householder_product(Tensor input,
 Tensor tau)

linalg_householder_product_out

public static void linalg_householder_product_out(Tensor out,
 Tensor input,
 Tensor tau)

linalg_inv

public static Tensor linalg_inv(Tensor self)

linalg_inv_ex

public static scala.Tuple2<Tensor,Tensor> linalg_inv_ex(Tensor self,
 boolean check_errors)

linalg_inv_ex_out

public static scala.Tuple2<Tensor,Tensor> linalg_inv_ex_out(Tensor inverse,
 Tensor info,
 Tensor self,
 boolean check_errors)

linalg_inv_out

public static void linalg_inv_out(Tensor out,
 Tensor self)

linalg_lstsq

public static scala.Tuple4<Tensor,Tensor,Tensor,Tensor> linalg_lstsq(Tensor self,
 Tensor b)

linalg_lstsq_out

public static scala.Tuple4<Tensor,Tensor,Tensor,Tensor> linalg_lstsq_out(Tensor solution,
 Tensor residuals,
 Tensor rank,
 Tensor singular_values,
 Tensor self,
 Tensor b)

linalg_matrix_norm_0

public static Tensor linalg_matrix_norm_0(Tensor self,
 double ord,
 long[] dim,
 boolean keepdim)

linalg_matrix_norm_0_l

public static Tensor linalg_matrix_norm_0_l(Tensor self,
 long ord,
 long[] dim,
 boolean keepdim)

linalg_matrix_norm_1

public static Tensor linalg_matrix_norm_1(Tensor self,
 String ord,
 long[] dim,
 boolean keepdim)

linalg_matrix_norm_out_0

public static void linalg_matrix_norm_out_0(Tensor out,
 Tensor self,
 double ord,
 long[] dim,
 boolean keepdim)

linalg_matrix_norm_out_0_l

public static void linalg_matrix_norm_out_0_l(Tensor out,
 Tensor self,
 long ord,
 long[] dim,
 boolean keepdim)

linalg_matrix_norm_out_1

public static void linalg_matrix_norm_out_1(Tensor out,
 Tensor self,
 String ord,
 long[] dim,
 boolean keepdim)

linalg_matrix_power

public static Tensor linalg_matrix_power(Tensor self,
 long n)

linalg_matrix_power_out

public static void linalg_matrix_power_out(Tensor out,
 Tensor self,
 long n)

linalg_matrix_rank_0

public static Tensor linalg_matrix_rank_0(Tensor self,
 boolean hermitian)

linalg_matrix_rank_1

public static Tensor linalg_matrix_rank_1(Tensor input,
 Tensor tol,
 boolean hermitian)

linalg_matrix_rank_out_0

public static void linalg_matrix_rank_out_0(Tensor out,
 Tensor self,
 boolean hermitian)

linalg_matrix_rank_out_1

public static void linalg_matrix_rank_out_1(Tensor out,
 Tensor input,
 Tensor tol,
 boolean hermitian)

linalg_multi_dot

public static Tensor linalg_multi_dot(Tensor[] tensors)

linalg_multi_dot_out

public static void linalg_multi_dot_out(Tensor out,
 Tensor[] tensors)

linalg_norm_0

public static Tensor linalg_norm_0(Tensor self,
 double ord,
 boolean keepdim)

linalg_norm_1

public static Tensor linalg_norm_1(Tensor self,
 String ord,
 boolean keepdim)

linalg_norm_out_0

public static void linalg_norm_out_0(Tensor out,
 Tensor self,
 double ord,
 boolean keepdim)

linalg_norm_out_1

public static void linalg_norm_out_1(Tensor out,
 Tensor self,
 String ord,
 boolean keepdim)

linalg_pinv_0

public static Tensor linalg_pinv_0(Tensor self,
 double rcond,
 boolean hermitian)

linalg_pinv_1

public static Tensor linalg_pinv_1(Tensor self,
 Tensor rcond,
 boolean hermitian)

linalg_pinv_out_0

public static void linalg_pinv_out_0(Tensor out,
 Tensor self,
 double rcond,
 boolean hermitian)

linalg_pinv_out_1

public static void linalg_pinv_out_1(Tensor out,
 Tensor self,
 Tensor rcond,
 boolean hermitian)

linalg_qr

public static scala.Tuple2<Tensor,Tensor> linalg_qr(Tensor self,
 String mode)

linalg_qr_out

public static scala.Tuple2<Tensor,Tensor> linalg_qr_out(Tensor Q,
 Tensor R,
 Tensor self,
 String mode)

linalg_slogdet

public static scala.Tuple2<Tensor,Tensor> linalg_slogdet(Tensor self)

linalg_slogdet_out

public static scala.Tuple2<Tensor,Tensor> linalg_slogdet_out(Tensor sign,
 Tensor logabsdet,
 Tensor self)

linalg_solve

public static Tensor linalg_solve(Tensor input,
 Tensor other)

linalg_solve_out

public static void linalg_solve_out(Tensor out,
 Tensor input,
 Tensor other)

linalg_svd

public static scala.Tuple3<Tensor,Tensor,Tensor> linalg_svd(Tensor self,
 boolean full_matrices)

linalg_svd_out

public static scala.Tuple3<Tensor,Tensor,Tensor> linalg_svd_out(Tensor U,
 Tensor S,
 Tensor Vh,
 Tensor self,
 boolean full_matrices)

linalg_svdvals

public static Tensor linalg_svdvals(Tensor input)

linalg_svdvals_out

public static void linalg_svdvals_out(Tensor out,
 Tensor input)

linalg_tensorinv

public static Tensor linalg_tensorinv(Tensor self,
 long ind)

linalg_tensorinv_out

public static void linalg_tensorinv_out(Tensor out,
 Tensor self,
 long ind)

linalg_tensorsolve

public static Tensor linalg_tensorsolve(Tensor self,
 Tensor other)

linalg_tensorsolve_out

public static void linalg_tensorsolve_out(Tensor out,
 Tensor self,
 Tensor other)

linalg_vector_norm

public static Tensor linalg_vector_norm(Tensor self,
 double ord,
 boolean keepdim)

linalg_vector_norm_l

public static Tensor linalg_vector_norm_l(Tensor self,
 long ord,
 boolean keepdim)

linalg_vector_norm_out

public static void linalg_vector_norm_out(Tensor out,
 Tensor self,
 double ord,
 boolean keepdim)

linalg_vector_norm_out_l

public static void linalg_vector_norm_out_l(Tensor out,
 Tensor self,
 long ord,
 boolean keepdim)

linear

public static Tensor linear(Tensor input,
 Tensor weight,
 scala.Option<Tensor> bias)

linspace_0

public static Tensor linspace_0(double start,
 double end,
 long steps,
 TensorOptions options)

linspace_0_l

public static Tensor linspace_0_l(long start,
 long end,
 long steps,
 TensorOptions options)

linspace_1

public static Tensor linspace_1(double start,
 double end,
 long steps)

linspace_1_l

public static Tensor linspace_1_l(long start,
 long end,
 long steps)

linspace_2

public static Tensor linspace_2(double start,
 double end,
 long steps)

linspace_2_l

public static Tensor linspace_2_l(long start,
 long end,
 long steps)

linspace_out

public static void linspace_out(Tensor out,
 double start,
 double end,
 long steps)

linspace_out_l

public static void linspace_out_l(Tensor out,
 long start,
 long end,
 long steps)

log

public static Tensor log(Tensor self)

log10

public static Tensor log10(Tensor self)

log10_

public static void log10_(Tensor self)

log10_out

public static void log10_out(Tensor out,
 Tensor self)

log1p

public static Tensor log1p(Tensor self)

log1p_

public static void log1p_(Tensor self)

log1p_out

public static void log1p_out(Tensor out,
 Tensor self)

log2

public static Tensor log2(Tensor self)

log2_

public static void log2_(Tensor self)

log2_out

public static void log2_out(Tensor out,
 Tensor self)

log_

public static void log_(Tensor self)

log_out

public static void log_out(Tensor out,
 Tensor self)

log_sigmoid

public static Tensor log_sigmoid(Tensor self)

log_sigmoid_backward

public static Tensor log_sigmoid_backward(Tensor grad_output,
 Tensor self,
 Tensor buffer)

log_sigmoid_backward_out

public static void log_sigmoid_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor buffer)

log_sigmoid_forward

public static scala.Tuple2<Tensor,Tensor> log_sigmoid_forward(Tensor self)

log_sigmoid_forward_out

public static scala.Tuple2<Tensor,Tensor> log_sigmoid_forward_out(Tensor output,
 Tensor buffer,
 Tensor self)

log_sigmoid_out

public static void log_sigmoid_out(Tensor out,
 Tensor self)

log_softmax

public static Tensor log_softmax(Tensor self,
 long dim)

logaddexp

public static Tensor logaddexp(Tensor self,
 Tensor other)

logaddexp2

public static Tensor logaddexp2(Tensor self,
 Tensor other)

logaddexp2_out

public static void logaddexp2_out(Tensor out,
 Tensor self,
 Tensor other)

logaddexp_out

public static void logaddexp_out(Tensor out,
 Tensor self,
 Tensor other)

logcumsumexp

public static Tensor logcumsumexp(Tensor self,
 long dim)

logcumsumexp_out

public static void logcumsumexp_out(Tensor out,
 Tensor self,
 long dim)

logdet

public static Tensor logdet(Tensor self)

logical_and

public static Tensor logical_and(Tensor self,
 Tensor other)

logical_and_out

public static void logical_and_out(Tensor out,
 Tensor self,
 Tensor other)

logical_not

public static Tensor logical_not(Tensor self)

logical_not_out

public static void logical_not_out(Tensor out,
 Tensor self)

logical_or

public static Tensor logical_or(Tensor self,
 Tensor other)

logical_or_out

public static void logical_or_out(Tensor out,
 Tensor self,
 Tensor other)

logical_xor

public static Tensor logical_xor(Tensor self,
 Tensor other)

logical_xor_out

public static void logical_xor_out(Tensor out,
 Tensor self,
 Tensor other)

logit

public static Tensor logit(Tensor self)

logit_

public static void logit_(Tensor self)

logit_backward

public static Tensor logit_backward(Tensor grad_output,
 Tensor self)

logit_backward_out

public static void logit_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self)

logit_out

public static void logit_out(Tensor out,
 Tensor self)

logspace

public static Tensor logspace(double start,
 double end,
 long steps,
 double base)

logspace_l

public static Tensor logspace_l(long start,
 long end,
 long steps,
 double base)

logspace_out

public static void logspace_out(Tensor out,
 double start,
 double end,
 long steps,
 double base)

logspace_out_l

public static void logspace_out_l(Tensor out,
 long start,
 long end,
 long steps,
 double base)

logsumexp

public static Tensor logsumexp(Tensor self,
 long[] dim,
 boolean keepdim)

logsumexp_out

public static void logsumexp_out(Tensor out,
 Tensor self,
 long[] dim,
 boolean keepdim)

lstm_0

public static scala.Tuple3<Tensor,Tensor,Tensor> lstm_0(Tensor input,
 Tensor[] hx,
 Tensor[] params,
 boolean has_biases,
 long num_layers,
 double dropout,
 boolean train,
 boolean bidirectional,
 boolean batch_first)

lstm_1

public static scala.Tuple3<Tensor,Tensor,Tensor> lstm_1(Tensor data,
 Tensor batch_sizes,
 Tensor[] hx,
 Tensor[] params,
 boolean has_biases,
 long num_layers,
 double dropout,
 boolean train,
 boolean bidirectional)

lstm_cell

public static scala.Tuple2<Tensor,Tensor> lstm_cell(Tensor input,
 Tensor[] hx,
 Tensor w_ih,
 Tensor w_hh,
 scala.Option<Tensor> b_ih,
 scala.Option<Tensor> b_hh)

lt_0

public static Tensor lt_0(Tensor self,
 double other)

lt_0_l

public static Tensor lt_0_l(Tensor self,
 long other)

lt_1

public static Tensor lt_1(Tensor self,
 Tensor other)

lt_out_0

public static void lt_out_0(Tensor out,
 Tensor self,
 double other)

lt_out_0_l

public static void lt_out_0_l(Tensor out,
 Tensor self,
 long other)

lt_out_1

public static void lt_out_1(Tensor out,
 Tensor self,
 Tensor other)

lu_solve

public static Tensor lu_solve(Tensor self,
 Tensor LU_data,
 Tensor LU_pivots)

lu_solve_out

public static void lu_solve_out(Tensor out,
 Tensor self,
 Tensor LU_data,
 Tensor LU_pivots)

lu_unpack

public static scala.Tuple3<Tensor,Tensor,Tensor> lu_unpack(Tensor LU_data,
 Tensor LU_pivots,
 boolean unpack_data,
 boolean unpack_pivots)

lu_unpack_out

public static scala.Tuple3<Tensor,Tensor,Tensor> lu_unpack_out(Tensor P,
 Tensor L,
 Tensor U,
 Tensor LU_data,
 Tensor LU_pivots,
 boolean unpack_data,
 boolean unpack_pivots)

margin_ranking_loss

public static Tensor margin_ranking_loss(Tensor input1,
 Tensor input2,
 Tensor target,
 double margin,
 long reduction)

masked_fill_0

public static Tensor masked_fill_0(Tensor self,
 Tensor mask,
 double value)

masked_fill_0_l

public static Tensor masked_fill_0_l(Tensor self,
 Tensor mask,
 long value)

masked_fill_1

public static Tensor masked_fill_1(Tensor self,
 Tensor mask,
 Tensor value)

masked_scatter

public static Tensor masked_scatter(Tensor self,
 Tensor mask,
 Tensor source)

masked_select

public static Tensor masked_select(Tensor self,
 Tensor mask)

masked_select_backward

public static Tensor masked_select_backward(Tensor grad,
 Tensor input,
 Tensor mask)

masked_select_out

public static void masked_select_out(Tensor out,
 Tensor self,
 Tensor mask)

matmul

public static Tensor matmul(Tensor self,
 Tensor other)

matmul_out

public static void matmul_out(Tensor out,
 Tensor self,
 Tensor other)

matrix_exp

public static Tensor matrix_exp(Tensor self)

matrix_exp_backward

public static Tensor matrix_exp_backward(Tensor self,
 Tensor grad)

matrix_power

public static Tensor matrix_power(Tensor self,
 long n)

matrix_power_out

public static void matrix_power_out(Tensor out,
 Tensor self,
 long n)

max_0

public static scala.Tuple2<Tensor,Tensor> max_0(Tensor self,
 long dim,
 boolean keepdim)

max_1

public static Tensor max_1(Tensor self)

max_2

public static Tensor max_2(Tensor self,
 Tensor other)

max_out_0

public static scala.Tuple2<Tensor,Tensor> max_out_0(Tensor max,
 Tensor max_values,
 Tensor self,
 long dim,
 boolean keepdim)

max_out_1

public static void max_out_1(Tensor out,
 Tensor self,
 Tensor other)

max_pool1d

public static Tensor max_pool1d(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

max_pool1d_with_indices

public static scala.Tuple2<Tensor,Tensor> max_pool1d_with_indices(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

max_pool2d

public static Tensor max_pool2d(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

max_pool2d_with_indices

public static scala.Tuple2<Tensor,Tensor> max_pool2d_with_indices(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

max_pool2d_with_indices_backward

public static Tensor max_pool2d_with_indices_backward(Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode,
 Tensor indices)

max_pool2d_with_indices_backward_out

public static void max_pool2d_with_indices_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode,
 Tensor indices)

max_pool2d_with_indices_out

public static scala.Tuple2<Tensor,Tensor> max_pool2d_with_indices_out(Tensor out,
 Tensor indices,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

max_pool3d

public static Tensor max_pool3d(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

max_pool3d_with_indices

public static scala.Tuple2<Tensor,Tensor> max_pool3d_with_indices(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

max_pool3d_with_indices_backward

public static Tensor max_pool3d_with_indices_backward(Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode,
 Tensor indices)

max_pool3d_with_indices_backward_out

public static void max_pool3d_with_indices_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode,
 Tensor indices)

max_pool3d_with_indices_out

public static scala.Tuple2<Tensor,Tensor> max_pool3d_with_indices_out(Tensor out,
 Tensor indices,
 Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

max_unpool2d

public static Tensor max_unpool2d(Tensor self,
 Tensor indices,
 long[] output_size)

max_unpool2d_out

public static void max_unpool2d_out(Tensor out,
 Tensor self,
 Tensor indices,
 long[] output_size)

max_unpool3d

public static Tensor max_unpool3d(Tensor self,
 Tensor indices,
 long[] output_size,
 long[] stride,
 long[] padding)

max_unpool3d_out

public static void max_unpool3d_out(Tensor out,
 Tensor self,
 Tensor indices,
 long[] output_size,
 long[] stride,
 long[] padding)

maximum

public static Tensor maximum(Tensor self,
 Tensor other)

maximum_out

public static void maximum_out(Tensor out,
 Tensor self,
 Tensor other)

mean_0

public static Tensor mean_0(Tensor self)

mean_1

public static Tensor mean_1(Tensor self,
 long[] dim,
 boolean keepdim)

mean_out

public static void mean_out(Tensor out,
 Tensor self,
 long[] dim,
 boolean keepdim)

median_0

public static Tensor median_0(Tensor self)

median_1

public static scala.Tuple2<Tensor,Tensor> median_1(Tensor self,
 long dim,
 boolean keepdim)

median_out

public static scala.Tuple2<Tensor,Tensor> median_out(Tensor values,
 Tensor indices,
 Tensor self,
 long dim,
 boolean keepdim)

meshgrid

public static Tensor[] meshgrid(Tensor[] tensors)

min_0

public static scala.Tuple2<Tensor,Tensor> min_0(Tensor self,
 long dim,
 boolean keepdim)

min_1

public static Tensor min_1(Tensor self)

min_2

public static Tensor min_2(Tensor self,
 Tensor other)

min_out_0

public static scala.Tuple2<Tensor,Tensor> min_out_0(Tensor min,
 Tensor min_indices,
 Tensor self,
 long dim,
 boolean keepdim)

min_out_1

public static void min_out_1(Tensor out,
 Tensor self,
 Tensor other)

minimum

public static Tensor minimum(Tensor self,
 Tensor other)

minimum_out

public static void minimum_out(Tensor out,
 Tensor self,
 Tensor other)

mish

public static Tensor mish(Tensor self)

mish_

public static void mish_(Tensor self)

mish_backward

public static Tensor mish_backward(Tensor grad_output,
 Tensor self)

mish_out

public static void mish_out(Tensor out,
 Tensor self)

mm

public static Tensor mm(Tensor self,
 Tensor mat2)

mm_out

public static void mm_out(Tensor out,
 Tensor self,
 Tensor mat2)

mode

public static scala.Tuple2<Tensor,Tensor> mode(Tensor self,
 long dim,
 boolean keepdim)

mode_out

public static scala.Tuple2<Tensor,Tensor> mode_out(Tensor values,
 Tensor indices,
 Tensor self,
 long dim,
 boolean keepdim)

moveaxis_0

public static Tensor moveaxis_0(Tensor self,
 long[] source,
 long[] destination)

moveaxis_1

public static Tensor moveaxis_1(Tensor self,
 long source,
 long destination)

movedim_0

public static Tensor movedim_0(Tensor self,
 long[] source,
 long[] destination)

movedim_1

public static Tensor movedim_1(Tensor self,
 long source,
 long destination)

mse_loss

public static Tensor mse_loss(Tensor self,
 Tensor target,
 long reduction)

mse_loss_backward

public static Tensor mse_loss_backward(Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction)

mse_loss_backward_out

public static void mse_loss_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction)

mse_loss_out

public static void mse_loss_out(Tensor out,
 Tensor self,
 Tensor target,
 long reduction)

msort

public static Tensor msort(Tensor self)

msort_out

public static void msort_out(Tensor out,
 Tensor self)

mul_0

public static Tensor mul_0(Tensor self,
 Tensor other)

mul_1

public static Tensor mul_1(Tensor self,
 double other)

mul_1_l

public static Tensor mul_1_l(Tensor self,
 long other)

mul_out

public static void mul_out(Tensor out,
 Tensor self,
 Tensor other)

multi_margin_loss

public static Tensor multi_margin_loss(Tensor self,
 Tensor target,
 double p,
 double margin,
 scala.Option<Tensor> weight,
 long reduction)

multi_margin_loss_l

public static Tensor multi_margin_loss_l(Tensor self,
 Tensor target,
 long p,
 long margin,
 scala.Option<Tensor> weight,
 long reduction)

multi_margin_loss_backward

public static Tensor multi_margin_loss_backward(Tensor grad_output,
 Tensor self,
 Tensor target,
 double p,
 double margin,
 scala.Option<Tensor> weight,
 long reduction)

multi_margin_loss_backward_l

public static Tensor multi_margin_loss_backward_l(Tensor grad_output,
 Tensor self,
 Tensor target,
 long p,
 long margin,
 scala.Option<Tensor> weight,
 long reduction)

multi_margin_loss_backward_out

public static void multi_margin_loss_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 double p,
 double margin,
 scala.Option<Tensor> weight,
 long reduction)

multi_margin_loss_backward_out_l

public static void multi_margin_loss_backward_out_l(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 long p,
 long margin,
 scala.Option<Tensor> weight,
 long reduction)

multi_margin_loss_out

public static void multi_margin_loss_out(Tensor out,
 Tensor self,
 Tensor target,
 double p,
 double margin,
 scala.Option<Tensor> weight,
 long reduction)

multi_margin_loss_out_l

public static void multi_margin_loss_out_l(Tensor out,
 Tensor self,
 Tensor target,
 long p,
 long margin,
 scala.Option<Tensor> weight,
 long reduction)

multilabel_margin_loss

public static Tensor multilabel_margin_loss(Tensor self,
 Tensor target,
 long reduction)

multilabel_margin_loss_backward

public static Tensor multilabel_margin_loss_backward(Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction,
 Tensor is_target)

multilabel_margin_loss_backward_out

public static void multilabel_margin_loss_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction,
 Tensor is_target)

multilabel_margin_loss_forward

public static scala.Tuple2<Tensor,Tensor> multilabel_margin_loss_forward(Tensor self,
 Tensor target,
 long reduction)

multilabel_margin_loss_forward_out

public static scala.Tuple2<Tensor,Tensor> multilabel_margin_loss_forward_out(Tensor output,
 Tensor is_target,
 Tensor self,
 Tensor target,
 long reduction)

multilabel_margin_loss_out

public static void multilabel_margin_loss_out(Tensor out,
 Tensor self,
 Tensor target,
 long reduction)

multinomial

public static Tensor multinomial(Tensor self,
 long num_samples,
 boolean replacement)

multinomial_out

public static void multinomial_out(Tensor out,
 Tensor self,
 long num_samples,
 boolean replacement)

multiply_0

public static Tensor multiply_0(Tensor self,
 Tensor other)

multiply_1

public static Tensor multiply_1(Tensor self,
 double other)

multiply_1_l

public static Tensor multiply_1_l(Tensor self,
 long other)

multiply_out

public static void multiply_out(Tensor out,
 Tensor self,
 Tensor other)

mv

public static Tensor mv(Tensor self,
 Tensor vec)

mv_out

public static void mv_out(Tensor out,
 Tensor self,
 Tensor vec)

mvlgamma

public static Tensor mvlgamma(Tensor self,
 long p)

nan_to_num

public static Tensor nan_to_num(Tensor self)

nan_to_num_

public static void nan_to_num_(Tensor self)

nan_to_num_out

public static void nan_to_num_out(Tensor out,
 Tensor self)

nanmedian_0

public static Tensor nanmedian_0(Tensor self)

nanmedian_1

public static scala.Tuple2<Tensor,Tensor> nanmedian_1(Tensor self,
 long dim,
 boolean keepdim)

nanmedian_out

public static scala.Tuple2<Tensor,Tensor> nanmedian_out(Tensor values,
 Tensor indices,
 Tensor self,
 long dim,
 boolean keepdim)

nanquantile_0

public static Tensor nanquantile_0(Tensor self,
 double q,
 long dim,
 boolean keepdim,
 String interpolation)

nanquantile_1

public static Tensor nanquantile_1(Tensor self,
 Tensor q,
 long dim,
 boolean keepdim,
 String interpolation)

nanquantile_out_0

public static void nanquantile_out_0(Tensor out,
 Tensor self,
 double q,
 long dim,
 boolean keepdim)

nanquantile_out_1

public static void nanquantile_out_1(Tensor out,
 Tensor self,
 double q,
 long dim,
 boolean keepdim,
 String interpolation)

nanquantile_out_2

public static void nanquantile_out_2(Tensor out,
 Tensor self,
 Tensor q,
 long dim,
 boolean keepdim,
 String interpolation)

narrow_0

public static Tensor narrow_0(Tensor self,
 long dim,
 long start,
 long length)

narrow_1

public static Tensor narrow_1(Tensor self,
 long dim,
 Tensor start,
 long length)

narrow_copy

public static Tensor narrow_copy(Tensor self,
 long dim,
 long start,
 long length)

narrow_copy_out

public static void narrow_copy_out(Tensor out,
 Tensor self,
 long dim,
 long start,
 long length)

native_batch_norm

public static scala.Tuple3<Tensor,Tensor,Tensor> native_batch_norm(Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 boolean training,
 double momentum,
 double eps)

native_batch_norm_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> native_batch_norm_backward(Tensor grad_out,
 Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 scala.Option<Tensor> save_mean,
 scala.Option<Tensor> save_invstd,
 boolean train,
 double eps,
 boolean[] output_mask)

native_batch_norm_out

public static scala.Tuple3<Tensor,Tensor,Tensor> native_batch_norm_out(Tensor out,
 Tensor save_mean,
 Tensor save_invstd,
 Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 scala.Option<Tensor> running_mean,
 scala.Option<Tensor> running_var,
 boolean training,
 double momentum,
 double eps)

native_group_norm

public static scala.Tuple3<Tensor,Tensor,Tensor> native_group_norm(Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 long N,
 long C,
 long HxW,
 long group,
 double eps)

native_group_norm_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> native_group_norm_backward(Tensor grad_out,
 Tensor input,
 Tensor mean,
 Tensor rstd,
 scala.Option<Tensor> weight,
 long N,
 long C,
 long HxW,
 long group,
 boolean[] output_mask)

native_layer_norm

public static scala.Tuple3<Tensor,Tensor,Tensor> native_layer_norm(Tensor input,
 long[] normalized_shape,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 double eps)

native_layer_norm_backward

public static scala.Tuple3<Tensor,Tensor,Tensor> native_layer_norm_backward(Tensor grad_out,
 Tensor input,
 long[] normalized_shape,
 Tensor mean,
 Tensor rstd,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 boolean[] output_mask)

native_norm_0

public static Tensor native_norm_0(Tensor self,
 double p)

native_norm_0_l

public static Tensor native_norm_0_l(Tensor self,
 long p)

native_norm_1

public static Tensor native_norm_1(Tensor self,
 double p,
 long[] dim,
 boolean keepdim)

ne_0

public static Tensor ne_0(Tensor self,
 double other)

ne_0_l

public static Tensor ne_0_l(Tensor self,
 long other)

ne_1

public static Tensor ne_1(Tensor self,
 Tensor other)

ne_out_0

public static void ne_out_0(Tensor out,
 Tensor self,
 double other)

ne_out_0_l

public static void ne_out_0_l(Tensor out,
 Tensor self,
 long other)

ne_out_1

public static void ne_out_1(Tensor out,
 Tensor self,
 Tensor other)

neg

public static Tensor neg(Tensor self)

neg_

public static void neg_(Tensor self)

neg_out

public static void neg_out(Tensor out,
 Tensor self)

negative

public static Tensor negative(Tensor self)

negative_

public static void negative_(Tensor self)

negative_out

public static void negative_out(Tensor out,
 Tensor self)

nextafter

public static Tensor nextafter(Tensor self,
 Tensor other)

nextafter_out

public static void nextafter_out(Tensor out,
 Tensor self,
 Tensor other)

nll_loss

public static Tensor nll_loss(Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nll_loss2d

public static Tensor nll_loss2d(Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nll_loss2d_backward

public static Tensor nll_loss2d_backward(Tensor grad_output,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index,
 Tensor total_weight)

nll_loss2d_backward_out

public static void nll_loss2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index,
 Tensor total_weight)

nll_loss2d_forward

public static scala.Tuple2<Tensor,Tensor> nll_loss2d_forward(Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nll_loss2d_forward_out

public static scala.Tuple2<Tensor,Tensor> nll_loss2d_forward_out(Tensor output,
 Tensor total_weight,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nll_loss2d_out

public static void nll_loss2d_out(Tensor out,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nll_loss_backward

public static Tensor nll_loss_backward(Tensor grad_output,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index,
 Tensor total_weight)

nll_loss_backward_out

public static void nll_loss_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index,
 Tensor total_weight)

nll_loss_forward

public static scala.Tuple2<Tensor,Tensor> nll_loss_forward(Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nll_loss_forward_out

public static scala.Tuple2<Tensor,Tensor> nll_loss_forward_out(Tensor output,
 Tensor total_weight,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nll_loss_nd

public static Tensor nll_loss_nd(Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nll_loss_out

public static void nll_loss_out(Tensor out,
 Tensor self,
 Tensor target,
 scala.Option<Tensor> weight,
 long reduction,
 long ignore_index)

nonzero

public static Tensor nonzero(Tensor self)

nonzero_numpy

public static Tensor[] nonzero_numpy(Tensor self)

nonzero_out

public static void nonzero_out(Tensor out,
 Tensor self)

norm_0

public static Tensor norm_0(Tensor self,
 double p,
 byte dtype)

norm_1

public static Tensor norm_1(Tensor self,
 double p)

norm_1_l

public static Tensor norm_1_l(Tensor self,
 long p)

norm_2

public static Tensor norm_2(Tensor self,
 double p,
 long[] dim,
 boolean keepdim,
 byte dtype)

norm_3

public static Tensor norm_3(Tensor self,
 double p,
 long[] dim,
 boolean keepdim)

norm_except_dim

public static Tensor norm_except_dim(Tensor v,
 long pow,
 long dim)

norm_out_0

public static void norm_out_0(Tensor out,
 Tensor self,
 double p,
 long[] dim,
 boolean keepdim,
 byte dtype)

norm_out_1

public static void norm_out_1(Tensor out,
 Tensor self,
 double p,
 long[] dim,
 boolean keepdim)

normal_0

public static Tensor normal_0(Tensor mean,
 double std)

normal_1

public static Tensor normal_1(double mean,
 Tensor std)

normal_2

public static Tensor normal_2(Tensor mean,
 Tensor std)

normal_3

public static Tensor normal_3(double mean,
 double std,
 long[] size,
 TensorOptions options)

normal_out_0

public static void normal_out_0(Tensor out,
 Tensor mean,
 double std)

normal_out_1

public static void normal_out_1(Tensor out,
 double mean,
 Tensor std)

normal_out_2

public static void normal_out_2(Tensor out,
 Tensor mean,
 Tensor std)

normal_out_3

public static void normal_out_3(Tensor out,
 double mean,
 double std,
 long[] size)

not_equal_0

public static Tensor not_equal_0(Tensor self,
 double other)

not_equal_0_l

public static Tensor not_equal_0_l(Tensor self,
 long other)

not_equal_1

public static Tensor not_equal_1(Tensor self,
 Tensor other)

not_equal_out_0

public static void not_equal_out_0(Tensor out,
 Tensor self,
 double other)

not_equal_out_0_l

public static void not_equal_out_0_l(Tensor out,
 Tensor self,
 long other)

not_equal_out_1

public static void not_equal_out_1(Tensor out,
 Tensor self,
 Tensor other)

nuclear_norm_0

public static Tensor nuclear_norm_0(Tensor self,
 boolean keepdim)

nuclear_norm_1

public static Tensor nuclear_norm_1(Tensor self,
 long[] dim,
 boolean keepdim)

nuclear_norm_out_0

public static void nuclear_norm_out_0(Tensor out,
 Tensor self,
 boolean keepdim)

nuclear_norm_out_1

public static void nuclear_norm_out_1(Tensor out,
 Tensor self,
 long[] dim,
 boolean keepdim)

one_hot

public static Tensor one_hot(Tensor self,
 long num_classes)

ones

public static Tensor ones(long[] size,
 TensorOptions options)

ones_like

public static Tensor ones_like(Tensor self,
 TensorOptions options)

ones_out

public static void ones_out(Tensor out,
 long[] size)

orgqr

public static Tensor orgqr(Tensor self,
 Tensor input2)

orgqr_out

public static void orgqr_out(Tensor out,
 Tensor self,
 Tensor input2)

ormqr

public static Tensor ormqr(Tensor self,
 Tensor input2,
 Tensor input3,
 boolean left,
 boolean transpose)

ormqr_out

public static void ormqr_out(Tensor out,
 Tensor self,
 Tensor input2,
 Tensor input3,
 boolean left,
 boolean transpose)

outer

public static Tensor outer(Tensor self,
 Tensor vec2)

outer_out

public static void outer_out(Tensor out,
 Tensor self,
 Tensor vec2)

pad_sequence

public static Tensor pad_sequence(Tensor[] sequences,
 boolean batch_first,
 double padding_value)

pairwise_distance

public static Tensor pairwise_distance(Tensor x1,
 Tensor x2,
 double p,
 double eps,
 boolean keepdim)

pdist

public static Tensor pdist(Tensor self,
 double p)

permute

public static Tensor permute(Tensor self,
 long[] dims)

pinverse

public static Tensor pinverse(Tensor self,
 double rcond)

pixel_shuffle

public static Tensor pixel_shuffle(Tensor self,
 long upscale_factor)

pixel_unshuffle

public static Tensor pixel_unshuffle(Tensor self,
 long downscale_factor)

poisson

public static Tensor poisson(Tensor self)

poisson_nll_loss

public static Tensor poisson_nll_loss(Tensor input,
 Tensor target,
 boolean log_input,
 boolean full,
 double eps,
 long reduction)

polar

public static Tensor polar(Tensor abs,
 Tensor angle)

polar_out

public static void polar_out(Tensor out,
 Tensor abs,
 Tensor angle)

polygamma

public static Tensor polygamma(long n,
 Tensor self)

polygamma_out

public static void polygamma_out(Tensor out,
 long n,
 Tensor self)

positive

public static Tensor positive(Tensor self)

pow_0

public static Tensor pow_0(Tensor self,
 Tensor exponent)

pow_1

public static Tensor pow_1(double self,
 Tensor exponent)

pow_1_l

public static Tensor pow_1_l(long self,
 Tensor exponent)

pow_2

public static Tensor pow_2(Tensor self,
 double exponent)

pow_2_l

public static Tensor pow_2_l(Tensor self,
 long exponent)

pow_out_0

public static void pow_out_0(Tensor out,
 Tensor self,
 Tensor exponent)

pow_out_1

public static void pow_out_1(Tensor out,
 double self,
 Tensor exponent)

pow_out_1_l

public static void pow_out_1_l(Tensor out,
 long self,
 Tensor exponent)

pow_out_2

public static void pow_out_2(Tensor out,
 Tensor self,
 double exponent)

pow_out_2_l

public static void pow_out_2_l(Tensor out,
 Tensor self,
 long exponent)

prelu

public static Tensor prelu(Tensor self,
 Tensor weight)

prod_0

public static Tensor prod_0(Tensor self)

prod_1

public static Tensor prod_1(Tensor self,
 long dim,
 boolean keepdim)

prod_out

public static void prod_out(Tensor out,
 Tensor self,
 long dim,
 boolean keepdim)

promote_types

public static byte promote_types(byte type1,
 byte type2)

put

public static Tensor put(Tensor self,
 Tensor index,
 Tensor source,
 boolean accumulate)

q_per_channel_axis

public static long q_per_channel_axis(Tensor self)

q_per_channel_scales

public static Tensor q_per_channel_scales(Tensor self)

q_per_channel_zero_points

public static Tensor q_per_channel_zero_points(Tensor self)

q_scale

public static double q_scale(Tensor self)

q_zero_point

public static long q_zero_point(Tensor self)

qr

public static scala.Tuple2<Tensor,Tensor> qr(Tensor self,
 boolean some)

qr_out

public static scala.Tuple2<Tensor,Tensor> qr_out(Tensor Q,
 Tensor R,
 Tensor self,
 boolean some)

quantile_0

public static Tensor quantile_0(Tensor self,
 double q,
 long dim,
 boolean keepdim)

quantile_1

public static Tensor quantile_1(Tensor self,
 Tensor q,
 long dim,
 boolean keepdim)

quantile_2

public static Tensor quantile_2(Tensor self,
 double q,
 long dim,
 boolean keepdim,
 String interpolation)

quantile_3

public static Tensor quantile_3(Tensor self,
 Tensor q,
 long dim,
 boolean keepdim,
 String interpolation)

quantile_out_0

public static void quantile_out_0(Tensor out,
 Tensor self,
 double q,
 long dim,
 boolean keepdim)

quantile_out_1

public static void quantile_out_1(Tensor out,
 Tensor self,
 Tensor q,
 long dim,
 boolean keepdim)

quantile_out_2

public static void quantile_out_2(Tensor out,
 Tensor self,
 double q,
 long dim,
 boolean keepdim,
 String interpolation)

quantile_out_3

public static void quantile_out_3(Tensor out,
 Tensor self,
 Tensor q,
 long dim,
 boolean keepdim,
 String interpolation)

quantize_per_channel

public static Tensor quantize_per_channel(Tensor self,
 Tensor scales,
 Tensor zero_points,
 long axis,
 byte dtype)

quantize_per_tensor_0

public static Tensor quantize_per_tensor_0(Tensor self,
 double scale,
 long zero_point,
 byte dtype)

quantize_per_tensor_1

public static Tensor[] quantize_per_tensor_1(Tensor[] tensors,
 Tensor scales,
 Tensor zero_points,
 byte dtype)

quantized_batch_norm

public static Tensor quantized_batch_norm(Tensor input,
 scala.Option<Tensor> weight,
 scala.Option<Tensor> bias,
 Tensor mean,
 Tensor var,
 double eps,
 double output_scale,
 long output_zero_point)

quantized_gru_cell

public static Tensor quantized_gru_cell(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 Tensor b_ih,
 Tensor b_hh,
 Tensor packed_ih,
 Tensor packed_hh,
 Tensor col_offsets_ih,
 Tensor col_offsets_hh,
 double scale_ih,
 double scale_hh,
 double zero_point_ih,
 double zero_point_hh)

quantized_gru_cell_l

public static Tensor quantized_gru_cell_l(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 Tensor b_ih,
 Tensor b_hh,
 Tensor packed_ih,
 Tensor packed_hh,
 Tensor col_offsets_ih,
 Tensor col_offsets_hh,
 long scale_ih,
 long scale_hh,
 long zero_point_ih,
 long zero_point_hh)

quantized_lstm_cell

public static scala.Tuple2<Tensor,Tensor> quantized_lstm_cell(Tensor input,
 Tensor[] hx,
 Tensor w_ih,
 Tensor w_hh,
 Tensor b_ih,
 Tensor b_hh,
 Tensor packed_ih,
 Tensor packed_hh,
 Tensor col_offsets_ih,
 Tensor col_offsets_hh,
 double scale_ih,
 double scale_hh,
 double zero_point_ih,
 double zero_point_hh)

quantized_lstm_cell_l

public static scala.Tuple2<Tensor,Tensor> quantized_lstm_cell_l(Tensor input,
 Tensor[] hx,
 Tensor w_ih,
 Tensor w_hh,
 Tensor b_ih,
 Tensor b_hh,
 Tensor packed_ih,
 Tensor packed_hh,
 Tensor col_offsets_ih,
 Tensor col_offsets_hh,
 long scale_ih,
 long scale_hh,
 long zero_point_ih,
 long zero_point_hh)

quantized_max_pool1d

public static Tensor quantized_max_pool1d(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

quantized_max_pool2d

public static Tensor quantized_max_pool2d(Tensor self,
 long[] kernel_size,
 long[] stride,
 long[] padding,
 long[] dilation,
 boolean ceil_mode)

quantized_rnn_relu_cell

public static Tensor quantized_rnn_relu_cell(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 Tensor b_ih,
 Tensor b_hh,
 Tensor packed_ih,
 Tensor packed_hh,
 Tensor col_offsets_ih,
 Tensor col_offsets_hh,
 double scale_ih,
 double scale_hh,
 double zero_point_ih,
 double zero_point_hh)

quantized_rnn_relu_cell_l

public static Tensor quantized_rnn_relu_cell_l(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 Tensor b_ih,
 Tensor b_hh,
 Tensor packed_ih,
 Tensor packed_hh,
 Tensor col_offsets_ih,
 Tensor col_offsets_hh,
 long scale_ih,
 long scale_hh,
 long zero_point_ih,
 long zero_point_hh)

quantized_rnn_tanh_cell

public static Tensor quantized_rnn_tanh_cell(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 Tensor b_ih,
 Tensor b_hh,
 Tensor packed_ih,
 Tensor packed_hh,
 Tensor col_offsets_ih,
 Tensor col_offsets_hh,
 double scale_ih,
 double scale_hh,
 double zero_point_ih,
 double zero_point_hh)

quantized_rnn_tanh_cell_l

public static Tensor quantized_rnn_tanh_cell_l(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 Tensor b_ih,
 Tensor b_hh,
 Tensor packed_ih,
 Tensor packed_hh,
 Tensor col_offsets_ih,
 Tensor col_offsets_hh,
 long scale_ih,
 long scale_hh,
 long zero_point_ih,
 long zero_point_hh)

rad2deg

public static Tensor rad2deg(Tensor self)

rad2deg_

public static void rad2deg_(Tensor self)

rad2deg_out

public static void rad2deg_out(Tensor out,
 Tensor self)

rand

public static Tensor rand(long[] size,
 TensorOptions options)

rand_like

public static Tensor rand_like(Tensor self,
 TensorOptions options)

rand_out_0

public static void rand_out_0(Tensor out,
 long[] size)

rand_out_1

public static void rand_out_1(Tensor out,
 long[] size)

randint_0

public static Tensor randint_0(long high,
 long[] size,
 TensorOptions options)

randint_1

public static Tensor randint_1(long high,
 long[] size,
 TensorOptions options)

randint_2

public static Tensor randint_2(long low,
 long high,
 long[] size,
 TensorOptions options)

randint_3

public static Tensor randint_3(long low,
 long high,
 long[] size,
 TensorOptions options)

randint_like_0

public static Tensor randint_like_0(Tensor self,
 long high,
 TensorOptions options)

randint_like_1

public static Tensor randint_like_1(Tensor self,
 long low,
 long high,
 TensorOptions options)

randint_out_0

public static void randint_out_0(Tensor out,
 long high,
 long[] size)

randint_out_1

public static void randint_out_1(Tensor out,
 long high,
 long[] size)

randint_out_2

public static void randint_out_2(Tensor out,
 long low,
 long high,
 long[] size)

randint_out_3

public static void randint_out_3(Tensor out,
 long low,
 long high,
 long[] size)

randn

public static Tensor randn(long[] size,
 TensorOptions options)

randn_like

public static Tensor randn_like(Tensor self,
 TensorOptions options)

randn_out_0

public static void randn_out_0(Tensor out,
 long[] size)

randn_out_1

public static void randn_out_1(Tensor out,
 long[] size)

randperm_0

public static Tensor randperm_0(long n,
 TensorOptions options)

randperm_1

public static Tensor randperm_1(long n,
 TensorOptions options)

randperm_out_0

public static void randperm_out_0(Tensor out,
 long n)

randperm_out_1

public static void randperm_out_1(Tensor out,
 long n)

range_0

public static Tensor range_0(double start,
 double end,
 double step,
 TensorOptions options)

range_0_l

public static Tensor range_0_l(long start,
 long end,
 long step,
 TensorOptions options)

range_1

public static Tensor range_1(double start,
 double end,
 TensorOptions options)

range_1_l

public static Tensor range_1_l(long start,
 long end,
 TensorOptions options)

range_out

public static void range_out(Tensor out,
 double start,
 double end,
 double step)

range_out_l

public static void range_out_l(Tensor out,
 long start,
 long end,
 long step)

ravel

public static Tensor ravel(Tensor self)

real

public static Tensor real(Tensor self)

reciprocal

public static Tensor reciprocal(Tensor self)

reciprocal_

public static void reciprocal_(Tensor self)

reciprocal_out

public static void reciprocal_out(Tensor out,
 Tensor self)

reflection_pad1d

public static Tensor reflection_pad1d(Tensor self,
 long[] padding)

reflection_pad1d_backward

public static Tensor reflection_pad1d_backward(Tensor grad_output,
 Tensor self,
 long[] padding)

reflection_pad1d_backward_out

public static void reflection_pad1d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] padding)

reflection_pad1d_out

public static void reflection_pad1d_out(Tensor out,
 Tensor self,
 long[] padding)

reflection_pad2d

public static Tensor reflection_pad2d(Tensor self,
 long[] padding)

reflection_pad2d_backward

public static Tensor reflection_pad2d_backward(Tensor grad_output,
 Tensor self,
 long[] padding)

reflection_pad2d_backward_out

public static void reflection_pad2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] padding)

reflection_pad2d_out

public static void reflection_pad2d_out(Tensor out,
 Tensor self,
 long[] padding)

relu

public static Tensor relu(Tensor self)

relu6

public static Tensor relu6(Tensor self)

relu6_

public static void relu6_(Tensor self)

relu_

public static void relu_(Tensor self)

remainder_0

public static Tensor remainder_0(Tensor self,
 double other)

remainder_0_l

public static Tensor remainder_0_l(Tensor self,
 long other)

remainder_1

public static Tensor remainder_1(Tensor self,
 Tensor other)

remainder_out_0

public static void remainder_out_0(Tensor out,
 Tensor self,
 double other)

remainder_out_0_l

public static void remainder_out_0_l(Tensor out,
 Tensor self,
 long other)

remainder_out_1

public static void remainder_out_1(Tensor out,
 Tensor self,
 Tensor other)

renorm

public static Tensor renorm(Tensor self,
 double p,
 long dim,
 double maxnorm)

renorm_l

public static Tensor renorm_l(Tensor self,
 long p,
 long dim,
 long maxnorm)

renorm_out

public static void renorm_out(Tensor out,
 Tensor self,
 double p,
 long dim,
 double maxnorm)

renorm_out_l

public static void renorm_out_l(Tensor out,
 Tensor self,
 long p,
 long dim,
 long maxnorm)

repeat_interleave_0

public static Tensor repeat_interleave_0(Tensor repeats)

repeat_interleave_1

public static Tensor repeat_interleave_1(Tensor self,
 Tensor repeats,
 long dim)

repeat_interleave_2

public static Tensor repeat_interleave_2(Tensor self,
 long repeats,
 long dim)

replication_pad1d

public static Tensor replication_pad1d(Tensor self,
 long[] padding)

replication_pad1d_backward

public static Tensor replication_pad1d_backward(Tensor grad_output,
 Tensor self,
 long[] padding)

replication_pad1d_backward_out

public static void replication_pad1d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] padding)

replication_pad1d_out

public static void replication_pad1d_out(Tensor out,
 Tensor self,
 long[] padding)

replication_pad2d

public static Tensor replication_pad2d(Tensor self,
 long[] padding)

replication_pad2d_backward

public static Tensor replication_pad2d_backward(Tensor grad_output,
 Tensor self,
 long[] padding)

replication_pad2d_backward_out

public static void replication_pad2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] padding)

replication_pad2d_out

public static void replication_pad2d_out(Tensor out,
 Tensor self,
 long[] padding)

replication_pad3d

public static Tensor replication_pad3d(Tensor self,
 long[] padding)

replication_pad3d_backward

public static Tensor replication_pad3d_backward(Tensor grad_output,
 Tensor self,
 long[] padding)

replication_pad3d_backward_out

public static void replication_pad3d_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long[] padding)

replication_pad3d_out

public static void replication_pad3d_out(Tensor out,
 Tensor self,
 long[] padding)

reshape

public static Tensor reshape(Tensor self,
 long[] shape)

resize_as_

public static void resize_as_(Tensor self,
 Tensor the_template)

resize_as_sparse_

public static void resize_as_sparse_(Tensor self,
 Tensor the_template)

result_type_0

public static byte result_type_0(Tensor tensor,
 Tensor other)

result_type_1

public static byte result_type_1(Tensor tensor,
 double other)

result_type_1_l

public static byte result_type_1_l(Tensor tensor,
 long other)

result_type_2

public static byte result_type_2(double scalar,
 Tensor tensor)

result_type_2_l

public static byte result_type_2_l(long scalar,
 Tensor tensor)

result_type_3

public static byte result_type_3(double scalar1,
 double scalar2)

result_type_3_l

public static byte result_type_3_l(long scalar1,
 long scalar2)

rnn_relu_0

public static scala.Tuple2<Tensor,Tensor> rnn_relu_0(Tensor input,
 Tensor hx,
 Tensor[] params,
 boolean has_biases,
 long num_layers,
 double dropout,
 boolean train,
 boolean bidirectional,
 boolean batch_first)

rnn_relu_1

public static scala.Tuple2<Tensor,Tensor> rnn_relu_1(Tensor data,
 Tensor batch_sizes,
 Tensor hx,
 Tensor[] params,
 boolean has_biases,
 long num_layers,
 double dropout,
 boolean train,
 boolean bidirectional)

rnn_relu_cell

public static Tensor rnn_relu_cell(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 scala.Option<Tensor> b_ih,
 scala.Option<Tensor> b_hh)

rnn_tanh_0

public static scala.Tuple2<Tensor,Tensor> rnn_tanh_0(Tensor input,
 Tensor hx,
 Tensor[] params,
 boolean has_biases,
 long num_layers,
 double dropout,
 boolean train,
 boolean bidirectional,
 boolean batch_first)

rnn_tanh_1

public static scala.Tuple2<Tensor,Tensor> rnn_tanh_1(Tensor data,
 Tensor batch_sizes,
 Tensor hx,
 Tensor[] params,
 boolean has_biases,
 long num_layers,
 double dropout,
 boolean train,
 boolean bidirectional)

rnn_tanh_cell

public static Tensor rnn_tanh_cell(Tensor input,
 Tensor hx,
 Tensor w_ih,
 Tensor w_hh,
 scala.Option<Tensor> b_ih,
 scala.Option<Tensor> b_hh)

roll

public static Tensor roll(Tensor self,
 long[] shifts,
 long[] dims)

rot90

public static Tensor rot90(Tensor self,
 long k,
 long[] dims)

round

public static Tensor round(Tensor self)

round_

public static void round_(Tensor self)

round_out

public static void round_out(Tensor out,
 Tensor self)

row_stack

public static Tensor row_stack(Tensor[] tensors)

row_stack_out

public static void row_stack_out(Tensor out,
 Tensor[] tensors)

rrelu

public static Tensor rrelu(Tensor self,
 double lower,
 double upper,
 boolean training)

rrelu_l

public static Tensor rrelu_l(Tensor self,
 long lower,
 long upper,
 boolean training)

rrelu_

public static void rrelu_(Tensor self,
 double lower,
 double upper,
 boolean training)

rrelu__l

public static void rrelu__l(Tensor self,
 long lower,
 long upper,
 boolean training)

rrelu_with_noise

public static Tensor rrelu_with_noise(Tensor self,
 Tensor noise,
 double lower,
 double upper,
 boolean training)

rrelu_with_noise_l

public static Tensor rrelu_with_noise_l(Tensor self,
 Tensor noise,
 long lower,
 long upper,
 boolean training)

rrelu_with_noise_

public static void rrelu_with_noise_(Tensor self,
 Tensor noise,
 double lower,
 double upper,
 boolean training)

rrelu_with_noise__l

public static void rrelu_with_noise__l(Tensor self,
 Tensor noise,
 long lower,
 long upper,
 boolean training)

rrelu_with_noise_backward

public static Tensor rrelu_with_noise_backward(Tensor grad_output,
 Tensor self,
 Tensor noise,
 double lower,
 double upper,
 boolean training,
 boolean self_is_result)

rrelu_with_noise_backward_l

public static Tensor rrelu_with_noise_backward_l(Tensor grad_output,
 Tensor self,
 Tensor noise,
 long lower,
 long upper,
 boolean training,
 boolean self_is_result)

rrelu_with_noise_out

public static void rrelu_with_noise_out(Tensor out,
 Tensor self,
 Tensor noise,
 double lower,
 double upper,
 boolean training)

rrelu_with_noise_out_l

public static void rrelu_with_noise_out_l(Tensor out,
 Tensor self,
 Tensor noise,
 long lower,
 long upper,
 boolean training)

rsqrt

public static Tensor rsqrt(Tensor self)

rsqrt_

public static void rsqrt_(Tensor self)

rsqrt_out

public static void rsqrt_out(Tensor out,
 Tensor self)

rsub_0

public static Tensor rsub_0(Tensor self,
 Tensor other,
 double alpha)

rsub_0_l

public static Tensor rsub_0_l(Tensor self,
 Tensor other,
 long alpha)

rsub_1

public static Tensor rsub_1(Tensor self,
 double other,
 double alpha)

rsub_1_l

public static Tensor rsub_1_l(Tensor self,
 long other,
 long alpha)

scalar_tensor

public static Tensor scalar_tensor(double s,
 TensorOptions options)

scalar_tensor_l

public static Tensor scalar_tensor_l(long s,
 TensorOptions options)

scatter_0

public static Tensor scatter_0(Tensor self,
 long dim,
 Tensor index,
 Tensor src)

scatter_1

public static Tensor scatter_1(Tensor self,
 long dim,
 Tensor index,
 double value)

scatter_1_l

public static Tensor scatter_1_l(Tensor self,
 long dim,
 Tensor index,
 long value)

scatter_add

public static Tensor scatter_add(Tensor self,
 long dim,
 Tensor index,
 Tensor src)

searchsorted_0

public static Tensor searchsorted_0(Tensor sorted_sequence,
 Tensor self,
 boolean out_int32,
 boolean right)

searchsorted_1

public static Tensor searchsorted_1(Tensor sorted_sequence,
 double self,
 boolean out_int32,
 boolean right)

searchsorted_1_l

public static Tensor searchsorted_1_l(Tensor sorted_sequence,
 long self,
 boolean out_int32,
 boolean right)

searchsorted_out

public static void searchsorted_out(Tensor out,
 Tensor sorted_sequence,
 Tensor self,
 boolean out_int32,
 boolean right)

select

public static Tensor select(Tensor self,
 long dim,
 long index)

select_backward

public static Tensor select_backward(Tensor grad,
 long[] input_sizes,
 long dim,
 long index)

selu

public static Tensor selu(Tensor self)

selu_

public static void selu_(Tensor self)

sgn

public static Tensor sgn(Tensor self)

sgn_out

public static void sgn_out(Tensor out,
 Tensor self)

sigmoid

public static Tensor sigmoid(Tensor self)

sigmoid_

public static void sigmoid_(Tensor self)

sigmoid_backward

public static Tensor sigmoid_backward(Tensor grad_output,
 Tensor output)

sigmoid_backward_out

public static void sigmoid_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor output)

sigmoid_out

public static void sigmoid_out(Tensor out,
 Tensor self)

sign

public static Tensor sign(Tensor self)

sign_out

public static void sign_out(Tensor out,
 Tensor self)

signbit

public static Tensor signbit(Tensor self)

signbit_out

public static void signbit_out(Tensor out,
 Tensor self)

silu

public static Tensor silu(Tensor self)

silu_

public static void silu_(Tensor self)

silu_backward

public static Tensor silu_backward(Tensor grad_output,
 Tensor self)

silu_out

public static void silu_out(Tensor out,
 Tensor self)

sin

public static Tensor sin(Tensor self)

sin_

public static void sin_(Tensor self)

sin_out

public static void sin_out(Tensor out,
 Tensor self)

sinc

public static Tensor sinc(Tensor self)

sinc_

public static void sinc_(Tensor self)

sinc_out

public static void sinc_out(Tensor out,
 Tensor self)

sinh

public static Tensor sinh(Tensor self)

sinh_

public static void sinh_(Tensor self)

sinh_out

public static void sinh_out(Tensor out,
 Tensor self)

slice

public static Tensor slice(Tensor self,
 long dim,
 long start,
 long end,
 long step)

slice_backward

public static Tensor slice_backward(Tensor grad,
 long[] input_sizes,
 long dim,
 long start,
 long end,
 long step)

slogdet

public static scala.Tuple2<Tensor,Tensor> slogdet(Tensor self)

smm

public static Tensor smm(Tensor self,
 Tensor mat2)

smooth_l1_loss_0

public static Tensor smooth_l1_loss_0(Tensor self,
 Tensor target,
 long reduction,
 double beta)

smooth_l1_loss_1

public static Tensor smooth_l1_loss_1(Tensor self,
 Tensor target,
 long reduction,
 double beta)

smooth_l1_loss_backward_0

public static Tensor smooth_l1_loss_backward_0(Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction,
 double beta)

smooth_l1_loss_backward_1

public static Tensor smooth_l1_loss_backward_1(Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction,
 double beta)

smooth_l1_loss_backward_out_0

public static void smooth_l1_loss_backward_out_0(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction,
 double beta)

smooth_l1_loss_backward_out_1

public static void smooth_l1_loss_backward_out_1(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction,
 double beta)

smooth_l1_loss_out_0

public static void smooth_l1_loss_out_0(Tensor out,
 Tensor self,
 Tensor target,
 long reduction,
 double beta)

smooth_l1_loss_out_1

public static void smooth_l1_loss_out_1(Tensor out,
 Tensor self,
 Tensor target,
 long reduction,
 double beta)

soft_margin_loss

public static Tensor soft_margin_loss(Tensor self,
 Tensor target,
 long reduction)

soft_margin_loss_backward

public static Tensor soft_margin_loss_backward(Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction)

soft_margin_loss_backward_out

public static void soft_margin_loss_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 Tensor target,
 long reduction)

soft_margin_loss_out

public static void soft_margin_loss_out(Tensor out,
 Tensor self,
 Tensor target,
 long reduction)

softmax

public static Tensor softmax(Tensor self,
 long dim)

softplus

public static Tensor softplus(Tensor self,
 double beta,
 double threshold)

softplus_l

public static Tensor softplus_l(Tensor self,
 long beta,
 long threshold)

softplus_backward

public static Tensor softplus_backward(Tensor grad_output,
 Tensor self,
 double beta,
 double threshold)

softplus_backward_l

public static Tensor softplus_backward_l(Tensor grad_output,
 Tensor self,
 long beta,
 long threshold)

softplus_backward_out

public static void softplus_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 double beta,
 double threshold)

softplus_backward_out_l

public static void softplus_backward_out_l(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long beta,
 long threshold)

softplus_out

public static void softplus_out(Tensor out,
 Tensor self,
 double beta,
 double threshold)

softplus_out_l

public static void softplus_out_l(Tensor out,
 Tensor self,
 long beta,
 long threshold)

softshrink

public static Tensor softshrink(Tensor self,
 double lambd)

softshrink_l

public static Tensor softshrink_l(Tensor self,
 long lambd)

softshrink_backward

public static Tensor softshrink_backward(Tensor grad_output,
 Tensor self,
 double lambd)

softshrink_backward_l

public static Tensor softshrink_backward_l(Tensor grad_output,
 Tensor self,
 long lambd)

softshrink_backward_out

public static void softshrink_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 double lambd)

softshrink_backward_out_l

public static void softshrink_backward_out_l(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long lambd)

softshrink_out

public static void softshrink_out(Tensor out,
 Tensor self,
 double lambd)

softshrink_out_l

public static void softshrink_out_l(Tensor out,
 Tensor self,
 long lambd)

sort

public static scala.Tuple2<Tensor,Tensor> sort(Tensor self,
 long dim,
 boolean descending)

sort_out_0

public static scala.Tuple2<Tensor,Tensor> sort_out_0(Tensor values,
 Tensor indices,
 Tensor self,
 long dim,
 boolean descending)

sort_out_1

public static scala.Tuple2<Tensor,Tensor> sort_out_1(Tensor values,
 Tensor indices,
 Tensor self,
 long dim,
 boolean descending)

sparse_coo_tensor

public static Tensor sparse_coo_tensor(Tensor indices,
 Tensor values,
 long[] size,
 TensorOptions options)

sparse_csr_tensor

public static Tensor sparse_csr_tensor(Tensor crow_indices,
 Tensor col_indices,
 Tensor values,
 long[] size)

special_entr

public static Tensor special_entr(Tensor self)

special_entr_out

public static void special_entr_out(Tensor out,
 Tensor self)

special_erf

public static Tensor special_erf(Tensor self)

special_erf_out

public static void special_erf_out(Tensor out,
 Tensor self)

special_erfc

public static Tensor special_erfc(Tensor self)

special_erfc_out

public static void special_erfc_out(Tensor out,
 Tensor self)

special_erfinv

public static Tensor special_erfinv(Tensor self)

special_erfinv_out

public static void special_erfinv_out(Tensor out,
 Tensor self)

special_exp2

public static Tensor special_exp2(Tensor self)

special_exp2_out

public static void special_exp2_out(Tensor out,
 Tensor self)

special_expit

public static Tensor special_expit(Tensor self)

special_expit_out

public static void special_expit_out(Tensor out,
 Tensor self)

special_expm1

public static Tensor special_expm1(Tensor self)

special_expm1_out

public static void special_expm1_out(Tensor out,
 Tensor self)

special_gammaln

public static Tensor special_gammaln(Tensor self)

special_gammaln_out

public static void special_gammaln_out(Tensor out,
 Tensor self)

special_i0e

public static Tensor special_i0e(Tensor self)

special_i0e_out

public static void special_i0e_out(Tensor out,
 Tensor self)

special_logit

public static Tensor special_logit(Tensor self)

special_logit_out

public static void special_logit_out(Tensor out,
 Tensor self)

special_xlog1py_0

public static Tensor special_xlog1py_0(Tensor self,
 Tensor other)

special_xlog1py_1

public static Tensor special_xlog1py_1(double self,
 Tensor other)

special_xlog1py_1_l

public static Tensor special_xlog1py_1_l(long self,
 Tensor other)

special_xlog1py_2

public static Tensor special_xlog1py_2(Tensor self,
 double other)

special_xlog1py_2_l

public static Tensor special_xlog1py_2_l(Tensor self,
 long other)

special_xlog1py_out_0

public static void special_xlog1py_out_0(Tensor out,
 Tensor self,
 Tensor other)

special_xlog1py_out_1

public static void special_xlog1py_out_1(Tensor out,
 double self,
 Tensor other)

special_xlog1py_out_1_l

public static void special_xlog1py_out_1_l(Tensor out,
 long self,
 Tensor other)

special_xlog1py_out_2

public static void special_xlog1py_out_2(Tensor out,
 Tensor self,
 double other)

special_xlog1py_out_2_l

public static void special_xlog1py_out_2_l(Tensor out,
 Tensor self,
 long other)

split

public static Tensor[] split(Tensor self,
 long split_size,
 long dim)

split_with_sizes

public static Tensor[] split_with_sizes(Tensor self,
 long[] split_sizes,
 long dim)

sqrt

public static Tensor sqrt(Tensor self)

sqrt_

public static void sqrt_(Tensor self)

sqrt_out

public static void sqrt_out(Tensor out,
 Tensor self)

square

public static Tensor square(Tensor self)

square_

public static void square_(Tensor self)

square_out

public static void square_out(Tensor out,
 Tensor self)

squeeze_0

public static Tensor squeeze_0(Tensor self)

squeeze_1

public static Tensor squeeze_1(Tensor self,
 long dim)

sspaddmm

public static Tensor sspaddmm(Tensor self,
 Tensor mat1,
 Tensor mat2,
 double beta,
 double alpha)

sspaddmm_l

public static Tensor sspaddmm_l(Tensor self,
 Tensor mat1,
 Tensor mat2,
 long beta,
 long alpha)

sspaddmm_out

public static void sspaddmm_out(Tensor out,
 Tensor self,
 Tensor mat1,
 Tensor mat2,
 double beta,
 double alpha)

sspaddmm_out_l

public static void sspaddmm_out_l(Tensor out,
 Tensor self,
 Tensor mat1,
 Tensor mat2,
 long beta,
 long alpha)

stack

public static Tensor stack(Tensor[] tensors,
 long dim)

stack_out

public static void stack_out(Tensor out,
 Tensor[] tensors,
 long dim)

std_0

public static Tensor std_0(Tensor self,
 boolean unbiased)

std_1

public static Tensor std_1(Tensor self,
 long[] dim,
 boolean unbiased,
 boolean keepdim)

std_2

public static Tensor std_2(Tensor self,
 long correction,
 boolean keepdim)

std_mean_0

public static scala.Tuple2<Tensor,Tensor> std_mean_0(Tensor self,
 boolean unbiased)

std_mean_1

public static scala.Tuple2<Tensor,Tensor> std_mean_1(Tensor self,
 long[] dim,
 boolean unbiased,
 boolean keepdim)

std_mean_2

public static scala.Tuple2<Tensor,Tensor> std_mean_2(Tensor self,
 long correction,
 boolean keepdim)

std_out_0

public static void std_out_0(Tensor out,
 Tensor self,
 long[] dim,
 boolean unbiased,
 boolean keepdim)

std_out_1

public static void std_out_1(Tensor out,
 Tensor self,
 long correction,
 boolean keepdim)

stft

public static Tensor stft(Tensor self,
 long n_fft,
 long hop_length,
 long win_length,
 scala.Option<Tensor> window,
 boolean normalized)

sub_0

public static Tensor sub_0(Tensor self,
 Tensor other,
 double alpha)

sub_0_l

public static Tensor sub_0_l(Tensor self,
 Tensor other,
 long alpha)

sub_1

public static Tensor sub_1(Tensor self,
 double other,
 double alpha)

sub_1_l

public static Tensor sub_1_l(Tensor self,
 long other,
 long alpha)

sub_out

public static void sub_out(Tensor out,
 Tensor self,
 Tensor other,
 double alpha)

sub_out_l

public static void sub_out_l(Tensor out,
 Tensor self,
 Tensor other,
 long alpha)

subtract_0

public static Tensor subtract_0(Tensor self,
 Tensor other,
 double alpha)

subtract_0_l

public static Tensor subtract_0_l(Tensor self,
 Tensor other,
 long alpha)

subtract_1

public static Tensor subtract_1(Tensor self,
 double other,
 double alpha)

subtract_1_l

public static Tensor subtract_1_l(Tensor self,
 long other,
 long alpha)

subtract_out

public static void subtract_out(Tensor out,
 Tensor self,
 Tensor other,
 double alpha)

subtract_out_l

public static void subtract_out_l(Tensor out,
 Tensor self,
 Tensor other,
 long alpha)

sum_0

public static Tensor sum_0(Tensor self)

sum_1

public static Tensor sum_1(Tensor self,
 long[] dim,
 boolean keepdim)

sum_out

public static void sum_out(Tensor out,
 Tensor self,
 long[] dim,
 boolean keepdim)

svd

public static scala.Tuple3<Tensor,Tensor,Tensor> svd(Tensor self,
 boolean some,
 boolean compute_uv)

svd_out

public static scala.Tuple3<Tensor,Tensor,Tensor> svd_out(Tensor U,
 Tensor S,
 Tensor V,
 Tensor self,
 boolean some,
 boolean compute_uv)

swapaxes

public static Tensor swapaxes(Tensor self,
 long axis0,
 long axis1)

swapdims

public static Tensor swapdims(Tensor self,
 long dim0,
 long dim1)

t

public static Tensor t(Tensor self)

take

public static Tensor take(Tensor self,
 Tensor index)

take_along_dim

public static Tensor take_along_dim(Tensor self,
 Tensor indices,
 long dim)

take_along_dim_out

public static void take_along_dim_out(Tensor out,
 Tensor self,
 Tensor indices,
 long dim)

take_out

public static void take_out(Tensor out,
 Tensor self,
 Tensor index)

tan

public static Tensor tan(Tensor self)

tan_

public static void tan_(Tensor self)

tan_out

public static void tan_out(Tensor out,
 Tensor self)

tanh

public static Tensor tanh(Tensor self)

tanh_

public static void tanh_(Tensor self)

tanh_backward

public static Tensor tanh_backward(Tensor grad_output,
 Tensor output)

tanh_backward_out

public static void tanh_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor output)

tanh_out

public static void tanh_out(Tensor out,
 Tensor self)

tensor_split_0

public static Tensor[] tensor_split_0(Tensor self,
 long sections,
 long dim)

tensor_split_1

public static Tensor[] tensor_split_1(Tensor self,
 long[] indices,
 long dim)

tensor_split_2

public static Tensor[] tensor_split_2(Tensor self,
 Tensor tensor_indices_or_sections,
 long dim)

tensordot

public static Tensor tensordot(Tensor self,
 Tensor other,
 long[] dims_self,
 long[] dims_other)

tensordot_out

public static void tensordot_out(Tensor out,
 Tensor self,
 Tensor other,
 long[] dims_self,
 long[] dims_other)

threshold

public static Tensor threshold(Tensor self,
 double threshold,
 double value)

threshold_l

public static Tensor threshold_l(Tensor self,
 long threshold,
 long value)

threshold_

public static void threshold_(Tensor self,
 double threshold,
 double value)

threshold__l

public static void threshold__l(Tensor self,
 long threshold,
 long value)

threshold_backward

public static Tensor threshold_backward(Tensor grad_output,
 Tensor self,
 double threshold)

threshold_backward_l

public static Tensor threshold_backward_l(Tensor grad_output,
 Tensor self,
 long threshold)

threshold_backward_out

public static void threshold_backward_out(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 double threshold)

threshold_backward_out_l

public static void threshold_backward_out_l(Tensor grad_input,
 Tensor grad_output,
 Tensor self,
 long threshold)

threshold_out

public static void threshold_out(Tensor out,
 Tensor self,
 double threshold,
 double value)

threshold_out_l

public static void threshold_out_l(Tensor out,
 Tensor self,
 long threshold,
 long value)

tile

public static Tensor tile(Tensor self,
 long[] dims)

to_dense_backward

public static Tensor to_dense_backward(Tensor grad,
 Tensor input)

topk

public static scala.Tuple2<Tensor,Tensor> topk(Tensor self,
 long k,
 long dim,
 boolean largest,
 boolean sorted)

topk_out

public static scala.Tuple2<Tensor,Tensor> topk_out(Tensor values,
 Tensor indices,
 Tensor self,
 long k,
 long dim,
 boolean largest,
 boolean sorted)

trace

public static Tensor trace(Tensor self)

trace_backward

public static Tensor trace_backward(Tensor grad,
 long[] sizes)

transpose

public static Tensor transpose(Tensor self,
 long dim0,
 long dim1)

trapz_0

public static Tensor trapz_0(Tensor y,
 Tensor x,
 long dim)

trapz_1

public static Tensor trapz_1(Tensor y,
 double dx,
 long dim)

triangular_solve

public static scala.Tuple2<Tensor,Tensor> triangular_solve(Tensor self,
 Tensor A,
 boolean upper,
 boolean transpose,
 boolean unitriangular)

triangular_solve_out

public static scala.Tuple2<Tensor,Tensor> triangular_solve_out(Tensor X,
 Tensor M,
 Tensor self,
 Tensor A,
 boolean upper,
 boolean transpose,
 boolean unitriangular)

tril

public static Tensor tril(Tensor self,
 long diagonal)

tril_indices

public static Tensor tril_indices(long row,
 long col,
 long offset,
 TensorOptions options)

tril_out

public static void tril_out(Tensor out,
 Tensor self,
 long diagonal)

triplet_margin_loss

public static Tensor triplet_margin_loss(Tensor anchor,
 Tensor positive,
 Tensor negative,
 double margin,
 double p,
 double eps,
 boolean swap,
 long reduction)

triu

public static Tensor triu(Tensor self,
 long diagonal)

triu_indices

public static Tensor triu_indices(long row,
 long col,
 long offset,
 TensorOptions options)

triu_out

public static void triu_out(Tensor out,
 Tensor self,
 long diagonal)

true_divide_0

public static Tensor true_divide_0(Tensor self,
 Tensor other)

true_divide_1

public static Tensor true_divide_1(Tensor self,
 double other)

true_divide_1_l

public static Tensor true_divide_1_l(Tensor self,
 long other)

true_divide_out

public static void true_divide_out(Tensor out,
 Tensor self,
 Tensor other)

trunc

public static Tensor trunc(Tensor self)

trunc_

public static void trunc_(Tensor self)

trunc_out

public static void trunc_out(Tensor out,
 Tensor self)

unbind

public static Tensor[] unbind(Tensor self,
 long dim)

unflatten_dense_tensors

public static Tensor[] unflatten_dense_tensors(Tensor flat,
 Tensor[] tensors)

unfold_backward

public static Tensor unfold_backward(Tensor grad_in,
 long[] input_sizes,
 long dim,
 long size,
 long step)

unique_consecutive

public static scala.Tuple3<Tensor,Tensor,Tensor> unique_consecutive(Tensor self,
 boolean return_inverse,
 boolean return_counts,
 long dim)

unique_dim

public static scala.Tuple3<Tensor,Tensor,Tensor> unique_dim(Tensor self,
 long dim,
 boolean sorted,
 boolean return_inverse,
 boolean return_counts)

unique_dim_consecutive

public static scala.Tuple3<Tensor,Tensor,Tensor> unique_dim_consecutive(Tensor self,
 long dim,
 boolean return_inverse,
 boolean return_counts)

unsafe_chunk

public static Tensor[] unsafe_chunk(Tensor self,
 long chunks,
 long dim)

unsafe_split

public static Tensor[] unsafe_split(Tensor self,
 long split_size,
 long dim)

unsafe_split_with_sizes

public static Tensor[] unsafe_split_with_sizes(Tensor self,
 long[] split_sizes,
 long dim)

unsqueeze

public static Tensor unsqueeze(Tensor self,
 long dim)

upsample_bicubic2d

public static Tensor upsample_bicubic2d(Tensor self,
 long[] output_size,
 boolean align_corners)

upsample_bicubic2d_backward

public static Tensor upsample_bicubic2d_backward(Tensor grad_output,
 long[] output_size,
 long[] input_size,
 boolean align_corners)

upsample_bicubic2d_backward_out

public static void upsample_bicubic2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 long[] output_size,
 long[] input_size,
 boolean align_corners)

upsample_bicubic2d_out

public static void upsample_bicubic2d_out(Tensor out,
 Tensor self,
 long[] output_size,
 boolean align_corners)

upsample_bilinear2d

public static Tensor upsample_bilinear2d(Tensor self,
 long[] output_size,
 boolean align_corners)

upsample_bilinear2d_backward

public static Tensor upsample_bilinear2d_backward(Tensor grad_output,
 long[] output_size,
 long[] input_size,
 boolean align_corners)

upsample_bilinear2d_backward_out

public static void upsample_bilinear2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 long[] output_size,
 long[] input_size,
 boolean align_corners)

upsample_bilinear2d_out

public static void upsample_bilinear2d_out(Tensor out,
 Tensor self,
 long[] output_size,
 boolean align_corners)

upsample_linear1d

public static Tensor upsample_linear1d(Tensor self,
 long[] output_size,
 boolean align_corners)

upsample_linear1d_backward

public static Tensor upsample_linear1d_backward(Tensor grad_output,
 long[] output_size,
 long[] input_size,
 boolean align_corners)

upsample_linear1d_backward_out

public static void upsample_linear1d_backward_out(Tensor grad_input,
 Tensor grad_output,
 long[] output_size,
 long[] input_size,
 boolean align_corners)

upsample_linear1d_out

public static void upsample_linear1d_out(Tensor out,
 Tensor self,
 long[] output_size,
 boolean align_corners)

upsample_nearest1d

public static Tensor upsample_nearest1d(Tensor self,
 long[] output_size)

upsample_nearest1d_backward

public static Tensor upsample_nearest1d_backward(Tensor grad_output,
 long[] output_size,
 long[] input_size)

upsample_nearest1d_backward_out

public static void upsample_nearest1d_backward_out(Tensor grad_input,
 Tensor grad_output,
 long[] output_size,
 long[] input_size)

upsample_nearest1d_out

public static void upsample_nearest1d_out(Tensor out,
 Tensor self,
 long[] output_size)

upsample_nearest2d

public static Tensor upsample_nearest2d(Tensor self,
 long[] output_size)

upsample_nearest2d_backward

public static Tensor upsample_nearest2d_backward(Tensor grad_output,
 long[] output_size,
 long[] input_size)

upsample_nearest2d_backward_out

public static void upsample_nearest2d_backward_out(Tensor grad_input,
 Tensor grad_output,
 long[] output_size,
 long[] input_size)

upsample_nearest2d_out

public static void upsample_nearest2d_out(Tensor out,
 Tensor self,
 long[] output_size)

upsample_nearest3d

public static Tensor upsample_nearest3d(Tensor self,
 long[] output_size)

upsample_nearest3d_backward

public static Tensor upsample_nearest3d_backward(Tensor grad_output,
 long[] output_size,
 long[] input_size)

upsample_nearest3d_backward_out

public static void upsample_nearest3d_backward_out(Tensor grad_input,
 Tensor grad_output,
 long[] output_size,
 long[] input_size)

upsample_nearest3d_out

public static void upsample_nearest3d_out(Tensor out,
 Tensor self,
 long[] output_size)

upsample_trilinear3d

public static Tensor upsample_trilinear3d(Tensor self,
 long[] output_size,
 boolean align_corners)

upsample_trilinear3d_backward

public static Tensor upsample_trilinear3d_backward(Tensor grad_output,
 long[] output_size,
 long[] input_size,
 boolean align_corners)

upsample_trilinear3d_backward_out

public static void upsample_trilinear3d_backward_out(Tensor grad_input,
 Tensor grad_output,
 long[] output_size,
 long[] input_size,
 boolean align_corners)

upsample_trilinear3d_out

public static void upsample_trilinear3d_out(Tensor out,
 Tensor self,
 long[] output_size,
 boolean align_corners)

value_selecting_reduction_backward

public static Tensor value_selecting_reduction_backward(Tensor grad,
 long dim,
 Tensor indices,
 long[] sizes,
 boolean keepdim)

vander

public static Tensor vander(Tensor x,
 long N,
 boolean increasing)

var_0

public static Tensor var_0(Tensor self,
 boolean unbiased)

var_1

public static Tensor var_1(Tensor self,
 long[] dim,
 boolean unbiased,
 boolean keepdim)

var_2

public static Tensor var_2(Tensor self,
 long correction,
 boolean keepdim)

var_mean_0

public static scala.Tuple2<Tensor,Tensor> var_mean_0(Tensor self,
 boolean unbiased)

var_mean_1

public static scala.Tuple2<Tensor,Tensor> var_mean_1(Tensor self,
 long[] dim,
 boolean unbiased,
 boolean keepdim)

var_mean_2

public static scala.Tuple2<Tensor,Tensor> var_mean_2(Tensor self,
 long correction,
 boolean keepdim)

var_out_0

public static void var_out_0(Tensor out,
 Tensor self,
 long[] dim,
 boolean unbiased,
 boolean keepdim)

var_out_1

public static void var_out_1(Tensor out,
 Tensor self,
 long correction,
 boolean keepdim)

vdot

public static Tensor vdot(Tensor self,
 Tensor other)

vdot_out

public static void vdot_out(Tensor out,
 Tensor self,
 Tensor other)

view_as_complex

public static Tensor view_as_complex(Tensor self)

view_as_real

public static Tensor view_as_real(Tensor self)

vsplit_0

public static Tensor[] vsplit_0(Tensor self,
 long sections)

vsplit_1

public static Tensor[] vsplit_1(Tensor self,
 long[] indices)

vstack

public static Tensor vstack(Tensor[] tensors)

vstack_out

public static void vstack_out(Tensor out,
 Tensor[] tensors)

where_0

public static Tensor where_0(Tensor condition,
 Tensor self,
 Tensor other)

where_1

public static Tensor where_1(Tensor condition,
 double self,
 Tensor other)

where_1_l

public static Tensor where_1_l(Tensor condition,
 long self,
 Tensor other)

where_2

public static Tensor where_2(Tensor condition,
 Tensor self,
 double other)

where_2_l

public static Tensor where_2_l(Tensor condition,
 Tensor self,
 long other)

where_3

public static Tensor where_3(Tensor condition,
 double self,
 double other)

where_3_l

public static Tensor where_3_l(Tensor condition,
 long self,
 long other)

where_4

public static Tensor[] where_4(Tensor condition)

xlogy_0

public static Tensor xlogy_0(Tensor self,
 Tensor other)

xlogy_1

public static Tensor xlogy_1(double self,
 Tensor other)

xlogy_1_l

public static Tensor xlogy_1_l(long self,
 Tensor other)

xlogy_2

public static Tensor xlogy_2(Tensor self,
 double other)

xlogy_2_l

public static Tensor xlogy_2_l(Tensor self,
 long other)

xlogy__0

public static void xlogy__0(Tensor self,
 Tensor other)

xlogy__1

public static void xlogy__1(Tensor self,
 double other)

xlogy__1_l

public static void xlogy__1_l(Tensor self,
 long other)

xlogy_out_0

public static void xlogy_out_0(Tensor out,
 Tensor self,
 Tensor other)

xlogy_out_1

public static void xlogy_out_1(Tensor out,
 double self,
 Tensor other)

xlogy_out_1_l

public static void xlogy_out_1_l(Tensor out,
 long self,
 Tensor other)

xlogy_out_2

public static void xlogy_out_2(Tensor out,
 Tensor self,
 double other)

xlogy_out_2_l

public static void xlogy_out_2_l(Tensor out,
 Tensor self,
 long other)

zero_

public static void zero_(Tensor self)

zeros

public static Tensor zeros(long[] size,
 TensorOptions options)

zeros_like

public static Tensor zeros_like(Tensor self,
 TensorOptions options)

zeros_out

public static void zeros_out(Tensor out,
 long[] size)