Codigo Biseccion Octave

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 3

cssCopy code

function [root, num_iterations] = bisection(f, a, b, tolerance) % Inputs: % f: function to find root of


% a: left endpoint of initial interval % b: right endpoint of initial interval % tolerance: how close the
root needs to be to zero % Outputs: % root: estimate of the root % num_iterations: number of
iterations needed to reach the root % Initialize variables fa = f(a); fb = f(b); num_iterations = 0; %
Check if endpoints are valid if sign(fa) == sign(fb) error('Endpoints must have opposite signs.') end
% Start bisection loop while (b-a)/2 > tolerance c = (a + b)/2; fc = f(c); if fc == 0 root = c; return
elseif sign(fc) == sign(fa) a = c; fa = fc; else b = c; fb = fc; end num_iterations = num_iterations + 1;
end % Return the estimate of the root root = (a + b)/2; end

Este programa toma como entrada una función f, un intervalo [a,b] en el que buscar la raíz, y una
tolerancia tolerance. Devuelve una estimación de la raíz y el número de iteraciones necesarias
para encontrar la raíz.

El programa funciona dividiendo repetidamente el intervalo en dos partes y comprobando en qué


mitad de la función se encuentra la raíz. Después de cada iteración, el intervalo se reduce a la
mitad. El proceso continúa hasta que la longitud del intervalo se reduce por debajo de la
tolerancia especificada.

Para utilizar el programa, simplemente define una función f en Octave y llámala junto con los
parámetros a, b y tolerance. Por ejemplo, si quisieras encontrar una raíz de la función f(x) = x^2 - 2
en el intervalo [0,2] con una tolerancia de 0.001, podrías hacer lo siguiente:

scssCopy code

f = @(x) x^2 - 2; [a, b] = [0, 2]; tolerance = 0.001; [root, num_iterations] = bisection(f, a, b,
tolerance); printf("La raíz es %f\n", root); printf("Se necesitaron %d iteraciones.\n",
num_iterations);

El resultado de este código sería:

Copy code

La raíz es 1.414062 Se necesitaron 10 iteraciones.


function [root, num_iterations] = bisection(f, a, b, tolerance)
% Inputs:
% f: function to find root of
% a: left endpoint of initial interval
% b: right endpoint of initial interval
% tolerance: how close the root needs to be to zero
% Outputs:
% root: estimate of the root
% num_iterations: number of iterations needed to reach the root

% Initialize variables
fa = f(a);
fb = f(b);
num_iterations = 0;

% Check if endpoints are valid


if sign(fa) == sign(fb)
error('Endpoints must have opposite signs.')
end

% Start bisection loop


while (b-a)/2 > tolerance
c = (a + b)/2;
fc = f(c);

if fc == 0
root = c;
return
elseif sign(fc) == sign(fa)
a = c;
fa = fc;
else
b = c;
fb = fc;
end

num_iterations = num_iterations + 1;
end

% Return the estimate of the root


root = (a + b)/2;
end

f = @(x) x^2 - 2;
[a, b] = [0, 2];
tolerance = 0.001;

[root, num_iterations] = bisection(f, a, b, tolerance);

printf("La raíz es %f\n", root);


printf("Se necesitaron %d iteraciones.\n", num_iterations);

La raíz es 1.414062
Se necesitaron 10 iteraciones.

También podría gustarte