Processing Apuntes.

Variables.

Una variable es un contenedor para almacenar datos. Cada variable tiene dos partes,
un nombre y un valor. Si el nmero 21 es almacenado en la variable edad. La palabra
edad va a ser sustituida por el valor 21 cada vez que esta palabra (variable) aparezca
en el programa.
Una variable debe ser declarada antes de que pueda usarse.

Ejemplo:

int x; // Declare the variable x of type int
float y; // Declare the variable y of type float
boolean b; // Declare the variable b of type boolean

x = 50; // Assign the value 50 to x
y = 12.6; // Assign the value 12.6 to y
b = true; // Assign the value true to b

Una variable puede ser declarada y asignada en una misma lnea.

Ejemplo:

int x = 50;
float y = 12.6;
boolean b = true;

Mas de una variable puede ser declarada en una misma lnea, despus se le asigna un valor
por separado.

Ejemplo:

float x, y, z;
x = -3.9;
y = 10.1;
z = 124.23;


Cuando se declara una variable es importante escribir el tipo de data antes del
nombre en este ejemplo int es el tipo de data y x es el nombre de la variable. Despus
de que la variable ha sido declarada el valor el tipo de data no puede ser cambiado o
reinterpretado. Si el mismo tipo de data se incluye de nuevo para la misma variable,
esto producir un error.
Ejemplo:

int x = 69; // Assign 69 to x
x = 70; // Assign 70 to x
int x = 71; // ERROR! The data type for x is duplicated

El smbolo de igual = es llamado operador de asignacin asigna el valor que esta de
lado derecho del = a la variable que se encuentra de lado izquierdo. Los valores solo
pueden ser asignados a variables. Asignar una constante a otra constante produce un
error.

Ejemplo:

// Error! The left side of an assignment must be a variable
5 = 12;

Cuando se trabaja con variables de distintos tipos en el mismo programa, hay que
tener cuidado de no mezclar los tipos de un modo que produzca un error en el
programa. Por ejemplo no se puede asignar un valor de tipo floating (decimales) a una
variable de tipo integer (eneteros).

Ejemplo:

// Error! Its not possible to fit a floating-point number into an int
int x = 24.8;

float f = 12.5;
// Error! Its not possible to fit a floating-point number into an int
int y = f;

Las variables deben de tener nombres que describan su contenido. Esto hace que los
programas sean ms fcil de leer. Depende del programador como asigna nombres a
las variables.

Ejemplo:

t
temp
temperature
roomTemp
roomTemperature

Los nombres de variables como t deben utilizarse al mnimo o no utilizarse en
absoluto ya que es crptico no indica que contiene la variable. Por otro lado variables
como roomTemperature pueden hacer que el cdigo sea tedioso de leer. Lo ideal sera
utilizar una variable como roomTemp ya que es conciso y descriptivo.
Los nombres de variables deben empezar con letras minsculas y si hay ms de una
palabra en la variable la primer letra de las palabras posteriores deben ser
maysculas como roomTemp.
Las variables no debe comenzar con nmeros y tampoco pueden usarse palabras
reservadas. Ejemplos de palabras reservadas inlcuyen: int, if, true, null. Para evitar
confusiones las variables no deben tener los mismos nombres de elementos del
lenguaje Processing.

Variables de Processing.

El tamao de la anchura y la altura de la ventana de processing estn almacenados en
las variables llamadas width y height. Si el programa no incluye la funcin size(), las
variables width y height adquieren un valor de 100. Se puede comprobar al correr los
siguientes programas.

Ejemplos:

println(width + ", " + height); // Prints "100, 100" to the console

size(300, 400);
println(width + ", " + height); // Prints "300, 400" to the console

size(1280, 1024);
println(width + ", " + height); // Prints "1280, 1024" to the console


