Added root-finding algorithms

Author: MatteoRaso

algorithms/arithmetic_analysis/false_position.m

@@ -0,0 +1,41 @@
+%The basic idea behind the false position method is similar to the bisection
+%method in that we continuously shrink the interval the root lies on until
+%the algorithm converges on the root. Unlike the bisection method, the false
+%position method does not halve the interval with each iteration. Instead of
+%using the midpoint of a and b to create the new interval, the false position
+%method uses the x-intercept of the line connecting f(a) and f(b). This 
+%algorithm converges faster than the bisection method.
+
+%INPUTS:
+%Function handle f
+%endpoint a
+%endpoint b
+%maximum tolerated error
+
+%OUTPUTS:
+%An approximated value for the root of f within the defined interval.
+
+%Written by MatteoRaso
+
+function y = false_position(f, a, b, error)
+  if ~(f(a) < 0)
+    disp("f(a) must be less than 0")
+  elseif ~(f(b) > 0)
+    disp("f(b) must be greater than zero")
+  else 
+    c = 100000;
+    while abs(f(c)) > error
+      %Formula for the x-intercept
+      c = -f(b) * (b - a) / (f(b) - f(a)) + b;
+      if f(c) < 0
+        a = c;
+      else
+        b = c;
+      endif
+      disp(f(c))
+    endwhile
+    x = ["The root is approximately located at ", num2str(c)];
+    disp(x)
+    y = c;
+  endif
+endfunction

algorithms/arithmetic_analysis/newton.m

@@ -0,0 +1,25 @@
+%Newton's method is one of the fastest algorithms to converge on a root.
+%It does not require you to provide any endpoints, but it does require for
+%you to provide the derivative of the function. It is faster than the secant
+%method, but is also not guaranteed to converge.
+
+%INPUTS:
+%function handle f
+%function handle df for the derivative of f
+%initial x-value
+%maximum tolerated error
+
+%OUTPUTS:
+%An approximated value for the root of f.
+
+%Written by MatteoRaso
+
+function y = newton(f, df, x, error)
+  while abs(f(x)) > error
+    x = x - f(x) / df(x);
+    disp(f(x))
+  endwhile
+  A = ["The root is approximately located at ", num2str(x)];
+  disp(A)
+  y = x;
+endfunction

algorithms/arithmetic_analysis/secant.m

@@ -0,0 +1,28 @@
+%Extremely similar to the false position method. The main difference is
+%that the secant method does not actually have a defined interval where
+%the root lies on. It converges faster than the false position method,
+%but it is not always guaranteed to converge.
+
+%INPUTS:
+%Function handle f
+%x1 = a
+%x2 = b
+%maximum tolerated error
+
+%OUTPUTS:
+%An approximated value for the root of f.
+
+%Written by MatteoRaso
+
+function y = secant(f, a, b, error)
+  x = [a, b];
+  n = 2;
+  while abs(f(x(n))) > error
+    x(n + 1) = -f(x(n)) * (x(n) - x(n - 1)) / (f(x(n)) - f(x(n - 1))) + x(n);
+    n = n + 1;
+    disp(f(x(n)))
+  endwhile     
+  A = ["The root is approximately ", num2str(x(n))];
+  disp(A)
+  y = x(n);
+endfunction