Algoritmia - Investigación de Operaciones

 
Vista:

Investigación de Operaciones

Publicado por Gustavo (2 intervenciones) el 18/09/2003 04:54:38
Hola amigos. Estoy buscando algún código en C o Pascal que utilice el método simplex para maximizar o minimizar ecuaciones con determinadas restricciones. Gracias.
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

Implementación símplex en C para problemas de programación lineal

Publicado por Alejandro (307 intervenciones) el 28/02/2024 21:28:09
Gustavo, el método símplex es un algoritmo utilizado para resolver problemas de programación lineal, donde se busca maximizar o minimizar una función lineal sujeta a un conjunto de restricciones lineales. Aquí te proporcionaré un ejemplo simple de implementación del método símplex en C. Ten en cuenta que este es un algoritmo complejo y puede requerir ajustes según tus necesidades y restricciones específicas.

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include <stdio.h>
 
void imprimirTabla(double tabla[20][20], int filas, int columnas) {
    int i, j;
 
    for (i = 0; i < filas; i++) {
        for (j = 0; j < columnas; j++) {
            printf("%.2lf\t", tabla[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
 
void pivotar(double tabla[20][20], int pivoteFila, int pivoteColumna, int filas, int columnas) {
    int i, j;
    double pivote = tabla[pivoteFila][pivoteColumna];
 
    for (j = 0; j < columnas; j++) {
        tabla[pivoteFila][j] /= pivote;
    }
 
    for (i = 0; i < filas; i++) {
        if (i != pivoteFila) {
            double factor = tabla[i][pivoteColumna];
            for (j = 0; j < columnas; j++) {
                tabla[i][j] -= factor * tabla[pivoteFila][j];
            }
        }
    }
}
 
int encontrarColumnaPivote(double tabla[20][20], int filas, int columnas) {
    int j;
    double minimo = tabla[0][1]; // Supongamos que el elemento (0,1) es el mínimo
    int columnaPivote = 1;
 
    for (j = 2; j < columnas - 1; j++) {
        if (tabla[0][j] < minimo) {
            minimo = tabla[0][j];
            columnaPivote = j;
        }
    }
 
    return columnaPivote;
}
 
int encontrarFilaPivote(double tabla[20][20], int columnaPivote, int filas, int columnas) {
    int i;
    double minimo = -1;
    int filaPivote = -1;
 
    for (i = 1; i < filas; i++) {
        if (tabla[i][columnaPivote] > 0) {
            double cociente = tabla[i][columnas - 1] / tabla[i][columnaPivote];
            if (minimo == -1 || cociente < minimo) {
                minimo = cociente;
                filaPivote = i;
            }
        }
    }
 
    return filaPivote;
}
 
void simplex(double tabla[20][20], int filas, int columnas) {
    while (1) {
        int columnaPivote = encontrarColumnaPivote(tabla, filas, columnas);
        if (columnaPivote == -1) {
            break; // Ya no hay columnas negativas, terminar
        }
 
        int filaPivote = encontrarFilaPivote(tabla, columnaPivote, filas, columnas);
        if (filaPivote == -1) {
            printf("Problema no acotado.\n");
            return;
        }
 
        printf("Pivote en (%d, %d)\n", filaPivote, columnaPivote);
        pivotar(tabla, filaPivote, columnaPivote, filas, columnas);
        imprimirTabla(tabla, filas, columnas);
    }
}
 
int main() {
    int filas, columnas, i, j;
 
    printf("Ingrese el número de filas: ");
    scanf("%d", &filas);
    printf("Ingrese el número de columnas: ");
    scanf("%d", &columnas);
 
    double tabla[20][20];
 
    printf("Ingrese los coeficientes de la función objetivo:\n");
    for (j = 0; j < columnas - 1; j++) {
        scanf("%lf", &tabla[0][j]);
    }
 
    printf("Ingrese los coeficientes de las restricciones y los lados derechos:\n");
    for (i = 1; i < filas; i++) {
        for (j = 0; j < columnas; j++) {
            scanf("%lf", &tabla[i][j]);
        }
    }
 
    printf("Ingrese la fila de la función objetivo:\n");
    for (j = 0; j < columnas - 1; j++) {
        scanf("%lf", &tabla[0][j]);
        tabla[0][j] *= -1; // Multiplicar por -1 para maximizar
    }
 
    imprimirTabla(tabla, filas, columnas);
    simplex(tabla, filas, columnas);
 
    printf("Solución encontrada:\n");
    for (j = 0; j < columnas - 1; j++) {
        int esCero = 1;
        for (i = 1; i < filas; i++) {
            if (tabla[i][j] != 0) {
                esCero = 0;
                break;
            }
        }
        if (esCero) {
            printf("x%d = 0\n", j + 1);
        } else {
            printf("x%d = %.2lf\n", j + 1, tabla[encontrarFilaPivote(tabla, j, filas, columnas)][columnas - 1]);
        }
    }
 
    return 0;
}

Este es un ejemplo simple de implementación del método símplex en C. Ten en cuenta que este algoritmo puede requerir ajustes según la especificación exacta del problema de programación lineal que estás tratando de resolver. Además, este código asume que el problema es de maximización; si necesitas minimizar, deberías ajustar la función objetivo. Además, esta implementación no maneja restricciones de igualdad directamente.

Es recomendable utilizar bibliotecas matemáticas especializadas o software específico para problemas de programación lineal en un entorno de producción.
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