Aritmética en computadora

Objetivos Cómo ejecuta el hardware las operaciones básicas (suma, resta, división y multiplicación). Operaciones con números enteros. Operaciones con números reales. Universidad de Sonora

Suma Sumar 7 más 6: Hay que tomar en cuenta los acarreos: Universidad de Sonora

Resta Restar 7 – 6. Se puede hacer directo: O se puede usar una suma, recordando que 7 – 6 = 7 + (-6): En conclusión, la resta se puede hacer con una suma. Universidad de Sonora

Pero… Por cuestiones de eficiencia las sumas no se hacen bit a bit (sumador de ripple carry). Si dos bits se pueden sumar en un ciclo de reloj, dos números de n bits necesitan al menos 2n ciclos (un ciclo para la suma y otro para pasar el carry al siguiente paso). Hay algoritmos para hacer sumas rápidas. El más común se llama sumador de carry-lookahead (carry adelantado). Universidad de Sonora

Suma de dos números de 1 bit C 1 S = a  b C = a . b Universidad de Sonora

Suma de tres números de 1 bit Entrada: Dos números, a y b, de 1 bit. Un carry de entrada, c0, de 1 bit. Salida: La suma, S, de 1 bit. Un carry de salida, c1, de 1 bit. Universidad de Sonora

Sumador completo (full adder) b c0 S c1 1 S = a  b  c0 c1 = a . c + a . b + b . c Universidad de Sonora

Suma de dos números de dos bits Entrada: Un número de 2 bits, A = a1a0. Un número de 2 bits, B = b1b0. Un carry de entrada, c0, de 1 bit. Salida: La suma, S, de dos bits, S = s1s0. Un carry de salida, c2, de 1 bit. Un carry intermedio, c1, de 1 bit. Universidad de Sonora

Ecuaciones para los carries La suma es el or exclusivo de ai, bi, y ci. Nos enfocamos en los carries, ci. c1 = (b0 . c0) + (a0 . c0) + (a0 . b0) c2 = (b1 . c1) + (a1 . c1) + (a1 . b1) Sustituyendo c1 en c2: c2 = (a1 . a0. b0) + (a1 . a0 . c0) + (a1 . b0 . c0) + (b1 . a0 . b0) + (b1 . a0 . c0) + (b1 . b0 . c0) + (a1 . b1) Se puede calcular c1 y c2 en paralelo. Universidad de Sonora

Ecuaciones para los carries Ese razonamiento se puede extender para números de n bits (n = 8, 16, 32, 64, 128, etc.) Y calcular los n carries en paralelo. Universidad de Sonora

Pero… La ecuación para ci se expande conforme i crece. Con números de dos bits se requieren: 6 compuertas AND de 3 entradas. 1 compuerta AND de 2 entradas. 1 compuerta OR de 7 entradas. Para números de 32 bits el costo del hardware y de energía es prohibitivo. Hay que buscar otra solución, aunque no sea las más rápida. Universidad de Sonora

Sumador de carry lookahead Se tiene que: c1 = (b0 . c0) + (a0 . c0) + (a0 . b0) c2 = (b1 . c1) + (a1 . c1) + (a1 . b1) En general: ci+1 = (bi . ci) + (ai . ci) + (ai . bi) = (ai . bi) + (ai + bi) . ci Universidad de Sonora

Sumador de carry lookahead Se reescribe la ecuación para c2: c2 = (a1 . b1) + (a1 . b1) . ((a0. b0) + (a0 + b0) . c0) Se nota que se repiten los factores (ai . bi) y (ai + bi). Se definen los factores genera (gi) y propaga (pi): gi = ai . bi pi = ai + bi Universidad de Sonora

Genera y propaga Se rescribe la ecuación para ci+1: ci+1 = gi + pi . ci Si gi = 1: ci+1 = 1. Si gi = 0 y pi = 1: ci+1 = ci Universidad de Sonora

