Major update of LightKrylov

.github/workflows/ci.yml

@@ -0,0 +1,49 @@
+name: ci
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            toolchain: {compiler: gcc, version: 12, flags: ['-cpp -O3 -march=native -mtune=native']}
+          - os: ubuntu-latest
+            toolchain: {compiler: gcc, version: 13, flags: ['-cpp -O3 -march=native -mtune=native']}
+          - os: ubuntu-latest
+            toolchain: {compiler: intel-classic, version: '2021.10', flags: ['-fpp -O0 -g']}
+          - os: ubuntu-latest
+            toolchain: {compiler: intel, version: '2024.1', flags: ['-fpp -O0 -g']}
+          # - os: ubuntu-latest
+          #   toolchain: {compiler: nvidia-hpc, version: '24.1', flags: ['-Mpreprocess -Ofast']}
+          - os: windows-latest
+            toolchain: {compiler: gcc, version: 13, flags: ['-cpp -O3 -march=native -mtune=native']}
+          # - os: windows-latest
+          #   toolchain: {compiler: intel-classic, version: '2021.10', flags: ["/fpp /O3"]}
+          # - os: windows-latest
+          #   toolchain: {compiler: intel, version: '2024.1', flags: ["/fpp /O3"]}
+          - os: macos-12
+            toolchain: {compiler: gcc, version: 13, flags: ['-cpp -O3 -march=native -mtune=native']}
+          # - os: macos-12
+          #   toolchain: {compiler: intel-classic, version: '2021.10', flags: ['-fpp -O3 -xhost']}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v1
+
+      - uses: fortran-lang/setup-fortran@main
+        id: setup-fortran
+        with:
+          compiler: ${{ matrix.toolchain.compiler }}
+          version: ${{ matrix.toolchain.version }}
+
+      - name: Setup Fortran Package Manager
+        uses: fortran-lang/setup-fpm@v5
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - run: |
+          fpm test --flag "${{ join(matrix.toolchain.flags, ' ') }}"

.gitignore

@@ -39,4 +39,6 @@
 *~
 
 # test/debug folder
-debug/
+debug/
+*.css
+doc/

README.md

@@ -2,13 +2,13 @@
 
 
 
