Пока у меня есть этот код для разложения LU. Он принимает входной массив и возвращает нижнюю и верхнюю треугольную матрицу.
void LUFactorization ( int d, const double*S, double*L, double*U )
{
for(int k = 0; k < d; ++k){
if (
for(int j = k; j < d; ++j){
double sum = 0.;
for(int p = 0; p < k; ++p) {
sum+=L[k*d+p]*L[p*d+j];
cout << L[k*d+p] << endl;
}
sum = S[k*d+j] - sum;
L[k*d+j]=sum;
U[k*d+j]=sum;
}
for(int i = k + 1; i < d; ++i){
double sum=0.;
for(int p = 0; p < k; ++p) sum+=L[i*d+p]*L[p*d+k];
L[i*d+k]=(S[i*d+k]-sum)/L[k*d+k];
}
}
for(int k = 0; k < d; ++k){
for(int j = k; j < d; ++j){
if (k < j) L[k*d+j]=0;
else if (k == j) L[k*d+j]=1;
}
}
}
Есть ли способ, которым я могу адаптировать это для выполнения обмена строк? Если нет, есть ли какой-то другой алгоритм, на который я мог бы быть направлен?
Спасибо
Обычный подход для LU-разложений с поворотом заключается в хранении массива перестановок P
который инициализируется как перестановка идентичности (P={0,1,2,...,d - 1}
), а затем обменять записи в P
вместо обмена рядами в S
Если у вас есть этот массив перестановок, каждый доступ к S
должен использовать P[i]
вместо i
для номера строки.
Обратите внимание, что P
сама является частью вывода, так как она представляет собой матрицу перестановок, такую что
P*A = L*U
, так что если вы хотите использовать его для решения систем линейных уравнений, вам придется применить P
на правой стороне перед применением обратной и прямой замены
Других решений пока нет …