Newton-Raphson en C

#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<math.h>
#include<process.h>

#define f(x) 3*x -cos(x) -1
#define df(x) 3 -sin(x)

void nwrap();

void main(){
 printf("\n Solucion por el Método de Newton Raphson \n");
 printf("\n F(x): ");
 printf("\n\t\t\t 3*x -cos(x) -1 = 0 \n\t");
 nwrap();
 getch();
}

void nwrap(){
 float x1,x0;
 float f1,f0;
 float df0;
 int i=0, itr=0;
 float TOL;
 float error;
   for(x1=0;;x1 +=0.01){
    f1=f(x1);
    if (f1>0){
     break;
    }
   }
x0 = x1-0.01;
f0 = f(x0);
printf("Numero de Iteraciones: ");
scanf("%d",&itr);
printf("Tolerancia Maxima: ");
scanf("%f",&TOL);
     if(fabs(f0)>f1){
      printf("\n\t\t La raiz es: %0.4f\n",x1);
     }
     if(f1 > fabs(f(x0))){
      printf("\n\t\t La raiz es: %0.4f\n",x1);
 }
x0 = (x0+x1)/2;
for(;i<=itr;i++){
 f0=f(x0);
 df0=df(x0);
 x1 = x0 - (f0/df0);
 printf("\n\t\t iteracion %d  aproximacion: %f",i,x1);
 error = fabs(x1-x0);
   if(error < TOL){
    break;
   }
 x0 = x1;
}
   if(error > TOL){
    printf("\n\n\t Iteraciones No suficientes" );    
   }
printf("\n\n\n\t\t\t--------------------------");
printf("\n\n\t\t Raiz: %0.4f ",x1);
printf("\n\n\n\t\t\t--------------------------");
}

Método de Falsa Posicion en C

# include <stdio.h>
# include <math.h>
# include<conio.h>
# include<string.h>
# include<process.h>
#define TOL 0.000005
#define f(x) 3*x+sin(x)-exp(x)

void falsaposicion();

void main() {
	printf("\n Solucion por el metodo de Falsa posicion \n");
	printf("\n La Ecuacion a resolver es: ");
	printf("\n\t\t\t 3*x+sin(x)-exp(x)= 0 \n\n");
falsaposicion();	
}

void falsaposicion(){
	float f0,f1,f2;
	float x0,x1,x2;
	int itr;
	int i;
	printf("Numero Maximo de Iteracciones: ");
	scanf("%d",&itr);
	for(x1=0.0;;){
		f1=f(x1);
		if (f1>0){
			break;
		}
		 else {
		 	x1 = x1+0.1;
		 }
	}
			
	x0= x1-0.1;
	f0 = f(x0);
	printf("\n\t\t----------------------------------------");
	printf("\n\t\t Iteraccion\t x\t\t F(X) \n");
	printf("\n\t\t----------------------------------------");
	  for(i=0;i<itr;i++){
	  	x2 = x0-((x1-x0)/(f1-f0))*f0;
	  	f2=f(x2);
	  	 if(f0*f2>0){
	  	 	x1=x2;
	  	 	f1=f2;
	  	 }
	  	   else {
	  	    	x0=x2;
	  	    	f0=f2;
	  	   }
	  	     if (fabs(f(2))>TOL){
	  	     	printf("\n\t\t%d\t%f\t%f\n",i+1,x2,f2);
	  	     }
	  }
	  printf("\t\t--------------------------------");
	  printf("\n\t\t\t Raiz= %f\n",x2);
	  printf("\t\t------------------------------");
	  getch();
			}

Método de Bisección en C, Usando funciones

# include<stdio.h>
# include<conio.h>
# include<math.h>
# include<process.h>
# include<string.h>
# define TOL 0.000001
# define F(x) (x)*log10(x) - 1.2

void Bisect();
int i=1, n;
float raiz = 1;

