Java: создайте дубликат массива, не делая его ссылкой
Я написал серию матричных операций, в которых я беру двумерный массив с плавающей точкой, трактую его как матрицу и выполняю матричные операции над ним, чтобы получить обратное. Моя проблема заключалась в том, что хотя массив, который я использую с методами класса, не является частью класса, каждый раз, когда я запускаю метод с массивом в качестве параметра, сам массив также модифицируется.
Сначала я опишу, как я получил обратную матрицу, а затем покажу вывод.
Шаги для взятия обратной матрицы:
- Получите матрицу кофактора (т.е. создайте матрицу минорных матриц исходной матрицы и затем отмените все остальные записи. Если C = Матрица кофактора, M = Матрица миноров, i - текущая строка, а j - текущий столбец, то C[ i ][ j ] = M[ i ][ j ]*( -1)^( i + j)
- Преобразуйте матрицу кофактора в сопряженную (также известную как сопряженную) матрицу, транспонируя (заменяя строку, запись в столбце ее аналогичным столбцом, запись в строке и наоборот), в матрицу кофактора. Если C = Матрица кофактора, A = Матрица сопряжения, i - текущая строка, а j - текущий столбец, то A[ i ][ j ] = C[ j ][ i ]
- Наконец, возьмем один определитель исходной матрицы и умножим вспомогательную матрицу на это значение. Если I = обратная матрица, A = сопряженная матрица и D = определитель, то I = (1/D)*A
- Чтобы проверить, действительно ли вы получили обратную матрицу матрицы, можно умножить исходную матрицу на ее обратную, чтобы получить единичную матрицу. Если I = Inverse, O = Исходная матрица и id = Матрица идентичности, тогда O*I = id
Теперь я представлю код, где я реализую эти операции. Для краткости я не буду описывать, как получить Матрицу несовершеннолетних или Определитель, но проблема, с которой я столкнулся, станет очевидной в любом случае.
public class MatrixOperations {
//Note: this method works fine. There are no problems.
public float determinant(float [][] a)
{
float [][] temp_mat;
float res = 0;
//assuming a square matrix
/*If it's a 2X2, then use the formula for a determinant of
2X2 matrices.*/
if(a.length == 2)
{
return a[0][0]*a[1][1]-a[0][1]*a[1][0];
}
/*Otherwise do the determinant formula recursively until your
determinant is made up of 2X2 matrix determinants and scalar products*/
else
{
temp_mat = new float[a.length-1][a.length-1];
int placej = 0;
int placei = 0;
for(int k = 0; k<a.length;k++)
{
for(int j = 0; j<a.length; j++)
{
for(int i = 1; i < a.length; i++)
{
placei = i-1;
if(j != k)
{
if(j < k)
{
temp_mat[placei][j] = a[i][j];
}
else if(j > k)
{
if (i == 1){
placej = j-1;
}
temp_mat[placei][placej] = a[i][j];
}
}
}
}
res+=a[0][k]*determinant(temp_mat)*(int)Math.pow(-1, k);
}
return res;
}
}
//Note: this method also works fine
//Scalar product method
public float[][] mul(float[][] m, float r)
{
float[][] res = new float[m.length][m.length];
for(int i = 0; i < m.length; i++)
{
for(int j = 0; j < m.length; j++)
{
res[i][j]= m[i][j]*r;
}
}
return res;
}
//Note: This method also works fine
public float[][] mul(float[][] m,float[][] n)
{
float[][] res = new float[m.length][m.length];
for(int i = 0; i < m.length; i++)
{
for(int j = 0; j < m.length; j++)
{
for(int k = 0; k < m.length; k++)
{
res[i][j] += m[i][k]*m[k][i];
}
}
}
return res;
}
//The method for creating a matrix of minors
//Here I start having problems
public float[][] minor(float [][] m)
{
float [][] minor_mat = new float [m.length][m.length];
//If the matrix is greater than a 2X2, use this to generate a matrix of minors
if(m.length > 2)
{
float [][] current_minor = new float [m.length-1][m.length-1];
int placei = 0;
int placej = 0;
for(int i = 0; i < m.length; i++)
{
for(int j = 0; j < m.length; j++)
{
for(int k = 0; k < m.length; k++)
{
for(int l = 0; l < m.length; l++)
{
if(i != k && j != l)
{
if(k<i)
placei = k;
else if(k>i)
placei = k-1;
if(l<j)
placej = l;
else if(l>j)
placej = l-1;
current_minor[placei][placej] = m[k][l];
}
}
}
minor_mat[i][j] = this.determinant(current_minor);
}
}
}
//otherwise use the definition for 2X2 matrix of minors
else
{
//even though minor_mat is using m.clone() rather than m, when I return the result, m has still been modified for some reason.
minor_mat = m.clone()
float temp;
temp = minor_mat[0][0];
minor_mat[0][0] = minor_mat[1][1];
minor_mat[1][1] = temp;
temp = minor_mat[0][1];
minor_mat[0][1] = minor_mat[1][0];
minor_mat[1][0] = temp;
}
return minor_mat;
}
//the same problem occurs here as it did in the minor method
//m appears to get modified even though I only use m.clone()
public float[][] cofactor(float [][] m)
{
float[][] res = m.clone();
res = this.minor(res)
for(int i = 0; i < m.length; i++)
{
for(int j = 0; j < m.length; j++)
{
res[i][j] = res[i][j]*(int)Math.pow(-1, i + j);
}
}
return res;
}
//The following transpose, adjugate, and inverse methods have the same problem
public float[][] transpose(float[][] m)
{
float[][] res = new float[m.length][m.length];
float temp = 0;
for(int i = 0; i < m.length; i++)
{
for(int j = 0; j < m.length; j++)
{
temp = m[i][j];
res[i][j] = m[j][i];
res[j][i] = temp;
}
}
return res;
}
public float[][] adjugate(float[][] m)
{
float[][] res = this.transpose(this.cofactor(m));
return res;
}
public float[][] inverse(float[][] m)
{
float[][] res = this.mul(this.adjugate(m), (1/this.determinant(m)));
return res;
}
//print out the matrix in square form
public void matrixprint(float [][] m)
{
for(int i = 0; i < m.length; i++)
{
System.out.println("");
for(int j = 0; j < m[i].length; j++){
System.out.print(m[i][j] + " ");
}
}
System.out.println("\n");
}
}
Теперь основной класс и основной метод, который создает экземпляр класса MatrixOperations и использует его методы в матрице 2X2.
public class Main {
public static void main(String[] args) {
MatrixOperations mo = new MatrixOperations();
//Create a 2X2 matrix called "matrix" and set its elements
//Then perform each step on "matrix" and finally test if you have acquired the correct inverse
float [][] matrix = new float[2][2];
matrix[0][0] = 2;
matrix [0][1] = 5;
matrix [1][0] = 4;
matrix [1][1] = 3;
System.out.println("Matrix = ");
mo.matrixprint(matrix);
System.out.println("Minor = ");
mo.matrixprint(mo.minor(matrix));
System.out.println("Matrix = ");
mo.matrixprint(matrix);
System.out.println("Cofactor = ");
mo.matrixprint(mo.cofactor(matrix));
System.out.println("Matrix = ");
mo.matrixprint(matrix);
System.out.println("Adjugate = ");
mo.matrixprint(mo.adjugate(matrix));
System.out.println("Matrix = ");
mo.matrixprint(matrix);
System.out.println("Determinant = ");
System.out.println(mo.determinant(matrix));
System.out.println("Matrix = ");
mo.matrixprint(matrix);
System.out.println("Inverse = ");
mo.matrixprint(mo.inverse(matrix));
System.out.println("Matrix = ");
mo.matrixprint(matrix);
System.out.println("Identity = ");
mo.matrixprint(mo.mul(mo.inverse(matrix), matrix));
}
}
Теперь вы увидите, что когда я показываю вывод, каждый раз, когда я использую метод для "матрицы" и перепечатываю "матрицу", сама "матрица" модифицируется, хотя мои методы используют только копию "матрицы", а не " матрица "сама.
Выход:
Matrix =
2.0 5.0
4.0 3.0
Minor =
3.0 4.0
5.0 2.0
Matrix =
3.0 4.0
5.0 2.0
Cofactor =
3.0 -4.0
-5.0 2.0
Matrix =
3.0 -4.0
-5.0 2.0
Adjugate =
3.0 5.0
4.0 2.0
Matrix =
3.0 4.0
5.0 2.0
Determinant =
-14.0
Matrix =
3.0 4.0
5.0 2.0
Inverse =
-0.21428573 0.35714287
0.2857143 -0.14285715
Matrix =
3.0 -4.0
-5.0 2.0
Identity =
0.1479592 0.1479592
0.12244898 0.12244898
Любая помощь / объяснение того, почему это происходит, будет принята с благодарностью.
3 ответа
Эта линия делает мелкий клон;
float[][] res = m.clone();
Это копирует res который является массивом для ссылок на массивы. но не любой из массивов res указывает на. Скорее всего, что вы хотели
float[][] res = new float[m.length][];
for (int i = 0; i < m.length; i++)
res[i] = m[i].clone();
Двумерный массив - это просто массив массивов. clone() на массиве просто делает мелкий клон. Итак, у вас есть новый клонированный внешний массив, но он ссылается на те же записи (внутренние массивы). После клонирования внешнего массива переберите внешний массив и клонируйте все внутренние массивы, чтобы получить глубокий клон.
Это потому, что вы передаете ссылку matrix объект в методах MatrixOperations учебный класс. Это не копия matrix объект.
Из Java документа:
Параметры ссылочного типа данных, такие как объекты, также передаются в методы по значению. Это означает, что когда метод возвращается, переданная ссылка все еще ссылается на тот же объект, что и раньше.