semita 0.1.0__tar.gz

semita-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,112 @@
+name: release
+
+# A published GitHub release, tagged `v` and semita's version, builds every wheel and the sdist and uploads them to
+# PyPI. A pull request builds and checks the same files without uploading them.
+on:
+  pull_request:
+  release:
+    types: [published]
+
+# Every job reads the repository at most; `publish` adds the identity PyPI trusts.
+permissions:
+  contents: read
+
+jobs:
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          # The version is the tag, which setuptools-scm reads from git.
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Build
+        run: uv build --sdist
+
+      - uses: actions/upload-artifact@v6
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  wheels:
+    # Every wheel is built from the sdist, so it carries the sdist's version and needs no git history.
+    needs: sdist
+    name: wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # Each wheel is built and tested on its own architecture: Linux x86_64 and aarch64, Windows AMD64, and macOS
+        # arm64 and x86_64. pyproject.toml's [tool.cibuildwheel] says what is built and how it is tested.
+        os: [ubuntu-latest, ubuntu-24.04-arm, windows-latest, macos-latest, macos-15-intel]
+
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          name: sdist
+          path: sdist
+
+      - name: Find the sdist
+        id: sdist
+        shell: bash
+        run: echo "path=$(ls sdist/semita-*.tar.gz)" >> "$GITHUB_OUTPUT"
+
+      - name: Build and test
+        uses: pypa/cibuildwheel@v4.2.1
+        with:
+          package-dir: ${{ steps.sdist.outputs.path }}
+
+      - uses: actions/upload-artifact@v6
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  check:
+    # What would be uploaded, all of it, and for a release the tag's version. Each wheel has already been audited for
+    # the stable ABI alone, by the audit-command in pyproject.toml.
+    needs: [wheels, sdist]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          path: dist
+          merge-multiple: true
+
+      - name: List the files
+        run: ls -l dist
+
+      - name: The tag is v and a version
+        if: github.event_name == 'release'
+        run: |
+          tag="$GITHUB_REF_NAME"
+          if [[ "$tag" != v* ]]; then
+            echo "A release's tag is v and its version, such as v0.2.0, not $tag"
+            exit 1
+          fi
+          if [ ! -f "dist/semita-${tag#v}.tar.gz" ]; then
+            echo "setuptools-scm did not read $tag as semita's version, and built $(ls dist)"
+            exit 1
+          fi
+
+  publish:
+    if: github.event_name == 'release'
+    needs: check
+    runs-on: ubuntu-latest
+    # PyPI trusts this workflow from this environment alone, so no token is stored anywhere.
+    environment:
+      name: pypi
+      url: https://pypi.org/project/semita/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          path: dist
+          merge-multiple: true
+
+      - name: Upload to PyPI
+        uses: pypa/gh-action-pypi-publish@v1.14.2

semita-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,62 @@
+name: test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.12", "3.13"]
+    env:
+      # The C compiler's warnings fail the build here.
+      SEMITA_WARNINGS_AS_ERRORS: "1"
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install, compiling the extension
+        run: uv sync --python ${{ matrix.python-version }} --extra dev
+
+      - name: Lint
+        run: uv run ruff check .
+
+      - name: Format
+        run: uv run ruff format --check .
+
+      - name: Type check
+        run: uv run pyright
+
+      - name: Test
+        run: uv run pytest -v
+
+  wheel:
+    # One wheel on the stable ABI serves every Python from 3.12; this checks the one built here loads on the newest.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Build
+        run: SEMITA_WARNINGS_AS_ERRORS=1 uv build
+
+      - name: Load the wheel on Python 3.14
+        run: |
+          wheel=$(ls dist/semita-*-cp312-abi3-*.whl)
+          uv run --isolated --no-project --python 3.14 --with "$wheel" python -c \
+            "import numpy, semita; assert semita.find_path(numpy.ones((3, 3), dtype=bool), (0, 0), (2, 2)) is not None"

