duduromeroa.com

Programación web

Aritmética con Javascript (01)


Los lenguajes de programación usan palabras y signos para operar números. Daré ejemplos de eso con Javascript, el lenguaje de programación de la web.

George Póyla, matemático. Resolver problemas de diseño. www.duduromeroa.com

Por Eduardo J. Romero Andrade

Guayaquil, Ecuador

Contacto duduromeroa@gmail.com


#aritmetica, #javascript, #Guayaquil, #duduromeroa, #programacion


Si deseas revisar los conceptos generales y avanzados en Javascript, por favor puedes ir a esta sección, o a la bibliografía al final de esa sección.



SUBTEMAS ¿Qué es Javascript?, los números, conjuntos de números, números reales, propiedades de los números reales, complejos, orden de ejecución de las operaciones, calcular el peso de un elemento según un peso general dado.


¿Qué es Javascript?

Según el contenido de esta sección, los lenguajes de programación son el idioma que las computadores leen e interpretan para ejecutar acciones y mostrarlas a usuario, como el cálculo de números, la lectura y posición de coordenadas, entre otros.

Programar es crear acciones que sean reconocibles por sistemas. Programar también refiere a insertar, leer, transformar y mostrar datos desde un sistema a otro, y obtenerlos perceptibles desde un soporte, como una pantalla.

El lenguaje llamado Javascript –Java, por la referencia a otro lenguaje de programación; y script, un anglicismo usado para definir que algo es redactado según ciertas normas– es un conjunto de sintaxis y palabras claves que es interpretado (leído y decodificado) por el programa navegador web de toda computadora o soporte electrónico en línea, y desde toda página web.

Javascript será el lenguaje de programación que usaré para explicar muchos conceptos aritméticos, y explicar así como un lenguaje de programación usa, leer y opera cantidades.

Los números

Son un antiguo invento humano para representar unidades y conjuntos del mundo real. Por ejemplo, una manzana (una unidad) puede ser dividida en porciones o subporciones (fracciones) cuyos conjuntos mantengan una relación uno a uno (pares); o por el contrario, que no guarden esa relación entre las partes (impares).

Representado desde variables y declarando cada valor:

En Javascript

var porciones = 10;
var personas = 5;
var aCadaUno = porciones / personas;

console.log("A cada uno le tocan " + aCadaUno + " pedazos");
// A cada uno le tocan 2 pedazos

O desde una función en JS. Esta permite generar resultados por cada ingreso de valores:

En Javascript

function partirManzana(porciones, personas) {
// Variable global
  let txt;

// Obtenemos residuo al ser divido para 2
     if (porciones % 2 === 0) {
     txt = "La cantidad de pedazos es par";
     // Muestra
     console.log(txt);
     } else {
     txt = "La cantidad de pedazos es impar";
     // Muestra
     console.log(txt);
     }

/* Fuera de la condicional, retornamos valores de argumentos */
   return porciones / personas;
}

// Agregamos valores a argumento
console.log("A cada uno le toca " + partirManzana(20, 5) + " pedazos");
// La cantidad de pedazos es par. A cada uno le toca 4 pedazos

console.log("A cada uno le toca " + partirManzana(7, 5) + " pedazos");
// La cantidad de pedazos es impar. A cada uno le toca 1.4 pedazos

Conjuntos de números

Para explicarlos, usaré un tipo de dato en JS conocido como arreglo (array). Los arreglos son conjuntos de elementos enumerados con un índice que los ubica en cada conjunto:

En Javascript, el objeto Math permite obtener números irracionales (aquellos con decimales infinitos que no se logran con la división de dos números enteros), como el PI . También, mediante la función sqrt() podemos lograr otros números irracionales, como la raíz cuadrada de 2, o de 3.

En Javascript

// Todos los números que pueden contarse (el cero no)
let naturales = [1,2,3,4, "etc"];

// Toda los números, incluído el cero
let enteros = [-5, -4, -3, -2, -1, 0, 1, 2, 3, "etc"];

// Todos los números en forma de cociente (resultado) entre dos números
let racionales = [1/2, 1/4, 1/1, "etc"];

