Table of Contents
Shortcuts

Program Listing for File linalg.h

↰ Return to documentation for file (torch/csrc/api/include/torch/linalg.h)

#pragma once

#include <ATen/ATen.h>

namespace torch {
namespace linalg {

#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace detail {

inline Tensor cholesky(const Tensor& self) {
  return torch::linalg_cholesky(self);
}

inline Tensor cholesky_out(Tensor& result, const Tensor& self) {
  return torch::linalg_cholesky_out(result, self);
}

inline Tensor det(const Tensor& self) {
  return torch::linalg_det(self);
}

inline std::tuple<Tensor, Tensor> slogdet(const Tensor& input) {
  return torch::linalg_slogdet(input);
}

inline std::tuple<Tensor&, Tensor&> slogdet_out(
    Tensor& sign,
    Tensor& logabsdet,
    const Tensor& input) {
  return torch::linalg_slogdet_out(sign, logabsdet, input);
}

inline std::tuple<Tensor, Tensor> eig(const Tensor& self) {
  return torch::linalg_eig(self);
}

inline std::tuple<Tensor&, Tensor&> eig_out(
    Tensor& eigvals,
    Tensor& eigvecs,
    const Tensor& self) {
  return torch::linalg_eig_out(eigvals, eigvecs, self);
}

inline Tensor eigvals(const Tensor& self) {
  return torch::linalg_eigvals(self);
}

inline Tensor& eigvals_out(Tensor& result, const Tensor& self) {
  return torch::linalg_eigvals_out(result, self);
}

inline std::tuple<Tensor, Tensor> eigh(
    const Tensor& self,
    c10::string_view uplo) {
  return torch::linalg_eigh(self, uplo);
}

inline std::tuple<Tensor&, Tensor&> eigh_out(
    Tensor& eigvals,
    Tensor& eigvecs,
    const Tensor& self,
    c10::string_view uplo) {
  return torch::linalg_eigh_out(eigvals, eigvecs, self, uplo);
}

inline Tensor eigvalsh(const Tensor& self, c10::string_view uplo) {
  return torch::linalg_eigvalsh(self, uplo);
}

inline Tensor& eigvalsh_out(
    Tensor& result,
    const Tensor& self,
    c10::string_view uplo) {
  return torch::linalg_eigvalsh_out(result, self, uplo);
}

inline Tensor householder_product(const Tensor& input, const Tensor& tau) {
  return torch::linalg_householder_product(input, tau);
}

inline Tensor& householder_product_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& tau) {
  return torch::linalg_householder_product_out(result, input, tau);
}

inline std::tuple<Tensor, Tensor> lu_factor(
    const Tensor& self,
    const bool pivot) {
  return torch::linalg_lu_factor(self, pivot);
}

inline std::tuple<Tensor&, Tensor&> lu_factor_out(
    Tensor& LU,
    Tensor& pivots,
    const Tensor& self,
    const bool pivot) {
  return torch::linalg_lu_factor_out(LU, pivots, self, pivot);
}

inline std::tuple<Tensor, Tensor, Tensor> lu(
    const Tensor& self,
    const bool pivot) {
  return torch::linalg_lu(self, pivot);
}

inline std::tuple<Tensor&, Tensor&, Tensor&> lu_out(
    Tensor& P,
    Tensor& L,
    Tensor& U,
    const Tensor& self,
    const bool pivot) {
  return torch::linalg_lu_out(P, L, U, self, pivot);
}

inline std::tuple<Tensor, Tensor, Tensor, Tensor> lstsq(
    const Tensor& self,
    const Tensor& b,
    c10::optional<double> cond,
    c10::optional<c10::string_view> driver) {
  return torch::linalg_lstsq(self, b, cond, driver);
}

inline Tensor matrix_exp(const Tensor& self) {
  return torch::linalg_matrix_exp(self);
}

inline Tensor norm(
    const Tensor& self,
    const optional<Scalar>& opt_ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return torch::linalg_norm(self, opt_ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor norm(
    const Tensor& self,
    c10::string_view ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return torch::linalg_norm(self, ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor& norm_out(
    Tensor& result,
    const Tensor& self,
    const optional<Scalar>& opt_ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return torch::linalg_norm_out(
      result, self, opt_ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor& norm_out(
    Tensor& result,
    const Tensor& self,
    c10::string_view ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return torch::linalg_norm_out(result, self, ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor vector_norm(
    const Tensor& self,
    Scalar ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return torch::linalg_vector_norm(self, ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor& vector_norm_out(
    Tensor& result,
    const Tensor& self,
    Scalar ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return torch::linalg_vector_norm_out(
      result, self, ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor matrix_norm(
    const Tensor& self,
    const Scalar& ord,
    IntArrayRef dim,
    bool keepdim,
    optional<ScalarType> dtype) {
  return torch::linalg_matrix_norm(self, ord, dim, keepdim, dtype);
}

inline Tensor& matrix_norm_out(
    const Tensor& self,
    const Scalar& ord,
    IntArrayRef dim,
    bool keepdim,
    optional<ScalarType> dtype,
    Tensor& result) {
  return torch::linalg_matrix_norm_out(result, self, ord, dim, keepdim, dtype);
}

inline Tensor matrix_norm(
    const Tensor& self,
    std::string ord,
    IntArrayRef dim,
    bool keepdim,
    optional<ScalarType> dtype) {
  return torch::linalg_matrix_norm(self, ord, dim, keepdim, dtype);
}

inline Tensor& matrix_norm_out(
    const Tensor& self,
    std::string ord,
    IntArrayRef dim,
    bool keepdim,
    optional<ScalarType> dtype,
    Tensor& result) {
  return torch::linalg_matrix_norm_out(result, self, ord, dim, keepdim, dtype);
}

inline Tensor matrix_power(const Tensor& self, int64_t n) {
  return torch::linalg_matrix_power(self, n);
}

inline Tensor& matrix_power_out(const Tensor& self, int64_t n, Tensor& result) {
  return torch::linalg_matrix_power_out(result, self, n);
}

inline Tensor matrix_rank(const Tensor& input, double tol, bool hermitian) {
  return torch::linalg_matrix_rank(input, tol, hermitian);
}

inline Tensor matrix_rank(
    const Tensor& input,
    const Tensor& tol,
    bool hermitian) {
  return torch::linalg_matrix_rank(input, tol, hermitian);
}

inline Tensor matrix_rank(
    const Tensor& input,
    c10::optional<double> atol,
    c10::optional<double> rtol,
    bool hermitian) {
  return torch::linalg_matrix_rank(input, atol, rtol, hermitian);
}

inline Tensor matrix_rank(
    const Tensor& input,
    const c10::optional<Tensor>& atol,
    const c10::optional<Tensor>& rtol,
    bool hermitian) {
  return torch::linalg_matrix_rank(input, atol, rtol, hermitian);
}

inline Tensor& matrix_rank_out(
    Tensor& result,
    const Tensor& input,
    double tol,
    bool hermitian) {
  return torch::linalg_matrix_rank_out(result, input, tol, hermitian);
}

inline Tensor& matrix_rank_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& tol,
    bool hermitian) {
  return torch::linalg_matrix_rank_out(result, input, tol, hermitian);
}

inline Tensor& matrix_rank_out(
    Tensor& result,
    const Tensor& input,
    c10::optional<double> atol,
    c10::optional<double> rtol,
    bool hermitian) {
  return torch::linalg_matrix_rank_out(result, input, atol, rtol, hermitian);
}

inline Tensor& matrix_rank_out(
    Tensor& result,
    const Tensor& input,
    const c10::optional<Tensor>& atol,
    const c10::optional<Tensor>& rtol,
    bool hermitian) {
  return torch::linalg_matrix_rank_out(result, input, atol, rtol, hermitian);
}

inline Tensor multi_dot(TensorList tensors) {
  return torch::linalg_multi_dot(tensors);
}

inline Tensor& multi_dot_out(TensorList tensors, Tensor& result) {
  return torch::linalg_multi_dot_out(result, tensors);
}

inline Tensor pinv(const Tensor& input, double rcond, bool hermitian) {
  return torch::linalg_pinv(input, rcond, hermitian);
}

inline Tensor& pinv_out(
    Tensor& result,
    const Tensor& input,
    double rcond,
    bool hermitian) {
  return torch::linalg_pinv_out(result, input, rcond, hermitian);
}

inline std::tuple<Tensor, Tensor> qr(
    const Tensor& input,
    c10::string_view mode) {
  return torch::linalg_qr(input, mode);
}

inline std::tuple<Tensor&, Tensor&> qr_out(
    Tensor& Q,
    Tensor& R,
    const Tensor& input,
    c10::string_view mode) {
  return torch::linalg_qr_out(Q, R, input, mode);
}

inline std::tuple<Tensor, Tensor> solve_ex(
    const Tensor& input,
    const Tensor& other,
    bool left,
    bool check_errors) {
  return torch::linalg_solve_ex(input, other, left, check_errors);
}

inline std::tuple<Tensor&, Tensor&> solve_ex_out(
    Tensor& result,
    Tensor& info,
    const Tensor& input,
    const Tensor& other,
    bool left,
    bool check_errors) {
  return torch::linalg_solve_ex_out(
      result, info, input, other, left, check_errors);
}

inline Tensor solve(const Tensor& input, const Tensor& other, bool left) {
  return torch::linalg_solve(input, other, left);
}

inline Tensor& solve_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& other,
    bool left) {
  return torch::linalg_solve_out(result, input, other, left);
}

inline Tensor solve_triangular(
    const Tensor& input,
    const Tensor& other,
    bool upper,
    bool left,
    bool unitriangular) {
  return torch::linalg_solve_triangular(
      input, other, upper, left, unitriangular);
}

inline Tensor& solve_triangular_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& other,
    bool upper,
    bool left,
    bool unitriangular) {
  return torch::linalg_solve_triangular_out(
      result, input, other, upper, left, unitriangular);
}

inline std::tuple<Tensor, Tensor, Tensor> svd(
    const Tensor& input,
    bool full_matrices,
    c10::optional<c10::string_view> driver) {
  return torch::linalg_svd(input, full_matrices, driver);
}

inline std::tuple<Tensor&, Tensor&, Tensor&> svd_out(
    Tensor& U,
    Tensor& S,
    Tensor& Vh,
    const Tensor& input,
    bool full_matrices,
    c10::optional<c10::string_view> driver) {
  return torch::linalg_svd_out(U, S, Vh, input, full_matrices, driver);
}

inline Tensor svdvals(
    const Tensor& input,
    c10::optional<c10::string_view> driver) {
  return torch::linalg_svdvals(input, driver);
}

inline Tensor& svdvals_out(
    Tensor& result,
    const Tensor& input,
    c10::optional<c10::string_view> driver) {
  return torch::linalg_svdvals_out(result, input, driver);
}

inline Tensor tensorinv(const Tensor& self, int64_t ind) {
  return torch::linalg_tensorinv(self, ind);
}

inline Tensor& tensorinv_out(Tensor& result, const Tensor& self, int64_t ind) {
  return torch::linalg_tensorinv_out(result, self, ind);
}

inline Tensor tensorsolve(
    const Tensor& self,
    const Tensor& other,
    OptionalIntArrayRef dims) {
  return torch::linalg_tensorsolve(self, other, dims);
}

inline Tensor& tensorsolve_out(
    Tensor& result,
    const Tensor& self,
    const Tensor& other,
    OptionalIntArrayRef dims) {
  return torch::linalg_tensorsolve_out(result, self, other, dims);
}

inline Tensor inv(const Tensor& input) {
  return torch::linalg_inv(input);
}

inline Tensor& inv_out(Tensor& result, const Tensor& input) {
  return torch::linalg_inv_out(result, input);
}

} // namespace detail
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

inline Tensor cholesky(const Tensor& self) {
  return detail::cholesky(self);
}

inline Tensor cholesky_out(Tensor& result, const Tensor& self) {
  return detail::cholesky_out(result, self);
}

// C10_DEPRECATED_MESSAGE("linalg_det is deprecated, use det instead.")
inline Tensor linalg_det(const Tensor& self) {
  return detail::det(self);
}

inline Tensor det(const Tensor& self) {
  return detail::det(self);
}

inline std::tuple<Tensor, Tensor> slogdet(const Tensor& input) {
  return detail::slogdet(input);
}

inline std::tuple<Tensor&, Tensor&> slogdet_out(
    Tensor& sign,
    Tensor& logabsdet,
    const Tensor& input) {
  return detail::slogdet_out(sign, logabsdet, input);
}

inline std::tuple<Tensor, Tensor> eig(const Tensor& self) {
  return detail::eig(self);
}

inline std::tuple<Tensor&, Tensor&> eig_out(
    Tensor& eigvals,
    Tensor& eigvecs,
    const Tensor& self) {
  return detail::eig_out(eigvals, eigvecs, self);
}

inline Tensor eigvals(const Tensor& self) {
  return detail::eigvals(self);
}

inline Tensor& eigvals_out(Tensor& result, const Tensor& self) {
  return detail::eigvals_out(result, self);
}

inline std::tuple<Tensor, Tensor> eigh(
    const Tensor& self,
    c10::string_view uplo) {
  return detail::eigh(self, uplo);
}

inline std::tuple<Tensor&, Tensor&> eigh_out(
    Tensor& eigvals,
    Tensor& eigvecs,
    const Tensor& self,
    c10::string_view uplo) {
  return detail::eigh_out(eigvals, eigvecs, self, uplo);
}

inline Tensor eigvalsh(const Tensor& self, c10::string_view uplo) {
  return detail::eigvalsh(self, uplo);
}

inline Tensor& eigvalsh_out(
    Tensor& result,
    const Tensor& self,
    c10::string_view uplo) {
  return detail::eigvalsh_out(result, self, uplo);
}

inline Tensor householder_product(const Tensor& input, const Tensor& tau) {
  return detail::householder_product(input, tau);
}

inline Tensor& householder_product_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& tau) {
  return detail::householder_product_out(result, input, tau);
}

inline std::tuple<Tensor, Tensor, Tensor, Tensor> lstsq(
    const Tensor& self,
    const Tensor& b,
    c10::optional<double> cond,
    c10::optional<c10::string_view> driver) {
  return detail::lstsq(self, b, cond, driver);
}

inline Tensor matrix_exp(const Tensor& input) {
  return detail::matrix_exp(input);
}

// C10_DEPRECATED_MESSAGE("linalg_norm is deprecated, use norm instead.")
inline Tensor linalg_norm(
    const Tensor& self,
    const optional<Scalar>& opt_ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::norm(self, opt_ord, opt_dim, keepdim, opt_dtype);
}

// C10_DEPRECATED_MESSAGE("linalg_norm is deprecated, use norm instead.")
inline Tensor linalg_norm(
    const Tensor& self,
    c10::string_view ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::norm(self, ord, opt_dim, keepdim, opt_dtype);
}

// C10_DEPRECATED_MESSAGE("linalg_norm_out is deprecated, use norm_out
// instead.")
inline Tensor& linalg_norm_out(
    Tensor& result,
    const Tensor& self,
    const optional<Scalar>& opt_ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::norm_out(result, self, opt_ord, opt_dim, keepdim, opt_dtype);
}

// C10_DEPRECATED_MESSAGE("linalg_norm_out is deprecated, use norm_out
// instead.")
inline Tensor& linalg_norm_out(
    Tensor& result,
    const Tensor& self,
    c10::string_view ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::norm_out(result, self, ord, opt_dim, keepdim, opt_dtype);
}

inline std::tuple<Tensor, Tensor> lu_factor(
    const Tensor& input,
    const bool pivot = true) {
  return detail::lu_factor(input, pivot);
}

inline std::tuple<Tensor&, Tensor&> lu_factor_out(
    Tensor& LU,
    Tensor& pivots,
    const Tensor& self,
    const bool pivot = true) {
  return detail::lu_factor_out(LU, pivots, self, pivot);
}

inline std::tuple<Tensor, Tensor, Tensor> lu(
    const Tensor& input,
    const bool pivot = true) {
  return detail::lu(input, pivot);
}

inline std::tuple<Tensor&, Tensor&, Tensor&> lu_out(
    Tensor& P,
    Tensor& L,
    Tensor& U,
    const Tensor& self,
    const bool pivot = true) {
  return detail::lu_out(P, L, U, self, pivot);
}

inline Tensor norm(
    const Tensor& self,
    const optional<Scalar>& opt_ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::norm(self, opt_ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor norm(
    const Tensor& self,
    std::string ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::norm(self, ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor& norm_out(
    Tensor& result,
    const Tensor& self,
    const optional<Scalar>& opt_ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::norm_out(result, self, opt_ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor& norm_out(
    Tensor& result,
    const Tensor& self,
    std::string ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::norm_out(result, self, ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor vector_norm(
    const Tensor& self,
    Scalar ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::vector_norm(self, ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor& vector_norm_out(
    Tensor& result,
    const Tensor& self,
    Scalar ord,
    OptionalIntArrayRef opt_dim,
    bool keepdim,
    optional<ScalarType> opt_dtype) {
  return detail::vector_norm_out(
      result, self, ord, opt_dim, keepdim, opt_dtype);
}

inline Tensor matrix_norm(
    const Tensor& self,
    const Scalar& ord,
    IntArrayRef dim,
    bool keepdim,
    optional<ScalarType> dtype) {
  return detail::matrix_norm(self, ord, dim, keepdim, dtype);
}

inline Tensor& matrix_norm_out(
    const Tensor& self,
    const Scalar& ord,
    IntArrayRef dim,
    bool keepdim,
    optional<ScalarType> dtype,
    Tensor& result) {
  return detail::matrix_norm_out(self, ord, dim, keepdim, dtype, result);
}

inline Tensor matrix_norm(
    const Tensor& self,
    std::string ord,
    IntArrayRef dim,
    bool keepdim,
    optional<ScalarType> dtype) {
  return detail::matrix_norm(self, ord, dim, keepdim, dtype);
}

inline Tensor& matrix_norm_out(
    const Tensor& self,
    std::string ord,
    IntArrayRef dim,
    bool keepdim,
    optional<ScalarType> dtype,
    Tensor& result) {
  return detail::matrix_norm_out(self, ord, dim, keepdim, dtype, result);
}

inline Tensor matrix_power(const Tensor& self, int64_t n) {
  return detail::matrix_power(self, n);
}

inline Tensor& matrix_power_out(const Tensor& self, int64_t n, Tensor& result) {
  return detail::matrix_power_out(self, n, result);
}

inline Tensor matrix_rank(const Tensor& input, double tol, bool hermitian) {
  return detail::matrix_rank(input, tol, hermitian);
}

inline Tensor matrix_rank(
    const Tensor& input,
    const Tensor& tol,
    bool hermitian) {
  return detail::matrix_rank(input, tol, hermitian);
}

inline Tensor matrix_rank(
    const Tensor& input,
    c10::optional<double> atol,
    c10::optional<double> rtol,
    bool hermitian) {
  return detail::matrix_rank(input, atol, rtol, hermitian);
}

inline Tensor matrix_rank(
    const Tensor& input,
    const c10::optional<Tensor>& atol,
    const c10::optional<Tensor>& rtol,
    bool hermitian) {
  return detail::matrix_rank(input, atol, rtol, hermitian);
}

inline Tensor& matrix_rank_out(
    Tensor& result,
    const Tensor& input,
    double tol,
    bool hermitian) {
  return detail::matrix_rank_out(result, input, tol, hermitian);
}

inline Tensor& matrix_rank_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& tol,
    bool hermitian) {
  return detail::matrix_rank_out(result, input, tol, hermitian);
}

inline Tensor& matrix_rank_out(
    Tensor& result,
    const Tensor& input,
    c10::optional<double> atol,
    c10::optional<double> rtol,
    bool hermitian) {
  return detail::matrix_rank_out(result, input, atol, rtol, hermitian);
}

inline Tensor& matrix_rank_out(
    Tensor& result,
    const Tensor& input,
    const c10::optional<Tensor>& atol,
    const c10::optional<Tensor>& rtol,
    bool hermitian) {
  return detail::matrix_rank_out(result, input, atol, rtol, hermitian);
}

inline Tensor multi_dot(TensorList tensors) {
  return detail::multi_dot(tensors);
}

inline Tensor& multi_dot_out(TensorList tensors, Tensor& result) {
  return detail::multi_dot_out(tensors, result);
}

inline Tensor pinv(
    const Tensor& input,
    double rcond = 1e-15,
    bool hermitian = false) {
  return detail::pinv(input, rcond, hermitian);
}

inline Tensor& pinv_out(
    Tensor& result,
    const Tensor& input,
    double rcond = 1e-15,
    bool hermitian = false) {
  return detail::pinv_out(result, input, rcond, hermitian);
}

inline std::tuple<Tensor, Tensor> qr(
    const Tensor& input,
    c10::string_view mode = "reduced") {
  // C++17 Change the initialisation to "reduced"sv
  //       Same for qr_out
  return detail::qr(input, mode);
}

inline std::tuple<Tensor&, Tensor&> qr_out(
    Tensor& Q,
    Tensor& R,
    const Tensor& input,
    c10::string_view mode = "reduced") {
  return detail::qr_out(Q, R, input, mode);
}

inline std::tuple<Tensor, Tensor, Tensor> ldl_factor_ex(
    const Tensor& input,
    bool hermitian,
    bool check_errors) {
  return torch::linalg_ldl_factor_ex(input, hermitian, check_errors);
}

inline std::tuple<Tensor&, Tensor&, Tensor&> ldl_factor_ex_out(
    Tensor& LD,
    Tensor& pivots,
    Tensor& info,
    const Tensor& input,
    bool hermitian,
    bool check_errors) {
  return torch::linalg_ldl_factor_ex_out(
      LD, pivots, info, input, hermitian, check_errors);
}

inline Tensor ldl_solve(
    const Tensor& LD,
    const Tensor& pivots,
    const Tensor& B,
    bool hermitian) {
  return torch::linalg_ldl_solve(LD, pivots, B, hermitian);
}

inline Tensor& ldl_solve_out(
    Tensor& result,
    const Tensor& LD,
    const Tensor& pivots,
    const Tensor& B,
    bool hermitian) {
  return torch::linalg_ldl_solve_out(result, LD, pivots, B, hermitian);
}

inline std::tuple<Tensor, Tensor> solve_ex(
    const Tensor& input,
    const Tensor& other,
    bool left,
    bool check_errors) {
  return detail::solve_ex(input, other, left, check_errors);
}

inline std::tuple<Tensor&, Tensor&> solve_ex_out(
    Tensor& result,
    Tensor& info,
    const Tensor& input,
    const Tensor& other,
    bool left,
    bool check_errors) {
  return detail::solve_ex_out(result, info, input, other, left, check_errors);
}

inline Tensor solve(const Tensor& input, const Tensor& other, bool left) {
  return detail::solve(input, other, left);
}

inline Tensor& solve_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& other,
    bool left) {
  return detail::solve_out(result, input, other, left);
}

inline Tensor solve_triangular(
    const Tensor& input,
    const Tensor& other,
    bool upper,
    bool left,
    bool unitriangular) {
  return detail::solve_triangular(input, other, upper, left, unitriangular);
}

inline Tensor& solve_triangular_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& other,
    bool upper,
    bool left,
    bool unitriangular) {
  return detail::solve_triangular_out(
      result, input, other, upper, left, unitriangular);
}

inline std::tuple<Tensor, Tensor, Tensor> svd(
    const Tensor& input,
    bool full_matrices,
    c10::optional<c10::string_view> driver) {
  return detail::svd(input, full_matrices, driver);
}

inline std::tuple<Tensor&, Tensor&, Tensor&> svd_out(
    Tensor& U,
    Tensor& S,
    Tensor& Vh,
    const Tensor& input,
    bool full_matrices,
    c10::optional<c10::string_view> driver) {
  return detail::svd_out(U, S, Vh, input, full_matrices, driver);
}

inline Tensor svdvals(
    const Tensor& input,
    c10::optional<c10::string_view> driver) {
  return detail::svdvals(input, driver);
}

inline Tensor& svdvals_out(
    Tensor& result,
    const Tensor& input,
    c10::optional<c10::string_view> driver) {
  return detail::svdvals_out(result, input, driver);
}

inline Tensor tensorinv(const Tensor& self, int64_t ind) {
  return detail::tensorinv(self, ind);
}

inline Tensor& tensorinv_out(Tensor& result, const Tensor& self, int64_t ind) {
  return detail::tensorinv_out(result, self, ind);
}

inline Tensor tensorsolve(
    const Tensor& input,
    const Tensor& other,
    OptionalIntArrayRef dims) {
  return detail::tensorsolve(input, other, dims);
}

inline Tensor& tensorsolve_out(
    Tensor& result,
    const Tensor& input,
    const Tensor& other,
    OptionalIntArrayRef dims) {
  return detail::tensorsolve_out(result, input, other, dims);
}

inline Tensor inv(const Tensor& input) {
  return detail::inv(input);
}

inline Tensor& inv_out(Tensor& result, const Tensor& input) {
  return detail::inv_out(result, input);
}

} // namespace linalg
} // namespace torch

Docs

Access comprehensive developer documentation for PyTorch

View Docs

Tutorials

Get in-depth tutorials for beginners and advanced developers

View Tutorials

Resources

Find development resources and get your questions answered

View Resources

To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.