void main(){
 printf("\n Solucion por el Metodo de Biseccion \n");
 printf ("\n La ecuacion es: ");
 printf("\n\t\t\t (x)*log10x) -1.2 = 0 \n\n");
 printf("Numero Maximo de Iteracciones: ");
 scanf ("%d",&n);
 Bisect();
}
void Bisect(){
 float x1,x2,x0;
 float f0,f1,f2;
 int j=0;
  for (x2=1;;x2++){
   f2 = F(x2);
   if(f2 >0){
    break;
   }
   
  }
  for (x1=x2-1;;x2--){
   f1 = F(x1);
   if(f1<0){
    break;
   }
  }
printf ("\t\t------------------------------------\t\t");
printf ("\n\t\t Iteracion                 Raiz \n");
printf("\t\t-------------------------------------\t\t");
 for (;i<=n;i++){
  x0 = (x1+x2)/2.0;
  f0 = F(x0);
    if (f0==0){
     raiz = x0;
    }
  if(f0*f1<0){
   x2=x0;
  }
     else{
      x1 = x0;
      f1= f0;
     }
  printf("\n\t\t Iteracion %d ", i);
  printf("\t  :\t %f", x0);
  if(fabs((x1-x2)/x1) < TOL ){
  printf("\n\t\t ------------------------------------");
    printf("\n\t\t Raiz = %f",x0);
 printf("\n\t\t Iteracion = %d\n",i);
 printf("\t\t-------------------------------------");
 getch(); 
   exit(0);
   }
  }
printf("\n\t\t---------------------------------------");
printf("\n\t\t\t Raiz = %7.5f",x0);
printf("\n\t\t\t Iteracion = %d\n", i-1);
printf("\t\t-----------------------------------------");
 
getch();
}

Ejecutando:

Cálculo de flash isotérmico mediante la ecuación de estado de Soave

Multicomponentes en flash cálculos utilizando una ecuación de estado y reglas de mezcla clásica.

Sólo tiene que ejecutar main01.m, es fácil cambiar la composición y las condiciones de funcionamiento. Si desea agregar nuevos componentes sólo hay que añadir los críticos y definir propiedades del factor acéntrico. También es posible utilizar parámetros de interacción binarios differentes con ZE

D.E.S.C.A.R.G.A.R

Una clase de Antoine orientados a objetos cálculos de equilibrio vapor-líquido

Antoine para facilitar el cálculo de temperaturas de los componentes puros de saturación y presiones. Un objeto que corresponde a un componente puro se crea una instancia mediante la especificación de los parámetros de Antoine. Los métodos incluyen el cálculo de la presión de saturación, la temperatura de saturación, y el trazado.

Los datos de ejemplo se incluye para un pequeño número de compuestos. Un método de búsqueda se incluye para facilitar la búsqueda Webbook NIST Química para los parámetros de Antoine de otros compuestos.

Un extenso tutorial demuestra el uso de la ecuación de Antoine para los cálculos de equilibrio líquido-vapor. Los ejemplos incluyen el punto de burbuja y cálculos de punto de rocío, la construcción de Txy binario y diagramas XY, y la solución de los problemas de flash isotérmicas.

Este fue desarrollado para su uso en cursos de introducción en Ingeniería Química

Ley de de Raoult en Matlab

Asumiendo la ley de Raoult es válido (solución ideal), esta interfaz gráfica de usuario permite al usuario elegir dos compuestos de una base de datos de más de 4500 productos químicos y trazar su diagrama Txy largo de un rango de temperatura especificado por el usuario.

Las unidades múltiples de presión y temperatura son compatibles.

Si T-split se define, en el trazado de la figura, el líquido-vapor se divide también será calculado a la temperatura definida.

Si la base de datos no está configurado correctamente, he incluido en el archivo. Accdb.

D.E.S.C.A.R.G.A.R

Transferencia de Calor en Matlab

Programa resuelve numéricamente la ecuación general de transferencia de  calor utilizando las entradas del usuario y las condiciones de contorno.

D.E.S.C.A.R.G.A.R

sistemas de 3 ecuaciones lineales en matlab con Guide

DESCARGAR

Polinomio de 2do Grado en Matlab (con Interfaz de Usuario)

Resolver un polinomio de 2do grado nunca había sido mas fácil. El siguiente programa creado en Matlab cumple con  este objetivo de una Forma Fácil y eficiente.

DESCARGAR APLICACION

Integral en Matlab (con Interfaz de Usuario)

Descargar

Derivadas en Matlab (con interfaz de Usuario)

Es es un programa con una interfaz de usuario desarrollada en matlab. En el cual hallamos la derivada de una Funcion f(x)

DESCARGAR

Metodo de Gauss- Jordan

fprintf('\n\n\n\t\t********************************************************************************\n')
fprintf('\t\t*   Este metodo es similar al de la eliminacion gaussiana, pero la             *\n')
fprintf('\t\t*   caracteristica importante de este metodo es que a diferencia de obtener    *\n')
fprintf('\t\t*   el valor de las variables del sistema en forma regresiva, aqui se los      *\n')
fprintf('\t\t*   obtiene directamente de reducir por filas la matriz aumentada A|B          *\n')
fprintf('\t\t********************************************************************************\n\n')


