Variables/Processing

PROCESSING

VARIABLES

PALABRAS CLAVE MousePressed: Una variable que es verdadera si el mouse está presionado.

KeyPressed: Una variable que es verdadera si la tecla está presionada.

Key: Una variable que contiene el valor de la tecla presionada.

KeyCode: Un entero que contiene el valor de la tecla que está presionada. Puede ser comparada con un set de constantes para teclas especiales. ARRIBA, ABAJO, IZQ, DER, ALT, CONTROL, SHIFT, BACKSPACE, ETC. Loop: Es un procedimiento que busca un comando en especifico y se ejecuta haciéndolo indefinidamente.

AJUSTE DE TAMAÑO Processing tiene una serie de variables especiales para almacenar información en el programa. Por ejemplo, el ancho y el alto de la ventana se almacenan en variables llamadas width y height. Estos valores son fijados por el tamaño () función. Se pueden utilizar para dibujar los elementos en relación con el tamaño de la ventana, incluso si el tamaño () cambia de línea.

En este ejemplo, cambiar los parámetros de tamaño () para ver cómo funciona:

size(480, 120); smooth(); line(0, 0, width, height); // Linefrom (0,0) to (480, 120) line(width, 0, 0, height); // Linefrom (480, 0) to (0, 120) ellipse(width/2, height/2, 60, 60);

ARITMETICA BĂ SICA

size(480, 120); intx = 25; inth = 20; int y = 25; rect(x, y, 300, h); // Top x = x + 100; rect(x, y + h, 300, h); // Middle x = x - 250; rect(x, y + h*2, 300, h); // Bottom

Multiplicación: * se denota con un asterisco.

División: / se denota con un slash.

Adición: ++ se denota con dos signos positivos o dos mas.

Sustracción: -- se denota con dos signos negativos o dos menos.

Valor del producto después de una división: i-2 Se usan también las variables de MousePressed, Keypressed, Key, Keycode.

Processing tiene un conjunto de normas para definir qué operadores tienen preferencia sobre los demás, lo que significa que los cálculos se hacen primero, segundo, tercero, y así sucesivamente. Estas reglas definen el orden en que se ejecuta el código. intx = 4 + 4 * 5; // Asigna 24ax

La expresión 4 * 5 se evalúa en primer lugar porque la multiplicación tiene la máxima prioridad. En segundo lugar, 4 se añade el producto de 4 * 5 para obtener 24.Por último, debido a que el operador de asignación (el símbolo de la igualdad) tiene la prioridad más baja, el valor 24 se asigna a la variable x. Esto se aclara con paréntesis, pero el resultado es el mismo: intx = 4 + (4 * 5); // Asigna 24 ax Si se desea forzar la adición a pasaraprimer lugar, sólo se mueven los paréntesis. Si debido a que los paréntesis tienen mayor precedencia que la multiplicación, se cambia el orden y el cálculo de afectados es la siguiente: intx = (4 + 4) * 5; / / Asignar 40 a x

Algunos cálculos se utilizan con tanta frecuencia en la programación que se han desarrollado atajos.

Por ejemplo, puede agregar a una variable, o restar de ella, con solo un operador x= + 10; / / Esto es lo mismo que x = x + 10 y -= 15; / / Esto es lo mismo que y = y - - 15 También es común añadir o restar 1 a una variable. Para esto también existe un atajo.

El + + y - - el operador hace lo siguiente: x++; // Thisisthesame as x = x + 1 y--; // Thisisthesame as y = y - 1

REPETICIÓN

A medida que se escriban mas programaciones, el dibujo se crea cuando las líneas del código se repiten, pero con pocas variaciones. Un código se llama a través de un loop el cual permite que funcione más de una vez.

En este ejemplo el dinujo es simplificado mediante un loop:

size(480, 120); smooth(); strokeWeight(8); line(20, 40, 80, 80); line(80, 40, 140, 80); line(140, 40, 200, 80); line(200, 40, 260, 80); line(260, 40, 320, 80); line(320, 40, 380, 80);

