Método de eliminación gaussiano de primera columna para resolver ecuaciones lineales AX=b lenguaje C
Se utiliza el método de eliminación primaria gaussiana #include lt; iostream.hgt;
#include lt; hgt;
/*Sitio web de LouJing www.LouJing.com
posee los derechos de autor de este programa; conserve los derechos de autor al reimprimir.
Gracias por su cooperación!*/
double* allocMem(int); //Asignar función de espacio de memoria
void GaussLineMain(double*, double*, double*, int); secuencia El método de eliminación del elemento principal se utiliza para resolver el valor del vector inicial de x
void Jacobi(double*, double*, double*, double*, int, int //Utilice la fórmula de iteración de Jacobi); para resolver el valor de x p>
void main()
{
short MatrixNum; //El número de filas (número de columnas) de la matriz
double *matrixA; // Matriz A, matriz de coeficientes inicial
double *matrixD; //La matriz D es la matriz diagonal principal en A
double *matrixL ; //La matriz L es el triángulo inferior en A Matrix
double *matrixU; //La matriz U es la matriz triangular superior en A
double *B; la matriz de iteración del método jacobiano
double *f; //La matriz f es la matriz de transición intermedia
double *x; /p>
double *xk; //xk Es una matriz unidimensional, utilizada en iteración
double *b; //b es una matriz unidimensional, que almacena los coeficientes el lado derecho del sistema de ecuaciones
int i, j, k
coutlt;lt;"lt;lt;Ingrese el número de filas de la matriz (el número de columnas es consistente con el número de filas)gt;gt;:";
cingt;gt;matrixNum;
//Asignar espacio de memoria a A, D, L, U, B, f, x, b respectivamente
MatrixA=allocMem(matrixNum*matrixNum);
MatrixD=allocMem(matrixNum*matrixNum);
MatrixL=allocMem (Nummatriz*Nummatriz);
MatrixU=allocMem(Nummatriz*Nummatriz);
B=allocMem(Nummatriz*Nummatriz);
f=allocMem(Nummatriz);
x=allocMem(matrizNum);
xk=allocMem(matrizNum);
b=allocMem(matrizNum);
//Ingresa el valor de cada elemento de la matriz de coeficientes
coutlt;lt;es
dllt;lt;endllt;lt;endllt;lt;"lt;lt; Ingrese el valor de cada elemento en la matriz (para "lt;lt;matrixNumlt;lt;"*"lt;lt;matrixNumlt;lt;" , ** *Cuenta "matrixNum*matrixNumlt;" elementos)"lt;lt;"gt;gt;:"lt;lt;endllt;lt;endl;
para (i= 0; ilt; MatrixNum; i )
{
coutlt;lt;"Ingrese la fila "lt;lt;" de "lt;lt;i 1lt;lt;" en la matriz; MatrixNumlt;lt;" elementos:";
for(j=0;jlt;matrixNum;j)
cingt;gt;*(matrixA i*matrixNum j); p>
}
//Ingrese el valor de cada elemento del coeficiente b en el lado derecho del sistema de ecuaciones
coutlt;lt;endllt;lt;endllt; lt;endllt;lt; "lt;lt; Por favor ingrese los valores de cada elemento del coeficiente en el lado derecho del sistema de ecuaciones, *** total "lt;lt;matrixNumlt;lt;" "lt;lt ;"gt;gt;:"lt;lt;endllt;lt; endl;
for(i=0; ilt; númeromatriz; i )
cingt; b i);
/* Dividir A a continuación For A=D-L-U */
//Primero inicializa D, L y U
for(i=0 ; ilt; númmatriz; i )
for(j=0;jlt;númmatriz;j)
*(matrizD i*númmatriz j)=*(matrizL i*númmatriz j) =*(matrixU i*matrixNum j)=0;
//D, L y U obtienen la diagonal principal, el triángulo inferior y el triángulo superior de A respectivamente, D toma la matriz inversa; , y cada elemento de L y U toma el número inverso
para (i=0; ilt; MatrixNum; i )
para (j=0; jlt; MatrixNum; j )
if (i==jamp; amp; *(matrixA i *matrixNum j)) *(matrixD i*matrixNum j)=1/(*(matrixA i*matrixNum j));
else if(igt;j) *(matrixL i*matrixNum j)= -*(matrixA i*matrixNum j);
else *(matrixU i*matrixNum j)=-*( MatrixA i*matrixNum j);
//Buscar elementos de la matriz B
for(i=0; ilt; MatrixNum; i )
for(j= 0; jlt; númeromatriz; j )
{
double temp=0;
for(k=0; klt; MatrixNum; k )
temp =*(matrixD i*matrixNum k)* (*(matrixL k*matrixNum j) *(matrixU k*matrixNum j));
*(B i*matrixNum j)=temp;
}
//Encontrar los elementos en f
for(i=0; ilt; MatrixNum; i )
{
double temp=0; p> p>
for(j=0;jlt;matrixNum;j)
temp =*(matrixD i*matrixNum j)*(*(b j));
* (f i)=temp;
}
/* Calcular el valor del vector inicial de x*/
GaussLineMain(matrixA, x, b, MatrixNum );
/* Utilice la fórmula de iteración de Jacobi para resolver el valor de xk*/
int JacobiTime;
coutlt;lt;endllt;lt;endllt. ;lt;endllt; lt;"lt;lt;La iteración de Jacobi comienza, ingrese el número de iteraciones que desea gt;gt;:";
cingt;gt;JacobiTime;
while(JacobiTimelt;= 0)
{
coutlt;lt;"El número de iteraciones debe ser mayor que 0, vuelva a ingresar:";
cingt;gt;JacobiTime;
}
Jacobi(x, xk, B, f, MatrixNum, JacobiTime);
//Salida del solución del sistema de ecuaciones lineales*/
cout< ); //Establece la precisión de salida para comparar los resultados de diferentes tiempos de iteración
for(i=0; ilt; MatrixNum; i )
coutlt; lt; "x"lt ;lt;i 1lt;lt;" = "lt;lt;*(xk i)lt;lt;endl;
coutlt;lt;endllt;lt;endllt;lt;"El proceso de solución finaliza..."lt;lt;endllt;lt;endl;
//Libera toda la memoria asignada dinámicamente
eliminar [] matrizA;
eliminar [ ] matrizD;
eliminar [] matrizL
eliminar [] ma;
trixU;
eliminar [] B;
eliminar [] f;
eliminar [] x;
eliminar [] b;
}
/*--------------------
Función de asignación de espacio de memoria
www.LouJing.com
--------------------- -----* /
doble* allocMem(int num)
{
doble *cabeza;
if(( head=new double[num ])==NULL)
{
coutlt;lt;"Error en la asignación de espacio de memoria, el programa finaliza!"lt;lt;endl; p>
salir (0);
}
regresar cabeza;
}
/*----- ------ ----------------------------------
Calcular el inicial vector de x en el valor Ax=b, utilizando el método de eliminación del elemento principal de la columna gaussiana
www.LouJing.com
-------------- ------- -----------------------*/
void GaussLineMain(doble* A, doble* x, double* b, int num)
{
int i, j, k
//***Proceso num-1 filas
for(i= 0; ilt; num-1; i )
{
//Primero selecciona el elemento pivote para cada columna, es decir, la más grande
double lineMax=fabs( *(A i*num i));
int lineI=i;
for(j=i;jlt;num; j)
if( fabs(*(A j*num i))gt;fabs(lineMax)) lineI=j;
//La fila donde se encuentra el pivote y la fila de procesamiento actual se intercambia y el coeficiente correcto b también se intercambia
for(j=i;jlt;num;j)
{
. //A intercambia
lineMax=*( A i*num j);
*(A i*num j)=*(A lineI*num j); p>
*(A lineI*num j)=lineMax;
//Intercambia los elementos correspondientes en b
lineMax=*(b i); > *(b i)=*(b líneaI);
*(b líneaI)=lineMax;
}
if(*(A i*num i)==0) continue; //Si el pivote actual es 0, este ciclo termina
//Cambia A a triangular superior matriz, b también se transforma en consecuencia
for(j=i 1;jlt;num;j)
{
double temp=-* (A j* num i)/(*(A i*num i));
for(k=i;klt;num;k)
{
* (A j*num k) =temp*(*(A i*num k));
}
*(b j) =temp*(*( b i));
}
}
/* Verificar si Ax=b tiene solución única es verificar si el determinante de A es 0;
p>Si |A|!=0, significa que hay una solución única*/
doble determinanteA=1;
for(i=0;ilt;num ;i)
determinanteA*=*(A i*num i);
if(determinanteA==0)
{
coutlt; lt;endllt;lt;endllt;lt;"Mediante el cálculo, el determinante de la matriz A es |A|=0, es decir, A no tiene solución única.
\nEl programa sale..."lt;lt;endllt;lt;endl;
exit(0);
}
/* Desde la última línea Comience sustituyendo nuevamente para resolver el valor del vector inicial de x*/
for(i=num-1;igt;=0;i--)
{
for(j=num-1;jgt;i;j--)
*(b i)-=*(A i*num j)*(*(x j));
*(x i)=*(b i)/(*(A i*num i));
}
}
/*- ----------------------------------
Utiliza la fórmula de iteración jacobiana para resolver x El valor exacto
www.LouJing.com
La fórmula de iteración es: xk=Bx f
---------- --- -----------------------*/
void Jacobi(doble* x, doble* xk, doble* B, double* f, int num, int tiempo)
{
int t=1, i, j
while (tlt; = tiempo) p>
{
for(i=0;ilt;num;i)
{
doble temp=0;
for( j=0; jlt; num; j )
temp =*(B i*num j)*(*(x j));
*(xk i )=temp * (f i);
}
//Asigna xk a x y prepárate para la siguiente iteración
for(i=0; ilt; número; i)
*(x i)=*(xk i);
t
}
}