Expresiones matemáticas

En la asignatura se resuelven problemas matemáticos empleando métodos numéricos. Los métodos numéricos se caracterizan porque permiten resolver problemas matemáticos complejos, con simples operaciones aritméticas (suma, resta, multiplicación y división), sin embargo, se requieren cientos, miles y hasta millones de operaciones aritméticas para encontrar un resultado, por lo que la aplicación práctica de los métodos numéricos, sólo es posible con la ayuda de computadoras y/o dispositivos programables (computadoras, tabletas, teléfonos inteligentes, calculadoras programables, etc.).

Para resolver problemas matemáticos con la ayuda de los métodos numéricos, se debe programar la expresión matemática o modelo matemático del problema a resolver y la forma más eficiente y ordenada de hacerlo es mediante la elaboración de funciones, por esa razón, las funciones son elementos fundamentales en la aplicación de los métodos numéricos.

Por esa razón, en este capítulo se hace un breve repaso de las expresiones matemáticas y las diferentes formas de programar funciones.

En la asignatura, al igual que en la asignatura previa (MAT204), se emplea como principal lenguaje de programación Javascript y para escribir y emplear los programas, se emplea la calculadora Javascript.

No obstante, en la asignatura se emplearán también otras herramientas y aplicaciones, principalmente: Octave, MatLab, Mathematica y Python.

Operadores y funciones matemáticas

Como se recordará, en Javascript, se pueden emplear los siguientes operadores aritméticos, para escribir expresiones matemáticas:

Operadores Matemáticos
+Suma
-Resta
*Multiplicación
/División
%Residuo (módulo)
**Potencia

Así, por ejemplo, para calcular el valor de la siguiente expresión:

\[{2^{7.2}-7 \times 8.2} \over {4.5+ \dfrac{9.2}{5.6}}\]

Se escribe y evalúa (con Shift+Enter) la siguiente expresión en la calculadora:

(2**7.2-7*8.2)/(4.5+9.2/5.6)

Como también se recordará, las funciones matemáticas disponibles en el objeto Math, de JavaScript, son las siguientes:

Funciones Matemáticas Predefinidas
abs(x)Valor absoluto de "x".
acos(x)Arco coseno de "x".
acosh(x)Arco coseno hiperbólico de "x".
asin(x)Arco seno de "x" (resultado en radianes).
asinh(x)Arco seno hiperbólico de "x".
atan(x)Arco tangente de "x".
atanh(x)Arco tangente hiperbólico de "x".
atan2(y,x)Arco tangente del cociente de "y" entre "x".
cbrt(x)Raíz cúbica de "x".
ceil(x)Entero más cercano mayor o igual a "x".
clz32(x)Número de ceros iniciales del entero "x" de 32 bits.
cos(x)Coseno de "x".
cosh(x)Coseno hiperbólico de "x".
exp(x)Exponente de "x": \( e^x \).
expm1(x)Devuelve \( e^x-1 \).
floor(x)Entero más cercano menor o igual "x".
fround(x)Devuelve el número real de simple precisión más cercano a "x".
hypot([x[,y[, ...]]])Raiz cuadrada de la suma de los cuadrados de "x", "y", ...
imul(x,y)Multiplica los enteros de 32 bits "x" y "y".
log(x)Logaritmo natural de "x": \( \ln(x)\).
log1p(x)Logaritmo natural de "1+x": \(\ln(1+x)\).
log10(x)Logaritmo en base 10 de "x": \(\log(x)\).
log2(x)Logaritmo en base 2 de "x": \(\log_{{}_2}(x)\).
max([x[,[y[, ...]]]])Mayor de los números "x", "y", ...
min([x[,[y[, ...]]]])Menor de los números "x", "y", ...
pow(x,y)"x" elevado a "y", (\(x^y\)), igual a x**y.
random()Número aleatorio comprendido entre 0 y 1.
round(x)Redondea "x" al entero más cercano.
sign(x)Devuelve 1, si "x" es positivo, -1 si es negativo y 0 si es cero.
sin(x)Seno del "x".
sinh(x)Seno hiperbólico de "x".
sqrt(x)Raíz cuadrada de "x".
tan(x)Tangente del "x" ("x" en radianes).
tanh(x)Tangente hiperbólica de "x".
trunc(x)Parte entera de "x".

Donde, en las funciones trigonométricas, los ángulos deben estar en radianes.

Además, en la calculadora Javascript, se pueden emplear también las siguientes funciones matemáticas.

Funciones Matemáticas Adicionales
cot(x)Cotangente de "x".
coth(x)Cotangente hiperbólica de "x".
csc(x)Cosecante de "x".
csch(x)Cosecante hiperbólica de "x".
even(x)Verdadero si "x" es par.
factorial(x)Factorial de "x".
frac(x)Parte fraccionaria de "x".
log(b,x)Logaritmo en base "b" de "x".
odd(x)Verdadero si "x" es impar.
quot(x,y)Cociente (parte entera) de "x/y".
sec(x)Secante de "x".
sech(x)Secante hiperbólica de "x".
sqr(x)Cuadrado de "x" (x2).
toDeg(x)Convierte "x" de radianes a grados.
toRad(x)Convierte "x" de grados a radianes.
nthroot(x,n)Raíz enésima (n) de "x".

Además, el objeto Math cuenta con las siguientes constantes:

Constantes Matemáticas Predefinidas
ENúmero de Euler.
LN2Logaritmo natural de 2.
LN10Logaritmo natural de 10.
LOG2ELogaritmo en base 2 del número de Euler.
LOG10ELogaritmo en base 10 del número de Euler.
PINúmero pi.
SQRT1_2 Raíz cuadrada de 1/2.
SQRT2Raíz cuadrada de 2.

Que, como se sabe, se emplean igual que las funciones sólo que no se escribe paréntesis después del nombre.

Se recuerda también que en programación, los nombres de las variables, funciones, constantes, objetos, etc., se conocen como identificadores.

Y aunque no es una regla, sino una convención, los nombres de las constantes se escriben en mayúsculas (como SQRT2) y si son nombres compuestos, las palabras que componen el nombre, se separan con guiones bajos (como en MAX_INTEGER). Los nombres de las variables y funciones se escriben en minúsculas (como en floor) y si son nombres compuestos, la segunda y subsiguientes palabras, que componen el nombre, se escriben con la letra inicial en mayúsculas (como en firstElementChild). Las clases (y objetos constructores) se escriben con la letra inicial en mayúsculas (como ocurre con la clase Math).

Además, Javascript, diferencia entre mayúsculas y minúsculas, por lo tanto, para Javascript, Math y math son nombres diferentes.

Debido a que, es muy fácil olvidar tanto las funciones como las diferentes instrucciones de un lenguaje, es conveniente contar con una ayuda memoria. En el caso de la calculadora y gracias a CodeMirror se cuenta con esa ayuda y se accede a la misma pulsando las teclas Ctrl+Espacio, como se muestra en el siguiente video:

Es conveniente acostumbrarse a emplear este procedimiento no sólo como una ayuda memoria, sino para acelerar la escritura de código y reducir los errores.

Empleando paréntesis y las funciones matemáticas de Javascript, se puede calcular el valor de prácticamente cualquier expresión matemática.

Por ejemplo, para calcular el valor de la siguiente expresiones matemáticas:

\[\sqrt{{\sin(4.5)-\cos(1.2)}\over{\tan(2.3)}}\]

Se escribe en la calculadora:

Math.sqrt((Math.sin(4.5)-Math.cos(1.2))/Math.tan(2.3))

Y para calcular el valor de la siguiente expresión:

\[\Big({\sin(1.2)+\cos(3.1)+\tan(0.7)}\Big)^{0.32}\]

Se escribe:

(Math.sin(1.2)+Math.cos(3.1)+Math.tan(0.7))**0.32

Que también puede ser calculada con pow:

Math.pow(Math.sin(1.2)+Math.cos(3.1)+Math.tan(0.7),0.32)

Como se puede recordará, en Javascript y en los lenguajes de programación en general, casi siempre existe más de una forma de resolver el mismo problema.