Genera y propaga Usando la ecuación de ci+1 se definen los carries: c1 = g0 + (p0 . c0) c2 = g1 + (p1 . g0) + (p1 . p0 . c0) c3 = g2 + (p2 . g1) + (p2 . p1 . g0) + (p2 . p1 . p0 . c0) c4 = g3 + (p3 . g2) + (p3 . p2 . g1) + (p3 . p2 . p1 . g0) + (p3 . p2 . p1 . p0 . c0) Se pueden calcular los carries en paralelo. Las ecuaciones se complican rápidamente. Hay que buscar una forma de simplificar las ecuaciones. Universidad de Sonora

Usando un segundo nivel de abstracción Suponer que se cuenta con un sumador de 4 bits con carry-lookahead. Se puede construir un sumador de 16 bits conectando 4 sumadores de 4 bits en serie (ripple). El carry de salida del sumador j se conecta al carry de entrada de sumador j + 1. El carry de entrada del sumador 0 es el carry inicial. El carry de salida del sumador 3 es el carry final. Universidad de Sonora

Propaga de segundo nivel Se define la señal “súper” propaga: P0 = p3 . p2 . p1 . p0 P1 = p7 . p6 . p5 . p4 P2 = p11 . p10 . p9 . p8 P3 = p15 . p14 . p13 . p12 Universidad de Sonora

Genera de segundo nivel Se define la señal “súper” genera G0 = g3 + (p3 . g2) + (p3 . p2 . g1) + (p3 . p2 . p1 . g0) G1 = g7 + (p7 . g6) + (p7 . p6 . g5) + (p7 . p6 . p5 . g4) G2 = g11 + (p11 . g10) + (p11 . p10 . g9) + (p11 . p10 . p9 . g8) G3 = g15 + (p15 . g14) + (p15 . p14 . g13) + (p15 . p14 . p13 . g12) Universidad de Sonora

Carries de segundo nivel Los carries para cada sumador de 4 bits: C1 = G0 + (P0 . c0) C2 = G1 + (P1 . G0) + (P1 . P0 . c0) C3 = G2 + (P2 . G1) + (P2 . P1 . G0) + (P2 . P1 . P0 . c0) C4 = G3 + (P3 . G2) + (P3 . P2 . G1) + (P3 . P2 . P1 . G0) + (P3 . P2 . P1 . P0 . c0) Universidad de Sonora

Conclusión Para hacer un sumador de 16 bits con carry-lookahead se necesitan: 4 sumadores con carry- lookahead de 4 bits. 1 unidad de carry-lookahead. Los carries de entrada de cada sumador de 4 bits se toma de la unidad de carry-lookahead. Universidad de Sonora

Universidad de Sonora

Ejemplo Calcular gi, pi, Pi, Gi y el carry final (C4) al sumar los siguientes dos números de 16 bits: Se obtiene gi = ai . bi y pi = ai + bi: Universidad de Sonora

Ejemplo Se calculan los “súper” propaga (P0, P1, P2, P3): Y los “súper” genera: Universidad de Sonora

Ejemplo Por último, el carry final (C4) En conclusión, al sumar a y b se obtiene un carry final. Universidad de Sonora

Comparación Un sumador de 16 bits de ripple-carry necesita 32 ciclos. Un sumador de 16 bits de carry-lookahead necesita 5 ciclos: 1 ciclo para obtener pi y gi en paralelo. 2 ciclos para obtener Pi y Gi en paralelo. 2 ciclos para obtener C4. Universidad de Sonora

Multiplicación Algoritmo clásico o multiplicación larga Algoritmo del campesino Algoritmo de quarter square (cuartos al cuadrado) Algoritmo de Karatsuba Universidad de Sonora

Multiplicación Multiplicación larga Universidad de Sonora

Algoritmo Universidad de Sonora

Ejemplo Multiplicar 3 x 2 Universidad de Sonora

