updating gaussian elimination to be more general (#219)

* Revamping Gaussian Elimination Chapter to have both Gauss-Jordan elimination and back-substitution. 
* updating Gaussian Elimination code with new Gauss-Jordan method

Author: leios

chapters/algorithms/gaussian_elimination/code/julia/gaussian_elimination.jl

@@ -3,41 +3,44 @@ function gaussian_elimination(A::Array{Float64,2})
     rows = size(A,1)
     cols = size(A,2)
 
+    # Row index
+    row = 1
+
     # Main loop going through all columns
-    for k = 1:min(rows,cols)
+    for col = 1:(cols-1)
 
         # Step 1: finding the maximum element for each column
-        max_index = indmax(abs.(A[k:end,k])) + k-1
+        max_index = indmax(abs.(A[row:end,col])) + row-1
 
         # Check to make sure matrix is good!
-        if (A[max_index, k] == 0)
-            println("matrix is singular! End!")
-            exit(0)
+        if (A[max_index, col] == 0)
+            println("matrix is singular!")
+            continue
         end
 
         # Step 2: swap row with highest value for that column to the top
         temp_vector = A[max_index, :]
-        A[max_index, :] = A[k, :]
-        A[k, :] = temp_vector
-        #println(A)
+        A[max_index, :] = A[row, :]
+        A[row, :] = temp_vector
 
         # Loop for all remaining rows
-        for i = (k+1):rows
+        for i = (row+1):rows
 
             # Step 3: finding fraction
-            fraction = A[i,k]/A[k,k]
+            fraction = A[i,col]/A[row,col]
 
             # loop through all columns for that row
-            for j = (k+1):cols
+            for j = (col+1):cols
 
                  # Step 4: re-evaluate each element
-                 A[i,j] -= A[k,j]*fraction
+                 A[i,j] -= A[row,j]*fraction
 
             end
 
             # Step 5: Set lower elements to 0
-            A[i,k] = 0
+            A[i,col] = 0
         end
+        row += 1
     end
 end
 
@@ -63,18 +66,51 @@ function back_substitution(A::Array{Float64,2})
     return soln
 end
 
+
+function gauss_jordan(A::Array{Float64,2})
+
+    rows = size(A,1)
+    cols = size(A,2)
+
+
+    # After this, we know what row to start on (r-1)
+    # to go back through the matrix
+    row = 1
+    for col = 1:cols-1
+        if (A[row, col] != 0)
+
+            # divide row by pivot and leaving pivot as 1
+            for i = cols:-1:col
+                A[row,i] /= A[row,col]
+            end
+    
+            # subtract value from above row and set values above pivot to 0
+            for i = 1:row-1
+                for j = cols:-1:col
+                    A[i,j] -= A[i,col]*A[row,j]
+                end
+            end
+            row += 1
+        end
+    end
+
+    return A
+end
+
 function main()
     A = [2. 3 4 6;
          1 2 3 4;
          3 -4 0 10]
 
     gaussian_elimination(A)
     println(A)
+
+    reduced = gauss_jordan(A)
+    println(reduced)
+
     soln = back_substitution(A)
+    println(soln)
 
-    for element in soln
-        println(element)
-    end
 end
 
 main()