(1) Overview
Introduction
Many domains, including Internet of Things (IoT) sensing, epidemiology and reliability engineering, require inspection of co-incident peaks across multiple time series. Conventional visualisation methods often struggle when peaks cluster: overlaid line charts preserve magnitudes but quickly become crowded; binary heatmaps show peak presence but disconnect events from their underlying values and event-tick timelines often separate the events from the data that produced them.
Time-Aligned Peaks (TAP) addresses these limitations by pairing raw values with an aligned peak-presence timeline. This dual-panel design highlights overlaps between primary and secondary variables, while bar-width strategies maintain legibility under irregular sampling. Here, a bar is a coloured rectangle representing a peak in a series. TAP takes two raw-value groups for comparison: primary variables, which represent the main subject of analysis, and secondary variables, which provide comparators. This distinction parallels endogenous and exogenous variables in forecasting models such as Seasonal AutoRegressive Integrated Moving Average with eXogenous variables (SARIMAX) [1, 2].
Figure 1 illustrates TAP’s dual-panel design: a top panel showing raw values as a line plot and a bottom panel displaying stacked peak bars aligned on the same x-axis. Synthetic data were used for this image to highlight TAP’s features.
Figure 1
Summary of TAP’s dual-panel visualisation. The top panel shows raw values as a line plot, while the bottom panel displays stacked peak bars aligned on the same x-axis. Colours and order are consistent across panels. Vertical lines indicate overlapping peaks between primary and secondary variables, aiding quick identification of co-occurrences.
A static predecessor (‘piikkivisualisointi’) was developed by the author in 2021 for the LYHTY – Lyhyiden työpoissaolojen ennaltaehkäisy (‘Short-Term Absence Prevention’) project to inspect co-occurring spikes between short-term sickness absences (primary series, univariate) and epidemic case counts aggregated at regional and national levels (secondary series, multivariate) in Finland [3]. The public final report documents the visualisation as both a tool and a result. The present software generalises this concept into a configurable, documented 2026 implementation with robust ingestion, alignment, visualisation options and machine-readable artefacts.
Existing approaches to time-series visualisation offer partial solutions, but each has trade-offs. Overlaid line charts preserve raw values but become visually dense when many series peak simultaneously [4]. Binary heatmaps compactly encode peak presence yet lose the link to underlying magnitudes [5]. Event-tick timelines show discrete occurrences but often break alignment with the raw data [6]. Ridgeline and horizon plots compress many series effectively but sacrifice precise event alignment [7]. Interactive tools such as Plotly or Bokeh reduce static clutter but require heavier setup and do not offer a dedicated peak-centric representation [8, 9].
Recent work explores interactive and compressed views for time-series analysis. Heer and Shneiderman’s taxonomy [10] emphasises provenance and coordinated views, which TAP supports via reproducible artefacts and shared axes. Braun et al. [11] propose horizon-style compression for large ranges, contrasting TAP’s focus on discrete peak alignment. Voyager [12] enables faceted browsing, while TAP offers a specialised peak-centric view. Hofmann and Vendettuoli [13] highlight perceptual fidelity, informing TAP’s overlap colour inversion. Unlike Machine-Learning (ML)-based event detection [14], TAP uses a transparent slope-change heuristic but exports artefacts suitable for hybrid workflows. The simple design is intentional, prioritising transparency, explainability and ease of inspection over algorithmic novelty. Formal mathematical analysis, error-bound derivations or comparisons with prominence- or wavelet-based detectors are therefore outside the scope of this software-centric metapaper, which focuses on reproducibility, availability and implementation clarity.
In contrast to existing methods [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], TAP provides a reproducible implementation of a dual-panel, peak-centric design that shares the x-axis between the raw line plot and stacked peak timeline, splits series into primary and secondary groups and provides overlap markers with perceptual safeguards; this split is illustrated by a horizontal line between these groups in the stacked peak timeline. Unlike general-purpose visualisation libraries, TAP focuses on peak co-occurrence visibility and artefact reproducibility, making it particularly useful for exploratory analytics where peaks signal anomalies or correlated events. It complements, rather than replaces, more advanced coordinated-view or interactive analytics systems. TAP’s lightweight interactivity is provided through Matplotlib’s pan and zoom [15].
Declarative toolchains such as Altair [16], built on Vega-Lite [17], provide a grammar-based approach with concise interaction and faceting, while libraries like Seaborn [18] streamline statistical graphics on top of Matplotlib [15]. These systems excel at general-purpose visualisation but do not offer a dedicated, aligned peak-timeline representation. TAP complements these ecosystems by specialising in peak co-occurrence visibility on a shared x-axis and by exporting machine-readable artefacts for reproducibility and downstream evaluation.
Prior work has explored alignment strategies for temporal event sequences and co-occurrence patterns in spatial time series [19]. For example, user studies on superimposed time-series alignment highlight the perceptual trade-offs of different alignment schemes [19, 20], while systems such as COPE (Co-Occurrence Pattern Exploration) [21] enable interactive exploration of co-occurrence patterns in spatial data. Design studies have also visualised co-occurrences in domains like genomic mutations [20]. TAP adopts a simpler, shared-axis alignment tailored to peak detection rather than sentinel-event realignment, offering a lightweight static view for small-to-medium datasets.
Recent surveys and benchmarking efforts on time-series anomaly detection emphasise the diversity of methods and the importance of multivariate dependencies [22, 23, 24]. While TAP uses a transparent slope-change heuristic, its exported peak matrix provides a bridge for evaluating overlap-based anomaly hypotheses and for integrating with machine-learning workflows. This positions TAP as a complementary tool for exploratory analytics and reproducible artefact generation in anomaly-focussed pipelines.
To maintain perceptual clarity, TAP includes two colour inversion modes (inverse1 and inverse2), the latter of which is grounded in the Web Content Accessibility Guidelines (WCAG) relative-luminance contrast formula [25]. These modes switch marker polarity when measured contrast would otherwise fall below recommended thresholds, improving readability in dense or colour-similar scenarios. The WCAG-inspired inversion mechanism is implemented as a practical engineering heuristic rather than a perceptual model. It is not intended to constitute a formal accessibility evaluation or a colour-blindness study, but instead provides a lightweight contrast-preserving safeguard for common visualisation cases.
Implementation and architecture
TAP’s design prioritises view coordination (dual-panel with shared x-axis), reproducibility (timestamped peak report and binary matrix) and perceptual clarity (contrast-preserving overlap markers). The implementation uses a modular architecture, with a command-line interface (CLI), file input/output, peak-finding and peak-handling, axis-frequency setting and plot rendering in separate files. Figure 2 illustrates this architecture, showing the CLI (cli.py) orchestrating four supporting modules: ingestion/preprocessing (io.py), peak detection and matrix generation (peaks.py), timeline rendering and colour logic (timeline.py) and axis utilities (plotting.py). Outputs include a dual-panel figure, a peak report [Comma-Separated Values (CSV)] and a binary peak matrix (CSV).
Figure 2
TAP architecture, split by files. The CLI module orchestrates ingestion, alignment, peak detection, visualisation and artefact export through four supporting modules. Outputs include a dual-panel figure, a peak report (CSV) and a binary peak matrix (CSV).
TAP relies on standard scientific Python packages, including NumPy [26] for numerical operations; pandas [27, 28] for data ingestion, alignment and tabular manipulation, and Matplotlib [15] for plotting and visualisation.
Design Rationale
Following Heer & Shneiderman’s taxonomy [10], TAP supports three key principles. First, view coordination is achieved through a dual-panel design with a shared x-axis, ensuring spatial consistency between raw values and peak timelines. Second, TAP addresses the analysis process and provenance by exporting timestamped peak reports and binary peak matrices, enabling reproducibility and downstream evaluation. Third, perceptual considerations, inspired by Hofmann & Vendettuoli [13], guide the inclusion of overlap colour inversion modes to maintain contrast when hues are similar.
Although TAP exports static images for reproducibility, it uses the interactive Matplotlib viewer that supports panning and zooming, enabling exploratory visual analysis during use. The bottom panel’s y-axis remains fixed during pan and zoom, ensuring all series remain visible and overlaps are preserved for navigation.
Functionality
TAP’s functionality spans five stages. Input ingestion and normalisation handles Comma-Separated Values (CSV) and Tab-Separated Values (TSV) files (with delimiter sniffing) and Excel formats (.xls/.xlsx), supports orientation auto-detection or override and normalises per-series metadata. Alignment and preprocessing merges indices into a unified timeline, offering optional resampling when a DatetimeIndex exists and configurable missing-value policies, including none, zero, forward fill (ffill) and backward fill (bfill). For peak detection, TAP applies a simple, explainable slope-change criterion – identifying a peak when a positive delta is followed by a negative delta with finite values – yielding sets of series peaking at each timestamp. Visualisation combines a dual-panel figure: a top line plot showing all series and a bottom stacked timeline of peak bars per series and timestamp, split into primary and secondary groups. Overlap markers employ contrast-preserving modes (inverse1 and inverse2). The first inverts the overlap marker colour when over a peak bar and otherwise applies the normal one. The second uses the WCAG luminance formula [25] and a custom threshold value to determine the overlap marker colour. Peak bar widths can be determined locally – guided by x-axis tick spacing – or globally based on median or minimum width. An optional scale factor introduces gaps between bars to improve clarity or aesthetics. Finally, artefact generation produces two machine-readable outputs: a peak report (CSV listing peaking series per timestamp) and a binary peak matrix (CSV encoding per-series/per-timestamp presence and optional overlap columns for primary∩secondary). All features are accessible via a single CLI with options for titles, labels, legend naming, overlap styles, timeline styles and export paths.
The inverse2 mode dynamically inverts the overlap indicator colour only when the original overlap colour would be visually similar to the underlying variable colour. Similarity is determined using two perceptual metrics implemented in the source code:
Red–Green–Blue (RGB) distance: the Euclidean distance between the two colours in RGB space; and
Relative brightness: computed as a weighted luminance (0.2126 R + 0.7152 G + 0.0722 B), as defined by WCAG [25].
If either the RGB distance is below 0.6 or the brightness difference is below 0.2, the colours are considered too similar (is_combined_similar) and the overlap indicator is replaced with the inverted colour. This ensures that overlap markers remain visually distinguishable from the bar colours directly beneath them, increasing effective perceptual contrast whenever a potential clash is detected. Parameters 0.6 and 0.2 were experimentally chosen.
Figures 3, 4, 5 are representative examples of the TAP dual-panel visualisation (line plot + stacked peak timeline) under different overlap marker modes (synthetic data were used for demonstration purposes).
Figure 3
TAP dual-panel visualisation with default overlap markers.
Figure 4
TAP dual-panel visualisation using ‘inverse1’ overlap mode for colour inversion inside the timeline rectangle (peak bar).
Figure 5
TAP dual-panel visualisation using ‘inverse2’ overlap mode, which inverts overlap markers only when their colour would otherwise be too similar, as measured by [25], to the series colours, improving contrast and readability in dense or colour-similar scenarios.
Figures 3, 4, 5 can be regenerated using the TAP command-line interface by selecting selftest/examples/primary1.csv and selftest/examples/secondary1.xlsx from the self-test data as input files, setting --secondary-sheet to Sheet1 and date format to "%Y-%m", choosing the desired colour mode and setting the output resolution (--dpi 600). Exact reproduction commands can be found in README.md in the repository.
Examples of machine-readable outputs – the peak report and the binary peak matrix – are shown in Figure 6. In the peak report, detected peaks are grouped into primary and secondary variables and labelled with their variable names; an empty field indicates that no peak occurred in that group at the corresponding timestamp (e.g., no peaks occur on 2026-01-01, whereas all variables exhibit peaks on 2026-11-01). In contrast, the binary peak matrix encodes peak presence using 1 and absence using 0 for each variable and includes an optional overlap column indicating where primary and secondary groups peak simultaneously. Full artefacts can be generated automatically by the CLI and are archived with the software release.
Figure 6
Output matrices. (a) peak reports, (b) binary peak matrix. The input files are examples/synthetic_primary2.csv and examples/synthetic_secondary2.csv from the repository.
Installation
TAP is distributed through GitHub and Zenodo as a lightweight research tool. Source-based installation is intentionally used to ensure complete transparency, allow inspection of all components and avoid packaging overhead for a small, research-oriented software package. This distribution model is consistent with JORS’s requirements for open availability and reproducibility of the published artefact.
TAP can be installed directly from the source repository using a standard Python virtual environment:
git clone https://github.com/villepitkakangas/time-aligned-peaks
cd time-aligned-peaks
python -m venv .venv
# Windows:
.venv\Scripts\activate
# macOS/Linux:
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -e.
This installs TAP in editable mode and exposes the command-line interface (‘python -m time_aligned_peaks.cli’), enabling immediate reproduction of the examples and figures in the metapaper.
After installation, TAP can be invoked using its CLI module:
python -m time_aligned_peaks.cli --primary examples/synthetic_primary.csv --secondary examples/synthetic_secondary.csv --secondary-sheet Sheet1 --save-figure demo.png
This minimal command verifies that the installation was successful by producing a dual-panel figure and saving it to ‘demo.png’. It uses the included synthetic datasets.
Command-line example
The following example demonstrates TAP’s full functionality using a dataset with overlapping peaks and exporting all artefacts to files:
python -m time_aligned_peaks.cli --primary examples/synthetic_primary.csv --secondary examples/synthetic_secondary.csv --secondary-date-format "%Y-%m" --title "Synthetic demo" --save-figure output_demo.png --output-peaks peaks_demo.csv --output-peak-matrix peaks_matrix.csv
This example loads the provided synthetic primary and secondary datasets, applies monthly date parsing, displays an interactive dual-panel visualisation of the overlapping peaks and exports all artefacts (combined plot, peak report and binary peak matrix).
The above command is optimised for Windows Command Prompt; other options and full examples for each overlap colour marker mode, complete with output peak and peak matrix files, are available in README.md in the repository. All options beyond the defaults are optional. TAP is designed to work out-of-the-box with no parameter tuning, and the CLI exposes additional configuration only for specialised scenarios.
Using TAP as a library
Although TAP is primarily used via its command-line interface, its internal components can also be accessed programmatically by importing parts from the corresponding submodules (e.g., ‘time_aligned_peaks.io’, ‘time_aligned_peaks.peaks’, ‘time_aligned_peaks.timeline’); for example, the function for rendering the bottom panel can be imported with ‘from time_aligned_peaks.timeline import add_peak_timeline’. A full programmatic example is provided in the repository under ‘examples/module_usage_example.py’. The CLI remains the recommended interface for most users.
Quality control
The package includes a comprehensive set of unit tests that validate core functionality:
Ingestion (delimiter sniffing),
Alignment (orientation fix and index mapping),
Peak detection [slope-change heuristic, not-a-number (NaN) handling and minimal cases],
Binary peak matrix generation (correct columns and overlap encoding) and
CLI execution (artefact generation and overlap column correctness).
The synthetic datasets used in all tests consist of smooth baseline curves with small random perturbations and manually inserted peak-like fluctuations of varying width and amplitude. These controlled perturbations ensured specific co-occurrences across the primary and secondary series, allowing a clear demonstration of TAP’s alignment and visualisation behaviour while avoiding any privacy or licencing constraints associated with real-world data. The simplified structure resembles common IoT and sensing scenarios (e.g., temperature spikes, load peaks, activation signals) but is not intended to represent any specific domain quantitatively.
A self-test was conducted comparing traditional combined line plots to TAP’s dual-panel view for identifying overlapping peaks between primary and secondary series. This example is intended purely as an illustrative reproducibility demonstration, not an independent validation. Two synthetic datasets were inspected: one with one overlap and one with four overlaps, deliberately positioned to allow controlled inspection of TAP’s alignment and detection behaviour. Default settings were used for the overlap indicators. Measures included time and accuracy [Precision/Recall/F1/Jaccard [29]] against reference overlap timestamps defined by the deliberately positioned overlaps in the synthetic datasets, encoded in machine-readable form via TAP’s exported peak matrix (Table 1). These values, therefore, reflect internal consistency rather than external benchmarking. Execution time was measured using a monotonic timer (‘time.perf_counter()’), starting when the plot window became interactive and ending when the analyst pressed the ‘Done’ button after marking perceived overlaps. This measurement, therefore, reflects only the human inspection and interaction time within the self-test tool, not file loading, rendering, or export overhead. For the self-test, ‘predicted overlaps’ were the timestamps clicked by the analyst in the self-test tool, and ‘reference overlaps’ were the timestamps flagged as overlapping (primary∩secondary) in TAP’s exported peak matrix. True positives were clicked timestamps that were also reference overlaps, false positives were clicked timestamps without a reference overlap, and false negatives were reference overlaps that were not clicked. Precision, recall, F1-score and Jaccard index [29] were computed from these counts using standard definitions. The four-overlapping-peak dataset yielded one false negative (missed overlap), lowering recall and Jaccard to 0.75 and F1 to 0.857.
Table 1
Analyst self-test results comparing line plots and TAP for detecting overlapping peaks.
| DATASET | METHOD | TIME (s) | PRECISION | RECALL | F1 | JACCARD |
|---|---|---|---|---|---|---|
| One-overlapping-peak | Line plot | 20.37 | 1.000 | 1.000 | 1.000 | 1.000 |
| TAP | 5.32 | 1.000 | 1.000 | 1.000 | 1.000 | |
| Four-overlapping-peak | Line plot | 21.12 | 1.000 | 0.750 | 0.857 | 0.750 |
| TAP | 7.59 | 1.000 | 1.000 | 1.000 | 1.000 |
In this illustrative example, TAP reduced inspection time by ~4× and ~2.8×, respectively, while improving recall without loss of precision. The stacked timeline surfaced co-occurrences crowded in overlaid lines.
This self-test reflects a single analyst and a small number of plots and is intended as a worked example illustrating reproducibility rather than a general usability study or statistical evaluation of peak-detection performance. The datasets are deliberately small to keep the procedure transparent and easy to verify. Independent validation, broader empirical evaluations, controlled user studies or statistical significance testing fall outside the scope of this software metapaper but represent natural directions for future methodological work. To support independent inspection, the self-test tool, inputs (CSV and Excel files) and outputs [CSV and JavaScript Object Notation (JSON)] are archived in the repository (in the ‘selftest/’ folder and its subfolders) so others can replicate the task on their own data using objective ground truth derived from the synthetic datasets and TAP’s peak-export mechanism. In addition to the automated comparison, all overlaps in the synthetic datasets were manually verified to confirm that TAP correctly reports co-occurring peaks between primary and secondary series.
Reproducing the self-test outputs and example artefacts:
Clone the repository and install in a virtual environment using 'pip install -e .' (as described in Installation).
Create a fresh output directory (e.g., 'examples/rerun_outputs/') to avoid overwriting reference files.
Run the three CLI examples listed in the README under 'Command-line Examples' using selftest/examples/primary1.csv and selftest/examples/secondary1.xlsx, with --secondary-sheet Sheet1, --secondary-date-format "%Y-%m", --dpi 600 and overlap modes default, inverse1 and inverse2 and setting output paths to examples/rerun_outputs/.
Compare the generated PNG and CSV outputs in 'examples/rerun_outputs/' to the reference files in 'examples/expected_outputs/' for each overlap-marker mode (default, inverse1, inverse2) and each output type (plot PNG, peak report CSV, peak matrix CSV).
Run the unit/integration test suite with 'python -m pytest' (dependencies in 'requirements-tests.txt') to verify ingestion, alignment, peak detection and artefact export.
Run the self-tests (one-overlap and four-overlap datasets) using:
python selftest/tap_selftest.py --primary selftest/examples/primary.csv --secondary selftest/examples/secondary.xlsx --secondary-sheet Sheet1 --secondary-date-format "%Y-%m" --title "TAP Self-Test" --out-dir tap_selftest_output_one
python selftest/tap_selftest.py --primary selftest/examples/primary1.csv --secondary selftest/examples/secondary1.xlsx --secondary-sheet Sheet1 --secondary-date-format "%Y-%m" --title "TAP Self-Test" --out-dir tap_selftest_output_four
The repository includes a test suite (unit and integration tests) located in the ‘tests/’ directory. Tests can be run on Python 3.10–3.13 on Windows 11 and Ubuntu 24.04 (WSL2) using ‘python -m pytest’. A ‘requirements-tests.txt’ file specifies all test dependencies. In addition, the ‘examples/’ folder contains the synthetic datasets used in the manuscript and a full programmatic example (‘module_usage_example.py’), and the ‘examples/expected_outputs/’ folder contains the corresponding expected PNG plots, peak reports and binary peak matrices for all three overlap-marker modes. These allow users to reproduce the figures and artefacts shown in the metapaper exactly. Instructions for running the tests and reproducing the examples are provided in the README.
(2) Availability
Operating system
Cross-platform (Linux, macOS, Windows); tested on Windows 11 Enterprise and Ubuntu 24.04.4 LTS (WSL2).
Programming language
Python (>= 3.9), CLI entry point. Tested on Python 3.9, 3.10, 3.12 and 3.13.
Additional system requirements
Processor: Dual-core CPU (e.g., Intel i5 or equivalent).
Memory: 4 GB RAM (8 GB recommended for medium datasets).
Disk space: 10–100 MB for installation; additional space depends on dataset size.
Input device: Keyboard for CLI parameter input; mouse or touchpad for interactive output exploration.
TAP has been tested on standard consumer hardware.
Dependencies
Core: matplotlib ≥3.5, pandas ≥2.0, numpy ≥1.23, python-dateutil ≥2.8; Excel: openpyxl (xlsx) ≥ 3.1, xlrd (xls) ≥ 2.0; Recommended for testing: pytest ≥7.4.
List of contributors
Ville Pitkäkangas, Centria University of Applied Sciences, Vierimaantie Campus, Vierimaantie 7, 84100 Ylivieska, Finland
Software location
Archive
Name: Zenodo
Persistent identifier: https://doi.org/10.5281/zenodo.18329360
Licence: MIT
Publisher: Ville Pitkäkangas
Version published: 0.3.1
Date published: 21/01/26
Code repository
Name: GitHub
Identifier: https://github.com/villepitkakangas/time-aligned-peaks
Licence: MIT
Date published: 21/01/26
The DOI above is the permanent Zenodo version DOI corresponding to release v0.3.1. The project also has a stable concept DOI (10.5281/zenodo.18328885), which always resolves to the latest version. Following Zenodo’s recommended practice, all repository metadata files (README.md, CITATION.cff) reference only the concept DOI to avoid repeated version churn and ensure long-term citation stability.
Language
English
(3) Reuse potential
TAP is useful for exploratory analytics when peaks signal anomalies, activations or correlated events across heterogeneous sources (e.g., sensors, administrative indicators). The dual-panel alignment reduces visual search effort while preserving magnitudes, and artefacts enable downstream evaluation (precision/recall against ground truth), aggregation or ML integration. TAP complements overlaid line charts, heatmaps, event timelines and horizon/ridgeline approaches by focussing on co-occurrence visibility with a shared x-axis and lightweight interactivity (Matplotlib pan/zoom). While TAP is effective for small-to-medium datasets and static outputs, its visual clarity may diminish with very large numbers of series or timestamps. In practical use, TAP is intended for datasets typically consisting of a few hundred to tens of thousands of timestamps across up to a few dozen series (variables), with at least one series designated as primary and one as secondary. Performance is dominated by Matplotlib rendering and therefore scales approximately linearly with the number of plotted elements; interactive navigation (pan and zoom) remains responsive within these ranges, while substantially larger datasets may benefit from prior downsampling. The exported peak-presence matrices are intended for exploratory and unsupervised analyses. Supervised learning workflows require user-provided labels, which TAP does not generate automatically, and the software therefore does not claim to provide complete supervised ML pipelines. Additional extensions could include optional integration with alternative peak-detection methods such as SciPy’s prominence-based detectors [30]. Addressing these limitations is a priority for potential future work, which may include colour-blind palettes, brushing/linked highlighting, configurable detection thresholds and ML-based event integration. The CSV matrices that TAP outputs can be directly consumed by Python data analytics and ML workflows [e.g., pandas [27, 28], NumPy [26], scikit-learn [31]]. A short example demonstrating this is included in the README.
Acknowledgements
A static predecessor (‘piikkivisualisointi’) was developed within the LYHTY project at Centria University of Applied Sciences, funded by the European Social Fund (ESF) and the Finnish Work Environment Fund. The present software (TAP) is an independently developed implementation that generalises the concept; no LYHTY code or assets are reused here.
Generative AI tools. The author used Microsoft Copilot (GPT-5) during the development of TAP to assist with drafting and refining portions of the Python source code, including elements of the core visualisation logic, test scaffolding and documentation text. Generative AI was also used to assist in refining the prose of the manuscript and in identifying relevant literature for citation. All AI-assisted outputs were reviewed, verified and extensively edited by the author, who takes full responsibility for the final software implementation and manuscript content.