Sumador binario: sigue los bits de suma y los acarreos

Sumar 7 y 9 solo con interruptores

Las puertas lógicas suman números binarios produciendo, en cada columna, un bit de suma y un bit de acarreo. Un sumador completo acepta además el acarreo de la columna anterior. En un sumador de acarreo en serie, cada acarreo tiene que atravesar las puertas antes de que el resultado final se estabilice.

En papel, 7 + 9 ocupa una sola línea: 6 en la columna de las unidades, te llevas 1 y el resultado es 16. Un ordenador no tiene papel ni sabe qué es un número. Lo que tiene son interruptores que están encendidos o apagados. Entonces, ¿cómo saca un montón de interruptores el 16 a partir del 7 y el 9?

La placa de arriba lo responde capa por capa y luego sigue adelante. Se abre con un sumador de acarreo en serie de 4 bits: ocho interruptores de bit en el borde delantero para dos números, A y B, cada uno de 0 a 15, veinte puertas lógicas detrás y cinco LED en el borde trasero para el resultado. Cuando cambias un interruptor, se iluminan las pistas de cobre que llevan un 1, y la luz avanza por las puertas a la velocidad que fijes con el control deslizante «Retardo de puerta». El panel de la esquina muestra a la vez las entradas y los LED, en binario y en decimal.

El control deslizante «Circuito» cambia la placa por uno de 15 circuitos construidos con el mismo tipo de chip de puertas: una puerta, un semisumador, un sumador completo, sumadores de acarreo en serie de 4 y de 8 bits, un sumador de acarreo anticipado, un sumador-restador, un comparador, un multiplexor, un decodificador de 7 segmentos, un cerrojo SR, un biestable D, un contador, una pequeña UAL y un reto hecho con cuatro puertas NAND. Todos funcionan con la misma simulación, así que puedes comparar cuántas puertas necesita cada uno y cuánto tarda en estabilizarse.

Números escritos con dos dígitos

En decimal, cada columna vale diez veces la que tiene a su derecha: unidades, decenas, centenas. El binario funciona igual, pero con dos en lugar de diez. Las columnas valen 1, 2, 4 y 8, de modo que cuatro bits pueden guardar cualquier número de 0 (0000) a 15 (1111). En la placa, el interruptor A0 es la columna de las unidades y A3 la de los ochos, y los números pequeños impresos bajo cada interruptor indican su valor.

Siete es 4 + 2 + 1, es decir, 0111. Nueve es 8 + 1, es decir, 1001. Su suma, 16, necesita una quinta columna que vale 16, así que el resultado es 10000. Esa quinta columna es el LED de acarreo, C4. Siempre que una suma supera 15, el LED de acarreo es la única manera que tiene la placa de mostrarlo.

El binario conviene a la electrónica porque un cable solo tiene que estar en uno de dos estados claramente distintos. Un circuito no tiene que distinguir 3 voltios de 3,5 voltios, solo «alto» de «bajo», y eso es mucho más fácil de hacer de forma fiable miles de millones de veces por segundo.

Un transistor como interruptor

Pon el control «Circuito» en «Una puerta» y elige «Cable» en el modelo. El interruptor X conecta un LED a la alimentación mediante un puente, y el LED muestra exactamente lo que dice el interruptor: 1 es encendido, 0 es apagado.

Ahora elige «Transistor». El modelo muestra un transistor NPN con tres patillas. Una pequeña corriente hacia la patilla central (la base) permite que fluya una corriente mucho mayor entre las otras dos (el colector y el emisor), y el LED se enciende. Si quitas la corriente de base, el LED se apaga. El transistor se ha convertido en un interruptor que se acciona con electricidad en lugar de con un dedo.

Esto es una simplificación, y el modelo lo indica. Un transistor real es un componente analógico: dentro de un intervalo, más corriente de base produce más corriente de colector. Los circuitos lógicos se diseñan para que el transistor pase el tiempo solo completamente en corte o completamente en conducción, y atraviese el estado intermedio lo más rápido que pueda. Eso es lo que permite tratarlo como un interruptor.

Puertas hechas de parejas de transistores

