chore: import upstream snapshot with attribution

numerical_methods/lu_decomposition.h

@@ -0,0 +1,102 @@
+/**
+ * @file lu_decomposition.h
+ * @author [Krishna Vedala](https://github.com/kvedala)
+ * @brief Functions associated with [LU
+ * Decomposition](https://en.wikipedia.org/wiki/LU_decomposition)
+ * of a square matrix.
+ */
+#pragma once
+
+#include <iostream>
+#include <valarray>
+#include <vector>
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+/** Define matrix type as a `std::vector` of `std::valarray` */
+template <typename T>
+using matrix = std::vector<std::valarray<T>>;
+
+/** Perform LU decomposition on matrix
+ * \param[in] A matrix to decompose
+ * \param[out] L output L matrix
+ * \param[out] U output U matrix
+ * \returns 0 if no errors
+ * \returns negative if error occurred
+ */
+template <typename T>
+int lu_decomposition(const matrix<T> &A, matrix<double> *L, matrix<double> *U) {
+    int row, col, j;
+    int mat_size = A.size();
+
+    if (mat_size != A[0].size()) {
+        // check matrix is a square matrix
+        std::cerr << "Not a square matrix!\n";
+        return -1;
+    }
+
+    // regularize each row
+    for (row = 0; row < mat_size; row++) {
+        // Upper triangular matrix
+#ifdef _OPENMP
+#pragma omp for
+#endif
+        for (col = row; col < mat_size; col++) {
+            // Summation of L[i,j] * U[j,k]
+            double lu_sum = 0.;
+            for (j = 0; j < row; j++) {
+                lu_sum += L[0][row][j] * U[0][j][col];
+            }
+
+            // Evaluate U[i,k]
+            U[0][row][col] = A[row][col] - lu_sum;
+        }
+
+        // Lower triangular matrix
+#ifdef _OPENMP
+#pragma omp for
+#endif
+        for (col = row; col < mat_size; col++) {
+            if (row == col) {
+                L[0][row][col] = 1.;
+                continue;
+            }
+
+            // Summation of L[i,j] * U[j,k]
+            double lu_sum = 0.;
+            for (j = 0; j < row; j++) {
+                lu_sum += L[0][col][j] * U[0][j][row];
+            }
+
+            // Evaluate U[i,k]
+            L[0][col][row] = (A[col][row] - lu_sum) / U[0][row][row];
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * Compute determinant of an NxN square matrix using LU decomposition.
+ * Using LU decomposition, the determinant is given by the product of diagonal
+ * elements of matrices L and U.
+ *
+ * @tparam T datatype of input matrix - int, unsigned int, double, etc
+ * @param A input square matrix
+ * @return determinant of matrix A
+ */
+template <typename T>
+double determinant_lu(const matrix<T> &A) {
+    matrix<double> L(A.size(), std::valarray<double>(A.size()));
+    matrix<double> U(A.size(), std::valarray<double>(A.size()));
+
+    if (lu_decomposition(A, &L, &U) < 0)
+        return 0;
+
+    double result = 1.f;
+    for (size_t i = 0; i < A.size(); i++) {
+        result *= L[i][i] * U[i][i];
+    }
+    return result;
+}