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()

mirror server hosted at Truenetwork, Russian Federation.