ANALISIS DE ALGORITMOS

Divide y Vencers (Rotacin de una imagen)

Presentado Por:
Andrea del pilar castao Lpez
Diego Fernando Rojas Goyeneche

Presentado a:
Alonso Guevara Prez

Corporacin Universitaria Minuto de Dios

Bogot
19 de octubre de 2015

1. Introduccin

A travs del tiempo se han ido mejorando los mtodos para dar solucin a
cualquier problema de programacin, ya que hoy en da se brindan ms
herramientas que facilitan la solucin de estos; pero los algoritmos desde su
aparicin hasta el da de hoy son de vital importancia para el desarrollo de
cualquier aplicacin, nos brinda el dominio sobre la lgica de programacin para
resolver cualquier problema presentado.
El anlisis de complejidad de los algoritmos de rotacin nos brinda informacin
importante sobre cul de los utilizados es el ms adecuado segn sea el caso
presentado, para cada problema determinaremos una medida N de su tamao
(por nmero de datos) e intentaremos hallar respuestas en funcin de dicho N. El
concepto exacto que mide N depende de la naturaleza del problema. As, para un
vector se suele utilizar como N su longitud; para una matriz, el nmero de
elementos que la componen; para un grafo, puede ser el nmero de nodos (a
veces es ms importante considerar el nmero de arcos, dependiendo del tipo de
problema a resolver); en un fichero se suele usar el nmero de registros, etc.
En esta prctica se pretende validar la complejidad y el tiempo de ejecucin de los
algoritmos de rotacin, as verificando cul de estos es el ms complejo de
utilizar, el conlleva menos tiempo en ser ejecutado; por consiguiente brindado
informacin clara para demostrar en estos las diferentes caractersticas.

2. Planteamiento del Problema

Validar mediante la programacin de los tres algoritmos de rotacin su
complejidad y tiempos de ejecucin, se deben programar los tres en cualquier
lenguaje.
Implementar el algoritmo de rotacin de imgenes que emplea tcnica divide y
vencers.
Sea una imagen de tamao 2n x 2n, k >0 Rotar 90o en sentido de las agujas del
reloj (el eje de rotacin es el que pasa por el centro de la imagen)
Algoritmo Clsico de Rotacin.
Rotacin mediante divide y vencers.
Algoritmo Divide y vencers de rotacin.

3 Anlisis de los algoritmos de Rotacin

3.1 Algoritmo Clsico de Rotacin
El algoritmo clsico de rotacin se apoya en una matriz auxiliar para realizar este
proceso de rotacin.
Complejidad temporal ft=O (n2)
Algoritmo:
Desde i=0 hasta n-1
Desde j:=0 hasta n-1
ImagenRotada [i, j]:=imagen [n-j-1, i]
Fin desde
Fin desde

Tamao de la imagen
Si k=5

25

tamao=32x32n=32
Si k=8 28 tamao=256x256n=256
Si k=5 210 tamao=1024x1024n=1024
Si k=5 212 tamao=4096x4096n=4096
Complejidad espacial=fe=n2+ n2=O (2n2)

Numero de asignaciones
1.024
65.536
1.048.576
16.177.216

3.2 Rotacin mediante divide y vencers.

La idea bsica consiste en dividir la imagen de entrada en 4 subimagenes, y luego
se realiza una traslacin de cada subimagen para obtener la resultante.

El algoritmo es conocido cuando la imagen tiene tamao 2x2. En esta

circunstancia no se divide la imagen sino que simplemente se realiza la traslacin.

