Facultad de Ingeniera

Algoritmos reconocidos mundialmente

Para qu se usa un algoritmo?
Curso: Fundamentos de programacin
Profesor: Pedro Pablo Rosales Lpez
Integrantes

Casas Bocanegra Kattia

Falcon Delgado Alexander
Ortiz Martinez Renato
Oyarce Milutinovich Branko
Robles Valdez Cristhian

2014-1

ALGORITMO 1: ALGORITMO SIMPLEX

TTULO: Algoritmo Simplex de George Dantzig
AUTOR: George Dantzig
George Bernard Dantzig (8 de
noviembre de 1914 13 de mayo de
2005) fue un profesor, fsico y
matemtico
estadounidense,
reconocido por desarrollar el mtodo
simplex y es considerado como el
"padre de la programacin lineal".
Recibi muchos honores, tales como la
Medalla Nacional de Ciencia en 1975 y
el premio de Teora John von Neumann en 1974.
Fue miembro de la Academia Nacional de Ciencias, la Academia Nacional
de Ingeniera y la Academia Americana de Artes y Ciencias.
Obtuvo su licenciatura en Matemticas y Fsica en la Universidad de
Maryland en 1936, su grado de mster en Matemticas en la
Universidad de Mchigan, y su doctorado en la Universidad de California,
Berkeley en 1946. Recibi adems un doctorado honorario de la
Universidad de Maryland en 1976.
El padre de Dantzig, Tobas Dantzig, fue un matemtico ruso que realiz
estudios con Henri Poincar en Pars. Tobas se cas con una estudiante
de la universidad de la Sorbona, Anja Ourisson, y la pareja emigr a los
Estados Unidos.
AO: 1947
PARA QU SE USA?
El algoritmo Simplex es un algoritmo que ayuda a la solucin de
problemas de programacin lineal de manera sencilla. Podramos decir
que tambin podemos utilizar el mtodo grfico, pero la diferencia entre
el mtodo simplex y el mtodo grfico, es que el segundo permite
nicamente dos variables como mximo, mientras que con el simplex se
pueden resolver problemas con n variables, pues no utiliza dos
cuadrantes, sino que se utilizan las matrices.
Es tambin un mtodo iterativo que permite mejorar la solucin en cada
paso. El mtodo bsicamente consiste en caminar del vrtice de un
poliedro a un vrtice continua pero de manera que aumente, si la
funcin objetivo es maximizar; o disminuya, si la funcin objetivo es
minimizar; y como el nmero de esquinas que presenta un poliedro es
finito, siempre habr una solucin.
CUL ES EL ALGORITMO?

