UNIVERSIDAD DE CARTAGENA

Facultad de ingeniería – Ingeniería Química

MÉTODOS NUMÉRICOS

Carolina Alvarado/Carlos Guerrero/Mario Montes/Michael Ramírez/Emily Rose

El presente documento contiene los códigos computacionales y algoritmos de dos métodos para la
solución de ecuaciones algebraicas, los cuales son: Cardano Vietta y Newton-Raphson. Además, se
encuentran anexados los intentos previos al resultado requerido, como se evolucionó en la
realización de la tarea para obtener los resultados esperados.

MÉTODO CARDANO VIETTA

Este programa fue diseñado para aplicar el método Cardano-Vietta con el fin de hallar las raíces de
una función cubica de volumen, la cual fue determinada a partir de la ecuación de gas real de
Redlich-Wkong.

Aquí se recorre las temperaturas manteniendo una presión fija, una vez termina un recorrido de
temperaturas, cambia el valor de la presión en aumento; las unidades fueron tomadas consistentes
para R con unidades de bar*m3/mol*K.

Este código es la versión final obtenida, a diferencia de otros intentos, que serán mostrados en el
anexo, este no contiene restricciones para la creación de una matriz (en la que se tabulan las tres
raíces a correspondientes presiones y temperaturas), sin embargo, estas restricciones no fueron
necesarias puesto que todas las raíces obtenidas fueron positivas. El cambio efectuado para esta
última versión fue definir a “a” y a “b” como constantes numéricas precalculadas y definir a “R’ con
las unidades anteriormente mencionadas, en este sentido, no fue necesario mantener la definición
de P crítica y T critica dentro del programa.

Al final se presenta una matriz de 5 columnas mostrando, respectivamente, las tres raíces halladas
(X1, X2 y X3), la presión correspondiente a las raíces, y las temperaturas correspondientes; todos los
valores se presentan en notación científica de (10-2).

Para su graficación, se tomaron en el eje “x” los valores de las dos raíces más convenientes y en el
eje “y” los valores de las presiones hasta 204.5 bar.

2.5

1.5

0.5

0
0 0.000005 0.00001 0.000015 0.00002 0.000025
Código computacional
clc;
i=0;

for P=20:4.1:225
i=(i+1);
for T=298:4.02:700

R=0.00008314472;
a= 0.000005526914954;
b=0.00002081832548;
A1=(-((R*T)/P));
A2=(-(((P*((b)^2))+(R*T*b)-a)/P));
A3=(-((a*b)/P));

Q=(((A1^2)-(3*A2))/9);
M=(((2*(A1^3))-(9*A1*A2)+(27*A3))/54);

c= ((Q^3)-(M^2));
k=(atan(sqrt(((Q^3)/(M^2))-1)));
if c>=0
if M>0

X1=((-2)*sqrt(Q)*(cos(k/3))-(A1/3));
X2=((-2)*sqrt(Q)*(cos((k+(2*pi))/3))-(A1/3));
X3=((-2)*sqrt(Q)*(cos((k+(4*pi))/3))-(A1/3));
dT=(T*1);
end
if M<0
X1=(2*sqrt(Q)*(cos(k/3))-(A1/3));
X2=(2*sqrt(Q)*(cos((k+(2*pi))/3))-(A1/3));
X3=(2*sqrt(Q)*(cos((k+(4*pi))/3))-(A1/3));
dT=(T*1);
end
else
if M>0
q=1;
end
if M<0
q=(-1);
end
X= (((-q)*(((sqrt((M^2)-(Q^3))+(abs(M)))^(1/3))+(Q/(((sqrt((M^2)-
(Q^3)))+(abs(M)))^(1/3)))))-(A1/3));
end
end
m(i,1)=X1;
m(i,2)=X2;
m(i,3)=X3;
m(i,4)=P;
m(i,5)=dT;

end
format long
m
Algoritmo
MÉTODO NEWTON-RAPHSON

La programación de este método se hizo de la siguiente manera: Se programaron dos programas,