Cuando un interruptor puede controlar a otro, se pueden construir decisiones. Los chips actuales usan un tipo de transistor llamado MOSFET, en dos variantes: los de canal n conducen cuando su entrada está en alto y los de canal p conducen cuando está en bajo. La lógica CMOS los empareja de modo que una red puede llevar la salida hasta la alimentación y la otra puede llevarla hasta masa, y para cualquier entrada conduce exactamente una de las dos redes. Una puerta en reposo casi no consume corriente. Esa propiedad, mostrada por Chih-Tang Sah y Frank Wanlass en Fairchild en 1963, es la razón de que un teléfono pueda contener miles de millones de transistores sin fundirse.

Si cuentas los transistores, las puertas dejan de costar lo mismo:

La sorpresa es que AND, la puerta que todo el mundo aprende primero, cuesta más que NAND. En CMOS las puertas naturales son las inversoras, porque la red de canal n lleva la salida hacia abajo: dos transistores de canal n en serie la bajan solo cuando ambas entradas son 1, lo que es NAND, y dos en paralelo forman NOR. Para obtener AND hay que añadir un inversor. Activa «Transistores por chip» y cada chip de la placa mostrará su propio recuento; el banco «Una puerta» te permite recorrer los siete tipos de puerta y el cable sencillo.

NAND tiene otra propiedad más. Solo con puertas NAND se puede construir NOT (uniendo las dos entradas), AND (una NAND y una NOT), OR (invirtiendo antes ambas entradas) y todo lo demás. El último circuito de la placa es un reto basado en esto: cuatro puertas NAND cuyas entradas eliges tú en el laboratorio, bajo los controles. Si el cableado es correcto, la salida coincide con XOR en las cuatro filas.

Semisumador: XOR para la suma, AND para el acarreo

Mira la tabla de verdad de XOR. 0 + 0 = 0, 0 + 1 = 1, 1 + 0 = 1 y 1 + 1 = 10 en binario, es decir, 0 en esta columna y un 1 que pasa a la siguiente. El dígito de la derecha de cada resultado es exactamente la columna de XOR. El acarreo es 1 solo en la última fila, que es exactamente AND.

Así pues, un XOR y un AND alimentados por los mismos dos bits los suman. Este par se llama semisumador. En la placa «Semisumador» aparece solo; en el sumador de 4 bits es el primer bloque de cada bit. Con A y B ambos a 1, XOR da suma 0 y AND da acarreo 1.

Sumador completo: entran tres bits, salen dos

Un semisumador basta para la columna de las unidades, pero todas las demás columnas tienen tres cosas que sumar: un bit de A, un bit de B y el acarreo que llega de la derecha. El sumador completo lo resuelve con dos semisumadores y una puerta OR. En la placa, cada bit usa estos nombres:

1. p = A xor B y g = A and B (el primer semisumador)
2. S = p xor C y t = p and C (el segundo semisumador suma el acarreo entrante C)
3. Acarreo de salida = g or t

La puerta OR nunca recibe dos 1 a la vez. Si A y B son ambos 1, entonces p es 0 y t no puede ser 1. Solo reúne las dos maneras en que se puede producir un acarreo: la columna lo generó por sí misma (g) o la columna transmitió el acarreo que recibió (t). Las ocho filas de la tabla de verdad del sumador completo cubren todos los casos, y la mayor, 1 + 1 + 1 = 3, da acarreo 1 y suma 1.

Cinco puertas por bit y cuatro bits forman las 20 puertas del sumador de 4 bits. El acarreo de salida de cada sumador completo está conectado al acarreo de entrada del siguiente, el de su izquierda, como el paso de «me llevo 1» en papel. Esa cadena es la razón del nombre de acarreo en serie. Mientras funciona, la tabla de verdad de la esquina marca qué fila está usando cada bit, de modo que puedes ver al bit 0 en 1 1 0 mientras el bit 3 espera en 0 1 1.

Por qué el acarreo tarda

Ninguna puerta responde al instante. Cuando cambian sus entradas, la salida las sigue un poco después, y ese intervalo se llama retardo de puerta o retardo de propagación. El modelo da a cada puerta un retardo de exactamente una unidad, y el control deslizante estira esa unidad de 0,05 a 2,4 segundos para que puedas observarla.

Así ocurre 7 + 9, partiendo de una placa en 0 + 0:

Cada bit necesita dos retardos de puerta para transmitir el acarreo: uno para el AND que produce t y otro para el OR que produce el acarreo de salida. En cuatro bits, el último acarreo llega tras 8 retardos. El peor caso de la placa de 4 bits es de 9 retardos, lo que coincide con 2n + 1 para n = 4 bits. Activa «Retardo en cada chip» y cada chip mostrará el retardo en el que su salida cambió por última vez; a lo largo de la cadena de acarreo los números suben 2, 4, 6, 8.

