UNIVERSIDAD SANTO TOMÁS - SEDE VILLAICENCIO

FACULTAD DE INGENIERÍA MECÁNICA

ESPACIO ACADÉMICO XX - GRUPO XX
DÍAS DE MES DEL 2020-2
Ley de enfriamiento de newton

LEY DE ENFRIAMIENTO DE NEWTON Y REGRESIONES

Daniela Ospina Rodríguez

Código: 2281199

INTRODUCCIÓN • Generar una opción capaz de genera el resultado

de la regresión con un coeficiente de
La ley de enfriamiento de Newton describe la velocidad en determinación más cercano a 1.
la que un objeto que es sometido a una temperatura distinta
a la que se encuentra inicialmente, presenta una tasa de DESCRICIÓN DEL PROBLEMA
pérdida o ganancia de calor, según sea el caso, que es
proporcional a la diferencia de temperatura del ambiente Describir el comportamiento de enfriamiento de un objeto
en el cual se encuentra sometido el objeto y la temperatura o en este caso una variedad de fluidos (agua, salmuera,
inicial del mismo. [1] aceite, aceite 20W50, jabones) suele tener complicaciones
si implementamos la ley de enfriamiento de Newton, la
Sin embargo, este comportamiento también se puede cual esta descrita por la Ec.1, que se podrá observar a
describir mediante el modelado estadístico como lo son las continuación, o esta ecuación no se ajusta completamente
regresiones, donde estas estiman las relaciones de una o a los datos obtenidos.
mas variables independientes, unas de las regresiones mas
implementadas es la regresión lineal, sin embargo, existen ECUACIONES
otras que se pueden ajustar mejor a los datos a estudiar.
Dentro de las ecuaciones que se van a implementar para
Por lo tanto, se busca implementar distintos tipos de llevar a cabo la programación son las siguientes.
regresiones (lineal, racional, potencial, exponencial o
polinómicas) para observar cual tiene un mejor ajuste a los Ec.1 – Ley de enfriamiento
datos analizados, donde tenemos en cuenta la función de Newton donde 𝑇0 es la
inicial que nos rige el enfriamiento de un objeto, en este 𝑇(𝑡) = 𝑇0 + (𝑇𝑖 − 𝑇0 )𝑒 −𝑘𝑡 temperatura del ambiente
caso una variedad de fluidos. [2] 𝑇𝑖 es la temperatura inicial
𝑘 es la constante de ritmo
OBJETIVOS
de enfriamiento 𝑡 es el
OBJETIVO GENERAL tiempo
Desarrollar una app en Matlab, la cual importe los datos de Ec.2 – Y modelo para una
𝑦 = 𝑎0 + 𝑎1 𝑥
un archivo Excel y con ello realice los cálculos necesarios regresión lineal
para arrojar un resultado.
a) 𝑦 = 𝛼1 𝑒 𝛽1 𝑥 Ec.3 – a) Y exponencial,
OBJETIVOS ESPECÍFICOS b) 𝐼𝑛(𝑦) = 𝐼𝑛(𝛼1 ) + antes de hacer la regresión.
𝛽1 𝑥 b) Y Modelo, ya linealizado
• Crear un interfaz fácil de entender para el usuario
a) 𝑦 = 𝛼2 𝑥 𝛽2 Ec.4 – a) Y potencial, antes
b) 𝑙𝑜𝑔(𝑦) = 𝑙𝑜𝑔(𝛼2 ) + de hacer la regresión. b) Y
• Aplicar cada una de las regresiones correctamente Modelo, ya linealizado
𝛽2 log (𝑥)
• Mostrar los coeficientes de determinación para 𝑥
a) 𝑦 = 𝛼3 ∗ 𝛽 Ec.5 – a) Y racional, antes
3 +𝑥 de hacer la regresión. b) Y
que el usuario pueda identificar la exactitud de 1 𝛽3 1 1
b) =𝛼 𝑥+𝛼 Modelo, ya linealizado
cada una de las regresiones. 𝑦 3 3
𝑦 = 𝑎0 + 𝑎1 𝑥 + 𝑎2 𝑥 2 +⋯ Ec.6 – Y modelo para una
+ 𝑎𝑛 𝑥 𝑛 regresión polinomial.