fprintf('\n\t\t********************************************************************************\n')
fprintf('\t\t*    Antes de empezar a ejecutar el algoritmo de Gauss-Jordan en el sistema,   *\n')
fprintf('\t\t*    por favor escoja una opcion de presentacion de datos....                  *\n')
fprintf('\t\t********************************************************************************\n\n\n')

fprintf('\t\t\t\t1. Format short; coma fija con 4 decimales (defecto)\n');
fprintf('\t\t\t\t2. Format long; coma fija con 15 decimales\n');
fprintf('\t\t\t\t3. Format short e;  notación científica con 4 decimales\n');
fprintf('\t\t\t\t4. Format long e;  notación científica con 15 decimales\n');
fprintf('\t\t\t\t5. Format rat;  expresa los números racionales como cocientes de enteros\n');



fprintf('\n\t\tIngrese una opcion por favor;\n');
onn=input('                Opcion #   ');
if (onn~=1&onn~=2&onn~=3&onn~=4&onn~=5)
    fprintf('\n\t\t\t\tIngrese una opcion valida...por favor, \n\n')
    fprintf('\n\t\t\t\tse iniciara con format short(por defecto) \n\n')
end

switch (onn) 
    
        case 1, 
            format short
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat short; coma fija con 4 decimales (defecto)\n')
        case 2, 
            format long
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat long; coma fija con 15 decimales\n')
        case 3, 
            format short e
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat short e;  notación científica con 4 decimales\n')
        case 4,
            format long e
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat long e;  notación científica con 15 decimales\n')
        case 5, 
            format rat
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat rat;  expresa los números racionales como cocientes de enteros\n')
end


fprintf('\n\t\tPresione una tecla para continuar por favor...\n ')
pause
clc
fprintf('\n\t\t\tIngrese la matriz de coeficientes  por favor\n\n')
fprintf('\t\t********************************************************************************\n')
fprintf('\t\t*                       POR EJEMPLO [4 1 2;2 4 -1;1 1 -3]                      *\n')
fprintf('\t\t********************************************************************************\n\n')

aa=input('                      ');

fprintf('\n\t\t\tIngrese matriz columna de terminos independientes  por favor\n\n')
fprintf('\t\t********************************************************************************\n')
fprintf('\t\t*                              POR EJEMPLO [9;-5;-9]                           *\n')
fprintf('\t\t********************************************************************************\n\n')
bb=input('                      ');

A=[aa,bb];
fprintf('\n\t\t\t\t\tLa matriz aumentada A|B del sistema es;\n')
A
fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...'), pause
[m,n] = size(A);
i = 1;
j = 1;
k = 0;
tol = max([m,n])*eps*norm(A,'inf'); 
while (i <= m) & (j <= n)
   [p,k] = max(abs(A(i:m,j))); k = k+i-1;
   if (p <= tol)
      fprintf(['\n\n\t\t\t\t  Columna ' int2str(j) ' es insignificante'])
      A(i:m,j) = zeros(m-i+1,1)
      fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...\n')
      pause
      j = j + 1;
   else
      if i ~= k
         % Cambiar las i-esimas y las k-esimas filas.
         fprintf(['\n\n\t\t\t\tCambiar filas ' int2str(i) ' y ' int2str(k) blanks(10)])
         fprintf('\n\n')
         A([i k],:) = A([k i],:)
         fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...\n')
         pause
      end
      % Normaliza la i-esima fila%
      fprintf('\n\n\t\t\t\tEliminando columna %d\n',j)
      fprintf(['\n\t\t\t\ta partir de la referencia en A(' int2str(i) ',' int2str(j) ')' blanks(10)])
      fprintf('\n\n\t\t\t\tA(%d,%d)/%0.5f\n',i,j,A(i,j))
      A(i,j:n) = A(i,j:n)/A(i,j)
      fprintf('\n\t\t\t\tPresione una tecla para continuar por favor...\n')
      pause
      %Ejecuta la eliminacion de la j-esima columna a partir de la i-esima
      %fila%
      fprintf(['\n\n\t\t\t\tEliminando la columna ' int2str(j) blanks(10)])
      fprintf('\n')
      A
      fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...\n')
      pause
      for k = 1:m
         if k ~= i
            fprintf('\n')
            fprintf('\n\n\tFila[%d]=Fila[%d] - (A[%d,%d]/A[%d,%d])*Fila[%d]\n',k,k,k,j,i,j,j)
            pause
            A(k,j:n) = A(k,j:n) - A(k,j)*A(i,j:n)
         end
      end
      fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...\n')
      pause
      i = i + 1;
      j = j + 1;
   end
end

   fprintf('\n\n\t\t\t\tEntonces los valores de  las incognitas son;\n')
      for k = 1:m
            fprintf('\n\n\tx(%d)=%d\n',k,A(k,n))
            pause

