我可以在Java中的单个方法（LDL^T Factroization）中同时返回两种数组类型吗

我在java中为LDL^T分解编写了这个方法，它将一个平方对称矩阵a分解为3个矩阵，其中L是一个对角为1的下三角矩阵，D是一个带正项的对角矩阵，L^T是L的转置矩阵。我想知道是否可以用相同的方法返回L和D矩阵，如果没有，我该如何拆分此方法。遵循我的教科书《Faires and Douglas第9版第417页的数值分析》中的算法，我的代码仍然存在一些逻辑缺陷，我必须找出这些缺陷。所以我的问题是，我能不能在同一个方法L[]]和D[]中同时返回两种不同类型的数组，所以D只返回对角线元素作为数组，L返回整个矩阵，和/或我如何拆分这个方法

public static double[][] Lfactor(double[][] A) {
    if (!isSquare(A)) {
        throw new RuntimeException("Matrix is not square");
    }
    if (!isSymmetric(A)) {
        throw new RuntimeException("Matrix is not symmetric");
    }
    int N = A.length;
    double[][] L = new double[N][N];
    double[] V = new double[N];
    double[] D = new double[N];
    for(int i=1; i <= N; i++ ){
        for(int j=1; j<=i-1;j++){
            V[j]= L[i][j]*D[j];
            double Sum1 = 0.0;
             Sum1+= L[i][j] * V[j];
             D[i] = A[i][i] - Sum1;
        for( j=i+1; j<=N;j++){
            for(int k = 1; k<=i-1; k++){
            double Sum2 = 0.0;
            Sum2 += L[j][k]*V[k];
            L[j][i]= (A[j][i] - Sum2)/D[i];
                    }
        }
    }
}
    return L;}

---

您可以创建一个同时包含L和D矩阵作为类成员的类，然后返回该类的实例

使用这种方法，您可以将该算法作为方法合并到类中，还可以提供检索L、D和转置的L矩阵的单独方法

例如，一个类沿着以下行：

public class LDLT
{
    private double[][] l;
    private double[][] d;

    public void calculate(double[][] a)
    {
        // calculate, and store in l and d...
    }

    public double[][] getL()
    {
        return l;
    }

    public double[][] getD()
    {
        return d;
    }

    public double[][] getTransposedL()
    {
        // calculate and transpose the l matrix...
    }
}

---

在一个方法中只能返回一个变量。获取这两个值有几种方法，但我要做的是创建一个名为LDArray的新类，该类将包含两个数组，L和D，以及两个数组的getter/setter。这样，您只需更改方法以返回LDArray并在一个对象中发布这两个数组。

您可以返回一个包含L和D的对象数组，尽管@Alan的建议更适合类型安全。

无需考虑太多，只需创建一个类（可能是内部的），将其称为DecompositionResults，给它两个公共成员：D和L。然后将计算出的矩阵分配给该类的一个新对象，并返回它

---

或者，由于L在概念上是二维的，而D是一维的，因此只需返回大小为N+1 x N的2D数组，其中最后/第一行是D。

适当的编程语言具有元组类型，这非常适合这种用途。但Java没有。因此，您可以将自己的一对模拟为两个元组，通常称为：

public static class Tuple<T, U> {
  public final T _1;
  public final U _2;
  public Tuple(T arg1, U arg2) {
    super();
    this._1 = arg1;
    this._2 = arg2;
  }
}

---

并将其用作返回值。

您可以将代码放入结果类中

class LFactor {
    public final double[] L[], V, D;

    public LFactor(double[][] A) {
        if (!isSquare(A)) {
            throw new RuntimeException("Matrix is not square");
        }
        if (!isSymmetric(A)) {
            throw new RuntimeException("Matrix is not symmetric");
        }
        int N = A.length;
        L = new double[N][N];
        V = new double[N];
        D = new double[N];
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= i - 1; j++) {
                V[j] = L[i][j] * D[j];
                double Sum1 = 0.0;
                Sum1 += L[i][j] * V[j];
                D[i] = A[i][i] - Sum1;
                for (j = i + 1; j <= N; j++) {
                    for (int k = 1; k <= i - 1; k++) {
                        double Sum2 = 0.0;
                        Sum2 += L[j][k] * V[k];
                        L[j][i] = (A[j][i] - Sum2) / D[i];
                    }
                }
            }
        }
    }
}

与

D[i] = A[i][i] - L[i][j] * V[j];

这是你想要的吗

此外，如果使用

for (int i = 0; i < N; i++) {

---

因为这是索引的范围。

如果D[]是L[]]的一部分，那么您可以返回L[]]，然后提取D[]，但是是。。。类容器可以做到这一点，就像其他人所建议的一样。这是本文的副本。这里有一些很好的答案。谢谢您的快速回答。所有这些都很有帮助，但我不得不选择一个作为我的最佳答案。谢谢，我喜欢这个想法。你的回答是最详细、最清楚的。

for (int i = 0; i < N; i++) {