我可以 return 在 Java 中的一个方法（LDL^T Factroization）中同时使用两种数组类型吗

Question

我在java中写了这个用于LDL^T分解的方法（它将对称方阵"A"分解为3个矩阵，其中"L"是下三角矩阵，其中1s对角线，"D" 是具有正项的对角矩阵，"L^T" 是 L 的转置矩阵）。想知道是否可以用相同的方法 return L 和 D 矩阵，如果不能，我该如何拆分此方法。按照我教科书中的算法（Faires and Douglas 第 9 版第 417 页的数值分析），我的代码仍然有一些我必须弄清楚的逻辑缺陷。所以我的问题 is/are 我可以 return 在同一个方法中同时使用两种不同类型的数组（ L[][] 和 D[] 所以 D 只有 returns对角线元素作为数组，L return 是整个矩阵 ) and/or 如何拆分此方法。

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;}

Answer 1

您可以创建一个包含 L 和 D 矩阵作为 class 成员的 class，然后 return 此 class 的一个实例。

使用此方法，您可以将此算法作为一种方法合并到 class 中，并提供单独的方法来检索 L、D 和转置的 L 矩阵。

例如，class 如下：

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...
    }
}

Answer 2

您只能 return 一个方法中的一个变量。有几种方法可以获得这两个值，但我会这样做的方法是创建一个新的 class 命名为 LDArray，并且 class 将包含两个数组，L 和D，以及两个数组的 getters/setters。这样你就可以简单地将你的方法更改为 return LDArray 和 post 两个数组在一个对象中。

Answer 3

您可以 return 一个 Object 的数组，其中包含 L 和 D，尽管 @Alan 的建议更安全。

Answer 4

不用多想，直接创建一个class（可能是inner），命名为DecompositionResults，给它两个public成员：D和L。然后把计算好的矩阵赋值给a class 和 return 的新对象。

或者，由于 L 在概念上是二维的，而 D 是一维的，因此 return 一个大小为 N+1 x N 的二维数组，其中 last/first 行是 D。

Answer 5

适当的编程语言都有元组类型，非常适合这种用途。但是 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;
  }
}

并将其用作 return 值。

Answer 6

您可以将代码放在结果中 class。

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];
                    }
                }
            }
        }
    }
}

顺便说一句

double Sum1 = 0.0;
Sum1 += L[i][j] * V[j];
D[i] = A[i][i] - Sum1;

与

相同

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

这是你想要的吗？

此外，如果您使用

，您的循环可能会更简单

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

因为这是索引的范围。

我可以 return 在 Java 中的一个方法（LDL^T Factroization）中同时使用两种数组类型吗

Can I return two array types at the same time in a single method (LDL^T Factroization) in Java

java

arrays

return

matrix-decomposition