La tercera estructura que veremos es la estructura "for-loop".
Los "loops" se asocian a estructuras iterativas.
Vamos a verlo en un ejemplo, supongamos que queremos sumar dos números x e y.
Vamos a representar los números x e y por vectores, en este caso x será un
vector, si tiene 4 dígitos decimales, de 4 posiciones
x3, x2, x1, x0. El número
"y" también tendrá 4 componentes, y3, ...
hasta y0, y el resultado también lo vamos a representar por
un vector, en este caso de 5 componentes, z4 ...
cuatro hasta z0. Este algoritmo
suma los números siguiendo el método manual.
Recordemos, 942 más 328, lo que hacíamos es ir sumando
columna a columna, 9 más 2 da 10, ponemos aquí el 0 y generamos un
acarreo igual a 1. Para cada pareja generamos dos números,
lo que es la suma parcial y el acarreo a la etapa siguiente.
Bien, pues este algoritmo manual que hemos repetido más de una vez,
es el que se implementa en este algoritmo.
Fijaros, para todos los valores de "i" desde 0
hasta 3, es decir, va recorriendo los vectores x e y, va
generándo s(i), que sería este resultado como la suma de
la x más la y más el posible acarreo de la etapa anterior.
Si el resultado es mayor que 9 como sería en este caso,
le resta 10 y lo coloca en z. Aquí el resultado
era 10, le restamos 10, da 0, colocamos aquí el 0
y genera un acarreo igual a 1 que pasa a la etapa siguiente.
Y en caso contrario, si el resultado es menor que 9 pues
simplemente pone este resultado en z y el acarreo siguiente es 0.
Vamos a implementar este algoritmo, el "loop", en dos pasos.
En primer lugar, identificamos lo que llamamos el "cuerpo del loop", las
operaciones básicas, y construimos un circuito
básico que va a ejecutar estas operaciones.
En concreto necesitamos un módulo que sea capaz de admitir en cada momento
x(i), y(i), y el acarreo(i),
y que a partir de ahí
calcule z(i), y el acarreo
a la etapa siguiente.
Bien, este módulo realmente lo hemos utilizado bastante a lo largo del curso,
o sea que no hace falta que expliquemos demasiadas cosas más.
pero lo importante es esto: el primer paso es
construir un módulo que ejecute el cuerpo del loop.
Y lo que son las 4 iteraciones del loop, las vamos a
implementar conectando en serie 4 módulos de estos que acabamos de definir,
de manera que cada módulo ejecuta una de las iteraciones del loop.
Este primer módulo ejecuta la iteración i=0,
En la iteración i=0, se hace la suma de x0 con y0 con
el acarreo0; la suma de x(0) con y(0) con y cero
con el acarreo inicial, que en este caso es 0,
y se calcula z(i) y el acarreo siguiente.
Se calcula z(i) que, como la i es 0 es z0, y el acarreo siguiente.
A continuación la i pasa a valer 1.
El segundo módulo ejecuta la iteración correspondiente a i=1 sumando
x1 con y1 con c1,
y calculando z1 y el acarreo(2).
Y así tantas veces como fuese necesario.
En este caso son 4 iteraciones, 4 módulos. Si
ahora la hacemos de n iteraciones necesitaríamos n módulos.
Finalmente lo que decimos aquí es que el último
acarreo se corresponde con el valor más significativo,
con el dígito más significativo de la suma.
Resumiendo, ¿cómo implementamos una estructura loop?:
Construyendo un módulo básico para el cuerpo
del loop y concatenando tantas veces este módulo
básico o tantas copias de este módulo
básico como número de iteraciones realice el loop.
Un par de comentarios acerca de la estructura loop:
El primero es que más adelante veremos otras implementaciones cuando hayamos
visto los circuitos secuenciales. El segundo comentario, más importante, es
que desgraciadamente no todos los loops pueden implementarse de esta manera.
Un ejemplo es la estructura "While condition loop operation"; mientras se
cumpla esta condición, ejecuta una y otra vez
una o varias o un conjunto de operaciones.
La estructura loop, hemos visto que se convierte en tantos módulos
concatenados como el número de veces que se ejecuta el loop.
Si el número de veces en que se cumple la condición es,
o bien desconocido, como es este caso, o bien el número de veces
en que se cumple la condición es muy grande, el loop no
se puede implementar en la práctica tal como hemos visto, y en esos casos
se hace necesario utilizar módulos secuenciales, que estudiaremos más adelante.
La última estructura que vamos a ver son las llamadas a procedimientos.
Las llamadas a procedimientos se asocian a descripciones jerárquicas.
Aquí tenemos un ejemplo
de una pequeña porción de código que realiza este cálculo.
Lo de menos es como realiza el cálculo, es
decir, no vamos a entrar en el algoritmo en
sí, pero lo importante es que aquí dentro hay
una llamada a un procedimiento MAC que realiza esta operación.