Bisección

sg ( f (a) ) =/ sg ( f (b) )
funtion [ x,err,ni ] = MB ( f,a,b,tol )
If tol = = o then
disp. ( `la tolerancia debe ser mayor a cero´)
end
endif
err = 2x tol ;
ni = 0 ;
while err > = tol
x = ( a+ b )/ 2 ;
err = ( b-a ) / 2;
fc = feval ( f,x );
c ni = ni + 1 ;
if f(x) = = 0
err = 0 ;
end
end
if fc * feval ( f,a ) < 0
else
b=x;
else
a=x;
end
End
Falsa Posición

Y – f (a) = m ( x-a )
Y=0
f (a) = m ( x-a )
x = a – f (a)/m
El punto de aproximación
X = a – f (a) (b-a) / f (b) – f (a)
function [ x,err,ni ] = FP ( f,a,b,tol,n máx )
%
for i = 1 : n máx
xa = x
x = a – f (a) * (b-a) / ( f(b) – f(a) )
err = ABS ( xa-x )
fc = feval ( f,x )
if = f ( x ) = = a
err = o ;
end
if err < = tol ;
ni = I ;
break
end
if fc * feval ( f,a ) < 0
b=x;
else
a=x;
end
end
ni = n máx ;
disp ( `Presición no alcanzada´ )
Iteración de Punto Fijo

function [k, p, err, P]=fixpt(g, p0, tol, max1)

% g es la función de iteración
% p0 es el punto de partida
% tol es la tolerancia
% max1 es el número máximo de iteraciones
% k es el número de iteraciones realizadas
% p es la aproximación al punto fijo
% err es la diferencia entre dos términos consecutivos
% P es la sucesión {pn} completa
P(1)= p0;
for K=2: max1
P(k)=feval(g, P(k-1));
err=abs(P(k)-P(k-1));
relerr=err/(abs(P(k))+eps);
p=P(k);
if (err<tol) l (relerr<tol)
break
end
end
if k ==max1
disp(´se ha exedido el número máximo de iteraciones`)
end
JACOBI

Fuction[x, niter, err]=JA (A, B, x‫׎‬, tol, nmax)

A= matriz de los coeficientes del sistema Ax=B
x‫ =׎‬vector de los valores iniciales
nmax= nº max de iteraciones
x= solución del sistema
niter= nº de iteraciones
err= error
B= Vector de términos independientes

n = length ( B );
X = Zeros ( n,1 );
niter = 0
Xa = x‫; ׎‬
for p = 1: n máx
for = i = 1: n
x (i) = ( B(i) – A(i, [ i-1, i+1 : n ])
* xa([ 1: i-1, i+1: n ])) / A ( i,i );
end
err = norm ( x – xa ) ;
if err < tol
niter = p
break
end
xa = x ;
end
if niter = = 0
disp (´No hay convergencia´)
end
Método de la secante

Function [ c,err,ni ] = MS ( f,a,b,tol n máx )

for i = 1 : n máx
c = b – feval ( f,b ) * ( b-a ) / ( feval ( f,b ) – feval ( f,a ) ) ;
err = ABS ( c-b )
if err < tol
ni = i ;
break
end
a=b;
b=c;
end
ni = n máx
disp. ( ´Presición no alcazada, verificar )
Newton – Raphson

function [x, niter, err]=NR(a, f, Df, tol, nmax)

% a= punto inicial
% f= función
% Df= derivada de la función
% tol= tolerancia
% n max= numero de iteraciones
xa=a;
for i=1 : nmax
x=xa-feval[(f,xa)/feval(Df,a)];
if abs(x-xa) <tol
err=abs(x-xa);
niter=i;
break
end
xa=x;
end
Pivoteo Escalonado

Function x = uptrbk (A , B)
% A es una matriz invertible de orden N x N
% B es una matriz de orden N x 1
% X es una matriz de orden N x 1 que contiene
la solución de AX = B.
% Inicializamos X y una matriz C que sirve de
almacén temporal
[ N N ] = size (A) ;
X = seros ( 1, N+1 ) ;
C = seros ( 1,N+1 ) ;
% Calculo de la matriz ampliada Aug = [ A/B ]
Aug = [ A B ] ;
for q = 1 : N-1
% Pivoteo parcial en la columna q – ésima
[ Y , j ] = max (abs (Aug (q:N,q))) ;
% Intercambiamos las filas q – ésima y ( j+q-1 ) – ésima
C = Aug ( q,: ) ;
Aug ( q,: ) = Aug ( j+q-1,: ) ;
Aug ( j+q-1, : ) = C ;
if Aug ( q,q ) == 0
´A es singular. No hay solución o no es única´
Break
End
% Proceso de eliminación en la columna q-ésima
For k=q+1: N
m = Aug ( k,q ) / Aug ( q,q ) ;
Aug ( k,q : N+1 ) – m*Aug ( q,q : N+1 );
end
end
GAUSS-SEIDEL

fuction [x, niter, err]=GS(A, B, x‫׎‬, tol, nmax)

% A= matriz de los coeficientes del sistema Ax=B

% x‫ =׎‬vector de los valores iniciales
% nmax= nº max de iteraciones
% x= solución del sistema
% niter= nº de iteraciones
% err= error
% B= Vector de términos independientes
n=length (B);

x= seros (n,1)

niter=0;

x= x‫׎‬

xa= x‫׎‬

for p=1:nmax

for i= 1:n

xi= B(i)-A(i,[1:i-1; i+1:n])*x([1:i-1,i+1:n]))/A(I,i);

end

err= norm(x-xa);

if err < tol

niter= p

break

end

xa=x

end

if niter==0

disp(`no hay convergencia`)

end