Observa los LED durante esos 8 retardos y verás respuestas erróneas. En el retardo 6, el panel puede marcar 01000, que es 8. No hay nada roto: esos LED muestran una suma calculada antes de que llegara el acarreo. Los circuitos reales tienen las mismas salidas falsas de corta duración, llamadas glitches, y por eso un procesador espera un tiempo fijo a que termine el camino más lento antes de leer la salida de un sumador. La duración de esa espera es una de las cosas que fijan la frecuencia de reloj. El «Diagrama temporal» muestra lo mismo como formas de onda, con cada salida subiendo y bajando antes de estabilizarse.

La placa de 8 bits deja claro el coste. Es el mismo sumador completo repetido ocho veces, con 40 puertas, y 255 + 1 envía un acarreo por todos los bits: los LED se estabilizan tras 16 retardos de puerta, el doble que 15 + 1 en la placa de 4 bits. Un sumador de acarreo en serie de 64 bits construido del mismo modo necesitaría 129 retardos de puerta en el peor caso. Si quieres ver un retardo cada vez, activa «Un retardo cada vez» y pulsa «Siguiente retardo» bajo el modelo.

Calcular los acarreos por adelantado

Los sumadores rápidos no esperan a que el acarreo avance en serie. Vuelve a mirar el sumador completo: una columna genera un acarreo por sí sola cuando g = A and B es 1, y transmite el acarreo que recibe cuando p = A xor B es 1. Esas dos señales están listas tras un retardo de puerta en todas las columnas a la vez. A partir de ellas, cada acarreo puede escribirse por completo:

• 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

Lee C2 como una frase: hay acarreo hacia el bit 2 si el bit 1 lo generó, o si el bit 1 transmite un acarreo generado por el bit 0, o si los bits 1 y 0 transmiten ambos el acarreo de entrada. Cada línea es una fila de puertas AND seguida de un único OR, así que todos los acarreos llegan tras tres retardos de puerta y las sumas, un retardo después. La placa «Sumador de acarreo anticipado de 4 bits» lo hace con 26 puertas. Pon 15 + 1 en ella y se estabiliza en 4 retardos de puerta, donde la placa de acarreo en serie tardó 8. La tabla del panel muestra P, G y el acarreo de cada bit.

El precio está en las puertas AND. C4 ya necesita un AND de 5 entradas y un OR de 5 entradas, y los términos crecen con cada bit, así que los sumadores anchos combinan las dos ideas: pequeños bloques de acarreo anticipado de cuatro bits, con un segundo nivel de anticipación entre los bloques. Gerald Rosenberger, de IBM, solicitó en 1957 una patente de un sumador binario de acarreo anticipado. Charles Babbage había visto el mismo problema un siglo antes y diseñó un mecanismo para anticipar los acarreos en su máquina analítica. Hoy, un sumador de 4 bits con «acarreo rápido» es un chip de catálogo: Texas Instruments aún ofrece el SN74LS283.

Restar con el mismo sumador

Los ordenadores no necesitan un restador aparte. En complemento a dos, la forma habitual de guardar números negativos, menos B se escribe como «invierte todos los bits de B y suma 1». Así, A − B es A + (not B) + 1.

La placa «Sumador-restador» añade un XOR por bit delante de B. Con SUB apagado, cada XOR deja pasar su bit de B tal cual; con SUB encendido, cada XOR invierte su bit, y la misma línea SUB alimenta el acarreo de entrada, que aporta el 1 extra. Prueba 5 − 7. B = 0111 pasa a 1000, el sumador calcula 0101 + 1000 + 1 = 1110, y 1110, leído como número de 4 bits con signo, es −2. Leído sin signo es 14, que también es correcto a su manera: 5 − 7 + 16 = 14. Los mismos bits significan cosas distintas según cómo se lean, y el panel muestra ambas lecturas.

Un número de 4 bits con signo solo abarca de −8 a 7, así que algunos resultados no caben. El LED verde V de la placa lo detecta: es un XOR del acarreo que entra en el bit superior y el que sale de él, y se enciende cuando difieren. 7 + 1 (con SUB apagado) lo enciende, porque 0111 + 0001 = 1000, que se lee como −8. La fila extra de XOR cuesta un retardo de puerta más al principio, y la puerta V otro más al final, así que el peor caso de esta placa es de 11 retardos.

