riptide-ffa 0.2.4__tar.gz → 0.2.6__tar.gz

{riptide-ffa-0.2.4 → riptide_ffa-0.2.6}/.coveragerc

@@ -2,11 +2,8 @@
 branch = True
 parallel = True
 concurrency = multiprocessing
-include =
-    riptide/*
 omit =
-    riptide/tests/*
-    riptide/_version.py
+    src/riptide/_version.py
 
 [report]
 exclude_lines =

riptide_ffa-0.2.6/.github/workflows/CI.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  # See: https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#example-running-a-job-within-a-container
+  continuous-integration:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          make install
+      - name: Test
+        run: |
+          make tests
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

{riptide-ffa-0.2.4 → riptide_ffa-0.2.6}/.gitignore

@@ -1,13 +1,19 @@
-*.o
-*.so
-*.pyc
-__pycache__
+dist
+build
+.egg
+.nox
 .vscode
-*.egg-info
 .coverage
-.eggs
+__pycache__
+.mypy_cache
+docs/_build
 .pytest_cache
-tmp
-build
-dist
 pip-wheel-metadata
+.ipynb_checkpoints
+src/riptide/_version.py
+
+*.o
+*.so
+*.egg
+*.py[cod]
+*.egg-info

riptide_ffa-0.2.6/.readthedocs.yaml

@@ -0,0 +1,15 @@
+# Read the Docs configuration file for Sphinx projects
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+
+sphinx:
+  configuration: docs/source/conf.py

{riptide-ffa-0.2.4 → riptide_ffa-0.2.6}/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.2.6 - 2026-09-10
+
+This version modernises the project layout and packaging, and fixes issues in candidate plotting and downsampled variance calculations.
+
+### Fixed
+
+- Candidate plots now normalise each sub-integration independently for better contrast,
+  contributed by Dejiang Yin.
+- Corrected the downsampled variance calculation for factors very close to an integer,
+  thanks to Francesco Coti Zelati for reporting the issue.
+
+
+## 0.2.5 - 2023-12-23
+
+This version fixes an installation error on recent OSX versions, and a segmentation fault that triggers in some edge cases.
+
+Thanks to Francesco Coti Zelati for [reporting the original issue](https://github.com/v-morello/riptide/issues/4) that led to both fixes.
+
+### Fixed
+
+- Fixed a serious bug where some intermediate output arrays were unexpectedly allocated with a size one element smaller than expected, causing segmentation faults. This was found to be a side effect of the compilation flag `-freciprocal-math`. See issue [#4](https://github.com/v-morello/riptide/issues/4) for a detailed explanation. The set of compilation flags for the C++ extensions has been reviewed and adjusted.
+- The C++ extensions can now be built with the C++17 standard enabled without throwing any errors or warnings. Recent `clang` versions (the default compiler on OSX) would throw a number of narrowing conversion errors, which would in turn make the installation of riptide fail with a cryptic error message. 
+
+
 ## 0.2.4 - 2022-02-03
 
 This version fixes a bug where all the functions in the python bindings to the C++ code (exposed in `riptide.libcpp` on the Python side) assume that their input numpy arrays are contiguous in memory. In practice, passing a column slice of a two-dimensional `float32` array to `fast_running_median` was found to produce incorrect results: the rather than reading `data[:, col_index]`, the code read `data[0, col_index:col_index+num_cols]`. The issue would only trigger on the `float32` type, because otherwise an implicit copy (contiguous in memory) of the input was created.

{riptide-ffa-0.2.4 → riptide_ffa-0.2.6}/Makefile

@@ -4,13 +4,10 @@ PKG = riptide-ffa
 dist: ## Build source distribution, must have installed 'develop' extra dependencies
 	python -m build --sdist
 
-docker: ## Build riptide-ffa docker image
-	docker build --file docker/Dockerfile --tag ${PKG} .
-
 # NOTE: -e installs in "Development Mode"
 # See: https://packaging.python.org/tutorials/installing-packages/
-install: ## Install the package in development mode
-	pip install -e .
+install: ## Install the package in editable mode with dev dependencies
+	pip install -e .[dev]
 
 # NOTE: remove the .egg-info directory
 uninstall: ## Uninstall the package
@@ -35,6 +32,6 @@ clean: ## Remove all python cache and build files
 	rm -f .coverage
 
 tests: ## Run the unit tests and print a coverage report
-	pytest --cov --verbose --cov-report term-missing riptide/tests
+	pytest --cov --verbose --cov-report term-missing tests
 
-.PHONY: dist docker install uninstall help clean upload upload_test tests
+.PHONY: dist install uninstall help clean tests

riptide_ffa-0.2.6/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: riptide-ffa
+Version: 0.2.6
+Summary: Pulsar searching with the Fast Folding Algorithm (FFA)
+Author-email: Vincent Morello <vmorello@gmail.com>
+Maintainer-email: Vincent Morello <vmorello@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2017-2021 Vincent Morello
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: homepage, https://github.com/vmorello/riptide
+Project-URL: documentation, https://riptide-ffa.readthedocs.io
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: C
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astropy
+Requires-Dist: pandas
+Requires-Dist: schema
+Requires-Dist: pyyaml
+Requires-Dist: threadpoolctl
+Requires-Dist: pytest
+Requires-Dist: pytest-cov
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+[![arXiv](http://img.shields.io/badge/astro.ph-2004.03701-B31B1B.svg)](https://arxiv.org/abs/2004.03701)   ![License](https://img.shields.io/badge/License-MIT-green.svg)   ![Python versions](https://img.shields.io/pypi/pyversions/riptide-ffa.svg)  ![CI status](https://github.com/v-morello/riptide/actions/workflows/CI.yml/badge.svg?branch=master)   [![codecov](https://codecov.io/gh/v-morello/riptide/branch/master/graph/badge.svg)](https://codecov.io/gh/v-morello/riptide)
+
+# riptide
+
+__riptide__ ("sea**r**ch**i**ng for **p**ulsars in the **ti**me **d**omain") is a pulsar searching package implementing the Fast Folding Algorithm (FFA), the theoretically optimal search method for periodic signals. Its interface is entirely in python while the core algorithms are implemented in C. riptide provides:  
+
+* A library of functions and classes to use interactively to process dedispersed time series  
+* A pipeline executable to process a set of DM trials and output a list of candidate files and other useful data products  
+
+## Citation
+
+If using ``riptide`` contributes to a project that leads to a scientific publication, please cite the article:  
+["Optimal periodicity searching: Revisiting the Fast Folding Algorithm for large scale pulsar surveys"](https://arxiv.org/abs/2004.03701)
+
+
+## Sensitivity of the FFA
+
+The article covers the topic of the FFA's sensitivity in theory, here is a practical example on a faint source. Below is an L-band observation of [PSR J1932-3655](https://www.atnf.csiro.au/people/joh414/ppdata/1932-3655.html) from the [SUPERB survey](https://arxiv.org/abs/1706.04459), significantly offset from the true position of the source. The first plot was obtained by folding the observation using the known ephemeris of the pulsar with [PSRCHIVE](http://psrchive.sourceforge.net/). This is one of the faintest known pulsar instances identifiable in the survey.
+
+![psrchive_plot](docs/source/images/J1932-3655_psrchive_small.png "PSRCHIVE direct ephemeris folding")  
+
+And below is a blind detection of the pulsar, running `riptide` on the same observation:  
+![riptide_plot](docs/source/images/J1932-3655_blind_detection.png "riptide blind detection")
+
+
+## Documentation
+
+A quickstart guide, a pipeline configuration tutorial and the full API documentation can be found [here](https://riptide-ffa.readthedocs.io).
+
+## Installation
+
+The easiest method is to use pip install, which pulls the latest release from the python package index and installs all required dependencies:
+```
+pip install riptide-ffa
+```
+
+The alternative is to clone the repository, especially if you want the absolute latest version:
+```bash
+git clone https://github.com/v-morello/riptide
+```
+
+And then in the base directory of `riptide` run
+
+```bash
+make install
+```
+
+This simply runs ``pip install`` in [editable mode](https://pip.pypa.io/en/latest/reference/pip_install/#editable-installs), which means you can freely edit the code. It also installs any required dependencies with ``pip`` that are not present already. The installer also adds links to two command-line apps in your python environment using [console_scripts entry points](https://python-packaging.readthedocs.io/en/latest/command-line-scripts.html):  
+
+* `rffa`: The full end-to-end pipeline to search multiple DM trials, see below for details on how to use it.
+* `rseek`: A lightweight app to search a single time series and print significant candidates found, useful for quick data checks.
+
+You may check that it all works by typing:  
+```
+rffa -h
+rseek -h
+```
+And you should see the full help of both applications.
+
+
+
+
+

{riptide-ffa-0.2.4 → riptide_ffa-0.2.6}/README.md

@@ -1,4 +1,4 @@
-[![arXiv](http://img.shields.io/badge/astro.ph-2004.03701-B31B1B.svg)](https://arxiv.org/abs/2004.03701)   ![License](https://img.shields.io/badge/License-MIT-green.svg)   ![Python versions](https://img.shields.io/pypi/pyversions/riptide-ffa.svg)   [![Build Status](https://travis-ci.com/v-morello/riptide.svg?branch=master)](https://travis-ci.com/v-morello/riptide)   [![codecov](https://codecov.io/gh/v-morello/riptide/branch/master/graph/badge.svg)](https://codecov.io/gh/v-morello/riptide)
+[![arXiv](http://img.shields.io/badge/astro.ph-2004.03701-B31B1B.svg)](https://arxiv.org/abs/2004.03701)   ![License](https://img.shields.io/badge/License-MIT-green.svg)   ![Python versions](https://img.shields.io/pypi/pyversions/riptide-ffa.svg)  ![CI status](https://github.com/v-morello/riptide/actions/workflows/CI.yml/badge.svg?branch=master)   [![codecov](https://codecov.io/gh/v-morello/riptide/branch/master/graph/badge.svg)](https://codecov.io/gh/v-morello/riptide)
 
 # riptide
 
@@ -17,10 +17,10 @@ If using ``riptide`` contributes to a project that leads to a scientific publica
 
 The article covers the topic of the FFA's sensitivity in theory, here is a practical example on a faint source. Below is an L-band observation of [PSR J1932-3655](https://www.atnf.csiro.au/people/joh414/ppdata/1932-3655.html) from the [SUPERB survey](https://arxiv.org/abs/1706.04459), significantly offset from the true position of the source. The first plot was obtained by folding the observation using the known ephemeris of the pulsar with [PSRCHIVE](http://psrchive.sourceforge.net/). This is one of the faintest known pulsar instances identifiable in the survey.
 
-![psrchive_plot](images/J1932-3655_psrchive_small.png "PSRCHIVE direct ephemeris folding")  
+![psrchive_plot](docs/source/images/J1932-3655_psrchive_small.png "PSRCHIVE direct ephemeris folding")  
 
 And below is a blind detection of the pulsar, running `riptide` on the same observation:  
-![riptide_plot](images/J1932-3655_blind_detection.png "riptide blind detection")
+![riptide_plot](docs/source/images/J1932-3655_blind_detection.png "riptide blind detection")
 
 
 ## Documentation

riptide_ffa-0.2.6/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [
+  "setuptools>=42",
+  "wheel",
+  "setuptools_scm[toml]>=3.4",
+  "pybind11>=2.6.0",
+]
+
+[project]
+name = "riptide-ffa"
+authors = [{name = "Vincent Morello", email = "vmorello@gmail.com"}]
+description = "Pulsar searching with the Fast Folding Algorithm (FFA)"
+dynamic = ["version"]
+license = {file = "LICENSE"}
+maintainers = [{name = "Vincent Morello", email = "vmorello@gmail.com"}]
+readme = "README.md"
+requires-python = ">=3.9"
+
+classifiers = [
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: C",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: Unix",
+  "Operating System :: MacOS :: MacOS X",
+  "Topic :: Scientific/Engineering :: Astronomy",
+]
+
+dependencies = [
+  "astropy",
+  "pandas",
+  "schema",
+  "pyyaml",
+  "threadpoolctl",
+  "pytest",
+  "pytest-cov",
+  "matplotlib",
+  "numpy",
+]
+
+[project.optional-dependencies]
+dev = [
+  "build",
+  "twine",
+]
+
+[project.scripts]
+rffa = "riptide.pipeline.pipeline:main"
+rseek = "riptide.apps.rseek:main"
+
+[project.urls]
+homepage = "https://github.com/vmorello/riptide"
+documentation = "https://riptide-ffa.readthedocs.io"
+
+[tool.setuptools_scm]
+write_to = "src/riptide/_version.py"

riptide_ffa-0.2.6/riptide/cpp/transforms_advanced_LEGACY.hpp

@@ -0,0 +1,248 @@
+#ifndef TRANSFORMS_ADVANCED_HPP
+#define TRANSFORMS_ADVANCED_HPP
+
+#include <cstddef> // size_t
+
+#include "transforms_blocked.hpp"
+
+namespace riptide::advanced
+{
+    using riptide::direct::merge_radix2;
+    using riptide::blocked::integer_log2;
+
+    constexpr size_t SMALL_INPUT_MAX_SIZE = 1UL << 18;
+
+    size_t head_size(const size_t rows)
+    {
+        return rows / 2;
+    }
+
+    size_t tail_size(const size_t rows)
+    {
+        return rows - head_size(rows);
+    }
+
+    /// @brief Represents a 2D vertical slice of a TransformCube.
+    /// @tparam DataType Numerical type of the data being wrapped.
+    template <typename DataType>
+    class VerticalSlice
+    {
+    public:
+        // Pointer to the start of the first row of the slice
+        DataType *data;
+
+        // number of planes within the original TransformCube spanned by this vertical slice
+        const size_t planes;
+
+        // number of bins across the pulse profiles (last dimension)
+        const size_t cols;
+
+        // offset between consecutive planes in number of data points
+        const size_t stride;
+
+        // the row index along which this slice was taken within the original TransformCube
+        const size_t row_index;
+
+        // The plane index within the original TransformCube where this slice starts.
+        const size_t plane_index;
+
+    public:
+        /// @brief Create a new VerticalSlice from a raw data pointer
+        /// Note that plane_index = 0 by default. Non-zero plane indices are
+        /// only used during the recursion of small FFA transforms.
+        VerticalSlice(DataType *data, size_t planes, size_t cols, size_t stride, size_t row_index, size_t plane_index = 0)
+            : data(data), planes(planes), cols(cols), stride(stride), row_index(row_index), plane_index(plane_index)
+        {
+        }
+
+        VerticalSlice<DataType> head() const
+        {
+            return VerticalSlice<DataType>(
+                data, head_size(planes), cols, stride, row_index, plane_index);
+        }
+
+        VerticalSlice<DataType> tail() const
+        {
+            const size_t h = head_size(planes);
+            const size_t t = tail_size(planes);
+            return VerticalSlice<DataType>(
+                data + h * stride, t, cols, stride, row_index, plane_index + h);
+        }
+
+    }; // class VerticalPlane
+
+    /// @brief Represents a 2D horizontal plane of a TransformCube
+    /// @tparam DataType
+    template <typename DataType>
+    class Plane
+    {
+    public:
+        DataType *data;
+        const size_t rows;
+        const size_t cols;
+
+    public:
+        Plane(DataType *data, size_t rows, size_t cols)
+            : data(data), rows(rows), cols(cols)
+        {
+        }
+
+        Plane<DataType> head() const
+        {
+            return Plane<DataType>(data, head_size(rows), cols);
+        }
+
+        Plane<DataType> tail() const
+        {
+            return Plane<DataType>(data + head_size(rows) * cols, tail_size(rows), cols);
+        }
+
+    }; // class Plane
+
+    /// @brief Represents data that has been FFA transformed by blocks.
+    /// 'planes' is the number of blocks of data that have been FFA transformed independently.
+    /// 'rows' is the number of rows inside each transformed block.
+    /// 'cols' is the number of columns = number bins across a pulse profile.
+    /// Special cases:
+    /// planes = N, rows = 1 is raw data, pre-transform.
+    /// planes = 1, rows = N is fully FFA-transformed data.
+    /// @tparam DataType Numerical type of the data being wrapped.
+    template <typename DataType>
+    class TransformCube
+    {
+    public:
+        DataType *data;
+        const size_t planes;
+        const size_t rows;
+        const size_t cols;
+        const size_t plane_stride;
+
+    public:
+        TransformCube(DataType *data, size_t planes, size_t rows, size_t cols)
+            : data(data), planes(planes), rows(rows), cols(cols), plane_stride(rows * cols)
+        {
+        }
+
+        /// @brief Return a view of one of the planes
+        Plane<DataType> getPlane(size_t index) const
+        {
+            return Plane<DataType>(data + index * plane_stride, rows, cols);
+        }
+
+        /// @brief Return a view of a group of rows within a given plane
+        Plane<DataType> getSubPlane(size_t plane_index, size_t start_row_index, size_t num_rows) const
+        {
+            const size_t offset = plane_index * plane_stride + start_row_index * cols;
+            return Plane<DataType>(data + offset, num_rows, cols);
+        }
+
+        /// @brief Return a VerticalSlice spanning all the planes, along given row index
+        VerticalSlice<DataType> getVerticalSlice(size_t row_index) const
+        {
+            return VerticalSlice<DataType>(
+                data + row_index * cols, planes, cols, plane_stride, row_index);
+        }
+
+        /// @brief Return a view of a group of consecutive planes
+        TransformCube<DataType> getSubCube(size_t start_plane_index, size_t num_planes) const
+        {
+            const size_t offset = start_plane_index * plane_stride;
+            return TransformCube<DataType>(data + offset, num_planes, rows, cols);
+        }
+    }; // class TransformCube
+
+    template <typename DataType>
+    void transform_vertical_slice(
+        VerticalSlice<DataType> vslice,
+        DataType *__restrict__ swap,
+        DataType *__restrict__ out)
+    {
+        if (vslice.planes == 1)
+        {
+            const size_t shift = vslice.plane_index * vslice.row_index;
+            rollback(vslice.data, vslice.cols, shift, out);
+            return;
+        }
+
+        // NOTE: Use output as swap space, and swap space as intermediate
+        // storage
+        const size_t offset = head_size(vslice.planes) * vslice.cols;
+        transform_vertical_slice(vslice.head(), out, swap);
+        transform_vertical_slice(vslice.tail(), out + offset, swap + offset);
+        merge_radix2(swap, swap + offset, vslice.planes / 2, vslice.cols, out);
+    }
+
+    /// @brief The maximum number of rows that should be transformed
+    /// within a small FFA transform. It is chosen such that the small FFA
+    /// input size does not exceed SMALL_INPUT_MAX_SIZE.
+    /// Returns a power of two that is >= 2.
+    template <typename DataType>
+    size_t small_transform_num_rows(const size_t cols)
+    {
+        const size_t max_size_elements = SMALL_INPUT_MAX_SIZE / sizeof(DataType);
+        const size_t max_rows = 1UL << integer_log2(max_size_elements / cols);
+        return std::max(max_rows, 2UL);
+    }
+
+    template <typename DataType>
+    TransformCube<DataType> transform_until(
+        TransformCube<DataType> incube, // 8 planes, 32 rows/plane
+        const size_t target_num_planes, // 2
+        DataType *__restrict__ swap,
+        DataType *__restrict__ temp,
+        DataType *__restrict__ out) // 2 planes, 256 rows/plane
+    {
+        if (incube.planes <= target_num_planes)
+        {
+            return incube;
+        }
+        const size_t merge_factor = std::min(
+            small_transform_num_rows<DataType>(incube.cols),
+            incube.planes / target_num_planes); // 4
+
+        // First obtain a cube whose number of planes is 'merge_factor' times
+        // larger than the target
+        // NOTE: use 'out' as the intermediate storage for the recursion level below
+        TransformCube<DataType> midcube = transform_until(incube, target_num_planes * merge_factor, swap, out, temp);
+
+        // Prepare output cube view with adequate dimensions
+        TransformCube<DataType> outcube = TransformCube(out, target_num_planes, midcube.rows * merge_factor, midcube.cols);
+
+        // Group planes of 'midcube' by groups of 'merge_factor' planes
+        // In other words, split 'midcube' into 'merge_factor' sub-cubes
+        // Each sub-cube can be directly transformed into an output plane
+        for (size_t i = 0; i < target_num_planes; ++i)
+        {
+            TransformCube<DataType> sub_midcube = midcube.getSubCube(i * merge_factor, merge_factor);
+
+            for (size_t j = 0; j < sub_midcube.rows; ++j)
+            {
+                transform_vertical_slice(
+                    sub_midcube.getVerticalSlice(j),
+                    swap,
+                    outcube.getSubPlane(i, j * merge_factor, merge_factor).data);
+            }
+        }
+        return outcube;
+    }
+
+    template <typename DataType>
+    void transform(
+        DataType *__restrict__ data,
+        const size_t total_rows,
+        const size_t cols,
+        DataType *__restrict__ swap,
+        DataType *__restrict__ temp,
+        DataType *__restrict__ out)
+    {
+        transform_until(
+            TransformCube<DataType>(data, total_rows, 1, cols),
+            1,
+            swap,
+            temp,
+            out);
+    }
+
+} // namespace riptide
+
+#endif // TRANSFORMS_ADVANCED_HPP

riptide_ffa-0.2.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{riptide-ffa-0.2.4 → riptide_ffa-0.2.6}/setup.py

@@ -3,6 +3,22 @@ from setuptools import setup
 # Available at setup time due to pyproject.toml
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
+# WARNING: Enabling -freciprocal-math (which is also enabled by
+# -funsafe-math-optimizations or -ffast-math) causes surprising inconsistencies
+# when calculating the size of the output periodogram, and the size of the
+# buffers to store data downsampled by a real-valued factor.
+# In turn, this can cause segmentation faults (code attempts to write past the
+# end of these arrays).
+# The flags below provide the same speedups as -ffast-math, without the risks.
+SAFE_FAST_MATH_FLAGS = [
+    "-fassociative-math",
+    "-fno-math-errno",
+    "-ffinite-math-only",
+    "-fno-rounding-math",
+    "-fno-signed-zeros",
+    "-fno-trapping-math",
+]
+
 # The main interface is through Pybind11Extension.
 # * You can add cxx_std=11/14/17, and then build_ext can be removed.
 # * You can set include_pybind11=false to add the include directory yourself,
@@ -13,9 +29,9 @@ from pybind11.setup_helpers import Pybind11Extension, build_ext
 #   reproducible builds (https://github.com/pybind/python_example/pull/53)
 ext_modules = [
     Pybind11Extension(
-        'riptide.libcpp',
-        sorted(['riptide/cpp/python_bindings.cpp']),
-        extra_compile_args=['-O3', '-ffast-math', '-march=native']
+        "riptide.libcpp",
+        sorted(["src/riptide/cpp/python_bindings.cpp"]),
+        extra_compile_args=["-O3", "-march=native"] + SAFE_FAST_MATH_FLAGS,
     ),
 ]