rename project to fluxsort

Author: OpusNano

.github/ISSUE_TEMPLATE/literature-review-task.md

@@ -16,7 +16,7 @@ Explain what wording, comparison, or novelty risk this review is meant to clarif
 
 ## Questions to answer
 
-- [ ] What is the closest overlap with AdicFlux?
+- [ ] What is the closest overlap with FluxSort?
 - [ ] What is the strongest difference?
 - [ ] Does this affect current README/docs wording?
 - [ ] Should it be cited in `docs/positioning.md` later?

README.md

@@ -1,6 +1,6 @@
-# AdicFlux
+# FluxSort
 
-AdicFlux is an experimental integer sorting algorithm in Zig built around exact local transport guided by a weighted 2-adic pressure field.
+FluxSort is an experimental integer sorting algorithm in Zig built around exact local transport guided by a weighted 2-adic pressure field.
 
 ![Representative benchmark comparison](docs/assets/representative-comparison.svg)
 
@@ -15,7 +15,7 @@ This repository is worth reading as an algorithm experiment, benchmark trail, an
 
 ## Algorithm Sketch
 
-AdicFlux sorts signed integers with four core ideas:
+FluxSort sorts signed integers with four core ideas:
 
 1. Convert signed integers to order-preserving biased unsigned keys.
 2. Compute a local pressure field inside each block from nearby comparisons.
@@ -74,7 +74,7 @@ See `docs/findings.md` for the condensed research trail.
 
 The current stable implementation does not beat the standard-library baseline on the representative full-sort cases below.
 
-| Dataset | Size | AdicFlux | `std.sort.pdq` |
+| Dataset | Size | FluxSort | `std.sort.pdq` |
 | --- | ---: | ---: | ---: |
 | `duplicate_heavy` | 1024 | 360123 ns | 1253 ns |
 | `duplicate_heavy` | 4096 | 3481692 ns | 3678 ns |
@@ -87,7 +87,7 @@ The current stable implementation does not beat the standard-library baseline on
 
 Interpretation:
 
-- AdicFlux has a meaningful internal optimization story.
+- FluxSort has a meaningful internal optimization story.
 - It does not have a competitive benchmark story against strong mainstream baselines.
 - The grouped duplicate-heavy path is interesting as an algorithm-specific milestone, not as evidence of overall speed.
 
@@ -132,31 +132,31 @@ Focused benchmark example:
 ## Basic Usage
 
 ```zig
-const adicflux = @import("adicflux");
+const fluxsort = @import("fluxsort");
 
 var xs = [_]i64{ 9, -3, 4, 4, 0, -9, 7 };
-adicflux.sort(i64, xs[0..]);
+fluxsort.sort(i64, xs[0..]);
 ```
 
 With explicit configuration:
 
 ```zig
-const cfg = adicflux.Config{
+const cfg = fluxsort.Config{
     .block_size = 32,
     .valuation_cap = 8,
     .neighborhood = 8,
     .max_displacement = 4,
     .transport_rounds = 4,
 };
 
-adicflux.sortWithConfig(i64, xs[0..], cfg);
+fluxsort.sortWithConfig(i64, xs[0..], cfg);
 ```
 
 `cleanup_pass_limit` remains available for diagnostic runs; leaving it as `null` preserves the exactness guarantee.
 
 ## Repository Layout
 
-- `src/adicflux.zig` public API
+- `src/fluxsort.zig` public API
 - `src/core/` pressure, energy, transport, cleanup, and configuration code
 - `test/` unit and property tests
 - `bench/main.zig` local benchmark harness
@@ -165,4 +165,4 @@ adicflux.sortWithConfig(i64, xs[0..], cfg);
 
 ## Final Assessment
 
-AdicFlux is an interesting experimental generic integer sorting algorithm with one meaningful optimization milestone and a substantial trail of tested ideas. It is exact, unusual, and reasonably well-documented. It has not been shown to beat relevant baselines, and this repository should be read as a research artifact rather than a production sorting library.
+FluxSort is an interesting experimental generic integer sorting algorithm with one meaningful optimization milestone and a substantial trail of tested ideas. It is exact, unusual, and reasonably well-documented. It has not been shown to beat relevant baselines, and this repository should be read as a research artifact rather than a production sorting library.

bench/main.zig

@@ -1,9 +1,9 @@
 const std = @import("std");
-const adicflux = @import("adicflux");
+const fluxsort = @import("fluxsort");
 
-const support = adicflux.unstable_test_support;
+const support = fluxsort.unstable_test_support;
 const Stats = support.stats.Stats;