Script que soluciona ecuaciones diferenciales y de diferencias.

ECUACIONES DIFERENCIALES EN FORMA SIMBÓLICA y(t)
con x(t) igual a las siguientes entradas; función impulso(d(t)-delta de dirac), función paso u(t), y función rampa t*u(t)mediante el uso de la Transformada de Fourier.

ECUACIONES DE DIFERENCIAS EN FORMA GRÁFICA Y SIMBÓLICA
muestra tres tipos de respuesta, impulso, paso y rampa, se ingresa los coeficientes de la ecuación y los coeficientes de larespuesta, presenta la solución en forma grafica usando stem, la transformada de fourier con plot(), y ademas la transformada z en forma simbólica.

Script that solves differential equations and differences.

Differential equations in symbolic form and (t)
with x (t) equal to the following entries; impulse function (d (t) the dirac-delta), step function u (t), and ramp function t * u (t) using Fourier Transform.

DIFFERENCES IN FORM EQUATIONS graphics and symbols
shows three types of response, impulse, step and ramp, enters the equation coefficients and coefficients of the answer, the solution presented in graphical form using stem, Fourier transform plot (), and also z-transform symbolic form  

DESCARGAR

Método del trapecio en matlab.

Realizado en Matlab con  interfaz de usuario.

function calcular_Callback(hObject, eventdata, handles)
f=inline(get(handles.F,'string'));
a=str2num(get(handles.A,'string'));
b=str2num(get(handles.B,'string'));
n=str2double(get(handles.N,'string'));

    
h=(b-a)/n;
 s=f(a)+f(b);
  for i=2:n
      x(i)=a+(i-1)*h;
      s=s+2*f(x(i));
      
  end
  I=s*(h/2);
  set(handles.salida,'string',I);

% --- Executes on button press in graficar.
function graficar_Callback(hObject, eventdata, handles)
f=inline(get(handles.F,'string'));
a=str2num(get(handles.A,'string'));
b=str2num(get(handles.B,'string'));
n=str2double(get(handles.N,'string'));
h=(b-a)/n;
 for i=2:n
      x(i)=a+(i-1)*h;
      y(i)=f(x(i));
 end
  x=[x,b,a,a];
  y=[y,0,0,f(a)];
  fill(x,y,[0.8 0.8 0.9])
  for i=1:n+1;
      x(i)=a+(i-1)*h;
      y(i)=f(x(i));
  end
hold on
 ezplot(f,[min(x):0.2:max(x)]);
 plot(x,y,'og');
 plot(x,y,'g');
function salir_Callback(hObject, eventdata, handles)
close(gcbf);

Metodo De Newton-Rapshon Con Interfaz De Usario en Matlab

Acontinuacion Mostramos el codigo Usado en Cada uno de los botones

 

%Edit Text entrada
  function entrada_Callback(hObject, eventdata, handles)
  funcion=inline(get(handles.entrada,'string'));

%Edit Text Derivada
  function derivada_Callback(hObject, eventdata, handles)
  Derivada=inline(get(handles.derivada,'string'));

%Edit Text Xo
  function Xo_Callback(hObject, eventdata, handles)
  xo=str2double(get(handles.Xo,'string'));

%Edit Text error
  function error_Callback(hObject, eventdata, handles)
  Error=str2double(get(handles.error,'string'));

%Codigo del Push Button calcular
  function calcular_Callback(hObject, eventdata, handles)
funcion=inline(get(handles.entrada,'string'));
Derivada=inline(get(handles.derivada,'string'));
xo=str2double(get(handles.Xo,'string'));
Error=str2double(get(handles.error,'string'));
if isnan (xo)
    msgbox({'Valor no Numerico o fuera de Rango',...
        'En Xo favor de introducir un Dato  Valido'},'Upss','error');
elseif isnan(Error)
    errordlg({'Valor no Numerico o Fuera de Rango',...
        'En Error Favor de Introducir un Dato Valido'},'Upss');
else
 X1=(xo-funcion(xo))/Derivada(xo);
while abs(X1-xo)>Error
    xo=X1;
    X1=(xo-funcion(xo))/Derivada(xo);
end
set(handles.salida,'string',X1);

end

%Codigo del Push Button Graficar
function graficar_Callback(hObject, eventdata, handles)
funcion=inline(get(handles.entrada,'string'));
Derivada=inline(get(handles.derivada,'string'));
grid on
hold on
fx=ezplot(Derivada);
set(fx,'color','m');

dfx=ezplot(funcion);
set(dfx,'color','b');
legend('F(X)','dF(X)');