Diferencia entre revisiones de «PrInf17: Algunos ejemplos con funciones»

Revisión actual del 14:25 9 ago 2013

En esta práctica vamos a escribir dos funciones y usarlas dentro de un programa, para ilustrar la metodología de diseño top-down. Tenemos que realizar un programa que, dado un polígono, pregunte un punto al usuario, y encuentre el vértice del polígono más próximo al punto introducido por el usuario. El programa debe dibujar el polígono, el punto introducido por el usuario y el vértice encontrado. Como es un programa algo complejo, vamos a escribir dos funciones, que usaremos desde el programa principal.

1 Requisitos previos

Antes de realizar esta práctica, es imprescindible haber realizado antes la siguiente práctica:

• PrInf16: Introducción a las funciones

Además, una de las funciones que vamos a programar tiene varios argumentos de salida, por lo que puede ser útil visualizar este vídeo (aunque en nuestro caso, los argumentos de salida no son opcionales):

• Prog24: Funciones con varios argumentos de salida

2 Vídeos posteriores

En esta práctica escribimos la documentación de una de las funciones. En el siguiente vídeo se explica cómo documentar funciones:

• Prog25: Cómo documentar funciones

3 Contenido de la práctica

3.1 Función para calcular la distancia

El programa necesita encontrar el vértice más cercano, dado un punto que introduce el usuario. El vértice más cercano será el que tiene la menor distancia al punto en cuestión. No existe ninguna función en Octave UPM para calcular la distancia entre dos puntos, así que tendremos que escribirla nosotros. Sabemos que la distancia entre dos puntos [math](x_0,y_0)[/math] y [math](x_1, y_1)[/math] viene dada por [math]\displaystyle d = \sqrt{(x_1-x_0)^2+(y_1-y_0)^2}[/math]

Tarea:

Crea una función de nombre distancia, que devuelva el valor de d dados cuatro argumentos de entrada: x0, y0, x1 e y1.

3.2 Función para buscar el vértice más cercano

Una vez que tenemos una función que calcula la distancia entre dos puntos en el plano, vamos a empezar a programar la función que encuentra el vértice más cercano de un polígono. Esta función acepta como argumentos de entrada las coordenadas [math](x_p,y_p)[/math] del punto, y dos vectores x e y, que contienen los vértices del polígono. Estos vectores contienen los vértices en el mismo formato que usan las funciones fill e inpolygon. La función devolverá las coordenadas [math](x_v, y_v)[/math] del vértice más cercano al punto.

Por tanto, la cabecera de la función será:

function [xv, yv] = encuentraVerticeMasCercano(xp, yp, x, y)

Tendremos que guardar esta función en un fichero de nombre encuentraVerticeMasCercano.m.

El algoritmo para buscar el vértice más cercano consistirá en ir comprobando la distancia del punto a cada uno de los vértices, y buscar el valor más pequeño de la distancia. Vamos a ir viéndolo paso a paso. Lo primero que necesitamos conocer es el número de vértices del polígono, ya que nuestra función debería funcionar con cualquier tipo de polígono. Como los vectores x e y contienen las coordenadas de los vértices, el número de vértices será igual al número de elementos en cualquiera de esos dos vectores:

  nVertices = length(x);

  xv = x(1);
  yv = y(1);
  d = distancia(xp, yp, xv, yv);

Hemos usado la función distancia, que hemos programado anteriormente.

Ahora será necesario recorrer todos los vértices restantes, para ver si hay algún vértice más cercano al punto [math](x_p, y_p)[/math]. Para realizar esta tarea, usaremos un bucle for. Ignoraremos el primer vértice, puesto que ya hemos calculado su distancia:

  for k=2:nVertices
    x1 = x(k);
    y1 = y(k);
    dNueva = distancia(xp, yp, x1, y1);
    if dNueva < d
      d = dNueva;
      xv = x1;
      yv = y1;
    end
  end

Con esto, hemos terminado la función. El código completo, incluyendo la documentación de la función, quedaría así:

function [xv, yv] = encuentraVerticeMasCercano(xp, yp, x, y)
% Función que encuentra el vértice más cercano a un punto dado
%
%  [xv, yv] = encuentraVerticeMasCercano(xp, yp, x, y)
%
%   xp: Coordenada x del punto
%   yp: Coordenada y del punto
%   x:  Vector con las coordenadas x de los vértices del polígono
%   y:  Vector con las coordenadas y de los vértices del polígono
%
%   xv: Coordenada x del vértice más cercano
%   yv: Coordenada y del vértice más cercano

  nVertices = length(x);
  xv = x(1);
  yv = y(1);
  d = distancia(xp, yp, xv, yv);

  for k=2:nVertices
    x1 = x(k);
    y1 = y(k);
    dNueva = distancia(xp, yp, x1, y1);
    if dNueva < d
      d = dNueva;
      xv = x1;
      yv = y1;
    end
  end
end

Tarea:

Copia el código anterior y guárdalo en el fichero correspondiente. Comprueba cuál es el resultado de ejecutar help encuentraVerticeMasCercano. ¿Cuál es el texto que se muestra?

3.3 Programa principal de la práctica

El programa principal de la práctica debe preguntar al usuario el punto, encontrar el vértice más cercano a un polígono dado, y mostrar por pantalla un mensaje informativo, además de un gráfico que ilustre el polígono, el punto y el vértice. Es decir, las partes del programa serán:

• Entrada de datos: el punto que se pregunta al usuario
• Algoritmo: encontrar el vértice más cercano al punto
• Salida de datos: mostrar un mensaje con el vértice encontrado, y mostrar gráficamente el resultado

En este programa, la entrada de datos es la misma que la de la práctica 15:

%% Encuentra el vertice más cercano y dibuja todo
%% Versión: 0.1
%% Fecha: Agosto de 2013 
% Entrada de datos
p = input('Introduce el punto de la forma [x y]: ');
% Vértices del polígono
x = [0 0.5 1];
y = [0 1 0];

En cuanto al algoritmo, ahora vamos a ver por qué la metodología top-down facilita el diseño de programas:

% Algoritmo
xp = p(1);
yp = p(2);
% Coordenadas del vértice más cercano
[xc, yc] = encuentraVerticeMasCercano(xp, yp, x, y);

Gracias a que podemos reutilizar las funciones programadas anteriormente, el algoritmo de nuestro programa principal se reduce a tres líneas de código, que son muy sencillas de entender. En este caso, el vértice encontrado será [math](x_c, y_c)[/math].

% Salida de datos
fprintf('El vértice más cercano a (%.3f, %.3f) es (%.3f, %.3f)\n', xp, yp, xc, yc);

Para dibujar la situación, primero dibujaremos el polígono, luego el punto introducido por el usuario, y luego resaltaremos el vértice encontrado en color rojo:

fill(x, y, 'g');
hold on;
plot(xp,yp,'x','LineWidth',8);
plot(xc,yc,'or','LineWidth,8);

Resultado de ejecutar el programa con el punto (-0.2, 0.3)

Por ejemplo, si ejecutamos el programa y probamos el punto (-0.2, 0.3), el resultado que se mostraría sería la figura de la derecha.

Tarea:

Prueba a ejecutar el programa usando un punto interior al polígono. ¿Funciona el programa correctamente?

%% Encuentra el vertice más cercano y dibuja todo
%% Versión: 0.1
%% Fecha: Agosto de 2013

% Entrada de datos
p = input('Introduce el punto de la forma [x y]: ');
% Vértices del polígono
x = [0 0.5 1];
y = [0 1 0];

% Algoritmo
xp = p(1);
yp = p(2);
% Coordenadas del vértice más cercano
[xc, yc] = encuentraVerticeMasCercano(xp, yp, x, y);

% Salida de datos
fprintf('El vértice más cercano a (%.3f, %.3f) es (%.3f, %.3f)\n', xp, yp, xc, yc);
clf;
fill(x, y, 'g');
hold on;
plot(xp,yp,'x','LineWidth',8);
plot(xc,yc,'or','LineWidth',8);
hold off;

Tarea:

Crea un programa similar al anterior, pero que en vez de encontrar el vértice más cercano, encuentre el vértice más lejano. Tendrás que escribir una función muy parecida a encuentraVerticeMasCercano, y modificar el programa para que use esta función.

4 Ejercicio post-práctica

Una vez que hayas creado el programa que buscar el vértice más lejano, modifica el programa para que, además del punto que introduce el usuario, dibuje tanto el vértice más lejano como el más cercano. El más lejano se dibujará con un círculo en color violeta (magenta en inglés). El más cercano se dibujará con un círculo rojo.

Cambia el polígono para que sea un pentágono, y ejecuta el programa para comprobar que funciona correctamente.