semita-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*.so
+*.pyd
+*.egg-info/
+# Written by setuptools-scm at build time.
+src/semita/_version.py
+build/
+dist/
+.venv/
+.pytest_cache/
+.ruff_cache/

semita-0.1.0/LICENSE

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

semita-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include csrc/*.c csrc/*.h
+# The release's wheels are built and tested from the sdist.
+graft tests
+global-exclude *.py[cod]

semita-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: semita
+Version: 0.1.0
+Summary: Shortest paths and distances on a grid, in C, for Python
+Author-email: Max Nusspickel <max.nusspickel@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/maxnus/semita
+Keywords: pathfinding,jump point search,dijkstra,grid
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: scipy>=1.14; extra == "dev"
+Requires-Dist: ruff>=0.8; extra == "dev"
+Requires-Dist: pyright>=1.1.390; extra == "dev"
+Requires-Dist: setuptools>=77; extra == "dev"
+Dynamic: license-file
+
+# semita
+
+Shortest and cheapest paths and distances on a grid, in C, for Python: jump point search for one path, A* for one
+where tiles cost differently, and Dijkstra for the cheapest paths from a point to every tile. *Semita* is Latin for a
+footpath.
+
+Written for [NachOS](https://github.com/maxnus/NachOS), a StarCraft II bot library, though nothing in it is about
+StarCraft.
+
+```python
+import numpy
+
+import semita
+
+passable = numpy.ones((5, 5), dtype=bool)
+passable[2, :4] = False  # a wall, open at its far end
+
+path = semita.find_path(passable, (0, 0), (4, 0))
+assert round(path.distance, 2) == 10.83  # round the wall's end
+assert path.tiles[:3].tolist() == [[0, 0], [1, 1], [1, 2]]
+
+assert semita.find_path(passable, (0, 0), (2, 1)) is None  # the end is blocked
+
+paths = semita.cheapest_paths_from(passable, (0, 0))  # to every tile, in one pass
+assert paths.distances[4, 0] == path.distance
+assert paths.distances[2, 1] == float("inf")
+assert paths.path_to((4, 0)).cost == path.cost
+
+# Costs: each value is the cost of moving a unit of distance across its tile, 1 on normal ground and more where it
+# is best avoided; 0 blocks, as False does.
+costs = numpy.ones((7, 7))
+costs[2:5, 2:5] = 10.0  # a patch to keep out of
+around = semita.find_path(costs, (3, 0), (3, 6))
+assert round(around.cost, 2) == round(around.distance, 2) == 7.66  # round the patch, on ground costing 1
+assert semita.find_path(numpy.ones((7, 7), dtype=bool), (3, 0), (3, 6)).distance == 6.0  # straight, on bools
+```
+
+## The rules
+
+- A grid is a 2-D numpy array of bools or real numbers, or anything numpy reads as one, indexed `[i, j]`. Its values
+  are the tiles' costs: the cost of moving one unit of distance across each, 1 for normal ground, less where movement
+  is faster, more where it is slower or best avoided.
+- 0 and `inf` block a tile. A grid of bools is the simplest: `True` costs 1 and `False` blocks. Otherwise a cost is
+  positive; NaN and negatives raise `ValueError`.
+- A step goes to one of the eight neighboring tiles, 1 long straight and √2 diagonally, and only between passable
+  tiles. A diagonal step needs both tiles beside it passable too, so no path cuts a corner. A step costs its length
+  times the mean of the costs of the two tiles it joins, so a path costs the same both ways.
+- The start is a path to itself, costing nothing, even on a blocked tile, but no step leaves or enters a blocked one.
+- A start or an end outside the grid raises `IndexError`; a negative index counts as outside.
+- `find_path` returns a `Path`, its `distance`, its `cost` and its `tiles` from the start to the end, or `None` if
+  there is no path. Of several equally cheap paths it returns one, but which is not part of the contract.
+- `cheapest_paths_from` returns the cheapest path from the start to every tile, found in one pass, as
+  `CheapestPaths`: their `costs` and their `distances`, two read-only arrays of the grid's shape, `inf` where no path
+  reaches, and `path_to(tile)`, a tile's path as a `Path`, or `None` where none reaches. Where several paths to a tile
+  cost the same, it holds one of them. On a grid of bools the distances are the costs.
+- A grid whose passable tiles all cost the same, a grid of bools included, is searched by jump point search; any other
+  by A*, which visits more tiles, the more so the cheaper the cheapest tile is, since its estimate of what is left is
+  the straight distance times that cost.
+- A grid of bools, or a C-contiguous one of float64, is read as it is; any other is converted on each call, so one
+  searched often is best kept as one of those.
+
+Each search allocates its own memory and releases the GIL, so searches run in parallel on threads. A grid must not be
+written to while a search reads it.
+
+## Building
+
+semita is a C extension on Python's stable ABI, so one wheel serves every Python from 3.12 on a platform. Installing
+from source compiles it with the platform's own compiler: MSVC on Windows, gcc or clang elsewhere.
+
+```bash
+uv sync --extra dev
+uv run pytest
+```
+
+The tests check every search against scipy's Dijkstra over the same steps.
+
+## Releasing
+
+Publish a GitHub release tagged `v` and the new version, such as `v0.2.0`. The version is the tag, which
+setuptools-scm reads from git; no file holds it.
+
+The `release` workflow then builds the sdist, builds from it a wheel for Linux x86_64 and aarch64, Windows AMD64 and
+macOS arm64 and x86_64, tests and audits each for the stable ABI alone, checks that the tag is a version,
+and uploads them to PyPI. Every pull request builds and checks the same files without uploading them.
+
+PyPI trusts the workflow through trusted publishing, from the repository's `pypi` environment, so no token is stored
+anywhere.

semita-0.1.0/README.md

@@ -0,0 +1,87 @@
+# semita
+
+Shortest and cheapest paths and distances on a grid, in C, for Python: jump point search for one path, A* for one
+where tiles cost differently, and Dijkstra for the cheapest paths from a point to every tile. *Semita* is Latin for a
+footpath.
+
+Written for [NachOS](https://github.com/maxnus/NachOS), a StarCraft II bot library, though nothing in it is about
+StarCraft.
+
+```python
+import numpy
+
+import semita
+
+passable = numpy.ones((5, 5), dtype=bool)
+passable[2, :4] = False  # a wall, open at its far end
+
+path = semita.find_path(passable, (0, 0), (4, 0))
+assert round(path.distance, 2) == 10.83  # round the wall's end
+assert path.tiles[:3].tolist() == [[0, 0], [1, 1], [1, 2]]
+
+assert semita.find_path(passable, (0, 0), (2, 1)) is None  # the end is blocked
+
+paths = semita.cheapest_paths_from(passable, (0, 0))  # to every tile, in one pass
+assert paths.distances[4, 0] == path.distance
+assert paths.distances[2, 1] == float("inf")
+assert paths.path_to((4, 0)).cost == path.cost
+
+# Costs: each value is the cost of moving a unit of distance across its tile, 1 on normal ground and more where it
+# is best avoided; 0 blocks, as False does.
+costs = numpy.ones((7, 7))
+costs[2:5, 2:5] = 10.0  # a patch to keep out of
+around = semita.find_path(costs, (3, 0), (3, 6))
+assert round(around.cost, 2) == round(around.distance, 2) == 7.66  # round the patch, on ground costing 1
+assert semita.find_path(numpy.ones((7, 7), dtype=bool), (3, 0), (3, 6)).distance == 6.0  # straight, on bools
+```
+
+## The rules
+
+- A grid is a 2-D numpy array of bools or real numbers, or anything numpy reads as one, indexed `[i, j]`. Its values
+  are the tiles' costs: the cost of moving one unit of distance across each, 1 for normal ground, less where movement
+  is faster, more where it is slower or best avoided.
+- 0 and `inf` block a tile. A grid of bools is the simplest: `True` costs 1 and `False` blocks. Otherwise a cost is
+  positive; NaN and negatives raise `ValueError`.
+- A step goes to one of the eight neighboring tiles, 1 long straight and √2 diagonally, and only between passable
+  tiles. A diagonal step needs both tiles beside it passable too, so no path cuts a corner. A step costs its length
+  times the mean of the costs of the two tiles it joins, so a path costs the same both ways.
+- The start is a path to itself, costing nothing, even on a blocked tile, but no step leaves or enters a blocked one.
+- A start or an end outside the grid raises `IndexError`; a negative index counts as outside.
+- `find_path` returns a `Path`, its `distance`, its `cost` and its `tiles` from the start to the end, or `None` if
+  there is no path. Of several equally cheap paths it returns one, but which is not part of the contract.
+- `cheapest_paths_from` returns the cheapest path from the start to every tile, found in one pass, as
+  `CheapestPaths`: their `costs` and their `distances`, two read-only arrays of the grid's shape, `inf` where no path
+  reaches, and `path_to(tile)`, a tile's path as a `Path`, or `None` where none reaches. Where several paths to a tile
+  cost the same, it holds one of them. On a grid of bools the distances are the costs.
+- A grid whose passable tiles all cost the same, a grid of bools included, is searched by jump point search; any other
+  by A*, which visits more tiles, the more so the cheaper the cheapest tile is, since its estimate of what is left is
+  the straight distance times that cost.
+- A grid of bools, or a C-contiguous one of float64, is read as it is; any other is converted on each call, so one
+  searched often is best kept as one of those.
+
+Each search allocates its own memory and releases the GIL, so searches run in parallel on threads. A grid must not be
+written to while a search reads it.
+
+## Building
+
+semita is a C extension on Python's stable ABI, so one wheel serves every Python from 3.12 on a platform. Installing
+from source compiles it with the platform's own compiler: MSVC on Windows, gcc or clang elsewhere.
+
+```bash
+uv sync --extra dev
+uv run pytest
+```
+
+The tests check every search against scipy's Dijkstra over the same steps.
+
+## Releasing
+
+Publish a GitHub release tagged `v` and the new version, such as `v0.2.0`. The version is the tag, which
+setuptools-scm reads from git; no file holds it.
+
+The `release` workflow then builds the sdist, builds from it a wheel for Linux x86_64 and aarch64, Windows AMD64 and
+macOS arm64 and x86_64, tests and audits each for the stable ABI alone, checks that the tag is a version,
+and uploads them to PyPI. Every pull request builds and checks the same files without uploading them.
+
+PyPI trusts the workflow through trusted publishing, from the repository's `pypi` environment, so no token is stored
+anywhere.

semita-0.1.0/csrc/astar.c

@@ -0,0 +1,90 @@
+/*
+ * The cheapest path between two tiles on a grid with costs, by A*. Its estimate of what is left, the octile distance
+ * times the cheapest cost on the grid, never exceeds what a step there can cost, so the first time the search
+ * settles the end it has found the cheapest path.
+ */
+
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "heap.h"
+#include "search.h"
+
+/* What a search knows of a tile: nothing yet, a cost to it that may still fall, or its final cost. */
+enum { UNREACHED = 0, REACHED = 1, SETTLED = 2 };
+
+SearchStatus find_cheapest_path(
+    const Grid *grid, int start, int end, double cheapest, int **tiles, int *tile_count, double *cost,
+    double *distance
+) {
+    int height = grid->height;
+    int end_i = end / height, end_j = end % height;
+    *tiles = NULL;
+    *tile_count = 0;
+    *cost = *distance = INFINITY;
+    if (start == end) {
+        int *path = malloc(2 * sizeof *path);
+        if (!path) return SEARCH_OUT_OF_MEMORY;
+        path[0] = end_i;
+        path[1] = end_j;
+        *tiles = path;
+        *tile_count = 1;
+        *cost = *distance = 0.0;
+        return SEARCH_DONE;
+    }
+    if (!is_passable(grid, start / height, start % height) || !is_passable(grid, end_i, end_j)) return SEARCH_DONE;
+
+    size_t count = (size_t)grid->width * (size_t)height;
+    double *best = malloc(count * sizeof *best);
+    int *parent = malloc(count * sizeof *parent);
+    uint8_t *state = calloc(count, 1);
+    Heap heap = {0};
+    SearchStatus status = SEARCH_DONE;
+    if (!best || !parent || !state) {
+        status = SEARCH_OUT_OF_MEMORY;
+        goto done;
+    }
+    state[start] = REACHED;
+    best[start] = 0.0;
+    parent[start] = -1;
+    if (heap_push(&heap, cheapest * octile_distance(start / height, start % height, end_i, end_j), start)) {
+        status = SEARCH_OUT_OF_MEMORY;
+        goto done;
+    }
+
+    while (heap.size > 0) {
+        int tile = heap_pop(&heap).tile;
+        if (state[tile] == SETTLED) continue;
+        state[tile] = SETTLED;
+        if (tile == end) {
+            status = write_path(grid, end, parent, tiles, tile_count, distance);
+            if (status == SEARCH_DONE) *cost = best[end];
+            break;
+        }
+        int i = tile / height, j = tile % height;
+        for (int step = 0; step < 8; step++) {
+            int di = STEP_I[step], dj = STEP_J[step];
+            if (!can_step(grid, i, j, di, dj)) continue;
+            int neighbor = tile + di * height + dj;
+            if (state[neighbor] == SETTLED) continue;
+            double neighbor_cost = best[tile] + step_cost(grid, tile, di, dj);
+            if (state[neighbor] == UNREACHED || neighbor_cost < best[neighbor]) {
+                state[neighbor] = REACHED;
+                best[neighbor] = neighbor_cost;
+                parent[neighbor] = tile;
+                double estimate = neighbor_cost + cheapest * octile_distance(i + di, j + dj, end_i, end_j);
+                if (heap_push(&heap, estimate, neighbor)) {
+                    status = SEARCH_OUT_OF_MEMORY;
+                    goto done;
+                }
+            }
+        }
+    }
+done:
+    heap_free(&heap);
+    free(best);
+    free(parent);
+    free(state);
+    return status;
+}

semita-0.1.0/csrc/costs.c

@@ -0,0 +1,25 @@
+/* The costs a grid gives its tiles, checked before a search reads them. */
+
+#include <math.h>
+#include <stddef.h>
+
+#include "search.h"
+
+SearchStatus check_costs(const Grid *grid, double *cheapest, double *dearest, int *bad_tile) {
+    size_t tile_count = (size_t)grid->width * (size_t)grid->height;
+    double lowest = INFINITY, highest = 0.0;
+    for (size_t tile = 0; tile < tile_count; tile++) {
+        double cost = grid->costs[tile];
+        if (cost == 0.0 || cost == INFINITY) continue;
+        /* Written so that NaN fails it too. */
+        if (!(cost > 0.0)) {
+            *bad_tile = (int)tile;
+            return SEARCH_BAD_COST;
+        }
+        if (cost < lowest) lowest = cost;
+        if (cost > highest) highest = cost;
+    }
+    *cheapest = lowest;
+    *dearest = highest;
+    return SEARCH_DONE;
+}

semita-0.1.0/csrc/dijkstra.c

@@ -0,0 +1,54 @@
+/* The cheapest path from one tile to every tile, by Dijkstra's algorithm: each path's cost, its length and the tile
+   it arrives from. */
+
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "heap.h"
+#include "search.h"
+
+SearchStatus fill_flood(const Grid *grid, int start, double *costs, double *distances, int *parents) {
+    int height = grid->height;
+    size_t tile_count = (size_t)grid->width * (size_t)height;
+    /* A tile's parent is written when it is reached, and read only where its cost is finite. */
+    for (size_t tile = 0; tile < tile_count; tile++) costs[tile] = distances[tile] = INFINITY;
+    costs[start] = distances[start] = 0.0;
+    parents[start] = -1;
+    if (!is_passable(grid, start / height, start % height)) return SEARCH_DONE;
+
+    uint8_t *settled = calloc(tile_count, 1);
+    if (!settled) return SEARCH_OUT_OF_MEMORY;
+    Heap heap = {0};
+    SearchStatus status = SEARCH_DONE;
+    if (heap_push(&heap, 0.0, start)) {
+        status = SEARCH_OUT_OF_MEMORY;
+        goto done;
+    }
+    while (heap.size > 0) {
+        int tile = heap_pop(&heap).tile;
+        if (settled[tile]) continue;
+        settled[tile] = 1;
+        int i = tile / height, j = tile % height;
+        for (int step = 0; step < 8; step++) {
+            int di = STEP_I[step], dj = STEP_J[step];
+            if (!can_step(grid, i, j, di, dj)) continue;
+            int neighbor = tile + di * height + dj;
+            if (settled[neighbor]) continue;
+            double cost = costs[tile] + step_cost(grid, tile, di, dj);
+            if (cost < costs[neighbor]) {
+                costs[neighbor] = cost;
+                distances[neighbor] = distances[tile] + (di && dj ? SQRT_2 : 1.0);
+                parents[neighbor] = tile;
+                if (heap_push(&heap, cost, neighbor)) {
+                    status = SEARCH_OUT_OF_MEMORY;
+                    goto done;
+                }
+            }
+        }
+    }
+done:
+    heap_free(&heap);
+    free(settled);
+    return status;
+}

