Módulos. Funciones: Primitivas y definidas por el usuario.

Módulos. Funciones: Primitivas y definidas por el usuario

Módulos: Funciones.

En la programación modular, los programas se dividen en módulos. Un módulo es una unidad lógica de código e independiente de otros módulos, en el cual es posible analizar, codificar y probar por separado. Cada programa tiene un módulo o bloque principal que actúa como coordinador o controlador, el cual deriva el control a otros módulos. A su vez un módulo –sub-módulo- puede ceder el control temporalmente a otro módulo, el cual una vez finalizado deberá devolver el control al módulo que lo invocó. Ya que, los módulos son independientes unos de otros, una consecuencia de esto sería poder dividir el trabajo a distintos programadores a efectos de acelerar los tiempos. Además a un módulo se lo podrá modificar, sin alterar a otros módulos. Existen dos formatos de módulos, a saber:

• Funciones
• Procedimientos

Funciones:

Una función es un módulo que presenta las siguientes partes:

Una cabecera

Un cuerpo

La cabecera presenta las siguientes partes:

El nombre de la función

Una lista de parámetros, que podría estar vacía

El tipo de valor -simple- que devolverá la función

El cuerpo de la función es un bloque, dentro del cual se escriben las sentencias. Deberá existir alguna sentencia que asigne al nombre de la función el resultado de una expresión que debe ser de igual tipo que el valor devuelto por la función. Al finalizar la función, el último valor asignado, será el valor que retorne. Una función la podemos ver como una caja negra –no nos interesa saber su interior- o como una caja transparente –si nos interesa saber su interior-. Para que una función pueda ser ejecutada, se deberá llamarla o invocarla. Generalmente los parámetros formales –aquellos que se definen en la cabecera de la función, son pasados por valor, en estos casos, se trabaja con una copia del valor pasado desde la invocación, cualquier modificación que se realice en los parámetros formales, no altera a los parámetros actuales –los indicados en el momento de la invocación-. Una función se la invoca en forma indirecta, es decir, como perteneciente a una sentencia, como p.e., la asignación interna, o como formando parte de una condición, etc..
Una función puede necesitar trabajar con variables internas a su ámbito, en estos casos esas variables definidas dentro de la función son denominadas variables locales. Fuera de la función en que han sido definidas no existen, salvo en los caos en que la función invoque a un módulo definido dentro de su ámbito, allí serán reconocidas. La comunicación entre el módulo que invocó a la función y la función invocada se establece por medio de los parámetros. Si bien una función puede devolver valores por medio de sus parámetros, por el momento no se emplearán.

Estructura de una función: -definición

Llamada o invocación a una función

Ejemplo:

Var <-- NomFunc(lst_par_actuales)

Observación: Los parámetros en la invocación también suelen llamarse argumentos. En estos casos los parámetros en la cabecera de los módulos se los puede indicar como parámetros a secas.

Funciones primitivas numéricas:

A continuación se verán las funciones numéricas predefinidas por el lenguaje Pascal, para nosotros serán cajas negras, debido a que solo sabremos el nombre de la función, los parámetros a pasar, de qué tipo han de ser c/u. de ellos y en que orden deben aparecer el tipo de valor retornado por la función y que tarea realiza la función, pero no sabremos nada acerca de cómo lo realiza.

Abs(x):tipo_x; Retorna el valor absoluto de x, en donde x es cualquier valor de tipo numérico. El valor absoluto de x es x, si x >= 0 o es, –x si x menor a 0, por lo tanto el valor retornado es siempre positivo.

Sqrt(x:real):real; Retorna la raíz cuadrada de x, en donde, x es >= 0, el tipo de resultado es real.

Sqr(x):tipo_x; Retorna el cuadrado de x, es decir, x * x. El tipo de resultado es del mismo tipo que el parámetro x.

Sin(x:real):real; Retorna el seno de x. X expresa un ángulo en radianes. Para convertir grados a radianes, si x está expresado en grados, utilizar:

radianes <-- x * PI / 180

Cos(x:real):real; Retorna el coseno de x. X expresa un ángulo en radianes. Para convertir grados a radianes, si x está expresado en grados, utilizar:

radianes <-- x * PI / 180

ArcTan(x:real):real; Retorna el arco tangente o tg-1 de x. El resultado es la medida del ángulo expresado en radianes. Para convertir de radianes a grados, utilizar:

grados <-- arctan(x) * 180 / PI

Ln(x:real):real; Retorna el logaritmo natural de x, con x > 0. Para obtener el logaritmo de otra base, utilizar:

log10 <-- ln(x) / ln(10);

log4 <-- ln(x) / ln(4)

es decir, se divide el ln(x) sobre el ln de la base a pasar.

Exp(x:real):real; Retorna el exponencial o antilogaritmo o ln-1 de x. Exp(x) = e**x. Exp(1) = e. Para convertir la base e a otra base, utilizar: expo ß exp(x * ln(b)), es decir, multiplicar el valor de x por el ln de la base b, a pasar, y a este resultado aplicar la función exponencial.

Int(x:real):real; Retorna la parte entera de x, es decir, x redondeado hacia cero; el resultado es de tipo real, con la parte decimal cero.

Trunc(x:real):longint; Retorna la parte entera de x, es decir, x redondeado hacia cero, pero a diferencia de int, el tipo de resultado es de tipo longint. Ocurrirá un error si el resultado no está dentro del intervalo de un longint.

Round(x:real):longint; Retorna la parte entera de x redondeado al entero más cercano, el tipo de resultado es de tipo longint. Ocurrirá un error si el resultado no está dentro del intervalo de un longint.
round(x) = trunc(x+0.5) si x >= 0 y
round(x) = trunc(x-0.5) si x menor a 0

round (3.29 = 3

round(5.7) = 6

round(-451.3) = -451

round(-2.7) = -3

Frac(x:real):real; Retorna la parte decimal o fraccionaria de x, esto es:

frac(x) = x – int(x). Frac(23.79) = 0.79. frac(-12.43) = -0.43.

Odd(x:longint):boolean; Retorna true si x es impar o false si x es par.

Pi:real; Retorna el número irracional π = 3.1415926535897932385

Random:real;

Random(x:longint):longint: Retorna un número al azar.
Random sin argumento genera un número al azar –en realidad pseudoaleatorio- en el intervalo semicerrado [0; 1).
Random con argumento genera un número al azar en el intervalo [0; x – 1].
Random(6) + 1, generará un valor en el intervalo [1; 6]
Random(b – a + 1) + a, con a <= b, generará un valor en el intervalo [a; b]

Randomize –Procedimiento-: Los valores generados por random son pseudoaleatorios, debido a que, en distintas ejecuciones se generarán las mismas secuencias de valores. Por esa razón si queremos generar valores aleatorios para que en distintas ejecuciones se generen distintas secuencias de valores, debemos utilizar randomize al comienzo del programa; esto prepara al algoritmo de generación de números aleatorios para que la semilla, -así se denomina al punto inicial para la generación de los valores aleatorios- quede preparada con un valor de arranque, que será distinto en cada nueva ejecución del programa.

Funciones definidas por el usuario

Como se vió en párrafos previos, una función está formada por una cabecera que contiene el nombre de la función, eventualmente una lista de parámetros y el tipo de valor devuelto y el cuerpo en donde se indican las acciones a realizar, en donde, al menos una de estas acciones se debe asignar al nombre de la función el resultado de una expresión del mismo tipo definido en la cabecera. Siguiendo estos pasos el usuario podrá definir sus propias funciones. A continuación se desarrollan algunas de estas funciones, de tratamiento numérico.

Aplicación:

Dados dos valores enteros a y b, encontrar la fracción irreducible de a / b.