Comparar dos números

¿Cómo decide un circuito que 9 es mayor que 5? Del modo en que lo harías con números escritos: buscando el dígito de mayor peso en el que difieren. La placa «Comparador» lo resuelve bit a bit. A > B en un bit significa que A es 1 y B es 0 (un AND con un inversor en B), A < B significa lo contrario, y el bit es igual cuando no se cumple ninguna de las dos, lo que es un NOR de ambas.

Después ordena los bits por prioridad. A es mayor si lo dice el bit 3, o si el bit 3 es igual y lo dice el bit 2, o si los bits 3 y 2 son iguales y lo dice el bit 1, y así hacia abajo. Son cuatro términos AND reunidos por un OR, la misma forma que los acarreos anticipados. 1001 frente a 0101 difieren primero en el bit 3, donde A tiene el 1, y el LED A > B se enciende tras 4 retardos de puerta (el peor caso de esta placa es de 5). La placa usa 29 puertas. El SN74LS85 de TI hace el mismo trabajo en un solo encapsulado y tiene entradas adicionales para que varios chips puedan comparar números más largos.

Elegir una entrada y dibujar un dígito

Otros dos circuitos usan el mismo patrón de puertas AND reunidas por un OR.

Un multiplexor elige. La placa de 4 a 1 tiene cuatro entradas de datos, D0 a D3, y dos bits de selección. Cada entrada de datos va a un AND de 3 entradas que recibe también los bits de selección (o sus inversos), de modo que para cualquier ajuste queda abierto exactamente un AND, y el OR transmite su bit de datos a Y. Son siete puertas y tres retardos de puerta. Allí donde un cable tiene que llevar una de varias señales, desde los registros de un procesador hasta el selector de fuentes de un televisor, hay un multiplexor.

Un decodificador dibuja. Una pantalla de 7 segmentos tiene siete LED en forma de barra, llamados a a g, y cada dígito enciende un conjunto distinto: el 1 enciende b y c, el 8 enciende los siete. Para cada segmento se puede hacer la lista de los dígitos que lo encienden y simplificarla hasta una suma de productos, unos pocos términos AND reunidos por un OR. El decodificador de la placa se resolvió así: 4 inversores, 28 términos AND compartidos y 7 OR, 39 puertas, con tres retardos de puerta del interruptor al segmento. Dibuja los dígitos hexadecimales A a F además de 0 a 9. El SN74LS47 de TI es la versión de catálogo para 0 a 9.

Circuitos que recuerdan

Todo lo anterior olvida. Si cambias los interruptores, la salida los sigue; nada depende de lo que ocurrió antes. La memoria necesita un bucle.

El cerrojo SR son dos puertas NOR, cada una conectando su salida a la entrada de la otra. Con S y R ambos a 0, el bucle conserva lo que tuviera, Q = 1 o Q = 0, y lo sigue conservando mientras haya alimentación. Un 1 en S fuerza Q a 1; un 1 en R lo fuerza a 0. Activa Q, apaga S de nuevo y Q sigue a 1. Eso es un bit de memoria hecho con ocho transistores.

El cerrojo tiene una entrada prohibida. Con S y R ambos a 1, las dos salidas son 0, y si entonces sueltas ambas en el mismo instante, las dos puertas compiten. En el modelo, donde ambas puertas tienen exactamente el mismo retardo, el bucle nunca se estabiliza: las salidas cambian juntas en cada retardo de puerta y el panel lo indica. Un cerrojo real nunca está perfectamente equilibrado, así que un lado gana, pero no se puede predecir cuál ni cuánto tardará. Los ingenieros llaman a esto metaestabilidad, y los diseños digitales se organizan para que no pueda ocurrir en el uso normal.

Un biestable D elimina el problema porque toma los datos solo en un instante. La versión de la placa es el diseño de seis NAND que usa el chip 7474. Mientras el reloj está en bajo o en alto, D puede cambiar tantas veces como quiera y Q no se mueve. Solo en el momento en que CLK sube de 0 a 1, Q toma el valor de D y lo conserva hasta el siguiente flanco ascendente. Con 49 152 pasos aleatorios de D y CLK, Q siguió esa regla en todos.

Contar pulsos de reloj

Pon cuatro biestables uno al lado de otro, añade un pequeño circuito que calcula el número actual más uno y devuelve el resultado a las entradas D de los biestables. Cada pulso de reloj carga el número siguiente. La placa del contador de 4 bits hace exactamente eso con 30 puertas: 24 NAND en los cuatro biestables y seis puertas para el sumador. El bit 0 cambia siempre, el bit 1 cambia cuando el bit 0 es 1, el bit 2 cuando los bits 1 y 0 son ambos 1, y el bit 3 cuando son 1 los tres inferiores.

Pulsa «Pulso de reloj» y observa el orden. El flanco de reloj llega a los cuatro biestables a la vez, sus salidas cambian dos retardos de puerta después, y las puertas de «más uno» preparan entonces el número siguiente mucho antes del próximo pulso. Como todos los bits cambian en el mismo flanco, se le llama contador síncrono, como el SN74LS161A de TI. Tras 1111 vuelve a 0000. Tras 40 pulsos, contó de 0 a 15 y volvió a empezar sin un solo fallo.

Una UAL con los mismos componentes

La unidad aritmético-lógica de un procesador es el circuito que hace las cuentas. La placa de la UAL de 4 bits muestra la idea con 59 puertas. Para cada bit calcula a la vez cuatro resultados: A + B, A − B, A AND B y A OR B. Dos bits op eligen entonces cuál llega a las salidas, mediante el mismo tipo de selección con AND y OR que el multiplexor. Op 00 suma, 01 resta (con la fila XOR del sumador-restador), 10 es AND y 11 es OR.

Los cuatro resultados se calculan siempre; los bits op solo eligen cuál ves. Así funcionan también las UAL reales, y por eso el camino más largo de la UAL, 13 retardos de puerta aquí, es mayor que el del sumador solo. Prueba 12 AND 10: 1100 y 1010 solo comparten el bit 3, así que el resultado es 1000, que es 8.

Cuánto dura un retardo de puerta

El modelo cuenta retardos; los componentes reales los miden en nanosegundos. Texas Instruments da un retardo típico de 9 ns para sus puertas NAND SN74HC00 a 4,5 V, de 9 a 10 ns para el SN74LS00, más antiguo, y de unos 5 ns para el SN74AC00 a 5 V. Un relé es un millón de veces más lento: la ficha técnica del Omron G5V-1 admite hasta 5 ms para actuar.

Multiplica eso por el camino más largo de la placa. Un sumador de acarreo en serie de 4 bits necesita 9 retardos, así que con puertas tipo 74HC00 se estabiliza en unos 81 ns, lo bastante rápido para doce millones de sumas por segundo. Construido con relés, el mismo sumador necesitaría 45 ms. El laboratorio bajo los controles hace esta cuenta para el circuito que esté en la placa. Un procesador moderno suma números de 64 bits miles de millones de veces por segundo porque sus puertas son miles de veces más rápidas y sus sumadores usan acarreo anticipado, no porque la lógica sea distinta.

Comprueba cada circuito

Cada circuito de la placa se verificó contra su tabla de verdad para todas las entradas posibles. El sumador de 4 bits dio A + B + C0 para las 512 combinaciones y se estabilizó en la respuesta correcta en 9 retardos de puerta tras cada uno de los 262 144 cambios posibles de una entrada a otra. El sumador de 8 bits se comprobó con las 131 072 sumas y 400 000 cambios aleatorios. El sumador de acarreo anticipado se estabilizó en 4 retardos, el sumador-restador en 11, el comparador en 5, el multiplexor y el decodificador en 3, y la UAL en 13 tras cada uno de sus 1 048 576 cambios. Los circuitos de memoria se probaron con secuencias: el cerrojo con activar, mantener y reiniciar; el biestable con reloj y datos aleatorios; el contador con 40 pulsos.

Puedes probar algunos casos en la placa:

• 15 + 1 en el sumador de acarreo en serie: los cuatro acarreos avanzan en cadena y los LED marcan 10000 tras 8 retardos.
• 15 + 1 en el sumador de acarreo anticipado: el mismo resultado tras 4 retardos.
• 5 + 2: ninguna columna acarrea y el resultado 0111 (7) está listo tras 2 retardos.
• 5 − 7 en el sumador-restador: 1110, que es −2.

Diferencias con un chip real