uno fue hecho para calcular por Newton-Raphson para cualquier función, que será mostrado en el
anexo, y con ese se comprobó que diera el Newton-Raphson para nuestra tarea en específico, el
cual será mostrado a continuación.

Código computacional

clc;

R=8.3144598;

Pc=22120;

Tc=647.3;

b=0.08661*(R*(Tc/Pc));

TAO=10^-5;

V1=0.0001;

X=2;

for T=298:(4.02):700 %Matriz para ir asignando las temperaturas

a=0.42748*(((R^2)* (Tc^2.5))/(Pc*(T^0.5)));

if(T==298) %Ubicacion de temperaturas en la matriz

temperatura = 1;%Contador en la matriz inicial de temperaturas

matriz(1,1)=0;

matriz(1,2)=T;

matriz(1,3)=0;

matriz(1,4)=0;

else

temperatura = temperatura + 1;%Contador en la matriz

i=((temperatura-1)*43)+1; %Para ubicar la temperatura en la matriz al principio de cada bloque
de presiones

matriz(i,1)=0;

matriz(i,2)=T;

matriz(i,3)=0;

matriz(i,4)=0;
 end

for P=2000:500:22500 %Matriz para ir asignando las presiones

contador_presion=0;

burbuja=0;

rocio=0;

E=1;

nuevo=0;

while X~=1 %Matriz de iteraciones (termina solo cuando se cumple la condicion)

if(E > TAO) %Casos para iterar cuando no se cumple la condicion TAO

if (contador_presion==0)

opcion=1;

else

opcion=2;

end

else %Casos para guardar los resultados de las iteraciones que cumplen la condicion TAO

if (burbuja==0)

opcion=3;

else

opcion=4;

end

end

switch(opcion) %Asignacion de V (volumen) para las iteraciones o guardar determinados valores

(punto de burbuja y rocio)

case 1 %Asignacion inicial de Volumen

V = V1;

X=3;

case 2 %Para cuando no se haya el volumen de ningún punto del domo

 V = nuevo;

X=4;

case 3 %Para cuando se haya el volumen del punto de burbuja

burbuja=1;

Vburbuja=nuevo;

V=(R*T)/P;

X=5;

case 4 %Para cuando se haya el volumen del punto de rocio

rocio=1;

Vrocio=nuevo;

X=1;

otherwise %En el caso de haber un error en la asignacion de Volumen

disp('Valor invalido')

end

F=((P*V^3)-(R*T*(V^2))-((P*(b^2)+(R*T*b)-a)*V)- b*a);

FD= (3*P*V^2)-(2*R*T*V)-((P*(b^2)+(R*T*b)-a));

anterior=V;

nuevo= anterior-(F / FD);

if(contador_presion==0)

E=2;

else

E=abs((nuevo - anterior)/nuevo);

end

contador_presion=contador_presion+1;

end %Final del While

if(P==2000) %Ubicacion de presiones en la matriz

 presion = 1;%Contador en la matriz inicial

i=((temperatura-1)*43)+2; %Se hace con el contador de temperatura porque debe repetirse los
bloques de presiones por cada temperatura

else

presion = presion + 1;%Contador en la matriz

i=i+1; %Para ubicar la temperatura en la matriz por bloque de presiones

end

matriz(i,1)=P;

matriz(i,2)=0;

matriz(i,3)=Vburbuja;

matriz(i,4)=Vrocio;

end

end

scatter(matriz(:,3),matriz(:,1))

scatter(matriz(:,4),matriz(:,1))

table(matriz)
Algoritmo
 ANEXOS

A continuación se muestran los intentos previos realizados para obtener los ya mostrados
resultados.

CARDANO VIETTA

Aquí se recorre las temperaturas manteniendo una presión fija, una vez termina un recorrido de
temperaturas, cambia el valor de la presión en aumento; las unidades fueron tomadas del SI.
Este programa solo acepta producir la matriz final (en la que se tabulan los pares de raíces y sus
presiones) si se obtienen por lo menos dos raíces positivas, en tal caso, se definiría el valor de la
isoterma para las raíces que cumplen la condición en esta presión. Sin embargo, no se arroja una
matriz debido a que no se encuentran dos raíces positivas.