// Números con decimales infinitos con iteración sin patrón
// Números que no son el resultado de dividor dos números ENTEROS
let irracionales = [Math.PI, Math.sqrt(2)];

// Invocamos el índice (desde cero) de cada elemento
console.log(naturales[0]);
// 1
console.log(enteros[4]);
// -1
console.log(racionales[1]);
// 0.25
console.log(irracionales[0]);
// 3.141592653589793
console.log(irracionales[1]);
// 3.141592653589793

// Operamos
let resul = enteros[0] * racionales[1];
console.log(resul);
// -1.25

El cálculo del área de una circunferencia también es un número irracional. Si tomamos la longitud de la línea exterior de cualquier círculo perfecto, y la dividimos para su radio (distancia del centro del círculo hacia cualquiera de sus lados) el resultado siempre será un número aproximado a PI (3.14159265358979...):

En Javascript

let longitud_Circunferencia = 22;
let radio_delcentro_a_unLado = 7;

console.log(longitud_Circunferencia / radio_delcentro_a_unLado );
// 3.142857142857143

Números reales

Es el conjunto de todos los demás subconjuntos de números. Un número real es el resultado de operar entre números racionales y números irracionales. Todos estos números contienen propiedades obvias que nunca podrán ser alteradas:

Algunas de las propiedades de los números reales

Antes de eso, debemos entender los números recíprocos. Un recíproco es el resultado de multiplicar un número por su original, dando como resultado siempre el número 1. Para que ese sea el resultado, el segundo término debe ser una fracción con el denominador del número inicial. En JS sería:

En Javascript

// Multiplicación común
console.log(2*2);
// 4

// Multiplicar un número por su recíproco (igual número) 
console.log(2 * (1/2))

// Multiplicación con recíproco
console.log(10 * (1/10));
// 1

// Multiplicación con recíproco
console.log(1.998 * (1/1.998));
// 1

¿Por qué el resultado siempre será uno?: tacha los dos números similares, y siempre quedará el 1.

Unas de las propiedades de los números reales, desde JS, son las siguientes. Tener atención a cómo en JS ocurre la multiplicación: mediante el signo *.

En Javascript

// La suma del mismo negativo con el positivo da cero
console.log(1+(-1)); // 0

// Negativos se suman
console.log(1-(-1)); // 2

// El producto del mismo negativo con el positivo da el negativo
console.log(1*(-1)); // -1

// La división del mismo negativo con el positivo da el negativo
console.log(1/(-1)); // -1

// Multiplicar un número por su recíproco (igual número) 
console.log(2*(1/2))
console.log(1234*(1/1234))
// Ambos dan 1

// Ley distributiva:
// OJO con la declaración desde un solo tipo de variable 
let a = 1, b = 3, c = 4;

// Ojo como ocurre la multiplicación (con *)
console.log(a*(b+c) === (a*b) + (a*c));
// TRUE. Ambos dan igual resultado

console.log(a*(b+c));
console.log((a*b) + (a*c));
// Ambos dan 7

La Ley distributiva da un resultado interesante: teniendo 3 números mayores a cero, podemos multiplicar el primero con la suma en correcta secuencia del resto; o podemos multipilicar el primer número con el segundo y luego con el tercero, para luego sumar esos resultados. En ambos casos, será el dará igual resultado.

Números complejos

Es la expresión (el conjunto aritmético de operaciones y valores) que contiene un número real y otro imaginario. ¿Cómo es eso posible?

Un número imaginario es un concepto matemático para decir que un número o una cantidad es desconocida pero posible. El estudio de los números imaginarios inició desde los años 1500 en matemáticos italianos como Nicolo Tartaglia, Girolamo Cardano, Rafael Bombelli; y en 1600 con el alemán Gottfried Wilhelm Leibniz. Javascript no cuenta con un valor representativo del número imaginario-matemático, pero librerías como Math.js cuentan con módulos de código para generar ecuaciones con ese valor, muy usado para resolver problemas de transmisión de voltajes en electrónica.

Un número imaginario clásico (desconocemos si es negativo o positivo, mayor o menor a otros números) (Soto, 2013, p. 18) es el resultado imposible de extraer la raíz cuadrada de un número negativo. Nuevamente, JS solo puede expresar esa operación, pero su resultado sera llamado NaN (Not a number). Por lo tanto no será operable.

En Javascript

console.log(Math.sqrt(-1));
// NaN 

Finalmente, la ley de signos en JS:

En Javascript

// Multplicar signos iguales
console.log((+10) * (+10));
// 100 --> Da positivo

// Multplicar + por -
console.log((+10) * (-10));
// Multplicar - por +
console.log((-10) * (+10));
// -100 --> Ambos dan negativo

// Multplicar - por -
console.log((-10) * (-10));
// 100 --> Da positivo

Orden de ejecución de las operaciones

Según Apolinar (2013, p.22) el correcto orden para operar es: primero resolver desde los paréntesis; luego potencias y raíces; luego multiplicación y división; y finalmente sumas y restas.

En Javascript

// Concatenar variables y valores
// Primero paréntesis
let a = 5, b = 10, c = 10;
console.log(10 - (a + b) + (a + a));

/*
(a+b) 15
(a+a) 10
Sumados dan 25
-10 = 5
*/

// ===

// Primero multiplicar y dividir, sin paréntesis
let a = 5, b = 10, c = 10;
console.log(10 + a * b + a / a );

/*
(a * b) 50
(a * a) 1
Sumados da 61
-10 = 5
*/

// ===
// Qué orden de operación se siguió allí?
let a = 50, b = 100, c = 100;

console.log(Math.sqrt(10) * a / b + 1000);
/* Primero raíz, luego multiplicar, luego dividir, luego suma */
// 1001.5811388300842

Luego, para redondear las cifras con decimales, podemos usar la función Math.floor(), que redondea al entero inmediato inferior de la cifra decimal; y en cuyo parámetro podremos agregar toda la operación aritmética.

En Javascript

let a = 50, b = 100, c = 100;
console.log(Math.floor( Math.sqrt(10) * a / b + 1000) );
// 1001

Y qué si necesitamos más de una raíz cuadrada?:

En Javascript

let a = 100, b = 200, c = 300;

console.log(Math.floor(
Math.sqrt(a) * Math.sqrt(b) -
Math.sqrt(b) * Math.sqrt(c)) 
);
// -104

Y si necesitamos elevar toda esa operación a una potencia?. En el siguiente ejemplo se debe cuidar cómo anidamos las funciones dentro de cada función. Especialmente la función que genera la potencia de un valor, como es Math.POW(num, potencia), en donde el segundo parámetro es la potencia aplicada:

En Javascript

let a = 1100, b = 1200, c = 1300;
console.log( 
Math.floor(
Math.pow(
Math.sqrt(a) * Math.sqrt(b) -
Math.sqrt(b) * Math.sqrt(c), 2) 
));
// 10017

Calcular el peso de un elemento según un peso general dado

5 papas pesaron juntas un kilogramo. ¿Cuánto pesa cada papa?. La solución es dividir la cantidad de unidades del kilo (es decir, los gramos) para la cantidad de unidades del producto. Tener en cuenta que la función valor. toFixed ( cantidadDecimal ) permite ajustar la cantidad de decimales del valor final.

En Javascript

// VARIABLES
let papasCantidad = 40;
let  pesoTotal_papas_Kg = 1;
const gramos_porKg = 1000; 
// Gramaje para cantidad de unidades
let  resultado = gramos_porKg / papasCantidad;

console.log( "En " + 
pesoTotal_papas_Kg + 
     "Kg de papas, cada una de las " + 
papasCantidad + 
     " papas pesa " +  resultado.toFixed(2) + 
     " gramos." );
 
/* En 1Kg de papas, cada una de las 40 papas pesa 25.00 gramos.  */

En el ejercicio anterior, cada valor esta alojado en un nombre de variable. Así, si deseamos usar otras cantidades, la operación reflejará el resultado según ese contexto.