1
PROGRAMA beta=a1;
A continuación, se podrá observar parte del programa yExponencial=alfa*exp(beta.*x)
realizado para obtener regresiones de distintos tipos y en ymod=sprintf('%0.4f + %0.4f * t', a0, a1);
distintos fluidos, esto debido a que la programación hecha app.YmodeloEditField.Value=ymod;
es y sirve para cada uno de los fluidos, por lo tanto, en cada coef=sprintf('%0.4f', r2);
caso del fluido, solo varia la ruta dada para el archivo en app.CoeficientededeterminacionEditField.Va
Excel del fluido a seleccionar. [3] lue=(coef);
global Tipo Fluido plot(app.UIAxes,x,y,'*',x,yExponencial);
cla(app.UIAxes2); plot(app.UIAxes2,x,log(y),'*',x,Ymodelo);
switch Fluido ylin=sprintf('%0.2f * exp (%0.2f * t )',
case 2 %Awa alfa, beta)
[Archivo,Directorio] app.YLinealizadoEditField.Value=ylin;
=uigetfile('Agua.xlsx','Abrir un archivo de case 4 % Potencial
datos'); sumax=sum(log10(x));sumax2=sum(log10(x).^2
Datos = strcat(Directorio,Archivo); );sumay=sum(log10(y))
app.UITable.Data=readtable(Datos); sumaxy=sum(log10(x).*log10(y));
W=app.UITable.Data; a1=((n*(sumaxy)-sumay*sumax))/(n*sumax2-
VectorDatos=table2array(W); (sumax)^2);
n=length(VectorDatos); a0=sumay/n-a1*sumax/n;
x=VectorDatos(:,1); Ymodelo=(a0+a1.*log10(x));
y=VectorDatos(:,2); st=sum((log10(y)-sumay/n).^2);
switch Tipo sr=sum(((log10(y))-(a0+a1.*log(x))).^2);
case 2 % Lineal r2=(st-sr)/st;
sumax=sum(x); sumay=sum(y); alfa=10^a0;
sumaxy=sum(x.*y); sumax2=sum(x.^2); beta=a1;
a1=(n*sumaxy-sumax*sumay)/(n*sumax2- yPotencial=alfa.*x.^beta;
sumax^2); ymod=sprintf('%0.4f + %0.4f * t', a0, a1);
a0=((sumay/n)-a1*(sumax/n)); app.YmodeloEditField.Value=ymod;
Ymodelo=(a0+a1.*x); coef=sprintf('%0.4f', r2);
st=sum((y-sumay/n).^2); app.CoeficientededeterminacionEditField.Va
sr=sum((y-(a0+a1.*x)).^2); lue=(coef);
r2=(st-sr)/st; plot(app.UIAxes,x,y,'*',x,yPotencial);
ymod=sprintf('%0.4f + %0.4f * t', a0, a1); plot(app.UIAxes2,log10(x),log10(y),'*',log
app.YmodeloEditField.Value=ymod; 10(x),Ymodelo);
coef=sprintf('%0.4f', r2); ylin=sprintf('%0.2f * t ^ %0.2f', alfa,
app.CoeficientededeterminacionEditField.Val beta)
ue=(coef); app.YLinealizadoEditField.Value=ylin;
plot(app.UIAxes2,x,y,'*',x,Ymodelo); case 5 % Racional
ylin=sprintf(' ------------------------- ') sumax=sum(1./x); sumax2=sum(1./(x).^2);
app.YLinealizadoEditField.Value=ylin; sumay=sum(1./y); sumaxy=sum(1./x.*1./y);
case 3 % Exponencial a1=((n*(sumaxy)-sumay*sumax))/(n*sumax2-
sumax=sum(x); sumay=sum(log(y)); (sumax)^2);
sumaxy=sum(x.*log(y)); sumax2=sum(x.^2); a0=(sumay/n-a1*sumax/n);
a1=(n*sumaxy-sumax*sumay)/(n*sumax2- st=sum((1./y-sumay/n).^2);
sumax^2); Ymodelo=(a0+a1.*(1./x));
a0=((sumay/n)-a1*(sumax/n)); sr=sum((1./y-(a0+a1.*1./x)).^2);
Ymodelo=(a0+a1.*x); r2=(st-sr)/st;
st=sum((log(y)-sumay/n).^2); alfa=1/a0;
sr=sum((log(y)-(a0+a1.*x)).^2); beta=a1*alfa;
r2=(st-sr)/st; yRacional=(alfa.*x)./(beta+x);
alfa=exp(a0); ymod=sprintf('%0.4f + %0.4f * t', a0, a1);
app.YmodeloEditField.Value=ymod;