Utilizar las variables width y height es muy til cuando se escribe un programa que
escale a diferentes tamaos. Esta tcnica permite un cambio simple a los parmetros
de size() para alterar las dimensiones y proporciones del programa, en lugar de
cambiar los valores a travs del cdigo. El ejemplo siguiente muestra como al cambiar
los valores en size() el dibujo del programa se ajusta al tamao de la pantalla.

Ejemplo:

size(100, 100);
ellipse(width*0.5, height*0.5, width*0.66, height*0.66);
line(width*0.5, 0, width*0.5, height);
line(0, height*0.5, width, height*0.5);




Matemticas 1: Aritmtica, Funciones.

Sintaxis:

+ (add), - (subtract), * (multiply), / (divide), % (modulus)
() (parentheses)
++ (increment), -- (decrement), += (add assign), -= (subtract assign)
*= (multiply assign), /= (divide assign), - (negation)
ceil(), floor(), round(), min(), max()

En programacin, las propiedades visuales de una imagen en la pantalla estn
definidas por nmeros, lo que significa que la imagen puede ser controladada
matemticamente. Por ejemplo, un rectngulo puede tener una posicin horizontal de
10, una posicin vertical de 10, una anchura y una altura de 55 y un tono gris con
valor de 153. Si este valor es almacenado en la variable grayVal y se le suman 102 a
esta variable, el valor de gris se convierte en 255 y la forma en la pantalla aparecer
de color blanco.

Ejemplo:

int grayVal = 153;
fill(grayVal);
rect(10, 10, 55, 55); // Draw gray rectangle
grayVal = grayVal + 102; // Assign 255 to grayVal
fill(grayVal);
rect(35, 30, 55, 55); // Draw white triangle

La expresin a la derecha del smbolo igual = es evaluada antes de que el valor sea
asignado a la variable de la izquierda. Asi pues, en el ejemplo siguiente: a= 5+4
primero se realiza la suma de 5+4 dando un valor de 9 despus este valor es asignado
a la variable a.
Dentro del campo visual, la suma, resta, multiplicacin y divisin pueden ser
utilizadas para controlar la posicin de elementos en pantalla o para cambiar
atributos como el tamao o el valor de gris. El smbolo + es usado para aadir, el
smbolo para restar, el smbolo * para multiplicar, y el smbolo / para dividir.

El smbolo % es ms extico. El operador % calcula el residuo cuando un nmero es
dividido por otro. El % notacin para modulus, regresa el residuo entero (integer)
despus de dividir el nmero a la izquierda del smbolo por el nmero de la derecha.

Expresin Resultado Explicacin
9 % 3 0 3 cabe en 0 tres veces, no hay residuo.
9 % 2 1 2 cabe en 9 cuatro veces, dando un residuo de 1.
35 % 4 3 4 cabe en 35 ocho veces, dando un residuo de 3.
El operador modulus es usado comnmente para mantener nmeros dentro de un
rango deseado. Por ejemplo, si una variable se esta incrementando constantemente
(0,1,2,3,4,5,6,7,etc.), aplicar el operador modulus puede transformar esta secuencia.
Un nmero que se incrementa continuamente puede crear un ciclo constante entre 0 y
3 al aplicar %4:

Ejemplo:

x 0 1 2 3 4 5 6 7 8 9 10
x % 4 0 1 2 3 0 1 2 3 0 1 2

Cuando se trabaja con operadores matemticos y variables es importante estar
pendiente de los tipos de datos de las variables que se estn usando. La combinacin
de dos enteros (integers) siempre van a resultar en un int. La combinacin de dos
nmeros decimales (floating) siempre van a resultar en un float, pero cuando un int y
un float son utilizados, el resultado es un float.

Valores enteros pueden ser asignados a variables decimales (float), pero no viceversa.
Asignar un float a un int haces los nmeros menos precisos. Trabajar con un int y un
float va a actualizar el int y tratar los dos nmeros como valores decimales, pero el
resultado no se va a ajustar en una variable int.

Ejemplo:

int a = 4/3; // Asigna 1 a a
int b = 3/4; // Asigna 0 a b
int c = 4.0/3; // ERROR!
int d = 4.0/3.0; // ERROR!
float e = 4.0/3; // Asigna 1.3333334 a e
float f = 4.0/3.0; // Asigna 1.3333334 a f

Los ltimos dos clculos requieren informacin adicional. El resultado de dividir dos
enteros siempre va a ser un entero: dividir el entero 4 entre el entero 3 es igual a 1.
Este resultado es convertido en una variable con punto decimal despus de que el
clculo ha terminado, entonces el valor 1 se convierte en 1.0 solo hasta que ha
alcanzado el lado izquierdo del signo =. Estoy puede resultar confuso, pero puede ser
muy til para programas ms avanzados.

Ejemplo:

float a = 4/3; // Asigna 1.0 a a
float b = 3/4; // Asigna 0.0 a b

Las reglas para calcular valores int y float pueden oscurecerse cuando variables son
usadas en lugar de los nmeros. Es importante estar pendiente de los tipos de datos
de las variables para evitar estos problemas.

Ejemplo:

int i = 4;
float f = 3.0;
int a = i/f; // ERROR! Assign a float value to an int variable
float b = i/f; // Assign 1.3333334 to b

Tambin es importante poner atencin al valor de las variables para evitar errores
aritmticos. Por ejemplo, dividir un nmero entre zero en matemticas es iguala
infinito, pero en programacin de software provoca un error.

Ejemplo:

int a = 0;
int b = 12/a; // ERROR! ArithmeticException: / by zero

Similarmente, dividir un nmero extremadamente pequeo puede producir un
resultado enorme. Esto puede resultar confuso cuando se dibujan formas porque no
van a ser visibles en la pantalla.

Ejemplo:

float a = 0.0001;
float b = 12/a; // Assign 120000.0 to b


Orden de operadores, Agrupacin.

El orden de las operaciones determina cual operador matemtica va a realizar
clculos antes que los dems. Por ejemplo, la multiplicacin siempre es evaluada antes
que la suma sin importar el orden de la secuencia de los elementos. La expresin 3 + 4
* 5 da como resultado 23 porque 4 es primero multiplicado por 5 que es igual a 20 y
despus se aade la suma de 3 dando como resultado 23. El orden de las operaciones
especifica que la multiplicacin siempre precede a la suma sin importar el orden en el
que aparezcan en la expresin. El orden de las operaciones para evaluar expresiones
puede ser cambiado al aadir parntesis. Por ejemplo, si una suma aparece dentro de
un parntesis, va a ser calculada antes que la multiplicacin. La expresin (3+4) * 5 da
como resultado 35 porque primero se realiza la suma dando 7, el cual es despus
multiplicado por 5 resultando en 35.

Ejemplo:

x = 3 + 4 * 5; // Assign 23 to x
y = (3 + 4) * 5; // Assign 35 to y

En muchos casos, los parntesis son necesarios para forzar elementos de una
expresin a ser evaluados antes que otros, pero algunas veces son usados para aclarar
el orden de las operaciones. Las siguientes lneas calculan el mismo resultado porque
la multiplicacin siempre sucede antes que la suma, pero se puede encontrar la
segunda lnea ms clara.

Ejemplo:

x = 10 * 20 + 5; // Assign 205 to x
y = (10 * 20) + 5; // Assign 205 to y

La siguiente tabla muestra el orden de procedencia de los operadores que se han
introducido hasta este momento. Los operadores en la parte superior preceden a los
de la parte inferior.

Multiplicativos * / %
Aditivos + -
Asignacin =

Esto significa, por ejemplo, que la divisin siempre va a suceder antes que la resta y
que la suma siempre va a suceder antes que el igual.

Shortcuts (atajos).

Hay muchas expresiones repetitivas en programacin, los atajos de cdigo son usados
para hacer los programas ms concisos. El operador de incremento ++ aade el valor
de 1 a una variable y el operador decremento - - resta el valor de 1:

Ejemplo:

int x = 1;
println(x); // Prints "1" to the console
x++; // Equivalent to x = x + 1
println(x); // Prints "2" to the console

int y = 1;
println(y); // Prints "1" to the console
y--; // Equivalent to y = y - 1
println(y); // Prints "0" to the console
El valor es incrementado o disminuido despus de que la expresin ha sido evaluada.
Esto ha menudo crea confusin y es mostrado en el siguiente ejemplo.

Ejemplo:

int x = 1;
println(x++); // Prints "1" to the console
println(x); // Prints "2" to the console

Para actualizar el valor antes de que la exoresin sea evaluada, se debe colocar el
operador enfrente de la variables.

Ejemplo:

int x = 1;
println(++x); // Prints "2" to the console
println(x); // Prints "2" to the console


El operador += combina la suma y la asignacin. El operador -= combina la resta y la
asignacin.

Ejemplo:

int x = 1;
println(x); // Prints "1" to the console
x += 5; // Equivalent to x = x + 5
println(x); // Prints "6" to the console

int y = 1;
println(y); // Prints "1" to the console
y -= 5; // Equivalent to y = y - 5
println(y); // Prints "-4" to the console

El operador *= combina la multiplicacin y la asignacin. El operador /= combina la
divisin y la asignacin.

Ejemplo:

int x = 4;
println(x); // Prints "4" to the console
x *= 2; // Equivalent to x = x * 2
println(x); // Prints "8" to the console


int y = 4;
println(y); // Prints "4" to the console y
/= 2; // Equivalent to y = y / 2
println(y); // Prints "2" to the console

El operador de negacin cambia el valor del signo a su derecha. Puede ser utilizado
para multiplicar un valor por -1.

Ejemplo:

int x = 5; // Assigns 5 to x
x = -x; // Equivalent to x = x * -1
println(x); // Prints "-5"

Constraining Numbers (Nmeros Delimitados).

Las funciones ceil(), floor(), round(), min(), y max() son utilizadas para generar
clculos de nmeros que los operadores aritmticos estndar no pueden realizar.
Estas funciones son diferentes de las utilizadas para dibujar formas, como line() y
ellipse() porque regresan valores. Esto significa que la funcin genera una salida de un
nmero que despus es asignado a una variable.

La funcin ceil() calcula el valor entero (int) ms cercano que es mayor o igual al valor
de su parmetro.

Ejemplo:

int w = ceil(2.0); // Assign 2 to w
int x = ceil(2.1); // Assign 3 to x
int y = ceil(2.5); // Assign 3 to y
int z = ceil(2.9); // Assign 3 to z

La funcin floor() calcula el valor entero (int) ms cercano que es menor o igual al
valor de su parmetro.

Ejemplo:

int w = floor(2.0); // Assign 2 to w
int x = floor(2.1); // Assign 2 to x
int y = floor(2.5); // Assign 2 to y
int z = floor(2.9); // Assign 2 to z

La funcin round() calcula el valor entero (int) ms cercano al valor de su parmetro.
Valores que terminan en .5 se redondean al siguiente valor entero(int).
Ejemplo:

int w = round(2.0); // Assign 2 to w
int x = round(2.1); // Assign 2 to x
int y = round(2.5); // Assign 3 to y
int z = round(2.9); // Assign 3 to z

Aunque las funciones ceil(), floor(), y round() actan con valores decimales, el
resultado es siempre un valor entero. Para convertir a un float, simplemente se le
asigna un resultado a una variable float.

Ejemplo:

float w = round(2.1); // Assign 2.0 to w

La funcin min() determina el valor ms pequeo en una secuencia de nmeros. LA
funcin max() determina el valor ms grande en una secuencia de nmeros. Ambas
funciones pueden tener dos o tres parmetros.

Ejemplo:

int u = min(5, 9); // Assign 5 to u
int v = min(-4, -12, -9); // Assign -12 to v
float w = min(12.3, 230.24); // Assign 12.3 to w i
nt x = max(5, 9); // Assign 9 to x
int y = max(-4, -12, -9); // Assign -4 to y
float z = max(12.3, 230.24); // Assign 230.24 to z

