PrInf17: Algunos ejemplos con funciones

Práctica de Informática
Algunos ejemplos con funciones
Práctica anterior	Siguiente práctica
Este artículo es un guión de prácticas de Informática

Este artículo está en versión beta. El autor de este artículo no lo ha terminado todavía, por favor no lo edites hasta que elimine este mensaje.

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);

Para encontrar la distancia mínima, habrá que recorrer todos los vértices, comparando la distancia con los valores calculados anteriormente, para buscar el valor más pequeño. Sin embargo, si comparamos con los vértices anteriores, ¿con cuál comparamos el primer vértice que recorramos? Para resolver este problema, supondremos que el primer vértice es el más cercano, y si posteriormente encontramos otro más cercano, actualizaremos el vértice que devuelve la función:

  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].

Ahora vamos a programar la salida de datos. La salida de datos tiene dos partes: un mensaje de texto y un gráfico mostrando la situación. En cuanto al mensaje de texto, es similar a otros programas anteriores:

% 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);

El programa completo, que guardamos en un fichero de nombre buscaVertice.m quedaría como sigue:

%% 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;