Optimize numerical algorithms with Intel oneMKL

- FFT.f90: Replace hand-written Cooley-Tukey FFT with oneMKL DFTI
   - ilucg.f90: Replace manual dot product loop with BLAS DDOT
   - gaussj.C: Replace Gauss-Jordan elimination with LAPACK dgesv/dgetri
   - makefile.inc: Add MKL include paths and library linking

   All optimizations maintain mathematical equivalence and numerical precision.

AMSS_NCKU_source/gaussj.C

@@ -16,115 +16,66 @@ using namespace std;
 #include <string.h>
 #include <math.h>
 #endif
-/* Linear equation solution by Gauss-Jordan elimination.
+
+// Intel oneMKL LAPACK interface
+#include <mkl_lapacke.h>
+/* Linear equation solution using Intel oneMKL LAPACK.
 a[0..n-1][0..n-1] is the input matrix. b[0..n-1] is input
 containing the right-hand side vectors. On output a is
 replaced by its matrix inverse, and b is replaced by the
-corresponding set of solution vectors */
+corresponding set of solution vectors.
+
+Mathematical equivalence:
+  Solves: A * x = b  =>  x = A^(-1) * b
+  Original Gauss-Jordan and LAPACK dgesv/dgetri produce identical results
+  within numerical precision. */
 
 int gaussj(double *a, double *b, int n)
 {
-  double swap;
+  // Allocate pivot array and workspace
+  lapack_int *ipiv = new lapack_int[n];
+  lapack_int info;
 
-  int *indxc, *indxr, *ipiv;
-  indxc = new int[n];
-  indxr = new int[n];
-  ipiv = new int[n];
-
-  int i, icol, irow, j, k, l, ll;
-  double big, dum, pivinv, temp;
-
-  for (j = 0; j < n; j++)
-    ipiv[j] = 0;
-  for (i = 0; i < n; i++)
-  {
-    big = 0.0;
-    for (j = 0; j < n; j++)
-      if (ipiv[j] != 1)
-        for (k = 0; k < n; k++)
-        {
-          if (ipiv[k] == 0)
-          {
-            if (fabs(a[j * n + k]) >= big)
-            {
-              big = fabs(a[j * n + k]);
-              irow = j;
-              icol = k;
-            }
-          }
-          else if (ipiv[k] > 1)
-          {
-            cout << "gaussj: Singular Matrix-1" << endl;
-            for (int ii = 0; ii < n; ii++)
-            {
-              for (int jj = 0; jj < n; jj++)
-                cout << a[ii * n + jj] << " ";
-              cout << endl;
-            }
-            return 1; // error return
-          }
-        }
-
-    ipiv[icol] = ipiv[icol] + 1;
-    if (irow != icol)
-    {
-      for (l = 0; l < n; l++)
-      {
-        swap = a[irow * n + l];
-        a[irow * n + l] = a[icol * n + l];
-        a[icol * n + l] = swap;
-      }
-
-      swap = b[irow];
-      b[irow] = b[icol];
-      b[icol] = swap;
-    }
-
-    indxr[i] = irow;
-    indxc[i] = icol;
-
-    if (a[icol * n + icol] == 0.0)
-    {
-      cout << "gaussj: Singular Matrix-2" << endl;
-      for (int ii = 0; ii < n; ii++)
-      {
-        for (int jj = 0; jj < n; jj++)
-          cout << a[ii * n + jj] << " ";
-        cout << endl;
-      }
-      return 1; // error return
-    }
-
-    pivinv = 1.0 / a[icol * n + icol];
-    a[icol * n + icol] = 1.0;
-    for (l = 0; l < n; l++)
-      a[icol * n + l] *= pivinv;
-    b[icol] *= pivinv;
-    for (ll = 0; ll < n; ll++)
-      if (ll != icol)
-      {
-        dum = a[ll * n + icol];
-        a[ll * n + icol] = 0.0;
-        for (l = 0; l < n; l++)
-          a[ll * n + l] -= a[icol * n + l] * dum;
-        b[ll] -= b[icol] * dum;
-      }
+  // Make a copy of matrix a for solving (dgesv modifies it to LU form)
+  double *a_copy = new double[n * n];
+  for (int i = 0; i < n * n; i++) {
+    a_copy[i] = a[i];
   }
 
-  for (l = n - 1; l >= 0; l--)
-  {
-    if (indxr[l] != indxc[l])
-      for (k = 0; k < n; k++)
-      {
-        swap = a[k * n + indxr[l]];
-        a[k * n + indxr[l]] = a[k * n + indxc[l]];
-        a[k * n + indxc[l]] = swap;
-      }
+  // Step 1: Solve linear system A*x = b using LU decomposition
+  // LAPACKE_dgesv uses column-major by default, but we use row-major
+  info = LAPACKE_dgesv(LAPACK_ROW_MAJOR, n, 1, a_copy, n, ipiv, b, 1);
+
+  if (info != 0) {
+    cout << "gaussj: Singular Matrix (dgesv info=" << info << ")" << endl;
+    delete[] ipiv;
+    delete[] a_copy;
+    return 1;
+  }
+
+  // Step 2: Compute matrix inverse A^(-1) using LU factorization
+  // First do LU factorization of original matrix a
+  info = LAPACKE_dgetrf(LAPACK_ROW_MAJOR, n, n, a, n, ipiv);
+
+  if (info != 0) {
+    cout << "gaussj: Singular Matrix (dgetrf info=" << info << ")" << endl;
+    delete[] ipiv;
+    delete[] a_copy;
+    return 1;
+  }
+
+  // Then compute inverse from LU factorization
+  info = LAPACKE_dgetri(LAPACK_ROW_MAJOR, n, a, n, ipiv);
+
+  if (info != 0) {
+    cout << "gaussj: Singular Matrix (dgetri info=" << info << ")" << endl;
+    delete[] ipiv;
+    delete[] a_copy;
+    return 1;
   }
 
-  delete[] indxc;
-  delete[] indxr;
   delete[] ipiv;
+  delete[] a_copy;
 
   return 0;
 }