Números con signos distintos Multiplicar 3 x (-2). Se le quita el signo al -2 y se guarda en alguna variable. Se multiplica 3 x 2 usando el algoritmo ya visto. Se multiplica el resultado por -1 para obtener -6. Universidad de Sonora

Algoritmo del campesino Sean x y y dos números. i = 0 X[i] = x Y[i] = y x = x / 2  x >> 1 y = y * 2  y << 1 i++ if x > 1 goto 2 x.y = suma de Y[i] en donde X[i] sea impar Universidad de Sonora

Ejemplo en base 10 Obtener 24 x 5: X[i] Y[i] 24 5 12 10 6 20 3 40 1 80 24 5 12 10 6 20 3 40 1 80 El producto es 40 + 80 = 120. Los demás se ignoran porque X[i] es par. Universidad de Sonora

Ejemplo en base 2 Obtener 11000 (24) x 101 (5): X[i] Y[i] 11000 101 11000 101 1100 1010 110 10100 11 101000 1 1010000 El producto es la suma de las Y[i] en donde X[i] sea impar:101000 + 1010000 = 1111000 (120). Universidad de Sonora

Algoritmo de quarter square Basado en la siguiente igualdad: Universidad de Sonora

Algoritmo de quarter square El algoritmo es eficiente si los quarter squares se guardan en tablas. Ejemplo: Calcular 9 x 3. Se obtiene 9 + 3 = 12 y 9 – 3 = 6. Se buscan en la tabla y se restan. 36 – 9 = 27. n 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |n2/4| 20 25 30 36 42 49 56 64 72 81 Universidad de Sonora

