diff --git a/README.md b/README.md
index ce93985d..56001a9b 100644
--- a/README.md
+++ b/README.md
@@ -74,6 +74,7 @@ Various Math algorithms:
 - [Fast Exponentiation](https://github.com/manrajgrover/algorithms-js/blob/master/src/algorithms/math/fast_exp.js)
 - [GCD](https://github.com/manrajgrover/algorithms-js/blob/master/src/algorithms/math/gcd.js)
 - [LCM](https://github.com/manrajgrover/algorithms-js/blob/master/src/algorithms/math/lcm.js)
+- [Tridiagonal Algorithm](https://github.com/manrajgrover/algorithms-js/blob/master/src/algorithms/math/tridiagonal_algorithm.js)
 
 #### String
 Various String algorithms:
diff --git a/docs/README.md b/docs/README.md
index 0f4eb555..1b4a0f6d 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,4 +1,4 @@
-# [algorithms-js](https://github.com/manrajgrover/algorithms-js#readme) *0.0.8*
+# [algorithms-js](https://github.com/manrajgrover/algorithms-js#readme) *0.0.13*
 
 > Algorithms Library in JavaScript
 
@@ -254,6 +254,35 @@ Calculates LCM of two numbers
 
 
 
+### src/algorithms/math/matrix_determinant.js
+
+
+#### matrixDeterminant(M) 
+
+Calculates the determinant of a non-singular matrix
+with real entries using Bareiss's algorithm.
+
+
+
+
+##### Parameters
+
+| Name | Type | Description |  |
+| ---- | ---- | ----------- | -------- |
+| M | `Array`  | Matrix with real entries. | &nbsp; |
+
+
+
+
+##### Returns
+
+
+- `Number`  determinant of the matrix M. 
+Reference: https://en.wikipedia.org/wiki/Bareiss_algorithm
+
+
+
+
 ### src/algorithms/math/modular_inverse.js
 
 
@@ -306,6 +335,69 @@ Calculates modular inverse of a number
 
 
 
+### src/algorithms/math/tridiagonal_algorithm.js
+
+
+#### extractTridiagonalCoefficients(A, pad) 
+
+Extracts the tridiagonal coefficients from
+a square matrix A. Pads the upper and lower
+diagonal arrays to ensure all three diagonals
+are of equal length.
+
+
+
+
+##### Parameters
+
+| Name | Type | Description |  |
+| ---- | ---- | ----------- | -------- |
+| A | `Array`  | Square matrix. | &nbsp; |
+| pad | `boolean`  | If true, pads lower and upper diagonal arrays. | &nbsp; |
+
+
+
+
+##### Returns
+
+
+- `Object`  Returns object with keys `lowerDiagonal`,                   `centralDiagonal` and `upperDiagonal`.
+
+
+
+#### tridiagonalAlgorithm(A, d) 
+
+Solves a linear system Ax=b where A is a tridiagonal matrix.
+
+Note: the method is only stable in some special cases
+such as when the matrix is diagonally dominant or symmetric
+positive definite (See reference).
+For an algorithm stable in the general case, see:
+http://www2.stat.duke.edu/~sayan/863/lec/linsys.pdf
+
+
+
+
+##### Parameters
+
+| Name | Type | Description |  |
+| ---- | ---- | ----------- | -------- |
+| A | `Array`  | Tridiagonal Maxtrix. | &nbsp; |
+| d | `Array`  | Vector of values. | &nbsp; |
+
+
+
+
+##### Returns
+
+
+-  array representing the solution vector x.          Returns null if system is singular.
+
+Reference: https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm
+
+
+
+
 ### src/algorithms/search/binary_search.js
 
 
diff --git a/docs/index.html b/docs/index.html
index 9294cff2..44a483f2 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -3,7 +3,7 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="initial-scale=1">
-<title>algorithms-js 0.0.8 &#8212; Algorithms Library in JavaScript</title>
+<title>algorithms-js 0.0.13 &#8212; Algorithms Library in JavaScript</title>
 <meta name="description" content="Algorithms Library in JavaScript">
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.0.0-alpha.6/css/bootstrap.min.css">
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css">
@@ -163,7 +163,7 @@
 
         <h1>
                 <a href="https://github.com/manrajgrover/algorithms-js#readme">algorithms-js</a>
-            <small>0.0.8</small>
+            <small>0.0.13</small>
         </h1>
 
         <p>Algorithms Library in JavaScript</p>
@@ -295,6 +295,21 @@ <h1>
                     </li>
 
 
+                    <li>
+                        <a href="#src/algorithms/math/matrix_determinant.js" class="file"><b>src/algorithms/math/matrix_determinant.js</b></a>
+                        <ul>
+
+
+                        <li class="method-link scope-public">
+                            <a href="#src-algorithms-math-matrix_determinant.js-matrixdeterminant" title="matrixDeterminant">matrixDeterminant</a>
+                        </li>
+
+
+                        </ul>
+
+                    </li>
+
+
                     <li>
                         <a href="#src/algorithms/math/modular_inverse.js" class="file"><b>src/algorithms/math/modular_inverse.js</b></a>
                         <ul>
@@ -315,6 +330,26 @@ <h1>
                     </li>
 
 
+                    <li>
+                        <a href="#src/algorithms/math/tridiagonal_algorithm.js" class="file"><b>src/algorithms/math/tridiagonal_algorithm.js</b></a>
+                        <ul>
+
+
+                        <li class="method-link scope-public">
+                            <a href="#src-algorithms-math-tridiagonal_algorithm.js-extracttridiagonalcoefficients" title="extractTridiagonalCoefficients">extractTridiagonalCoefficients</a>
+                        </li>
+
+
+                        <li class="method-link scope-public">
+                            <a href="#src-algorithms-math-tridiagonal_algorithm.js-tridiagonalalgorithm" title="tridiagonalAlgorithm">tridiagonalAlgorithm</a>
+                        </li>
+
+
+                        </ul>
+
+                    </li>
+
+
                     <li>
                         <a href="#src/algorithms/search/binary_search.js" class="file"><b>src/algorithms/search/binary_search.js</b></a>
                         <ul>
@@ -1979,6 +2014,84 @@ <h3>Returns</h3>
 
 
 
+                        </section>
+
+                    </div>
+
+
+
+                <a id="src/algorithms/math/matrix_determinant.js"></a>
+
+
+                    <div class="method scope-public">
+
+                        <h2 id="src-algorithms-math-matrix_determinant.js-matrixdeterminant">
+                            <a href="#src-algorithms-math-matrix_determinant.js-matrixdeterminant" class="permalink">#</a>
+                            <span class="method-name" title="matrixDeterminant(M)">matrixDeterminant(M)</span>
+                        </h2>
+
+                        <div class="description lead">
+
+                            <p>Calculates the determinant of a non-singular matrix
+with real entries using Bareiss's algorithm.</p>
+
+
+                        </div>
+
+
+                        <section class="parameters">
+
+                            <h3>Parameters</h3>
+
+                            <div class="table-responsive">
+                                <table class="table">
+
+                                    <thead>
+                                        <tr>
+                                            <th>Name</th>
+                                            <th>Type</th>
+                                            <th>Description</th>
+                                            <th></th>
+                                        </tr>
+                                    </thead>
+
+                                    <tbody>
+                                    <tr>
+                                        <td>M</td>
+                                        <td>
+                                            <code>Array</code>
+                                        </td>
+                                        <td><p>Matrix with real entries.</p>
+</td>
+                                        <td>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+
+                                </table>
+                            </div>
+
+                        </section>
+
+
+
+
+                        <section class="returns">
+
+                            <h3>Returns</h3>
+
+
+
+                                    <p>
+                                            <code>Number</code>
+                                    </p>
+
+                                    <p>determinant of the matrix M.
+Reference: <a href="https://en.wikipedia.org/wiki/Bareiss_algorithm">https://en.wikipedia.org/wiki/Bareiss_algorithm</a></p>
+
+
+
+
                         </section>
 
                     </div>
@@ -2147,6 +2260,182 @@ <h3>Returns</h3>
 
 
 
+                        </section>
+
+                    </div>
+
+
+
+                <a id="src/algorithms/math/tridiagonal_algorithm.js"></a>
+
+
+                    <div class="method scope-public">
+
+                        <h2 id="src-algorithms-math-tridiagonal_algorithm.js-extracttridiagonalcoefficients">
+                            <a href="#src-algorithms-math-tridiagonal_algorithm.js-extracttridiagonalcoefficients" class="permalink">#</a>
+                            <span class="method-name" title="extractTridiagonalCoefficients(A, pad)">extractTridiagonalCoefficients(A, pad)</span>
+                        </h2>
+
+                        <div class="description lead">
+
+                            <p>Extracts the tridiagonal coefficients from
+a square matrix A. Pads the upper and lower
+diagonal arrays to ensure all three diagonals
+are of equal length.</p>
+
+
+                        </div>
+
+
+                        <section class="parameters">
+
+                            <h3>Parameters</h3>
+
+                            <div class="table-responsive">
+                                <table class="table">
+
+                                    <thead>
+                                        <tr>
+                                            <th>Name</th>
+                                            <th>Type</th>
+                                            <th>Description</th>
+                                            <th></th>
+                                        </tr>
+                                    </thead>
+
+                                    <tbody>
+                                    <tr>
+                                        <td>A</td>
+                                        <td>
+                                            <code>Array</code>
+                                        </td>
+                                        <td><p>Square matrix.</p>
+</td>
+                                        <td>
+                                        </td>
+                                    </tr>
+                                    <tr>
+                                        <td>pad</td>
+                                        <td>
+                                            <code>boolean</code>
+                                        </td>
+                                        <td><p>If true, pads lower and upper diagonal arrays.</p>
+</td>
+                                        <td>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+
+                                </table>
+                            </div>
+
+                        </section>
+
+
+
+
+                        <section class="returns">
+
+                            <h3>Returns</h3>
+
+
+
+                                    <p>
+                                            <code>Object</code>
+                                    </p>
+
+                                    <p>Returns object with keys <code>lowerDiagonal</code>,                   <code>centralDiagonal</code> and <code>upperDiagonal</code>.</p>
+
+
+
+
+                        </section>
+
+                    </div>
+
+
+                    <div class="method scope-public">
+
+                        <h2 id="src-algorithms-math-tridiagonal_algorithm.js-tridiagonalalgorithm">
+                            <a href="#src-algorithms-math-tridiagonal_algorithm.js-tridiagonalalgorithm" class="permalink">#</a>
+                            <span class="method-name" title="tridiagonalAlgorithm(A, d)">tridiagonalAlgorithm(A, d)</span>
+                        </h2>
+
+                        <div class="description lead">
+
+                            <p>Solves a linear system Ax=b where A is a tridiagonal matrix.</p>
+<p>Note: the method is only stable in some special cases
+such as when the matrix is diagonally dominant or symmetric
+positive definite (See reference).
+For an algorithm stable in the general case, see:
+<a href="http://www2.stat.duke.edu/~sayan/863/lec/linsys.pdf">http://www2.stat.duke.edu/~sayan/863/lec/linsys.pdf</a></p>
+
+
+                        </div>
+
+
+                        <section class="parameters">
+
+                            <h3>Parameters</h3>
+
+                            <div class="table-responsive">
+                                <table class="table">
+
+                                    <thead>
+                                        <tr>
+                                            <th>Name</th>
+                                            <th>Type</th>
+                                            <th>Description</th>
+                                            <th></th>
+                                        </tr>
+                                    </thead>
+
+                                    <tbody>
+                                    <tr>
+                                        <td>A</td>
+                                        <td>
+                                            <code>Array</code>
+                                        </td>
+                                        <td><p>Tridiagonal Maxtrix.</p>
+</td>
+                                        <td>
+                                        </td>
+                                    </tr>
+                                    <tr>
+                                        <td>d</td>
+                                        <td>
+                                            <code>Array</code>
+                                        </td>
+                                        <td><p>Vector of values.</p>
+</td>
+                                        <td>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+
+                                </table>
+                            </div>
+
+                        </section>
+
+
+
+
+                        <section class="returns">
+
+                            <h3>Returns</h3>
+
+
+
+                                    <p>
+                                    </p>
+
+                                    <p>array representing the solution vector x.          Returns null if system is singular.</p>
+<p>Reference: <a href="https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm">https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm</a></p>
+
+
+
+
                         </section>
 
                     </div>
diff --git a/src/algorithms/math/index.js b/src/algorithms/math/index.js
index 41b2e488..0c06df1c 100644
--- a/src/algorithms/math/index.js
+++ b/src/algorithms/math/index.js
@@ -3,11 +3,13 @@ const gcd = require('./gcd');
 const fastexp = require('./fast_exp');
 const lcm = require('./lcm');
 const modularInverse = require('./modular_inverse');
+const tridiagonalAlgorithm = require('./tridiagonal_algorithm');
 
 module.exports = {
   extendedEuclidean,
   gcd,
   fastexp,
   lcm,
-  modularInverse
+  modularInverse,
+  tridiagonalAlgorithm
 };
diff --git a/src/algorithms/math/tridiagonal_algorithm.js b/src/algorithms/math/tridiagonal_algorithm.js
new file mode 100644
index 00000000..7673f042
--- /dev/null
+++ b/src/algorithms/math/tridiagonal_algorithm.js
@@ -0,0 +1,89 @@
+/**
+ * Extracts the tridiagonal coefficients from
+ * a square matrix A. Pads the upper and lower
+ * diagonal arrays to ensure all three diagonals
+ * are of equal length.
+ * @param {Array} A Square matrix.
+ * @param {boolean} pad If true, pads lower and upper diagonal arrays.
+ * @returns {Object} Returns object with keys `lowerDiagonal`,
+ *                   `centralDiagonal` and `upperDiagonal`.
+ */
+const extractTridiagonalCoefficients = (A, pad = false) => {
+  const n = A.length;
+  const upperDiag = [A[0][1]];
+  const diag = [A[0][0]];
+  const lowerDiag = [];
+  // padding lower diag vector if padding enabled.
+  if (pad) {
+    lowerDiag.push(0);
+  }
+
+  // Extracting diagonal values.
+  for (let i = 1; i < n - 1; i += 1) {
+    upperDiag.push(A[i][i + 1]);
+    diag.push(A[i][i]);
+    lowerDiag.push(A[i][i - 1]);
+  }
+
+  // Padding upper diag vector if padding enabled.
+  if (pad) {
+    upperDiag.push(0);
+  }
+  diag.push(A[n - 1][n - 1]);
+  lowerDiag.push(A[n - 1][n - 2]);
+
+  return {
+    lowerDiagonal: lowerDiag,
+    centralDiagonal: diag,
+    upperDiagonal: upperDiag
+  };
+};
+
+/**
+ * Solves a linear system Ax=b where A is a tridiagonal matrix.
+ *
+ * Note: the method is only stable in some special cases
+ * such as when the matrix is diagonally dominant or symmetric
+ * positive definite (See reference).
+ * For an algorithm stable in the general case, see:
+ * http://www2.stat.duke.edu/~sayan/863/lec/linsys.pdf
+ *
+ * @param {Array} A Tridiagonal Maxtrix.
+ * @param {Array} d Vector of values.
+ * @return array representing the solution vector x.
+ *          Returns null if system is singular.
+ *
+ * Reference: https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm
+ */
+const tridiagonalAlgorithm = (A, d) => {
+  // Extracting the diagonals.
+  const n = A.length;
+  const diagonals = extractTridiagonalCoefficients(A, true);
+  const a = diagonals.lowerDiagonal;
+  const b = diagonals.centralDiagonal;
+  const c = diagonals.upperDiagonal;
+
+  // Solution vector.
+  const x = new Array(n);
+  let w = 0;
+  // Forward sweep.
+  for (let i = 1; i < n; i += 1) {
+    w = a[i] / b[i - 1];
+    b[i] -= w * c[i - 1];
+    d[i] -= w * d[i - 1];
+  }
+  // Back substitution.
+  x[n - 1] = d[n - 1] / b[n - 1];
+  for (let i = n - 2; i >= 0; i -= 1) {
+    x[i] = (d[i] - (c[i] * x[i + 1])) / b[i];
+  }
+
+  // If solution has NaN's, return null.
+  const nanValPresent = x.filter(val => isNaN(val)).length > 0;
+  if (nanValPresent) {
+    return null;
+  }
+  return x;
+};
+
+module.exports = tridiagonalAlgorithm;
diff --git a/test/algorithms/math/testTridiagonalAlgorithm.js b/test/algorithms/math/testTridiagonalAlgorithm.js
new file mode 100644
index 00000000..bab2096e
--- /dev/null
+++ b/test/algorithms/math/testTridiagonalAlgorithm.js
@@ -0,0 +1,80 @@
+/* eslint-env mocha */
+const tridiagonalAlgorithm = require('../../../src/').algorithms.math.tridiagonalAlgorithm;
+
+const assert = require('assert');
+
+// Creates a square zero matrix of size n.
+const createEmptyMatrix = (n) => {
+  const zeroMatrix = new Array(n).fill(0);
+  for (let i = 0; i < n; i += 1) {
+    zeroMatrix[i] = new Array(n).fill(0);
+  }
+  return zeroMatrix;
+};
+
+// Creates an identity matrix of size n.
+const generateIdentityMatrix = (n) => {
+  const identityMatrix = createEmptyMatrix(n);
+  for (let i = 0; i < n; i += 1) {
+    identityMatrix[i][i] = 1;
+  }
+  return identityMatrix;
+};
+
+// Checks if two vectors are equal up to a tolerance value.
+function equalUptoTolerance(a, b, tol = 0) {
+  for (let i = 0; i < a.length; i += 1) {
+    if (Math.abs(a[i] - b[i]) > tol) {
+      return false;
+    }
+  }
+  return true;
+}
+
+describe('Tridiagonal Algorithm', () => {
+  it('should return vector of 1\'s', () => {
+    const idMatrix4 = generateIdentityMatrix(4);
+    const idMatrix7 = generateIdentityMatrix(7);
+    const d4 = new Array(4).fill(1);
+    const d7 = new Array(7).fill(1);
+    assert.deepEqual(tridiagonalAlgorithm(idMatrix4, d4), d4);
+    assert.deepEqual(tridiagonalAlgorithm(idMatrix7, d7), d7);
+  });
+
+  it('should return a vector of 0\'s', () => {
+    const A = new Array(9);
+    for (let i = 0; i < 9; i += 1) {
+      A[i] = Array.from({ length: 9 }, () => 1 + Math.floor(Math.random() * 9));
+    }
+    const d = new Array(9).fill(0);
+    assert.deepEqual(tridiagonalAlgorithm(A, d), d);
+  });
+
+  it('should return `null` for system with no solutions', () => {
+    const idMatrix7 = generateIdentityMatrix(7);
+    idMatrix7[6][6] = 0;
+    const d = new Array(7).fill(1);
+    assert.equal(tridiagonalAlgorithm(idMatrix7, d), null);
+  });
+
+  it('should return correct solution when diagnoally dominant.', () => {
+    const testTridiagMatrix = [[3, 1, 0, 0],
+      [1, 3, 1, 0],
+      [0, 1, 3, 1],
+      [0, 0, 1, 3]];
+    const d = [2, 3, 3, 2];
+    const expectedSol = [5 / 11, 7 / 11, 7 / 11, 5 / 11];
+    assert.equal(equalUptoTolerance(tridiagonalAlgorithm(testTridiagMatrix, d),
+      expectedSol, 1E-12), true);
+  });
+
+  it('should return correct solution when A is symmetric positive definite.', () => {
+    const testTridiagMatrix = [[1, 3 / 4, 0],
+      [3 / 4, 1, 3 / 4],
+      [0, 3 / 4, 1]];
+    const d = [1, 2, 3];
+    const expectedSol = [-5, 8, -3];
+    assert.equal(equalUptoTolerance(tridiagonalAlgorithm(testTridiagMatrix, d),
+      expectedSol, 1E-12), true);
+  });
+});

Name	Type	Description
A	+ `Array` +	Square matrix. +	+
pad	+ `boolean` +	If true, pads lower and upper diagonal arrays. +	+
Name	Type	Description
A	+ `Array` +	Tridiagonal Maxtrix. +	+
d	+ `Array` +	Vector of values. +	+