clc;
Tc=658.416405;
Pc=22500;
i=0;
for P=2000:410:22500
i=(i+1);
for T=298:4.02:700

R=8.3144598;
a=((0.42748*(((R^2)*(Tc^2.5))/(Pc*(T^2.5)))));
b=0.02108;
A1=(-((R*T)/P));
A2=(-(((P*((b)^2))+(R*T*b)-a)/P));
A3=(-((a*b)/P));

Q=(((A1^2)-(3*A2))/9);
M=(((2*(A1^3))-(9*A1*A2)+(27*A3))/54);

c= ((Q^3)-(M^2));
k=(atan(sqrt(((Q^3)/(M^2))-1)));
if c>=0
if M>0

X1=((-2)*sqrt(Q)*(cos(k/3))-(A1/3));
X2=((-2)*sqrt(Q)*(cos((k+(2*pi))/3))-(A1/3));
X3=((-2)*sqrt(Q)*(cos((k+(4*pi))/3))-(A1/3));

if X2>0 && X3>0

m(i,1)=X1;
m(i,2)=X2;
m(i,3)=X3;
m(i,4)=P;
dT=(T*1);
m(i,5)=dT;
 end
if X1>=0 && X3>=0
m(i,1)=X1;
m(i,2)=X2;
m(i,3)=X3;
m(i,4)=P;
dT=(T*1);
m(i,5)=dT;
end
if X1>=0 && X2>=0
m(i,1)=X1;
m(i,2)=X2;
m(i,3)=X3;
m(i,4)=P;
dT=(T*1);
m(i,5)=dT;
end

end
if M<0
X1=(2*sqrt(Q)*(cos(k/3))-(A1/3));
X2=(2*sqrt(Q)*(cos((k+(2*pi))/3))-(A1/3));
X3=(2*sqrt(Q)*(cos((k+(4*pi))/3))-(A1/3));
if X2>0 && X3>0
m(i,1)=X1;
m(i,2)=X2;
m(i,3)=X3;
m(i,4)=P;
dT=(T*1);
m(i,5)=dT;
end
if X1>=0 && X3>=0
m(i,1)=X1;
m(i,2)=X2;
m(i,3)=X3;
m(i,4)=P;
dT=(T*1);
m(i,5)=dT;
end
if X1>=0 && X2>=0
m(i,1)=X1;
m(i,2)=X2;
m(i,3)=X3;
m(i,4)=P;
dT=(T*1);
m(i,5)=dT;
end
 end
end

if c<0
if M>0
q=1;
end
if M<0
q=(-1);
end
X= (((-q)*(((sqrt((M^2)-(Q^3))+(abs(M)))^(1/3))+(Q/(((sqrt((M^2)-(Q^3)))+(abs(M)))^(1/3)))))-
(A1/3));

end

end
end
format long
m

Este programa fue el último intento funcional para la aplicación del método Cardano-Vietta; ya se
han hecho aquí las correcciones correspondientes al uso de la función atan. Este programa hace
un recorrido de presiones con recorrido interno de temperaturas, pero toma siempre la última
temperatura del recorrido(Tc) para hallar las raíces de la función cuadrática, dos de las cuales son
negativas. Esto ocurre al no tener criterios que discriminen raíces tomadas para la matriz.

clc;
Tc=658.416405;
Pc=22500;
i=0;
for P=2000:410:22500
i=(i+1);
for T=298:4.02:700

R=8.3144598;
a=((0.42748*(((R^2)*(Tc^2.5))/(Pc*(T^2.5)))));
b=0.02108;
A1=(-((R*T)/P));
A2=(-(((P*((b)^2))+(R*T*b)-a)/P));
A3=(-((a*b)/P));

Q=(((A1^2)-(3*A2))/9);
M=(((2*(A1^3))-(9*A1*A2)+(27*A3))/54);
 c= ((Q^3)-(M^2));
k=(atan(sqrt(((Q^3)/(M^2))-1)));
if c>=0
if M>0

