tensorstudio 1.0.0rc2__tar.gz → 1.0.1__tar.gz

{tensorstudio-1.0.0rc2 → tensorstudio-1.0.1}/.github/workflows/ci.yml

@@ -30,6 +30,10 @@ jobs:
         run: mypy --python-version ${{ matrix.python-version }} python/tensorstudio
       - name: Tests
         run: pytest -q
+      - name: Runner scripts
+        run: |
+          python test_all.py --help
+          python benchmark_all.py --help
       - name: Example
         run: python examples/basic_tensor_ops.py
 
@@ -59,6 +63,10 @@ jobs:
         run: mypy --python-version ${{ matrix.python-version }} python/tensorstudio
       - name: Tests
         run: pytest -q
+      - name: Runner scripts
+        run: |
+          python test_all.py --help
+          python benchmark_all.py --help
       - name: Example
         run: python examples/basic_tensor_ops.py
 
@@ -88,5 +96,9 @@ jobs:
         run: mypy --python-version ${{ matrix.python-version }} python/tensorstudio
       - name: Tests
         run: pytest -q
+      - name: Runner scripts
+        run: |
+          python test_all.py --help
+          python benchmark_all.py --help
       - name: Example
         run: python examples/basic_tensor_ops.py

{tensorstudio-1.0.0rc2 → tensorstudio-1.0.1}/.github/workflows/publish-testpypi.yml

@@ -106,3 +106,4 @@ jobs:
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           repository-url: https://test.pypi.org/legacy/
+          skip-existing: true

{tensorstudio-1.0.0rc2 → tensorstudio-1.0.1}/.github/workflows/publish.yml

@@ -6,7 +6,7 @@ on:
     types: [published]
   push:
     tags:
-      - "v1.0.0"
+      - "v*"
 
 permissions:
   contents: read
@@ -103,5 +103,11 @@ jobs:
           pattern: dist-*
           path: dist
           merge-multiple: true