-|                         **License**                          |                       **Build Status**                       | **Documentation** |
-| :----------------------------------------------------------: | :----------------------------------------------------------: | :---------------: |
-| [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause) | [![Github actions](https://github.com/nekStab/LightKrylov/actions/workflows/gcc.yml/badge.svg?event=push)](https://github.com/nekStab/LightKrylov/actions) | [![Github actions](https://github.com/nekStab/LightKrylov/actions/workflows/docs.yml/badge.svg?event=push)](https://nekstab.github.io/LightKrylov) |
+|                         **License**                          |                       **Build Status**                       |                      **Documentation**                       |
+| :----------------------------------------------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: |
+| [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause) | [![ci](https://github.com/nekStab/LightKrylov/actions/workflows/ci.yml/badge.svg)](https://github.com/nekStab/LightKrylov/actions/workflows/ci.yml) | [![Github actions](https://github.com/nekStab/LightKrylov/actions/workflows/docs.yml/badge.svg?event=push)](https://nekstab.github.io/LightKrylov) |
 
 # LightKrylov
 
-Targeting large-scale linear algebra applications where the matrix $\mathbf{A}$ is only defined implicitly (e.g. through a call to a `matvec` subroutine), this package provides lightweight Fortran implementations of certain of the most useful Krylov methods to solve a variety of problems, among which:
+Targeting large-scale linear algebra applications where the matrix $\mathbf{A}$ is only defined implicitly (e.g. through a call to a `matvec` subroutine), this package provides lightweight Fortran implementations of the most useful Krylov methods to solve a variety of problems, among which:
 
 1. Eigenvalue Decomposition
    $$\mathbf{A} \mathbf{x} = \lambda \mathbf{x}$$
@@ -32,22 +32,17 @@ Krylov methods are *iterative methods*, i.e. they iteratively refine the solutio
 `LightKrylov` leverages Fortran's `abstract type` feature to provide generic implementations of the various Krylov methods.
 The only requirement from the user to benefit from the capabilities of `LightKrylov` is to extend the `abstract_vector` and `abstract_linop` types to define their notion of vectors and linear operators. `LightKrylov` then provides the following functionalities:
 
-- Krylov factorizations : `arnoldi_factorization`, `lanczos_tridiagonalization`, `lanczos_bidiagonalization`.
+- Krylov factorizations : `arnoldi`, `lanczos_tridiagonalization`, `lanczos_bidiagonalization`.
 - Spectral analysis : `eigs`, `eighs`, `svds`.
 - Linear systems : `gmres`, `cg`.
 
-### Known limitations
-
-For the sake of simplicity, `LightKrylov` only works with `real` or `double precision` data. While this might seem restrictive at first, consider that a complex-valued $n \times n$ linear system $\mathbf{Ax} = \mathbf{b}$ can always be rewritten using only real arithmetic as a $2n \times 2n$ real-valued system.
-The primary reason to develop `LightKrylov` is to couple it with high-performance solvers in computational mechanics which often use exclusively real-valued data types. As such, we do not have any plan to natively support complex-valued linear operators or vectors.
-
 ### Examples
 
-Several examples can be found in the `example` folder. These include:
+Some examples can be found in the `example` folder. These include:
 - [Ginzburg-Landau]() : Serial computation of the leading eigenpairs of a complex-valued linear operator via time-stepping.
 - [Laplace operator]() : Parallel computation of the leading eigenpairs of the Laplace operator defined on the unit-square.
 
-Alternatively, you can also look at [`neklab`](), a bifurcation and stability analysis toolbox based on `LightKrylov` and designed to augment the functionalities of the massively parallel spectral element solver [`Nek5000`]().
+Alternatively, you can also look at [`neklab`](https://github.com/nekStab/neklab), a bifurcation and stability analysis toolbox based on `LightKrylov` and designed to augment the functionalities of the massively parallel spectral element solver [`Nek5000`]().
 
 | [**Ginzburg-Landau**]() | [**Laplace operator**]() |
 | :---------------------: | :----------------------: |
@@ -72,12 +67,14 @@ gh repo clone nekStab/LightKrylov
 `LightKrylov` has a very minimal set of dependencies. These only include:
 
 - a Fortran compiler,
-- [LAPACK]() (or similar),
-- [`fpm`](https://github.com/fortran-lang/fpm) or `make` for building the code.
+- [`fpm`](https://github.com/fortran-lang/fpm) for building the code.
 
-And that's all of it. To date, the tested compilers include:
+To date, the tested compilers include:
 
-- `gfortran 12.0.3`
+- `gfortran 12` (Linux)
+- `gfortran 13` (Linux, Windows, MacOS)
+- `ifort` (Linux)
+- `ifx` (Linux)
 
 ### Building with `fpm`
 
@@ -87,13 +84,17 @@ Provided you have cloned the repo, installing `LightKrylov` with `fpm` is as sim
 fpm build --profile release
 ```
 
-### Building with `make`
+To install it and make it accessible for other non-`fpm` related programs, simply run
+
+```
+fpm install --profile release
+```
 
-N/A
+Both of these will make use of the standard compilation options set by the `fpm` team. Please refer to their documentation ([here](https://fpm.fortran-lang.org/)) for more details.
 
 ### Running the tests
 
-To see if the library has been compiled correctly, a set of unit tests are provided in [test](). If you use `fpm`, running these tests is as simple as
+To see if the library has been compiled correctly, a set of unit tests are provided in [test](). Run the following command.
 
 ```
 fpm test

deployment.py

@@ -0,0 +1,43 @@
+import os
+import fypp
+import argparse
+
+
+def apply_command(folder, with_qp, with_xqp, with_hp):
+    # Get a list of all files in the folder
+    # Filter files based on the provided extension
+    lfiles = os.listdir(folder)
+    files = [folder+os.sep+file for file in lfiles if file.endswith(".fypp")]
+
+    args = []
+    if with_qp:
+        args.append("-DWITH_QP=True")
+    if with_xqp:
+        args.append("-DWITH_XQP=True")
+    if with_hp:
+        args.append("-DWITH_HP=True")
+
+    optparser = fypp.get_option_parser()
+    options, leftover = optparser.parse_args(args=args)
+    tool = fypp.Fypp(options)
+    # Apply the command line to each file
+    for file in files:
+        source_file = file
+        target_file = file.removesuffix('fypp')+'f90'
+        tool.process_file(source_file, target_file)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description='Preprocess LightKrylov source files.')
+    # parser.add_argument("--with_qp", action="store_true",
+    #                     help="Include WITH_QP in the command")
+    # parser.add_argument("--with_xqp", action="store_true",
+    #                     help="Include WITH_XQP in the command")
+    # parser.add_argument("--with_hp", action="store_true",
+    #                     help="Include WITH_HP in the command")
+
+    args = parser.parse_args()
+    # apply_command(args.with_qp, args.with_xqp, args.with_hp)
+    apply_command("./src/", False, False, False)
+    apply_command("./test/", False, False, False)