De nuevo por aquí... con noticias frescas :D
Estoy haciendo un ejercicio para la uni que consiste en desarrollar el algoritmo ELGAMAL en Java, así que... ya sabéis que lo compartiré con vosotros (una vez lo tenga, y una vez acabe esta saga)
Hoy, no obstante, nos toca hablar un poquillo de algunos conceptos básicos.
Vamos allá!
En esta entrada nos toca hablar de los conceptos básicos del algoritmo. Tenemos un concepto que está "fuera" del algoritmo (la conversión entre bases), y luego bastantes funciones lógicas que me gustaría revisar con vosotros.
Conversión entre bases
El uso del algoritmo se basa en una entrada binaria, pero vamos a ser civilizados y permitir la entrada en ASCII (el texto que todos sabemos interpretar), ¿no?
Ya que estamos trabajando en COBOL, vamos a trabajar la conversión entre bases directamente desde COBOL.
Existe una función intrínseca (ORD) que da el valor decimal del caracter que se le pasa, pero vamos a jugar con otro concepto más interesante.
Get Raw
000105 TEXTO-RAW PIC X(256) VALUE SPACES.
000205 TEXTO REDEFINES TEXTO-RAW
0003 OCCURS 256 PIC X(01).
0004
000505 CHAR-BLOCK
0006 10 FILLER PIC X(01).
0007 10 CHAR PIC X(01).
000805 HEX-CHAR REDEFINES CHAR-BLOCK
0009 PIC 9(04) BINARY.
001005 NUM-CHAR PIC 9(03).
0011
0012PERFORM VARYING INDICE FROM 1 BY 1 UNTIL
0013INDICE > LONGITUD
0014 MOVE TEXTO(INDICE) TO CHAR
0015 MOVE HEX-CHAR TO NUM-CHAR
0016
0017 SUBTRACT 192 FROM NUM-CHAR
0019END-PERFORM
¿Qué está pasando aquí?
Tenemos el texto en TEXTO-RAW, y lo redefinimos como un array de 256 posiciones.
Por cada posición del texto, lo movemos a CHAR, pero ¡ojo!, CHAR es en realidad un bloque de 2 bytes. Este bloque de 2 bytes está redefinido como un bloque de 4 numeros binarios, es decir, 2 bytes (ya que COBOL trabaja en BCD y un número definido como BINARY ocupa la mitad)
Finalmente, movemos a un numérico de 3, ya que el ASCII máximo es 256 (FF).
El quitarle 192 es debido a que COBOL trabaja con EDIBDC y lo más común es ASCII (con esta resta se cuadran las COLLATION).
Con esto, tenemos nuestro carácter ASCII en un decimal de 3 posiciones, pero buscamos un binario!
Así que el siguiente paso es pasar este decimal a hexadecimal, y finalmente a binario.
Para pasar a HEX, creamos una tabla de 256 registros que contenga una base de conversión, y, usando el valor decimal como índice, obtenemos la clave en HEX (es un poco chapuza, pero es lo más rápido).
Finalmente, pasamos a binario:
Get Raw
0001DIVIDE 16 INTO NUM-CHAR
0002 GIVING HEX-VAL-1
0003 REMAINDER HEX-VAL-2
Esto nos dejará en HEX-VAL-1 el correspondiente primer carácter HEX, y en HEX-VAL-2 el segundo.
Usamos otra tabla de conversión para sacar el valor binario y ya lo tenemos.
Y con esto terminamos el cambio de base (tranquilos, más adelante se verá cómo es todo en conjunto.
Funciones y operaciones lógicas
Las funciones que vamos a ver serán:
AND, OR, NOT, XOR, S^L / S^R, Suma binaria
Antes de empezar, un pequeño concepto... el contador de acarreo. Este contador es un flag que se activa en nuestro microprocesador cuando "nos llevamos una", y tiene importancia para estas operaciones.
Estas operaciones (a excepción de las dos últimas y el NOT) se realizan sobre pares de bits, así que tenemos cuatro posibles entradas:
- 0 + 0 = 0, acc = 0
- 0 + 1 = 1, acc = 0
- 1 + 0 = 1, acc = 0
- 1 + 1 = 1, acc = 1
Entonces, la función AND devuelve un resultado positivo siempre que el acc es 1; la función OR devuelve positivo cuando el resultado es 1, y XOR es positivo si el resultado es 1 y no hay acc (o bien si ((a OR b) AND (NOT acc))
La función NOT es la más fácil, devuelve 0 si entra 1, y 1 si entra 0.
Las funciones S^L y S^R, también conocidas como "Left Shift (movimiento izquierda)" y "Right Shift (movimiento derecha)" se basa en desplazar un bloque de bits, de la siguiente manera:
S^L1(00110010) = 01100100
En un S^Ln, se mueven los "n" bits de la izquierda hacia el final; en un S^Rn se mueven los de la derecha.
Finalmente, la suma binaria es casi como una suma convencional, pero siempre dentro del módulo del binario máximo dentro del rango.
¿LO QUÉ?
Un ejemplo será más claro. Imaginemos que jugamos con registros de 4 bits
0101 y 1100
Su suma sería (juntando por colores, de derecha a izquierda):
1 + 0 = 1
0 + 0 = 0
1 + 1 = 1 acc 1
0 + 1 = 1
1 + 1 (acc) = 1 acc 1
11101
En este caso, nos estamos saliendo del módulo del mayor binario máximo (1111), así que se tiene que aplicar el módulo
¿Cómo?
Mágicamente (broma), basta con no quedarnos con el acc, es decir... 1101. Más adelante os enseñaré por qué pasa esto!
En fin, esta entrada se queda un poco larga, así que me callo ya...
¡hasta la próxima!
No hay comentarios:
Publicar un comentario