Este proceso que se repite una y otra vez, siempre inicia en un punto
extremo de la regin factible que normalmente es el origen, en cada
iteracin se mueve a otro punto extremo adyacente hasta llegar a la
solucin ptima.
Los pasos del Mtodo Simplex son los siguientes:
1. Utilizando la forma estndar, determinar una solucin bsica factible
inicial igualando a las n-m variables igual a cero (el origen).
2. Seleccionar la variable de entrada de las variables no bsicas que al
incrementar su valor pueda mejorar el valor en la funcin objetivo.
Cuando no exista esta situacin, la solucin actual es la ptima; si no,
ir al siguiente paso.
3. Seleccionar la variable de salida de las variables bsicas actuales.
4. Determinar la nueva solucin al hacer la variable de entrada bsica y
la variable de salida no bsica, ir al paso 2 (actualizar).
ALGORITMO EN C++:
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
//Lo maximo que pueden alcanzar las variables y restricciones
#define MAX 10
#define RESTRICCION 3
double funcion[MAX], restricciones[MAX+1][MAX+RESTRICCION];
double independiente[RESTRICCION];
int leeDatos(int *var) {
int rest,c,i;
printf(" Funcion a Optimizar \nNumero de Variables: ");
scanf("%d",var);
printf("\nRecuerda: c1.X1+c2.X2+...cn.Xn = b \n\n");
for(c=0;c<*var;c++)
{
printf(" c%d: ", c+1);
scanf("%lf",&funcion[c]);
fflush(stdin);
}
printf("\nNumero de Restricciones: ");
scanf("%d",&rest);

fflush(stdin);
for(i=0;i<rest;i++)
{
printf("Restriccion %d\n",i+1);
for(c=0;c<*var;c++)
{
printf(" c%d: ",c+1);
scanf("%lf",&restricciones[i][c]);
fflush(stdin);
}
printf("Termino independiente ");
scanf("%lf", &independiente[i]);
fflush(stdin);
}
return rest;
}
int main(void)
{
int rest, var, ni ;
int i,j, k, columna, renglon, count, cuenta;
double maximo = 0, menor, aux, mult, temp;
rest = leeDatos(&var);
//Crear tabla inicial simplex
for(i=0;i<rest;i++)
for(j=0; j<rest; j++)
if (i == j)
restricciones[i][var+j]=1;
else
restricciones[i][var+j]=0;
for(i=0; i<rest;i++)
restricciones[i][var+rest] = independiente[i];
for(j=0; j<var; j++)
restricciones[rest][j] = funcion[j] * -1;
for(j=var; j<rest+var; j++)
restricciones[rest][j] = 0;
ni=1;
printf("\n-----------------------------------------------");
printf("\n ITERACION %d",ni);
printf("\n-----------------------------------------------\n");
ni++;

for(i=0; i<=rest; i++) {

for(j=0; j<=rest+var; j++)
printf(" %.2lf \t", restricciones[i][j]);
printf("\n");
}
//Encontrar la variable de decision que entra a la base
//y la de holgura que saldra de la base
do
{
//Encontrar la variable de decision que entrara a la base
maximo = abs(restricciones[rest][0]);
columna = 0;
for(j=0; j<=rest+var; j++)
{
if( restricciones[rest][j] < 0 )
{
temp = -1 * restricciones[rest][j];
if ( maximo < temp)
{
maximo = temp;
columna = j;
}
}
else
continue;
}
count = 0;
aux = 1e20;
menor = 1e20;
for(i=0; i<rest; i++) {
if(restricciones[i][columna] > 0)
aux = restricciones[i][rest+var] / restricciones[i][columna];
else
count++;
if( menor > aux ) {
menor = aux;
renglon = i;
}
}
if(count == rest) {
printf("Soluci no acotada");
exit(1);

}
printf("\nPivote:
%.2lf,
renglon
%d
%d",restricciones[renglon][columna], renglon, columna);
//Encontrar los coeficientes de la nueva tabla
aux = restricciones[renglon][columna];
for(j=0; j<=(rest+var); j++)
restricciones[renglon][j] = restricciones[renglon][j] / aux;
for(i=0; i<=rest; i++) {
if (i == renglon )
continue;
else {
aux = restricciones[i][columna] * -1;
for(k=0; k <= rest+var; k++) {
restricciones[i][k] = (aux * restricciones[renglon][k]) +
restricciones[i][k];
}
}
}
printf("\n-----------------------------------------------");
printf("\n ITERACION %d",ni);
printf("\n-----------------------------------------------\n");
ni++;
for(i=0; i<=rest; i++) {
for(j=0; j<=rest+var; j++)
printf(" %.2lf \t", restricciones[i][j]);
printf("\n");
}
cuenta = 0;
for(j=0;j<rest+var;j++)
if(restricciones[rest][j] >= 0)
cuenta++;
if (cuenta == rest+var)
break;
} while(cuenta);
printf("---->");
getch();
}
FUENTES:

columna

 http://www.ingenieriaindustrialonline.com/herramientas-para-elingeniero-industrial/investigaci%C3%B3n-de-operaciones/m
%C3%A9todo-simplex/
http://www.forosdelweb.com/f96/metodo-simplex-c-826061/
http://es.wikipedia.org/wiki/George_Dantzig

ALGORITMO 2: ALGORITMO RELACIN ENTERO

TTULO: Algoritmo relacin entero
AUTOR: Helaman Ferguson y Rodney Forcade
Helaman Pratt Rolfe Ferguson (nacido en
1940 en Salt Lake City, Utah) es un escultor
americano
y
un
artista
digital,
especficamente un algorista.
La madre de Ferguson muri cuando l tena
cerca de tres y su padre se fue a servir en la
Segunda Guerra Mundial. Fue adoptado por
un inmigrante irlands y se cri en Nueva
York. Aprendi a trabajar con sus manos en un
estilo del viejo mundo con materiales de
tierra de su padre adoptivo, que era carpintero y albail de profesin. Un
profesor de matemticas del arte-inclinado en la escuela secundaria le
ayud a desarrollar su doble inters en las matemticas y el arte.
Ferguson era un graduado de Hamilton College, una escuela de artes
liberales en Nueva York. En 1971, recibi un doctorado en matemticas
de la Universidad de Washington. Ferguson y su esposa, Claire, ms
tarde se traslad a Utah, donde continu enseando matemticas y
estudi arte en la Universidad Brigham Young. La pareja levant sus
siete hijos-contando los matemticos, msicos, un desarrollador de
software y un alfarero entre ellos-mientras que Ferguson fue titular en la
Universidad de Brigham Young durante 17 aos.
En 1977, Ferguson y otro matemtico, Rodney Forcade, desarrollaron un
algoritmo para la deteccin relacin entero. Fue la primera
generalizacin viable del algoritmo de Euclides para tres o ms
variables. Un algoritmo de deteccin relacin nmero entero ms
notable que desarroll, el algoritmo PSLQ, fue seleccionado como uno de
los "Top Ten Algoritmos del Siglo" por Jack Dongarra y Francis Sullivan.
AO: 1947
PARA QU SE USA?
Algoritmos de relacin enteros tienen numerosas aplicaciones. La
primera aplicacin es para determinar si un nmero real dado x es
probable que sea algebraica, mediante la bsqueda de una relacin de
nmero entero entre un conjunto de potencias de x {1, x, x2, ..., xn}. La
segunda aplicacin es la bsqueda de una relacin de nmero entero

entre un nmero real x y un conjunto de constantes matemticas tales

como el correo, y ln (2), lo que conducir a una expresin para x como
una combinacin lineal de estas constantes.
Un xito notable de este enfoque fue el uso del algoritmo PSLQ para
encontrar la relacin de nmero entero que condujo a la frmula BaileyBorwein-Plouffe por el valor de . PSLQ tambin ha ayudado a encontrar
nuevas identidades que implican mltiples funciones zeta y su aparicin
en la teora cuntica de campos; y en la identificacin de puntos de
bifurcacin del mapa logstico. Por ejemplo, cuando B4 es el cuarto
punto de bifurcacin del mapa logstico, el = constante -B4 (B4-2) es
una raz de un polinomio 120 grados cuyo coeficiente es ms grande se
combinan 25730. algoritmos de relacin Integer con las tablas de alta
precisin constantes matemticas y mtodos de bsqueda heurstica en
aplicaciones tales como la calculadora simblica Inversa o inversor de
Plouffe.
CUL ES EL ALGORITMO?
Una relacin de nmero entero entre un conjunto de nmeros reales x1,
x2, ..., xn es un conjunto de nmeros enteros a1, a2, ..., an, no todos 0,
tal que

a_1x_1 + a_2x_2 + \ cdots + a_nx_n = 0 \,

Un algoritmo relacin entero es un algoritmo para encontrar las

relaciones de nmeros enteros. Especficamente, dado un conjunto de
nmeros reales conocidos con una precisin determinada, un algoritmo
relacin nmero entero o bien encontrar un nmero entero relacin
entre ellos, o determinar que no existe ninguna relacin con
coeficientes enteros cuyas magnitudes son menores que un cierto lmite
superior.
ALGORITMO EN C++:
(Es un ejemplo corto debido a la complejidad del algoritmo)
int main()
{
float x;

int y;
printf("ingrese un numero: ");
scanf("%f",&x);
y=x;
x=x-y;
if(x>0)
printf("es decimal\n\n");
else
printf("es entero\n\n");

return 0;
}
FUENTES:
Weisstein, Eric W., "Integer Relation", MathWorld.
A Polynomial Time, Numerically Stable Integer Relation Algorithm
http://en.wikipedia.org/wiki/Integer_relation_algorithm

ALGORITMO 3: MTODOS ITERATIVOS ESTACIONARIOS

TTULO DEL ALGORITMO:
Algoritmo de mtodos iterativos estacionarios
AUTOR DEL ALGORITMO:
Francisco Herrera
MTODOS ITERATIVOS ESTACIONARIOS:
Los algoritmos iterativos se caracterizan por ejecutarse mediante ciclos.
Estos algoritmos son muy tiles al momento de realizar tareas
repetitivas. La opcin al uso de algoritmos iterativos es el uso de la
recursividad en funciones. Estas implican una escritura ms sencilla
(corta), tanto para su implementacin como para su entendimiento, pero
en contraparte, utilizan mucho ms recursos de sistema que una
iteracin debido a que necesitan, adems del uso del procesador, la pila
del sistema para "apilar" los diversos mbitos de cada funcin. Los
mtodos iterativos estacionarios resuelven un sistema lineal con un
operador que se aproxima al original; y basndose en la medida de error
(el residuo), desde una ecuacin de correccin para la que se repite este
proceso. Mientras que estos mtodos son sencillos de derivar,
implementar y analizar, la convergencia normalmente slo est
garantizada para una clase limitada de matrices.
Permite ejecutar una instruccin repetidas veces. Similar a la instruccin
alternativa.
CMO ES EL ALGORITMO?
Sintaxis:
While(B1) I1 *[B1 I1
]
En lenguaje while:
f := 0; i := 1;
while(i <= N) f := f + i;
i := i + 1;
PARA QU SE USA?

Optimizacin combinatoria y en dominio reales

Modelado e identificacin de sistemas
Planificacin y control
Ingeniera
Vida artificial
Aprendizaje y minera de datos
Visin por computador e informtica grfica

Internet y Sistemas de Recuperacin de informacin

EL ALGORITMO
Inicio (1)
t=0
inicializar P(t)
evaluar P(t)
Mientras (no se cumpla la condicin de parada) hacer
Inicio(2)
t=t+1
seleccionar P(t) desde P(t-1)
P(t)
cruce P(t)
P(t)
mutacin P(t)
P(t)
reemplazamiento (P(t-1),P(t))
evaluar P(t)
Final(2)
Final(1)
Ejemplo del algoritmo:
#include <stdio.h>
int main(int argc, char** argcv)
{
for(int i = 1; i <= 10; i++) {
printf("Esta es la vez %d que hago esto!\n", i);
}
return 0;
}
Fuentes:
http://es.wikipedia.org/wiki/Algoritmo_iterativo
http://www.lcc.uma.es/~villa/tn/tema05.pdf
http://sci2s.ugr.es/docencia/doctoCaminos/Sesion-1-b.pdf

ALGORITMO 4: LOS ALGORITMOS GENTICOS

TTULO:
LOS ALGORITMOS GENTICOS
AUTOR:
John Henry Holland
Dr. John Henry Holland (2 de febrero de 1929)
pionero en sistemas complejos y ciencia no
lineal. Tambin es conocido como el padre del
Algoritmo gentico. Profesor de Filosofa, de
Ingeniera Elctrica y de Ciencias de la
computacin en la Universidad de Mchigan.
Autor de numerosos libros
complejos adaptativos.

sobre

Sistemas

AO:
1962
PARA QU SE USA?
Cuando hablamos de algoritmos genticos, hay que hablar de John
Holland que en 1962 asienta las bases para sus posteriores desarrollos
hasta llegar a lo que se conoce hoy por algoritmos genticos.
Un algoritmo gentico es un mtodo de bsqueda que imita la teora de
la evolucin biolgica de Darwin para la resolucin de problemas. Para
ello, se parte de una poblacin inicial de la cual se seleccionan los
individuos ms capacitados para luego reproducirlos y mutarlos para
finalmente obtener la siguiente generacin de individuos que estarn
ms adaptados que la anterior generacin.
En la naturaleza todo el proceso de evolucin biolgica se hace de forma
natural pero para aplicar el algoritmo gentico al campo de la resolucin
de problemas habr que seguir una serie de pasos.
Una premisa es conseguir que el tamao de la poblacin sea lo
suficientemente grande para garantizar la diversidad de soluciones. Se
aconseja que la poblacin sea generada de forma aleatoria para obtener
dicha diversidad. En caso de que la poblacin no sea generada de forma
aleatoria habr que tener en cuenta que se garantice una cierta
diversidad en la poblacin generada.
CUL ES EL ALGORITMO?
Los pasos bsicos de un algoritmo gentico son:
Evaluar la puntuacin de cada uno de los cromosomas generados.
Permitir la reproduccin de los cromosomas siendo los ms aptos los
que tengan ms probabilidad de reproducirse.

 Con cierta probabilidad de mutacin, mutar un gen del nuevo individuo

generado.
Organizar la nueva poblacin.
Estos pasos se repetirn hasta que se de una condicin de terminacin.
Se puede fijar un nmero mximo de iteraciones antes de finalizar el
algoritmo gentico o detenerlo cuando no se produzcan ms cambios en
la poblacin (convergencia del algoritmo). Esta ltima opcin suele ser la
ms habitual.
ALGORITMO EN C++:
Debido a la gran complejidad del cdigo, se colocar nicamente
el cdigo del siguiente modelo:

llifndef SGA_H_
lldefine SGA_H_
llinclude <stdio.h>
llinclude <stdlib.h>
llinclude <assert.h>
llinclude <float.h>
llinclude <math.h>
llinclude "ctes.h"
llinclude // Vector.h"
llinclude "random.h"
llinclude "absindv.h"
lldefine ASCENDENTE

lldefine DESCENDENTE
class GA {
protected:
int
float
float
long
Absindiv
Absindiv
float
Mutacion.
float
Cruzamiento.
1
2
Censo;
MinFitness;
MaxFitness;
Generation;
**Poblacion;
**PobTmp;
ProbMutation;
ProbCross;
//
//
//
//
//
//
//
//
Censo of GA.
Minimo fitness.
Maximo fitness
Generacion actual
Puntero a la poblacion.
Poblacin Temporal.
Probabilidad de
Probabilidad de
// Ordena un vector de punteros a individuos.
void
ASCENDENTE);
public:
SortAbsindiv(Absindiv **P, int ORDEN 86 Antonio M. Carpintero Snchez
// Constructores.
GA ( Absindiv *indiv, int Numindiv )

// Constructor de copia.
GA ( const GA & P );
// Destructor.
virtual -GA();
// Retorna el censo de la poblacion.
int GetCenso(void) {return Censo;}
// Visualiza la poblacion.
void Show(void);
// Retorna el indice del individuo con mayor fitness.
int GetMaxFitness(void) const;
// Retorna el ipdice del individuo con menor fitness.
int GetMinFitness(void) const;
// Inicializa aleatoriamente individuos desde iStart hasta
iEnd.
void Random(int iStart = O,int iEnd=O);
// Selecciona un individuo que sea distinto de "i"
int Select(int i -1);
// Realiza una iteracion delGA.
void OneGeneration(void);
// Ordena la poblacion segun ORDEN.
void SortPob(int ORDEN= ASCENDENTE);
// Ordena la poblacion temporal segun ORDEN.
void SortPobTmp(int ORDEN= ASCENDENTE);
// Normaliza las probabilidades de la poblacion temporal.
void NormalizeTmp(void);
// Normaliza las probabilidades de la poblacion.
void NormalizePob(void);
// Normaliza las probabilidades de un vector de punteros a
individuos.
void Normalize(Absindiv **);
// Reinicializa las poblaciones.
void Reset(void);
// Retorna el numero de generacion actual.
long GetGeneration(void) const {return
Generation;};
// Calcula los fenotipos de los individuos. Redes de Neuronas .... 87
};
void SetPhenotype(void);
// Calcula los fitness de los individuos.
void SetFitness(void);
// Sustituye los individuos [iStart .. iEnd] de la poblacion
por los
// de la poblacion temporal [iStart .. iEnd].
void Replace(int iStart , int iEndl;
// Asigna la probabilidad de mutacion.
void

p;}
SetProbMutation(float P) { ProbMutation
// Asigna la probabilidad de cruce.
void SetProbCross(float P) { ProbCross p;}
// Intercambia dos punteros a individuos.
void Swap(Absindiv* &Indl,Absindiv* &Ind2);
// Operadores.
// Operador de asignacion.
GA& operator=(const GA& V);
// Retorna una referencia al individuo i.
Absindiv& operator[] (int i);
#endif
FUENTES:
http://www.it.uc3m.es/jvillena/irc/practicas/06-07/05.pdf
http://www.sc.ehu.es/ccwbayes/docencia/mmcc/docs/temageneticos.pdf
http://es.wikipedia.org/wiki/Algoritmo_gen%C3%A9tico