+      - name: Verify artifacts
+        run: |
+          python -m pip install -U twine
+          python -m twine check dist/*
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true

{tensorstudio-1.0.0rc2 → tensorstudio-1.0.1}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 1.0.1
+
+- Added `test_all.py` for one-command local release checks covering lint,
+  typing, tests, examples, docs, build, and package metadata validation.
+- Added `benchmark_all.py` for one-command full benchmark report generation.
+- Added explicit benchmark win columns for NumPy, TensorFlow, PyTorch, and JAX,
+  plus fastest-library reporting for each benchmark case.
+- Hardened release publishing triggers so future `v*` tags are eligible for
+  the publish workflow instead of only `v1.0.0`.
+- Updated docs to describe benchmark interpretation, local release checks, and
+  site navigation for benchmark, hardware, roadmap, and usage pages.
+
+## 1.0.0
+
+- Promoted the CPU-only stable API foundation from release candidate status.
+- Added direct C++ buffer copies for NumPy import/export paths.
+- Added faster typed tensor construction, flat-vector export, contiguous tensor
+  copy, and floating-point optimizer update paths.
+- Added a `float32` contiguous matmul fast path that avoids double accumulation
+  and per-element dtype conversion for the common training dtype.
+- Added typed contiguous reduction kernels for `sum` and `mean`.
+- Expanded benchmark reports with framework version metadata and PyTorch
+  win/loss summaries.
+- Updated documentation to describe honest `1.0.0` performance boundaries.
+
 ## 1.0.0rc2
 
 - Added `*_like` tensor creation helpers for zero, one, full, empty, uniform

{tensorstudio-1.0.0rc2 → tensorstudio-1.0.1}/CMakeLists.txt

@@ -1,7 +1,9 @@
 cmake_minimum_required(VERSION 3.18)
 
-project(tensorstudio VERSION 1.0.0 LANGUAGES CXX)
+project(tensorstudio VERSION 1.0.1 LANGUAGES CXX)
 
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+set(PYBIND11_FINDPYTHON ON)
 find_package(pybind11 CONFIG REQUIRED)
 
 set(TENSORSTUDIO_CORE_SOURCES

{tensorstudio-1.0.0rc2 → tensorstudio-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tensorstudio
-Version: 1.0.0rc2
+Version: 1.0.1
 Summary: TensorStudio is a compact C++ tensor and autograd engine with a Python API for learning, experimentation, and lightweight ML workloads.
 Keywords: tensor,autograd,machine-learning,cpp,pybind11
 Author: TensorStudio contributors
@@ -65,14 +65,12 @@ Description-Content-Type: text/markdown
 TensorStudio is a compact C++ tensor and autograd engine with a Python API for
 learning, experimentation, and lightweight ML workloads.
 
-TensorStudio `1.0.0rc2` is a release candidate for a CPU-only stable API
-foundation. It is eager-only, intentionally small, and not a replacement for
-mature ML frameworks. The final `1.0.0` version should only be tagged after the
-Windows, Linux, and macOS release checklist passes.
+TensorStudio `1.0.1` is a CPU-only stable API foundation. It is eager-only,
+intentionally small, and not a replacement for mature ML frameworks.
 
 ## Install
 
-From PyPI, once release-candidate wheels are published:
+From PyPI:
 
 ```bash
 python -m pip install tensorstudio
@@ -219,8 +217,8 @@ for features, targets in loader:
     print(features.shape, targets.shape)
 ```
 
-The v1 release candidate DataLoader is intentionally single-process so it works
-cleanly on Windows without multiprocessing setup.
+The v1 DataLoader is intentionally single-process so it works cleanly on
+Windows without multiprocessing setup.
 
 ## Performance
 
@@ -229,34 +227,38 @@ performance is still experimental. Benchmarks live in `benchmarks/` and can be
 run locally:
 
 ```bash
+python benchmark_all.py
 python benchmarks/benchmark_report.py
 ```
 
-On one Windows CPython 3.10 run for `1.0.0rc2`, TensorStudio beat NumPy on 11
-small activation/reduction benchmark cases and lost on 78 NumPy-comparable
-cases. The strongest local wins were small `sigmoid`, `sum`, and `mean` cases;
-medium elementwise operations and matrix multiplication remain slower than
-NumPy. The C++ contiguous matmul fast path is much faster than the original
-naive storage-access loop, but it is not a BLAS replacement. See
-`benchmarks/results.md` for the full table, platform details, and exact timings.
+`benchmark_all.py` writes `benchmarks/results.md` and includes explicit win
+columns for NumPy, TensorFlow, PyTorch, and JAX when those libraries are
+available locally.
+
+On one Windows CPython 3.10 run for `1.0.1`, TensorStudio beat NumPy on 13
+small activation/reduction benchmark cases and lost on 76 NumPy-comparable
+cases. Against PyTorch CPU `2.12.1+cpu`, TensorStudio won 71 local cases and
+lost 23. The strongest local wins were small eager operations where framework
+dispatch overhead dominates; larger matrix multiplication, larger transcendental
+activations, and larger autograd workloads remain faster in PyTorch and NumPy.
+See `benchmarks/results.md` for the full table, platform details, and exact
+timings.
 
 Snapshot from that local run:
 
-| operation | shape | TensorStudio median | NumPy median | speedup | result |
-|---|---:|---:|---:|---:|---|
-| `sigmoid` | `(1,)` | 0.0016 ms | 0.0036 ms | 2.2170x | win |
-| `mean` | `(1,)` | 0.0014 ms | 0.0081 ms | 5.8562x | win |
-| `mean` | `(8,)` | 0.0016 ms | 0.0079 ms | 5.0005x | win |
-| `add` | `(16384,)` | 0.0100 ms | 0.0037 ms | 0.3682x | loss |
-| `matmul` | `(256, 256)` | 4.1393 ms | 0.4222 ms | 0.1020x | loss |
+| operation | shape | TensorStudio | NumPy | PyTorch CPU | TS vs NumPy | TS vs PyTorch |
+|---|---:|---:|---:|---:|---:|---:|
+| `sigmoid` | `(32,)` | 0.0018 ms | 0.0036 ms | 0.0575 ms | 2.0414x | 32.2110x |
+| `mean` | `(32,)` | 0.0016 ms | 0.0069 ms | 0.0112 ms | 4.4051x | 7.1262x |
+| `chain_relu` | `(128,)` | 0.0086 ms | 0.0039 ms | 0.0567 ms | 0.4488x | 6.5977x |
+| `matmul` | `(256, 256)` | 2.4215 ms | 0.4027 ms | 0.0832 ms | 0.1663x | 0.0343x |
+| `elementwise_backward` | `(1024,)` | 2.3527 ms | n/a | 0.1887 ms | n/a | 0.0802x |
 
-Speedup is `NumPy median / TensorStudio median`, so values above `1.0x` favor
-TensorStudio. The matmul result is from the optimized C++ contiguous path; a
-pre-optimization run was about 259 ms for the same `(256, 256)` case on this
-machine.
+Speedup is `competitor median / TensorStudio median`, so values above `1.0x`
+favor TensorStudio.
 
-Do not treat these results as universal. TensorStudio does not currently claim
-to be faster than NumPy, TensorFlow, PyTorch, or JAX overall.
+Do not treat these results as universal. TensorStudio does not claim to be
+faster than NumPy, TensorFlow, PyTorch, or JAX overall.
 
 ## Save And Load
 
@@ -276,6 +278,7 @@ unsafe because pickle can execute arbitrary code.
 
 ```bash
 python -m pip install -e ".[dev,docs]"
+python test_all.py --skip-build
 ruff check .
 mypy python/tensorstudio
 pytest -q
@@ -288,6 +291,7 @@ scikit-build-core, and C++20.
 
 ## Release Checklist
 
+- `python test_all.py` passes locally.
 - `ruff check .` passes.
 - `mypy python/tensorstudio` passes.
 - `pytest -q` passes on Windows, Linux, and macOS.
@@ -312,6 +316,7 @@ tokens or print secrets.
 - CPU backend only.
 - Eager execution only.
 - No CUDA or Metal backend yet.
+- No BLAS-backed matrix multiplication yet.
 - No graph compiler or distributed runtime.
 - No convolution layers yet.
 - No sparse tensors or advanced indexing.

{tensorstudio-1.0.0rc2 → tensorstudio-1.0.1}/README.md

@@ -7,14 +7,12 @@
 TensorStudio is a compact C++ tensor and autograd engine with a Python API for
 learning, experimentation, and lightweight ML workloads.
 
-TensorStudio `1.0.0rc2` is a release candidate for a CPU-only stable API
-foundation. It is eager-only, intentionally small, and not a replacement for
-mature ML frameworks. The final `1.0.0` version should only be tagged after the
-Windows, Linux, and macOS release checklist passes.
+TensorStudio `1.0.1` is a CPU-only stable API foundation. It is eager-only,
+intentionally small, and not a replacement for mature ML frameworks.
 
 ## Install
 
-From PyPI, once release-candidate wheels are published:
+From PyPI:
 
 ```bash
 python -m pip install tensorstudio
@@ -161,8 +159,8 @@ for features, targets in loader:
     print(features.shape, targets.shape)
 ```
 
-The v1 release candidate DataLoader is intentionally single-process so it works
-cleanly on Windows without multiprocessing setup.
+The v1 DataLoader is intentionally single-process so it works cleanly on
+Windows without multiprocessing setup.
 
 ## Performance
 
@@ -171,34 +169,38 @@ performance is still experimental. Benchmarks live in `benchmarks/` and can be
 run locally:
 
 ```bash
+python benchmark_all.py
 python benchmarks/benchmark_report.py
 ```
 
-On one Windows CPython 3.10 run for `1.0.0rc2`, TensorStudio beat NumPy on 11
-small activation/reduction benchmark cases and lost on 78 NumPy-comparable
-cases. The strongest local wins were small `sigmoid`, `sum`, and `mean` cases;
-medium elementwise operations and matrix multiplication remain slower than
-NumPy. The C++ contiguous matmul fast path is much faster than the original
-naive storage-access loop, but it is not a BLAS replacement. See
-`benchmarks/results.md` for the full table, platform details, and exact timings.
+`benchmark_all.py` writes `benchmarks/results.md` and includes explicit win
+columns for NumPy, TensorFlow, PyTorch, and JAX when those libraries are
+available locally.
+
+On one Windows CPython 3.10 run for `1.0.1`, TensorStudio beat NumPy on 13
+small activation/reduction benchmark cases and lost on 76 NumPy-comparable
+cases. Against PyTorch CPU `2.12.1+cpu`, TensorStudio won 71 local cases and
+lost 23. The strongest local wins were small eager operations where framework
+dispatch overhead dominates; larger matrix multiplication, larger transcendental
+activations, and larger autograd workloads remain faster in PyTorch and NumPy.
+See `benchmarks/results.md` for the full table, platform details, and exact
+timings.
 
 Snapshot from that local run:
 
-| operation | shape | TensorStudio median | NumPy median | speedup | result |
-|---|---:|---:|---:|---:|---|
-| `sigmoid` | `(1,)` | 0.0016 ms | 0.0036 ms | 2.2170x | win |
-| `mean` | `(1,)` | 0.0014 ms | 0.0081 ms | 5.8562x | win |
-| `mean` | `(8,)` | 0.0016 ms | 0.0079 ms | 5.0005x | win |
-| `add` | `(16384,)` | 0.0100 ms | 0.0037 ms | 0.3682x | loss |
-| `matmul` | `(256, 256)` | 4.1393 ms | 0.4222 ms | 0.1020x | loss |
+| operation | shape | TensorStudio | NumPy | PyTorch CPU | TS vs NumPy | TS vs PyTorch |
+|---|---:|---:|---:|---:|---:|---:|
+| `sigmoid` | `(32,)` | 0.0018 ms | 0.0036 ms | 0.0575 ms | 2.0414x | 32.2110x |
+| `mean` | `(32,)` | 0.0016 ms | 0.0069 ms | 0.0112 ms | 4.4051x | 7.1262x |
+| `chain_relu` | `(128,)` | 0.0086 ms | 0.0039 ms | 0.0567 ms | 0.4488x | 6.5977x |
+| `matmul` | `(256, 256)` | 2.4215 ms | 0.4027 ms | 0.0832 ms | 0.1663x | 0.0343x |
+| `elementwise_backward` | `(1024,)` | 2.3527 ms | n/a | 0.1887 ms | n/a | 0.0802x |
 
-Speedup is `NumPy median / TensorStudio median`, so values above `1.0x` favor
-TensorStudio. The matmul result is from the optimized C++ contiguous path; a
-pre-optimization run was about 259 ms for the same `(256, 256)` case on this
-machine.
+Speedup is `competitor median / TensorStudio median`, so values above `1.0x`
+favor TensorStudio.
 
-Do not treat these results as universal. TensorStudio does not currently claim
-to be faster than NumPy, TensorFlow, PyTorch, or JAX overall.
+Do not treat these results as universal. TensorStudio does not claim to be
+faster than NumPy, TensorFlow, PyTorch, or JAX overall.
 
 ## Save And Load
 
@@ -218,6 +220,7 @@ unsafe because pickle can execute arbitrary code.
 
 ```bash
 python -m pip install -e ".[dev,docs]"
+python test_all.py --skip-build
 ruff check .
 mypy python/tensorstudio
 pytest -q
@@ -230,6 +233,7 @@ scikit-build-core, and C++20.
 
 ## Release Checklist
 
+- `python test_all.py` passes locally.
 - `ruff check .` passes.
 - `mypy python/tensorstudio` passes.
 - `pytest -q` passes on Windows, Linux, and macOS.
@@ -254,6 +258,7 @@ tokens or print secrets.
 - CPU backend only.
 - Eager execution only.
 - No CUDA or Metal backend yet.
+- No BLAS-backed matrix multiplication yet.
 - No graph compiler or distributed runtime.
 - No convolution layers yet.
 - No sparse tensors or advanced indexing.

tensorstudio-1.0.1/benchmark_all.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from benchmarks.benchmark_report import run_benchmarks
+
+ALL_SECTIONS = {
+    "elementwise",
+    "matmul",
+    "reductions",
+    "activations",
+    "autograd",
+    "training_loop",
+}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run every TensorStudio benchmark section.")
+    parser.add_argument(
+        "--section",
+        action="append",
+        choices=sorted(ALL_SECTIONS),
+        help="Run only the selected section. Repeat for multiple sections.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("benchmarks") / "results.md",
+        help="Markdown report path. Defaults to benchmarks/results.md.",
+    )
+    parser.add_argument(
+        "--print",
+        action="store_true",
+        help="Print the full Markdown report after writing it.",
+    )
+    args = parser.parse_args()
+
+    selected_sections = set(args.section or ALL_SECTIONS)
+    report = run_benchmarks(selected_sections, args.output)
+    if args.print:
+        print(report)
+    else:
+        print(f"Wrote benchmark report to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

tensorstudio-1.0.1/benchmarks/__init__.py

@@ -0,0 +1,2 @@
+"""Local TensorStudio benchmark helpers."""
+

{tensorstudio-1.0.0rc2 → tensorstudio-1.0.1}/benchmarks/benchmark_report.py

@@ -62,6 +62,11 @@ def _optional_import(module_name: str) -> Any | None:
         return None
 
 
+def _version_note(module: Any) -> str:
+    version = getattr(module, "__version__", "")
+    return str(version) if version else "available"
+
+
 def _shape_label(shape: tuple[int, ...]) -> str:
     return "(" + ", ".join(str(dim) for dim in shape) + ("," if len(shape) == 1 else "") + ")"
 
@@ -135,19 +140,41 @@ def _load_libraries() -> list[Library]:
     if tf is not None:
         with suppress(Exception):
             tf.config.set_visible_devices([], "GPU")
-        libraries.append(Library("TensorFlow CPU eager", lambda array: tf.constant(array)))
+        libraries.append(
+            Library(
+                "TensorFlow CPU eager",
+                lambda array: tf.constant(array),
+                True,
+                _version_note(tf),
+            )
+        )
     else:
         libraries.append(Library("TensorFlow CPU eager", _numpy_factory, False, "not installed"))
 
     torch = _optional_import("torch")
     if torch is not None:
-        libraries.append(Library("PyTorch CPU", lambda array: torch.from_numpy(array.copy())))
+        libraries.append(
+            Library(
+                "PyTorch CPU",
+                lambda array: torch.from_numpy(array.copy()),
+                True,
+                _version_note(torch),
+            )
+        )
     else:
         libraries.append(Library("PyTorch CPU", _numpy_factory, False, "not installed"))
 
     jnp = _optional_import("jax.numpy")
     if jnp is not None:
-        libraries.append(Library("JAX CPU dispatch", lambda array: jnp.array(array)))
+        jax = _optional_import("jax")
+        libraries.append(
+            Library(
+                "JAX CPU dispatch",
+                lambda array: jnp.array(array),
+                True,
+                _version_note(jax or jnp),
+            )
+        )
     else:
         libraries.append(Library("JAX CPU dispatch", _numpy_factory, False, "not installed"))
 
@@ -512,12 +539,24 @@ def _format_float(value: float | None) -> str:
     return f"{value:.4f}"
 
 
+def _format_win(value: float | None) -> str:
+    if value is None:
+        return "n/a"
+    return "yes" if value > 1.0 else "no"
+
+
 def _speedup(ts_ms: float | None, competitor_ms: float | None) -> float | None:
     if ts_ms is None or competitor_ms is None or ts_ms <= 0:
         return None
     return competitor_ms / ts_ms
 
 
+def _fastest_library(medians: dict[str, float]) -> str:
+    if not medians:
+        return "n/a"
+    return min(medians.items(), key=lambda item: item[1])[0]
+
+
 def _run_cases(cases: Iterable[BenchmarkCase], libraries: list[Library]) -> dict[str, Stats]:
     results: dict[str, Stats] = {}
     for case in cases:
@@ -559,34 +598,49 @@ def _render_report(
     for library in libraries:
         if library.name in {"TensorStudio", "NumPy"}:
             continue
-        status = "available" if library.available else f"unavailable ({library.note})"
+        status = (
+            f"available ({library.note})"
+            if library.available
+            else f"unavailable ({library.note})"
+        )
         lines.append(f"- {library.name}: {status}")
     lines.append("")
     lines.append("## Summary")
     lines.append("")
 
-    wins = 0
-    losses = 0
-    for case in cases:
-        ts_stats = results.get(_result_key(case, "TensorStudio"))
-        np_stats = results.get(_result_key(case, "NumPy"))
-        ratio = _speedup(
-            ts_stats.median_ms if ts_stats else None,
-            np_stats.median_ms if np_stats else None,
-        )
-        if ratio is None:
-            continue
-        if ratio > 1.0:
-            wins += 1
-        else:
-            losses += 1
+    def win_loss_against(library_name: str) -> tuple[int, int]:
+        wins = 0
+        losses = 0
+        for benchmark_case in cases:
+            ts_stats = results.get(_result_key(benchmark_case, "TensorStudio"))
+            competitor_stats = results.get(_result_key(benchmark_case, library_name))
+            ratio = _speedup(
+                ts_stats.median_ms if ts_stats else None,
+                competitor_stats.median_ms if competitor_stats else None,
+            )
+            if ratio is None:
+                continue
+            if ratio > 1.0:
+                wins += 1
+            else:
+                losses += 1
+        return wins, losses
+
+    wins, losses = win_loss_against("NumPy")
     lines.append(f"- TensorStudio wins versus NumPy: `{wins}`")
     lines.append(f"- TensorStudio losses versus NumPy: `{losses}`")
+
+    for competitor in ["PyTorch CPU", "TensorFlow CPU eager", "JAX CPU dispatch"]:
+        competitor_wins, competitor_losses = win_loss_against(competitor)
+        if competitor_wins or competitor_losses:
+            lines.append(f"- TensorStudio wins versus {competitor}: `{competitor_wins}`")
+            lines.append(f"- TensorStudio losses versus {competitor}: `{competitor_losses}`")
     lines.append("")
+
     if wins == 0:
         lines.append(
             "TensorStudio did not beat NumPy on this machine for the available benchmark set. "
-            "Performance remains a blocker for a final `1.0.0` performance claim."
+            "Performance remains a blocker for broad performance claims."
         )
     else:
         lines.append(
@@ -598,10 +652,13 @@ def _render_report(
     lines.append("")
     lines.append(
         "| category | operation | shape | library | median ms | mean ms | min ms | "
-        "max ms | std ms | TS vs NumPy | TS vs TensorFlow | TS vs PyTorch | TS vs JAX | result |"
+        "max ms | std ms | TS vs NumPy | TS vs TensorFlow | TS vs PyTorch | TS vs JAX | "
+        "win vs NumPy | win vs TensorFlow | win vs PyTorch | win vs JAX | "
+        "fastest library | result |"
     )
     lines.append(
-        "|---|---|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---|"
+        "|---|---|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|"
+        "---|---|---|---|---|---|"
     )
 
     for case in cases:
@@ -626,6 +683,7 @@ def _render_report(
                 medians.get("JAX CPU dispatch"),
             ),
         }
+        fastest = _fastest_library(medians)
         for library in libraries:
             stats = results.get(_result_key(case, library.name))
             if stats is None:
@@ -650,13 +708,19 @@ def _render_report(
                 f"{_format_float(speedups['NumPy'])} | "
                 f"{_format_float(speedups['TensorFlow CPU eager'])} | "
                 f"{_format_float(speedups['PyTorch CPU'])} | "
-                f"{_format_float(speedups['JAX CPU dispatch'])} | {result} |"
+                f"{_format_float(speedups['JAX CPU dispatch'])} | "
+                f"{_format_win(speedups['NumPy'])} | "
+                f"{_format_win(speedups['TensorFlow CPU eager'])} | "
+                f"{_format_win(speedups['PyTorch CPU'])} | "
+                f"{_format_win(speedups['JAX CPU dispatch'])} | "
+                f"{fastest} | {result} |"
             )
     lines.append("")
     lines.append(
         "Speedup columns are `competitor median / TensorStudio median`; values above 1.0 mean"
     )
     lines.append("TensorStudio was faster for that specific case.")
+    lines.append("Win columns say whether that same speedup is above 1.0 for the competitor.")
     lines.append("")
     return "\n".join(lines)