TEMA 3: Sentencias 

        Las   sentencias   o   instrucciones   se   pueden   dividir
principalmente en tres grandes grupos:

- Sentencias Simples.
- Sentencias Compuestas.
- Sentencias de control del flujo del algoritmo.

        Las Sentencias Simples son del tipo de:

- Asignación de Variables y Constantes.
- Llamadas  a Procedimientos  y Funciones,  dentro de  estas últimas
englobamos  todas las  funciones y  procedimientos que  conforman la
librería general de sentencias que veremos posteriormente.

        Las Sentencias Compuestas:

- Son  aquellas  que  están   limitas  dentro  de  Procedimientos  o
Funciones.

        Las Sentencias de Control de Flujo:

- Sentencias Reiterativas: Mientras, Repetir, Para.
- Sentencias Condicionales: Si, Case... of

3.1 Aritméticas y varias funciones.

        Dentro de  la asignaciones de variables  juega un gran papel
los operadores y funciones matemáticas, tales como:

  +-------------+-----------------------------------------------+ 
  | +           | Suma                                          | 
  | -           | Resta                                         | 
  | *           | Producto                                      | 
  | /           | División (devuelve un valor real)             | 
  | div         | División (devuelve un valor entero)           | 
  | mod         | Cálculo del módulo aritmético.                | 
  | log         | Logaritmo en base 10                          | 
  | ln          | Logaritmo neperiano                           | 
  | exp         | Exponencial de un número                      | 
  | pow         | Potencia de un número                         | 
  | random      | Obtención de un número aleatorio              | 
  | abs         | Obtenemos el valor absoluto de un número      | 
  | sqr         | Obtención del cuadrado de un número           | 
  | sqrt        | Obtención de la raíz cuadrada                 | 
  | sin,cos,tan | Funciones trigonométricas                     | 
  | chr/toascii | Obtenemos un carácter a partir de un número   | 
  | ord         | Obtenemos el número correspondiente al código | 
  |             | ASCII                                         | 
  +-------------+-----------------------------------------------+ 

        Lógicamente, existen  más funciones aritméticas  que veremos
más adelante.

3.2 Sentencias de Control.

        Como  ya  dijimos  en  la   introducción  del  tema  3,  las
sentencias  de control  son  aquellas  que interrumpen  la ejecución
secuencial  de las  instrucciones  de  un algoritmo,  permitiendo la
generación de reiteraciones.

3.2.1 Condicionales (Si y Case).

        La función  SI, viene acompañada por  una serie de elementos
que son los operadores relacionales y operadores booleanos.

        Los operadores relacionales son los siguientes:

            +----+-----------------+ 
            | =  | Igual a         | 
            | <  | menor que       | 
            | >  | mayor que       | 
            | <= | menor o igual a | 
            | >= | mayor o igual a | 
            | <> | distinto de     | 
            +----+-----------------+ 

        Estos operadores nos van a servir generalmente para comparar
y comprobar  los valores  que toman   las variables  a lo  largo del
algoritmo,  y dependiendo  de los  resultados, realizar  una cosa  u
otra.

Operadores booleanos:

        Los  operadores booleanos  nos permiten  generar condiciones
compuestas. (AND, OR, XOR, NOT)

Ejemplo: ¨Es  la variable b  mayor que  12  y la variable  d igual a
cierto?

  Operador AND: (debe cumplirse las dos condiciones)

              +--------------------------+ 
              | true  AND true  -> true  | 
              | true  AND false -> false | 
              | false AND true  -> false | 
              | false AND false -> false | 
              +--------------------------+ 

  Operador OR: (debe cumplirse una de las  dos condiciones)

              +-------------------------+ 
              | true  OR true  -> true  | 
              | true  OR false -> true  | 
              | false OR true  -> true  | 
              | false OR false -> false | 
              +-------------------------+ 

  Operador XOR: (se cumple cuando las dos condiciones son distintas)

              +--------------------------+ 
              | true  XOR true  -> false | 
              | true  XOR false -> true  | 
              | false XOR true  -> true  | 
              | false XOR false -> false | 
              +--------------------------+ 

  Operador NOT: (niega el resultado de una condicion)

              +--------------------+ 
              | NOT true  -> false | 
              | NOT false -> true  | 
              +--------------------+ 

- La sentencias SI puede tener las siguientes estructuras:

              +-Si (condición) entonces
              |         ...
              +-Sino
              |         ...
              +-Finsi

        También puede aparecer en estructuras más complejas:

              +-Si (condición1) entonces
              | +-Si (condición2) entonces
              | |         ...
              | +-Finsi
              +-Sino
              |           ...
              | +-Si (condición3) entonces
              | |         ...
              | +-Sino
              | |         ...
              | +-Finsi
              +-Finsi

        A  este tipo  de estructuras  se le  denomina "anidamiento o