2
coef=sprintf('%0.4f', r2); r2=(st-sr)/st;
app.CoeficientededeterminacionEditField.Val ymod=sprintf('%0.2f + %0.2f * t + %0.2f * t
ue=(coef); ^ 2 + %0.2f * t^3', a0, a1, a2, a3);
plot(app.UIAxes,x,y,'*',x,yRacional); app.YmodeloEditField.Value=ymod;
plot(app.UIAxes2,1./x,1./y,'*',1./x,Ymodelo coef=sprintf('%0.4f', r2);
); app.CoeficientededeterminacionEditField.Val
ylin=sprintf(['(%0.2f * x) / (%0.2f + t ue=(coef);
)'], alfa, beta) plot(app.UIAxes2,x,y,'*',x,Ymodelo);
app.YLinealizadoEditField.Value=ylin; ylin=sprintf(' --------------------------')
case 6 % Polinomial 2 app.YLinealizadoEditField.Value=ylin;
sumax=sum(x); sumax2=sum(x.^2); end
sumax3=sum(x.^3);sumax4=sum(x.^4);
sumay=sum(y); sumaxy=sum(x.*y); case 3 %Aceite
sumax2y=sum(x.^2.*y); [Archivo,Directorio] =
A=[n sumax sumax2; sumax sumax2 uigetfile('Aceite.xlsx','Abrir un archivo
sumax3;sumax2 sumax3 sumax4]; de datos');
B=[sumay; sumaxy; sumax2y]; Datos = strcat(Directorio,Archivo);
X=inv(A)*B app.UITable.Data=readtable(Datos);
a0=X(1) W=app.UITable.Data;
a1=X(2) VectorDatos=table2array(W);
a2=X(3) n=length(VectorDatos);
Ymodelo=(a0+a1.*x+a2.*x.^2) x=VectorDatos(:,1);
st=sum((y-sumay/n).^2) y=VectorDatos(:,2);
sr=sum((y-(a0+a1.*x+a2.*x.^2)).^2)
r2=(st-sr)/st; switch Tipo
ymod=sprintf('%0.4f + %0.4f * t + %0.4f * t case 2 % Lineal
^ 2', a0, a1, a2); case 3 % Exponencial
app.YmodeloEditField.Value=ymod; case 4 % Potencial
coef=sprintf('%0.4f', r2); case 5 % Racional
app.CoeficientededeterminacionEditField.Val case 6 % Polinomial grado 2
ue=(coef); Case 7 % Polinomial grado 3
plot(app.UIAxes2,x,y,'*',x,Ymodelo); end
ylin=sprintf(' --------------------------') case 3 % Jabon manos
app.YLinealizadoEditField.Value=ylin; [Archivo,Directorio] =
case 7 % Polinomial 3 uigetfile('Aceite.xlsx','Abrir un archivo
sumax=sum(x); sumax2=sum(x.^2); de datos');
sumax3=sum(x.^3);sumax4=sum(x.^4); Datos = strcat(Directorio,Archivo);
sumax5=sum(x.^5); sumax6=sum(x.^6); app.UITable.Data=readtable(Datos);
sumay=sum(y); sumaxy=sum(x.*y); W=app.UITable.Data;
sumax2y=sum(x.^2.*y); sumax3y=sum(x.^3.*y); VectorDatos=table2array(W);
A=[n sumax sumax2 sumax3; sumax sumax2 n=length(VectorDatos);
sumax3 sumax4; sumax2 sumax3 sumax4 sumax5; x=VectorDatos(:,1);
sumax3 sumax4 sumax5 sumax6]; y=VectorDatos(:,2);
B=[sumay; sumaxy; sumax2y; sumax3y];
X=inv(A)*B case 3 % Jabón manos
a0=X(1) case 4 % Jabón loza
a1=X(2) case 5 % Salmuera
a2=X(3) case 6 % Aceite 20W50
a3=X(4)
Ymodelo=(a0+a1.*x+a2.*x.^2+a3.*x.^3); end
st=sum((y-sumay/n).^2); end
sr=sum((y-(a0+a1.*x+a2.*x.^2+a3.*x.^3)).^2)

3
Además, se programó un check box, por fuera del botón de seleccionar el tipo de fluido y la regresión, debajo de estos
calcular para mostrar algunos por aparte los resultados de hay una tabla, la cual nos permite observar los datos de
la “mejor” regresión y a si el usuario pueda compararlas. tiempo y temperatura, con los que se está realizando el
show = app.Mostrar.Value; procedimiento. Aproximadamente en el centro y parte
if show==1 izquierda, se encuentran los resultados que se obtendrán
[Archivo,Directorio] = después de ejecutar el programa, y el botón para ello, se
uigetfile('*.xlsx','Abrir un archivo de encuentra debajo de las gráficas, que están en la parte
datos'); central y media de la parte derecha. Y, por último, en la
Datos = strcat(Directorio,Archivo); parte inferior izquierda, se encuentra un check box, y luego
app.UITable.Data=readtable(Datos); se ser activado, automáticamente, aparecen los datos de la
W=app.UITable.Data; regresión con más ajusta obtenida.
VectorDatos=table2array(W);
n=length(VectorDatos);
x=VectorDatos(:,1);
y=VectorDatos(:,2);
sumax=sum(x); sumax2=sum(x.^2);
sumax3=sum(x.^3);sumax4=sum(x.^4);
sumax5=sum(x.^5); sumax6=sum(x.^6);
sumay=sum(y); sumaxy=sum(x.*y);
sumax2y=sum(x.^2.*y); sumax3y=sum(x.^3.*y);
A=[n sumax sumax2 sumax3; sumax sumax2
sumax3 sumax4; sumax2 sumax3 sumax4 sumax5;
sumax3 sumax4 sumax5 sumax6];
B=[sumay; sumaxy; sumax2y; sumax3y];
X=inv(A)*B
a0=X(1)
a1=X(2)
a2=X(3)
a3=X(4)
Ymodelo=(a0+a1.*x+a2.*x.^2+a3.*x.^3);
st=sum((y-sumay/n).^2); Ilustración 1 - Interfaz gráfica realizada para el programa.
sr=sum((y-(a0+a1.*x+a2.*x.^2+a3.*x.^3)).^2)
r2=(st-sr)/st; Con esto, pasamos a ejecutar y observar los datos
ymod=sprintf('%0.2f + %0.2f * t + %0.2f * t obtenidos, entonces, procederemos a realizar la prueba,
^ 2 + %0.2f * t^3', a0, a1, a2, a3); con uno de los fluidos y todas las regresiones, para
app.YmodeloEditField_2.Value=ymod; observar cual de ellas tiene un mejor ajuste, teniendo esto
coef=sprintf('%0.4f', r2); en cuenta, inicialmente se implementará la comparación
app.CoeficientededeterminacionEditField_2.V con el jabón para loza y la regresión lineal, como se puede
alue=(coef); observar en la Ilustración 2.
plot(app.UIAxes,x,y,'*',x,Ymodelo);
plot(app.UIAxes2,x,y,'*',x,Ymodelo);
app.YLinealizadoEditField.Value=ylin;
app.RegresionEditField.Value= 'Polinomica
grado 3' ;
end

ANALISIS DE LOS RESULTADOS OBTENIDOS

Inicialmente en la Ilustración 1, se puede observar la
interfaz gráfica diseñada, donde en la parte superior Ilustración 2 - Ejecución del programa. Fluido: Jabón para loza.
izquierda, se encuentran dos drop donw, que nos permite Regresión: Lineal.

4
En la Ilustración 2, se pudo observar, que solo se mostraba
una gráfica, esto es debido a que la ecuación modelo es
igual a la linealizada, también se pudo ver un coeficiente
de correlación, cercano a 1, sin embargo, en la gráfica, se
nota que esta línea no coincide mucho con la gráfica de los
datos.
Luego, y pasamos a ejecutar la aplicación con el mismo
fluido y una regresión exponencial, la cual los resultados
se pueden observar en la Ilustración 3.
Ilustración 3 - Resultados al ejecutar el programa. Fluido: Jabón
para loza. Regresión: Exponencial.
Como se puede observar en la Ilustración 3, una de las
gráficas, presenta una leve curva, permitiendo que el
coeficiente de determinación se un poco más cercano a 1.
Donde también se evidencian las de ecuaciones de la
función, ya que esta la modelo y la linealizada.
Proseguimos con la siguiente regresión, es decir la
potencial. Y sus resultados se pueden observar en la
Ilustración 4.
Ilustración 4 - Resultados obtenidos con la regresión potencial.
Fluido: Jabón para loza
En la Ilustración 4, se observar que la regresión potencial,
tiene un coeficiente de determinación un poco más bajo
que la regresión exponencial, pero se puede percibir que
esta regresión hay un ajuste similar, debido a la
aproximación entre los valores reales a los linealizados o
los arrojados por la ecuación modelo.
5
Posteriormente, se realizo la prueba para la regresión
racional, donde los resultados se podrán ver en la
Ilustración 5.
Ilustración 5 - Datos obtenidos luego de ejecutar el programa,
en regresión racional y jabón para manos.
En la Ilustración 5, se evidencia, que la regresión racional
no es la mejor opción para realizar la linealización, esto se
puede observar por las graficas y el coeficiente de
restitución confirma esto, ya que el valor que este tiene no
es cercano a 1.
Después realizamos el procedimiento con la regresión
polinomial de segundo grado, y los resultados obtenidos,
se observan en la Ilustración 6.
Ilustración 6 - Datos obtenidos después de ejecutar el programa
con regresión polinomial grado 2, y jabón para loza.
Las regresiones polinomiales presentan solo una ecuación
al igual que la lineal, por lo tanto, solo podremos observar
una gráfica, por otro lado, se observa la regresión
polinomial, tiene un mayor ajuste, y se evidencia en la
grafica presentada en la Ilustración 6, y el coeficiente de
determinación, nos indica lo mismo, ya que se encuentra
muy cercano a 1.
Por otra parte, se evaluó la regresión polinomial de grado
3, la cual se podrá observar en la Ilustración 7.
Ilustración 7 - Resultados obtenidos al ejecutar el programa con
regresión polinomial de grado 3 y jabón para loza.
Analizando los datos obtenidos en la Ilustración 7, se
observa una leve diferencia con el polinomio de grado 2,
sin embargo, según el coeficiente de determinación, este
tiene un mayor ajuste.
Para finalizar, se mostrar una comparación de cualquiera
de las regresiones, con la que mejor ajuste tuvo, es decir,
la polinomial de grado tres, para ello se implementara el
check down, en la ilustración 8, se observara antes de
activarlo y la 9, ya activado y arrojando los valores de la
regresión polinomial de grado tres y sus graficas.
Ilustración 8 - Ejecución del programa con regresión racional y
jabón para loza.
6
Ilustración 9 - Datos obtenidos luego de activar el drop down.
Como se puede observar en la Ilustración 9, los datos del
centro son los datos de la regresión ingresada
anteriormente, y en la parte inferior nos indica los
resultados de la regresión con un mayor ajuste.
CONCLUSIONES
La implementación de importación de datos desde Excel,
es una forma muy efectiva cuando se manejan una gran
cantidad de datos, además, esta disminuye ciertas líneas de
código.
Como se mencionó anteriormente la regresión polinómica
de 2 y 3, fueron los métodos mas exactos con respecto a
los datos, teniendo en cuenta que la función que rige esa
curva es exponencial, como determina la ecuación de ley
de enfriamiento, y aunque esta tuvo un coeficiente de
determinación alto, las polinómicas eran aun así más
cercanas a 1, esto puedo ocurrir debido a la cantidad de
constantes que tiene cada regresión.
Para finalizar se notó la importancia de seleccionar bien un
tipo de regresión, dependiendo los datos que se tiene, un
ejemplo claro es la regresión racional, la cual su coeficiente
de determinación no tenía una aproximación valida a 1.
BIBLIOGRAFÍA
[1] K. Dotor, «Ley de Enfriamento de Newton,» 06 04 2022.
[En línea]. Available:
https://www.academia.edu/26520605/Ley_de_Enfriament
o_de_Newton?msclkid=6f0799ddb78211ec9bde4b4b71d
3894c.
[2] S. C. Chapra y R. P. Canale, Metodos Numericos para
ingenieros, México: The McGraw - Hill Education, 2015.
[3] Mathworks, «Mathworks,» Mathworks, 2022. [En línea].
Available: https://la.mathworks.com/help/matlab/.
[Último acceso: 2 04 2022].