Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Algoritmia » algortimo de eliminacion gaussiana hacia atras

Algoritmia - algortimo de eliminacion gaussiana hacia atras

Volver
Nuevo Tema
<<>>
 
Vista:

algortimo de eliminacion gaussiana hacia atras

Publicado por Fernanda (1 intervención) el 06/08/2008 20:09:23
Disculpen otra vez las molestias, pero no se si podrian ayudarme a descifrar este algoritmo para ke korra en java, mas o menos tengo la idea pero por ejemplo en el paso 6 y paso 9 no se ke se tiene ke hacer.

Este es el algoritmo:

Para resolver el sistema lineal de n x n

E1: a11x1+a12x2+....a1nxn=a1,n+1
E2: a21x1+a22x2+....a2nxn=a2,n+1
.
.
.
En: an1x1+an2x2+....a1nxn=an,n+1

Entrada numero de incognitas y ecuaciones n; matriz aumentada A=(aij)
donde 1 es menor o igual a i es menor o igual n y
1 es menor o igual j es menor o igual n+1

salida solucion x1,x2...xn o mensaje de que el sistema lineal no tiene solucion unica

paso 1 para i=1... n-1 haga pasos 2-4(proceso de eliminacion)
paso 2 sea p el entero mas peqeño con i menor o igual a p es menor o igual n y
api sea difrente de 0 entonces encontraste un entero p
entonces Salida ('no existe solucion')
parar

paso3 si p es dirente de i reaice (Ep)<->(Ei)

paso4 para j=i+1,...,n haga pasos 5 y 6
paso 5 tome mij=aij/aii
paso6 Realice (Ej-mijEij)->(Ej);

paso 7 Si ann=0 entonces salida('no existe solucion unica') parar

paso8 tome xn= an,n+1/ann (cominece la sustitucion hacia tras)
n
paso9 para i=n-1...1 tome xi=[ai,n+1- Ej=i+1 aij xj]/aii

paso10 salida (k1...xn)(Preceso terminado exitosamente parar)

Muchas gracias por su atnecion.

Atentamente: Ma. Fernanda
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Sistemas lineales por eliminación gaussiana en Java

Publicado por Alejandro (307 intervenciones) el 12/03/2024 22:02:09
Fernanda, voy a traducir el algoritmo a Java y explicar cada paso para que puedas entenderlo mejor:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
public class SistemaLineal {
 
    public static void resolverSistema(double[][] A) {
        int n = A.length;
 
        // Paso 1
        for (int i = 0; i < n - 1; i++) {
            // Paso 2
            int p = encontrarPivote(A, i);
            if (p == -1) {
                System.out.println("No existe solución");
                return;
            }
 
            // Paso 3
            if (p != i) {
                intercambiarFilas(A, p, i);
            }
 
            // Paso 4
            for (int j = i + 1; j < n; j++) {
                // Paso 5
                double mij = A[j] / A;
                // Paso 6
                for (int k = i; k < n + 1; k++) {
                    A[j][k] -= mij * A[k];
                }
            }
        }
 
        // Paso 7
        if (A[n - 1][n - 1] == 0) {
            System.out.println("No existe solución única");
            return;
        }
 
        // Paso 8
        double[] soluciones = new double[n];
        soluciones[n - 1] = A[n - 1][n] / A[n - 1][n - 1];
 
        // Paso 9
        for (int i = n - 2; i >= 0; i--) {
            double suma = A[n];
            for (int j = i + 1; j < n; j++) {
                suma -= A[j] * soluciones[j];
            }
            soluciones = suma / A;
        }
 
        // Paso 10
        System.out.print("Solución: ");
        for (double solucion : soluciones) {
            System.out.print(solucion + " ");
        }
    }
 
    // Función para encontrar el pivote en la columna i
    private static int encontrarPivote(double[][] A, int i) {
        int n = A.length;
        for (int j = i; j < n; j++) {
            if (A[j] != 0) {
                return j;
            }
        }
        return -1; // No se encontró un pivote válido
    }
 
    // Función para intercambiar dos filas en la matriz A
    private static void intercambiarFilas(double[][] A, int i, int j) {
        double[] temp = A;
        A = A[j];
        A[j] = temp;
    }
 
    public static void main(String[] args) {
        double[][] A = {{1, 1, 1, 6}, {2, 3, 5, 18}, {4, 6, 8, 32}};
        resolverSistema(A);
    }
}

Ahora, veamos qué hace cada paso:

1. Paso 1: Recorre todas las filas excepto la última.
2. Paso 2: Encuentra el pivote [i]p. Si no se encuentra un pivote válido, el sistema no tiene solución única.
3. Paso 3: Si el pivote [i]p no está en la fila actual [i]i, intercambia las filas [i]i y [i]p.
4. Paso 4: Reduce las filas por debajo de la fila [i]i para hacer ceros debajo del pivote.
5. Paso 5: Calcula el coeficiente [i]m_ij para cada fila [i]j por encima del pivote.
6. Paso 6: Resta [i]m_ij veces la fila [i]i de la fila [i]j para hacer ceros debajo del pivote.
7. Paso 7: Verifica si el último elemento de la última fila es cero. Si lo es, el sistema no tiene solución única.
8. Paso 8: Calcula [i]x_n, la solución para la última incógnita.
9. Paso 9: Calcula las demás soluciones hacia atrás utilizando la sustitución hacia atrás.
10. Paso 10: Imprime las soluciones encontradas.

Espero que esta explicación te ayude a entender mejor el algoritmo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar