rtide-optimizer 1.0.0__py3-none-any.whl

RTIDE/__init__.py

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

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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,7 @@
+RTIDE/__init__.py,sha256=v_LuPRyAgPLUbfG3qW4vEfyf_ZldTMUuty_id2c8T5c,52
+RTIDE/optimizer.py,sha256=PAm4k2BeQmiHiWnNMzaKMb2ypSty0G-T_sCv9L6op24,9428
+rtide_optimizer-1.0.0.dist-info/licenses/LICENSE,sha256=cN3NcGe-TVaYqib8P29hN1v1OxGOERIsA8CwBVcn9TY,1067
+rtide_optimizer-1.0.0.dist-info/METADATA,sha256=B38EqMcuJ65_6xuGBMTKh2ahCyiA86OO_9fLcbgN6ec,9097
+rtide_optimizer-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+rtide_optimizer-1.0.0.dist-info/top_level.txt,sha256=EJJZskk3sFcik0oLGyoeh5_KpUTQEXMqfMx0JLpY96g,6
+rtide_optimizer-1.0.0.dist-info/RECORD,,

rtide_optimizer-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rtide_optimizer-1.0.0.dist-info/licenses/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.dist-info/top_level.txt

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