encadenamiento de sentencias SI".

- En cuanto  a la sentencia EN  CASO hay que decir,  que se trata de
una simplificación de sentencias SI anidadas. De esta forma, sea una
variable A tenemos la siguiente estructura de Si encadenados.

              +-Si (condición1) entonces
              |   acción1
              +-Sino Si (condición2) entonces
              |   acción2
              +-Sino Si (condición3) entonces
              |   acción3
              +-Sino
              |   acción4
              +-Finsi

        Con una estructura del tipo  EN CASO, tendríamos el problema
resuelto de la siguiente forma:

              +-En Caso de Variable
              |   condición1:     Acción1
              |   condición2:     Acción2
              |   condición3:     Acción3
              +-En Otro Caso
              |   Acción4
              +-Fincaso

3.2.2 Bucles Mientras, Repetir y Para.

        Las iteraciones son otro tipo  de sentencias de control. Las
que  veremos son  las siguientes:  Mientras, Repetir  y Para. Siendo
este último uno de los más usados.  La utilización de un bucle en un
programa permite la posibilidad de realizar iteraciones de secciones
de  código,  evitando  así  andar  con  condiciones,  etiquetas y la
sentencia GOTO. Esta última sentencia  GOTO, hay que evitarla en por
todos los  medios. Cualquier programa puede  ser realizado sin tener
que utilizar dicha sentencia; ya que su uso crea confusión a la hora
de seguir la ejecución secuencial de las sentencias de un algoritmo.

3.2.2.1 Bucle Mientras.

        El bucle Mientras se caracteriza por ser utilizado cuando no
conocemos el número de iteraciones con antelación.  Es por ello  que
nos  ayudamos de una comprobación o condición para la entrada/salida
del mismo antes de realizar la  ejecución de la sección del código a
repetir; esto último nos posibilita el caso de no  efectuar  ninguna
iteración (iteración=0).

+-Algoritmo Multiplicar (mult1,mult2,resul)
|   Parámetros reales mult1,mult2,resul
|
|   resul=0
| +-Mientras mult2>0 hacer
| |   resul=resul+mult1
| |   mult2=mult2-1
| +-Finmientras
+-Final

3.2.2.2 Bucle Repetir.

        El  bucle  Repetir  se  caracteriza  porque  al igual que el
anterior  no  sabemos el número de iteraciones que debemos realizar,
es por ello que se  apoya  en  condiciones para salir del mismo.  Al
contrario que el anterior, la comprobación va al final del bucle, de
esta forma, como mínimo siempre se produce una iteración.  Veamos el
algoritmo anterior utilizando el bucle repetir.

+-Algoritmo Multiplicar (mult1,mult2,resul)
|   Parámetros reales mult1,mult2,resul
|
|   resul=0
| +-Repetir
| |   resul=resul+mult1
| |   mult2=mult2-1
| +-Hasta que mult2<=0    (o también  hasta que not (mult2 >0) )
+-Final

        Una  forma  muy  sencilla  para  pasar  un  bucle Mientras a
Repetir, es hallando la condición opuesta, o bien poniendo un not en
la comprobación,  negando así la condición  del mientras. También se
puede  hallar teniendo  en cuenta  el significado  de los operadores
relacionales y booleanos.

      +----------+----+ 
      | NOT (<)  | >= | 
      | NOT (<=) | >  | 
      | NOT (>)  | <= | ¦  * Negación de lo operadores ralacionales.
      | NOT (>=) | <  | 
      | NOT (=)  | <> | 
      | NOT (<>) | =  | 
      +----------+----+ 

3.2.2.3 Bucle Para

        Lo  que caracteriza  al bucle   Para es  que ya  sabemos con
antelación  el número de iteraciones a realizar.  Es por ello que no
nos hace falta  una  comprobación  de  salida  y/o entrada.  También
existe la posibilidad de realizar 0 iteraciones, cuando la  variable
secundaria  es  menor  que  la primaria.  Otra característica, es la
posibilidad de realizar incrementos  de  n  en  n en el contador del
bucle.  Pasemos a ver el algoritmo anterior mediante un bucle Para.

+-Algoritmo Multiplicar (mult1,mult2,resul)
|   Parámetros reales mult1,mult2,resul
|   Variable Local loop
|   resul=0
| +-Para loop=1 hasta mult2 de incremento 1 hacer
| |   resul=resul+mult1
| |   mult2=mult2-1
| +-Finpara
+-Final

        En este caso, la variable primaria es "loop" y la secundaria
es "mult2".  Si esta última  toma un valor  inferior a la  primaria,
entonces  el bucle  no se   realiza. Obsérvese  que hemos  puesto el
incremento= 1, este es el valor que posee el bucle Para por defecto,
es  por ello  que cuando  el incremento  es de  1 en  1, no  se debe
especificar.