Question

我必须使用Gram-Schimdt进行正交化处理，这样我才能得到A = QR。我使用矩阵列作为 double [] 并将它们存储在 ArrayList 中，事情是，我只是计算Q所以我我可以做其余的事情，一旦我得到Q就更容易了。但我的问题是，当程序添加finalArray时，我不知道为什么参数 array 被修改，每个向量都在它被改变了，显然结果是错误的。我做错了什么？（顺便说一句，我不能使用Java库来解决这个问题）。我也用自己的双手测试算法，它应该有效，因为我也打印结果并注意它被改变的地方

/*
I should do Uk = (Vk - (Uk-1*Vk)*Uk-1 - ... - (U1*Vk)*Uk1)/||Uk|| 
Where ||Uk|| = Length of Uk

Vectors U own to finalArray and the V ones own to array 
*/
public ArrayList< double[] > gramSchmidt(ArrayList< double[] > array)
{
    ArrayList< double[] > finalArray= new ArrayList<>();

    //I set the first vector because it never changes, it's always the first vector of the array receive divided between it's length
    finalArray.add(multiplyScalarPerVector(1/(calculateVectorLength(array.get(0))), array.get(0)));
    //This last line is the one that modifies EVERYTHING in array and it shouldn't

    for(int i=1; i<array .size(); i++)
    {
        double[] newVector= substractVectors(array .get(i), proyection(finalArray.get(i-1),array .get(i)));
        for(int e=i-1;e>0;e--)
        {
            newVector= substractVectors(newVector, proyection(finalArray.get(e-1),array .get(i)));
        }
        newVector= multiplyScalarPerVector(1/(calculateVectorLength(newVector)), newVector);
        finalArray.add(newVector);
    }
    return finalArray;
}

//Obtain the (Uk-1*Vk)*Uk-1
public double[] proyection(double[] array1, double[] array2)
{
    double dotProductResult= dotProduct(array1,array2);
    double[] finalVector= multiplyScalarPerVector(dotProductResult, array1);
    return finalVector;
}

//To do Uk-1*Vk
public double dotProduct(double[] vector1, double[] vector2)
{
    double result = 0;
    for(int i=0; i<vector1.length; i++)
    {
        result +=vector1[i]*vector2[i];
    }
    return result ;
}

public double[] multiplyScalarPerVector(double scalar, double[] vector)
{
    double[] newVector = new double[vector.length];
    for(int i=0; i<vector.length; i++)
    {
        newVector[i] = scalar*vector[i];
    }
    return newVector;
}

public double[] substractVectors(double[] vector1, double[] vector2)
{
    double[] finalVector= new double[vector1.length];
    for(int i=0; i<vector1.length; i++)
    {
        finalVector[i] = vector1[i] - vector2[i];
    }
    return finalVector;
}

//Calculate the euclidean distance
public double calculateVectorLength(double[] vector)
{
    double result = 0;
    for(int i=0; i<vector.length; i++)
    {
        result +=Math.pow(vector[i], 2);
    }
    return Math.sqrt(result );
}

Answer 1

分配时

double[] newVector= vector;

然后您不创建新对象，但newVector和vector引用同一对象。 newVector不是新对象，它是对vector引用的同一对象的引用。

这导致循环

for(int i=0; i<vector.length; i++)
{
    newVector[i] = scalar*vector[i];
}

newVector和vector变化相似。对newVector[i]的分配也会更改vector[i]，因为它们引用同一个对象。

当你这样做时也是如此：

double[] finalVector= vector1;
for(int i=0; i<vector1.length; i++)
{
    finalVector[i] = vector1[i] - vector2[i];
}

请注意，您不会使用新内容创建新的矢量对象，但更改输入矢量对象并返回对更改对象的引用。
因此您可以更改源向量对象，这些对象在进一步计算中仍然需要。这导致最终结果不应该如此。

创建新对象以解决问题：

double[] newVector= new double[vector.length];

double[] finalVector= new double[vector1.length];

另见Java assigning object reference

在Java中获得Gram-Schmidt正交化

1 个答案: