rtide-optimizer 1.0.0__tar.gz

rtide_optimizer-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Emine Ayaz
+
+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.

rtide_optimizer-1.0.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: rtide-optimizer
+Version: 1.0.0
+Summary: RTI-DE: Rejected-Trial Interpolation Differential Evolution for box-constrained continuous minimisation
+Author: Emine Ayaz
+License-Expression: MIT
+Project-URL: Repository, https://github.com/ayazemine/rti-de
+Keywords: differential evolution,evolutionary algorithm,metaheuristic,global optimization,black-box optimization
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.17
+Dynamic: license-file
+
+# RTI-DE: Rejected-Trial Interpolation Differential Evolution
+
+RTI-DE is a differential evolution (DE) variant for the minimisation of a black-box function over a
+box `[lb, ub]` within a fixed budget of function evaluations. Unlike classic DE, it does not discard
+the evaluation of a rejected trial point. Late in the run (by default after 70 % of the budget), an
+agent whose trial point was rejected evaluates the half step along the same displacement. If that
+is rejected as well, it evaluates the minimiser of the parabola through the three values known on
+that line (the *rejected-trial chain*). The other components come from established DE variants:
+
+- DE/current-to-pbest/1 mutation (JADE) without the external archive, with midpoint bound repair;
+- binomial crossover with a fixed rate CR = 0.9;
+- step factor F ~ N(mu_F, 0.15) clipped to [0.05, 1], where mu_F is adapted from the successful
+  trial points (weighted Lehmer mean);
+- linear population size reduction from 18 D to 4 agents (L-SHADE).
+
+The complete rules are in the docstring of `python/RTIDE/optimizer.py` and in Section 3 of the paper.
+
+This repository contains:
+
+```
+python/RTIDE/        the Python package (import name RTIDE, distribution name rtide-optimizer)
+matlab/              MATLAB / GNU Octave port (rti_de.m), example and verification against Python
+tests/               unit tests of the algorithm (Python)
+experiments/         code of the experiments of the paper (benchmarks, engineering applications,
+                     experiment runner, table and figure scripts, their tests)
+```
+
+## Publishing to PyPI
+
+Releases are built and published from GitHub tags using PyPI Trusted Publishing. To enable the
+first release, sign in to PyPI as `emineayaz` and add a pending publisher at
+<https://pypi.org/manage/account/publishing/> with these values:
+
+- PyPI project name: `rtide-optimizer`
+- GitHub owner: `ayazemine`
+- GitHub repository: `rti-de`
+- Workflow: `publish.yml`
+- GitHub environment: `pypi`
+
+Create the `pypi` environment in the GitHub repository settings and require a reviewer before
+publishing. The pending publisher does not reserve the project name until its first successful
+upload.
+
+For each release, update `version` in `pyproject.toml`, create a matching `v<version>` tag, and
+push it to GitHub. For example, the current `1.0.0` version can be published with:
+
+```bash
+git tag v1.0.0
+git push origin v1.0.0
+```
+
+The workflow builds and checks the distributions before publishing them to PyPI.
+
+## Installation (Python)
+
+The only dependency is NumPy; the code was tested with Python 3.11.9 and NumPy 1.26.0.
+
+```bash
+pip install rtide-optimizer   # from PyPI
+pip install .                 # from a clone of this repository
+```
+
+## Usage (Python)
+
+```python
+import numpy as np
+from RTIDE import rti_de
+
+def rastrigin(X):                      # vectorised: (k, D) array -> k values
+    return 10 * X.shape[1] + np.sum(X**2 - 10 * np.cos(2 * np.pi * X), axis=1)
+
+D = 10
+lb, ub = np.full(D, -5.12), np.full(D, 5.12)
+x_best, f_best, fes = rti_de(rastrigin, lb, ub, max_fes=50_000, seed=1)
+```
+
+Optional arguments (defaults): `n_init=None` (18 D), `n_min=4`, `p=0.11`, `chain=2`,
+`chain_from=0.7`, `CR=0.9` (`None`: no crossover), `lpsr=True`, `adapt=True`, and `trace=None`
+(a list that receives one record per generation). A NaN objective value is treated as +inf. The
+function returns `(x_best, f_best, evaluations_used)`.
+
+## Usage (MATLAB / GNU Octave)
+
+```matlab
+addpath('matlab')
+rastrigin = @(X) 10 * size(X, 2) + sum(X .^ 2 - 10 * cos(2 * pi * X), 2);   % one point per row
+D = 10;
+[x_best, f_best, fes] = rti_de(rastrigin, -5.12 * ones(1, D), 5.12 * ones(1, D), 50000, 1);
+[x_best, f_best, fes, trace] = rti_de(rastrigin, -5.12 * ones(1, D), 5.12 * ones(1, D), 50000, 1, ...
+                                      'chain_from', 0.5, 'CR', 0.9);
+```
+
+`rti_de.m` takes the same options as name-value pairs (or a struct) and also needs `rtide_rules.m`.
+See `matlab/example_rti_de.m`. MATLAB R2016b or later is required (implicit expansion). Because the
+two languages use different random number generators, a MATLAB run with a given seed differs from
+the Python run with that seed. With the same random numbers, the two implementations give
+bit-identical runs. `matlab/VERIFICATION.md` reports this check (GNU Octave 11.3.0).
+
+## Tests
+
+```bash
+python -m unittest discover -s tests -v                    # algorithm; also imports DE and L-SHADE from experiments/
+cd experiments && python -W ignore -m unittest discover -s tests -v
+```
+
+Install `experiments/requirements-experiments.txt` first. The CEC tests compile the official C
+code with `g++` on first use (into `experiments/benchmarks/official_cec/_build/`). The reference-run
+test in `tests/test_rtide.py` compares a stored CEC2017 result bit-exactly on Windows (MinGW build)
+and with a relative tolerance of 1e-3 elsewhere.
+
+MATLAB/Octave verification (from `matlab/verification/`):
+
+```bash
+python verify_rtide.py prepare
+octave-cli --no-gui --quiet --eval "run_octave_checks"
+python verify_rtide.py compare          # writes output/summary.json and ../VERIFICATION.md
+```
+
+## Reproducing the experiments of the paper
+
+All commands are run from `experiments/` in a Python 3.11 environment:
+
+```bash
+cd experiments
+pip install -r requirements-experiments.txt
+python benchmarks/cec_official_functions.py        # builds and checks the official CEC libraries (g++)
+
+# CEC2022 (D = 20) and CEC2017 (D = 100): 7 algorithms, 30 runs, 1,000,000 evaluations
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31
+
+# engineering problems (composite laminate, with and without contiguity constraint; UAV path planning)
+python -W ignore run_experiments.py --suites composite composite_contiguity uav --runs 30 --workers 31
+
+# ablation (6 variants) and parameter sensitivity (8 variants)
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31 --algorithms RTI-DE-noChain RTI-DE-halfStep RTI-DE-chainAlways RTI-DE-noLPSR RTI-DE-fixedF RTI-DE-noCR --out results_cache/paper_ablation
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31 --algorithms RTI-DE-cf50 RTI-DE-cf90 RTI-DE-p05 RTI-DE-p20 RTI-DE-n10D RTI-DE-n25D RTI-DE-cr70 RTI-DE-cr95 --out results_cache/paper_sensitivity
+
+# tables and figures (written to experiments/outputs/)
+python -W ignore scripts/make_tables.py
+python -W ignore scripts/make_figures.py
+```
+
+- `--dry-run` lists the work and a rough duration without running anything.
+- An interrupted command can be restarted; finished runs are skipped.
+- `--workers` should be at most the number of cores minus one.
+- The runner refuses to continue a result directory if `python/RTIDE/optimizer.py` or the
+  reference implementations in `experiments/benchmarks/` have changed (SHA-256 recorded in
+  `config.json`).
+- `experiments/applications/composite/exhaustive_search.py` recomputes the exact reference optima of
+  the laminate problems (`reference_optimum.json`).
+- `experiments/scripts/supplementary_stats.py` computes supplementary statistics (seed-paired Wilcoxon
+  tests, rank-sum tests with a tie tolerance, Holm adjustment over a suite) from the generated
+  tables and from the `run_log.txt` and `summary.csv` files of `run_experiments.py`, copied to
+  `experiments/results_summary/<set>/`.
+
+The values of all tables of the paper, at full precision, are in `experiments/results_tables/`
+(one CSV file per table; the README there maps the files to the table numbers). The raw results of
+the individual runs are not included in this repository. The problems are described in
+`experiments/applications/README.md` and the CEC code in
+`experiments/benchmarks/official_cec/README.md`.
+
+## License and citation
+
+The RTI-DE code is released under the MIT License (`LICENSE`). If you use RTI-DE in research, please
+cite the paper:
+
+> E. Ayaz, "Rejected-Trial Interpolation Differential Evolution with Applications to Composite
+> Laminate Design and UAV Path Planning."
+
+Citation metadata: `CITATION.cff`.
+
+The official CEC 2017/2022 test-function code in `experiments/benchmarks/official_cec/` and the SPSO
+terrain data in `experiments/applications/uav/data/` are third-party material under their own
+terms; see `NOTICE.md`.

rtide_optimizer-1.0.0/README.md

@@ -0,0 +1,174 @@
+# RTI-DE: Rejected-Trial Interpolation Differential Evolution
+
+RTI-DE is a differential evolution (DE) variant for the minimisation of a black-box function over a
+box `[lb, ub]` within a fixed budget of function evaluations. Unlike classic DE, it does not discard
+the evaluation of a rejected trial point. Late in the run (by default after 70 % of the budget), an
+agent whose trial point was rejected evaluates the half step along the same displacement. If that
+is rejected as well, it evaluates the minimiser of the parabola through the three values known on
+that line (the *rejected-trial chain*). The other components come from established DE variants:
+
+- DE/current-to-pbest/1 mutation (JADE) without the external archive, with midpoint bound repair;
+- binomial crossover with a fixed rate CR = 0.9;
+- step factor F ~ N(mu_F, 0.15) clipped to [0.05, 1], where mu_F is adapted from the successful
+  trial points (weighted Lehmer mean);
+- linear population size reduction from 18 D to 4 agents (L-SHADE).
+
+The complete rules are in the docstring of `python/RTIDE/optimizer.py` and in Section 3 of the paper.
+
+This repository contains:
+
+```
+python/RTIDE/        the Python package (import name RTIDE, distribution name rtide-optimizer)
+matlab/              MATLAB / GNU Octave port (rti_de.m), example and verification against Python
+tests/               unit tests of the algorithm (Python)
+experiments/         code of the experiments of the paper (benchmarks, engineering applications,
+                     experiment runner, table and figure scripts, their tests)
+```
+
+## Publishing to PyPI
+
+Releases are built and published from GitHub tags using PyPI Trusted Publishing. To enable the
+first release, sign in to PyPI as `emineayaz` and add a pending publisher at
+<https://pypi.org/manage/account/publishing/> with these values:
+
+- PyPI project name: `rtide-optimizer`
+- GitHub owner: `ayazemine`
+- GitHub repository: `rti-de`
+- Workflow: `publish.yml`
+- GitHub environment: `pypi`
+
+Create the `pypi` environment in the GitHub repository settings and require a reviewer before
+publishing. The pending publisher does not reserve the project name until its first successful
+upload.
+
+For each release, update `version` in `pyproject.toml`, create a matching `v<version>` tag, and
+push it to GitHub. For example, the current `1.0.0` version can be published with:
+
+```bash
+git tag v1.0.0
+git push origin v1.0.0
+```
+
+The workflow builds and checks the distributions before publishing them to PyPI.
+
+## Installation (Python)
+
+The only dependency is NumPy; the code was tested with Python 3.11.9 and NumPy 1.26.0.
+
+```bash
+pip install rtide-optimizer   # from PyPI
+pip install .                 # from a clone of this repository
+```
+
+## Usage (Python)
+
+```python
+import numpy as np
+from RTIDE import rti_de
+
+def rastrigin(X):                      # vectorised: (k, D) array -> k values
+    return 10 * X.shape[1] + np.sum(X**2 - 10 * np.cos(2 * np.pi * X), axis=1)
+
+D = 10
+lb, ub = np.full(D, -5.12), np.full(D, 5.12)
+x_best, f_best, fes = rti_de(rastrigin, lb, ub, max_fes=50_000, seed=1)
+```
+
+Optional arguments (defaults): `n_init=None` (18 D), `n_min=4`, `p=0.11`, `chain=2`,
+`chain_from=0.7`, `CR=0.9` (`None`: no crossover), `lpsr=True`, `adapt=True`, and `trace=None`
+(a list that receives one record per generation). A NaN objective value is treated as +inf. The
+function returns `(x_best, f_best, evaluations_used)`.
+
+## Usage (MATLAB / GNU Octave)
+
+```matlab
+addpath('matlab')
+rastrigin = @(X) 10 * size(X, 2) + sum(X .^ 2 - 10 * cos(2 * pi * X), 2);   % one point per row
+D = 10;
+[x_best, f_best, fes] = rti_de(rastrigin, -5.12 * ones(1, D), 5.12 * ones(1, D), 50000, 1);
+[x_best, f_best, fes, trace] = rti_de(rastrigin, -5.12 * ones(1, D), 5.12 * ones(1, D), 50000, 1, ...
+                                      'chain_from', 0.5, 'CR', 0.9);
+```
+
+`rti_de.m` takes the same options as name-value pairs (or a struct) and also needs `rtide_rules.m`.
+See `matlab/example_rti_de.m`. MATLAB R2016b or later is required (implicit expansion). Because the
+two languages use different random number generators, a MATLAB run with a given seed differs from
+the Python run with that seed. With the same random numbers, the two implementations give
+bit-identical runs. `matlab/VERIFICATION.md` reports this check (GNU Octave 11.3.0).
+
+## Tests
+
+```bash
+python -m unittest discover -s tests -v                    # algorithm; also imports DE and L-SHADE from experiments/
+cd experiments && python -W ignore -m unittest discover -s tests -v
+```
+
+Install `experiments/requirements-experiments.txt` first. The CEC tests compile the official C
+code with `g++` on first use (into `experiments/benchmarks/official_cec/_build/`). The reference-run
+test in `tests/test_rtide.py` compares a stored CEC2017 result bit-exactly on Windows (MinGW build)
+and with a relative tolerance of 1e-3 elsewhere.
+
+MATLAB/Octave verification (from `matlab/verification/`):
+
+```bash
+python verify_rtide.py prepare
+octave-cli --no-gui --quiet --eval "run_octave_checks"
+python verify_rtide.py compare          # writes output/summary.json and ../VERIFICATION.md
+```
+
+## Reproducing the experiments of the paper
+
+All commands are run from `experiments/` in a Python 3.11 environment:
+
+```bash
+cd experiments
+pip install -r requirements-experiments.txt
+python benchmarks/cec_official_functions.py        # builds and checks the official CEC libraries (g++)
+
+# CEC2022 (D = 20) and CEC2017 (D = 100): 7 algorithms, 30 runs, 1,000,000 evaluations
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31
+
+# engineering problems (composite laminate, with and without contiguity constraint; UAV path planning)
+python -W ignore run_experiments.py --suites composite composite_contiguity uav --runs 30 --workers 31
+
+# ablation (6 variants) and parameter sensitivity (8 variants)
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31 --algorithms RTI-DE-noChain RTI-DE-halfStep RTI-DE-chainAlways RTI-DE-noLPSR RTI-DE-fixedF RTI-DE-noCR --out results_cache/paper_ablation
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31 --algorithms RTI-DE-cf50 RTI-DE-cf90 RTI-DE-p05 RTI-DE-p20 RTI-DE-n10D RTI-DE-n25D RTI-DE-cr70 RTI-DE-cr95 --out results_cache/paper_sensitivity
+
+# tables and figures (written to experiments/outputs/)
+python -W ignore scripts/make_tables.py
+python -W ignore scripts/make_figures.py
+```
+
+- `--dry-run` lists the work and a rough duration without running anything.
+- An interrupted command can be restarted; finished runs are skipped.
+- `--workers` should be at most the number of cores minus one.
+- The runner refuses to continue a result directory if `python/RTIDE/optimizer.py` or the
+  reference implementations in `experiments/benchmarks/` have changed (SHA-256 recorded in
+  `config.json`).
+- `experiments/applications/composite/exhaustive_search.py` recomputes the exact reference optima of
+  the laminate problems (`reference_optimum.json`).
+- `experiments/scripts/supplementary_stats.py` computes supplementary statistics (seed-paired Wilcoxon
+  tests, rank-sum tests with a tie tolerance, Holm adjustment over a suite) from the generated
+  tables and from the `run_log.txt` and `summary.csv` files of `run_experiments.py`, copied to
+  `experiments/results_summary/<set>/`.
+
+The values of all tables of the paper, at full precision, are in `experiments/results_tables/`
+(one CSV file per table; the README there maps the files to the table numbers). The raw results of
+the individual runs are not included in this repository. The problems are described in
+`experiments/applications/README.md` and the CEC code in
+`experiments/benchmarks/official_cec/README.md`.
+
+## License and citation
+
+The RTI-DE code is released under the MIT License (`LICENSE`). If you use RTI-DE in research, please
+cite the paper:
+
+> E. Ayaz, "Rejected-Trial Interpolation Differential Evolution with Applications to Composite
+> Laminate Design and UAV Path Planning."
+
+Citation metadata: `CITATION.cff`.
+
+The official CEC 2017/2022 test-function code in `experiments/benchmarks/official_cec/` and the SPSO
+terrain data in `experiments/applications/uav/data/` are third-party material under their own
+terms; see `NOTICE.md`.

rtide_optimizer-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rtide-optimizer"
+version = "1.0.0"
+description = "RTI-DE: Rejected-Trial Interpolation Differential Evolution for box-constrained continuous minimisation"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Emine Ayaz" }]
+requires-python = ">=3.9"
+dependencies = ["numpy>=1.17"]
+keywords = ["differential evolution", "evolutionary algorithm", "metaheuristic", "global optimization", "black-box optimization"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.urls]
+Repository = "https://github.com/ayazemine/rti-de"
+
+[tool.setuptools]
+package-dir = { "" = "python" }
+packages = ["RTIDE"]

rtide_optimizer-1.0.0/python/RTIDE/__init__.py

@@ -0,0 +1,3 @@
+from .optimizer import rti_de
+
+__all__ = ["rti_de"]

rtide_optimizer-1.0.0/python/RTIDE/optimizer.py

@@ -0,0 +1,189 @@
+"""
+RTI-DE: Rejected-Trial Interpolation Differential Evolution.
+
+A differential evolution variant in which the evaluation of a rejected trial point is used
+instead of being discarded.
+
+Components
+----------
+1. Trial point
+       v = x + F (x_e - x) + F (x_r1 - x_r2),
+   x_e drawn from the best p N agents, r1 != r2 != i: the DE/current-to-pbest/1 mutation of JADE
+   (Zhang and Sanderson, 2009) without the external archive, followed by the binomial crossover
+   of classic DE (Storn and Price, 1997) with the fixed rate CR: component j of the trial point
+   is v_j with probability CR and for one random j, and x_j otherwise. The displacement is
+   d = trial point - x.
+2. Selection: v replaces x when f(v) <= f(x).
+3. Rejected-trial chain, used after the fraction ``chain_from`` of the evaluation budget.
+   An agent whose trial point was rejected does not draw a new displacement at once:
+       second point   x + d / 2
+       third point    x + t* d, t* the minimiser of the parabola through the three collinear
+                      points x, x + d / 2, x + d, limited to [-1, 1]; t* = -1/2 when the parabola
+                      is not convex. The point is skipped when t* is closer than 0.02 to a point
+                      already evaluated (0, 1/2 or 1).
+   An accepted point ends the chain; after the third point a new displacement is drawn.
+4. Step factor: F ~ N(mu_F, 0.15) clipped to [0.05, 1], mu_F = 0.5 at the start. After a
+   generation in which first trial points were accepted,
+       mu_F <- 0.9 mu_F + 0.1 L,   L = sum(w F^2) / sum(w F),
+   over the accepted first trial points, w proportional to the improvement (the adaptation rule
+   of JADE with the improvement weights of SHADE; points of the chain do not enter).
+5. Population size: reduced linearly in the evaluations used from n_init to n_min, the worst
+   agents being removed (linear population size reduction of L-SHADE, Tanabe and Fukunaga, 2014).
+
+Bounds: a component of v outside the box is set to the midpoint between the bound and x (before
+the crossover), and d is the displacement actually made; the third point is clipped to the box.
+
+CR = 0.9 was chosen on a development setting (CEC2017, D = 30, 300,000 evaluations, seeds 0-4,
+among 0.5, 0.7, 0.9 and no crossover) and confirmed on seeds 5-14 on 2026-10-10.
+"""
+
+import numpy as np
+
+
+def rti_de(func, lb, ub, max_fes, seed=None, n_init=None, n_min=4, p=0.11, chain=2, chain_from=0.7,
+           CR=0.9, lpsr=True, adapt=True, trace=None):
+    """Minimise ``func`` (vectorised: (k, D) array -> k values) within ``max_fes`` evaluations.
+
+    n_init      initial population size (default 18 D)
+    n_min       final population size
+    p           fraction of the population from which x_e is drawn
+    chain       points of the rejected-trial chain: 2 (half step and parabola), 1 (half step
+                only) or 0 (no chain); values below 2 are for the ablation
+    chain_from  fraction of the budget after which the chain is used
+    CR          rate of the binomial crossover (None: no crossover; for the ablation)
+
+    Switches for the ablation (the algorithm is the default):
+    lpsr        False: the population keeps its initial size
+    adapt       False: mu_F stays at 0.5
+
+    trace       None, or a list to which one dict is appended per generation (the run itself is
+                not changed: no random number is drawn and nothing is evaluated for the trace):
+                  fes, n, mu_F, f_best     evaluations used, population size, mean step factor and
+                                           best value after the generation (n before the reduction)
+                  evaluated, accepted,     candidates of the generation by stage [first trial point,
+                  improved                 half step, parabola point]: evaluated, accepted
+                                           (f <= f of the agent), strictly better
+                  skipped                  third points left out by the skip rule
+                  theta, theta_accepted    factor t* of every third point evaluated and whether it
+                                           was accepted
+                The list is filled as the run goes, so it is valid when ``func`` ends the run early.
+
+    Returns (x_best, f_best, evaluations used)."""
+    rng = np.random.default_rng(seed)
+    lb, ub = np.asarray(lb, float), np.asarray(ub, float)
+    dim = lb.size
+    n_init = int(n_init or 18 * dim)
+    n = n_init
+
+    def evaluate(X):
+        f = np.asarray(func(X), dtype=float)
+        return np.where(np.isnan(f), np.inf, f)
+
+    X = rng.uniform(lb, ub, (n, dim))
+    fit = evaluate(X)
+    fes = n
+    mu_F = 0.5
+    stage = np.zeros(n, dtype=int)               # 0: first trial point, 1: half step, 2: parabola
+    D = np.zeros((n, dim))                       # displacement of the running chain
+    T = np.ones(n)                               # factor of d in the current candidate
+    F = np.full(n, 0.5)                          # step factor with which d was drawn
+    f_one, f_half = np.zeros(n), np.zeros(n)     # values at x + d and x + d / 2
+
+    while fes < max_fes:
+        # --- third point: minimiser of the parabola through (0, fit), (1/2, f_half), (1, f_one)
+        s2 = np.nonzero(stage == 2)[0]
+        n_skip = 0
+        if s2.size:
+            d_one, d_half = f_one[s2] - fit[s2], f_half[s2] - fit[s2]
+            with np.errstate(all="ignore"):
+                beta = (d_half - 0.5 * d_one) / -0.25
+                t = -(d_one - beta) / (2.0 * beta)
+            t = np.where(np.isfinite(t) & (beta > 0), t, -0.5)
+            ok = np.isfinite(d_one) & np.isfinite(d_half)
+            t = np.clip(np.where(ok, t, 0.0), -1.0, 1.0)
+            ok &= (np.abs(t) >= 0.02) & (np.abs(t - 0.5) >= 0.02) & (np.abs(t - 1.0) >= 0.02)
+            T[s2[ok]] = t[ok]
+            stage[s2[~ok]] = 0
+            n_skip = int((~ok).sum())
+
+        # --- second point: half step
+        T[stage == 1] = 0.5
+
+        # --- first trial point: new displacement
+        s0 = np.nonzero(stage == 0)[0]
+        if s0.size:
+            k = s0.size
+            order = np.argsort(fit, kind="stable")
+            elite = X[order[rng.integers(max(2, int(round(p * n))), size=k)]]
+            f = np.clip(rng.normal(mu_F, 0.15, k), 0.05, 1.0)
+            r1 = rng.integers(n - 1, size=k)
+            r1 += r1 >= s0
+            r2 = rng.integers(n, size=k)
+            while True:
+                bad = (r2 == s0) | (r2 == r1)
+                if not bad.any():
+                    break
+                r2[bad] = rng.integers(n, size=int(bad.sum()))
+            V = X[s0] + f[:, None] * (elite - X[s0]) + f[:, None] * (X[r1] - X[r2])
+            V = np.where(V < lb, (lb + X[s0]) / 2.0, V)
+            V = np.where(V > ub, (ub + X[s0]) / 2.0, V)
+            if CR is not None:
+                cross = rng.random((k, dim)) < CR
+                cross[np.arange(k), rng.integers(dim, size=k)] = True
+                V = np.where(cross, V, X[s0])
+            D[s0], F[s0], T[s0] = V - X[s0], f, 1.0
+
+        U = np.clip(X + T[:, None] * D, lb, ub)
+        k = min(n, max_fes - fes)                # the last generation is cut at the budget
+        f_new = np.full(n, np.inf)
+        f_new[:k] = evaluate(U[:k])
+        fes += k
+
+        better = f_new < fit
+        accept = f_new <= fit
+        accept[k:] = False
+
+        # --- step factor: accepted first trial points only
+        counted = better & (stage == 0)
+        if adapt and counted.any():
+            gain = fit[counted] - f_new[counted]
+            gain = np.where(np.isfinite(gain), gain, 0.0)
+            w = gain / gain.sum() if gain.sum() > 0 else np.full(gain.size, 1.0 / gain.size)
+            s_f = F[counted] * np.abs(T[counted])
+            den = np.sum(w * s_f)
+            lehmer = np.sum(w * s_f ** 2) / den if den > 0 else 0.0
+            mu_F = float(np.clip(0.9 * mu_F + 0.1 * lehmer, 0.05, 1.0))
+
+        if trace is not None:
+            done = np.arange(n) < k
+            by_stage = [done & (stage == s) for s in (0, 1, 2)]
+            trace.append(dict(
+                fes=fes, n=n, mu_F=mu_F, f_best=float(min(fit.min(), f_new[:k].min())),
+                evaluated=[int(m.sum()) for m in by_stage],
+                accepted=[int((m & accept).sum()) for m in by_stage],
+                improved=[int((m & better).sum()) for m in by_stage],
+                skipped=n_skip, theta=T[by_stage[2]].copy(), theta_accepted=accept[by_stage[2]].copy()))
+
+        # --- selection and next stage of the chain
+        rejected = ~accept
+        rejected[k:] = False
+        f_one = np.where(rejected & (stage == 0), f_new, f_one)
+        f_half = np.where(rejected & (stage == 1), f_new, f_half)
+        X[accept], fit[accept] = U[accept], f_new[accept]
+        nxt = np.where(rejected, stage + 1, 0)
+        nxt[nxt > chain] = 0
+        if fes < chain_from * max_fes:
+            nxt[:] = 0
+        nxt[k:] = stage[k:]
+        stage = nxt
+
+        # --- linear population size reduction
+        n_next = max(n_min, int(round((n_min - n_init) / max_fes * fes + n_init))) if lpsr else n
+        if n_next < n:
+            keep = np.argsort(fit, kind="stable")[:n_next]
+            X, fit, stage, D, T, F = X[keep], fit[keep], stage[keep], D[keep], T[keep], F[keep]
+            f_one, f_half = f_one[keep], f_half[keep]
+            n = n_next
+
+    best = int(np.argmin(fit))
+    return X[best].copy(), float(fit[best]), fes

