The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.

cayleyR 0.2.6

• landmark_states() — 25 rule-defined permutations of 1:n as fixed probe points for graphs too large to enumerate; rotation-equivalent constructions are detected and separated automatically.
• convex_hull_3d(), enclosing_hull_3d() — the solid a point cloud bounds, with area and volume; the second passes through every point, not just the convex ones. New vignette landmark-geometry and two example scripts.

cayleyR 0.2.5

• human_algorithm_to() — reaches an arbitrary target by relabelling values to their target positions and solving once, instead of routing through 1:n twice. About half the word length of the old route.

• cycle_shortcut() — shortens a path by cutting across cycles: a combo looped from a point on the path can rejoin a later state, replacing the stretch between them. Complements short_path_bfs(). OpenMP-parallel; result verified against the start state.

• cayley_bfs_full() and cayley_graph_diameter() — full BFS over the reachable component with per-state distance, and graph diameter (all-pairs or from-start, with max_pairs sampling).

• openmp_threads() is now exported.

• The ring-size cap of 63 is gone — human_algorithm() and human_algorithm_to() now run at n = 1000 and beyond, by storing tail offsets instead of raw tile numbers in the finish table.

cayleyR 0.2.4

• human_algorithm() — solver that follows the way a person solves TopSpin by hand (C++, src/human_algorithm.cpp). Phase 1 grows a sorted run one value at a time; phase 2 finishes the tail with cycle primitives derived by search per k and cached as a lookup table. Accepts an arbitrary target, not just sorting to 1:n. Solves even ring sizes with k from 3 to 6, including the classic n = 20, k = 4 TopSpin.

cayleyR 0.2.3

• Disabled GPU for store_analyze_combos() — benchmarks showed GPU (Vulkan via ggmlR) is ~24x slower than CPU (C++) for this workload. ggmlR remains as optional dependency for other use cases.

• short_path_bfs.cpp — short_path_bfs() rewritten entirely in C++ with depth-limited BFS and multi-index lookup, replacing the previous R implementation for significantly better performance.

cayleyR 0.2.2

• find_path_iterative() now uses C++ StateStore backend instead of data.frame lists — memory usage is linear instead of quadratic

• analyze_top_combinations() still works but the new store_analyze_combos() writes directly to C++ store without intermediate data.frames

• C++ StateStore — compact hash-indexed state storage (src/state_store.h, src/state_store.cpp):

  • Flat vector<int> for states, separate metadata vectors, unordered_map hash index
  • Capacity starts at 10,000 and doubles on demand (amortized O(1) insert)
  • Operations encoded as int (1/2/3) instead of strings for cache efficiency
  • Incremental hash: keys computed only for new states, never recomputed
  • state_store_find_intersections() — O(min(N,M)) set intersection via hash
  • state_store_find_best_match() — Manhattan distance on flat array
  • state_store_filter_middle() — skip first/last steps per combo
  • state_store_reconstruct_path() — full C++ path reconstruction
  • state_store_to_dataframe() — convert to data.frame for debugging

• store_analyze_combos() — C++ cycle expansion writing directly to StateStore, bypassing all R-level list/data.frame creation

• sort_by parameter for find_best_random_combinations():

  • Flexible vector of sorting criteria: "longest", "shortest", "most_unique", "least_unique", "most_repeated", "least_repeated"
  • Criteria combine freely: e.g. c("shortest", "most_unique")
  • New repetition_ratio column in output
  • sort_by parameter propagated to find_path_iterative()

• Bridge state output — find_path_iterative() and find_path_bfs() now print bridge state chains with 1-based numbering and labels

• Direct vs hub distance check in find_path_bfs() — compares Manhattan distance start<->final vs hub_s<->hub_f, skips BFS hubs when direct is closer

• CelestialCoords struct extracted to shared header (celestial_coords.h) for reuse across C++ files

• find_path_bfs() now returns bridge_states_start and bridge_states_final in its result, including BFS hub states

cayleyR 0.2.1

• Removed arrow dependency — all functions now return plain data.frame instead of Arrow Tables

• data.table moved from Imports to Suggests — package works without it, uses data.table for speed when available

• Significantly faster installation: removed heavy arrow dependency (~50+ MB)

• Lightweight by default: only Rcpp is required

cayleyR 0.2.0

• GPU acceleration via ggmlR Vulkan backend (optional):

  • cayley_gpu_available(), cayley_gpu_init(), cayley_gpu_status(), cayley_gpu_free() — GPU infrastructure with lazy initialization
  • calculate_differences(..., use_gpu = TRUE) — Manhattan distance on GPU (sub -> abs -> sum_rows)
  • apply_operations_batch_gpu() — batch permutation operations via matrix multiplication on GPU
  • manhattan_distance_matrix_gpu() — pairwise N*M Manhattan distance matrix using 3D tensors

• Sparse BFS: sparse_bfs(), reconstruct_bfs_path() — sparse BFS with hybrid hub/random selection

• BFS pathfinding: find_path_bfs() — find path via BFS highways + iterative connector

• Path shortening: short_path_bfs() — greedy BFS hopping to shorten existing paths

• Bidirectional BFS pathfinding: bidirectional_bfs() for shortest path between permutation states

• Iterative path solver: find_path_iterative() for finding paths via cycle expansion

• Celestial coordinates: convert_LRX_to_celestial(), calculate_angular_distance_z(), calculate_midpoint_z(), find_closest_to_coords() — map operation counts to spherical coordinates

• Combination analysis: analyze_top_combinations() for full cycle analysis of top operation sequences

• State utilities: generate_state(), generate_unique_states_df(), select_unique(), check_duplicates(), save_bridge_states(), find_combination_in_states(), convert_digits()

• Path utilities: invert_path(), validate_and_simplify_path(), reconstruct_full_path()

• Distance metrics: manhattan_distance(), breakpoint_distance(), short_position()

• Simple operation variants: shift_left_simple(), shift_right_simple(), reverse_prefix_simple()

• C++ implementations of all core operations via Rcpp with OpenMP

• GPU functions fall back to CPU automatically when ggmlR/Vulkan is unavailable

cayleyR 0.1.0

• Initial CRAN submission.
• Basic TopSpin operations: shift_left(), shift_right(), reverse_prefix()
• Cycle analysis functions: get_reachable_states(), get_reachable_states_light()
• Optimization tools: find_best_random_combinations()

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.