• Todas las puertas tienen el mismo retardo. En la lógica real, un XOR es más lento que un NAND, una puerta que alimenta muchas entradas es más lenta que una que alimenta una sola, y los retardos cambian con la temperatura y la tensión de alimentación.
• Cada cable tarda 0,85 de un retardo de puerta en cruzarse, sea cual sea su longitud. En una placa real, las pistas cortas son prácticamente instantáneas; dentro de un chip, los cables largos pueden ser más lentos que las puertas.
• Las señales son 0 o 1 perfectos. Las tensiones reales suben y bajan durante un breve tiempo, y la placa no tiene ruido, calor ni límites de carga de salida.
• Una puerta por chip. Los chips lógicos reales reúnen cuatro NAND o seis inversores en un solo encapsulado, y necesitan patillas de alimentación, condensadores de desacoplo y resistencias de puesta a nivel alto que la placa omite.
• El transistor del banco de pruebas se dibuja como un único interruptor bipolar, mientras que los recuentos de transistores de los chips corresponden a CMOS.

Del álgebra de Boole a los sumadores de relés

En 1854, George Boole publicó The Laws of Thought, un álgebra en la que los enunciados lógicos se combinan con operaciones muy parecidas a la multiplicación y la suma, y en la que los símbolos 1 y 0 desempeñan un papel especial. Era un libro sobre el razonamiento, no sobre máquinas.

El vínculo con los circuitos llegó en 1937. Claude Shannon, estudiante de máster en el MIT, escribió la tesis A Symbolic Analysis of Relay and Switching Circuits. Demostró que los interruptores en serie y en paralelo siguen las mismas reglas que el álgebra de Boole, de modo que un circuito puede diseñarse y simplificarse con álgebra en lugar de por ensayo y error. En el último capítulo dio varios circuitos de ejemplo, entre ellos un sumador de números binarios. Un artículo basado en la tesis se publicó en las Transactions of the American Institute of Electrical Engineers en 1938 y ganó el Alfred Noble Prize.

Ese mismo año, George Stibitz, científico de Bell Labs, construyó con relés un sumador de demostración. Lo llamó Model K, por la mesa de cocina en la que lo montó. Diez años después, en diciembre de 1947, John Bardeen y Walter Brattain hicieron el primer transistor funcional en Bell Labs, en un grupo dirigido por William Shockley. Los tres compartieron el Premio Nobel de Física de 1956 «por sus investigaciones sobre semiconductores y su descubrimiento del efecto transistor».

De relés a miles de millones de transistores

Los primeros ordenadores grandes usaron los interruptores que tenían a mano. El Z3 de Konrad Zuse, de 1941, usaba 2300 relés; el Harvard Mark 1, terminado en 1944, usaba 3500, mantenidos al compás por un árbol de levas de cincuenta pies de largo. Colossus, en funcionamiento en Bletchley Park desde principios de 1944, conmutaba con 2500 válvulas, y ENIAC, anunciado en la University of Pennsylvania en febrero de 1946, necesitaba 18 000 tubos de vacío y llenaba una sala de 30 por 50 pies (unos 9 por 15 metros). El TX-0 del MIT, de 1956, fue el primer ordenador programable de propósito general construido con transistores, cada uno en una «botella» enchufable para poder cambiarlo como un tubo.

Después, las puertas pasaron al silicio. En 1961, Fairchild anunció uno de los primeros circuitos integrados planares, un biestable con cuatro transistores y cinco resistencias. La serie 7400 de chips lógicos TTL de Texas Instruments, vendida en baratos encapsulados de plástico desde 1966, pronto acaparó más de la mitad del mercado de lógica, y muchas de sus piezas, como el SN7400 con cuatro NAND, se siguen vendiendo hoy. El Apollo Guidance Computer, que voló por primera vez en el Apollo 7 en 1968, estaba construido sobre todo con un único tipo de chip que contenía dos puertas NOR de 3 entradas, varios miles de ellos por ordenador.

En 1965, Gordon Moore predijo que el número de componentes en un chip se duplicaría cada año, y más tarde lo revisó a cada dos años. El Intel 4004 de 1971 puso un procesador completo de 4 bits en un solo chip con 2300 transistores (la cronología del Computer History Museum da 2250). El M1 de Apple, de 2020, tiene 16 mil millones, unos siete millones de veces más, y las GPU Blackwell de NVIDIA, de 2024, tienen 208 mil millones. En todos ellos la aritmética sigue haciéndose con sumadores, multiplexores y biestables como los de esta placa.