Computación I

Miércoles 26 de Mayo

Definición de funciones

Objetivos: Mostrar cómo se puede extender el lenguaje Java con nuevas funciones.

Temas:

Definición de funciones.
Semántica de invocación de una función.

Motivación

Escribir un programa que determine la cantidad de combinaciones que se pueden realizar tomando k elementos distintos de un grupo de n elementos. El número de combinaciones está dado por la siguiente fórmula:

    | n |      n!
    |   | = ---------
    | k |   k! (n-k)!

Solución:

Calcular n!
Calcular k!
Calcular (n-k)!
Entregar resultado final

Calcular el factorial de un número es simple, pero escribir 3 veces el mismo código para calcular el factorial de distintos números es incómodo. Por otra parte, se triplica la probabilidad de cometer algún error.

Definición de funciones

En clases anteriores vimos que Java posee funciones predefinidas para calcular el seno, la raíz cuadrada, el logaritmo y otras funciones científicas. El problema es que es imposible que un lenguaje de programación suministre todas las funciones que un programador podría necesitar.

Por esta razón, prácticamente todos los lenguajes incorporan algún mecanismo para que los programadores puedan definir sus propias funciones cuando no existe la función predefinida apropiada. Para definir una nueva función, el programador debe escribir el código (programa) que calcula esa función.

Por ejemplo, el siguiente programa calcula el número de combinaciones:

    class Combinaciones extends Program {
      void run() {
        print("Ingrese k ? ");
        int k= readInt();
        print("Ingrese n ? ");
        int n= readInt();
        int combinaciones= fact(n)/(fact(k)*fact(n-k));
        println("Combinaciones= "+combinaciones);
      }
      // Definición de la funcion fact
      int fact(int x) {
        // fact recibe un argumento entero y entrega un resultado entero.
        // El siguiente código calcula el factorial de x
        int prod= 1;
        int i= 1;
        while (i<=x) {
          prod= prod*i;
          i= i+1;
        }
        // Indica qué valor entrega esta función.
        return prod;
      }
    }

El siguiente patrón de programación se usa para definir varias funciones que pueden ser usadas en un programa:

    class ... extends Program {
      void run() {
        ...
      }
      tipo nombre-función ( parámetros ) {
        ... programa que calcula esta función ...
        return expresión;
      }
      ... Más funciones ...
    }

Explicación:

tipo: es el tipo del valor entregado por la función. Por ejemplo, el factorial entrega un número entero. Otra función podría entregar un número real o un string.
nombre-función: es un identificador que elige el programador para nombrar su función.
parámetros: son los parámetros de la función, es decir de qué depende el cálculo de la función. Pueden indicarse 0, 1, 2 o todos los parámetros que se necesiten.
return expresión: señala cual es la expresión que representa el valor entregado por la función.
Una función que no retorna ningún valor se define indicando que entrega un valor de tipo void. En este caso se prefiere hablar de procedimiento.
void run() { ... }: es un procedimiento que no recibe argumentos y que es invocado por java Run ...

Invocación de una función

La forma general de una invocación de una función es:

    nombre-función ( argumentos )

en donde argumentos son 0, 1, 2 o más expresiones separadas por coma. Por ejemplo:

    fact(n-k)

La semántica de una invocación de función es la siguiente:

Se evalúan las expresiones, obteniendo así valores que corresponden a los argumentos de la función. Por ejemplo, n-k puede dar como resultado 5.
Se asignan los argumentos a las variables que representan los parámetros en la difinición de la función. Por ejemplo, en la función fact:
```
    x= 5;
```
Se ejecutan las instrucciones señaladas en la definición de la función. Es decir:
```
        int prod= 1;
        int i= 1;
        while (i<=x) {
          prod= prod*i;
          i= i+1;
        }
```
Después de ejecutar este código, la variable prod almacena el valor 120 (5!) e i el valor 6.
Se evalúa la expresión que acompaña return.
```
        return prod;
```
Como esta expresión es simplemente la variable prod, el resultado de la evaluación es 120. Este valor es el resultado de la invocación de fact y substituye toda la expresión de invocación:
```
    fact(n-k)
```

Esto se puede apreciar en la siguiente figura que muestra las 3 invocaciones de la función fact a partir de run() cuando n es 7 y k es 2:

En cada invocación el argumento es distinto y por tanto el valor entregado por la función.

Ejemplo:

Definir la función repite(s,n) que entrega el string s concatenado con sí mismo n veces. Es decir, se desea que repite("hola",3) entregue (o retorne) como resultado el string "holaholahola".

    class Triangulo extends Program {
      String repite(String s, int n) {
        String r= "";
        int i= 1;
        while (i<=n) {
          r= r+s;
          i= i+1;
        }
        return r;
      }
      void run() {
        int i=1;
        while (i<=8) {
          println(repite("*",i));
          i= i+1;
        }
      }
    }

El programa anterior produce la siguiente salida:

    *
    **
    ***
    ****
    *****
    ******
    *******
    ********

Tarea:

Defina la función esPrimo(n) que entrega verdadero cuando n es un número primo y falso en caso contrario. Utilice cualquier método para determinar si n es primo. Ejemplos:

esPrimo(2) true
esPrimo(3) true
esPrimo(25) false
esPrimo(31) true
esPrimo(9) false
Escriba un programa que use la función esPrimo para mostrar los números primos entre 200 y 300.

`esPrimo(2)`	`true`
`esPrimo(3)`	`true`
`esPrimo(25)`	`false`
`esPrimo(31)`	`true`
`esPrimo(9)`	`false`