Replace deprecated libtorch APIs with torch::linalg equivalents

src/Native/LibTorchSharp/THSLinearAlgebra.cpp

@@ -351,14 +351,17 @@ Tensor THSLinalg_vecdot(const Tensor x, const Tensor y, const int64_t dim, Tenso
     CATCH_TENSOR(out == nullptr ? torch::linalg_vecdot(* x, *y, dim) : torch::linalg_vecdot_out(*out, *x, *y, dim))
 }
 
-Tensor THSTensor_lu_solve(const Tensor B, const Tensor LU, const Tensor pivots, bool left, bool adjoint, Tensor out)
+Tensor THSLinalg_lu_solve(const Tensor B, const Tensor LU, const Tensor pivots, bool left, bool adjoint, Tensor out)
 {
     CATCH_TENSOR(out == nullptr ? torch::linalg_lu_solve(*LU, *pivots, *B, left, adjoint) : torch::linalg_lu_solve_out(*out, *LU, *pivots, *B, left, adjoint))
 }
 
 Tensor THSTensor_cholesky(const Tensor tensor, const bool upper)
 {
-    CATCH_TENSOR(tensor->cholesky(upper))
+    // torch::cholesky is deprecated in favor of torch::linalg_cholesky.
+    // Here we call torch::linalg_cholesky with its default (lower-triangular) output,
+    // and return its conjugate transpose via .mH() when upper is true.
+    CATCH_TENSOR(upper ? torch::linalg_cholesky(*tensor).mH() : torch::linalg_cholesky(*tensor))
 }
 
 Tensor THSTensor_cholesky_inverse(const Tensor tensor, const bool upper)
@@ -441,7 +444,9 @@ Tensor THSTensor_lu(const Tensor tensor, bool pivot, bool get_infos, Tensor* inf
 
 Tensor THSTensor_lu_solve(const Tensor tensor, const Tensor LU_data, const Tensor LU_pivots)
 {
-    CATCH_TENSOR(tensor->lu_solve(*LU_data, *LU_pivots))
+    // tensor.lu_solve is deprecated in favor of torch::linalg_lu_solve.
+    // Note: linalg_lu_solve arg order is (LU, pivots, B).
+    CATCH_TENSOR(torch::linalg_lu_solve(*LU_data, *LU_pivots, *tensor))
 }
 
 Tensor THSTensor_lu_unpack(const Tensor LU_data, const Tensor LU_pivots, bool unpack_data, bool unpack_pivots, Tensor* L, Tensor* U)

src/TorchSharp/Tensor/Tensor.LinearAlgebra.cs

@@ -64,6 +64,7 @@ public Tensor tensordot(Tensor b, long dims = 2)
             /// </summary>
             /// <param name="upper">If upper is true, the returned matrix U is upper-triangular. If upper is false, the returned matrix L is lower-triangular</param>
             /// <returns></returns>
+            [Obsolete("torch.cholesky is deprecated in favor of torch.linalg.cholesky and will be removed in a future release. Use torch.linalg.cholesky instead.", false)]
             public Tensor cholesky(bool upper = false)
             {
                 var res = THSTensor_cholesky(Handle, upper);

src/TorchSharp/Tensor/torch.BlasAndLapackOperations.cs

@@ -131,7 +131,10 @@ public static Tensor addbmm_(Tensor input, Tensor batch1, Tensor batch2, float b
 
         // https://pytorch.org/docs/stable/generated/torch.cholesky
 
+        [Obsolete("torch.cholesky is deprecated in favor of torch.linalg.cholesky and will be removed in a future release. Use torch.linalg.cholesky instead.", false)]
+#pragma warning disable CS0618 // Obsolete
         public static Tensor cholesky(Tensor input) => input.cholesky();
+#pragma warning restore CS0618
 
         // https://pytorch.org/docs/stable/generated/torch.cholesky_inverse
         /// <summary>
@@ -250,6 +253,7 @@ public static (Tensor A_LU, Tensor? pivots, Tensor? infos) lu(Tensor A, bool piv
         /// The pivots of the LU factorization from torch.lu() of size (∗,m), where *∗ is zero or more batch dimensions.
         /// The batch dimensions of LU_pivots must be equal to the batch dimensions of LU_data.</param>
         /// <returns></returns>
+        [Obsolete("torch.lu_solve is deprecated in favor of torch.linalg.lu_solve and will be removed in a future release. Use torch.linalg.lu_solve(LU, pivots, B) instead.", false)]
         public static Tensor lu_solve(Tensor b, Tensor LU_data, Tensor LU_pivots)
         {
             var solution = THSTensor_lu_solve(b.Handle, LU_data.Handle, LU_pivots.Handle);

src/TorchSharp/Tensor/torch.cs

@@ -16,7 +16,10 @@ public static partial class torch
         /// <param name="input">The input matrix</param>
         /// <param name="upper">If upper is true, the returned matrix U is upper-triangular. If upper is false, the returned matrix L is lower-triangular</param>
         /// <returns></returns>
+        [Obsolete("torch.cholesky is deprecated in favor of torch.linalg.cholesky and will be removed in a future release. Use torch.linalg.cholesky instead.", false)]
+#pragma warning disable CS0618 // Obsolete
         public static Tensor cholesky(Tensor input, bool upper) => input.cholesky(upper);
+#pragma warning restore CS0618
 
         /// <summary>
         /// Returns the matrix norm or vector norm of a given tensor.

test/TorchSharpTest/LinearAlgebra.cs

@@ -49,7 +49,7 @@ public void TestLUSolve()
                 Assert.Equal(new long[] { 2, 3, 3 }, A_LU.shape);
                 Assert.Equal(new long[] { 2, 3 }, pivots.shape);
 
-                var x = lu_solve(b, A_LU, pivots);
+                var x = linalg.lu_solve(A_LU, pivots, b);
                 Assert.Equal(new long[] { 2, 3, 1 }, x.shape);
 
                 var y = norm(bmm(A, x) - b);
@@ -67,7 +67,7 @@ public void TestLUSolve()
                 Assert.Equal(new long[] { 2, 3 }, pivots.shape);
                 Assert.Equal(new long[] { 2 }, infos.shape);
 
-                var x = lu_solve(b, A_LU, pivots);
+                var x = linalg.lu_solve(A_LU, pivots, b);
                 Assert.Equal(new long[] { 2, 3, 1 }, x.shape);
 
                 var y = norm(bmm(A, x) - b);
@@ -305,6 +305,20 @@ public void CholeskyTest()
             Assert.True(a.allclose(l.matmul(l.swapaxes(-2, -1)))); // Worked this in to get it tested. Alias for 'transpose'
         }
 
+        [Fact]
+        [TestOf(nameof(Tensor.cholesky))]
+        public void CholeskyUpperTest()
+        {
+            var a = randn(new long[] { 3, 2, 2 }, float64);
+            a = a.matmul(a.swapdims(-2, -1));
+#pragma warning disable CS0618 // Obsolete
+            var u = a.cholesky(upper: true);
+#pragma warning restore CS0618
+
+            // U should be upper-triangular: for real inputs U^T * U == A (more generally, U^H * U == A)
+            Assert.True(a.allclose(u.swapaxes(-2, -1).matmul(u)));
+        }
+
         [Fact]
         [TestOf(nameof(linalg.cholesky_ex))]
         public void CholeskyExTest()