Feat/rref

.github/workflows/github-actions.yml

@@ -1,10 +1,9 @@
 name: Github Actions
 on:
-  push:
   pull_request:
 jobs:
-  test:
-    name: Test
+  test-api:
+    name: test-api
     runs-on: ubuntu-20.04
     steps:
       - uses: actions/checkout@v2
@@ -23,3 +22,23 @@ jobs:
             ${{ runner.OS }}-
       - run: npm ci
       - run: npm run test
+  test-unit:
+    name: test-unit
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js
+        uses: actions/setup-node@v1
+        with:
+          node-version: "14.x"
+      - name: Cache Node.js modules
+        uses: actions/cache@v2
+        with:
+          # npm cache files are stored in `~/.npm` on Linux/macOS
+          path: ~/.npm
+          key: ${{ runner.OS }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.OS }}-node-
+            ${{ runner.OS }}-
+      - run: npm ci
+      - run: npm run test-unit

app/classes/Matrix.ts

@@ -1,3 +1,10 @@
+import { range } from "../utils/misc"
+
+import { EchelonType } from "../types/Matrix"
+import { leadingEntryIndex } from "../utils/Matrix"
+
+import * as _ from "lodash"
+
 interface IMatrix {
   rows: number
   columns: number
@@ -23,6 +30,213 @@ abstract class BaseMatrix {
       this.entries = tmp
     }
   }