-const Config = adicflux.Config;
+const Config = fluxsort.Config;
 
 const Dataset = enum {
     random,
@@ -154,11 +154,11 @@ fn validateCase(allocator: std.mem.Allocator, input: []const i32, cfg: Config) !
     support.sortWithStats(i32, actual, cfg, &stats);
 
     if (!std.mem.eql(i32, expected, actual)) return error.BenchmarkValidationFailed;
-    if (!adicflux.isSorted(i32, actual)) return error.BenchmarkValidationFailed;
+    if (!fluxsort.isSorted(i32, actual)) return error.BenchmarkValidationFailed;
     return stats;
 }
 
-fn timeAdicFlux(allocator: std.mem.Allocator, input: []const i32, cfg: Config, iterations: usize) !Result {
+fn timeFluxSort(allocator: std.mem.Allocator, input: []const i32, cfg: Config, iterations: usize) !Result {
     const scratch = try allocator.alloc(i32, input.len);
     defer allocator.free(scratch);
 
@@ -168,12 +168,12 @@ fn timeAdicFlux(allocator: std.mem.Allocator, input: []const i32, cfg: Config, i
     var iter: usize = 0;
     while (iter < iterations) : (iter += 1) {
         @memcpy(scratch, input);
-        adicflux.sort(i32, scratch);
+        fluxsort.sort(i32, scratch);
     }
     const total_ns = timer.read();
 
     return .{
-        .algo = "adicflux",
+        .algo = "fluxsort",
         .dataset = undefined,
         .size = input.len,
         .iterations = iterations,
@@ -273,11 +273,11 @@ pub fn main() !void {
 
     const sizes = [_]usize{ 32, 64, 128, 256, 512, 1024, 2048, 4096 };
     const datasets = [_]Dataset{ .random, .sorted, .reverse, .nearly_sorted, .duplicate_heavy, .clustered, .signed_mixed, .alternating };
-    const cfg = adicflux.DefaultConfig;
+    const cfg = fluxsort.DefaultConfig;
     var prng = std.Random.DefaultPrng.init(0xad1cf1);
     const random = prng.random();
 
-    try writer.print("# adicflux benchmark harness\n", .{});
+    try writer.print("# fluxsort benchmark harness\n", .{});
     try writer.print("# zig_version,{s}\n", .{@import("builtin").zig_version_string});
     try writer.print("# optimize_mode,{s}\n", .{@tagName(@import("builtin").mode)});
     try writer.print("algo,dataset,size,iterations,total_ns,avg_ns,avg_ns_per_item,transport_accepted,transport_rejected,grouped_exact_blocks,moved_delta_blocks,full_delta_blocks,cleanup_rounds,cleanup_swaps\n", .{});
@@ -292,7 +292,7 @@ pub fn main() !void {
 
             const iterations = filters.iterations_override orelse chooseIterations(size);
 
-            var adic_result = try timeAdicFlux(allocator, input, cfg, iterations);
+            var adic_result = try timeFluxSort(allocator, input, cfg, iterations);
             adic_result.dataset = dataset;
             try printResult(writer, adic_result, dataset);
 

build.zig

@@ -4,16 +4,16 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const adicflux_mod = b.createModule(.{
+    const fluxsort_mod = b.createModule(.{
         .root_source_file = b.path("src/lib.zig"),
         .target = target,
         .optimize = optimize,
     });
 
     const lib = b.addLibrary(.{
         .linkage = .static,
-        .name = "adicflux",
-        .root_module = adicflux_mod,
+        .name = "fluxsort",
+        .root_module = fluxsort_mod,
     });
     b.installArtifact(lib);
 
@@ -22,10 +22,10 @@ pub fn build(b: *std.Build) void {
         .target = target,
         .optimize = optimize,
     });
-    exe_mod.addImport("adicflux", adicflux_mod);
+    exe_mod.addImport("fluxsort", fluxsort_mod);
 
     const exe = b.addExecutable(.{
-        .name = "adicflux-demo",
+        .name = "fluxsort-demo",
         .root_module = exe_mod,
     });
     b.installArtifact(exe);
@@ -42,7 +42,7 @@ pub fn build(b: *std.Build) void {
         .target = target,
         .optimize = optimize,
     });
-    example_mod.addImport("adicflux", adicflux_mod);
+    example_mod.addImport("fluxsort", fluxsort_mod);
 
     const example_exe = b.addExecutable(.{
         .name = "basic_sort",
@@ -58,25 +58,25 @@ pub fn build(b: *std.Build) void {
         .target = target,
         .optimize = optimize,
     });
-    tests_mod.addImport("adicflux", adicflux_mod);
+    tests_mod.addImport("fluxsort", fluxsort_mod);
 
     const tests = b.addTest(.{
         .root_module = tests_mod,
     });
     const run_tests = b.addRunArtifact(tests);
 
-    const test_step = b.step("test", "Run AdicFlux tests");
+    const test_step = b.step("test", "Run FluxSort tests");
     test_step.dependOn(&run_tests.step);
 
     const bench_mod = b.createModule(.{
         .root_source_file = b.path("bench/main.zig"),
         .target = target,
         .optimize = optimize,
     });
-    bench_mod.addImport("adicflux", adicflux_mod);
+    bench_mod.addImport("fluxsort", fluxsort_mod);
 
     const bench_exe = b.addExecutable(.{
-        .name = "adicflux-bench",
+        .name = "fluxsort-bench",
         .root_module = bench_mod,
     });
 

build.zig.zon

@@ -6,7 +6,7 @@
     //
     // It is redundant to include "zig" in this name because it is already
     // within the Zig package namespace.
-    .name = .AdicFlux,
+    .name = .FluxSort,
 
     // This is a [Semantic Version](https://semver.org/).
     // In a future version of Zig it will be used for package deduplication.
@@ -24,7 +24,7 @@
     // original project's identity. Thus it is recommended to leave the comment
     // on the following line intact, so that it shows up in code reviews that
     // modify the field.
-    .fingerprint = 0xfda167fb8d1aa117, // Changing this has security and trust implications.
+    .fingerprint = 0x84d987ee2e833367, // Changing this has security and trust implications.
 
     // Tracks the earliest Zig version that the package considers to be a
     // supported use case.

docs/algorithm.md

@@ -10,7 +10,7 @@ For unsigned integers, the key is the value itself.
 
 For indices `i < j`, an inversion contributes energy when `key(xs[i]) > key(xs[j])`.
 
-The baseline contribution is `1`. AdicFlux adds a capped 2-adic closeness bonus:
+The baseline contribution is `1`. FluxSort adds a capped 2-adic closeness bonus:
 
 - compute `key(xs[i]) xor key(xs[j])`,
 - take `ctz(...)`,
@@ -44,7 +44,7 @@ That is a local acceptance criterion. In the current repository it should not be
 
 ## 5. Exact cleanup stage
 
-After transport rounds finish, AdicFlux runs odd-even adjacent cleanup until no swaps remain. This is the exact stage. With the default configuration, it guarantees that the final output is sorted even if every transport proposal is rejected.
+After transport rounds finish, FluxSort runs odd-even adjacent cleanup until no swaps remain. This is the exact stage. With the default configuration, it guarantees that the final output is sorted even if every transport proposal is rejected.
 
 The configuration also exposes `cleanup_pass_limit` for diagnostic runs. Using a finite limit intentionally weakens that guarantee because cleanup may stop before the array is sorted.
 

docs/api.md

@@ -8,7 +8,7 @@
 pub fn sort(comptime T: type, xs: []T) void
 ```
 
-Sorts an integer slice in place using the default AdicFlux configuration.
+Sorts an integer slice in place using the default FluxSort configuration.
 
 ### `sortWithConfig`
 
@@ -26,7 +26,7 @@ Invalid configurations panic with the validation error name. This keeps the publ
 pub fn isSorted(comptime T: type, xs: []const T) bool
 ```
 
-Checks whether a slice is nondecreasing under AdicFlux's key ordering.
+Checks whether a slice is nondecreasing under FluxSort's key ordering.
 
 `isSorted` is an intentional part of the public API. It exists as a small validation helper for examples, tests, and user code that experiments with non-default configurations such as `cleanup_pass_limit`, where a caller may intentionally request a diagnostic run that does not complete the exact cleanup stage.
 
@@ -63,6 +63,6 @@ Optional diagnostic/testing limit for odd-even cleanup rounds.
 
 ## Non-stable internal support
 
-Internal modules used by the test suite are exposed under `adicflux.unstable_test_support`.
+Internal modules used by the test suite are exposed under `fluxsort.unstable_test_support`.
 
 That namespace exists for repository development and tests. It is intentionally non-stable and may change without notice.

docs/assets/internal-milestone.svg

@@ -22,7 +22,7 @@ Pre-milestone comparison was collected from `46f9743` in a temporary worktree us
 
 ## Representative Stable Numbers (`7d12617`)
 
-| Dataset | Size | AdicFlux | `std.sort.pdq` |
+| Dataset | Size | FluxSort | `std.sort.pdq` |
 | --- | ---: | ---: | ---: |
 | `duplicate_heavy` | 1024 | 360123 ns | 1253 ns |
 | `duplicate_heavy` | 4096 | 3481692 ns | 3678 ns |