En la calculadora, como ocurre en la mayoría de los editores, para deshacer la última acción se pulsan las teclas Ctrl+Z. Si bien es posible copiar y pegar en la forma estándar (Ctrl+C y Ctrl+V o Ctrl+Arrastrar con el mouse) es más eficiente recuperar instrucciones anteriores pulsando las teclas Ctrl+Arriba y las teclas Ctrl+Abajo para instrucciones posteriores.

Por ejemplo para calcular los cosenos de 5, 7, 10, 15 y 25 radianes, se procede de la siguiente forma:

Se recomienda emplear el anterior procedimiento siempre que sea posible. Así, para calcular el valor de las siguientes expresiones (que sólo difieren en dos signos):

\[\sqrt{{3+4^{1.2}+6^{3.2}}\over{\text{e}^{6.5}+\cos(6.7)}}\] \[\sqrt{{3-4^{1.2}+6^{3.2}}\over{\text{e}^{6.5}-\cos(6.7)}}\]

Se procede de la siguiente manera:


Los siguientes ejercicios tienen el propósito de refrescar la memoria y reforzar las habilidades en la escritura de expresiones matemáticas.

Funciones

Como se recordará, las funciones en Javascript pueden ser creadas de varias maneras, siendo la forma estándar la siguiente:

function Nombre_de_la_función(lista_de_parámetros) { // instrucciones Javascript return valor/expresión; }

Por ejemplo, la siguiente función devuelve la suma de los cubos de los tres números que recibe:

function sumCub(x, y, z) {
return x**3+y**3+z**3;
}
sumCub(1, 2, 3)
sumCub(5, 3, 4)
sumCub(1, 5, 9)

Una función puede ser creada también como una expresión literal empleando una función anónima:

var variable = function(lista_de_parámetros) { // instrucciones Javascript return valor/expresión; }

Así, la función sumCub, empleando una expresión literal, se crea de la siguiente forma:

var sumCub = function(x, y, z) {
return x**3+y**3+z**3;
}
sumCub(1, 2, 3)
sumCub(5, 3, 4)
sumCub(1, 5, 9)

Las funciones anónimas se invocan (ejecutan) inmediatamente, sin guardarlas en una variable, de acuerdo a la siguiente sintaxis:

(function(lista_de_parámetros) { // instrucciones Javascript })(datos_pasados_a_la_función);

O alternativamente:

(function(lista_de_parámetros) { // instrucciones Javascript }(datos_pasados_a_la_función));

Estas formas, conocidas como funciones IIFE (por su denominación en inglés: Inmediately Invoked Function Expressions), se emplean sobre todo cuando el programa debe ser ejecutado una sola vez. Así, si sólo se quiere calcular la suma de los cubos de 1, 5 y 9 y no de otros números, se puede emplear una función IIFE (pronunciada "ifi"):

(function(x, y, z) {
return x**3+y**3+z**3;
})(1, 5, 9)

O igualmente:

(function(x, y, z) {
return x**3+y**3+z**3;
}(1, 5, 9))

En realidad, como se recordará, los paréntesis se emplean únicamente para que Javascript trate a la palabra function como una expresión y no como la declaración de una función.

Las funciones también pueden ser creadas en forma de funciones flecha:

var Nombre_de_la_función = (lista_de_parámetros) => { // instrucciones Javascript return valor/expresión; }

Esta es una de las formas más útiles para programar expresiones y modelos matemáticos, por lo que será empleada frecuentemente en la materia.

Empleando una función flecha, la función sumCub, se crea de la siguiente forma:

var sumCub = (x, y, z) => x**3+y**3+z**3;
sumCub(1, 2, 3)
sumCub(5, 3, 4)
sumCub(1, 5, 9)

Como se puede ver en el ejemplo, si el cuerpo de la función sólo consta de una expresión, no se requieren ni llaves ni el comando return.

Si además la función sólo tiene un parámetro (sólo recibe un dato) tampoco son necesarios los paréntesis. Así, con la siguiente instrucción (que no emplea paréntesis) se crea una función para calcular el cubo de un número:

var cubo = x => x*x*x;
cubo(3)
cubo(5)
cubo(9)

Las funciones flecha son por defecto funciones anónimas y pueden ser empleadas también para crear funciones IIFE, así, con una función flecha, la IIFE creada previamente, es:

((x, y, z) => x**3+y**3+z**3)(1, 5, 9)

Es importante tener presente que, sin importar el tipo de función que se emplee, no cambian ni la lógica ni la forma en que se emplean las funciones.

Parámetros

Como se recordará, los parámetros de una función son los nombres de las variables (separadas con comas) en las que la función recibe los datos que requiere.

Los parámetros, al igual que las variables declaradas dentro de una función, sólo existen mientras la función está siendo ejecutada, luego, cuando la función termina, son destruidas, por esa razón son conocidas como variables locales o variables temporales.

Los parámetros normales son parámetros por valor. Este tipo de parámetro guarda una copia del valor que recibe, entonces, en la función se trabaja con la copia, por lo que el valor original no es modificado. Si no se manda un valor a este tipo de parámetros, JavaScript le asigna el valor undefined (indefinido).

Los parámetros también pueden ser por defecto. En este caso al parámetro se le asigna un valor (el valor por defecto). Si no se manda un valor a un parámetro de este tipo, toma su valor por defecto (no undefined, como ocurre con los parámetros por valor).

Los parámetros por defecto se emplean cuando es muy probable que deba recibir un determinado valor o cuando es necesario evitar que quede indefinido.

Por ejemplo, la siguiente función calcula la suma de hasta 5 números, pero, gracias a los parámetros por defecto, funciona igualmente si se le manda 4 o menos valores:

function suma(a=0, b=0, c=0, d=0, e=0) {
return a+b+c+d+e;
};
suma(1, 2, 3, 4, 5)
suma(1, 2, 3, 4)
suma(1, 2, 3)
suma(1, 2)
suma(1)
suma()

Los parámetros también pueden ser nombrados. En ese caso, no sólo se debe mandar el valor, sino también el nombre del parámetro. Este tipo de parámetros son de uso, casi obligado, cuando la función recibe tres o más parámetros. En esos casos es más fácil recordar el nombre de los parámetros que el orden en que fueron escritos.

Por ejemplo la siguiente función recibe cuatro números y calcula la raíz cuadrada de su suma. Como se puede ver, al ser creada con parámetros nombrados, puede ser llamada mandando los nombres:valores, en cualquier orden:

function sqrtSum({a, b, c, d}={}) {
return Math.sqrt(a+b+c+d);
};
sqrtSum({a:1, b:2, c:3, d:4})
sqrtSum({c:3, a:1, b:2, d:4})
sqrtSum({c:3, a:1, d:4, b:2})
sqrtSum({d:4, b:2, c:3, a:1})
sqrtSum({b:2, d:4, c:3, a:1})
sqrtSum({b:2, d:4, a:1, c:3})

La función sqrtSum, creada como una función flecha y con parámetros nombrados con valores por defecto, es:

var sqrtSum = ({a=0, b=0, c=0, d=0}={}) => Math.sqrt(a+b+c+d);
sqrtSum({a:1, c:3, d:4})
sqrtSum({c:3, d:4})
sqrtSum({b:2})
sqrtSum()

Se recuerda también que, las variables dentro de una función se declaran con las palabras reservadas let, cuando su valor es modificado o recalculado dentro de la función y const, cuando su valor no debe ser modificado dentro de la función.

Por ejemplo, para calcular el valor de la siguiente expresión:

\[ \begin{gathered} f(x) = 14.0 - x - y^2 - z^2 \\ y = \dfrac{3 x^{2.1}-7.0}{5} \\ z = \dfrac{14.3-y^{1.2}}{4} \end{gathered} \]

Se debe programar una función que reciba un parámetro (x) y donde las variables internas (y, z) deben ser declaradas como constantes, porque su valor no es modificado en la función.

La función, programada como una función flecha, es:

var f = x => {
const y = (3*x**2.1-7.0)/5;
const z = (14.3-y**1.2)/4;
return 14.0-x-y**2-z**2;
};
f(1.5)
f(3)
f(5.1)