Las matemáticas pueden ser un aspecto importante de la programación, pero no es necesario ser bueno en matemáticas para entender o disfrutar de la programación. Hay tantos estilos de programación, como personas que programan, y es vuestra decisión utilizar o ignorar las matemáticas. Las personas que disfrutan con las matemáticas suelen escribir programas para visualizar ecuaciones o deleitarse en la exploración de fenómenos como los fractales. Las personas que lucharon con las matemáticas en el colegio a veces encuentran que les gustan y lo entienden mejor cuando se aplica para formas y movimiento.
Este libro trata de aritmética, álgebra, trigonometría al servicio y la producción de formas y movimiento. Una sorprendente variedad de formas y movimiento sutiles se pueden crear con las matemáticas básicas, y una comprensión más matizada de estas técnicas puede dar más control sobre el software. Matemáticas más avanzadas, como el álgebra lineal y el cálculo se utilizan con frecuencia para imágenes y movimiento, pero queda fuera del alcance de este libro.
ARITMÉTICA
En programación, las propiedades visuales de una imagen en la pantalla se definen por los números, lo que significa que la imagen se puede controlar matemáticamente.
Por ejemplo, un rectángulo podría tener una posición horizontal de 50, una posición vertical de 30, una anchura y una altura de 80, y un valor de gris de 153. Si el valor de gris se almacena en una variable grayVal y 102 se añade a esta variable, el valor de gris se convertirá en 255 y aparecerá la forma blanca en pantalla. Esto se demuestra mejor usando un ejemplo:
int grayVal = 153;
fill(grayVal);
rect(10, 10, 55, 55);
grayVal = grayVal + 102;
fill(grayVal);
rect(35, 30, 55, 55);
Se evalúa la expresión a la derecha del símbolo “=” antes de que el valor se asigne a la variable de la izquierda. Por lo tanto, la sentencia a = 5 + 4 añade primero 5 y 4 para producir 9 y luego asigna el valor 9 a la variable a.
Dentro del dominio visual, suma, resta, multiplicación y división se pueden utilizar para controlar la posición de los elementos en pantalla o cambiar atributos como el tamaño o el valor de gris. El símbolo + se utiliza para sumar, el símbolo - para resta, el símbolo * para la multiplicación y el símbolo / para la división.
int a = 30;
line(a, 0, a, height);
a = a + 40;
strokeWeight(4);
line(a, 0, a, height);
________________________________
int a = 30;
int b = 40;
line(a, 0, a, height);
line(b, 0, b, height);
strokeWeight(4);
line(b-a, 0 b-a, height);
________________________________
int a = 8;
int b = 10;
line(a, 0, a, height);
line(b, 0, b, height);
strokeWeight(4);
line(a*b, 0, a*b, height);
________________________________
int a = 8;
int b = 10;
line(a, 0, a, height);
line(b, 0, b, height);
strokeWeight(4);
line(a/b, 0, a/b, height);
________________________________
int y = 20;
line (0, y, width, y);
y = y + 6; // Asignar 26 a y
line(0, y, width, y);
y = y + 6; // Asignar 32 a y
line(0, y, width, y);
y = y + 6; // Asignar 38 a y
line(0, y, width, y);
________________________________
float y = 20;
line(0, y, width, y);
y = y * 1.6 // Asignar 32.0 a y
line(0, y, width, y);
y = y * 1.6 // Asignar 51.2 a y
line(0, y, width, y);
y = y * 1.6 // Asignar 81.920006 a y
line(0, y, width, y);
________________________________
OPERADOR MÓDULO %
Los símbolos +, - *, / o = probablemente te sean familiares, pero % (módulo) es algo más exótico. El operador % calcula el resto cuando un número se divide por otro. El %, la notación en código para el modulo, devuelve el resto entero después de dividir el número a la izquierda del símbolo por el número de la derecha.
9%3 obtiene un resultado de 0, porque 9 dividido entre 3 es igual a 3, resto 0.
9%2 obtiene un resultado de 1, porque 9 dividido entre 2 es igual a 4, resto 1.
35%4 obtiene un resultado de 3, porque 35 dividido entre 4 es igual a 8, resto 3.
El operador maduro se utiliza a menudo para mantener los números dentro de un rango deseado. Por ejemplo, si una variable está aumentando continuamente (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, etc.), aplicando el operador módulo puede transformar esta secuencia. Un número creciente puede hacer un ciclo continuo entre 0 y 3 aplicando %4
x 0 1 2 3 4 5 6 7 8 9 10 11
–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
x%4 0 1 2 3 0 1 2 3 0 1 2 3
Veremos muchos ejemplos con % durante el curso y los estudiaremos con más detenimiento.
Ya hemos comentado , que cuando se trabaja con operadores matemáticos y variables, es importante ser conscientes de los tipos de datos que se están usando en las variables.
La combinación de dos números enteros siempre resultará un entero (int). La combinación de dos números decimales, siempre resultará un número decimal, pero cuando un entero (int) y un decimal (float) operan, el resultado es un decimal.
println(4/3); // Prints “1”
println(4.0/3); // Prints “1.3333334”
println(4/3.0); // Prints “1.3333334”
println(4.0/3.0); // Prints “1.333334”
Los valores enteros pueden ser asignados a las variables decimales (float) o también conocidas como de punto flotante, pero no a la inversa. La asignación de un número decimal o una variable de números enteros hace que el número sea menos preciso, por lo que la elaboración requiere que se haga de forma explícita.
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.33333334 a e
float f = 4.0/3.0 // Asigna 1.3333334 a f
Los dos últimos resultados requieren explicación adicional. El resultado de dividir dos números enteros siempre será un número entero: dividir el número entero 4 entre 3 es igual a 1. El resultado se convierte en una variable de números decimales una vez que el cálculo ha terminado, por lo que 1 se convierte en 1.0 sólo una vez que se ha alcanzado el lado izquierdo del signo =. Si bien esto puede parecer confuso, puede ser útil para programas más avanzados.
float a = 4/3 // Asigna 1.0 a “a”
float b = 3/4; // Asigna 0.0 a “b”
Las reglas de cálculo de los valores int y float pueden volverse más oscuras cuando se utilizan variables en lugar de números reales. Es importante ser consciente de los tipos de datos de nuestras variables para evitar este problema.
int i = 4;
float f = 3.0;
int a = i/f; // ¡ERROR! Asigna un decimal a un entero.
float b = i/f; // Asigna 1.333334 a “b”
LIMITADORES DE NÚMEROS
Las funciones ceil(), floor(), round(), min(), max() se utilizan para realizar cálculos con números que los operadores aritméticos estándar no puede.
Estas funciones son diferentes a las que usamos para dibujar formas, tales como line() y ellipse(), debido a que devuelven valores. Esto significa que la función genera un número que se puede asignar a una variable.
la función ceil() calcula el número entero (int) más cercano que es mayor que o igual que el valor de su parámetro.
int w = ceil(2.0); // Asigna 2 a w
int x = ceil(2.1); // Asigna 3 a x
int y = ceil(2.5); // Asigna 3 a y
int z = ceil(2.9); // Asigna 3 a z
La función floor() calcula el número entero (int) más cercano que es menor que o igual que el valor de su parámetro:
int w = floor(2.0); // Asigna 2 a w
int x = floor(2.1); // Asigna 2 a x
int y = floor(2.5); // Asigna 2 a y
int z = floor(2.9); // Asigna 2 a z
La función round() calcula el valor entero (int) más cercano al valor de su parámetro. Valores que terminan con 0.5 ronda hasta el siguiente valor entero:
int w = round(2.0); // Asigna 2 a w
int x = round(2.1); // Asigna 2 a x
int y = round(2.5); // Asigna 3 a y
int z = round(2.9); // Asigna 3 a z
A pesar que ceil(), floor() y round() actúan sobre los números de cómo flotante (float), el resultado siempre es un número entero, porque esta es la forma en la que estas funciones son útiles. Para convertir un float, simplemente asigna el resultado a un variable float.
La función min() determina el valor más pequeño en una secuencia de números. La función max() determina el valor más grande de una secuencia de números. Ambas funciones pueden tener dos o tres parámetros:
int u = min(5,9); // Asigna “5” a “u”
int v = min(-4, -12, -9); // Asigna “-12” a “v”
float w = min(12.3, 230.24); // Asigna “12.3” a “w”
int x = max(5, 9); // Asigna “9” a “x”
int y = max(-4, -12, -9); // Asigna “-4” a “y”
float z = max(12.3, 230.24); // Asigna 230.24 a z
También es importante prestar atención al valor de las variables para evitar cometer errores aritméticos. Por ejemplo, dividir un número por cero produce el “infinito” en matemáticas, al go que en software provoca un error.
int a = 0;
int b = 12/a; // ¡ERROR! ArithmeticException: / by zero
Del mismo modo, dividir por un número extremadamente pequeño puede producir un enorme resultado. Esto puede ser confuso cuando usamos el dibujo de formas, ya que no serán visibles en la ventana de visualización.
float a = 0.0001;
float b = 12/a; // Asigna 1200000.0 a “b”
ORDEN DE LAS OPERACIONES, AGRUPACIÓN
El orden de la operaciones determinan qué operadores realizan sus cálculos antes que otros. Por ejemplo, la multiplicación siempre se evalúa antes que la suma con independencia de la secuencia de los elementos.
La expresión 3 + 4 * 5 es igual a 23. Porque 4 se multiplica primero por 5 para dar 20 y después se añade 3 para dar 23.
El orden de las operaciones especifica que la multiplicación siempre precede a la suma sin tener en cuenta el orden en el que aparezca en la expresión.
El orden de las operaciones para evaluar expresiones se puede cambiar añadiendo un paréntesis. Por ejemplo, si una operación de suma aparece entre paréntesis, se realiza antes que la multiplicación. De la expresión (3 + 4) * 5 se obtiene un resultado de 35, porque 3 se añade a 4 para dar 7, que luego se multiplica por 5 para obtener 35. Esto se expresa de forma más concisa en código.
x = 3 + 4 * 5; // Asigna 23 a “x”
y = (3 + 4) * 5; // Asigna 35 a “y”
En muchos casos, los paréntesis son necesarios para obligar a los elementos de una expresión a que sean evaluados antes que otros, pero a veces solo se utilizan para aclarar el orden de las operaciones. Las siguientes líneas de código evalúan el mismo resultado porque la multiplicación siempre ocurre antes de la adición, pero es posible encontrar la segunda línea más clara.
x = 10 * 20 + 5; // Asigna 205 a “x”
y = (10 * 20) + 5; // Asigna 205 a “y”
La siguiente tabla muestra la prioridad de los operadores introducidos hasta el momento. Los signos en la parte superior preceden a los de la parte inferior.
Multiplicativo * / %
Aditivo + -
Asignación =
SHORTCUTS
Hay muchas expresiones repetitivas en programación, por lo que los accesos directos o atajos se utilizan para hacer nuestros programas más concisos. El operador incremento ++ suma el valor 1 a una variable y el operador decremento — resta 1 al valor.
int x = 1;
println(x); // Imprime “1” en la consola
x++; // Equivale a x = x + 1;
pinrtln(x); // Imprime “2” en la consola
_______________________________
int y= 1;
println(y); // Imprime “1” en la consola
y--; // Equivale a y = y - 1;
printnl(y); // Imprime “0” en la consola
El valor se incrementa o decrementa después se evalúa la expresión. A menudo, esto crea confusión y se muestra en el siguiente ejemplo:
int x = 1;
println(x++); // Imprime “1” en la consola
println(x); /7 Imprime “2” en la consola
Para actualizar el valor antes de que se evalúe la expresión, coloca el operador delante de la variable.
int x = 1;
println(++x);
println(x);
El operador suma asignación += combina la suma y la asignación. El operador de asignación de resta - = combina con la asignación de resta:
int x = 1;
println(x);
x += 5;
println(x);
_____________________________
int y = 1;
println(y);
y -= 5;
println(y);
El operador de multiplicación de asignación *= combina con la multiplicación de asignación. El operador de asignación de división /= combina con la asignación:
int x = 4;
println(x); // Imprime “4” en la consola
x * 2; // Equivale a x = x * 2
println(x); // Imprime “8” en la consola
______________________________
int y = 4;
println(y); // Imprime “4” en la consola
y /= 2; // Equivale a y = y / 2
println(y);
El operador de negación - cambia el signo del valor a su derecha. Se puede utilizar en lugar de la multiplicación de un valor por -1.
int x = 5; /7 Asigna 5 a x
x = -x; // Equivale a x = x * -1
println(x); // Imprime “-5” en la consola
No hay comentarios:
Publicar un comentario