X1=((-2)*sqrt(Q)*(cos(k/3))-(A1/3));
X2=((-2)*sqrt(Q)*(cos((k+(2*pi))/3))-(A1/3));
X3=((-2)*sqrt(Q)*(cos((k+(4*pi))/3))-(A1/3));

end
if M<0
X1=(2*sqrt(Q)*(cos(k/3))-(A1/3));
X2=(2*sqrt(Q)*(cos((k+(2*pi))/3))-(A1/3));
X3=(2*sqrt(Q)*(cos((k+(4*pi))/3))-(A1/3));

end
end

if c<0
if M>0
q=1;
end
if M<0
q=(-1);
end
X= (((-q)*(((sqrt((M^2)-(Q^3))+(abs(M)))^(1/3))+(Q/(((sqrt((M^2)-(Q^3)))+(abs(M)))^(1/3)))))-
(A1/3));

end

end
m(i,1)=X1;
m(i,2)=X2;
m(i,3)=X3;
m(i,4)=P;

end
format long

m
A continuacion, la ultima columna de la matriz reportada en command window, registra que la
temperatura guarada para los calculos de las raices es la Tc, ya que no se tienen restricciones para
la aceptacion de raices.
----------------------------------------------------------------------------------------------------------------------------------

Inicialmente y por error, se usó la función acot para el cálculo de del ángulo teta; a continuación,
se muestran las gráficas que se obtuvieron y la posterior corrección del cálculo de teta en el
programa.
El siguiente es el primer error en el proceso del diseño del programa, del cual se tiene registro. En
un principio, se definió “a” como una constante del agua, pero, al tener en cuenta el recorrido de
las temperaturas se determinó la dependencia de “a” hacia T y se reemplazó su valor fijo por la
fórmula que lo define.
Newton-Raphson

Para la realización de este método, se realizó un programa que sirviera para solucionar cualquier
función, y para ir comparando con el programa específico para la tarea (el cual presenta el error
de calcular para el primer dato y en los demás cambios de presión y temperatura coloca el mismo)
y lo veremos a continuación:

clc;

Pc=221.2;

Tc=647.3;

T=input('Ingrese la temperatura');

P=input('Ingrese la presion');

R=0.08314;

TAO=10^-5;

a=0.42748*(((R^2)* (Tc^2.5))/(Pc*(T^0.5)));

b=0.08661*(R*(Tc/Pc));

X=2;

E=1;

V=0.718564;

nuevo=V;

contador_presion=0;

while X~=1 %Matriz de iteraciones (termina solo cuando se cumple la condicion)

if(E > TAO) %Casos para iterar cuando no se cumple la condicion TAO
 opcion=1;

else %Casos para guardar los resultados de las iteraciones que cumplen la condicion TAO

opcion=2;

end

switch(opcion) %Asignacion de V (volumen) para las iteraciones o guardar determinados valores

(punto de burbuja y rocio)

case 1 %Asignacion inicial de Volumen

V= nuevo;

X=2;

case 2 %Para cuando no se haya el volumen de ningun punto del domo

V = nuevo;

X=1;

otherwise %En el caso de haber un error en la asignacion de Volumen

disp('Valor invalido')

end

F=((P*V^3)-(R*T*(V^2))-((P*(b^2)+(R*T*b)-a)*V)- b*a);%Funcion (asignar)

FD= (3*P*V^2)-(2*R*T*V)-((P*(b^2)+(R*T*b)-a)); %Derivada de la funcion (asignar)

anterior=V;

nuevo= anterior-(F/FD);

if(contador_presion==0)

E=1;

else

E=abs((nuevo - anterior)/nuevo);

end

contador_presion=contador_presion+1;

end

disp(V)
Errores obtenidos en la realización del método Newton-Raphson, fueron los siguientes:
Valores obtenidos del programa de Newton-Raphson realizado para cualquier función. De este
modo, se obtienen uno a uno los valores con presiones y temperaturas determinadas para
comprobar los valores que estaban siendo obtenidos en el programa original que recorre los
intervalos proveídos de tales variables.