_____________________________________________________
Teniendo presente todo lo anterior se pueden crear algoritmos lineales, que empiezan en un punto, hacen un número de
operaciones y terminan. Ésto es muy útil, pero en realidad necesitamos más cosas para poder procesar todo lo necesario
de forma adecuada. Algo muy importante en éste aspecto es, por ejemplo, las expresiones condicionales, bucles,
interrupciones, negaciones etc
Pero recordemos nuestro punto de vista respecto a la programación, desglobando cada problema desde su base damos con
los responsables físicos de todos éstos comportamientos. Las puertas lógicas. Una puerta lógica es un elemento, normalmente
electrónico que tiene una o dos entradas y una salida normalmente. A las entradas puede llegar un cierto voltage que
interpretaremos como un true o false boleano, y la salida puede emitir un valor boleano que dependerá de las entradas, es decir:
in ----|>
|>>
|>>>>---- out (dependiendo de los dos in)
|>>
in ----|>
in ----|>------ out (dependiendo de in)
Entonces, algunos tienen un in y un out, lo que significa que crea un dato que dependerá de la entrada y lo envía en
out, sin embargo, otros tipos trasforman dos boleanos en uno, dependiendo de las entradas. vamos a explicarlo paso
a paso para el que no sepa mucho de lógica electrónica. Veamos que tipos hay y para que sirven.
Usaremos un sistema muy común para representar los comportamientos de las puertas lógicas, la tabla de verdad.
Si no sabes como funciona, tranquilo, porque es más simple que rascarse la naríz. Se trata de una taba en la
que ponemos las dos entradas y la salida de la puerta logica de esta forma:
ejemplo:la tabla de verdad de una puerta XOR es:
entrada+entrada=salida
1+1=0
1+0=1
0+1=1
0+0=0
recuerda que usamos + pero no el matemático, es un simbolo que significa "con esto y esto es igual a esto" o sea:
con un uno y un uno es igual a cero.
o tambien se puede expresar a través del tipo de puerta, o sea:
1 XOR 1 = 0
esto significa
true o (exclusivo) true es igual false?; o, uno, cero. ¿está activado sólo uno de los dos? respuesta= no (cero)
Por lo tanto la tabla de verdad es algo parecido a recorrer todas las posibilidades que nos dá una puerta lógica según sus entradas, guardando sus salidas.
los tipos básicos son estos
puerta YES: La puerta yes tiene una entrada, y siempre devuelve el mismo valor que entra. Existe principalmente
como amplificador electrónico, así que no afectará en los algoritmos directamente, sino únicamente
en la capa física. Éstas puertas lógicas se las dejamos a los ingenieros electrónicos.
in -----|>----- out = in
tabla de verdad:
1=1
0=0
puerta NOT: Esta puerta lo que hace es devolver el inverso boleano de la entrada. O sea, el negativo del valor, si
tenemos uno da cero y si tenemos cero da uno.
in -----|>----- out = NOT in
tabla de verdad:
1=0
0=1
puerta AND: Interesante, ya que devuelve un uno cuando las dos entradas son verdaderas, o sea, que sirve para comparar
dos valores boleanos y dice true solo si las dos son true. Ok, ésto es básico en programación general,
ya que como bien dice el título de éste tema, trataremos las condiciones, es decir, haremos que nuestros
sistemas tengan capacidad para elegir una u otra acción. Y ésto se hace, ni más ni menos que con
puertas lógicas combinadas. Se explicará luego, pero tienes que entender las puertas de más de una
entrada, si hace falta lee en internet, en alguna enciclopedia, libros de electrónica... en serio.
inA -----|>
|>>--- out = inA AND inB
inB -----|>
De esta tenemos que hablar más ya que es una pieza clave como vengo diciendo. Un electricista se
habría percatado de que la tabla de verdad de ésta puerta lógica equivale a un circuito simple
con dos interruptores en serie. Exacto, de hecho éso mismo son las puertas lógicas, y por eso mismo
llamamos interruptor a una cifra boleana, y no número. veamos el esquema de otra forma:
inA inB
____ ____
true -----: :--------: :----- out = inA AND inB
-en este esquema in significa bajar el interruptor. Entonces tenemos un true continuo, lo que
viene a ser una fuente de energía, y el cable está cortado por dos interruptores
convencionales. En out sólo tendremos ésa energía si pulsamos los dos interruptores al
mismo tiempo, pulsar uno independientemente es inútil. Posiblemente un electricista lo
vea así más claro, pero exísten relacciones matemáticas y algorítmicas, que son las que
aprobecharemos.
tabla de verdad: -bien, tiene dos entradas boleanas, medio nibble. Asi que tenemos cuatro opciones.
1+1=1
1+0=0
0+1=0
0+0=0
Y como buscamos la relacción matemática pues interpretamos las dos entradas como medio nibble:
3=1
2=0 -o sea, nos indica si el resultado, en este caso 11 (3 dec), no cabe en un solo bit... interesante.
1=0
0=0
Visto así, parece que tiene menos sentido, pero es en realidad, lo que hace el ordenador según nuestra
interpretación, y expresado en decimal. la salida siempre será uno o cero, ya que tiene una cifra binaria.
puerta OR: Una puerta OR u "o", realiza lo que se llama "suma lógica", que es algo distinta de una suma numérica.
Tengamos en cuenta que estamos tratando con valores boleanos, así que SOLO PODEMOS USAR UNA CIFRA
para los cálculos, y ésta sólo puede ser uno o cero. Así que 1+1=1, el dos no existe, no tiene
sentido hablar de otra cifra que no sea uno o cero. Para verlo mejor, true mas true es true. Asi
mejor, ¿no? porque en realidad no son números, sino trues y falses, si o no.
inA -----|>
|>>--- out = inA OR inB
inB -----|>
Otra vez el electricista entenderá bien el siguiente ejemplo, supongamos que tenemos una entrada
de corriente y dos interruptores en paralelo. Si pulsamos cualquiera de los dos, pues la bombilla
se enciende, lo que significa True. Si pulsamos los dos a la vez pues tambien se enciende, y
unicamente cuando se deja todo apagado recibimos un cero, o sea, oscuridad, éste es el funcionamiento
de la puerta or.
La tabla de verdad:
1+1=1
1+0=1
0+1=1
0+0=0
Y lo interpretamos en números:
3=1
2=1
1=1 -vaya, éste nos indica cuando el resultado es mayor a 0.
0=0
Y hay muchos más tipos de puertas lógicas, pero precisamente se deducen a partir de éstos. Por ejemplo, para que una puerta lógica tenga ésta tabla de verdad:
1+1=1
1+0=0 -que nos indica cuando los dos valores son iguales.
0+1=0
0+0=1
Tendríamos que conectar en paralelo cada entrada a una puerta AND y una OR. Éste tipo de puertas se llama XNOR, la x indica "exclusivo", la n NOT y su comportamiento se deduce de la OR. Es decir: AND-NOT-OR exclusivo... Pero le llamaremos XNOR.
Si un circuito en paralelo hemos dicho que es una puerta OR y queremos conectar una AND y una OR en paralelo hacemos:
-Llamamos bit1 y bit2 a las dos entradas.
XNOR=(bit1 AND bit2) OR NOT(bit1 OR bit2)
Entonces podemos deducir la tabla de verdad XNOR con estas relacciones:
(1 AND 1) OR NOT(1 OR 1)= XNOR(1+1)
(1 AND 0) OR NOT(1 OR 0)= XNOR(1+0)
(0 AND 1) OR NOT(0 OR 1)= XNOR(0+1)
(0 AND 0) OR NOT(0 OR 0)= XNOR(0+0)
Y ya tenemos un nuevo tipo de puerta lógica creada de forma matemática a partir de otras más simples. Lo que tiene que quedar claro es que cualquier tipo de puerta lógica puede combinarse dando lugar a otros tipos, por ejemplo tipos con más entradas, así como más salidas. Al final todo lo que hay en un chip para un programador son puertas lógicas y memorias. Vamos a aplicar la fórmula anterior para comprobar que funciona.
la tabla de verdad XNOR dice lo siguiente:
0+0=1
entonces si (0 XOR 0) = (0 AND 0) OR (NOT(0 OR 0))
paso por paso:
(0 AND 0)= 0 -Calculamos cada paréntesis.
(NOT(0 OR 0))= (NOT 0) -ok, los dos dan cero. Pero tenemos otro paréntesis aún.
(NOT 0) = 1 -la segunda salida. perfecto. usaremos ésta y la del primer parentesis como entradas.
para el último OR así que:
0 OR 1 = 1 -funciona-
Una puerta XNOR se puede entender como:
-es una puerta lógica de tres patillas, dos entradas y una salida.
-tiene dos pistas en paralelo. (por el OR de enmedio)
-la primera pista pasa por una puerta AND, y de ahí a la salida. (bit1 AND bit2)
-la segunda pista pasa por una puerta OR, y luego por una NOT y va a la salida. NOT(bit1 OR bit2)
Por lo tanto, (AND)OR NOT(OR) es más que una fórmula, bién leído es un mapa de puertas lógicas. Yo lo he dibujado y tiene lógica.
Espero que éste método de expresión ayude a entender un aparato de una forma distinta, ya que podemos
expresar su arquitectura interna a través de un lenguaje bastante matemático. Bueno, las operaciones de este tipo se llaman operaciones lógicas, y como ya sabes no maneja cifras, sino condiciones, verdaderas o falsas. La matemática de objetos boleanos se denomina Álgebra de boole y es en si misma la base donde se sostiene todo el sofware y las decisiones de diseño de los aparatos.
El álgebra de boole recibe el nombre de su inventor, un matemático llamado George Boole. Se le considera como uno de los fundadores del campo cientifico de la computación. Ten en cuenta que Boole murio en 1815, es decir, no llegó a conocer las computadoras y sin embargo, a través de su álgebra aprendió a simplificar y resolver problemas lógicos y filosóficos con los primeros algoritmos de nivel bajo, escritos y resueltos a papel y lápiz.
Y esque lo que Boole buscaba no era para nada dotar de capacidades aritméticas a las máquinas, sino un lenguaje algebráico a través del cual pudiera expresar problemas de lógica, no de números. Boole creó una matemática especial a través de la cual, hoy día podemos comunicarnos con las máquinas de una manera adecuada para un sistema informático. Lo que diseño boole es algo muy extenso y preciso, como matématica que es. Digamos que nosotros lo aprenderemos de una forma diferente, pero sabiendo que lo que hacemos, en todo momento, es expresable en álgebra de boole así como en hardware puro (el ejemplo de las bombillas y los interruptores, por ejemplo). El álgebra de boole, nosotros lo expresaremos a través de los efectos de los datos sobre una puerta lógica, es decir (1 OR 0) es pasar por una puerta OR un 1 y un 0, lo cual vale 1, o true.
¿Para que aprendemos todo esto? Pues para aprender de nuevo a sumar:
Bueno, ya has visto que podemos transformar boleano en diferentes cosas, por ejemplo, si lo interpretamos como binario y realizamos una suma... Espera, un binario es un monton de boleanos, y los boleanos no se pueden sumar aritméticamente. Claro, solo podemos hacer operaciones boleanas, lo que es lo mismo, transformaciones a través de puertas lógicas... o sea, tenemos que diseñar un circuito electrónico que sea capáz de sumar... Tranquilo, suelta el soldador, que lo haremos matemáticamente. Es importante tener una memoria donde se guarde el número final, y necesitamos dos entradas de un numeros
binarios.
Usaremos cuatro cifras binarias de entrada, que es un número hexadecimal de una cifra.
Son ocho entradas y cinco salidas para que nos quepa el resultado final si sumamos 16+15=31, que en binario es la quinta cifra.
creamos IN1(4), IN2(4) y OUT(4) como colecciones boleanas. Son dos entradas y una memoria o salida.
Creamos AC como boleano. tambien un boleano simple llamado AC
para sumar hay que trabajar en cada In1 e In2 en IN1() e IN2(), pero no vamos a usar un bucle, porque es pronto, así que lo haremos de forma absoluta. Es decir, un chip que suma dos números hexadecimales de una cifra y devuelve la suma en binario porque sí, porque está diseñado para responder así, no hay condiciones ni funciones ni repeticiones. Es algo parecido a una pequeña parte de un coprocesador, que ya explicaremos
qué es.
entonces, siempre haremos esto:
OUT(0)=(IN1(0) XNOR IN2(0)) -metemos en out un nor exclusivo de las primeras cifras.
así sólo dará uno si una u otra está activada, pero no si lo están las dos.
AC= (IN1(0) AND IN1(0)) -AC guarda un and, si están las dos éste es true. És lo que llamaremos el
"acarreo", igual que en matemática clasica, nos llevamos una, esta se usará luego
OUT(1)=(AC XNOR (IN1(1) XNOR IN2(1))- Calculamos el xnor, y hacemos otro xnor comparando con AC, la que nos llevamos.
AC= (IN1(1) AND IN1(1)) - Guardamos el acarreo, y ya repetiremos hasta el final lo mismo.
OUT(2)=(AC XNOR (IN1(2) XNOR IN2(2))-Calculamos xnor y xnor con el acarreo
AC= (IN1(2) AND IN1(2)) -Guardamos el acarreo dentro de AC
OUT(3)=(AC XNOR (IN1(3) XNOR IN2(3))-Calculamos xnor y xnor con el acarreo
AC= (IN1(3) AND IN1(3)) -Guardamos el acarreo dentro de AC
OUT(4)=(AC XNOR (IN1(4) XNOR IN2(4))-Calculamos xnor y xnor con el acarreo
AC= (IN1(4) AND IN1(4)) -Guardamos el acarreo dentro de AC
OUT(5)=(AC) -La ultima cifra corresponde al último acarreo solo
Y tenemos un algoritmo en el más básico de los niveles que podemos elegir. Puedes darles valores a las entradas y calcular cómo funciona. La tabla de verdad de ésta circuitería es enorme, y correspondería en decimal a 1+1=2, 1+2=3, 1+3=4, y así hasta el número máximo de combinaciones que podemos lograr, en binario usando cinco cifras el valor máximo de respuesta es 31. Éste pequeño chip o pequeño programa en ensamblador, o pequeño circuito eléctrico es una calculadora que sólo sabe sumar números en binario, ya con ésto podrías construirla, si le añades entradas y salidas (botones, leds, pantalla...). Pero podría ser otra cosa tambien, una Funcion. Las funciones son grupos de acciónes que normalmente devuelven un valor. Se usan en casi todos los lenguajes que no correspondan al nivel bajo, y algunos que si. Cuando mandamos sumar a una máquina, ésta hace lo que has visto arriba con las cadenas boleanas (que son numeros sin interpretar). O sea, ¿Para que construir la máquina si tenemos un ordenador que puede ser entrada y salida a la vez? ademas, un ordenador tiene un conjunto de interfaces muy bien diseñados, como por ejemplo los sistemas operativos, consolas de comandos o lenguajes de programación.
Con la fórmula anterior podemos sumar... puede que prefieras el método clásico para hacerlo, pero la máquina no, ella siempre suma de ese modo, y por eso es bueno saber que lo hace así. Y hay que entender que se puede hacer de diferentes formas, ya que XNOR= NOT XOR Y XOR= OR OR AND. Se que parece complicado verlo a primera vista, pero todo tiene una lógica tan bien estructurada que al final se entiende por su propio peso. el algoritmo anterior, expresado matemáticamente sería tan solo:
creamos IN14, IN24 y OUT5 como numeros binarios. Son dos entradas y una memoria o salida.
OUT5 = IN14 + IN24
Vaya parece más simple... Claro, el poder procesar los datos así automáticamente es tambien resultado del diseño de interfaces manejables. Los viejos ordenadores que usaban targetas perforadas, sólo entendían entradas en boleano y respondían con ellas. Podía resultar complicado en aquel momento procesar una simple suma, ya que tendrían que recurrir a sistemas parecidos al expuesto arriba. En realidad, tenemos que entender cualquier operacion matemática como una función de nivel bajo, o físico que produce un resultado. Así seremos conscientes de que lo que escribimos en un código fuente NO es lo que procesa el ordenador exáctamente. El problema que tenemos para entender esto surge de que nosotros sumamos "casi automáticamente", parece como si no tuvieramos consciencia de cómo sacamos el resultado, pero sale, y no analizamos paso por paso el problema, porque no nos hace falta.
Desglobar un problema es la manera de entenderlo, y la mejor manera es reduciendolo al menor número de símbolos, lo cual produce una mayor cantidad de pequeños pasos. En el caso de la suma, hay una forma de automatizar el proceso, que consiste en realizar la misma acción en cada línea. Entonces podemos decir que:
Donde pun indica el puntero en el que realizamos la acción, es decir, la posición de la cifra que queremos calcular.
OUT(pun)=((IN1(pun-1) AND IN2(pun-1)) XNOR (IN1(pun)XNOR IN2(pun))
Así que cada vez que sumes un número recuerda: ((IN1(pun-1) AND IN2(pun-1)) XNOR (IN1(pun)XNOR IN2(pun))=
Pero es un algoritmo no diseñado aún para estar dentro de un chip de memoria, sino que utilizamos matrices virtuales. En un caso real no sería buena idea usar un chip de memoria para cada número, sino darles una dirección en la matriz principal, que será toda la memoria del programa. Es decir, que podemos diseñar nuestra placa de tal forma que todos los números se encuentran en el mismo chip de memoria, a parte necesitamos las mismas puertas lógicas, pero no son muchas. Ésta forma de escribir un algoritmo lineal con puertas lógicas nos permite entender por un lado cómo suma realmente una máquina, pero además es un mapa de un circuito de puertas lógicas, sólamente hay que saber descifrarlo paso por paso.
Para hacer un plano de puertas lógicas:
(entrada1 OR entrada2)=salida1. -significa:
tenemos una puerta OR conectado a dos entradas, entrada1 y entrada2 y a una salida que se llama salida1. Parece un órden extraño, pero míralo de otra forma. Cuando veas una puerta lógica, en este caso OR, el elemento de antes y de despues son las dos patillas de entrada, y el iguala de despues del parentesis es la salida (o sea, que decimos dónde va a parar el dato). Si tenemos un parentesis doble, por ejemplo: (in1 OR (in1 AND in2)) empezaremos siempre por lo de dentro de los paréntesis, o sea, (in1 AND in2) que significa una puerta AND con entradas conectadas a in1 e in2. (in1 OR ...) Pueden ser dos cosas, una puerta or, que por un lado tiene conectado in1 y por otro la salida de la puerta AND de antes (in1 AND in2). O si no se puede entender como el modo en que se conecta el circuito: AND=serie, OR=paralelo. Así que podemos decir que in1 va directo a la salida y además está en paralelo con una puerta lógica que tiene de entrada in1 e in2. El comportamiento de las dos placas es el mismo exáctamente. El mapa codificado no define si vamos a usar una puerta lógica o una estructura de pistas, porque es "virtualmente" lo mismo. En este caso no salen, pero cuando una puerta lógica sólo tiene una entrada, se pone primero la puerta y luego la entrada, es decir: (NOT in1)= y la salida es por el =. Ahora veamos otro ejemplo de placa:
(bus1 OR (bus5 AND (NOT bus7)))
tenemos una puerta OR conectada con dos entradas, una es bus1 y otra es la salida de una puerta and, que tiene dos entradas, bus5 y una puerta not conectada a bus7, en este caso no hay salida porque no existe el =. Esto tiene un par de consecuencias, atemáticamente es una expresión que no se guarda en ningún sitio, podria servir como sentencia, que ya explicaremos lo que significa, y por otro lado, físicamente podemos decir que se trata de un circuito sin acabar, o que tiene una salida desconectada, además podemos afirmar que la salida desconectada es la de la puerta OR. Y todos éstos datos están
en (bus1 OR (bus5 AND (NOT bus7))), pero hace falta pensar sobre ello un buen rato.
Así que, combinando memorias, numeración binaria y álgebra de boole conseguimos... Un Ordenador. Cualquier expresión que pudieramos escribir en su forma de fórmula con puertas lógicas es computable con un ordenador común, lo que normalmente se llama touring completo. Tambien se pueden añadir memorias a nuestro mapa-fórmula, definiendolas como boleanos, o matrices boleanas; usamos un boleano para indicar un solo bit, o un interruptor, y una matriz para indicar una memoria en el mismo chip, o un bus con varios bits boleanos de ancho de banda, es decir, varios bits de entradas que forman parte de lo mismo. Si diseñamos un programa es lo mismo, solo que la placa de memoria que usamos, es el trocito que el sistema operativo nos asigne. Su tamaño dependerá de los requisitos del propio lenguaje, o sus propias convenciones.
Sabiendo ésto nos queda otra pieza clave, más que nada una pieza algorítmica, o lo que se llama de "flujo del programa", se trata de los saltos de línea. A través de complejos diseños de puertas lógicas y/o de funciones se consigue indicar a un programa, que "salte" hasta donde le indicamos, dando igual que dicho punto se encuentre arriba o abajo en el código, ya que ésto sólamente significa alante o atras en la memoria ram, o pun>label o pun
Trata de imaginar uno de esos libros de "elige tu aventura", de esos que dicen "salta a la página 23 para matar al mono" o "salta a la pagina 12 para empezar a programar". Pues la idea básica de estos libros es la misma que la de un programa de nivel medio o alto. Lo que hace es:
1- poner el programa entero en la ram (incluyendo los números o char que creemos)
2- comenzar a leer por el "cuerpo" del programa, linea a linea hacia abajo
3- de vez en cuando hay un "goto siguiente" o "goto fin" que quiere decir ve a siguiente, o ve a fin.
4- todos los programas son finitos, como los libros, así que despues de saltar alante y atras siempre encuentra una salida y fin.
El sistema con el que lo vamos a explicar es el mismo que usan el quickbasic y el visual basic. Ya que acostumbrandote a visualbasic podrás diseñar programas de muy alto nivel capaces de aprobechar tu sistema operativo así como tus capacidades de conexión a periféricos. Un lenguaje muy documentado, del que encontrarás comunidades y ejemplos en internet, y con un sistema de ayuda para principiantes que te enseñará mejor que cualquier universidad. Para saltar a una línea lo que tenemos que hacer es goto [label] y tiene que existir en el programa un punto que se llame label:. Por supuesto cambias label por la etiqueta que mejor te venga.
ejemplos:
creamos num1 y num2 como numeros hex -tenemos dos nibbles, y cada uno de ellos es un número.
num1=1h -aquí num1 vale 1h, y num2, como no tiene valor "null", que significa nada.
goto fin -decimos salta a la etiqueta fin.
num1=fh -aqui num1 debería de cambiar a fh
num2=dh -aquí num2 debería de cambiar a dh
fin: -esta es la etiqueta fin. goto fin significa venir hasta aquí y procesar hacia abajo.
exit
Y nuestro programa ha terminado, ahora si miramos qué hay dentro de num1 y num2:
num1=1h
num2=null
Porque ha saltado los pasos num1=fh y num2=dh cuando se ha dicho goto fin. Fin podría tener cualquier nombre, pero el exit del final significa que el programa ahi termina, es una palabra reservada, como goto, o creamos. O sea, a partir de ahora, cuando escribamos un codigo con fin, éste se llamará exit. Conociendo los saltos goto, que son algo simple, podemos conectar ésta pequeña placa a otras puertas lógicas. Hay una muy interesante, que es una combinación compleja que usa los saltos de línea, ésta es la condición if:
If significa "si" condicional, no de afirmación. Es muy simple, una puerta lógica de una sola entrada y dos o tres salidas, que están conectadas a saltos de línea. Como es una puerta lógica que solo tiene una entrada, se escribe antes que su entrada. La entrada de una puerta if se llama sentencia, y se trata siempre como conectada a la entrada de if, aunque se tenga un igual a "=", ya que entonces significa comparar, y si son identicas pues manda true. O sea, el iguala sería otra puerta lógica que compara. Un ejemplo sería este:
If (Ent1 AND Ent2) -que significa: una puerta if conectada a una AND que tiene dos entradas, ent1 y ent2 nos devuelve true.
Pero if a su vez tiene salidas, unas salidas que no vemos, y van a saltos de línea. Las salidas hacen saltar a diferentes puntos, puede haber
hasta tres puntos:
if (Ent1 AND Ent2) then -then es la primera salida. si (Ent1 AND Ent2)=true pues salta hasta then. despues de cargar then, salta hasta end if
else -la segunda salida, else, en inglés "si no". salta hasta aquí si (Ent1 AND Ent2)=false. Pero else es opcional, si no está va a end if.
end if -esta es la última salida. Todos los caminos acaban saltando hasta aquí si no se dice lo contrario con otro salto.
se puede hacer tambien así:
if (Ent1) then -significa, si ent1 tiene un bit boleano en true salta a then.
end if -como no hay else, si ent1 no tiene un bit boleano salta hasta end if.
o así:
if (txt3 = txt2) then -lo cual significa que tenemos una puerta AND combinada, a la que llamaremos "=" y devuelve true si las dos entradas son totalmente
idénticas.
end if
y los símbolos =, >, <, <>, se consideran puertas lógicas complejas, que comparan números, y devuelven sólo un uno o un cero si..:
= - si las dos entradas son iguales. Funciona con texto también.
> - si la primera es mayor que la segunda
< - si la primera es menor que la segunda
<> - si son distintas es lo mismo que NOT =. Funciona con texto también.
Es decir, que son puertas lógicas de ancho de banda aparentemente indeterminado, y sólo da uno si se cumple la norma definida en todas las cifras boleanas de
entrada. Son circuiterías muy complicadas, pero muy básicas y eficientes. Ahora podemos hacer sentencias, o sea, entradas if como éstas:
if ((5 > int1*2) AND ( NOT(hex1 = hex2) )) -lo cual significa: devuelve true si cinco es mayor que int1*2 y hex1 no es igual que hex2.
-es una placa con infinidad de puertas lógicas de las básicas, además aun deberíamos de situar los puntos de salto...
end if
O sea, que podemos construir sentencias muy muy complejas para que nuestro programa sea "inteligente". Como if son puertas lógicas, se pueden combinar para dar lugar a otras, como el switch o select case, o la etiqueta elseif, ahora no los explicaré, pero verás que símplemente nos ahorran trabajo a la hora de escribir, podríamos diseñarlos a partir de if, o incluso a partir de saltos de línea en ocasiones. Como te irás dando cuenta, unas cosas se apollan en las anteriores, y nos permiten hacer cosas cada vez más complejas. Es lo que se conoce en ciencias de la información como estructura por capas. En cada capa que subes, lo que puedes hacer es más abstracto, así que al final acabas programando ventanitas y fotos con pocas líneas de texto, apollandote en todo lo que queda por debajo, incluyendo al sistema operativo, los intérpretes, interrupciones de sistema, niveles de prioridad, todo tipo de librerías que ya existen y no vamos a rehacer etc etc etc.
Bueno, poco a poco subiremos al nivel alto, pero poco a poco, porque si no, no entenderemos nada de lo que hacemos. Aprender desde abajo es mejor que aprender lo de arriba, que es la punta del iceberg y tratar de desentrañar qué es lo que todo eso significa para la máquina. No tiene sentido. Además, el nivel alto tiene muchísimas funcionalidades, clases, y procedimientos, y el bajo tiene las cuatro cosas en las que todo esto se apolla.
