__________________________________________________________
El sistema de numeración binaria tiene una función similar a la del decimal, es decir, registrar números. Es conocido como el "lenguaje interno" de los ordenadores, bueno, en realidad es su forma de interpretar números, y dependiendo de dónde coloquemos esos números pasa una cosa u otra. Pero esto no viene al tema, lo que trataremos de explicar es el sistema numérico binario y las operaciones de matemática básica, que están muy relaccionados.
Tenemos que diferenciar entre expresiones numericas binarias y boleanas.
El sistema numerico binario es un sistema de base2, es decir, por cada unidad independiente el valor puede ser o
nulo o "1".
ejemplos:
10 =2 =1*2+0*1
10111 =23 =1*16+0*8+1*4+1*2+1*3
1 =1 =1*1
100 =4 =1*4+0*2+0*1
Una expresión boleana no representa un número, sino una opción que puede ser verdadera o falsa, un número binario se podría entender como una serie de expresiones boleanas separadas en tiempo o posición (de memoria), haciendo split(binario) a boleano().
ejemplos:
1 =si
0 =no
true =si
false =no
+ =si
- =no
y así cualquier otro símbolo que pudiera expresar dos estados diferenciados.
en este texto utilizaremos true/false o 0/1.
La relacción entre binario y boleano es muy clara, porque como he explicado antes, el binario se puede dividir en un montón de expresiónes boleanas. De hecho, las máquinas actuales, a nivel muy muy bajo, de interior del chip, no interpreta el binario porque no puede, sino que utiliza las cadenas boleanas para activar interupciones que desencadenan la trasformación adecuada de los datos. Ésto lo explicaremos a fondo poco a poco.
ejemplo:
la entrada en binario es 1011
1011= true true false true
Para diferenciar entre las diferentes expresiones hay que separarlas o referenciarlas. Les daremos una posición en una matriz y listo.creamos una matriz de 4 valores boleanos: Nb(3) -(si, el cero existe!)
entonces al trasformar el binario a boleano queda así:
split(1011) a Nb(3), que es una matriz boleana
Nb(0)=true=1
Nb(1)=true=1
Nb(2)=false=0
Nb(3)=true=1
y tenemos que entender que esto NO ES UN NÚMERO, sino un monton de interruptores encendidos o apagados. A través de una simple fórmula se puede recuperar el número. Para hacerlo matemáticamente tenemos que interpetar el boleano como una cifra que o es 1 o es 0, para hacerlo algorítmicamente lo interpretamos como verdadero o falso y creamos condiciones:
boleano a binario:
para recuperar el numero binario tenemos que concatenar los boleanos en el órden adecuado,
es por eso que se necesita usar direcciones de memoria, que en nuestro ejemplo son
direcciones de puntero dentro de la matriz:
donde Nt es un numero binario
Nt=Nb(&)
Nt=1&0&1&1=1011
Nt contendrá el número total, es un número en binario, no un boleano:
Cada nb en Nb() se trasforma en un binario de una sola cifra, lo cierto es que no requiere
ninguna trasformación excepto por el trato que le damos:
Recuperaremos el valor en decimal, para entender mejor la diferencia entre interruptores o número.
Nt=Nb(0)+Nb(1)*2+Nb(2)*4+Nb(3)*8
en nuestro caso_ Nt = 1+1*2+0*4+1*8 = 11
Cuando concatenamos dos boleanos dentro de un sólo boleano lo que estámos haciendo es una condición and, que sólo devuelve 1 si las dos entradas son 1:
B1 y B2 son boleanos
donde B1=1 y B2=0, B1&B2=0
donde B1=1 y B2=1, B1&B2=1
Y ahora no nos vamos a meter con el texto, pero si concatenas un char con otro, el resultado es por fuerza un texto.
"a"&"g"&" "&"r"= "ag r" -el resultado está en modo texto.
Hay que aclarar que "casi cualquier cosa" se puede trasformar a una cadena boleana() y recuperarla con el adecuado algoritmo, cuando hagamos esto, llamaremos a esa cadena stream, para entendernos. Por ejemplo, si trasformamos texto a un modo manejable para ser enviado por red crearemos un stream(texto) que es identico a hacer split(texto) a boleano, lo mismo para un número binario o decimal.
Un valor boleano positivo es por definición un interruptor activado. En nuestros ordenadores comúnes se entendería como una puerta lógica cerrada, un microtransistor en estado "excitado", así como un campo magnético en el disco duro, o un agujerito en la superficie de un dvd. Y esque éste es el único lenguaje que entiende la máquina, más allá de lo que nos han enseñado sobre el código binario.
Con combinaciones de puertas lógicas, o colecciones boleanas, se pueden conseguir cosas muy interesantes, por ejemplo:
si tenemos bol(4) es fácil interpretarlo cómo un número binario bin4 de cuatro cifras, lo que se conoce como nibble, esto es porque hacemos esto:
bin4=bol(&) (concatena todo en orden)
y si usamos el sistema explicado anteriormente:
creamos un decimal vacío de dos cifras: Dec2
split(bin4) -trasformamos bin4 en matriz dimensional
por cada puntero en bin4() hacemos:
Dec2=Bin4*(puntero) -el valor máximo de Dec2 es 99, el de Bin4() en binario es 15, así que el valor cabe en el casillero.
de esta forma, la primera pasada, el puntero es 0, y nos da el valor de unos, el segundo el puntero es 1, nos da el numero de doses y así sucesivamente.
Bien, precioso, pero es todo matemática, ¿no?. Bueno, en realidad es mucho más. Es electrónica e informática, teoria de la información y comunicaciones en parte. Me explico. Si un valor que puede ser uno o cero es tambien un acumulador de memoria de un bit, es decir, unidad mínima del chip de memoria, entonces para crear un chip que pueda memorizar un número de 0 a 15 lo que hay que hacer es colocar cuatro de éstos y diferenciarlos independientemente de algún modo. Ésto lo simplificamos así:
bin4 es el número que vamos a meter en los cuatro transistores estáticos, un binario de 4 cifras.
Chip(4) representa una matriz de valores boleanos, que es lo unico que entiende un chip.
bin4=bol(&)
Y en este caso la dirección de la memoria del dato la representamos con el puntero de bol().
Hay que entender que aunque parezca muy teórico no lo és, es una simplificación de algo que depende de muchas más cosas, como el voltage interno del chip, las resistencias, ruido electromagnético etc y lo encapsulamos en fórmulas matemáticas. bin4=bol(&) representa un comportamiento de un chip, que si le mandas un numero binario de cuatro cifras, en un lenguaje que él entienda, lo romperá y meterá cada uno o cero en un casillero adecuado.
¿Y porque cuatro? en realidad nada es al azar, si recordamos el ejemplo del ábaco, el interface es algo importantísimo, y
en este caso hablamos de un interface que no está dirigido al usuario final, sino al desarrollador de máquinas. Si utilizamos
cuatro cifras binarias, podremos determinar un número de 0 a 15, lo cual es un número redondo, si, es redondo en hexadecimal:
0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f
esta es la base del sistema hexadecimal, y si cuentas el número de cifras verás que te da 16, de 0 a 15 son 16 posibilidades,
es un interface perfecto para guardar tambien un número hexadecimal. ¿y la pérdida de memoria por el interface? Si, tambien
la hay, aunque no es mucha, me explico:
si creamos un número hexadecimal de una cifra Hex1
y tenemos una memoria vacía de un nibble Chip(4) -las memorias se entienden en modo boleano, un nibble=cuatro cifras binarias
Hex1=ch -que significa 12, la h es para saber que es hexadecimal. en binario es 1100, como vemos son cuatro cifras, esto es, un nibble.
vemos que el hexadecimal cabe en la memoria, porque en cuatro bits caben 16 opciones, pero, si el ejemplo es menor de 8:
Hex1=5h -el valor es 5, que en binario es 101, tres cifras. Pero al pasar el valor a boleano se crea un bit de basura. en este caso:
stream(Hex1) a Hex1() -pasamos Hex1 a una memoria boleana, stream es para trasformarlo de hex a boleano.
-si vemos los cuatro primeros valores de hex1 en boleano:
Hex1(0)=1
Hex1(1)=0
Hex1(2)=1
Hex1(3)=0
La última posición no afecta al resultado en binario, solo existe en boleano y =false, porque no
necesita tantas cifras, y ésta es exáctamente la pérdida de memoria que se acarrea del uso de
notación hexadecimal. Se puede decir que son dos sistemas que encajan muy bien, porque sus
múltiplos son comúnes en muchas ocasiones. A pesar de que al guardar 1h estémos desperdiciando
tres veces la memoria usada, es una pérdida muy aceptable a favor de la propia interface de los
chips. El sistema hexadecimal es muy usado en punteros de memoria por ésta misma causa.
Las puertas lógicas trabajan sobre los datos boleanos, digamos que son ellas las que hacen:
stream(Hex1) Hex1()
que en realidad se trata de un direccionamiento de posición, es como hacer en asm de x86:
[es aproximado] */si tienes windows puedes probar esto en debug.exe, ejecutar debug.exe/*
worda=[numerohex]
mov worda,0100h
Lo cual situaría el valor numerohex a la posición 0100h de la memoria. Como hex es una única cifra
en hexadecimal pues ocupará una única casilla hexadecimal a partir de 0100h, es decir, un solo nibble:
creamos MEM(ffffh) -que representa la memoria de nuestro programa en nivel bajo. es una memoria, por
lo tanto es una matriz boleana de dimensión ffffh es una matriz enorme,
así que tenemos memoria de sobra. creamos entrada que es el número
hexadecimal que vamos a almacenar.
stream (entrada()) a entradab() -pasamos a boleano a través de un stream a toda la memoria.
trim (entradab()) -eliminamos todos los caracteres que nos sobran.
MEM(0100h)=entradab() -y guardamos el dato en la posición 0100h, como hicímos en assembler.
No hay comentarios:
Publicar un comentario