Merge pull request #23 from MatteoRaso/master

Added a new section and a few algorithms

Author: cozek

README.md

@@ -26,8 +26,14 @@ These repository is a collection of useful algorithms and data structures built
     * Palindrome
   * maths
     * to_polar
+  * arithmetic_analysis
+    * bisection
+    * newton
+    * secant
+    * false position
   * other
     * tic_tac_toe
+  
 
 * machine-learning
   * nearest neighbor

algorithms/arithmetic_analysis/bisection.m

@@ -0,0 +1,44 @@
+%The bisection method for finding the root of a function.
+%f(a) is < 0 and f(b) > 0. By the intermediate value theorem,
+%there exists a number c in between a and b such that f(c) = 0.
+%In other words, there is always a root in between f(a) and f(b).
+%The bisection method takes the midpoint between a and b and evaluates
+%the value of the function at the midpoint. If it is less than 0,
+%a is assigned the midpoint. If it is greater than 0, b is assigned the
+%midpoint. With each iteration, the interval the root lies in is halved,
+%guaranteeing that the algorithm will converge towards the root.
+
+%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 = bisection(f, a, b, error)
+  %Making sure that the user didn't input invalid endpoints.
+  if ~(f(a) < 0)
+    disp("f(a) must be less than 0")
+  elseif ~(f(b) > 0)
+    disp("f(b) must be greater than 0")
+  else 
+    c = 1e9;
+    %Loops until we reach an acceptable approximation.
+    while abs(f(c)) > error
+      c = (a + b) / 2;
+      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/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