PSeInt - Variables como lógico

 Un lógico es la asignacion de valores verdadero o falso a una variable. Con estas podemos definir límites, entradas de acceso, puntos de referencia, etc.

 Simplificando
 Tenemos una variable y la definimos como lógico.
 Al definir una variable "como lógico" esta solo podrá tomar dos valores: verdadero o falso.
 (Imaginemos que si el valor fuera falso, procesos se podrían detener, eliminar, cambiar, etc. Siendo posible que esta variable lógica sea utilizada de varias formas.)
  Teniendo esta variable lógica, podemos usarla como punto de referencia o acceso para datos.
//(Es decir, podemos usarlo como una condición para proseguir con una determinada acción, función, o  sección de código, por ejemplo: Un juego. Si tu nivel es superior a 9000 entonces a "misionesSecretas" se le asignara el valor "Verdadero" (*) y podrás realizar las misiones secretas. Mientras seas nivel inferior a 9000 (~(OVER 9000)) "misionesSecretas" se mantendra en "falso" y no podras realizarlas).

Ejemplo en PSeInt de un programa con uso de variables lógicos.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Proceso Respirando
    Definir respirar Como Logico;
    Definir condicionalRespirar Como Caracter;
    //
    respirar<-Verdadero;
    condicionalRespirar<-"";
    //
    Repetir
        Escribir "Inhalando";
        Esperar Tecla;
        Escribir "Exhalando";
        Esperar Tecla;
        Escribir "Desea parar de respirar? Para parar de respirar, ingrese cualquier caracter a excepción de 0.";
        Leer condicionalRespirar;
        Si condicionalRespirar <> "" Entonces
            respirar<-falso;
        FinSi
    Hasta que respirar = Falso;
  
    Repetir
        Escribir "Me ahogo...";
        Esperar Tecla;
        Escribir "Desea respirar? Para respirar, ingrese cualquier caracter a excepción de 0.";
        Leer condicionalRespirar;
        Si condicionalRespirar <> "" Entonces
            respirar<-verdadero;
            Escribir "respirando";
        FinSi
    Hasta que respirar = verdadero
  
FinProceso
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 A pesar de que el ejemplo no tenga un ciclo para seguir preguntando ssi deseamos parar o no de respirar, se puede apreciar la función de las variables lógicas.
 Al ejecutar el programa, este nos mostrará:

*** Ejecucion Iniciada. ***
Inhalando
Exhalando
Desea parar de respirar? Para parar de respirar, ingrese cualquier caracter a ex
cepción de 0.
>
Inhalando
Exhalando
Desea parar de respirar? Para parar de respirar, ingrese cualquier caracter a ex
cepción de 0.
> a
Me ahogo...
Desea respirar? Para respirar, ingrese cualquier caracter a excepción de 0.
>
Me ahogo...
Desea respirar? Para respirar, ingrese cualquier caracter a excepción de 0.
> a
Respirando

*** Ejecucion Finalizada. ***


(*) : Explicación de cómo"misionesSecretas<-verdadero" se podría aplicar en PSeInt.
(Si nivel>9000 Entonces misionesSecretas<-Verdadero. FinSi //// Si misionesSecretas=Verdadero Entonces <mostrar lista de misiones secretas> FinSi ( <mostrar lista de misiones secretas> = forma de explicar que hay más pseudocodigo dentro de este--> imaginese un codigo con muchos "Escribir", "Si" y más "Logico"/s incluidos)).



**********************************************************************************************************************
**********************************************************************************************************************

********************************************************************************************************************** **********************************************************************************************************************
 Si aún tienes dudas de "para qué" o "porqué" existe esta función, daremos un ejemplo mas amplio, pero no aplicable en PSeInt. En el siguiente ejemplo nos abstraeremos un poco, intenta relacionar :
Paradigma Orientado a Objetos, Soporte en Software y Programación de Algoritmos.
(intenta relacionarlos como sea, si no puedes razonar correctamente, solo sigue leyendo.)

**********************************************************************************************************************
**********************************************************************************************************************

 Sigamos con el ejemplo de respirar.

 Donde usamos esta clase? En el objeto cuerpo. // (Intenta distribuir los objetos del cuerpo en dominios, y éstos distribuirlos en distintas clases.)
 El objeto cuerpo necesita "recursos de sistema", como alimento, oxígeno y agua. // (Como organizaríamos el proceso cerebral de despertarnos? Intenta crear algo con byte, boolean, if, while, do while, go to, abstract, void, public, protected, ptivate, etc.)

 En el proceso de respirar, si es que este está funcionando, se activan y desactivan otros procesos, como inhalar y exhalar (que como ya sabemos, no podemos hacer al mismo tiempo). Y dentro de estos ocurren otros procesos, como por ejemplo en la sangre (distribución de oxigeno).

Intentemos escribir vágamente en pseudocódigo lo que creamos que debería pasar para cuando "respirar" esté asignado como "Verdadero".
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Proceso ejemploLogicos
//
//Para ahorrar tiempo, en vez de anteponer "proceso"/"rutaAbierta"/"rutaNoObstruída"/ //"funcionalidad" u otra función específica de los objetos, los encerramos en "<>", quedando como //"<objeto>".
//
Definir <víasNasales>, <faringe>, <traquea>,, <traquea>, <bronquio>, <pulónDerecho>, <pulónDerecho>, <pulónDerecho>, <pulónDerecho>, <pulmonIzquierdo>, <pulmonIzquierdo>, <pulmonIzquierdo>, <pulmonIzquierdo>, <respirar>, <inhalar>, <inhalar>, <inhalar>, <exhalar>, <exhalar>, <exhalar>, <distribuciónDeOxigeno>, <distribuciónDeNitrogeno>, <alveolo>, <alveolo>, <bronqueolo> como logico;

<víasNasales><-verdadero;
<faringe><-verdadero;
<traquea><-verdadero;
<traquea><-verdadero;
<bronquio><-verdadero;
<pulónDerecho><-verdadero;
<pulónDerecho><-verdadero;
<pulónDerecho><-verdadero;
<pulónDerecho><-verdadero;
<pulmonIzquierdo><-verdadero;
<pulmonIzquierdo><-verdadero;
<pulmonIzquierdo><-verdadero;
<pulmonIzquierdo><-falso;
<respirar><-verdadero;
<inhalar><-verdadero;
<inhalar><-verdadero;
<inhalar><-verdadero;
<exhalar><-verdadero;
<exhalar><-falso; 
<exhalar><-verdadero;
<distribuciónDeOxigeno><-verdadero;
<distribuciónDeNitrogeno><-verdadero;
<alveolo><-verdadero;
<alveolo><-verdadero;
<bronqueolo><-verdadero;
//
Mientras respirar = verdadero Hacer
        <inhalar> | <exhalar> ;
     Si inhalar = verdadero Entonces
          exhalar<-falso
     FinSi

(...)

FinProceso
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Si usted manejara directamente los impulsos eléctricos del cerebro:
 Cree que sería más recomendable, o incluso posible usar "Mientras"/s o "Si"/s para administrar estos procesos?
 Algunos de estos procesos (aunque no todos) no pueden ser realizados si otros fallan. Si tuviera un sistema que mostrara la condición actual de sus lógicos facilitaría bastante la busqueda para solucionar un problema, o aún mejor, un sistema para determinar qué procesos fallan.