Eliminação de Gauss

function x = eliminacaoGauss(A, b)
Ab = [A, b];
n = size(A, 1);

for k = 1:n
[~, pivot] = max(abs(Ab(k:n, k)));
pivot = pivot + k - 1;
Ab([k, pivot], :) = Ab([pivot, k], :);
Ab(k+1:end, :) = Ab(k+1:end, :) - Ab(k+1:end, k) / Ab(k, k) * Ab(k,
:);
end

x = zeros(n, 1);
for i = n:-1:1
x(i) = (Ab(i, end) - Ab(i, i+1:n) * x(i+1:n)) / Ab(i, i);
end
end

Eliminação de Gauss com pivoteamento

function x = eliminacaoGaussPivoteamento(A, b)

[n, m] = size(A);

if n ~= m
error('A matriz A deve ser quadrada.');
end

if length(b) ~= n
error('O vetor b deve ter o mesmo número de linhas que A.');
end

Ab = [A, b];

for i = 1:n
[~, idx_pivo] = max(abs(Ab(i:n, i)));
idx_pivo = idx_pivo + i - 1;

Ab([i, idx_pivo], :) = Ab([idx_pivo, i], :);

for j = i+1:n
fator = Ab(j, i) / Ab(i, i);
Ab(j, i:end) = Ab(j, i:end) - fator * Ab(i, i:end);
end
end

x = zeros(n, 1);
for i = n:-1:1
x(i) = (Ab(i, end) - Ab(i, i+1:end-1) * x(i+1:end)) / Ab(i, i);
end
end
Gauss-Seidel
function [x, iter] = gaussSeidel(A, b, tol, max_iter)
[n, ~] = size(A);

x = zeros(n, 1);
iter = 0;

while iter < max_iter

x_ant = x;

for i = 1:n
sigma1 = A(i, 1:i-1) * x(1:i-1);
sigma2 = A(i, i+1:end) * x_ant(i+1:end);
x(i) = (b(i) - sigma1 - sigma2) / A(i, i);
end

if norm(x - x_ant, inf) < tol

break;
end

iter = iter + 1;
end

if iter == max_iter
warning('O método de Gauss-Seidel atingiu o número máximo de
iterações.');
end
end

Jacobi

function [x, iter] = jacobi(A, b, tol, max_iter)

[n, ~] = size(A);

x = zeros(n, 1);
x_ant = x;
iter = 0;

while iter < max_iter

for i = 1:n
sigma = A(i, 1:i-1) * x_ant(1:i-1) + A(i, i+1:end) *
x_ant(i+1:end);
x(i) = (b(i) - sigma) / A(i, i);
end

if norm(x - x_ant, inf) < tol

break;
end

x_ant = x;
iter = iter + 1;
end

if iter == max_iter
warning('O método de Jacobi atingiu o número máximo de iterações.');
end
end
Bissecção

clear all

format short;

a = input('Digite o valor de a: ');

b = input('Digite o valor de b: ');
cont = input('Digite o número de iterações cont: ');
fun = input('Digite a função f(x): ', 's');

f = inline(fun);

for k = 1:cont
c = (a + b) / 2;
e = abs((b - a) / 2);

fprintf('Iteração %d: a=%.5f, b=%.5f, c=%.5f, f(c)=%.5f, erro=%.5f\n', k,

a, b, c, f(c), e);

if e < 1e-6 || f(c) == 0

fprintf('Solução:\n c=%8.5f\n', c);
fprintf('f(c)=%8.5f\n', f(c));
fprintf('erro=%8.5f\n', e);
return;
end

if f(a) * f(c) < 0

b = c;
else
a = c;
end
end

fprintf('O método da bissecção não convergiu dentro do número máximo de

iterações.\n');
Newton
function [raiz, iter] = metodoNewton(f, df, x0, tol, max_iter)
x = x0;
iter = 0;

while iter < max_iter

x_ant = x;
x = x - f(x) / df(x);

if abs(f(x)) < tol

break;
end

iter = iter + 1;
end

raiz = x;

if iter == max_iter
warning('O Método de Newton atingiu o número máximo de iterações.');
end
end
Newton-Raphson
function [raiz, historial] = newtonRaphson(f, df, x0, tolerancia, max_iter)

historial = zeros(max_iter, 1);

x = x0;

for i = 1:max_iter
x = x - f(x) / df(x);
historial(i) = x;

if abs(f(x)) < tolerancia

break;
end
end

raiz = x;

figure;
plot(1:i, historial(1:i), '-o');
title('Convergência do Método de Newton-Raphson');
xlabel('Iteração');
ylabel('Aproximação da Raiz');
grid on;
end