Control 1: Deciciones.

Esta unidad se concentra en controlar el flujo de un programa con estructuras
condicionales.

Sintaxis:

> (greater than), < (less than)
>= (greater than or equal to),
<= (less than or equal to)
== (equality),
!= (inequality)
if, else, {} (braces)
|| (logical OR), && (logical AND), ! (logical NOT)


Los programas que se han visto hasta este momento corren en lnea secuencial. Es
decir leen la primera lnea, despus la segunda, la tercera, etc. EL programa se detiene
cuando lee la ltima lnea del cdigo. Es benfico alterar este orden constantemente
saltando algunas lneas o repetir otras lneas muchas veces para generar una accin
repetitiva. Aunque las lneas de cdigo que competen al programa siempre son
posicionadas en un orden de arriba hacia abajo en la pgina, esto no necesariamente
define el orden en que cada lnea es ejecutada. Este orden se llama flujo del programa.
El flujo puede ser alterado al agregar elementos de cdigo llamados controladores
estructurales.

Expresiones Relacionales.

Elementos de cdigo llamados expresiones relacionales evalan a verdadero o falso.
Una expresin de relacin es generada a partir de dos valores que son comparados
con un operador de relacin. En Processing, dos valores pueden ser comparados con
operadores de relacin como se muestra a continuacin:

Expression Evaluation
3> 5 false
3< 5 true
5< 3 false
5> 3 true

Cada una de estas declaraciones puede ser convertida al ingles. Utilizando la prima
fila como ejemplo, podemos decir, Es tres mayor que cinco? La respuesta no es
expresada con el valor false. La siguiente fila tambin puede ser convertida Es tres
menor que cinco? La respuesta es si y es expresada con el valor true. En una
expresin de relacin, dos valores son comparados con un operador de relacin que
evala a true o a false. No existen otros valores posibles.

Los operadores de relacin se definen a continuacin:

Operator Meaning
> greater than
< less than
>= greater than or equal to
<= less than or equal to
== equivalent to
!= not equivalent to





Las siguientes lneas de cdigo muestran el resultado comparando el mismo grupo de
nmeros con diferentes operadores de relacin:

println(3 > 5); // Prints "false"
println(5 > 3); // Prints "true"
println(5 > 5); // Prints "false"

println(3 < 5); // Prints "true"
println(5 < 3); // Prints "false"
println(5 < 5); // Prints "false"

println(3 >= 5); // Prints "false"
println(5 >= 3); // Prints "true"
println(5 >= 5); // Prints "true"

println(3 <= 5); // Prints "true"
println(5 <= 3); // Prints "false"
println(5 <= 5); // Prints "true"

El operador de igualdad ==, determina si dos valores son equivalente. Es diferente al
smbolo =, que asigna un valor, pero los dos son usados incorrectamente
intercambiando uno por el otro. El nico modo de evitar este error es teniendo
cuidado. El smbolo != es opuesto a == y determina si dos valores no son equivalentes.

println(3 == 5); // Prints "false"
println(5 == 3); // Prints "false"
println(5 == 5); // Prints "true"

println(3 != 5); // Prints "true"
println(5 != 3); // Prints "true"
println(5 != 5); // Prints "false"


Condicionales.

Las condicionales le permiten a un programa tomar decisiones acerca de que lnea de
cdigo debe ejecutar y cual no. Permiten que ciertas acciones tomen lugar solo cuando
la condicin especfica es requerida. Las condicionales le permiten al programa
comportarse diferente dependiendo de los valores en las variables. Por ejemplo, el
programa puede dibujar una lnea o una elipse dependiendo del valor de la variable.
La estructura if es usada en Processing para tomar decisiones.



Ejemplo:

if (test) {
statements
}

