UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

(Universidad del Perú, DECANA DE AMÉRICA)

FACULTAD DE QUÍMICA E INGENIERÍA QUÍMICA

Laboratorio N°1

Grupo 3 (Integrantes):

Curo Benites, Pierre Antonio

De la Cruz Huamani, Juan Diego

Laguna Jiménez, Luis André

Saenz Chirinos, Christopher Willian

Tantalean Sarmiento, Sebastian Jose

Profesora:

Juana Sandivar Rosas

Lima, 2024
Introduccion

En el vasto panorama de las matemáticas y la ingeniería, la precisión y la eficiencia son pilares

fundamentales para el desarrollo de modelos y la resolución de problemas complejos. En este
contexto, las series de Taylor y Maclaurin emergen como herramientas esenciales que permiten
aproximar funciones de manera local y global con un grado de exactitud ajustable. En el curso de
Métodos Numéricos, el uso de estas series se convierte en un recurso imprescindible para
abordar diversas situaciones, desde la aproximación de funciones hasta la resolución de
ecuaciones diferenciales.

Las series de Taylor y Maclaurin son técnicas que nos permiten expresar funciones como sumas
infinitas de términos polinómicos. Estas expansiones tienen aplicaciones profundas en la
aproximación de funciones complicadas, donde la precisión es crucial pero los cálculos directos
son inmanejables. Al emplear estas series, podemos descomponer funciones en componentes
más simples, facilitando así su manipulación y análisis numérico.

En este informe, explicaremos la importancia del uso de las series de Taylor y Maclaurin en el
contexto de los Métodos Numéricos. Veremos cómo estas herramientas nos permiten obtener
aproximaciones confiables de funciones complejas, optimizando así los procesos de cálculo y
modelado en diversas áreas de la ingeniería, las ciencias físicas y la computación.
Marco Teorico

Métodos Numéricos de aproximación

Son técnicas matemáticas y computacionales utilizadas para obtener aproximaciones numéricas

de valores o soluciones que pueden ser difíciles o imposibles de calcular de forma exacta. Estos
métodos se aplican ampliamente en diversas áreas como la ingeniería, la física, la economía, la
ciencia de datos y muchas otras disciplinas donde se requiere resolver problemas prácticos que
involucran cálculos numéricos complejos. Algunos ejemplos podrían ser:

● Método de Newton-Raphson: Utilizado para encontrar las raíces de una ecuación no

lineal. Se basa en iteraciones sucesivas para acercarse a la solución.
● Interpolación: Utilizado para estimar valores intermedios entre puntos dados en un
conjunto de datos. Métodos como el de Lagrange o el de interpolación polinómica de
Newton son ejemplos de esto.
● Métodos de aproximación de integrales: Incluyen técnicas como la regla del trapecio, la
regla de Simpson y la integración numérica mediante cuadraturas, que se utilizan para
aproximar el valor de una integral definida.
● Métodos de aproximación de derivadas: Utilizados para calcular derivadas numéricas,
como el método de diferencias finitas.
● Series de Taylor y Maclaurin: Son utilizadas para aproximar funciones mediante
polinomios, lo que permite simplificar cálculos y obtener resultados precisos en ciertos
rangos.

Serie de Taylor

La serie de Taylor es una herramienta matemática que permite aproximar funciones continuas
mediante polinomios. Se basa en expresar una función como una suma infinita de términos
polinomiales, donde cada término se calcula en función de las derivadas de la función original en
un punto específico. Al truncar la serie después de un número finito de términos, se obtiene una
aproximación polinomial de la función original, cuya precisión aumenta cuanto más términos se
incluyan. Esta aproximación es útil en métodos numéricos para simplificar el cálculo y la
manipulación de funciones complicadas, y se aplica ampliamente en campos como el cálculo, la
física, la ingeniería y la computación.

Serie de Maclaurin

En la serie de Maclaurin, los términos de la serie de Taylor están evaluados en x = 0, lo que

simplifica los cálculos y hace que la aproximación sea especialmente útil para funciones
centradas en el origen. Esta serie es fundamental en cálculo y análisis numérico, y se utiliza
ampliamente en la aproximación de funciones y en la resolución de problemas en diversos
campos científicos y tecnológicos.