rtide_optimizer-1.0.0/python/rtide_optimizer.egg-info/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: rtide-optimizer
+Version: 1.0.0
+Summary: RTI-DE: Rejected-Trial Interpolation Differential Evolution for box-constrained continuous minimisation
+Author: Emine Ayaz
+License-Expression: MIT
+Project-URL: Repository, https://github.com/ayazemine/rti-de
+Keywords: differential evolution,evolutionary algorithm,metaheuristic,global optimization,black-box optimization
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.17
+Dynamic: license-file
+
+# RTI-DE: Rejected-Trial Interpolation Differential Evolution
+
+RTI-DE is a differential evolution (DE) variant for the minimisation of a black-box function over a
+box `[lb, ub]` within a fixed budget of function evaluations. Unlike classic DE, it does not discard
+the evaluation of a rejected trial point. Late in the run (by default after 70 % of the budget), an
+agent whose trial point was rejected evaluates the half step along the same displacement. If that
+is rejected as well, it evaluates the minimiser of the parabola through the three values known on
+that line (the *rejected-trial chain*). The other components come from established DE variants:
+
+- DE/current-to-pbest/1 mutation (JADE) without the external archive, with midpoint bound repair;
+- binomial crossover with a fixed rate CR = 0.9;
+- step factor F ~ N(mu_F, 0.15) clipped to [0.05, 1], where mu_F is adapted from the successful
+  trial points (weighted Lehmer mean);
+- linear population size reduction from 18 D to 4 agents (L-SHADE).
+
+The complete rules are in the docstring of `python/RTIDE/optimizer.py` and in Section 3 of the paper.
+
+This repository contains:
+
+```
+python/RTIDE/        the Python package (import name RTIDE, distribution name rtide-optimizer)
+matlab/              MATLAB / GNU Octave port (rti_de.m), example and verification against Python
+tests/               unit tests of the algorithm (Python)
+experiments/         code of the experiments of the paper (benchmarks, engineering applications,
+                     experiment runner, table and figure scripts, their tests)
+```
+
+## Publishing to PyPI
+
+Releases are built and published from GitHub tags using PyPI Trusted Publishing. To enable the
+first release, sign in to PyPI as `emineayaz` and add a pending publisher at
+<https://pypi.org/manage/account/publishing/> with these values:
+
+- PyPI project name: `rtide-optimizer`
+- GitHub owner: `ayazemine`
+- GitHub repository: `rti-de`
+- Workflow: `publish.yml`
+- GitHub environment: `pypi`
+
+Create the `pypi` environment in the GitHub repository settings and require a reviewer before
+publishing. The pending publisher does not reserve the project name until its first successful
+upload.
+
+For each release, update `version` in `pyproject.toml`, create a matching `v<version>` tag, and
+push it to GitHub. For example, the current `1.0.0` version can be published with:
+
+```bash
+git tag v1.0.0
+git push origin v1.0.0
+```
+
+The workflow builds and checks the distributions before publishing them to PyPI.
+
+## Installation (Python)
+
+The only dependency is NumPy; the code was tested with Python 3.11.9 and NumPy 1.26.0.
+
+```bash
+pip install rtide-optimizer   # from PyPI
+pip install .                 # from a clone of this repository
+```
+
+## Usage (Python)
+
+```python
+import numpy as np
+from RTIDE import rti_de
+
+def rastrigin(X):                      # vectorised: (k, D) array -> k values
+    return 10 * X.shape[1] + np.sum(X**2 - 10 * np.cos(2 * np.pi * X), axis=1)
+
+D = 10
+lb, ub = np.full(D, -5.12), np.full(D, 5.12)
+x_best, f_best, fes = rti_de(rastrigin, lb, ub, max_fes=50_000, seed=1)
+```
+
+Optional arguments (defaults): `n_init=None` (18 D), `n_min=4`, `p=0.11`, `chain=2`,
+`chain_from=0.7`, `CR=0.9` (`None`: no crossover), `lpsr=True`, `adapt=True`, and `trace=None`
+(a list that receives one record per generation). A NaN objective value is treated as +inf. The
+function returns `(x_best, f_best, evaluations_used)`.
+
+## Usage (MATLAB / GNU Octave)
+
+```matlab
+addpath('matlab')
+rastrigin = @(X) 10 * size(X, 2) + sum(X .^ 2 - 10 * cos(2 * pi * X), 2);   % one point per row
+D = 10;
+[x_best, f_best, fes] = rti_de(rastrigin, -5.12 * ones(1, D), 5.12 * ones(1, D), 50000, 1);
+[x_best, f_best, fes, trace] = rti_de(rastrigin, -5.12 * ones(1, D), 5.12 * ones(1, D), 50000, 1, ...
+                                      'chain_from', 0.5, 'CR', 0.9);
+```
+
+`rti_de.m` takes the same options as name-value pairs (or a struct) and also needs `rtide_rules.m`.
+See `matlab/example_rti_de.m`. MATLAB R2016b or later is required (implicit expansion). Because the
+two languages use different random number generators, a MATLAB run with a given seed differs from
+the Python run with that seed. With the same random numbers, the two implementations give
+bit-identical runs. `matlab/VERIFICATION.md` reports this check (GNU Octave 11.3.0).
+
+## Tests
+
+```bash
+python -m unittest discover -s tests -v                    # algorithm; also imports DE and L-SHADE from experiments/
+cd experiments && python -W ignore -m unittest discover -s tests -v
+```
+
+Install `experiments/requirements-experiments.txt` first. The CEC tests compile the official C
+code with `g++` on first use (into `experiments/benchmarks/official_cec/_build/`). The reference-run
+test in `tests/test_rtide.py` compares a stored CEC2017 result bit-exactly on Windows (MinGW build)
+and with a relative tolerance of 1e-3 elsewhere.
+
+MATLAB/Octave verification (from `matlab/verification/`):
+
+```bash
+python verify_rtide.py prepare
+octave-cli --no-gui --quiet --eval "run_octave_checks"
+python verify_rtide.py compare          # writes output/summary.json and ../VERIFICATION.md
+```
+
+## Reproducing the experiments of the paper
+
+All commands are run from `experiments/` in a Python 3.11 environment:
+
+```bash
+cd experiments
+pip install -r requirements-experiments.txt
+python benchmarks/cec_official_functions.py        # builds and checks the official CEC libraries (g++)
+
+# CEC2022 (D = 20) and CEC2017 (D = 100): 7 algorithms, 30 runs, 1,000,000 evaluations
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31
+
+# engineering problems (composite laminate, with and without contiguity constraint; UAV path planning)
+python -W ignore run_experiments.py --suites composite composite_contiguity uav --runs 30 --workers 31
+
+# ablation (6 variants) and parameter sensitivity (8 variants)
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31 --algorithms RTI-DE-noChain RTI-DE-halfStep RTI-DE-chainAlways RTI-DE-noLPSR RTI-DE-fixedF RTI-DE-noCR --out results_cache/paper_ablation
+python -W ignore run_experiments.py --suites cec2022 cec2017 --budget fe --max-fes 1000000 --runs 30 --workers 31 --algorithms RTI-DE-cf50 RTI-DE-cf90 RTI-DE-p05 RTI-DE-p20 RTI-DE-n10D RTI-DE-n25D RTI-DE-cr70 RTI-DE-cr95 --out results_cache/paper_sensitivity
+
+# tables and figures (written to experiments/outputs/)
+python -W ignore scripts/make_tables.py
+python -W ignore scripts/make_figures.py
+```
+
+- `--dry-run` lists the work and a rough duration without running anything.
+- An interrupted command can be restarted; finished runs are skipped.
+- `--workers` should be at most the number of cores minus one.
+- The runner refuses to continue a result directory if `python/RTIDE/optimizer.py` or the
+  reference implementations in `experiments/benchmarks/` have changed (SHA-256 recorded in
+  `config.json`).
+- `experiments/applications/composite/exhaustive_search.py` recomputes the exact reference optima of
+  the laminate problems (`reference_optimum.json`).
+- `experiments/scripts/supplementary_stats.py` computes supplementary statistics (seed-paired Wilcoxon
+  tests, rank-sum tests with a tie tolerance, Holm adjustment over a suite) from the generated
+  tables and from the `run_log.txt` and `summary.csv` files of `run_experiments.py`, copied to
+  `experiments/results_summary/<set>/`.
+
+The values of all tables of the paper, at full precision, are in `experiments/results_tables/`
+(one CSV file per table; the README there maps the files to the table numbers). The raw results of
+the individual runs are not included in this repository. The problems are described in
+`experiments/applications/README.md` and the CEC code in
+`experiments/benchmarks/official_cec/README.md`.
+
+## License and citation
+
+The RTI-DE code is released under the MIT License (`LICENSE`). If you use RTI-DE in research, please
+cite the paper:
+
+> E. Ayaz, "Rejected-Trial Interpolation Differential Evolution with Applications to Composite
+> Laminate Design and UAV Path Planning."
+
+Citation metadata: `CITATION.cff`.
+
+The official CEC 2017/2022 test-function code in `experiments/benchmarks/official_cec/` and the SPSO
+terrain data in `experiments/applications/uav/data/` are third-party material under their own
+terms; see `NOTICE.md`.