La prueba debe ser una expresin que se resuelva en verdadero (true) o falso (false).
Cuando la expresin se evala en true, el cdigo dentro de { (llave izquierda) y } (llave
derecha) se ejecuta. Si la expresin es false, el cdigo se ignora. Al cdigo dentro de
llaves se le llama bloque.

Los siguientes ejemplos presentan el mismo cdigo con diferentes valores para la
variable x. Como esta variable es utilizada para probar la estructura if, modificarla
afecta que lneas de cdigo se ejecutan. Cambiar el valor genera una elipse, un
rectngulo o ninguna de las dos.


Ejemplo 1:

// The text expressions are "x > 100" and "x < 100"
// Because x is 150, the code inside the first block
// runs and the ellipse draws, but the code in the second
// block is not run and the rectangle is not drawn
int x = 150;
if (x > 100) { // If x is greater than 100,
ellipse(50, 50, 36, 36); // draw this ellipse
}
if (x < 100) { // If x is less than 100
rect(35, 35, 30, 30); // draw this rectangle
}
line(20, 20, 80, 80);

// Because x is 50, only the rectangle draws
int x = 50;
if (x > 100) { // If x is greater than 100,
ellipse(50, 50, 36, 36); // draw this ellipse
}
if (x < 100) { // If x is less than 100,
rect(33, 33, 34, 34); // draw this rectangle
}
line(20, 20, 80, 80);




Ejemplo 2:

// Because x is 100, only the line draws
int x = 100;
if (x > 100) { // If x is greater than 100,
ellipse(50, 50, 36, 36); // draw this ellipse
}
if (x < 100) { // If x is less than 100,
rect(33, 33, 34, 34); // draw this rectangle
}
line(20, 20, 80, 80);

Para ejecutar cdigo agrupado distinto cuando la expresin relacional de una
estructura if no es true, se utiliza la palabra else. La palabra else extiende una
estructura if, cuando una expresin asociada con la estructura es false, el cdigo en el
bloque else es ejecutado.

Ejemplo:

// Because x is 90, only the rectangle draws
int x = 90;
if (x > 100) { // If x is greater than 100,
ellipse(50, 50, 36, 36); // draw this ellipse
} else { // Otherwise,
rect(33, 33, 34, 34); // draw this rectangle
}
line(20, 20, 80, 80); // Always draw the line


// Because x is 290, only the ellipse draws
int x = 290;
if (x > 100) { // If x is greater than 100,
ellipse(50, 50, 36, 36); // draw this ellipse
} else { // Otherwise,
rect(33, 33, 34, 34); // draw this rectangle
}
line(20, 20, 80, 80); // Always draw the line

Las condicionales pueden ser embebidas dentro de otras condicionales para controlar
cuales lneas de cdigo se vana ejecutar. En el siguiente ejemplo, el cdigo para
dibujar una elipse o una lnea puede ser alcanzado solo si x es mayor a 100. Si esta
expresin se evala a true, una segunda comparacin de x determina cual de estas
formas va a ser dibujada.


Ejemplo:

// If x is greater than 100 and less than 300, draw the
// ellipse. If x is greater than or equal to 300, draw
// the line. If x is not greater than 100, draw the
// rectangle. Because x is 420, only the line draws.
int x = 420;
if (x > 100) { // First test to draw ellipse or line
if (x < 300) { // Second test determines which to draw
ellipse(50, 50, 36, 36);
} else {
line(50, 0, 50, 100);
}
} else {
rect(33, 33, 34, 34);
}

Las condicionales pueden ser extendidas aun ms al combinar un else con un if. Esto
le permite a las condicionales usar multiples pruebas para determinar cual lnea del
programa debe ser ejecutada. Esta tcnica es usada cuando hay muchas opciones y
solo una puede ser seleccionada a la vez.

Ejemplo:

// If x is less than or equal to 100, then draw
// the rectangle. Otherwise, if x is greater than
// or equal to 300, draw the line. If x is between
// 100 and 300, draw the ellipse. Because x is 101,
// only the ellipse draws.
int x = 101;
if (x <= 100) {
rect(33, 33, 34, 34);
} else if (x >= 300) {
line(50, 0, 50, 100);
} else {
ellipse(50, 50, 36, 36);
}

Operadores Lgicos.

Los operadores lgicos son usados para combinar dos o ms expresiones de relacin y
para invertir valores lgicos. Le permiten a ms de una condicin ser consideradas
simultneamente. Los operadores lgicos son smbolos para los conceptos lgicos de
ANDm OR y NOT:
Operator Meaning
&& AND
|| OR
! NOT

La siguiente tabla esquematiza todas las combinaciones posibles y los resultados.

Expression Evaluation

true && true true
true && false false
false && false false
true || true true
true || false true
false || false false
!true false
!false true

El operador lgico OR, es decir, las dos barras verticales hace la expresin relacional
verdadera (true) si solo una parte es verdadera (true). El siguiente ejemplo muestra
como utilizarlo.

Ejemplo:

int a = 10;
int b = 20;
// The expression "a > 5" must be true OR "b < 30"
// must be true. Because they are both true, the code
// in the block will run.
if ((a > 5) || (b < 30)) {
line(20, 50, 80, 50);
}
// The expression "a > 15" is false, but "b < 30"
// is true. Because the OR operator requires only one part
// to be true in the entire expression, the code in the
// block will run.
if ((a > 15) || (b < 30)) {
ellipse(50, 50, 36, 36);
}

Expresiones lgicas compuestas pueden ser difciles de entender, pero se vuelven
simples cuando se observan paso a paso. Los parntesis son indicios tiles para
determinar el orden de evaluacin. Al observar la estructura if en la lnea 6 del
ejemplo anterior, se puede ver que las variables primero son reemplazadas por sus
valores, despus cada sub-expresin es evaluada y finalmente la expresin con el
operador lgico es evaluada.
Step 1 (a > 5) || (b < 30)

Step2 (10 > 5) || (20 < 30)

Step 3 true || true

Step 4 true


El operador lgico AND, dos et (&&), permite a toda la declaracin relacional se
verdadera (true) solo si las dos partes son verdaderas (true). El ejemplo siguiente es el
mismo al anterior excepto que el operador lgico OR ha sido cambiado por el
operador lgico AND. Puesto que cada operador compara los valores de forma
diferente, solo la lnea es dibujada aqu, mientras que el ejemplo anterior dibujaba la
lnea y el crculo.

Ejemplo:

int a = 10;
int b = 20;
// The expression "a > 5" must be true AND "b < 30"
// must be true. Because they are both true, the code
// in the block will run.
if ((a > 5) && (b < 30)) {
line(20, 50, 80, 50);
}
// The expression "a > 15" is false, but "b < 30" is
// true. Because the AND operator requires both to be
// true, the code in the block will not run.
if ((a > 15) && (b < 30)) {
ellipse(50, 50, 36, 36);
}

Cuando se usa AND, la primer parte de la expresin va a ser evaluada. Si esta parte es
falsa (false), entonces la segunda parte de la expresin no va a ser evaluada. Por
ejemplo, en esta expresin

(a > 5) && (b < 30)

Si a > 5 evala a false, entonces b < 30 es ignorado por eficacia. Esto es llamado un
operador de corto circuito. Lo mismo sucede para el operador OR, donde la primer
declaracin true va a terminar la evaluacin. Por ejemplo, si esta expresin es:

(a > 5) || (b < 30)

Si a > 5 es true, entonces b < 30 va a ser ignorado, porque la expresin completa va a
ser evaluada a true, sin importar el valor de b < 30. Esto tiene muchas aplicaciones
practicas en cdigos mas avanzados.

El operador lgico NOT es un signo de exclamacin. Invierte el valor lgico de las
variables booleanas. Cambia el true por false, y el false por true. El operador lgico
NOT solo puede ser aplicado a las variables booleanas.