Algoritmo:
Z:=imagen [i1, j1]
Imagen [i1, j1]:=imagen [i1+1, j1]
Imagen [i1+1, j1]:= [i1+1, j1+1]`
Imagen [i1+1, j1+1]:= [i1+1, j1+1]
Imagen [i1, j1+1]:=z
Complejidad espacial: O (1)
3.3 Algoritmo Divide y vencers de rotacin
El Algoritmo de traslacin consistir en iterar para todos los puntos de la
subimagen superior izquierda, y en cada paso de iteracin se har:
Algoritmo:

Resultado que el algoritmo que rota la imagen mediante la tcnica divide y

vencers es:

Como se escribe originalmente: Rota90grados (0, 0, n, n, imagen, n)

(0,0): Coordenadas de la esquina superior izquierda.
(n-1, n-1): Coordenadas de la esquina inferior derecha

Es importante tener en cuenta las coordenadas de las subimagenes en que se

divide la imagen, de manera que , para el caso general, la funcin principal tiene
como parmetros de entrada (adems de la tabla de la imagen) las coordenadas
del pixel de la esquina superior izquierda: (i, j) y de la esquina inferior derecha ms
uno (i1,j1). El tamao de la tabla engloba a las cuatro es n.

El algoritmo tendr una ecuacin de recurrencia:

T(n)=4T(n/2)+c_1
Resolviendo por el mtodo maestro:
A=4, b = 2 y k =0
a> bk T(n)

--

nlog4=n2

Ft: O (n2)

Se puede pensar que no tiene ventaja alguna, pero si se piensa en que su

complejidad espacial disminuye al no usar una matriz auxiliar y adems se puede
programar de manera paralela, su eficiencia es mayor frente al algoritmo clsico
de programacin.
Complejidad espacial = fe =n2=O (n2)

4. Implementacin de algoritmos
4.1 Algoritmo Clsico de Rotacin
El algoritmo clsico de rotacin se apoya en una matriz auxiliar para realizar este
proceso de rotacin.
Cdigo:

*//* Funcin encargada de rotar una imagen usando el algoritmo clsico*//*

Void rotacionClasica (BMP *imagenOriginal, BMP * imagenTratada) {
Int i;
Int j;
Int n = imagenOriginal->alto;
For (i = 0; i < n; i++) {
For (j = 0; j < n; j++) {
ImagenTratada->pixelR[i] [j] = imagenOriginal->pixelR
[n - j - 1] [i];
ImagenTratada->pixelB[i] [j] = imagenOriginal->pixelB
[n - j - 1] [i];
ImagenTratada->pixelG[i] [j] = imagenOriginal->pixelG
[n - j - 1] [i];
}
}
}
4.2 Rotacin mediante divide y vencers.
La idea bsica consiste en dividir la imagen de entrada en 4 subimagenes, y luego
se realiza una traslacin de cada subimagen para obtener la resultante

*//* Funcin encargada de rotar una imagen la cantidad de grados

especificada mediante el uso de un algoritmo con la tcnica divide y
vencers*//*
Void rota90GradosDivide (int i, int j, int i1, int j1, BMP *
imagen, int n) {
If (n > 1) {
rota90GradosDivide (i, j, (n / 2) + i, (n / 2) + j,
imagen, n / 2);
rota90GradosDivide (i + (n / 2), j, n + i, (n / 2) + j,
imagen, n / 2);
rota90GradosDivide (i + (n / 2), j + (n / 2), n + i, n +
j, imagen, n / 2);
rota90GradosDivide (i, j + (n / 2), (n / 2) + i, n + j,
imagen, n / 2);
}
Traslacion (i, j, i1, j1, imagen, n / 2);
}
4.3 Algoritmo Divide y vencers de rotacin.

La idea bsica consiste en dividir la imagen de entrada en 4 subimagenes, y luego

se realiza una traslacin de cada subimagen para obtener la resultante, el
Algoritmo de traslacin consistir en iterar para todos los puntos de la subimagen
superior izquierda
*//* Funcin encargada de rotar una imagen la cantidad de grados
especificada mediante el uso de un algoritmo con la tcnica divide y
vencers y adicional se utiliza el mtodo thread para acelerar su ejecucin*//*

Void rota90GradosDivideThreads (int i, int j, int i1, int j1, BMP

* imagen, int n) {

If (n > 1) {
Int matrices = 4;
// Comenzamos la
// reparticion de los subarreglos
pthread_t *thread;
Thread = malloc (matrices*sizeof (pthread_t));
// Creamos los auxiliares
BMPAux * c11 = (BMPAux *) malloc (sizeof (BMPAux));
(*c11).i = i;
(*c11).j = j;
(*c11).i1 = (n / 2) + i;
(*c11).j1 = (n / 2) + j;
(*c11).n = (n / 2);
(*c11).imagen = imagen;

BMPAux * c12 = (BMPAux *) malloc (sizeof(BMPAux));

(*c12).i = i + (n / 2);
(*c12).j = j;
(*c12).i1 = n + i;
(*c12).j1 = (n / 2) + j;
(*c12).n = (n / 2);
(*c12).imagen = imagen;

BMPAux * c21 = (BMPAux *) malloc (sizeof(BMPAux));

(*c21).i = i + (n / 2);
(*c21).j = j + (n / 2);
(*c21).i1 = n + i;
(*c21).j1 = n + j;
(*c21).n = (n / 2);
(*c21).imagen = imagen;

BMPAux * c22 = (BMPAux *) malloc (sizeof(BMPAux));

(*c22).i = i;
(*c22).j = j + (n / 2);
(*c22).i1 = (n / 2) + i;
(*c22).j1 = n + j;
(*c22).n = (n / 2);
(*c22).imagen = imagen;

// Creamos los hilos

If (pthread_create (&thread[0], NULL, ejecutaRotacion, (void
*)c11) != 0)
{
Perror ("El thread no

pudo crearse [Arbol]\n");

Exit (-1);
}
If (pthread_create (&thread [1], NULL, ejecutaRotacion, (void
*) c12)! = 0)
{
Perror ("El thread no

pudo crearse [Arbol]\n");

Exit (-1);
}
If (pthread_create (&thread [2], NULL, ejecutaRotacion, (void
*)c21) != 0)
{
Perror ("El thread no

pudo crearse [Arbol]\n");

Exit (-1);
}
If (pthread_create (&thread [3], NULL, ejecutaRotacion, (void
*) c22)! = 0)
{
Perror ("El thread no

pudo crearse [Arbol]\n");

Exit (-1);
}
// Esperamos a los hilos
Int i;
For (i=0; i<matrices; i++) pthread_join (thread[i], NULL);
Free (thread);

}
Traslacion (i, j, i1, j1, imagen, n / 2);
}
Void Traslacion (int i, int j, int i1, int j1, BMP * imagen, int
n) {
If (i < i1 - n) {
RotacionBaseM (i, j, i1, j1, imagen->pixelB, n);

RotacionBaseM (i, j, i1, j1, imagen->pixelR, n);

RotacionBaseM (i, j, i1, j1, imagen->pixelG, n);
Traslacion (i + 1, j, i1, j1, imagen, n);
}
}

Void traslacionM (int i, int j, int i1, int j1, unsigned char **
matriz, int n) {
If (i < i1 - n) {
RotacionBaseM (i, j, i1, j1, matriz, n);
TraslacionM (i + 1, j, i1, j1, matriz, n);
}
}

5. Actividades y Pruebas
5.10 La implementacin con n threads reduce el tiempo en 1/n vs. El algoritmo
DyV? Porque sucede esto?
El algoritmo reduce el tiempo de ejecucin en 1/n sobre el algoritmo de divide y
vencers ya que este mtodo en java nos permite ejecutar varios procesos a la
vez, es decir de forma recurrente y por tanto nos permite realizar programas en
menos tiempo y ms eficientes. Por lo cual cuando lo utilizamos no estamos en
matriz auxiliar y estamos ejecutando el cdigo de manera paralela.

11. Preguntas:
1. Cul de los tres algoritmos es ms fcil de implementar?
El algoritmo ms fcil de implementar es el Algoritmo clsico de rotacin.
2. Cul de los tres algoritmos es ms difcil de implementar?
El algoritmo ms difcil de implementar es el de divide y vencers utilizando
theards.
3. Cul de los algoritmos tiene menor complejidad temporal?
El algoritmo con menor complejidad es el de el de divide y vencers utilizando
theards.
4. Cul algoritmo es ms rpido y porque?
El algoritmo de divide y vencers con threads reduce el tiempo de ejecucin en 1/n
sobre el algoritmo de divide y vencers ya que este mtodo en java nos permite
ejecutar varios procesos a la vez, es decir de forma recurrente y por tanto nos
permite realizar programas en menos tiempo y ms eficientes. Por lo cual cuando
lo utilizamos no estamos en matriz auxiliar y estamos ejecutando el cdigo de
manera paralela.
5. El comportamiento experimental de los algoritmos era el esperado
porque?

Los algoritmos como se valid en el anlisis realizado se comportaron segn el

anlisis previo generado, ya que desde all se verifico que el algoritmo con menor
complejidad temporal es el algoritmo de divide y vencers con theards, y el de
mayor complejidad temporal es el algoritmo clsico de rotacin, donde se valida
que es el ms fcil de implementar por la sencillez del cdigo.
6. Sus resultados experimentales difieren mucho de los anlisis de otros
compaeros? a qu se debe?
Los resultados experimentales no difieren mucho de los anlisis realizados por
otros compaeros, ya que mediante la complejidad del algoritmo se puede validar
si este cuando se implementa en complejidad temporal cual va a ser el ms
demorado o el ms rpido, tambin por la validacin del cdigo se verifica el ms
complejo y el menos complejo; por ende la informacin no difiere mucho.

7. Existi un entorno controlado para realizar las pruebas? Cul fue?

No existi un entorno controlado.
8. Qu recomendaciones daran a nuevos equipos para realizar esta
prctica?
Cuando se va a realizar cualquier prctica es necesario conocer los fundamentos
de implementacin de un algoritmo de rotacin, adems de conocer el
funcionamiento de cada uno de los algoritmos que se implementan en el cdigo.

6. Problemas De implementacin
Cuando se implementa el cdigo existen problemas en las libreras de java, ya que
no reconoce en el cdigo unas libreras se valida que si se encuentran pero
eclipse el compilador asume que no estn por lo cual no se puede ejecutar el
cdigo en ese equipo y es necesario se ejecute en otro pc donde fue generado, no
se puede resolver el inconveniente; adicional se presentan inconvenientes con el
ingreso de la imagen al programa para que ejecute los mtodos, se puede
solucionar inconveniente.

7. Plataforma Experimental

Sistema operativo: Windows seven ultmate

Procesador: AMD turin
Memoria RAM: 3GB instalada
Disco Duro: 500 GB
Entorno: Eclipse-Netbeans Versin 8.0

Conclusiones
1. Cuando se ejecuta un algoritmo se valida a priori la eficiencia de estos, en el
caso de algoritmos de rotacin se valida la complejidad espacial antes de ejecutar
el programa, brindando as informacin vital para la realizacin de cualquier
programa ejecutando este cdigo.
2. A travs de la prctica se permite evidenciar que el algoritmo de divide y
vencers implementado con theards nos permite ejecutar el cdigo de manera
ms rpida y eficiente.

Bibliografa

1. Universidad del cauca

Anlisis de rendimiento de un algoritmo
En:http://sedici.unlp.edu.ar/bitstream/handle/10915/20756/Documento_
completo__.pdf?sequence=1

2 .La eficiencia de los algoritmos

Multitarea e Hilos en Java
En: http://jarroba.com/multitarea-e-hilos-en-java-con-ejemplos-threadrunnable/

3. Algoritmo de Rotacion
Anlisis de Algoritmos de bsqueda
En: http://www.mediavida.com/foro/dev/ayuda-algoritmo-rotacioncontinua-453406