semita-0.1.0/csrc/heap.h

@@ -0,0 +1,69 @@
+/*
+ * A binary min-heap of tiles keyed by cost, growing as it fills. A tile may be pushed again at a lower cost; the
+ * searches skip the entries they have already settled.
+ */
+
+#ifndef SEMITA_HEAP_H
+#define SEMITA_HEAP_H
+
+#include <stddef.h>
+#include <stdlib.h>
+
+typedef struct {
+    double cost;
+    int tile;
+} HeapEntry;
+
+typedef struct {
+    HeapEntry *entries;
+    size_t size;
+    size_t capacity;
+} Heap;
+
+#define HEAP_FIRST_CAPACITY 256
+
+/* Push `tile` at `cost`: 0 if pushed, -1 if memory ran out. */
+static inline int heap_push(Heap *heap, double cost, int tile) {
+    if (heap->size == heap->capacity) {
+        size_t capacity = heap->capacity ? 2 * heap->capacity : HEAP_FIRST_CAPACITY;
+        HeapEntry *entries = realloc(heap->entries, capacity * sizeof *entries);
+        if (!entries) return -1;
+        heap->entries = entries;
+        heap->capacity = capacity;
+    }
+    size_t position = heap->size++;
+    while (position > 0) {
+        size_t parent = (position - 1) / 2;
+        if (heap->entries[parent].cost <= cost) break;
+        heap->entries[position] = heap->entries[parent];
+        position = parent;
+    }
+    heap->entries[position].cost = cost;
+    heap->entries[position].tile = tile;
+    return 0;
+}
+
+/* Remove and return the cheapest entry. The heap must not be empty. */
+static inline HeapEntry heap_pop(Heap *heap) {
+    HeapEntry cheapest = heap->entries[0];
+    HeapEntry last = heap->entries[--heap->size];
+    size_t position = 0;
+    for (;;) {
+        size_t child = 2 * position + 1;
+        if (child >= heap->size) break;
+        if (child + 1 < heap->size && heap->entries[child + 1].cost < heap->entries[child].cost) child++;
+        if (last.cost <= heap->entries[child].cost) break;
+        heap->entries[position] = heap->entries[child];
+        position = child;
+    }
+    if (heap->size > 0) heap->entries[position] = last;
+    return cheapest;
+}
+
+static inline void heap_free(Heap *heap) {
+    free(heap->entries);
+    heap->entries = NULL;
+    heap->size = heap->capacity = 0;
+}
+
+#endif /* SEMITA_HEAP_H */