Error Relativo

El error relativo es una medida que evalúa la precisión de una aproximación numérica en
comparación con el valor verdadero de una cantidad. Se calcula como la diferencia entre el valor
aproximado y el valor verdadero, dividida por el valor verdadero y expresada como un
porcentaje. Esta métrica es fundamental en métodos numéricos para determinar la confiabilidad
de los resultados obtenidos y es crucial en aplicaciones donde se requiere alta precisión, como en
ingeniería, ciencia y modelización matemática.
Error Absoluto

El error absoluto es una medida que cuantifica la discrepancia entre el valor aproximado de una
cantidad y su valor verdadero, sin considerar la dirección de la discrepancia. Se calcula como la
diferencia entre el valor aproximado y el valor verdadero. Cuanto menor sea el valor del error
absoluto, más precisa será la aproximación. Esta métrica es fundamental en métodos numéricos
para evaluar la precisión de los cálculos y es esencial en campos como la ingeniería, la física y la
estadística, donde la precisión de los resultados es crítica.
Desarrollo de Problemas
CODIGO:

function problema2()
disp('Hallamos el error de primer orden de la velocidad (v)')
disp('v = g*m/c*(1-exp(-c/m*t))')
// Introducimos los datos del problema
// Aceleración de la gravedad
g = 9.81;
// Coeficiente de resistencia del aire
c = 12.5;
// Ingreso de la masa en kg
m = input('Ingrese la masa (kg): ');
// Ingreso de un tiempo dado en segundos
t = input('Ingrese el tiempo (s): ');
// Margen error del coeficiente de resistencia
dc = input('Margen error del coeficiente de resistencia: ');
// Cálculo de la velocidad
v = g*m/c*(1-exp(-c/m*t));
printf('La velocidad con respecto al tiempo dado en m/s es %5.6f\n', v);
if dc == 1.5 then
// Cálculo de la derivada parcial de v respecto a c
dvdc = (c*g*t*(exp((-c/m)*t))-(g*m*(1-exp((-c/m)*t))))/(c^2);
// Cálculo del valor de la incertidumbre
df = abs(dvdc)*dc;
printf('El valor de la incertidumbre es %5.6f\n', df);
end
rpta = "Por lo tanto la velocidad en un tiempo de " + string(t) + " seg es " + string(v) + " m/s, con un margen de
error del " + string(df);
disp(rpta)
endfunction

PRUEBA DE ESCRITORIO
DIAGRAMA DE FLUJO:
Diagrama de flujo
CODIGO:

function Ejercicio_3()
//Introducimos un ciclo while
resp = 's' ;
while resp =='s'
printf('Desarrolle la serie de Maclaurin y trunque en el cuarto término. Luego halle el error de truncamiento\n\n')
printf( ' 1) f(x)=cos(x)/(1+x) ; w = 0,5 \n')
printf( ' 2) f(x)=tan(x) ; w = 0,3 \n\n')
opc=input(' Elija una opción: ')
switch opc
case 1 then
w=input(" Ingrese valor de w a evaluar: ")
Valor_real=(cos(w))/(1+w)
printf(" Valor real: %7f \n\n",Valor_real)
FC=cos(0)/(1+0);//Evaluando la función en cero
printf(' La función valuada en 0 (FC) = %7f \n\n',FC)
printf(" La primera derivada (PD) tiene la forma: \n -sin(x)/(x+1)-cos(x)/(x+1)^2 \n")
PD=-sin(0)/(0+1)-cos(0)/(0+1)^2
printf(' Valuando en 0 obtenemos = %7f \n\n',PD)
printf(" La segunda derivada (SD) tiene la forma: \n 2((x+1)*sin(x)+cos(x))/(x+1)^3-cos(x)/(x+1) \n")
SD=2*((0+1)*sin(0)+cos(0))/(0+1)^3-cos(0)/(0+1)
printf(' Valuando en 0 obtenemos = %7f \n\n',SD)
printf(" La tercera derivada (TD) tiene la forma: \n
-6*((x+1)*sin(x)+cos(x))/(x+1)^4+sen(x)/(x+1)+3*cos(x)/(x+1)^2 \n")
TD=-6*((0+1)*sin(0)+cos(0))/(0+1)^4+sin(0)/(0+1)+3*cos(0)/(0+1)^2
printf(" Valuando en 0 obtenemos = %7f \n\n",TD)
Aprox_Maclaurin=FC+PD*w+SD*w^2/factorial(2)+TD*w^3/factorial(3)
Error=Valor_real-Aprox_Maclaurin
//Introducimos una tabla con los valores obtenidos
printf('\n')

printf("\t===================================================================================
===========\n")
printf("\t%s\t\t\t%s\t\t\t%s\n", 'Valor verdadero', 'Valor Aproximado', 'Error de truncamiento')
printf("%18f\t\t\t\t%f\t\t\t\t%f\n", Valor_real, Aprox_Maclaurin, Error)

printf("\t===================================================================================
===========\n")
case 2 then
w=input(" Ingrese valor de w a evaluar: ")
Valor_real=tan(w)
printf(" Valor real: %7f \n\n",Valor_real)
FC=tan(0); //Evaluando la función en cero
printf(" La función valuada en 0 (FC) = %7f \n\n",FC)
printf(" La primera derivada (PD) tiene la forma:\n 1/cos(x)^2.\n")
PD=1/cos(0)^2
printf(" Valuando en 0 obtenemos: %7f \n\n",PD)
printf(" La segunda derivada (SD) tiene la forma:\n 2*1/cos(x)^2*sin(x)/cos(x).\n")
SD=2*1/cos(0)^2*sin(0)/cos(0)
printf(" Valuando en 0 obtenemos: %7f \n\n", SD)
printf(" La tercera derivada (TD) tiene la forma:\n 4*1/cos(x)^2*sin(x)^2/cos(x)^2+2*1/cos(x)^4.\n")
TD=4*1/cos(0)^2*sin(0)^2/cos(0)^2+2*1/cos(0)^4
printf(" Valuando en 0 obtenemos: %7f \n\n",TD)
 Aprox_Maclaurin=FC+PD*w+SD*w^2/factorial(2)+TD*w^3/factorial(3)
Error=Valor_real-Aprox_Maclaurin
//Introducimos una tabla con los valores obtenidos
printf('\n')

printf("\t===================================================================================
===========\n")
printf("\t%s\t\t\t%s\t\t\t%s\n", 'Valor verdadero', 'Valor Aproximado', 'Error de truncamiento')
printf("%18f\t\t\t\t%f\t\t\t\t%f\n", Valor_real, Aprox_Maclaurin, Error)

printf("\t===================================================================================
===========\n")
otherwise
disp(' Opción incorrecta ');
end
// para salir de la estructura repititva while controlada por el usuario
resp=input('Si desea repetir otra opcion del MENU presione s: ','s');
end //fin del while
endfunction
Diagrama de Flujo
Codigo

function [resultado, error_rel, num_iteraciones,

valor_verdadero]=coseno_maclaurin(x, es, maxit)
n = 0;

es_valor = input('¿Deseas establecer un valor para el criterio de detención? (1) Sí /

(2) No: ');
if es_valor == 1 then
es = input('Ingresa el valor del criterio de detención: ');
 else
es = 0.000001;
disp('El valor por defecto para el criterio de detención será ' + string(es));
end

maxit_valor = input('¿Deseas establecer un número máximo de iteraciones? (1) Sí /

(2) No: ');
if maxit_valor == 1 then
maxit = input('Ingresa el número máximo de iteraciones: ');
else
maxit = 100;
disp('El número máximo de iteraciones por defecto será ' + string(maxit));
end

resultado_aprox = 0;
error_rel_aprox = 1.0; // Un valor mayor que es para entrar al bucle

valor_verdadero = cos(x);

while error_rel_aprox > es && n < maxit

termino_n = ((-1)^n) * (x^(2*n)) / factorial(2*n);
resultado_aprox = resultado_aprox + termino_n;

if resultado_aprox ~= 0 then
error_rel_aprox = abs((resultado_aprox - valor_verdadero) / resultado_aprox);
else
error_rel_aprox = 0;
end

n = n + 1;
end

resultado = resultado_aprox;
error_rel = error_rel_aprox;
num_iteraciones = n;
valor_verdadero = cos(x);
endfunction

x = input('Ingresa el valor de x en radianes para calcular cos(x): ');

[resultado, error_rel, num_iteraciones, valor_verdadero] = coseno_maclaurin(x,
0.000001, 100);

printf('Valor estimado de cos(%f): %f\n', x, resultado);

printf('Error relativo aproximado: %f\n', error_rel);
printf('Número de iteraciones: %d\n', num_iteraciones);
printf('Valor verdadero de cos(%f): %f\n', x, valor_verdadero);

Prueba de escritorio
Diagrama de flujo
function maclaurin()
x = %pi / 3;
f0 = cos(0);
valor_inicial_error = 0;
valor_exacto = cos(%pi / 3);

// Indicamos el número de términos que queremos

terminos = input("¿Cuántos términos desea en la serie? ");

// Iniciamos un ciclo for para la serie de coseno

for n = 0:terminos
f_coseno = f0 + ((-1)^n * (x^(2*n))) / factorial(2*n);
Ev = ((valor_exacto - f_coseno) / valor_exacto) * 100;
printf("El error verdadero es: %f%%\n", Ev);
Ea = abs(((f_coseno - valor_inicial_error) / f_coseno) * 100);
printf("El error aproximado es: %f%%\n", Ea);
valor_inicial_error = f_coseno;
end
// Colocamos un IF para que nos muestre cuándo el error es o no el adecuado (2 cifras
significativas)
if Ea > 0.01 then
 disp("El error aún es muy grande. ¡Incremente el número de términos!");
else
disp("El error aproximado es lo suficientemente pequeño.");
end
endfunction

Fig 1. Problema 4.2 con 3 términos.

Fig 2. Problema 4.2 con 5 términos.

Viendo la sección 4.2, tenemos lo siguiente:
Suponga que se tiene la función f(x) que es dependiente de una sola variable independiente x.
Considere que 𝑥 es una aproximación de x. Se desearía evaluar el efecto de la discrepancia entre
x y 𝑥.
Utilizando la serie de Taylor para calcular f(x) cerca de f(𝑥).
(Recordando que no se tomará los de segundo orden y orden superior)

El enfoque anterior puede generalizarse a funciones que sean dependientes de más de una
variable independiente, lo cual se realiza con una versión para varias variables de la serie de
Taylor. (Recordando que no se tomará los de segundo orden y orden superior)

donde ∆𝑢y ∆𝑣 son estimaciones del error en u y v, respectivamente.

Teniendo esto en cuenta podemos hacer lo que nos piden:
Código scilab:
function problema4_14_lab1()
disp("adición y sustracción");
disp("f(u,y)=u+v o f(u,y)=u-v"); //u y v son numeros inexactos
u = poly(0, 'u');
fu=u
dfu=derivat(fu);
v = poly(0, 'v');
fv=v
dfv=derivat(fv);
disp("△f(u,y)=|df/du|*△u+|df/dv|*△v");
disp("|df/du|=",dfu);
disp("|df/dv|=",dfv);
disp("△f(u,y)=△u+△v")
disp("multiplicación");
disp("f(u,y)=u.v"); //u y v son numeros inexactos
disp("△f(u,y)=|df/du|*△u+|df/dv|*△v");
disp("|df/du|=|v|");
disp("|df/dv|=|u|");
disp("△f(u,y)=|v|△u+|u|△v");
disp("división");
disp("f(u,y)=u/v"); //u y v son numeros inexactos
disp("△f(u,y)=|df/du|*△u+|df/dv|*△v");
 disp("|df/du|=1/|v|");
disp("|df/dv|=-|u|/|v|^2");
disp("△f(u,y)=(|v|△u+|u|△v)/|v|^2");
endfunction
problema4_14_lab1();
Ventana de comandos:

Conclusiones
● La serie de Taylor y la de Maclaurin sirven para las aproximaciones de los problemas
asignados. A partir de ello se calculó los errores relativos y absolutos para determinar la
precisión de los resultados de los problemas.
Bibliografia
McGregor, C & Stothers, W. (2010). Numerical Methods.
https://www.sciencedirect.com/topics/mathematics/numerical-methods
Mortimer, R & Blinder, S. (2024). Taylor Series.
https://www.sciencedirect.com/topics/mathematics/taylor-series