Lo mismo puede ser hecho con un loop y con menos códigos: size(480, 120); smooth(); strokeWeight(8); for (inti = 20; i< 400; i += 60) { line(i, 40, i + 60, 80); } La información entre corchetes {. .} carácteres. El código entre los corchetes es llamado BLOCK. Este será el código que se repetirá en cada iteración del bucle for.

Dentro del paréntesis hay tres instrucciones, separados por punto y coma, que trabajan juntos para controlar la cantidad de veces que el código dentro del bloque corre o funciona. Desde izquierda a derecha, estas instrucciones hacen referencia a la initializacion (init), el test y el update: for (init; test; update) { statements }

El init declara de forma típica una nueva variable para utilizar dentro del "loop" asignándole un valor. El nombre variable i se utiliza con frecuencia, pero no hay realmente nada especial sobre él. La prueba evalúa el valor de esta variable, y la actualización cambia el valor de la variable.

La siguiente figura muestra el orden en la cual corren y cómo controlan las declaraciones del código dentro del bloque.

• Los operadores relacionales mas comunes son : > Mayor que < Menor que >= Mayor o igual que <= Menor o igual que == Igual != No igual

La expresión relacional siempre evalúa lo verdadero y lo falto. Por ejemplo la expresión 5 > 3 es verdadera. Podemos hacernos la pregunta “ ¿Es cinco mayor que tres?” Ya que la repuesta es “si, “ podemos decir que esta expresión es verdadera.

Para la expresión 5 <3, nos preguntamos, “ ¿Es cinco menor que tres?” La respuesta es “no,” entonces podemos decir que esta expresión es falsa.

Cuando la evaluación es verdadera, el código dentro del block corre, cuando es falsa, el código no corre y la repetición (loop) termina.

Al modificar un poco el ejemplo que ya vimos podemos general diferentes patrones.

size(480, 120); smooth(); strokeWeight(2); for (int i = 20; i < 400; i += 8) { line(i, 40, i + 60, 80); }

Disgregaci贸n de las l铆neas:

size(480, 120); smooth(); strokeWeight(2); for (int i = 20; i < 400; i += 20) { line(i, 0, i + i/2, 80); } 20) y

En este caso, cambiamos una variable ( el i+=8 por un podemos ver que hay un cambio en la formaci贸n de las l铆neas.

Plegando las lĂ­neas:

size(480, 120); smooth(); strokeWeight(2); for (int i = 20; i < 400; i += 20) { line(i, 0, i + i/2, 80); line(i + i/2, 80, i*1.2, 120); } Se agrega una nueva variable manteniendo los valores.

Cuando un loop se encaja dentro de otro, el nĂşmero de repeticiones se multiplica.

size(480, 120); background(0); smooth(); noStroke(); for (int y = 0; y <= height; y += 40) { for (int x = 0; x <= width; x += 40) { fill(255, 140); ellipse(x, y, 40, 40); } }

En este ejemplo los loops son adyacentes, o mas bien que encaja sobre el otro.

Los resultados nos muestran que uno de los loops está dibujado en una columna de cuatro círculos y la otra esta dibujado en un extensión de trece círculos size(480, 120); background(0); smooth(); noStroke(); for (int y = 0; y < height+45; y += 40) { fill(255, 140); ellipse(0, y, 40, 40); } for (int x = 0; x < width+45; x += 40) { fill(255, 140); ellipse(x, 0, 40, 40); }

En los siguientes ejemplos podemos ver como las variables de manera repetida pueden ser modificas y nos entregan diferentes maneras de que la repetici贸n por loops sea posible.

size(480, 120); background(0); smooth(); fill(255); stroke(102); for (int y = 20; y <= height-20; y += 10) { for (int x = 20; x <= width-20; x += 10) { ellipse(x, y, 4, 4); // Draw a line to the center of the display line(x, y, 240, 60); } }

size(480, 120); background(0); smooth(); for (int y = 32; y <= height; y += 8) { for (int x = 12; x <= width; x += 15) { ellipse(x + y, y, 16 - y/10.0, 16 - y/10.0); } }