rtide_optimizer-1.0.0/python/rtide_optimizer.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+python/RTIDE/__init__.py
+python/RTIDE/optimizer.py
+python/rtide_optimizer.egg-info/PKG-INFO
+python/rtide_optimizer.egg-info/SOURCES.txt
+python/rtide_optimizer.egg-info/dependency_links.txt
+python/rtide_optimizer.egg-info/requires.txt
+python/rtide_optimizer.egg-info/top_level.txt
+tests/test_rtide.py

rtide_optimizer-1.0.0/python/rtide_optimizer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rtide_optimizer-1.0.0/python/rtide_optimizer.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.17

rtide_optimizer-1.0.0/python/rtide_optimizer.egg-info/top_level.txt

@@ -0,0 +1 @@
+RTIDE

rtide_optimizer-1.0.0/setup.cfg

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

rtide_optimizer-1.0.0/tests/test_rtide.py

@@ -0,0 +1,173 @@
+"""Tests for python/RTIDE/optimizer.py and the reference implementations of DE and L-SHADE."""
+import os
+import sys
+import unittest
+
+import numpy as np
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ROOT = os.path.join(REPO_ROOT, "experiments")                 # run_experiments.py, benchmarks/
+for _p in (os.path.join(REPO_ROOT, "python"), ROOT, os.path.join(ROOT, "benchmarks")):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from RTIDE import rti_de  # noqa: E402
+from de_reference import de  # noqa: E402
+from lshade_reference import lshade  # noqa: E402
+
+
+def _rastrigin(X):
+    return 10 * X.shape[1] + np.sum(X**2 - 10 * np.cos(2 * np.pi * X), axis=1)
+
+
+def _shifted_sphere(X):
+    return 500.0 + np.sum((X - 1.5) ** 2, axis=1)
+
+
+class Counted:
+    def __init__(self, f):
+        self.f, self.n, self.X = f, 0, []
+
+    def __call__(self, X):
+        self.n += X.shape[0]
+        self.X.append(np.array(X))
+        return self.f(X)
+
+
+ALGOS = {"rti_de": rti_de, "de": de, "lshade": lshade}
+
+
+class TestBudgetAndBounds(unittest.TestCase):
+    def test_exact_budget_and_points_inside_the_box(self):
+        lb, ub = np.full(8, -5.0), np.full(8, 5.0)
+        for name, fn in ALGOS.items():
+            for max_fes in (1000, 2357):
+                with self.subTest(algo=name, max_fes=max_fes):
+                    c = Counted(_rastrigin)
+                    x, f, fes = fn(c, lb, ub, max_fes, seed=0)
+                    self.assertEqual((c.n, fes), (max_fes, max_fes))
+                    X = np.vstack(c.X)
+                    self.assertTrue(np.all(X >= lb) and np.all(X <= ub))
+                    self.assertEqual(f, float(_rastrigin(x[None])[0]))
+                    self.assertEqual(f, min(float(_rastrigin(b).min()) for b in c.X))
+
+    def test_same_seed_same_run(self):
+        lb, ub = np.full(6, -5.0), np.full(6, 5.0)
+        for name, fn in ALGOS.items():
+            with self.subTest(algo=name):
+                a, b = fn(_rastrigin, lb, ub, 3000, seed=3), fn(_rastrigin, lb, ub, 3000, seed=3)
+                self.assertTrue(np.array_equal(a[0], b[0]) and a[1] == b[1])
+                self.assertFalse(np.array_equal(a[0], fn(_rastrigin, lb, ub, 3000, seed=4)[0]))
+
+
+class TestRTIDE(unittest.TestCase):
+    lb, ub = np.full(10, -5.0), np.full(10, 5.0)
+
+    def test_converges_on_a_sphere(self):
+        _, f, _ = rti_de(_shifted_sphere, self.lb, self.ub, 20000, seed=0)
+        self.assertLess(f - 500.0, 1e-6)
+
+    def test_chain_is_inactive_before_chain_from(self):
+        """With chain_from = 1 the chain is never used: the run equals the run without chain."""
+        a = rti_de(_rastrigin, self.lb, self.ub, 6000, seed=1, chain_from=1.0)
+        b = rti_de(_rastrigin, self.lb, self.ub, 6000, seed=1, chain=0)
+        self.assertTrue(np.array_equal(a[0], b[0]) and a[1] == b[1])
+
+    def test_chain_changes_the_run(self):
+        full = rti_de(_rastrigin, self.lb, self.ub, 6000, seed=1)
+        for kw in (dict(chain=0), dict(chain=1), dict(chain_from=0.0)):
+            with self.subTest(**kw):
+                self.assertFalse(np.array_equal(full[0], rti_de(_rastrigin, self.lb, self.ub, 6000, seed=1, **kw)[0]))
+
+    def test_switches_change_the_run(self):
+        full = rti_de(_rastrigin, self.lb, self.ub, 6000, seed=1)
+        for kw in (dict(lpsr=False), dict(adapt=False), dict(CR=None), dict(CR=0.5)):
+            with self.subTest(**kw):
+                self.assertFalse(np.array_equal(full[0], rti_de(_rastrigin, self.lb, self.ub, 6000, seed=1, **kw)[0]))
+
+    def test_constant_population_without_lpsr(self):
+        c = Counted(_rastrigin)
+        rti_de(c, self.lb, self.ub, 3000, seed=0, n_init=40, lpsr=False)
+        self.assertEqual({b.shape[0] for b in c.X[:-1]}, {40})
+
+    def test_reference_run(self):
+        """The default algorithm must not change: stored results of two reference runs
+        (CEC2017 F12, D = 30, 300,000 evaluations, seed 8), with CR = 0.9 and without crossover.
+
+        The values were stored on Windows (MinGW build of the CEC library) and are bit-exact only
+        there: the C math library of another platform rounds differently in the last bit, and
+        the run amplifies that. Noise of one ulp on the objective values moved the two results
+        within [2203.875, 2203.897] and [2712.22, 2712.35]; elsewhere the tolerance is 1e-3 relative."""
+        try:
+            sys.path.insert(0, ROOT)
+            import run_experiments as rx
+            obj = rx.load_objective("cec2017", "F12", 30)
+        except Exception as e:                       # CEC library not built
+            self.skipTest(f"CEC2017 functions not available: {e!r}")
+        for kw, ref in ((dict(), 2203.883115060296), (dict(CR=None), 2712.3308479876405)):
+            with self.subTest(**kw):
+                f = rti_de(obj["vec"], obj["lb"], obj["ub"], 300000, seed=8, **kw)[1]
+                if os.name == "nt":
+                    self.assertEqual(f, ref)
+                else:
+                    self.assertAlmostEqual(f, ref, delta=1e-3 * ref)
+
+    def test_trace_does_not_change_the_run_and_is_consistent(self):
+        max_fes, n_init = 6000, 180
+        plain = rti_de(_rastrigin, self.lb, self.ub, max_fes, seed=1)
+        log = []
+        traced = rti_de(_rastrigin, self.lb, self.ub, max_fes, seed=1, trace=log)
+        self.assertTrue(np.array_equal(plain[0], traced[0]) and plain[1] == traced[1])
+        ev = np.array([g["evaluated"] for g in log])
+        acc = np.array([g["accepted"] for g in log])
+        imp = np.array([g["improved"] for g in log])
+        fes = np.array([g["fes"] for g in log])
+        self.assertEqual(int(ev.sum()), max_fes - n_init)            # one candidate per evaluation
+        self.assertTrue(np.array_equal(np.diff(np.r_[n_init, fes]), ev.sum(axis=1)))
+        self.assertEqual(fes[-1], max_fes)
+        self.assertTrue(np.all(imp <= acc) and np.all(acc <= ev))
+        self.assertEqual(log[-1]["f_best"], plain[1])
+        self.assertTrue(np.all(np.diff([g["f_best"] for g in log]) <= 0))
+        # the chain is used only after chain_from of the budget
+        before = fes < 0.7 * max_fes
+        self.assertEqual(int(ev[before][:, 1:].sum()), 0)
+        self.assertGreater(int(ev[:, 1].sum()), 0)
+        self.assertGreater(int(ev[:, 2].sum()), 0)
+        # third points: one factor per evaluated point, all in [-1, 1/4) and not near 0
+        theta = np.concatenate([g["theta"] for g in log])
+        self.assertEqual(theta.size, int(ev[:, 2].sum()))
+        self.assertEqual(int(np.concatenate([g["theta_accepted"] for g in log]).sum()), int(acc[:, 2].sum()))
+        self.assertTrue(np.all(theta >= -1.0) and np.all(theta < 0.25) and np.all(np.abs(theta) >= 0.02))
+        # every half step that is rejected leads to a third point or to a skipped one
+        rejected_half = int((ev[:, 1] - acc[:, 1]).sum())
+        third_or_skipped = int(ev[:, 2].sum()) + sum(g["skipped"] for g in log)
+        self.assertLessEqual(third_or_skipped, rejected_half)        # agents removed by the reduction are lost
+        self.assertGreaterEqual(third_or_skipped, rejected_half - n_init)
+
+    def test_trace_summary_of_the_harness(self):
+        sys.path.insert(0, ROOT)
+        import run_experiments as rx
+        max_fes, log = 6000, []
+        rti_de(_rastrigin, self.lb, self.ub, max_fes, seed=1, trace=log)
+        s = rx.summarize_rtide_trace(log, max_fes, bins=20)
+        for key in ("evaluated", "accepted", "improved"):
+            self.assertTrue(np.array_equal(s[key].sum(axis=0), np.sum([g[key] for g in log], axis=0)), key)
+        self.assertEqual(int(s["generations"].sum()), len(log))
+        self.assertEqual(int(s["skipped"].sum()), sum(g["skipped"] for g in log))
+        self.assertEqual((s["mu_F"][-1], s["n"][-1]), (log[-1]["mu_F"], log[-1]["n"]))
+        self.assertEqual(s["theta_outside"], 0)
+        self.assertEqual(int(s["theta_accepted"].sum() + s["theta_rejected"].sum()),
+                         int(s["evaluated"][:, 2].sum()))
+        self.assertEqual(int(s["evaluated"][:14, 1:].sum()), 0)       # parts that end before 0.7 of the budget
+
+    def test_nan_objective_is_treated_as_infeasible(self):
+        def f(X):
+            v = _rastrigin(X)
+            v[X[:, 0] > 4.0] = np.nan
+            return v
+        x, fx, _ = rti_de(f, self.lb, self.ub, 3000, seed=0)
+        self.assertTrue(np.isfinite(fx) and x[0] <= 4.0)
+
+
+if __name__ == "__main__":
+    unittest.main()