polybench 0.2.0__tar.gz → 0.3.0__tar.gz

{polybench-0.2.0 → polybench-0.3.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2021 Takahiro Ueda
+Copyright (c) 2020-2024 Takahiro Ueda
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

polybench-0.3.0/PKG-INFO

@@ -0,0 +1,210 @@
+Metadata-Version: 2.1
+Name: polybench
+Version: 0.3.0
+Summary: Multivariate polynomial arithmetic benchmark tests.
+Home-page: https://github.com/tueda/polybench
+License: MIT
+Keywords: benchmark,mathematics,multivariate-polynomials
+Author: Takahiro Ueda
+Author-email: t.ueda.od@juntendo.ac.jp
+Requires-Python: >=3.6.1,<4.0.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: System :: Benchmark
+Requires-Dist: colorama (>=0.4.5,<0.5.0)
+Requires-Dist: colorlog (>=6.8.2,<7.0.0)
+Requires-Dist: importlib-metadata (>=4.8.3,<5.0.0)
+Requires-Dist: importlib-resources (>=5.4.0,<6.0.0)
+Requires-Dist: kiwisolver (>=1.3.1,<1.4.0) ; python_full_version >= "3.6.1" and python_full_version < "3.7.0"
+Requires-Dist: kiwisolver (>=1.4.5,<2.0.0) ; python_version >= "3.7" and python_version < "3.13"
+Requires-Dist: matplotlib (>=3.3.4,<3.4.0) ; python_full_version >= "3.6.1" and python_full_version < "3.7.0"
+Requires-Dist: matplotlib (>=3.5.3,<3.6.0) ; python_version >= "3.7" and python_version < "3.11"
+Requires-Dist: matplotlib (>=3.9.0,<4.0.0) ; python_version >= "3.11" and python_version < "3.13"
+Requires-Dist: numpy (>=1.19.5,<1.20.0) ; python_full_version >= "3.6.1" and python_full_version < "3.7.0"
+Requires-Dist: numpy (>=1.21.6,<1.22.0) ; python_version >= "3.7" and python_version < "3.11"
+Requires-Dist: numpy (>=2.0.0,<3.0.0) ; python_version >= "3.11" and python_version < "3.13"
+Requires-Dist: pandas (>=1.1.5,<1.2.0) ; python_full_version >= "3.6.1" and python_full_version < "3.7.1"
+Requires-Dist: pandas (>=1.3.5,<1.4.0) ; python_full_version >= "3.7.1" and python_version < "3.11"
+Requires-Dist: pandas (>=2.2.2,<3.0.0) ; python_version >= "3.11" and python_version < "3.13"
+Requires-Dist: pretty-errors (>=1.2.25,<2.0.0)
+Requires-Dist: psutil (>=6.0.0,<7.0.0)
+Requires-Dist: py-cpuinfo (>=9.0.0,<10.0.0)
+Requires-Dist: symengine (>=0.10.0,<0.11.0) ; python_version >= "3.7" and python_version < "3.8"
+Requires-Dist: symengine (>=0.11.0,<0.12.0) ; python_version >= "3.8" and python_version < "3.13"
+Requires-Dist: symengine (>=0.8.1,<0.9.0) ; python_full_version >= "3.6.1" and python_full_version < "3.7.0"
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: typing-extensions (>=4.1.1,<5.0.0)
+Project-URL: Repository, https://github.com/tueda/polybench
+Description-Content-Type: text/markdown
+
+polybench
+=========
+
+[![Test](https://github.com/tueda/polybench/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/tueda/polybench/actions?query=branch:master)
+[![PyPI version](https://badge.fury.io/py/polybench.svg)](https://pypi.org/project/polybench/)
+
+Multivariate polynomial arithmetic benchmark tests.
+
+Many scientific and engineering applications utilise multivariate polynomial
+arithmetic in their algorithms and solutions. Here we provide a set of
+benchmark tests for often-used operations in multivariate polynomial
+arithmetic:
+
+- Greatest common divisor
+- Factorisation
+
+
+Requirements
+------------
+
+- [Python](https://www.python.org/) >= 3.6.1
+
+You also need at least one or more tools to be benchmarked.
+They are (in alphabetical order):
+
+- [Fermat](https://home.bway.net/lewis/)
+- [FLINT](https://flintlib.org/): automatically downloaded via [vcpkg](https://vcpkg.io/)
+  (requires [CMake](https://cmake.org/) >= 3.15, a C compiler and the Make utility).
+- [FORM](https://www.nikhef.nl/~form/):
+  if not available in the system, then
+  a [release binary](https://github.com/vermaseren/form/releases)
+  will be automatically downloaded.
+- [Mathematica](https://www.wolfram.com/mathematica/):
+  indeed, [Free Wolfram Engine for Developers](https://www.wolfram.com/engine/) is sufficient to run.
+- [reFORM](https://reform.readthedocs.io/en/latest/):
+  automatically downloaded
+  (requires [Rust](https://www.rust-lang.org/) >= 1.36).
+- [Rings](https://rings.readthedocs.io/en/latest/):
+  automatically downloaded
+  (requires [JDK](https://www.oracle.com/technetwork/java/) >= 8).
+- [Singular](https://www.singular.uni-kl.de/)
+- [Symbolica](https://symbolica.io/):
+  automatically downloaded
+  (requires [Rust](https://www.rust-lang.org/) >= 1.73),
+  running in [restricted mode](https://symbolica.io/docs/get_started.html#license).
+
+
+Getting started
+---------------
+
+Clone this repository and try to run the `run.sh` script:
+
+```sh
+git clone https://github.com/tueda/polybench.git
+cd polybench
+./run.sh --all
+```
+
+When starting the script for the first time, it automatically sets up
+a virtual environment for required Python packages so that it will not dirty
+your environment. Some of the tools are provided as libraries registered in
+public package registries, so the first run takes some time to download,
+compile and link them with test binaries. After testing, a CSV file and
+comparison plots will be generated.
+
+For practical benchmarking, configuration parameters should be set
+adequately. See the help message shown by
+
+```sh
+./run.sh --help
+```
+
+You can also use [pip](https://pip.pypa.io/en/stable/),
+[pipx](https://pipxproject.github.io/pipx/),
+[Poetry](https://python-poetry.org/)
+or [Docker](https://www.docker.com/) with this repository.
+Installation with `pip(x) install` or `poetry install` makes a command
+`polybench` available, which acts as the `run.sh` script described above.
+```sh
+pip install polybench
+polybench --all
+python -m polybench --all  # alternative way to launch
+```
+```sh
+pipx install polybench
+polybench --all
+```
+```sh
+git clone https://github.com/tueda/polybench.git
+cd polybench
+poetry install
+poetry run polybench --all
+```
+```sh
+docker build -t polybench:latest https://github.com/tueda/polybench.git
+docker run -it --rm polybench:latest
+./run.sh --all
+```
+
+
+Example
+-------
+
+|                |                                                                              |
+|----------------|------------------------------------------------------------------------------|
+| platform       | Linux-5.15.0-84-generic-x86_64-with-glibc2.29                                |
+| python_version | 3.8.10.final.0 (64 bit)                                                      |
+| cpu_brand      | 12th Gen Intel(R) Core(TM) i9-12900                                          |
+| cpu_count      | 16 (logical: 24)                                                             |
+| total_memory   | 62.6GB                                                                       |
+| FLINT          | flint 2.9.0, cc (GNU) 10.5.0                                                 |
+| FORM           | FORM 4.3.1 (Apr 11 2023, v4.3.1) 64-bits                                     |
+| Mathematica    | 14.1.0 for Linux x86 (64-bit) (July 22, 2024)                                |
+| reFORM         | 0.1.0-fix-serialize, rustc 1.81.0 (eeb90cda1 2024-09-04)                     |
+| Rings          | 2.5.8, JVM: 11.0.20.1 (Ubuntu 11.0.20.1+1-post-Ubuntu-0ubuntu120.04)         |
+| Singular       | Singular for x86_64-Linux version 4.4.0 (44002, 64 bit) May 29 2024 14:14:10 |
+| Symbolica      | 0.11.0, rustc 1.81.0 (eeb90cda1 2024-09-04)                                  |
+
+![nontrivial-gcd](https://raw.githubusercontent.com/tueda/polybench-result/refs/heads/main/0.3.0/05/0002.figures/summary.png)
+
+![nontrivial-factor](https://raw.githubusercontent.com/tueda/polybench-result/refs/heads/main/0.3.0/05/0004.figures/summary.png)
+
+Additional benchmark results are available [here](https://github.com/tueda/polybench-result/tree/main).
+
+
+Development
+-----------
+
+```bash
+# Initialisation
+poetry install
+pre-commit install
+
+# Linting and testing
+pre-commit run --all-files
+poetry run pytest
+
+# Linting and testing for Cargo subproject
+cd path/to/project
+cargo fmt
+cargo clippy
+cargo test
+
+# Linting and testing for Gradle subproject
+cd path/to/project
+./gradlew spotlessApply
+./gradlew check
+
+# Test run
+./run.sh <options>  # for example, --all
+
+# Release a new version
+./scripts/make-release.sh <new_version>  # for example, 0.3.0rc1
+```
+
+
+License
+-------
+
+[MIT](https://github.com/tueda/polybench/blob/master/LICENSE)
+

{polybench-0.2.0 → polybench-0.3.0}/README.md

@@ -1,9 +1,8 @@
 polybench
 =========
 
-[![Test](https://github.com/tueda/polybench/workflows/Test/badge.svg?branch=master)](https://github.com/tueda/polybench/actions?query=branch:master)
+[![Test](https://github.com/tueda/polybench/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/tueda/polybench/actions?query=branch:master)
 [![PyPI version](https://badge.fury.io/py/polybench.svg)](https://pypi.org/project/polybench/)
-[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/tueda/polybench.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/tueda/polybench/context:python)
 
 Multivariate polynomial arithmetic benchmark tests.
 
@@ -25,6 +24,8 @@ You also need at least one or more tools to be benchmarked.
 They are (in alphabetical order):
 
 - [Fermat](https://home.bway.net/lewis/)
+- [FLINT](https://flintlib.org/): automatically downloaded via [vcpkg](https://vcpkg.io/)
+  (requires [CMake](https://cmake.org/) >= 3.15, a C compiler and the Make utility).
 - [FORM](https://www.nikhef.nl/~form/):
   if not available in the system, then
   a [release binary](https://github.com/vermaseren/form/releases)
@@ -34,10 +35,14 @@ They are (in alphabetical order):
 - [reFORM](https://reform.readthedocs.io/en/latest/):
   automatically downloaded
   (requires [Rust](https://www.rust-lang.org/) >= 1.36).
-- [Rings](https://ringsalgebra.io/):
+- [Rings](https://rings.readthedocs.io/en/latest/):
   automatically downloaded
   (requires [JDK](https://www.oracle.com/technetwork/java/) >= 8).
 - [Singular](https://www.singular.uni-kl.de/)
+- [Symbolica](https://symbolica.io/):
+  automatically downloaded
+  (requires [Rust](https://www.rust-lang.org/) >= 1.73),
+  running in [restricted mode](https://symbolica.io/docs/get_started.html#license).
 
 
 Getting started
@@ -96,25 +101,57 @@ docker run -it --rm polybench:latest
 Example
 -------
 
-|                |                                                                 |
-|----------------|-----------------------------------------------------------------|
-| platform       | Linux-3.10.0-957.21.3.el7.x86_64-x86_64-with-glibc2.23          |
-| python_version | 3.9.9.final.0 (64 bit)                                          |
-| cpu_brand      | Intel(R) Xeon(R) Gold 6248 CPU @ 2.50GHz                        |
-| cpu_count      | 40                                                              |
-| total_memory   | 754.6GB                                                         |
-| FORM           | FORM 4.2.1 (Nov 21 2018, v4.2.1) 64-bits                        |
-| Mathematica    | 13.0.0 for Linux x86 (64-bit) (December 10, 2021)               |
-| reFORM         | 0.1.0-fix-serialize, rustc 1.56.1                               |
-| Rings          | 2.5.8, JVM: 17.0.1 (Homebrew 17.0.1+1)                          |
-| Singular       | Singular for x86_64-Linux version 4.2.1 (4210, 64 bit) May 2021 |
-
-![nontrivial-gcd](https://github.com/tueda/polybench-result/raw/b31989da7eef19faf127bac177ad8d89a7e51e2c/0.2.0/0002.figures/summary.png)
-
-![nontrivial-gcd](https://github.com/tueda/polybench-result/raw/b31989da7eef19faf127bac177ad8d89a7e51e2c/0.2.0/0004.figures/summary.png)
-
-ReFORM has no factorization functionality.
-Mathematica exceeded the timeout of 60 minutes for the "nontrivial-factor" test.
+|                |                                                                              |
+|----------------|------------------------------------------------------------------------------|
+| platform       | Linux-5.15.0-84-generic-x86_64-with-glibc2.29                                |
+| python_version | 3.8.10.final.0 (64 bit)                                                      |
+| cpu_brand      | 12th Gen Intel(R) Core(TM) i9-12900                                          |
+| cpu_count      | 16 (logical: 24)                                                             |
+| total_memory   | 62.6GB                                                                       |
+| FLINT          | flint 2.9.0, cc (GNU) 10.5.0                                                 |
+| FORM           | FORM 4.3.1 (Apr 11 2023, v4.3.1) 64-bits                                     |
+| Mathematica    | 14.1.0 for Linux x86 (64-bit) (July 22, 2024)                                |
+| reFORM         | 0.1.0-fix-serialize, rustc 1.81.0 (eeb90cda1 2024-09-04)                     |
+| Rings          | 2.5.8, JVM: 11.0.20.1 (Ubuntu 11.0.20.1+1-post-Ubuntu-0ubuntu120.04)         |
+| Singular       | Singular for x86_64-Linux version 4.4.0 (44002, 64 bit) May 29 2024 14:14:10 |
+| Symbolica      | 0.11.0, rustc 1.81.0 (eeb90cda1 2024-09-04)                                  |
+
+![nontrivial-gcd](https://raw.githubusercontent.com/tueda/polybench-result/refs/heads/main/0.3.0/05/0002.figures/summary.png)
+
+![nontrivial-factor](https://raw.githubusercontent.com/tueda/polybench-result/refs/heads/main/0.3.0/05/0004.figures/summary.png)
+
+Additional benchmark results are available [here](https://github.com/tueda/polybench-result/tree/main).
+
+
+Development
+-----------
+
+```bash
+# Initialisation
+poetry install
+pre-commit install
+
+# Linting and testing
+pre-commit run --all-files
+poetry run pytest
+
+# Linting and testing for Cargo subproject
+cd path/to/project
+cargo fmt
+cargo clippy
+cargo test
+
+# Linting and testing for Gradle subproject
+cd path/to/project
+./gradlew spotlessApply
+./gradlew check
+
+# Test run
+./run.sh <options>  # for example, --all
+
+# Release a new version
+./scripts/make-release.sh <new_version>  # for example, 0.3.0rc1
+```
 
 
 License

{polybench-0.2.0 → polybench-0.3.0}/polybench/main.py

@@ -12,7 +12,7 @@ import sys
 import time
 from collections import OrderedDict
 from pathlib import Path
-from typing import Any, Callable, List, Optional, Sequence, Set, Tuple, cast
+from typing import Any, Callable, List, NamedTuple, Optional, Sequence, Set, cast
 
 import colorama
 import cpuinfo
@@ -110,6 +110,14 @@ def prepare_solvers(
     return tuple(available_solvers)
 
 
+class SolverResult(NamedTuple):
+    """Result from a solver."""
+
+    name: str
+    res: Sequence[Result]
+    output_dir: Path
+
+
 def run_solvers(
     solvers: Sequence[Solver],
     problems: ProblemSet,
@@ -140,14 +148,15 @@ def run_solvers(
         if len(times) == 1:
             return f" ({times[0]:.3f} sec)"
         mean = statistics.mean(times)
-        stdev = statistics.stdev(times)
+        stdev = statistics.stdev(times, mean)
         max_t, max_i = max((t, i) for i, t in enumerate(times))
         return (
-            f" (average: {mean:.3f} +- {stdev:.3f} sec,"
-            f" slowest: {max_t:.3f} sec on {max_i + 1 + n_warmups})"
+            f" (mean: {mean:.3f} sec,"
+            f" SD: {stdev:.3f} sec,"
+            f" slowest: {max_t:.3f} sec on Prob. {max_i + 1 + n_warmups})"
         )
 
-    results: List[Tuple[str, Sequence[Result], Path]] = []
+    results: List[SolverResult] = []
 
     for s in solvers:
         s._problem_file = problem_file  # Yes, this is ugly.
@@ -155,40 +164,87 @@ def run_solvers(
         r = s.solve(problems)
         t2 = time.time()
         if r and len(r) == len(problems):
-            results.append((s.name, r, s._output_dir))
+            results.append(SolverResult(s.name, r, s._output_dir))
             s.logger.info(
                 f"{t2 - t1:.3f} sec{get_timing_information(r, problems.n_warmups)}"
             )
         else:
             s.logger.error("failed")
 
-    # Check the consistency.
+    # Check the consistency of the obtained results.
 
     check_logger = logger.getChild("Check")
 
     wrong: Set[str] = set()
 
+    def count_factors(pp: Sequence[Polynomial]) -> int:
+        n = 0
+        m = 0
+        for p in pp:
+            n_terms = len(p)
+            if n_terms == 0:
+                return 0
+            elif n_terms == 1:
+                if not p.is_unit:
+                    m += 1
+            else:
+                n += 1
+        if m >= 1:
+            n += 1
+        return n
+
     if problems.problem_type == "gcd":
+        # The GCD must be given as a single polynomial.
+        for name, res, _ in results:
+            for i, ri in enumerate(res):
+                if len(ri.answer) != 1:
+                    check_logger.error(f"{name}:{i + 1}: wrong answer")
+                    wrong.add(name)
+        # The GCD must be the same up to a multiplicative unit.
         if len(results) >= 2:
             for i in range(len(problems)):
-                p0 = results[0][1][i].answer[0]
+                pp0 = results[0].res[i].answer
+                if len(pp0) != 1:
+                    continue
+                p0 = pp0[0]
                 for j in range(1, len(results)):
-                    pj = results[j][1][i].answer[0]
+                    ppj = results[j].res[i].answer
+                    if len(ppj) != 1:
+                        continue
+                    pj = ppj[0]
                     if not p0.equals_without_unit(pj):
-                        name0 = results[0][0]
-                        namej = results[j][0]
+                        name0 = results[0].name
+                        namej = results[j].name
                         check_logger.error(
                             f"{name0}:{namej}:{i + 1}: inconsistent answers"
                         )
                         wrong.add(name0)
                         wrong.add(namej)
     elif problems.problem_type == "factor":
+        # The product of the factorized polynomials must equal the original polynomial.
         for name, res, _ in results:
             for i, ri in enumerate(res):
                 product = functools.reduce(operator.mul, ri.answer, Polynomial(1))
                 if problems[i].p != product:
                     check_logger.error(f"{name}:{i + 1}: wrong answer")
                     wrong.add(name)
+        # The number of factorized polynomials must match,
+        # excluding any single-term polynomials.
+        if len(results) >= 2:
+            for i in range(len(problems)):
+                pp0 = results[0].res[i].answer
+                n0 = count_factors(pp0)
+                for j in range(1, len(results)):
+                    ppj = results[j].res[i].answer
+                    nj = count_factors(ppj)
+                    if n0 != nj:
+                        name0 = results[0].name
+                        namej = results[j].name
+                        check_logger.error(
+                            f"{name0}:{namej}:{i + 1}: inconsistent answers"
+                        )
+                        wrong.add(name0)
+                        wrong.add(namej)
 
     # Remove the solver's output directory only if succeeded.
 
@@ -316,7 +372,7 @@ def main(
     )
     parser.add_argument(
         "--max-coeff",
-        default=2 ** 14,
+        default=2**14,
         type=int,
         help="set the maximum coefficient (default: 2^14)",
         metavar="N",
@@ -502,6 +558,7 @@ def main(
 
     if debug:
         logger.setLevel(logging.DEBUG)
+        Solver.debug = True
     else:
         logger.setLevel(logging.INFO)
 

{polybench-0.2.0 → polybench-0.3.0}/polybench/plot.py

@@ -1,4 +1,4 @@
-"""Routines for making comaprsion plots."""
+"""Routines for making comparison plots."""
 
 import itertools
 from pathlib import Path

{polybench-0.2.0 → polybench-0.3.0}/polybench/poly.py

@@ -13,7 +13,7 @@ class Polynomial:
     def __init__(self, expr: Union[str, int, "Polynomial"] = 0) -> None:
         """Construct a polynomial."""
         if isinstance(expr, str):
-            p = symengine.sympify(expr.lstrip("+"))  # symengine/symengine.py#331
+            p = symengine.sympify(expr)
             self._raw = symengine.expand(p)
         elif isinstance(expr, int):
             self._raw = symengine.sympify(expr)
@@ -28,7 +28,17 @@ class Polynomial:
 
     def __bool__(self) -> bool:
         """Return ``bool(self)``."""
-        return self._raw != 0  # type: ignore
+        return not self._raw.is_zero
+
+    def __len__(self) -> int:
+        """Return the number of terms in the polynomial."""
+        raw = self._raw
+        if raw.is_Add:
+            return len(raw.args)
+        elif raw.is_zero:
+            return 0
+        else:
+            return 1
 
     def __eq__(self, other: object) -> bool:
         """Return ``self == other``."""
@@ -46,26 +56,31 @@ class Polynomial:
         """Return ``- self``."""
         result = super().__new__(Polynomial)
         result._raw = symengine.expand(-self._raw)
-        return result  # type: ignore
+        return result
 
     def __add__(self, other: "Polynomial") -> "Polynomial":
         """Return ``self + other``."""
         result = super().__new__(Polynomial)
         result._raw = symengine.expand(self._raw + other._raw)
-        return result  # type: ignore
+        return result
 
     def __sub__(self, other: "Polynomial") -> "Polynomial":
         """Return ``self - other``."""
         result = super().__new__(Polynomial)
         result._raw = symengine.expand(self._raw - other._raw)
-        return result  # type: ignore
+        return result
 
     def __mul__(self, other: "Polynomial") -> "Polynomial":
         """Return ``self * other``."""
         result = super().__new__(Polynomial)
         result._raw = symengine.expand(self._raw * other._raw)
-        return result  # type: ignore
+        return result
 
     def equals_without_unit(self, other: "Polynomial") -> bool:
         """Return `True` if ``self == other`` up to a unit."""
         return self == other or self == -other
+
+    @property
+    def is_unit(self) -> bool:
+        """True if the polynomial is 1 or -1."""
+        return len(self) == 1 and (self == 1 or self == -1)

{polybench-0.2.0 → polybench-0.3.0}/polybench/solver.py

@@ -30,6 +30,8 @@ class Result(NamedTuple):
 class Solver:
     """Abstract solver."""
 
+    debug = False
+
     # Things that must be overridden in subclasses.
 
     _name = "None"  # Must be a unique name (without spaces).
@@ -44,8 +46,8 @@ class Solver:
 
     def _solve(self, problems: ProblemSet) -> Optional[Sequence[Result]]:
         # Solve the given problems and return the results. If the underlying executable
-        # has a programming langauge that is versatile enough, then the easiest way is
-        # to generate a program in the langauge that creates a CSV file for the results
+        # has a programming language that is versatile enough, then the easiest way is
+        # to generate a program in the language that creates a CSV file for the results
         # and use `parse_csv_log` (example: `MathematicaSolver`). When this method is
         # called, the current working directory is set to `output_dir` and
         # `problem_file` is accessible. One can also use files in `build_dir`.
@@ -170,11 +172,16 @@ class Solver:
             new_args = [str(args)]
 
         try:
+            if self.debug:
+                redirect = None
+            else:
+                redirect = subprocess.DEVNULL
+
             p = subprocess.run(  # noqa: S603
                 new_args,
                 input=input,
-                stdout=subprocess.PIPE if capture_output else subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
+                stdout=subprocess.PIPE if capture_output else redirect,
+                stderr=redirect,
                 universal_newlines=True,
                 timeout=timeout,
             )
@@ -297,6 +304,11 @@ class Solver:
                     dest_dir.mkdir(parents=True, exist_ok=True)
                     shutil.copy2(p, q)
 
+    @property
+    def cmake_command(self) -> Sequence[str]:
+        """Return the CMake command."""
+        return [shutil.which("cmake") or "cmake"]
+
     @property
     def gradlew_command(self) -> Sequence[str]:
         """Return the gradlew command."""

{polybench-0.2.0 → polybench-0.3.0}/polybench/solvers/__init__.py

@@ -6,5 +6,7 @@ from pkgutil import iter_modules
 
 # Load all modules.
 
-for (_, module_name, _) in iter_modules([str(Path(__file__).resolve().parent)]):
+for _, module_name, _ in iter_modules(  # type: ignore[assignment]
+    [str(Path(__file__).resolve().parent)]
+):
     import_module(f"{__name__}.{module_name}")

polybench-0.3.0/polybench/solvers/flint/CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.15)
+include(cmake/init-vcpkg.cmake)
+project(
+  polybench-flint
+  VERSION 0.1.0
+  LANGUAGES C)
+
+get_filename_component(COMPILER_NAME ${CMAKE_C_COMPILER} NAME_WE)
+set(COMPILER_VERSION
+    "${COMPILER_NAME} (${CMAKE_C_COMPILER_ID}) ${CMAKE_C_COMPILER_VERSION}")
+
+configure_file(${CMAKE_SOURCE_DIR}/version.h.in ${CMAKE_BINARY_DIR}/version.h
+               @ONLY)
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(gmp REQUIRED IMPORTED_TARGET gmp)
+pkg_check_modules(mpfr REQUIRED IMPORTED_TARGET mpfr)
+
+find_path(FLINT_INCLUDE_DIR flint/flint.h)
+find_library(FLINT_LIBRARY flint)
+
+add_executable(polybench-flint main.c)
+
+target_include_directories(polybench-flint PRIVATE ${FLINT_INCLUDE_DIR}
+                                                   ${CMAKE_BINARY_DIR})
+target_link_libraries(polybench-flint PRIVATE m PkgConfig::gmp PkgConfig::mpfr
+                                              ${FLINT_LIBRARY})