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

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>

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;

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

*(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;

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)

{

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

}

}