+
+  /**
+   * Returns whether a matrix is in RREF, REF, or NONE.
+   */
+  echelonStatus(): EchelonType {
+    // obtain array of leading entry indices
+    let leadingIndices: number[] = []
+    this.entries.forEach((row) => {
+      const leadingIndex = leadingEntryIndex(row)
+      leadingIndices.push(leadingIndex)
+    })
+
+    // remove all end -1s as they are extra zero rows at the bottom of the matrix
+    while (
+      leadingIndices.length > 0 &&
+      leadingIndices[leadingIndices.length - 1] === -1
+    )
+      leadingIndices.pop()
+
+    // Check 1a: if there are still non-zero rows, this means they are not at the bottom, so return NONE
+    if (leadingIndices.some((one) => one === -1)) return EchelonType.NONE
+
+    // Check 1b: if leadingEntryIndices not in increasing order, return NONE
+    let idx = 1
+    while (idx < this.rows) {
+      if (leadingIndices[idx - 1] >= leadingIndices[idx])
+        return EchelonType.NONE
+      idx++
+    }
+
+    // reaching here means is either REF or RREF
+
+    // Check 2: if leadingIndices has no more entries (i.e. was all -1s), this is a zero matrix, and is RREF
+    if (leadingIndices.length === 0) return EchelonType.RREF
+
+    // Check 3: For RREF, all leading entries of nonzero rows should be 1
+    const allLeadingOne = leadingIndices.every(
+      (colIdx, rowIdx) => this.entries[rowIdx][colIdx] === 1
+    )
+    if (!allLeadingOne) return EchelonType.REF
+
+    // Check 4: For RREF, the only nonzero value in a pivot column is the pivot point
+    const pivotColumnsCheck = leadingIndices.every((colIdx, idx) => {
+      const res = range(this.rows).every((rowIdx) => {
+        // if the leading index found previously belongs to this row
+        if (idx == rowIdx) return true
+
+        return this.entries[rowIdx][colIdx] === 0
+      })
+      return res
+    })
+    if (!pivotColumnsCheck) return EchelonType.REF
+
+    // reaching here means RREF
+    return EchelonType.RREF
+  }
+
+  /**
+   * Multiplies a row by a given factor
+   * @param rowIdx row index number
+   * @param factor factor to multiply by
+   */
+  multiplyRow(rowIdx: number, factor: number) {
+    this.entries[rowIdx] = this.entries[rowIdx].map((one) => factor * one)
+  }
+
+  /**
+   * Swaps rows i and j
+   * @param i row index number
+   * @param j row index number
+   */
+  swapRows(i: number, j: number) {
+    const tmp = this.entries[i]
+    this.entries[i] = this.entries[j]
+    this.entries[j] = tmp
+  }
+
+  /**
+   * Adds a multiple of one row to another row
+   * @param rowIdx index of the row to multiply factor
+   * @param factor factor to multiply by
+   * @param addToIdx index of the row to add to
+   */
+  addMultiple(rowIdx: number, factor: number, addToIdx: number) {
+    range(this.columns).forEach((colIdx) => {
+      this.entries[addToIdx][colIdx] += this.entries[rowIdx][colIdx] * factor
+    })
+  }
+
+  /**
+   * Returns true if every entry in column colIdx is 0, false otherwise
+   * @param colIdx index of the column
+   */
+  isZeroColumn(colIdx: number) {
+    return range(this.rows).every(
+      (rowIdx) => this.entries[rowIdx][colIdx] === 0
+    )
+  }
+
+  /**
+   * Reduces the matrix to REF
+   */
+  toREF() {
+    let actions = [] // array of actions done during REF
+
+    actions.push({
+      action: "none",
+      params: [],
+      matrix: _.cloneDeep(this.entries),
+    })
+
+    let colIdx = 0 // leftmost nonzero column idx
+    let rowsDone = 0 // number of rows done
+
+    while (this.echelonStatus() === EchelonType.NONE) {
+      // find next nonzero column
+      let foundColumn = false
+      while (!foundColumn && colIdx < this.columns) {
+        if (this.isZeroColumn(colIdx)) colIdx++
+        else foundColumn = true
+      }
+
+      if (foundColumn) {
+        let firstEntryRowIdx = -1
+        // find first nonzero entry in column, that is excluding the done rows
+        for (let i = rowsDone; i < this.rows; i++)
+          if (this.entries[i][colIdx] !== 0) {
+            firstEntryRowIdx = i
+            break
+          }
+
+        // swap top row with this row
+        if (rowsDone !== firstEntryRowIdx) {
+          this.swapRows(rowsDone, firstEntryRowIdx)
+          actions.push({
+            action: "swap",
+            params: [rowsDone, firstEntryRowIdx],
+            matrix: _.cloneDeep(this.entries),
+          })
+        }
+
+        // add multiple of top row to every other row below
+        const pivotValue = this.entries[rowsDone][colIdx]
+        for (let i = rowsDone + 1; i < this.rows; i++) {
+          const factor = (this.entries[i][colIdx] / pivotValue) * -1
+          this.addMultiple(rowsDone, factor, i)
+          actions.push({
+            action: "addMultiple",
+            params: [rowsDone, factor, i],
+            matrix: _.cloneDeep(this.entries),
+          })
+        }
+
+        // mark as done
+        rowsDone++
+        colIdx++
+      } else {
+        break
+      }
+    }
+
+    return actions
+  }
+
+  /**
+   * Reduces the matrix to RREF
+   */
+  toRREF() {
+    let actions = this.toREF()
+
+    // make all leading entries 1
+    this.entries.forEach((row, rowIdx) => {
+      const colIdx = leadingEntryIndex(row)
+      if (colIdx !== -1) {
+        const leadingVal = row[colIdx]
+        const factor = 1 / leadingVal
+        if (factor !== 1) {
+          this.multiplyRow(rowIdx, factor)
+          actions.push({
+            action: "multiplyRow",
+            params: [rowIdx, factor],
+            matrix: _.cloneDeep(this.entries),
+          })
+        }
+      }
+    })
+
+    // add multiples to rows above
+    for (let i = this.rows - 1; i >= 0; i--) {
+      const colIdx = leadingEntryIndex(this.entries[i])
+      if (colIdx === -1) continue
+
+      for (let j = i - 1; j >= 0; j--) {
+        const factor = -this.entries[j][colIdx]
+        if (factor !== 0) {
+          this.addMultiple(i, factor, j)
+          actions.push({
+            action: "addMultiple",
+            params: [i, factor, j],
+            matrix: _.cloneDeep(this.entries),
+          })
+        }
+      }
+    }
+
+    return actions
+  }
 }
 
 class Matrix extends BaseMatrix {

app/controllers/matrix.ts

@@ -1,6 +1,6 @@
 import { VercelRequest, VercelResponse } from "@vercel/node"
 
-import { SquareMatrix } from "../classes/Matrix"
+import { Matrix, SquareMatrix } from "../classes/Matrix"
 
 const calcDeterminant = (req: VercelRequest, res: VercelResponse) => {
   try {
@@ -27,6 +27,34 @@ const calcDeterminant = (req: VercelRequest, res: VercelResponse) => {
   }
 }
 
+const reduceRREF = (req: VercelRequest, res: VercelResponse) => {
+  try {
+    let arr
+    // string array
+    if (Array.isArray(req.query.matrix))
+      arr = JSON.parse(req.query.matrix.join())
+    else arr = JSON.parse(req.query.matrix)
+
+    const rows = arr.length
+    const cols = arr[0].length
+
+    const matrix = new Matrix({
+      rows,
+      columns: cols,
+      entries: arr,
+    })
+
+    const actions = matrix.toRREF()
+    res.json({
+      actions,
+      matrix: matrix.entries,
+    })
+  } catch (err) {
+    res.status(500).json({ message: err.message })
+  }
+}
+
 export default {
   calcDeterminant,
+  reduceRREF,
 }

app/tests/unit/index.ts

@@ -0,0 +1,7 @@
+import utils from "./utils"
+import matrix from "./matrix"
+
+describe("Unit tests", () => {
+  describe("Utils tests", utils)
+  describe("Matrix tests", matrix)
+})