diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/CholeskyDecomposition.cs b/src/Bonsai.ML.Torch/LinearAlgebra/CholeskyDecomposition.cs
index 92369615..3e901641 100644
--- a/src/Bonsai.ML.Torch/LinearAlgebra/CholeskyDecomposition.cs
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/CholeskyDecomposition.cs
@@ -3,24 +3,23 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class CholeskyDecomposition
 {
     /// <summary>
     /// Computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.
     /// </summary>
-    [Combinator]
-    [Description("Computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class CholeskyDecomposition
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tensor> source)
     {
-        /// <summary>
-        /// Computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tensor> Process(IObservable<Tensor> source)
-        {
-            return source.Select(linalg.cholesky);
-        }
+        return source.Select(linalg.cholesky);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/CrossProduct.cs b/src/Bonsai.ML.Torch/LinearAlgebra/CrossProduct.cs
new file mode 100644
index 00000000..dd4be273
--- /dev/null
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/CrossProduct.cs
@@ -0,0 +1,34 @@
+using System;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+using static TorchSharp.torch.linalg;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the cross product of 2 tensors.
+/// </summary>
+[Combinator]
+[Description("Computes the cross product of 2 tensors.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class CrossProduct
+{
+    /// <summary>
+    /// The dimension to perform the operation.
+    /// </summary>
+    public long Dimension { get; set; } = -1;
+
+    /// <summary>
+    /// Computes the cross product of 2 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor>> source)
+    {
+        return source.Select(value =>
+        {
+            return cross(value.Item1, value.Item2, Dimension);
+        });
+    }
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/Determinant.cs b/src/Bonsai.ML.Torch/LinearAlgebra/Determinant.cs
index 475651d0..4a5cb78d 100644
--- a/src/Bonsai.ML.Torch/LinearAlgebra/Determinant.cs
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/Determinant.cs
@@ -3,24 +3,23 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the determinant of a square matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the determinant of a square matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class Determinant
 {
     /// <summary>
     /// Computes the determinant of a square matrix.
     /// </summary>
-    [Combinator]
-    [Description("Computes the determinant of a square matrix.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class Determinant
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tensor> source)
     {
-        /// <summary>
-        /// Computes the determinant of a square matrix.
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tensor> Process(IObservable<Tensor> source)
-        {
-            return source.Select(linalg.det);
-        }
+        return source.Select(linalg.det);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/EigenvalueDecomposition.cs b/src/Bonsai.ML.Torch/LinearAlgebra/EigenvalueDecomposition.cs
index 6784b1bf..d4029fc7 100644
--- a/src/Bonsai.ML.Torch/LinearAlgebra/EigenvalueDecomposition.cs
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/EigenvalueDecomposition.cs
@@ -3,24 +3,40 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the eigenvalue decomposition of a square matrix if it exists.
+/// </summary>
+[Combinator]
+[Description("Computes the eigenvalue decomposition of a square matrix if it exists.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class EigenvalueDecomposition
 {
     /// <summary>
     /// Computes the eigenvalue decomposition of a square matrix if it exists.
     /// </summary>
-    [Combinator]
-    [Description("Computes the eigenvalue decomposition of a square matrix if it exists.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class EigenvalueDecomposition
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<EigenDecompositionResult> Process(IObservable<Tensor> source)
     {
+        return source.Select(tensor => new EigenDecompositionResult(linalg.eig(tensor)));
+    }
+
+    /// <summary>
+    /// Represents the result of an eigenvalue decomposition.
+    /// </summary>
+    /// <param name="result">The tuple containing the eigenvalues and eigenvectors.</param>
+    public readonly struct EigenDecompositionResult((Tensor eigenvalues, Tensor eigenvectors) result)
+    {
+        /// <summary>
+        /// Gets the eigenvalues of the decomposition.
+        /// </summary>
+        public Tensor Eigenvalues => result.eigenvalues;
+
         /// <summary>
-        /// Computes the eigenvalue decomposition of a square matrix if it exists.
+        /// Gets the eigenvectors of the decomposition.
         /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tuple<Tensor, Tensor>> Process(IObservable<Tensor> source)
-        {
-            return source.Select(tensor => linalg.eig(tensor).ToTuple());
-        }
+        public Tensor Eigenvectors => result.eigenvectors;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/Inverse.cs b/src/Bonsai.ML.Torch/LinearAlgebra/Inverse.cs
index 1d879b5b..530979fc 100644
--- a/src/Bonsai.ML.Torch/LinearAlgebra/Inverse.cs
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/Inverse.cs
@@ -4,24 +4,23 @@
 using static TorchSharp.torch;
 using static TorchSharp.torch.linalg;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the inverse of the input matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the inverse of the input matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class Inverse
 {
     /// <summary>
     /// Computes the inverse of the input matrix.
     /// </summary>
-    [Combinator]
-    [Description("Computes the inverse of the input matrix.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class Inverse
+    /// <param name="source">The input matrix to invert.</param>
+    /// <returns>The inverse of the input matrix.</returns>
+    public IObservable<Tensor> Process(IObservable<Tensor> source)
     {
-        /// <summary>
-        /// Computes the inverse of the input matrix.
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tensor> Process(IObservable<Tensor> source)
-        {
-            return source.Select(inv);
-        }
+        return source.Select(inv);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/LeastSquaresSolve.cs b/src/Bonsai.ML.Torch/LinearAlgebra/LeastSquaresSolve.cs
new file mode 100644
index 00000000..aaa058c3
--- /dev/null
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/LeastSquaresSolve.cs
@@ -0,0 +1,57 @@
+using System;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the solution to the least squares and least norm problems for a full rank matrix A of size m*n and a matrix B of size m*k.
+/// </summary>
+[Combinator]
+[Description("Computes the solution to the least squares and least norm problems for a full rank matrix A of size m*n and a matrix B of size m*k.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class LeastSquaresSolve
+{
+    /// <summary>
+    /// Computes the solution to the least squares and least norm problems for a full rank matrix A of size m*n and a matrix B of size m*k.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<LeastSquaresResult> Process(IObservable<Tuple<Tensor, Tensor>> source)
+    {
+        return source.Select(value => new LeastSquaresResult(linalg.lstsq(value.Item1, value.Item2)));
+    }
+
+    /// <summary>
+    /// Represents the result of solving of linear equations using the least squares method.
+    /// </summary>
+    /// <param name="result"></param>
+    public readonly struct LeastSquaresResult((
+        Tensor solution,
+        Tensor residuals,
+        Tensor rank,
+        Tensor singularValues
+    ) result)
+    {
+        /// <summary>
+        /// The solution to the system of equations.
+        /// </summary>
+        public Tensor Solution => result.solution;
+
+        /// <summary>
+        /// The residual error.
+        /// </summary>
+        public Tensor Residuals => result.residuals;
+
+        /// <summary>
+        /// The effective rank of the solution.
+        /// </summary>
+        public Tensor Rank => result.rank;
+
+        /// <summary>
+        /// The singular values of the solution.
+        /// </summary>
+        public Tensor SingularValues => result.singularValues;
+    }
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/MatrixMultiply.cs b/src/Bonsai.ML.Torch/LinearAlgebra/MatrixMultiply.cs
new file mode 100644
index 00000000..0703dc3d
--- /dev/null
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/MatrixMultiply.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+using static TorchSharp.torch.linalg;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that performs matrix multiplication of 2 or more tensors.
+/// </summary>
+[Combinator]
+[Description("Performs matrix multiplication of 2 or more tensors.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class MatrixMultiply
+{
+    /// <summary>
+    /// Performs matrix multiplication of 2 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor>> source)
+    {
+        return source.Select(input =>input.Item1.matmul(input.Item2));
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 3 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 4 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3, input.Item4]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 5 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3, input.Item4, input.Item5]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 6 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor, Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3, input.Item4, input.Item5, input.Item6]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 7 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3, input.Item4, input.Item5, input.Item6, input.Item7]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of an array of tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tensor[]> source)
+    {
+        return source.Select(multi_dot);
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of a list of tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<IList<Tensor>> source)
+    {
+        return source.Select(multi_dot);
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of an enumerable of tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<IEnumerable<Tensor>> source)
+    {
+        return source.Select(input => multi_dot([.. input]));
+    }
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/MatrixRank.cs b/src/Bonsai.ML.Torch/LinearAlgebra/MatrixRank.cs
new file mode 100644
index 00000000..84eb4c37
--- /dev/null
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/MatrixRank.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+using static TorchSharp.torch.linalg;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the numerical rank of a matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the numerical rank of a matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class MatrixRank
+{
+    /// <summary>
+    /// Gets or sets the absolute tolerance for singular values to be considered non-zero.
+    /// </summary>
+    [Description("The absolute tolerance for singular values to be considered non-zero.")]
+    public double? AbsoluteTolerance { get; set; } = null;
+
+    /// <summary>
+    /// Gets or sets the relative tolerance for singular values to be considered non-zero.
+    /// </summary>
+    [Description("The relative tolerance for singular values to be considered non-zero.")]
+    public double? RelativeTolerance { get; set; } = null;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to treat the input matrix as Hermitian if input is complex or symmetric if real.
+    /// </summary>
+    [Description("Indicates whether to treat the input matrix as Hermitian if input is complex or symmetric if real.")]
+    public bool Hermitian { get; set; } = false;
+
+    /// <summary>
+    /// Computes the numerical rank of a matrix.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tensor> source)
+    {
+        return source.Select(input => matrix_rank(input, atol: AbsoluteTolerance, rtol: RelativeTolerance, hermitian: Hermitian));
+    }
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/Norm.cs b/src/Bonsai.ML.Torch/LinearAlgebra/Norm.cs
index eb18920d..510a7b59 100644
--- a/src/Bonsai.ML.Torch/LinearAlgebra/Norm.cs
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/Norm.cs
@@ -3,35 +3,36 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes a vector or matrix norm.
+/// </summary>
+[Combinator]
+[Description("Computes a vector or matrix norm.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class Norm
 {
     /// <summary>
-    /// Computes a vector or matrix norm.
+    /// The dimensions along which to compute the norm.
     /// </summary>
-    [Combinator]
-    [Description("Computes a vector or matrix norm.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class Norm
-    {
-        /// <summary>
-        /// The dimensions along which to compute the norm.
-        /// </summary>
-        [TypeConverter(typeof(UnidimensionalArrayConverter))]
-        public long[] Dimensions { get; set; } = null;
+    [TypeConverter(typeof(UnidimensionalArrayConverter))]
+    [Description("The dimensions along which to compute the norm.")]
+    public long[] Dimensions { get; set; } = null;
 
-        /// <summary>
-        /// If true, the reduced dimensions are retained in the result as dimensions with size one.
-        /// </summary>
-        public bool Keepdim { get; set; } = false;
+    /// <summary>
+    /// If true, the reduced dimensions are retained in the result as dimensions with size one.
+    /// </summary>
+    [Description("If true, the reduced dimensions are retained in the result as dimensions with size one.")]
+    public bool Keepdim { get; set; } = false;
 
-        /// <summary>
-        /// Computes a matrix norm.
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tensor> Process(IObservable<Tensor> source)
-        {
-            return source.Select(tensor => linalg.norm(tensor, dims: Dimensions, keepdim: Keepdim));
-        }
+    /// <summary>
+    /// Computes a matrix norm.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tensor> source)
+    {
+        return source.Select(tensor => linalg.norm(tensor, dims: Dimensions, keepdim: Keepdim));
     }
-}
\ No newline at end of file
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/QRDecomposition.cs b/src/Bonsai.ML.Torch/LinearAlgebra/QRDecomposition.cs
new file mode 100644
index 00000000..eb01aaf3
--- /dev/null
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/QRDecomposition.cs
@@ -0,0 +1,50 @@
+using System;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+using static TorchSharp.torch.linalg;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the QR decomposition of a matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the QR decomposition of a matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class QRDecomposition
+{
+    /// <summary>
+    /// Gets or sets the mode of the QR decomposition.
+    /// </summary>
+    [Description("The mode of the QR decomposition.")]
+    public QRMode Mode { get; set; } = QRMode.Reduced;
+
+    /// <summary>
+    /// Computes the QR decomposition of a matrix.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<QRDecompositionResult> Process(IObservable<Tensor> source)
+    {
+        return source.Select(tensor => new QRDecompositionResult(qr(tensor, mode: Mode)));
+    }
+
+    /// <summary>
+    /// Represents the result of a QR decomposition.
+    /// </summary>
+    /// <param name="result"></param>
+    public readonly struct QRDecompositionResult((Tensor Q, Tensor R) result)
+    {
+        /// <summary>
+        /// Gets the orthogonal matrix Q.
+        /// </summary>
+        public Tensor Q => result.Q;
+
+        /// <summary>
+        /// Gets the upper triangular matrix R.
+        /// </summary>
+        public Tensor R => result.R;
+    }
+
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/SignLogDeterminant.cs b/src/Bonsai.ML.Torch/LinearAlgebra/SignLogDeterminant.cs
index 6d29c910..2b9eb66d 100644
--- a/src/Bonsai.ML.Torch/LinearAlgebra/SignLogDeterminant.cs
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/SignLogDeterminant.cs
@@ -3,24 +3,40 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the sign and natural logarithm of the absolute value of the determinant of a square matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the sign and natural logarithm of the absolute value of the determinant of a square matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class SignLogDeterminant
 {
     /// <summary>
-    /// Computes the determinant of a square matrix.
+    /// Computes the sign and natural logarithm of the absolute value of the determinant of a square matrix.
     /// </summary>
-    [Combinator]
-    [Description("Computes the sign and natural logarithm of the absolute value of the determinant of a square matrix.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class SignLogDeterminant
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<SignLogDeterminantResult> Process(IObservable<Tensor> source)
     {
+        return source.Select(result => new SignLogDeterminantResult(linalg.slogdet(result)));
+    }
+
+    /// <summary>
+    /// Represents the result of computing the sign and natural logarithm of the absolute value of the determinant.
+    /// </summary>
+    /// <param name="result"></param>
+    public readonly struct SignLogDeterminantResult((Tensor sign, Tensor logabsdet) result)
+    {
+        /// <summary>
+        /// Gets the sign of the determinant.
+        /// </summary>
+        public Tensor Sign => result.sign;
+
         /// <summary>
-        /// Computes the determinant of a square matrix.
+        /// Gets the natural logarithm of the absolute value of the determinant.
         /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<(Tensor, Tensor)> Process(IObservable<Tensor> source)
-        {
-            return source.Select(linalg.slogdet);
-        }
+        public Tensor LogAbsDeterminant => result.logabsdet;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/SingularValueDecomposition.cs b/src/Bonsai.ML.Torch/LinearAlgebra/SingularValueDecomposition.cs
index c440316f..25ac9581 100644
--- a/src/Bonsai.ML.Torch/LinearAlgebra/SingularValueDecomposition.cs
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/SingularValueDecomposition.cs
@@ -3,29 +3,55 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the singular value decomposition (SVD) of a matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the singular value decomposition (SVD) of a matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class SingularValueDecomposition
 {
+    /// <summary>
+    /// Whether to compute the full or reduced SVD.
+    /// </summary>
+    [Description("Whether to compute the full or reduced SVD.")]
+    public bool FullMatrices { get; set; } = false;
+
     /// <summary>
     /// Computes the singular value decomposition (SVD) of a matrix.
     /// </summary>
-    [Combinator]
-    [Description("Computes the singular value decomposition (SVD) of a matrix.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class SingularValueDecomposition
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<SingularValueDecompositionResult> Process(IObservable<Tensor> source)
+    {
+        return source.Select(tensor => new SingularValueDecompositionResult(linalg.svd(tensor, fullMatrices: FullMatrices)));
+    }
+
+    /// <summary>
+    /// Represents the result of a singular value decomposition.
+    /// </summary>
+    /// <param name="result"></param>
+    public readonly struct SingularValueDecompositionResult((
+        Tensor u,
+        Tensor s,
+        Tensor vh
+    ) result)
     {
         /// <summary>
-        /// Whether to compute the full or reduced SVD.
+        /// The U tensor.
+        /// </summary>
+        public Tensor U => result.u;
+
+        /// <summary>
+        /// The singular values.
         /// </summary>
-        public bool FullMatrices { get; set; } = false;
+        public Tensor S => result.s;
 
         /// <summary>
-        /// Computes the singular value decomposition (SVD) of a matrix.
+        /// The Vh tensor.
         /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tuple<Tensor, Tensor, Tensor>> Process(IObservable<Tensor> source)
-        {
-            return source.Select(tensor => linalg.svd(tensor, fullMatrices: FullMatrices).ToTuple());
-        }
+        public Tensor Vh => result.vh;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/TensorSolve.cs b/src/Bonsai.ML.Torch/LinearAlgebra/TensorSolve.cs
new file mode 100644
index 00000000..52b5f5d3
--- /dev/null
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/TensorSolve.cs
@@ -0,0 +1,36 @@
+using System;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+using static TorchSharp.torch.linalg;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the solution X to the system tensordot(A, X) = B.
+/// </summary>
+[Combinator]
+[Description("Computes the solution to the system tensordot(A, X) = B.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class TensorSolve
+{
+    /// <summary>
+    /// The dimensions to perform the operation.
+    /// </summary>
+    [TypeConverter(typeof(UnidimensionalArrayConverter))]
+    [Description("The dimensions to perform the operation.")]
+    public long[] Dimensions { get; set; } = [];
+
+    /// <summary>
+    /// Computes the solution to the system tensordot(A, X) = B.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor>> source)
+    {
+        return source.Select(value =>
+        {
+            return tensorsolve(value.Item1, value.Item2, Dimensions);
+        });
+    }
+}
diff --git a/src/Bonsai.ML.Torch/LinearAlgebra/TriangularSolve.cs b/src/Bonsai.ML.Torch/LinearAlgebra/TriangularSolve.cs
new file mode 100644
index 00000000..8f7b1f54
--- /dev/null
+++ b/src/Bonsai.ML.Torch/LinearAlgebra/TriangularSolve.cs
@@ -0,0 +1,47 @@
+using System;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+using static TorchSharp.torch.linalg;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the solution to a triangular system of linear equations with a unique solution.
+/// </summary>
+[Combinator]
+[Description("Computes the solution to a triangular system of linear equations with a unique solution.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class TriangularSolve
+{
+    /// <summary>
+    /// Gets or sets a value indicating whether the first matrix is upper triangular.
+    /// </summary>
+    [Description("Indicates whether the first matrix is upper triangular.")]
+    public bool Upper { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to solve the system with the first matrix on the left or right (AX = B or XA = B).
+    /// </summary>
+    [Description("Indicates whether to solve the system with the first matrix on the left or right (AX = B or XA = B).")]
+    public bool Left { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the first matrix has a unit diagonal, i.e., all diagonal elements are assumed to be 1.
+    /// </summary>
+    [Description("Indicates whether the first matrix has a unit diagonal, i.e., all diagonal elements are assumed to be 1.")]
+    public bool UnitDiagonal { get; set; } = false;
+
+    /// <summary>
+    /// Computes the solution to a triangular system of linear equations for each pair of input tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor>> source)
+    {
+        return source.Select(value =>
+        {
+            return solve_triangular(value.Item1, value.Item2, upper: Upper, left: Left, unitriangular: UnitDiagonal);
+        });
+    }
+}