Algoritmo de quarter square Implementaciones: En hardware en 1980 por E.L. Johnson (ver E.L. Johnson, "A Digital Quarter Square Multiplier", IEEE Transactions on Computers, vol. 29, pp. 258-261, March 1980, https://www.computer.org/csdl/trans/tc/1980/03/01675558-abs.html). En la CPU 6502 en 1995 por S. Judd (ver http://www.ffd2.com/fridge/chacking/c=hacking9.txt) Universidad de Sonora

Algoritmo de Karatsuba Sean x y y números de n dígitos en base B. Se desea calcular el producto xy. x y y se escriben de la siguiente forma: x = x1Bm + x0 y = y1Bm + y1 Por ejemplo 7425 en base 10 es: 7 x 103 + 425 x1 = 7, x0 = 425 Universidad de Sonora

Algoritmo de Karatsuba El producto xy se obtiene así: xy = (x1Bm + x0)(y1Bm + y0) = z2B2m + z1Bm + z0 donde: z2 = x1y1 z1 = x1y0 + x0y1 z0 = x0y0 z1 se puede también escribir: z1 = (x1 + x0)(y1 + y0) – z2 – z0 Universidad de Sonora

Algoritmo de Karatsuba El producto se puede también escribir así: xy = (b2 + b)x1y1 – b(x1 – x0)(y1 – y0) + (b + 1)x0y0 Con b = Bm. Ahora se requieren 3 multiplicaciones. Ventajas: [x1|y1] << [x|y], [x0|y0] < [x|y] Los 3 productos se pueden hacer de forma recursivas. Al final se hacen productos de un dígito. Universidad de Sonora

Algoritmo de Karatsuba Para números de n bits, la complejidad: Multiplicación larga es O(n2). Algoritmos de Karatsuba es O(nlog2 3  n1.6) Para números de 32 bits: 322 = 1024 32log2 3 = 243 Speedup = 1024 / 243 = 4.21 Universidad de Sonora

Algoritmo de Karatsuba Para números de 1024 bits (usados en encriptación): 10242 = 1,048,576 1024log2 3 = 59,049 Speedup = 1048576 / 59049 = 17.76 En 2011 Intel patentó un algoritmo basado en el de Karatsuba: https://www.google.com/patents/US7930337. Universidad de Sonora

Comparación Multiplicación larga vs Karatsuba. Fuente: https://www.quora.com/What-is-the-fastest-algorithm-for-multiplication-of-two-n-digit-numbers-1 Universidad de Sonora

División Método restoring. Método non-restoring. Universidad de Sonora

División Nomenclatura: Universidad de Sonora

División Nomenclatura alterna: Universidad de Sonora

Método restoring Ejemplo: Obtener 4537 / 3 en base 10. 4537 tiene 4 dígitos numerados 3, 2, 1,0. 4537 – 3 x 103 = 1537 q3 = 1 1537 – 3 x 103 = -1463 q3 = 2 -1463 + 3 x 103 = 1537 restaura q3 = 1 1537 – 3 x 102 = 1237 q2 = 1 1237 – 3 x 102 = 937 q2 = 2 937 – 3 x 102 = 637 q2 = 3 Universidad de Sonora

Método restoring 637 – 3 x 102 = 337 q2 = 4 337 – 3 x 102 = 37 q2 = 5 -263 + 3 x 102 = 37 restaura q2 = 5 37 – 3 x 101 = 7 q1 = 1 7 – 3 x 101 = -23 q1 = 2 -23 + 3 x 101 = 7 restaura q1 = 1 7 – 3 x 100 = 4 q0 = 1 4 – 3 x 100 = 1 q0 = 2 Universidad de Sonora

Método restoring 1 – 3 x 100 = -2 q0 = 3 -2 + 3 x 100 = 1 restaura q0 = 2 El cociente está en las qi restauradas (en rojo). El residuo está en la última operación (en verde). 4537 / 3 = 1512 (división entera). 4537 % 3 = 1 (módulo). Universidad de Sonora

Método restoring Ejemplo: Obtener 11101 / 11 en base 2 (29 / 3 en base 10). 11101 tiene 5 dígitos numerados 4, 3, 2, 1, 0. 29 – 3 x 24 = -19 q4 = 1 -19 + 3 x 24 = 29 restaura q4 = 0 29 – 3 x 23 = 5 q3 = 1 5 – 3 x 23 = -19 q3 = 2 -19 + 3 x 23 = 5 restaura q3 = 1 5 – 3 x 22 = -7 q2 = 1 Universidad de Sonora

Método restoring -7 + 3 x 22 = 5 restaura q2 = 0 5 – 3 x 21 = -1 q1 = 1 -1 + 3 x 21 = 5 restaura q1 = 0 5 – 3 x 20 = 2 q0 = 1 2 – 3 x 20 = -1 q0 = 2 -1 + 3 x 20 = 2 restaura q0 = 1 Conclusión: 11101 / 11 = 1001 (29 / 3 = 9) 11101 % 11 = 10 (29 % 3 = 2) Universidad de Sonora

Método restoring en Java // Enteros positivos de 16 bits: public Point restoring(int n, int d) { int q = 0; // Cociente int p = n; // Residuo d = d << 16; for (int i = 15; i >= 0; i--) { p = 2 * p - d; if (p >= 0) { q |= 1 << i; } else { p = p + d; return new Point(q, p >> 16); Universidad de Sonora

Método non-restoring en Java // Ciclo principal public Point nonrestoring(int n, int d) { int q = 0; // Cociente int p = n; // Residuo d = d << 16; for (int i = 15; i >= 0; i--) { if (p >= 0) { q |= 1 << i; p = 2 * p - d; } else { p = 2 * p + d; Universidad de Sonora

Método non-restoring en Java // Parte final q = q - neg(q); p >>= 16; if (p < 0) { q--; p += (d >> 16); } return new Point(q, p); Universidad de Sonora

Método non-restoring Ejemplo: Dividir 29 / 3 29 en binario es 11101 y tiene 5 bits. Inicializa: q = 0, p = 29, d = 3 << 5 = 96. i = 4 p >= 0 q = q | (1 << 4) = 16 p = 2 x p – d = 2 x 29 – 96 = -38 Universidad de Sonora

Método non-restoring i = 3 p < 0 p = 2 x p + d = 2 x (-38) + 96 = 20 i = 2 p >= 0 q = q | (1 << 2) = 20 p = 2 x p – d = 2 x 20 – 96 = -56 Universidad de Sonora

Método non-restoring i = 1 p < 0 p = 2 x p + d = 2 x (-56) + 96 = -16 i = 0 p = 2 x p + d = 2 x (-16) + 96 = 64 Universidad de Sonora

Método non-restoring Al final del ciclo principal: q = 20 p = 64 Instrucción q = q - neg(q); 20 = 10100 neg(20) = 01011 = 11 en base 10 q = 20 – 11 = 9 r = 64 >> 5 = 2 Universidad de Sonora

Método non-restoring Resultado final: 29 / 3 = 9 29 % 3 = 2 Universidad de Sonora

Números de punto flotante Suma Resta Multiplicación División Universidad de Sonora

Suma Para sumar dos números normalizados en notación científica: Alinear los exponentes. Hacer la suma. Normalizar si es necesario. Redondear. Universidad de Sonora

Suma Ejemplo: sumar 9.999 x 101 + 1.610 x 10-1 en base 10 con cuatro dígitos. Paso 1: alinear los exponentes. Se mueve el punto decimal del número con el exponente más pequeño. 1.610 x 10-1 se convierte en 0.016 x 101. Paso 2: hacer la suma: Universidad de Sonora

Suma La suma es 10.015 x 101. Paso 3: normalizar. 9.999 + 0.016 -------- 10.015 La suma es 10.015 x 101. Paso 3: normalizar. 10.015 x 101 = 1.0015 x 102. Paso 4: redondear a 4 dígitos. 9.999 x 101 + 1.610 x 10-1 = 1.002 x 102. Universidad de Sonora

Suma Fuente: COD 5, p. 205 Universidad de Sonora

Precisión Ejemplo: hacer 2.56 x 100 + 2.34 x 102 en base 10 con 3 dígitos. Paso 1: alinear los exponentes. 2.56 x 100 se convierte en 0.02 x 102 con tres dígitos. Se perdió precisión. El standard IEEE 754 define dos bits extras, llamados guard y round, para cálculos intermedios. Universidad de Sonora

Precisión En realidad los números se guardan cómo 2.5600 x 100 + 2.3400 x 102. Paso 1: alinear los exponentes. 2.5600 x 100 se convierte 0.0256 x 102. Paso 2: hacer la suma 2.3400 + 0.0256 -------- 2.3656 Universidad de Sonora

Precisión Paso 3: normalizar. 2.3656 x 102 ya está normalizado. Paso 4: redondear a 3 dígitos. 2.37 x 102 2.56 x 100 + 2.34 x 102 = 2.37 x 102. Universidad de Sonora

Algoritmo para sumar Se usa el mismo algoritmo que para números enteros. En el standard IEEE 754 la mantisa está guardada como un número binario entero. Fuente: Wikipedia (https://upload.wikimedia.org/wikipedia/commons/thumb/e/e8/IEEE_754_Single_Floating_Point_Format.svg/618px-IEEE_754_Single_Floating_Point_Format.svg.png) Universidad de Sonora

Resta La resta se convierte en suma al poner el segundo número en complemento a 2. Universidad de Sonora

Multiplicación Para multiplicar dos números normalizados en notación científica: Sumar los exponentes. Multiplicar las mantisas. Normalizar si es necesario. Redondear. Universidad de Sonora

Multiplicación Ejemplo: multiplicar 1.110 x 1010 por 9.200 x 10-5 en base 10 con 4 dígitos en la mantisa y 2 en el exponente. Paso 1: sumar los exponentes. 10 + (-5) = 5. Paso 2: multiplicar las mantisas. Universidad de Sonora

Multiplicación 1.100 x 9.200 ------- 0000 2200 9990 --------- 10212000 Se le pone el punto decimal 10.212000. Universidad de Sonora

Multiplicación Paso 3: normalizar. 10.212000 x 105 se normaliza a 1.0212000 x 106. En este punto se checa si hay overflow o underflow. Paso 4: redondear. 1.0212000 x 106 se convierte en 1.021 x 106 con 4 dígitos para la mantisa. Universidad de Sonora

Algoritmo para multiplicar Se puede usar cualquiera de los algoritmos vistos para multiplicar números enteros. Universidad de Sonora

División Para dividir dos números normalizados en notación científica: Restar los exponentes. Dividir las mantisas. Normalizar si es necesario. Redondear. Universidad de Sonora

División Ejemplo: dividir 7.152 x 100 entre 2.491 x 102 en base 10 con 3 dígitos en la mantisa. Paso 1: restar los exponentes. 0 – 2 = -2. Paso 2: dividir las mantisas. 7.152 / 2.491 = 2.87113608992. Paso 3: normalizar. El cociente ya está normalizado. Universidad de Sonora

División Paso 4: redondear. 2.87113608992 = 2.871 con 3 dígitos en la mantisa. Conclusión: 7.152 x 100 entre 2.491 x 102 = 2.871 x 10-2. Universidad de Sonora

Algoritmos de división Se pueden usar los algoritmos de división entera. Pero hay que tener cuidado con la interpretación de los resultados. La división entera entrega el cociente y el residuo (módulo) por separado. En la división de punto flotante solo interesa el cociente (número de punto flotante) con cierta precisión. Universidad de Sonora

Algoritmos de división Por ejemplo, al dividir 4715.22 / 241.9 nos interesa que el resultado sea 19.4924 y no que el resultado sea cociente = 19, residuo = 119.12. Una opción es la división Newton-Raphson. Universidad de Sonora

División Newton-Raphson Se desea calcular a / b. Calcular 1 / b usando Newton-Raphson. Multiplicar a x (1 / b). Universidad de Sonora

Newton-Raphson Es un método para encontrar raíces de una función (x:f(x) = 0). Dada f(x), la derivada f’(x) y un valor inicial x0 para la raíz de f, una mejor aproximación es: Se repite el proceso: Universidad de Sonora

Newton-Raphson Para obtener 1 / b, se utiliza: Sustituyendo lo anterior en la ecuación general: Universidad de Sonora

Newton-Raphson Universidad de Sonora

Ventaja Convergencia cuadrática. Ejemplo: calcular 1 / 4 con x0 = 0.2. 0.24 x2 0.2496 x3 0.24999936 x4 0.2499999999983616 x5 0.25 Universidad de Sonora

Desventaja Si x0 no es una buena aproximación, el método diverge. Ejemplo: calcular 1 / 4 con x0 = 0.51. x0 0.51 x1 -0.02040000000000002 x2 -0.04246464000000004 … x9 -1.31525429545336E8 x10 -6.9195754731391424E16 x15 -Infinity Universidad de Sonora

Solución Tomar ventaja de que los números están normalizados: En base 10, 1 ≤ mantisa < 10. En base 2, 1 ≤ mantisa < 2. Guardar en una tabla (o en una ROM para implementaciones en hardware) algunos inversos. Por ejemplo, para base 10. Universidad de Sonora

Solución Para calcular 1 / 8.25: Se toma la parte entera, 8. Índice Inverso 1.0000 1 0.5000 2 0.3333 3 0.2500 4 0.2000 5 0.1667 6 0.1429 7 0.1250 8 0.1111 Para calcular 1 / 8.25: Se toma la parte entera, 8. Se usa ROM[7] como x0. Universidad de Sonora

Solución 1 / 8.25. x0 0.125 x1 0.12109375 x2 0.12121200561523438 x3 0.12121212121201097 x4 0.12121212121212122 Universidad de Sonora

División Newton-Raphson Para leer sobre una implementación en hardware. Gaurav Agrawal, Ankit Khandelwal. A Newton Raphson Divider Based on Improved Reciprocal Approximation Algorithm. http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.134.725&rep=rep1&type=pdf Universidad de Sonora