diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,5 @@ +# Revision history for cube-hs + +## 0.3.0 -- YYYY-mm-dd + +* First version. Released on an unsuspecting world. diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2026 coshz + +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. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,61 @@ +# cube-hs + +[![Hackage](https://img.shields.io/hackage/v/cube-hs.svg)](https://hackage.haskell.org/package/cube-hs) +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) +[![GitHub](https://img.shields.io/badge/github-coshz%2Fcube-blue?logo=github)](https://github.com/coshz/cube/tree/master/bindings/haskell) + +A performant and type-safe Rubik's Cube manipulation and permutation library for Haskell. + +## Features + +- **Type-Safe Representation**: Strongly typed representations of Cubes, Faces, Turns, and Moves. +- **Algebraic Group Actions**: Pure permutation math leveraging `Semigroup`, `Monoid`, and the `ActsOn` typeclass. +- **Flexible Interactions**: Turn individual faces, apply sequence moves, or compose transformations seamlessly. + +## Installation + +Add `cube-hs` to your project's `.cabal` file dependencies: + +```cabal +build-depends: base >= 4.14 && < 5, cube-hs +``` + +Or install it via `cabal`: + +```bash +cabal update +cabal install cube-hs +``` + +## Usage + +```haskell +module Main where + +import Data.Cube +import Data.Maybe (fromMaybe) + +main :: IO () +main = do + -- 1. Inspect solved cube state + let solvedCube = cubeId + putStrLn $ "Solved Cube Colors: " ++ showCube solvedCube + -- "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB" + + -- 2. Parse standard turn notations + let turnNotation = "U F U' L2 R L' D2 B" + let turns = fromMaybe [] $ parseTurns turnNotation + + -- 3. Scramble the cube by folding turns + let scrambledCube = foldl (&>) solvedCube turns + putStrLn $ "Scrambled Cube: " ++ showCube scrambledCube + + -- 4. Solve the scrambled cube & verify + let solution = unsafeSolveFrom scrambledCube + let restoredCube = applyTurns scrambledCube solution + + if restoredCube == solvedCube + then putStrLn $ "Solution: " ++ showTurns solution ++ "." + else putStrLn "Solving failed." +``` + diff --git a/cbits/cube_amalg.min.cpp b/cbits/cube_amalg.min.cpp new file mode 100644 --- /dev/null +++ b/cbits/cube_amalg.min.cpp @@ -0,0 +1,1658 @@ +/* + * File: cube_amalg.min.cpp + * Project: cube + * Author: coshz + * Version: 0.4.0 + * Date: 2026-09-18 + * Homepage: https://github.com/coshz/cube + * License: MIT + * + * Copyright (c) 2026 coshz . All rights reserved. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +enum Face { U1,U2,U3,U4,U5,U6,U7,U8,U9,R1,R2,R3,R4,R5,R6,R7,R8,R9,F1,F2,F3,F4,F5,F6,F7,F8,F9,D1,D2,D3,D4,D5,D6,D7,D8,D9,L1,L2,L3,L4,L5,L6,L7,L8,L9,B1,B2,B3,B4,B5,B6,B7,B8,B9 }; +enum Layer { U,R,F,D,L,B }; +enum TurnMove { Ux1,Ux2,Ux3,Rx1,Rx2,Rx3,Fx1,Fx2,Fx3,Dx1,Dx2,Dx3,Lx1,Lx2,Lx3,Bx1,Bx2,Bx3 }; +enum Symmetry { S_URF3,S_F2,S_U4,S_LR2 }; +enum ColorIndex { UCol,RCol,FCol,DCol,LCol,BCol,NoCol }; +enum Corner { URF,UFL,ULB,UBR,DFR,DLF,DBL,DRB }; +enum Edge { UR,UF,UL,UB,DR,DF,DL,DB,FR,FL,BL,BR }; +struct OrientedCorner { Corner c; unsigned o; }; +struct OrientedEdge { Edge e; unsigned o; }; +typedef ColorIndex SingleFace[9]; +typedef ColorIndex CornerColorIndex[8][3]; +typedef ColorIndex EdgeColorIndex[12][2]; +typedef ColorIndex FaceletColor[54]; +typedef Face CentreFacelet[6]; +typedef Face CornerFacelet[8][3]; +typedef Face EdgeFacelet[12][2]; +typedef Face Facelet[54]; +typedef OrientedCorner CornerCubie[8]; +typedef OrientedEdge EdgeCubie[12]; +typedef Corner EdgeNeighbour[12][2]; +const CornerColorIndex CCI = {{UCol,RCol,FCol},{UCol,FCol,LCol},{UCol,LCol,BCol},{UCol,BCol,RCol},{DCol,FCol,RCol},{DCol,LCol,FCol},{DCol,BCol,LCol},{DCol,RCol,BCol}}; +const EdgeColorIndex ECI = {{UCol,RCol},{UCol,FCol},{UCol,LCol},{UCol,BCol},{DCol,RCol},{DCol,FCol}, {DCol,LCol},{DCol,BCol},{FCol,RCol},{FCol,LCol},{BCol,LCol},{BCol,RCol}}; +const CentreFacelet CC = {U5,R5,F5,D5,L5,B5}; +const CornerFacelet CF = {{U9,R1,F3},{U7,F1,L3},{U1,L1,B3},{U3,B1,R3},{D3,F9,R7},{D1,L9,F7},{D7,B9,L7},{D9,R9,B7}}; +const EdgeFacelet EF = {{U6,R2},{U8,F2},{U4,L2},{U2,B2},{D6,R8},{D2,F8}, {D4,L8},{D8,B8},{F6,R4},{F4,L6},{B6,L4},{B4,R6}}; +const EdgeNeighbour EN = {{URF,UBR},{UFL,URF},{ULB,UFL},{UBR,ULB},{DRB,DFR},{DFR,DLF}, {DLF,DBL},{DBL,DRB},{URF,DFR},{DLF,UFL},{DBL,ULB},{UBR,DRB}}; +const Facelet FaceletMove[6] = { + {U3,U6,U9,U2,U5,U8,U1,U4,U7,F1,F2,F3,R4,R5,R6,R7,R8,R9,L1,L2,L3,F4,F5,F6,F7,F8,F9,D1,D2,D3,D4,D5,D6,D7,D8,D9,B1,B2,B3,L4,L5,L6,L7,L8,L9,R1,R2,R3,B4,B5,B6,B7,B8,B9}, + {U1,U2,B7,U4,U5,B4,U7,U8,B1,R3,R6,R9,R2,R5,R8,R1,R4,R7,F1,F2,U3,F4,F5,U6,F7,F8,U9,D1,D2,F3,D4,D5,F6,D7,D8,F9,L1,L2,L3,L4,L5,L6,L7,L8,L9,D9,B2,B3,D6,B5,B6,D3,B8,B9}, + {U1,U2,U3,U4,U5,U6,R1,R4,R7,D3,R2,R3,D2,R5,R6,D1,R8,R9,F3,F6,F9,F2,F5,F8,F1,F4,F7,L3,L6,L9,D4,D5,D6,D7,D8,D9,L1,L2,U9,L4,L5,U8,L7,L8,U7,B1,B2,B3,B4,B5,B6,B7,B8,B9}, + {U1,U2,U3,U4,U5,U6,U7,U8,U9,R1,R2,R3,R4,R5,R6,B7,B8,B9,F1,F2,F3,F4,F5,F6,R7,R8,R9,D3,D6,D9,D2,D5,D8,D1,D4,D7,L1,L2,L3,L4,L5,L6,F7,F8,F9,B1,B2,B3,B4,B5,B6,L7,L8,L9}, + {F1,U2,U3,F4,U5,U6,F7,U8,U9,R1,R2,R3,R4,R5,R6,R7,R8,R9,D1,F2,F3,D4,F5,F6,D7,F8,F9,B9,D2,D3,B6,D5,D6,B3,D8,D9,L3,L6,L9,L2,L5,L8,L1,L4,L7,B1,B2,U7,B4,B5,U4,B7,B8,U1}, + {L7,L4,L1,U4,U5,U6,U7,U8,U9,R1,R2,U1,R4,R5,U2,R7,R8,U3,F1,F2,F3,F4,F5,F6,F7,F8,F9,D1,D2,D3,D4,D5,D6,R9,R6,R3,D7,L2,L3,D8,L5,L6,D9,L8,L9,B3,B6,B9,B2,B5,B8,B1,B4,B7} +}; +const Facelet FaceletSym[4] = { + {R9,R8,R7,R6,R5,R4,R3,R2,R1,F3,F6,F9,F2,F5,F8,F1,F4,F7,U3,U6,U9,U2,U5,U8,U1,U4,U7,L1,L2,L3,L4,L5,L6,L7,L8,L9,B7,B4,B1,B8,B5,B2,B9,B6,B3,D3,D6,D9,D2,D5,D8,D1,D4,D7}, + {D9,D8,D7,D6,D5,D4,D3,D2,D1,L9,L8,L7,L6,L5,L4,L3,L2,L1,F9,F8,F7,F6,F5,F4,F3,F2,F1,U9,U8,U7,U6,U5,U4,U3,U2,U1,R9,R8,R7,R6,R5,R4,R3,R2,R1,B9,B8,B7,B6,B5,B4,B3,B2,B1}, + {U3,U6,U9,U2,U5,U8,U1,U4,U7,F1,F2,F3,F4,F5,F6,F7,F8,F9,L1,L2,L3,L4,L5,L6,L7,L8,L9,D7,D4,D1,D8,D5,D2,D9,D6,D3,B1,B2,B3,B4,B5,B6,B7,B8,B9,R1,R2,R3,R4,R5,R6,R7,R8,R9}, + {U3,U2,U1,U6,U5,U4,U9,U8,U7,L3,L2,L1,L6,L5,L4,L9,L8,L7,F3,F2,F1,F6,F5,F4,F9,F8,F7,D3,D2,D1,D6,D5,D4,D9,D8,D7,R3,R2,R1,R6,R5,R4,R9,R8,R7,B3,B2,B1,B6,B5,B4,B9,B8,B7} +}; +const CornerCubie CornerCubieMove[6] = { + {{UBR,0},{URF,0},{UFL,0},{ULB,0},{DFR,0},{DLF,0},{DBL,0},{DRB,0}}, + {{DFR,2},{UFL,0},{ULB,0},{URF,1},{DRB,1},{DLF,0},{DBL,0},{UBR,2}}, + {{UFL,1},{DLF,2},{ULB,0},{UBR,0},{URF,2},{DFR,1},{DBL,0},{DRB,0}}, + {{URF,0},{UFL,0},{ULB,0},{UBR,0},{DLF,0},{DBL,0},{DRB,0},{DFR,0}}, + {{URF,0},{ULB,1},{DBL,2},{UBR,0},{DFR,0},{UFL,2},{DLF,1},{DRB,0}}, + {{URF,0},{UFL,0},{UBR,1},{DRB,2},{DFR,0},{DLF,0},{ULB,2},{DBL,1}} +}; +const EdgeCubie EdgeCubieMove[6] = { + {{UB,0},{UR,0},{UF,0},{UL,0},{DR,0},{DF,0},{DL,0},{DB,0},{FR,0},{FL,0},{BL,0},{BR,0}}, + {{FR,0},{UF,0},{UL,0},{UB,0},{BR,0},{DF,0},{DL,0},{DB,0},{DR,0},{FL,0},{BL,0},{UR,0}}, + {{UR,0},{FL,1},{UL,0},{UB,0},{DR,0},{FR,1},{DL,0},{DB,0},{UF,1},{DF,1},{BL,0},{BR,0}}, + {{UR,0},{UF,0},{UL,0},{UB,0},{DF,0},{DL,0},{DB,0},{DR,0},{FR,0},{FL,0},{BL,0},{BR,0}}, + {{UR,0},{UF,0},{BL,0},{UB,0},{DR,0},{DF,0},{FL,0},{DB,0},{FR,0},{UL,0},{DL,0},{BR,0}}, + {{UR,0},{UF,0},{UL,0},{BR,1},{DR,0},{DF,0},{DL,0},{BL,1},{FR,0},{FL,0},{UB,1},{DB,1}} +}; +const CornerCubie CornerCubieSym[4] = { + {{URF,1},{DFR,2},{DLF,1},{UFL,2},{UBR,2},{DRB,1},{DBL,2},{ULB,1}}, + {{DLF,0},{DFR,0},{DRB,0},{DBL,0},{UFL,0},{URF,0},{UBR,0},{ULB,0}}, + {{UBR,0},{URF,0},{UFL,0},{ULB,0},{DRB,0},{DFR,0},{DLF,0},{DBL,0}}, + {{UFL,3},{URF,3},{UBR,3},{ULB,3},{DLF,3},{DFR,3},{DRB,3},{DBL,3}} +}; +const EdgeCubie EdgeCubieSym[4] = { + {{UF,1},{FR,0},{DF,1},{FL,0},{UB,1},{BR,0},{DB,1},{BL,0},{UR,1},{DR,1},{DL,1},{UL,1}}, + {{DL,0},{DF,0},{DR,0},{DB,0},{UL,0},{UF,0},{UR,0},{UB,0},{FL,0},{FR,0},{BR,0},{BL,0}}, + {{UB,0},{UR,0},{UF,0},{UL,0},{DB,0},{DR,0},{DF,0},{DL,0},{BR,1},{FR,1},{FL,1},{BL,1}}, + {{UL,0},{UF,0},{UR,0},{UB,0},{DL,0},{DF,0},{DR,0},{DB,0},{FL,0},{FR,0},{BR,0},{BL,0}} +}; +enum Constant { + GN_HTM = 20, + GN_QTM = 26, + N_MOVE = 18, + N_TWIST = 2187, + N_FLIP = 2048, + N_SLICE = 495, + N_CORNER = 40320, + N_EDGE8 = 40320, + N_EDGE4 = 24, + N_SYM = 48, + N_SYM_D4h = 16, + EQ_FLIPSLICE= 64430, + EQ_CORNER = 2768, +}; +namespace cube::math { +using std::size_t; +template +auto decomposite(const VectorLike &xs) -> std::pair,std::vector>>; +template +size_t orderOf(const std::array &xs); +template +constexpr size_t rankOf(const std::array &xs); +template +constexpr std::array fromRank(size_t r); +template +constexpr std::array nestList(F &&f, T &&x); +template +constexpr auto takeByRange(const std::array&) -> std::array; +template +constexpr auto fromDigits(const std::array &xs) -> size_t; +template +constexpr auto toDigits(size_t i) -> std::array; +constexpr size_t factorial(size_t n); +constexpr size_t binomial(size_t n, size_t k); +template +constexpr auto lexicalOrderFromIndices(const std::array &X) -> int; +template +constexpr auto lexicalOrderToIndices(int rank) -> std::array; +template +constexpr bool isValidPermutation(const ArrayLike& xs); +template +constexpr Array backpermute(const Array& src, const Perm& P); +template +constexpr Array forepermute(const Array& src, const Perm& P); +template +auto decomposite(const VectorLike &xs) -> std::pair,std::vector>> +{ + using T = typename VectorLike::value_type; + std::vector fixed; + std::vector> cycles; + std::vector visited(xs.size(),false); + for(int i = 0; i < xs.size(); ++i) { + if(visited[i]) continue; + std::vector cycle; + for(int j = xs[i]; j != i; j = xs[j]) { + visited[j] = true; + cycle.push_back(static_cast(j)); + } + visited[i] = true; + cycle.push_back(static_cast(i)); + if(cycle.size() > 1) cycles.push_back(cycle); + else fixed.push_back(cycle[0]); + } + std::sort(cycles.begin(), cycles.end(), [](auto &v1, auto &v2){ + return v1.size() > v2.size(); + }); + return std::make_pair(fixed,cycles); +} +template +size_t orderOf(const std::array &xs) +{ + size_t m = 1; + auto cs = decomposite(xs); + for(size_t i = 1; i < cs.size(); i++) { m = std::lcm(m, cs[i].size()); } + return m; +} +template +constexpr size_t rankOf(const std::array &xs) +{ + size_t r = 0; + std::array used {false}; + for(size_t i = 0; i < N; i++) + { + int cnt = 0; + for(int j=0; j < xs[i]; j++) if(!used[j]) cnt++; + r += cnt * factorial(N - i - 1); + used[xs[i]] = true; + } + return r; +} +template +constexpr std::array fromRank(size_t r) +{ + std::array A{}; + std::array used {false}; + for(size_t i = 0; i < N; i++) + { + size_t f = factorial(N - i - 1); + size_t cnt = r / f; + r %= f; + for(size_t j = 0; j < N; j++) + { + if(used[j]) continue; + if(cnt-- == 0) { + A[i] = j; + used[j] = true; + break; + } + } + } + return A; +} +template +constexpr std::array nestList(F &&f, T &&x) +{ + std::array r; + r[0] = x; + for(auto i = 1; i <= N; i++) r[i] = f(r[i-1]); + return r; +} +template +constexpr auto takeByRange(const std::array &xs) -> std::array +{ + static_assert(Begin <= End && End < N); + std::array ys; + std::copy(xs.begin()+Begin,xs.begin()+End+1,ys.begin()); + return ys; +} +template +constexpr auto fromDigits(const std::array &xs) -> size_t +{ + auto pow = [](size_t base, size_t exp) -> size_t { + size_t prod = 1; + for(size_t i = 0; i < exp; i++) prod *= base; + return prod; + }; + size_t res = 0; + for(size_t i = 0; i < N; i++) res += static_cast(xs[i]) * pow(B, N-i-1); + return res; +} +template +constexpr auto toDigits(size_t i) -> std::array +{ + auto pow = [](size_t base, size_t exp) -> size_t { + size_t prod = 1; + for(size_t i = 0; i < exp; i++) prod *= base; + return prod; + }; + std::array a {}; + for(size_t k = 0; k < N; k++) { + size_t z = pow(B, N-1-k); + a[k] = static_cast(i / z); + i = i % z; + } + return a; +} +constexpr size_t binomial(size_t n, size_t k) +{ + if(n < k) return 0; + if(n == k) return 1; + size_t r = 1, m = std::min(k, n-k); + for(size_t i = 1; i <= m; i++) r *= n-i+1; + for(size_t i = 1; i <= m; i++) r /= i; + return r; +}; +constexpr size_t factorial(size_t n) +{ + if(n>=21) throw std::invalid_argument("factorial(n) overflows for n >= 21"); + return n == 0 ? 1 : n * factorial(n-1); +} +template +constexpr auto lexicalOrderFromIndices(const std::array &X) -> int +{ + static_assert(M<=N); + int rank = 0; + for(size_t i = 0; i < M; i++) rank += binomial(N-1-X[i],M-i); + return rank; +} +template +constexpr auto lexicalOrderToIndices(int rank) -> std::array +{ + static_assert(M<=N); + std::array X {}; + size_t n=rank, k=0; + for(size_t i = 0; i < M; i++) { + while(binomial(N-1-k,M-i) > n || n >= binomial(N-k,M-i)) k++; + X[i] = k; + n -= binomial(N-1-k,M-i); + k += 1; + } + return X; +} +template +constexpr bool isValidPermutation(const ArrayLike& xs) +{ + if(xs.size() != N) return false; + std::array visited{}; + for(auto i = 0; i < N; ++i) { + size_t val = static_cast(xs[i]); + if(xs[i] < 0 || xs[i] >= N) return false; + if(visited[val]) return false; + visited[val] = true; + } + return true; +} +template +constexpr Array backpermute(const Array& src, const Perm& P) +{ + Array out{src}; + for (size_t i = 0; i < P.size(); ++i) { out[i] = src[P[i]]; } + return out; +} +template +constexpr Array forepermute(const Array& src, const Perm& P) +{ + Array out{src}; + for (size_t i = 0; i < P.size(); ++i) { out[P[i]] = src[i]; } + return out; +} +} +namespace cube::utils { +inline auto get_cache_dir() -> std::filesystem::path +{ +#ifdef _WIN32 + const char* localAppData = std::getenv("LOCALAPPDATA"); + if (localAppData) return std::filesystem::path(localAppData); +#elif __APPLE__ + const char* home = std::getenv("HOME"); + if (home) return std::filesystem::path(home) / "Library" / "Caches"; +#else + const char* xdgCache = std::getenv("XDG_CACHE_HOME"); + if (xdgCache) return std::filesystem::path(xdgCache); + const char* home = std::getenv("HOME"); + if (home) return std::filesystem::path(home) / ".cache"; +#endif + throw std::runtime_error("Unable to determine cache path"); +} +template +inline auto time_execution(F&& f, Args&&... args) +{ + using Rf = std::invoke_result_t; + auto start = std::chrono::high_resolution_clock::now(); + auto duration_from_start = [start](){ + auto end = std::chrono::high_resolution_clock::now(); + return std::chrono::duration_cast(end-start); + }; + if constexpr (std::is_void_v) { + std::forward(f)(std::forward(args)...); + return std::make_pair( + duration_from_start(), + std::nullopt + ); + } else { + auto result = std::forward(f)(std::forward(args)...); + return std::make_pair( + duration_from_start(), + std::make_optional(result) + ); + } +} +template +bool is_valid_config(const VectorLike &cfg) +{ + if(cfg.size() != 54) return false; + std::set vs { cfg[CC[0]],cfg[CC[1]],cfg[CC[2]],cfg[CC[3]],cfg[CC[4]],cfg[CC[5]] }; + if(vs.size() != 6) return false; + for(size_t i = 0, x = 0; i < 8; i++) { + for(x = 0; x < 24; x++) { + if(cfg[CC[CCI[i][0]]] == cfg[CF[x/3][x%3]] + && cfg[CC[CCI[i][1]]] == cfg[CF[x/3][(x+1)%3]] + && cfg[CC[CCI[i][2]]] == cfg[CF[x/3][(x+2)%3]]) break; + } + if(x >= 24) return false; + } + for(size_t i = 0, y = 0; i < 12; i++) { + for(y = 0; y < 24; y++) { + if(cfg[CC[ECI[i][0]]] == cfg[EF[y/2][y%2]] + && cfg[CC[ECI[i][1]]] == cfg[EF[y/2][(y+1)%2]]) break; + } + if(y >= 24) return false; + } + return true; +} +inline bool is_valid_maneuver(std::string_view s) +{ + static const std::regex pat( + R"(\s*(([UDLRFB]['23]?|\(([UDLRFB]['23]?\s*)+\)(\{\d+\})?)\s*)*)" + ); + return std::regex_match(s.begin(), s.end(), pat); +} +inline auto parse_manuever(std::string_view s) -> std::vector +{ + assert(is_valid_maneuver(s) && "invalid maneuver"); + auto expand = [](std::string_view in) -> std::string { + static const std::regex group_re(R"(\(([^)]+)\)(?:\{(\d+)\})?)"); + std::string res; + auto start = in.cbegin(); + std::match_results m; + while (std::regex_search(start, in.cend(), m, group_re)) { + res.append(start, m[0].first); + int repeat = m[2].matched ? std::stoi(m[2].str()) : 1; + for (int i = 0; i < repeat; ++i) res += m[1].str(); + start = m[0].second; + } + res.append(start, in.cend()); + return res; + }; + auto char_to_move = [](char c) -> TurnMove { + switch(c) { + case 'U': return Ux1; + case 'R': return Rx1; + case 'F': return Fx1; + case 'D': return Dx1; + case 'L': return Lx1; + case 'B': return Bx1; + default: throw std::invalid_argument("char_to_move: ???"); + } + }; + std::string in = expand(s); + std::vector ms; + ms.reserve(in.size()); + for (char c : in) + { + switch (c) { + case ' ': break; + case '2': + ms.back() = static_cast(ms.back() + 1); + break; + case '\'': + ms.back() = static_cast(ms.back() + 2); + break; + default: + ms.push_back(char_to_move(c)); + break; + } + } + return ms; +} +inline std::vector operator""_Tm(const char* ts, size_t n) +{ + return parse_manuever(std::string(ts,n)); +} +} +namespace cube::data { +using std::size_t; +using namespace cube::math; +template +struct Perm +{ + using value_type = T; + static constexpr size_t size() { return N; } + constexpr Perm() noexcept + { + for(size_t i = 0; i < N; ++i) X[i] = static_cast(i); + } + constexpr Perm(const std::array& xs) noexcept + :X{xs} + { + assert(isValidPermutation(xs) && "array must be a valid permutation"); + } + constexpr Perm(std::initializer_list xs) noexcept + { + assert(xs.size() == N && "size mismatch"); + auto dit = X.begin(); + for(auto it = xs.begin(); it != xs.end(); it++, dit++) { *dit = *it; } + assert(isValidPermutation(X) && "invalid permutation list"); + } + template + constexpr ArrayLike act_right(const ArrayLike& src) const noexcept + { + return backpermute(src,this->X); + } + friend constexpr Perm operator*(const Perm &P, const Perm& Q) noexcept + { + return Q.act_right(P); + } + constexpr Perm& operator*=(const Perm& rhs) noexcept + { + return *this = *this * rhs; + } + friend constexpr bool operator==(const Perm &lhs, const Perm& rhs) noexcept + { + return lhs.X == rhs.X; + } + constexpr Perm operator~() const + { + return { forepermute(Perm::id.X, this->X) }; + } + constexpr T& operator[](size_t idx) { return X[idx]; } + constexpr const T& operator[](size_t idx) const { return X[idx]; } + bool parity() const + { + const auto [fixed, cs] = decomposite(this->X); + int s = 1; + for(auto &c:cs) s *= (c.size() % 2 == 0) ? -1 : 1; + return s == 1; + } + size_t order() const { return orderOf(X); } + constexpr size_t rank() const { return rankOf(X); } + static constexpr Perm fromRank(size_t i) + { return { cube::math::fromRank(i) }; } + static const Perm id; + std::array X{}; +}; +template +inline constexpr Perm Perm::id{}; +template +struct CArray +{ + using value_type = T; + static constexpr size_t period = N; + static constexpr size_t size() noexcept { return L; } + constexpr CArray() noexcept {} + constexpr CArray(const std::array &arr) noexcept + :xs{arr} + { + auto n = static_cast(N); + for(size_t i = 0; i < L; i++) { xs[i] = (xs[i] % n + n) % n; } + } + constexpr CArray(std::initializer_list list) noexcept + { + auto n = static_cast(N); + std::size_t i = 0; + for(T val : list) { if(i < L) { xs[i++] = (val % n + n) % n; } } + } + constexpr T& operator[](size_t idx) noexcept { return xs[idx]; } + constexpr const T& operator[](size_t idx) const noexcept { return xs[idx]; } + friend constexpr bool operator==(const CArray& lhs, const CArray& rhs) noexcept + { + return lhs.xs == rhs.xs; + } + constexpr CArray& operator+=(const CArray& rhs) + { + for(size_t i = 0; i < L; i++) xs[i] = (xs[i] + rhs.xs[i]) % N; + return *this; + } + friend constexpr CArray operator+(CArray lhs, const CArray& rhs) + { + return lhs += rhs; + } + constexpr CArray operator~() const noexcept + { + CArray inv {}; + auto n = static_cast(N); + for(size_t i = 0; i < L; i++) inv[i] = (n - xs[i]) % n; + return inv; + } + constexpr T sum() const noexcept + { + T s = 0; + for(size_t i = 0; i < L; i++) s += xs[i]; + return s % N; + } + static const CArray id; + std::array xs {}; +}; +template +inline constexpr CArray CArray::id{}; +template +constexpr CArray operator*(const CArray &xs, const Perm &P) +{ + return P.act_right(xs); +} +template +constexpr CArray& operator*=(CArray &xs, const Perm &P) +{ + return xs = P.act_right(xs); +} +template +struct ArrayHelper { + using type = std::array::type,N>; +}; +template +struct ArrayHelper { + using type = std::array; +}; +template +struct NArray +{ + using value_type = T; + static constexpr size_t size = (Ns * ...); + static constexpr size_t dim = sizeof...(Ns); + static constexpr std::array shape { Ns... }; + typename ArrayHelper::type data; + auto & operator[](size_t i) { + return data[i]; + } + const auto & operator[](size_t i) const { + return data[i]; + } +}; +} +namespace cube { +using namespace cube::data; +using namespace cube::utils; +typedef int8_t cube_value_t; +typedef Perm<54, cube_value_t> FacePerm; +typedef Perm<8, cube_value_t> CornerPerm; +typedef Perm<12, cube_value_t> EdgePerm; +typedef CArray<3, 8,cube_value_t> CornerOri; +typedef CArray<2,12,cube_value_t> EdgeOri; +struct ColorState; +struct FaceCube; +struct CubieCube; +constexpr CornerPerm operator*(const CornerPerm &cp, const CubieCube &cc); +constexpr CornerOri operator*(const CornerOri &co, const CubieCube &cc); +constexpr EdgePerm operator*(const EdgePerm &ep, const CubieCube &cc); +constexpr EdgeOri operator*(const EdgeOri &eo, const CubieCube &cc); +struct ColorState +{ + std::array s; + Layer & operator[](size_t i) noexcept { return s[i]; } + const Layer operator[](size_t i) const noexcept { return s[i]; } + static ColorState fromString(std::string_view cube); + FaceCube toFaceCube() const; + CubieCube toCubieCube() const; + static const ColorState id; +}; +inline const ColorState ColorState::id = {{U,U,U,U,U,U,U,U,U,R,R,R,R,R,R,R,R,R,F,F,F,F,F,F,F,F,F,D,D,D,D,D,D,D,D,D,L,L,L,L,L,L,L,L,L,B,B,B,B,B,B,B,B,B}}; +struct FaceCube +{ + FacePerm f; + CubieCube toCubieCube() const; + friend constexpr FaceCube operator*(const FaceCube &lhs, const FaceCube &rhs) + { return { lhs.f * rhs.f }; } + constexpr FaceCube& operator*=(const FaceCube &rhs) + { return *this = *this * rhs; } + constexpr FaceCube operator~() const + { return { ~f }; } + friend bool operator==(const FaceCube &lhs, const FaceCube &rhs) + { return lhs.f == rhs.f; } + static const FaceCube id; +}; +struct CubieCube +{ + CornerPerm cp; + CornerOri co; + EdgePerm ep; + EdgeOri eo; + FaceCube toFaceCube() const; + constexpr bool isSolvable() const + { return cp.parity() == ep.parity() && co.sum() == 0 && eo.sum() == 0; } + friend constexpr CubieCube operator*(const CubieCube &a, const CubieCube &b) + { return { a.cp*b, a.co*b, a.ep*b, a.eo*b }; } + constexpr CubieCube& operator*=(const CubieCube &rhs) + { return *this = *this * rhs; } + constexpr CubieCube operator~() const + { + auto cp_inv = ~cp; + auto ep_inv = ~ep; + return { cp_inv, ~(co*cp_inv), ep_inv, ~(eo*ep_inv) }; + } + friend bool operator==(const CubieCube &lhs, const CubieCube &rhs) + { return lhs.cp == rhs.cp && lhs.co == rhs.co && lhs.ep == rhs.ep && lhs.eo == rhs.eo; } + static const CubieCube id; +}; +inline constexpr CornerPerm operator*(const CornerPerm &cp, const CubieCube &cc) { return cp * cc.cp;} +inline constexpr CornerOri operator*(const CornerOri &co, const CubieCube &cc) { return co * cc.cp + cc.co; } +inline constexpr EdgePerm operator*(const EdgePerm &ep, const CubieCube &cc) { return ep * cc.ep; } +inline constexpr EdgeOri operator*(const EdgeOri &eo, const CubieCube &cc) { return eo * cc.ep + cc.eo; } +inline constexpr CornerPerm eCP = {0,1,2,3,4,5,6,7}; +inline constexpr EdgePerm eEP = {0,1,2,3,4,5,6,7,8,9,10,11}; +inline constexpr CornerOri eCO = {0,0,0,0,0,0,0,0}; +inline constexpr EdgeOri eEO = {0,0,0,0,0,0,0,0,0,0,0,0}; +inline constexpr FacePerm eFP = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53}; +inline const FaceCube FaceCube::id = FaceCube{eFP}; +inline const CubieCube CubieCube::id = CubieCube{eCP,eCO,eEP,eEO}; +inline constexpr CubieCube mU = {{3,0,1,2,4,5,6,7},{0,0,0,0,0,0,0,0},{3,0,1,2,4,5,6,7,8,9,10,11},{0,0,0,0,0,0,0,0,0,0,0,0}}; +inline constexpr CubieCube mR = {{4,1,2,0,7,5,6,3},{2,0,0,1,1,0,0,2},{8,1,2,3,11,5,6,7,4,9,10,0},{0,0,0,0,0,0,0,0,0,0,0,0}}; +inline constexpr CubieCube mF = {{1,5,2,3,0,4,6,7},{1,2,0,0,2,1,0,0},{0,9,2,3,4,8,6,7,1,5,10,11},{0,1,0,0,0,1,0,0,1,1,0,0}}; +inline constexpr CubieCube mD = {{0,1,2,3,5,6,7,4},{0,0,0,0,0,0,0,0},{0,1,2,3,5,6,7,4,8,9,10,11},{0,0,0,0,0,0,0,0,0,0,0,0}}; +inline constexpr CubieCube mL = {{0,2,6,3,4,1,5,7},{0,1,2,0,0,2,1,0},{0,1,10,3,4,5,9,7,8,2,6,11},{0,0,0,0,0,0,0,0,0,0,0,0}}; +inline constexpr CubieCube mB = {{0,1,3,7,4,5,2,6},{0,0,1,2,0,0,2,1},{0,1,2,11,4,5,6,10,8,9,3,7},{0,0,0,1,0,0,0,1,0,0,1,1}}; +inline constexpr std::array + ElementaryMove = { mU,mU*mU,mU*mU*mU,mR,mR*mR,mR*mR*mR,mF,mF*mF,mF*mF*mF,mD,mD*mD,mD*mD*mD,mL,mL*mL,mL*mL*mL,mB,mB*mB,mB*mB*mB }; +inline constexpr FaceCube pU = {{6,3,0,7,4,1,8,5,2,45,46,47,12,13,14,15,16,17,9,10,11,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,18,19,20,39,40,41,42,43,44,36,37,38,48,49,50,51,52,53}}; +inline constexpr FaceCube pR = {{0,1,20,3,4,23,6,7,26,15,12,9,16,13,10,17,14,11,18,19,29,21,22,32,24,25,35,27,28,51,30,31,48,33,34,45,36,37,38,39,40,41,42,43,44,8,46,47,5,49,50,2,52,53}}; +inline constexpr FaceCube pF = {{0,1,2,3,4,5,44,41,38,6,10,11,7,13,14,8,16,17,24,21,18,25,22,19,26,23,20,15,12,9,30,31,32,33,34,35,36,37,27,39,40,28,42,43,29,45,46,47,48,49,50,51,52,53}}; +inline constexpr FaceCube pD = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,24,25,26,18,19,20,21,22,23,42,43,44,33,30,27,34,31,28,35,32,29,36,37,38,39,40,41,51,52,53,45,46,47,48,49,50,15,16,17}}; +inline constexpr FaceCube pL = {{53,1,2,50,4,5,47,7,8,9,10,11,12,13,14,15,16,17,0,19,20,3,22,23,6,25,26,18,28,29,21,31,32,24,34,35,42,39,36,43,40,37,44,41,38,45,46,33,48,49,30,51,52,27}}; +inline constexpr FaceCube pB = {{11,14,17,3,4,5,6,7,8,9,10,35,12,13,34,15,16,33,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,36,39,42,2,37,38,1,40,41,0,43,44,51,48,45,52,49,46,53,50,47}}; +inline constexpr std::array + ElementaryPerm = { pU,pU*pU,pU*pU*pU,pR,pR*pR,pR*pR*pR,pF,pF*pF,pF*pF*pF,pD,pD*pD,pD*pD*pD,pL,pL*pL,pL*pL*pL,pB,pB*pB,pB*pB*pB }; +inline CubieCube operator*(const CubieCube &c, const std::vector &ms) +{ + CubieCube cc = c; + for (auto m : ms) cc = cc * ElementaryMove[m]; + return cc; +} +inline ColorState operator*(const ColorState &c, const std::vector &ms) +{ + ColorState cs = c; + for (auto m : ms) cs = ElementaryPerm[m].f.act_right(cs); + return cs; +} +} +namespace cube { +ColorState ColorState::fromString(std::string_view cube) +{ + assert(is_valid_config(cube) && "invalid cube config"); + std::array xs{}; + std::transform(cube.cbegin(), cube.cend(), xs.begin(), [](char c) { + switch(c) { + case 'U': return U; + case 'R': return R; + case 'F': return F; + case 'D': return D; + case 'L': return L; + case 'B': return B; + default: throw std::invalid_argument("invalid cube config"); + } + }); + return { xs }; +} +FaceCube ColorState::toFaceCube() const +{ + FacePerm fp{}; + for(int i = 0; i < 6; ++i) { + fp[CC[i]] = s[CC[i]]; + } + for(int i = 0; i < 8; i++) { + for(int x = 0; x < 24; x++) { + if(s[CC[CCI[i][0]]] == s[CF[x/3][x%3]] + && s[CC[CCI[i][1]]] == s[CF[x/3][(x+1)%3]] + && s[CC[CCI[i][2]]] == s[CF[x/3][(x+2)%3]]) + { + fp[CF[x/3][x%3]] = CF[i][0]; + fp[CF[x/3][(x+1)%3]] = CF[i][1]; + fp[CF[x/3][(x+2)%3]] = CF[i][2]; + break; + } + } + } + for(int i = 0; i < 12; i++) { + for(int y = 0; y < 24; y++) { + if(s[CC[ECI[i][0]]] == s[EF[y/2][y%2]] + && s[CC[ECI[i][1]]] == s[EF[y/2][(y+1)%2]]) + { + fp[EF[y/2][y%2]] = EF[i][0]; + fp[EF[y/2][(y+1)%2]] = EF[i][1]; + break; + } + } + } + return { fp }; +} +CubieCube ColorState::toCubieCube() const +{ + return toFaceCube().toCubieCube(); +} +CubieCube FaceCube::toCubieCube() const +{ + CubieCube cc{}; + const FaceCube &fc = *this; + for(int i = 0; i < 8; i++) { + for(int x = 0; x < 24; x++) { + if(fc.f[CF[i][0]] == CF[x/3][x%3]) { + cc.cp[i] = x/3, cc.co[i] = (3-x%3)%3; + break; + } + } + } + for(int i = 0; i < 12; i++){ + for(int y = 0; y < 24; y++){ + if(fc.f[EF[i][0]] == EF[y/2][y%2]) { + cc.ep[i] = y/2, cc.eo[i] = (2-y%2)%2; + break; + } + } + } + return cc; +} +FaceCube CubieCube::toFaceCube() const +{ + FaceCube fc{}; + const CubieCube &cc = *this; + for(int i = 0; i < 6; i++) { + fc.f[CC[i]] = CC[i]; + } + for(int i = 0; i < 8; i++) for(int j = 0; j < 3; j++) { + fc.f[CF[i][j]] = CF[cc.cp[i]][(j-cc.co[i]+3)%3]; + } + for(int i = 0; i < 12; i++) for(int j = 0; j < 2; j++) { + fc.f[EF[i][j]] = EF[cc.ep[i]][(j-cc.eo[i]+2)%2]; + } + return fc; +} +} +namespace cube::pdb { +struct Coord +{ + int twist, flip, slice; + int corner, edge4, edge8; + static const Coord id; + static CornerOri twist2co(int); + static int co2twist(const CornerOri &); + static EdgeOri flip2eo(int); + static int eo2flip(const EdgeOri &); + static CornerPerm corner2cp(int); + static int cp2corner(const CornerPerm &); + static int ep2slice(const EdgePerm &); + static int ep2edge4(const EdgePerm &); + static int ep2edge8(const EdgePerm &); + static EdgePerm slice2ep(int); + static EdgePerm edge42ep(int); + static EdgePerm edge82ep(int); + static EdgePerm see2ep(int,int,int); + static Coord CubieCube2Coord(const CubieCube &); + static CubieCube Coord2CubieCube(const Coord &); +}; +constexpr bool operator==(const Coord &c1, const Coord &c2) +{ + return c1.twist == c2.twist && c1.flip == c2.flip && c1.slice == c2.slice + && c1.corner == c2.corner && c1.edge4 == c2.edge4 && c1.edge8 == c2.edge8; +} +inline constexpr Coord Coord::id = { 0,0,0,0,0,0 }; +} +namespace cube::pdb { +using namespace cube::math; +using namespace cube::data; +inline bool isSliceEdge(size_t idx) +{ + return FR <= idx && idx <= BR; +} +int Coord::co2twist(const CornerOri &co) +{ + return static_cast(fromDigits<3>(takeByRange<1,7>(co.xs))); +} +CornerOri Coord::twist2co(int i) +{ + CornerOri co; + auto sub1to7 = CArray<3,7,CornerOri::value_type>{toDigits<3,7,CornerOri::value_type>(i)}; + std::copy(sub1to7.xs.begin(),sub1to7.xs.end(),co.xs.begin()+1); + co[0] = (3 - sub1to7.sum()) % 3; + return co; +} +int Coord::eo2flip(const EdgeOri &eo) +{ + return static_cast(fromDigits<2>(takeByRange<1,11>(eo.xs))); +} +EdgeOri Coord::flip2eo(int i) +{ + EdgeOri eo; + auto sub1to11 = CArray<2,11,CornerOri::value_type>{toDigits<2,11,CornerOri::value_type>(i)}; + std::copy(sub1to11.xs.begin(),sub1to11.xs.end(),eo.xs.begin()+1); + eo[0] = (2 - sub1to11.sum()) % 2; + return eo; +} +int Coord::ep2slice(const EdgePerm &ep) +{ + int x[4],slice=0,N=12; + for(int i = 0, j = 0; i < N; i++) { + if(isSliceEdge(ep[i])) x[j++] = i; + } + for(int i = 0; i < 4; i++) slice += binomial(N-1-x[i],4-i); + return slice; +} +int Coord::ep2edge4(const EdgePerm &ep) +{ + Perm<4,EdgePerm::value_type> edge4_perm; + for(int i = 0, j = 0; i < 4; i++, j++) { + while(!isSliceEdge(ep[j])) j++; + edge4_perm[i] = ep[j] - 8; + } + return static_cast(edge4_perm.rank()); +} +int Coord::ep2edge8(const EdgePerm &ep) +{ + Perm<8,EdgePerm::value_type> edge8_perm; + for(size_t i = 0, j = 0; i < 8; i++, j++) { + while(isSliceEdge(ep[j]) || ep[j] == (EdgePerm::value_type) ~0UL) j++; + edge8_perm[i] = ep[j] - 0; + } + return static_cast(edge8_perm.rank()); +} +int Coord::cp2corner(const CornerPerm &cp) +{ + return static_cast(cp.rank()); +} +CornerPerm Coord::corner2cp(int i) +{ + return CornerPerm::fromRank(i); +} +EdgePerm Coord::slice2ep(int i) +{ + auto si = lexicalOrderToIndices<12,4>(i); + EdgePerm ep; + for(size_t i = 0, j = 0; i < 12; i++){ + ep[i] = (i == si[j]) ? 8 + j++ : (EdgePerm::value_type) ~0UL; + } + return ep; +} +EdgePerm Coord::edge42ep(int i) +{ + EdgePerm ep; + auto e4 = Perm<4,EdgePerm::value_type>::fromRank(i); + for(size_t i = 0; i < 12; i++){ + ep[i] = (i < 8) ? (EdgePerm::value_type) ~0UL : e4[i-8] + 8; + } + return ep; +} +EdgePerm Coord::edge82ep(int i) +{ + EdgePerm ep; + auto e8 = Perm<8,EdgePerm::value_type>::fromRank(i); + for(size_t i = 0; i < 12; i++){ + ep[i] = (i < 8) ? e8[i] + 0 : (EdgePerm::value_type) ~0UL; + } + return ep; +} +EdgePerm Coord::see2ep(int slice, int edge4, int edge8) +{ + auto e4 = Perm<4,EdgePerm::value_type>::fromRank(edge4); + auto e8 = Perm<8,EdgePerm::value_type>::fromRank(edge8); + auto slice_indices = lexicalOrderToIndices<12,4>(slice); + EdgePerm ep; + for(size_t i = 0, j = 0, x = 0, y = 0; i < 12; i++) { + ep[i] = (i == slice_indices[j] && ++j) ? e4[x++]+8: e8[y++]+0; + } + return ep; +} +Coord Coord::CubieCube2Coord(const CubieCube &cc) +{ + return { + Coord::co2twist(cc.co), + Coord::eo2flip(cc.eo), + Coord::ep2slice(cc.ep), + Coord::cp2corner(cc.cp), + Coord::ep2edge4(cc.ep), + Coord::ep2edge8(cc.ep) + }; +} +CubieCube Coord::Coord2CubieCube(const Coord &c) +{ + return { + Coord::corner2cp(c.corner), + Coord::twist2co(c.twist), + Coord::see2ep(c.slice,c.edge4,c.edge8), + Coord::flip2eo(c.flip) + }; +} +} +namespace cube::internal +{ +void set_table_dir(std::string_view dir); +auto get_table_dir() -> std::filesystem::path; +bool is_table_ready(); +void preload_tables(); +} +namespace cube::pdb { +#define TABLE_DIR_DEFAULT cube::internal::get_table_dir() +typedef uint16_t mt_value_t; +typedef uint8_t pt_value_t; +template void save_to(const Table &table, std::filesystem::path path); +template void load_from(Table &table, std::filesystem::path path); +template +class Singleton +{ +public: + Singleton(const Singleton&) = delete; + Singleton(Singleton&&) = delete; + Singleton& operator=(const Singleton&) = delete; + Singleton& operator=(Singleton&&) = delete; + static T& instance() { + static T obj {}; + return obj; + } +protected: + Singleton() = default; + ~Singleton() = default; +}; +template +struct TableMove +{ + static_assert(std::is_integral::value); + static_assert(std::numeric_limits::digits >= 16); + using value_t = T; + TableMove(std::filesystem::path dir = TABLE_DIR_DEFAULT); + TableMove(const TableMove &) = delete; + ~TableMove(); + TableMove& operator=(const TableMove &) = delete; + template + std::enable_if_t + buildMoveTable(Table &t, F1&& coord2i, F2&& i2coord, std::string filename=""); + const std::filesystem::path tdir; + NArray *pTMTwist; + NArray *pTMFlip; + NArray *pTMSlice; + NArray *pTMCorner; + NArray *pTMEdge4; + NArray *pTMEdge8; +}; +template +struct TablePrunning +{ + using value_type = T; + TablePrunning(std::filesystem::path dir = TABLE_DIR_DEFAULT); + TablePrunning(const TablePrunning &) = delete; + ~TablePrunning(); + TablePrunning operator=(const TablePrunning &) = delete; + template + std::enable_if_t + buildPrunningTable(Table &t, const MT1 &mt1, const MT2 &mt2, std::string filename); + const std::filesystem::path tdir; + NArray *pTPSliceFlip; + NArray *pTPSliceTwist; + NArray *pTPEdge4Edge8; + NArray *pTPEdge4Corner; +}; +inline const auto &get_TM() { return Singleton>::instance(); } +inline const auto &get_TP() { return Singleton>::instance(); } +} +#if defined(VERBOSE) && VERBOSE +#define VPRINT(...) printf(__VA_ARGS__) +#else +#define VPRINT(...) +#endif +namespace cube::pdb { +namespace fs = std::filesystem; +template +void save_to(const Table &table, fs::path path) +{ + std::ofstream f(path, std::ios::binary); + if(f.is_open()) { + f.write(reinterpret_cast(&table.data), sizeof(table.data)); + f.close(); + } +} +template +void load_from(Table &table, fs::path path) +{ + VPRINT("loading table from %s...", path.c_str()); + std::ifstream f(path,std::ios::binary); + f.read(reinterpret_cast(&table.data), sizeof(table.data)); + f.close(); + VPRINT("done.\n"); +} +template +template +std::enable_if_t +TableMove::buildMoveTable(Table &t, F1&& coord2i, F2&& i2coord, std::string filename) +{ + VPRINT("creating move table %s of shape (%zu,%zu)... ", + filename.c_str(), t.shape[0], t.shape[1]); + for(size_t i = 0; i < t.shape[0]; i++) for(size_t j = 0; j < t.shape[1]; j++) { + t[i][j] = coord2i(i2coord(j) * ElementaryMove[i]); + } + if(filename != "") save_to(t, tdir/filename); + VPRINT("done.\n"); +} +template +TableMove::TableMove(std::filesystem::path dir) +:tdir(dir) +{ + VPRINT("INIT MOVE TABLES -- \n"); + pTMTwist = new NArray; + pTMFlip = new NArray; + pTMSlice = new NArray; + pTMCorner = new NArray; + pTMEdge4 = new NArray; + pTMEdge8 = new NArray; + if(!fs::exists(tdir/"tm_twist.dat")) { + if(!fs::exists(tdir)) fs::create_directories(tdir); + buildMoveTable(*pTMTwist, Coord::co2twist, Coord::twist2co, "tm_twist.dat"); + buildMoveTable(*pTMFlip, Coord::eo2flip, Coord::flip2eo, "tm_flip.dat"); + buildMoveTable(*pTMSlice, Coord::ep2slice, Coord::slice2ep, "tm_slice.dat"); + buildMoveTable(*pTMCorner, Coord::cp2corner, Coord::corner2cp, "tm_corner.dat"); + buildMoveTable(*pTMEdge4, Coord::ep2edge4, Coord::edge42ep, "tm_edge4.dat"); + buildMoveTable(*pTMEdge8, Coord::ep2edge8, Coord::edge82ep, "tm_edge8.dat"); + } else { + load_from(*pTMTwist, tdir/"tm_twist.dat"); + load_from(*pTMFlip, tdir/"tm_flip.dat"); + load_from(*pTMSlice, tdir/"tm_slice.dat"); + load_from(*pTMCorner, tdir/"tm_corner.dat"); + load_from(*pTMEdge4, tdir/"tm_edge4.dat"); + load_from(*pTMEdge8, tdir/"tm_edge8.dat"); + } + VPRINT("-- DONE.\n"); +} +template +TableMove::~TableMove() +{ + delete pTMTwist; + delete pTMFlip; + delete pTMSlice; + delete pTMCorner; + delete pTMEdge4; + delete pTMEdge8; +} +template +template +std::enable_if_t +TablePrunning::buildPrunningTable( + Table &t, const MT1 &mt1, const MT2 &mt2, std::string filename) +{ + VPRINT("creating prunning table %s of shape (%zu,%zu):\n", + filename.c_str(), mt1.shape[1], mt2.shape[1]); + std::fill_n(&t.data[0][0], t.size, (typename Table::value_type) ~0UL); + t[0][0] = 0; + typename Table::value_type depth = 0; + size_t count = 1; + VPRINT("\tdepth %2d: %10zu / %-10zu.\n", depth, count, t.size); + while(count < t.size) + { + for(size_t i = 0; i < t.shape[0]; i++) + for(size_t j = 0; j < t.shape[1]; j++) + if(t[i][j] == depth) { + for(auto k = 0; k < N_MOVE; k++) { + auto ii = mt1[k][i], jj = mt2[k][j]; + if(t[ii][jj] == (typename Table::value_type)~0UL) { t[ii][jj] = depth + 1; count++; } + } + } + depth++; + VPRINT("\tdepth %2d: %10zu / %-10zu.\n", depth, count, t.size); + } + if(filename != "") save_to(t, tdir/filename); + VPRINT("done.\n"); +} +template +TablePrunning::TablePrunning(std::filesystem::path dir) +:tdir(dir) +{ + VPRINT("INIT PRUNNING TABLES -- \n"); + pTPSliceFlip = new NArray; + pTPSliceTwist = new NArray; + pTPEdge4Edge8 = new NArray; + pTPEdge4Corner = new NArray; + if(!fs::exists(tdir/"tp_slicetwist.dat")) { + const auto &TM = get_TM(); + buildPrunningTable(*pTPSliceTwist, *TM.pTMSlice, *TM.pTMTwist, "tp_slicetwist.dat"); + buildPrunningTable(*pTPSliceFlip, *TM.pTMSlice, *TM.pTMFlip, "tp_sliceflip.dat"); + buildPrunningTable(*pTPEdge4Corner, *TM.pTMEdge4, *TM.pTMCorner, "tp_edge4corner.dat"); + buildPrunningTable(*pTPEdge4Edge8, *TM.pTMEdge4, *TM.pTMEdge8, "tp_edge4edge8.dat"); + } else { + load_from(*pTPSliceTwist, tdir/"tp_slicetwist.dat"); + load_from(*pTPSliceFlip, tdir/"tp_sliceflip.dat"); + load_from(*pTPEdge4Corner,tdir/"tp_edge4corner.dat"); + load_from(*pTPEdge4Edge8, tdir/"tp_edge4edge8.dat"); + } + VPRINT("-- DONE.\n"); +} +template +TablePrunning::~TablePrunning() +{ + delete pTPSliceFlip; + delete pTPSliceTwist; + delete pTPEdge4Edge8; + delete pTPEdge4Corner; +} +template struct TableMove<>; +template struct TablePrunning<>; +} +namespace cube::solver { +using namespace cube::pdb; +class TwoPhaseSolver +{ +public: + auto solve(const Coord &c, int step, bool best) + -> std::tuple,std::vector>; +protected: + enum enum_phase { Ph1=0, Ph2=1 }; + template bool search_phase(const Coord &c, size_t togo); + template static Coord transform(const Coord &c, const TurnMove &m); + template static size_t distance(const Coord &c); + static constexpr int D0 = 12, D1 = 18, DS = D0+D1; + template static constexpr auto& D = std::get(std::tie(D0,D1)); + static constexpr std::array EM0 + = { Ux1,Ux2,Ux3,Rx1,Rx2,Rx3,Fx1,Fx2,Fx3,Dx1,Dx2,Dx3,Lx1,Lx2,Lx3,Bx1,Bx2,Bx3 }; + static constexpr std::array EM1 + = { Ux1,Ux2,Ux3,Rx2,Fx2,Dx1,Dx2,Dx3,Lx2,Bx2 }; + template + static constexpr auto& EM = std::get(std::tie(EM0,EM1)); +private: + template + void reset_ph_sofar_() { sofar_[PhX].fill(-1); } + template + void set_ph_solution_(size_t L) + { + rsolution_[PhX].first = L; + std::copy(sofar_[PhX].begin(), sofar_[PhX].begin()+L, rsolution_[PhX].second.begin()); + } + template + auto get_ph_solution_() const -> std::vector + { + size_t n = rsolution_[PhX].first; + if(n == 0) return {}; + std::vector sol(n); + for(auto i = 0; i < n; i++) { + sol[i] = static_cast(rsolution_[PhX].second[n-1-i]); + } + return sol; + } + Coord ph2_origin_(Coord c) const; + std::array,2> sofar_; + std::array>,2> rsolution_; +}; +} +#define TM get_TM() +#define TP get_TP() +namespace cube::solver { +inline bool is_dull_triple(const TurnMove A, const int B, const int C) +{ + return ( B>=Ux1 && B<=Bx3 ) && + ( (A/3==B/3) || ((C>=Ux1&&C<=Bx3) && A/3==C/3 && (3+A/3-B/3)%3==0) ) + ; +} +template +Coord TwoPhaseSolver::transform(const Coord &c, const TurnMove &m) +{ + if constexpr (I == Ph1) + return Coord { + (*TM.pTMTwist)[m][c.twist], (*TM.pTMFlip)[m][c.flip], (*TM.pTMSlice)[m][c.slice], + -1,-1,-1 + }; + else + return Coord { + 0,0,0, + (*TM.pTMCorner)[m][c.corner], (*TM.pTMEdge4)[m][c.edge4], (*TM.pTMEdge8)[m][c.edge8] + }; +} +template +size_t TwoPhaseSolver::distance(const Coord &c) +{ + if constexpr (I == Ph1) + return std::max((*TP.pTPSliceTwist)[c.slice][c.twist], + (*TP.pTPSliceFlip)[c.slice][c.flip]); + else + return std::max((*TP.pTPEdge4Corner)[c.edge4][c.corner], + (*TP.pTPEdge4Edge8)[c.edge4][c.edge8]); +} +template +bool TwoPhaseSolver::search_phase(const Coord &c, size_t togo) +{ + if(togo == 0) return distance(c) == 0; + if(togo < distance(c)) return false; + for(auto m: EM) + { + if(is_dull_triple(m,sofar_[PhX][togo],sofar_[PhX][togo+1])) continue; + sofar_[PhX][togo-1] = m; + bool ret = search_phase(transform(c,m), togo-1); + if(ret) return true; + } + return false; +} +Coord TwoPhaseSolver::ph2_origin_(Coord c) const +{ + int corner = c.corner, edge4, edge8; + auto ep = Coord::see2ep(c.slice,c.edge4,c.edge8); + for(auto &m : get_ph_solution_()) + { + corner = (*TM.pTMCorner)[m][corner]; + ep = ep * ElementaryMove[m].ep; + } + edge4 = Coord::ep2edge4(ep); + edge8 = Coord::ep2edge8(ep); + return Coord { 0,0,0,corner,edge4,edge8 }; +} +auto TwoPhaseSolver::solve(const Coord &c, int step, bool best) + -> std::tuple,std::vector> +{ + const size_t maxL = std::clamp(step,0,DS); + size_t solL = maxL + 1; + std::array,2> solution; + reset_ph_sofar_(); + reset_ph_sofar_(); + for(auto d1 = distance(c); d1 <= maxL; d1++) + { + bool ret1 = search_phase(c,d1); + if(!ret1) continue; + set_ph_solution_(d1); + auto c2 = ph2_origin_(c); + size_t togo = (solL > rsolution_[Ph1].first) ? solL - rsolution_[Ph1].first : 0; + for(auto d2 = distance(c2); d2 < togo; d2++) + { + bool ret2 = search_phase(c2,d2); + if(!ret2) continue; + set_ph_solution_(d2); + solution[Ph1] = get_ph_solution_(); + solution[Ph2] = get_ph_solution_(); + solL = solution[1].size() + solution[0].size(); + if(!best) goto found; + if(d2==0) goto found; else break; + } + } + if(solL > maxL) + return {false, {}, {}}; + found: + return std::make_tuple(true, solution[0], solution[1]); +} +} +#ifndef CUBE_EXPORT_H +#define CUBE_EXPORT_H +#ifdef CUBE_STATIC_DEFINE +# define CUBE_EXPORT +# define CUBE_NO_EXPORT +#else +# ifndef CUBE_EXPORT +# ifdef cube_EXPORTS +# define CUBE_EXPORT __attribute__((visibility("default"))) +# else +# define CUBE_EXPORT __attribute__((visibility("default"))) +# endif +# endif +# ifndef CUBE_NO_EXPORT +# define CUBE_NO_EXPORT __attribute__((visibility("hidden"))) +# endif +#endif +#ifndef CUBE_DEPRECATED +# define CUBE_DEPRECATED __attribute__ ((__deprecated__)) +#endif +#ifndef CUBE_DEPRECATED_EXPORT +# define CUBE_DEPRECATED_EXPORT CUBE_EXPORT CUBE_DEPRECATED +#endif +#ifndef CUBE_DEPRECATED_NO_EXPORT +# define CUBE_DEPRECATED_NO_EXPORT CUBE_NO_EXPORT CUBE_DEPRECATED +#endif +#if 0 +# ifndef CUBE_NO_DEPRECATED +# define CUBE_NO_DEPRECATED +# endif +#endif +#endif +#define CUBE_VERSION_FULL v0.4.0-alpha +#define CUBE_VERSION_MAJOR 0 +#define CUBE_VERSION_MINOR 4 +#define CUBE_VERSION_PATCH 0 +#define CUBE_VERSION_BUILD alpha +#if defined(__GNUC__) || defined(__clang__) + #define CUBE_EXPORT_FORCE CUBE_EXPORT __attribute__((used)) +#else + #define CUBE_EXPORT_FORCE CUBE_EXPORT +#endif +#ifdef __cplusplus + #define Default(x) = x +#else + #define Default(x) +#endif +#define CUBE_BS 128 +#define CUBE_ID "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB" +#ifndef CF_ENUM + #if defined(__cplusplus) + #define CF_ENUM(_type, _name) \ + int __CF_ENUM_##_name; \ + enum _name : _type + #elif defined(__clang__) || defined(__OBJC__) + #define CF_ENUM(_type, _name) \ + enum _name : _type _name; \ + enum _name: _type + #else + #define CF_ENUM(_type, _name) \ + _type _name; \ + enum + #endif +#endif +typedef CF_ENUM(int32_t,SolveResult) { + SolveResultSuccess = 0, + SolveResultUnsolvable = 1, + SolveResultNotFound = 2, + SolveResultInvalidSrc = 3, + SolveResultInvalidTgt = 4, + SolveResultUnknownErr = 5 +}; +#ifdef __cplusplus +extern "C" { +#endif +CUBE_EXPORT_FORCE inline const char *solve_result_to_string(SolveResult sr) { + switch(sr) { + case SolveResultSuccess: return "Success."; + case SolveResultUnsolvable: return "The cube configuration is unsolvable."; + case SolveResultNotFound: return "No solution found within the step limit."; + case SolveResultInvalidSrc: return "Invalid source color configuration."; + case SolveResultInvalidTgt: return "Invalid target color configuration."; + case SolveResultUnknownErr: return "Unknown error."; + default: return "???"; + } +} +CUBE_EXPORT SolveResult solve( + char* buf, + const char* src Default(CUBE_ID), + const char* tgt Default(CUBE_ID), + int step Default(30), + bool best Default(true) +); +CUBE_EXPORT bool solvable( + const char* color_cube Default(CUBE_ID) +); +CUBE_EXPORT bool facecube( + char* buf, + const char* maneuver Default(""), + const char *cube Default(CUBE_ID) +); +CUBE_EXPORT bool permutation( + char* buf, + const char* ms_or_cube Default(CUBE_ID), + int format Default(2) +); +#ifdef __cplusplus +} +#endif +namespace cube::show { +template +using StringArr = std::array; +inline constexpr StringArr< 8> CornerToString = { "urf", "ufl", "ulb", "ubr", "dfr", "dlf", "dbl", "drb" }; +inline constexpr StringArr<12> EdgeToString = { "ur","uf","ul","ub","dr","df","dl","db","fr","fl","bl","br" }; +inline constexpr StringArr< 6> CenterToString = { "u", "r", "f", "d", "l", "b" }; +inline constexpr StringArr< 3> OrientationToString = { "", "+", "-" }; +inline constexpr StringArr<18> Move2Str = { "U","U2","U'","R","R2","R'","F","F2","F'","D","D2","D'","L","L2","L'","B","B2","B'" }; +inline constexpr StringArr<54> Face2Str = { "U1","U2","U3","U4","U5","U6","U7","U8","U9","R1","R2","R3","R4","R5","R6","R7","R8","R9","F1","F2","F3","F4","F5","F6","F7","F8","F9","D1","D2","D3","D4","D5","D6","D7","D8","D9","L1","L2","L3","L4","L5","L6","L7","L8","L9","B1","B2","B3","B4","B5","B6","B7","B8","B9" }; +inline constexpr std::string_view ColorSet = "URFDLB"; +inline constexpr std::string_view CornerSet = "ABCDEFGH"; +inline constexpr std::string_view EdgeSet = "opqrstuvwxyz"; +enum class CubeFormat { + Face, + Cubie, + Cycle +}; +template +inline std::string seq2str_fmt(const Array &xs, + Formatter && fmt, + std::string_view sep="", + std::string_view pre="", + std::string_view suf="") +{ + const size_t len = xs.size(); + if(len == 0) { return std::string(pre) + std::string(suf); } + std::stringstream ss; + ss << pre << fmt(xs[0]); + for(size_t i = 1; i < len; ++i) ss << sep << fmt(xs[i]); + ss << suf; + return ss.str(); +} +template +inline std::string seq2str(const Container &xs, + std::string_view sep="", + std::string_view pre="", + std::string_view suf="") +{ + auto default_formatter = [](const auto& val) { + using T = std::decay_t; + if constexpr (std::is_same_v || std::is_same_v) { + return static_cast(val); + } else { + return val; + } + }; + return seq2str_fmt(xs, default_formatter, sep, pre, suf); +} +std::string to_string(const ColorState& cs) +{ + return seq2str_fmt(cs.s, [](auto v) { + switch(v){ + case U: return 'U'; + case R: return 'R'; + case F: return 'F'; + case D: return 'D'; + case L: return 'L'; + case B: return 'B'; + default: throw std::invalid_argument("to_string(ColorState): ???"); + } + }); +} +std::string to_string(const FaceCube& fc, bool use_digit=true) +{ + if(use_digit){ + return seq2str(fc.f); + } else { + return seq2str_fmt(fc.f, [](auto v) { return Face2Str[v]; }); + } +} +std::string to_string(const CubieCube& cc, CubeFormat fmt) +{ + switch(fmt){ + case CubeFormat::Face: + return to_string(cc.toFaceCube(), false); + case CubeFormat::Cubie: + return seq2str_fmt(cc.cp, [](auto v) { return CornerSet[v]; }) + + seq2str_fmt(cc.co, [](auto v) { return static_cast('0'+v); }) + + seq2str_fmt(cc.ep, [](auto v) { return EdgeSet[v]; }) + + seq2str_fmt(cc.eo, [](auto v) { return static_cast('0'+v);}); + default: + const auto [fixed_corner,cycles_corner] = decomposite(cc.cp); + const auto [fixed_edge, cycles_edge ] = decomposite(cc.ep); + std::string s1, s2; + s1.reserve(64); + s2.reserve(64); + auto append_fixed = [&](std::string& out, const auto& fixed, const auto& ori_arr, auto name_table) { + for(auto idx: fixed) { + if(ori_arr[idx] == 0) continue; + out += '('; + out += OrientationToString[ori_arr[idx]]; + out += name_table[idx]; + out += ')'; + } + }; + auto append_cycles = [&](std::string& out, const auto& cycles, const auto& ori_arr, auto name_table) { + for(const auto& cycle: cycles) { + const size_t N = cycle.size(); + if(N == 0) continue; + out += '('; + for(int i = 0; i < N; i++) { + if(i > 0) out += ','; + size_t prev_idx = cycle[(N-1+i)%N]; + out += OrientationToString[ori_arr[prev_idx]]; + out += name_table[cycle[i]]; + } + out += ')'; + } + }; + append_fixed(s1, fixed_corner, cc.co, CornerToString); + append_cycles(s1, cycles_corner, cc.co, CornerToString); + append_fixed(s2, fixed_edge, cc.eo, EdgeToString); + append_cycles(s2, cycles_edge, cc.eo, EdgeToString); + return s1.empty() && s2.empty() ? "id" : s1 + s2; + } +} +std::string to_string(const std::vector& ms) +{ + return seq2str_fmt(ms, [](auto v){ + return Move2Str[v]; + }, " "); +} +} +using namespace cube; +const std::string_view cid = CUBE_ID; +cube::solver::TwoPhaseSolver TPS; +std::string apply_moves(std::string_view s, const std::vector &ms) +{ + assert(s.size() == 54 && "invalid cube length"); + char buf[2][54]; + std::memcpy(buf[0], s.data(), 54); + size_t curr = 0; + for(const auto &m : ms) + { + const auto& p = ElementaryPerm[m].f; + const char* src = buf[curr]; + char* dst = buf[1-curr]; + for(int i = 0; i < 54; ++i) dst[i] = src[p[i]]; + curr = 1-curr; + } + return std::string(buf[curr],54); +} +SolveResult solve( + char* buf, const char *src, const char* tgt, int step, bool best) +{ + auto s_src = src == NULL ? cid : std::string_view(src); + auto s_tgt = tgt == NULL ? cid : std::string_view(tgt); + if(s_src != cid && !cube::utils::is_valid_config(s_src)) return SolveResultInvalidSrc; + if(s_tgt != cid && !cube::utils::is_valid_config(s_tgt)) return SolveResultInvalidTgt; + if(s_src == s_tgt) { buf[0] = '\0'; return SolveResultSuccess; } + auto cc_src = ColorState::fromString(s_src).toCubieCube(); + auto cc_tgt = ColorState::fromString(s_tgt).toCubieCube(); + CubieCube cc = ~cc_tgt*cc_src; + if(!cc.isSolvable()) return SolveResultUnsolvable; + const auto & [found, s1, s2] = TPS.solve(cube::pdb::Coord::CubieCube2Coord(cc), step, best); + if(!found) return SolveResultNotFound; + std::vector sol = [](const auto &s1, const auto &s2) { + std::vector solution; + size_t n1 = s1.size(), n2 = s2.size(); + if(!s1.empty() && !s2.empty() && s1[n1-1]/3 == s2[0]/3) { + std::copy(s1.begin(), s1.end()-1, std::back_inserter(solution)); + int m = (s1[n1-1] + s2[0]- s2[0]/3 *6 +2) %4; + if(m!=0) solution.push_back(static_cast(s2[0]/3*3+m-1)); + std::copy(s2.begin()+1, s2.end(), std::back_inserter(solution)); + } else { + std::copy(s1.begin(), s1.end(), std::back_inserter(solution)); + std::copy(s2.begin(), s2.end(), std::back_inserter(solution)); + } + return solution; + }(s1,s2); + auto s = show::to_string(sol); + std::copy(s.cbegin(), s.cend(), buf); + buf[s.length()] = '\0'; + return SolveResultSuccess; +} +bool solvable(const char* cube) +{ + return cube::utils::is_valid_config(cube) + && ColorState::fromString(cube).toCubieCube().isSolvable(); +} +bool facecube(char* buf, const char *maneuver, const char *cube) +{ + if(!buf) return false; + std::string cube_str = cube ? std::string(cube) : std::string(CUBE_ID); + std::string maneuver_str = maneuver ? std::string(maneuver) : std::string(""); + if(cube_str.size()!= 54 || !cube::utils::is_valid_maneuver(maneuver_str)) { + buf[0] = '\0'; + return false; + } + const auto ms = cube::utils::parse_manuever(maneuver_str); + const auto color = apply_moves(cube_str, ms); + std::copy(color.cbegin(), color.cend(), buf); + buf[color.length()] = '\0'; + return true; +} +bool permutation(char* buf, const char* ms_or_cube, int format) +{ + if(!buf) return false; + std::string cube_str{}; + if(ms_or_cube) { + if(cube::utils::is_valid_config(ms_or_cube)) { + cube_str = std::string(ms_or_cube); + } else if(cube::utils::is_valid_maneuver(ms_or_cube)) { + auto ms = cube::utils::parse_manuever(ms_or_cube); + cube_str = apply_moves(cid,ms); + } else { + buf[0] = '\0'; + return false; + } + } else { + cube_str = cid; + } + std::string perm_str{}; + auto cc = ColorState::fromString(cube_str).toCubieCube(); + perm_str = show::to_string(cc, show::CubeFormat(format)); + std::copy(perm_str.cbegin(), perm_str.cend(), buf); + buf[perm_str.length()] = '\0'; + return true; +} +namespace cube::internal { +namespace fs = std::filesystem; +static std::string& get_custom_dir_storage() +{ + static std::string custom_dir = ""; + return custom_dir; +} +void set_table_dir(std::string_view dir) +{ + get_custom_dir_storage() = dir; +} +fs::path get_table_dir() +{ + std::string user_dir = get_custom_dir_storage(); + if(!user_dir.empty()) return fs::path(user_dir); + if(const char *env = std::getenv("CUBE_TABLE_DIR")) { + if(env[0] != '\0') return fs::path(env); + } + try { + return cube::utils::get_cache_dir() / "cube" / "tables"; + } catch (...) {} + return fs::current_path() / "tables"; +} +bool is_table_ready() +{ + return fs::exists(get_table_dir() / "tm_twist.dat"); +} +void preload_tables() +{ + (void)pdb::get_TM(); + (void)pdb::get_TP(); +} +} diff --git a/cube-hs.cabal b/cube-hs.cabal new file mode 100644 --- /dev/null +++ b/cube-hs.cabal @@ -0,0 +1,118 @@ +cabal-version: 3.0 +-- The cabal-version field refers to the version of the .cabal specification, +-- and can be different from the cabal-install (the tool) version and the +-- Cabal (the library) version you are using. As such, the Cabal (the library) +-- version used must be equal or greater than the version stated in this field. +-- Starting from the specification version 2.2, the cabal-version field must be +-- the first thing in the cabal file. + +-- Initial package description 'cube-hs' generated by +-- 'cabal init'. For further documentation, see: +-- http://haskell.org/cabal/users-guide/ +-- +-- The name of the package. +name: cube-hs + +-- The package version. +-- See the Haskell package versioning policy (PVP) for standards +-- guiding when and how versions should be incremented. +-- https://pvp.haskell.org +-- PVP summary: +-+------- breaking API changes +-- | | +----- non-breaking API additions +-- | | | +--- code changes with no API change +version: 0.4.0.0 + +-- A short (one-line) description of the package. +synopsis: High-performance, type-safe Rubik's Cube solver with C FFI bindings. + +-- A longer description of the package. +description: A professional Haskell library providing algebraic operations and zero-cost FFI bindings to C solvers for Rubik's Cube. + +-- The license under which the package is released. +license: MIT + +-- The file containing the license text. +license-file: LICENSE + +-- The package author(s). +author: coshz +maintainer: fsinhx@gmail.com + +-- A copyright notice. +-- copyright: + +category: Game, Data Structures, Algorithms +homepage: https://github.com/coshz/cube +bug-reports: https://github.com/coshz/cube/issues + +build-type: Simple + +-- Extra doc files to be distributed with the package, such as a CHANGELOG or a README. +extra-doc-files: CHANGELOG.md + README.md + +-- Extra source files to be distributed with the package, such as examples, or a tutorial module. +extra-source-files: + cbits/cube_amalg.min.cpp + +common warnings + ghc-options: -Wall + +library + -- Import common warning flags. + import: warnings + + -- Modules exported by the library. + exposed-modules: Data.Cube + , Data.Cube.Internal + + -- Modules included in this library but not exported. + other-modules: Data.Cube.Def + , Data.Cube.FFI + , Data.Cube.Raw + + -- LANGUAGE extensions used by modules in this package. + -- other-extensions: + + -- Other library packages from which modules are imported. + build-depends: base >= 4.14 && < 5 + , array ^>= 0.5 + , vector-sized ^>= 1.6.1 + , system-cxx-std-lib ^>= 1.0 + + -- Directories containing source files. + hs-source-dirs: src + + -- Base language which the package is written in. + default-language: Haskell2010 + + cxx-sources: cbits/cube_amalg.min.cpp + include-dirs: cbits + cxx-options: -std=c++17 + +test-suite cube-hs-test + -- Import common warning flags. + import: warnings + + -- Base language which the package is written in. + default-language: Haskell2010 + + -- Modules included in this executable, other than Main. + -- other-modules: + + -- LANGUAGE extensions used by modules in this package. + -- other-extensions: + + -- The interface type and version of the test suite. + type: exitcode-stdio-1.0 + + -- Directories containing source files. + hs-source-dirs: test + + -- The entrypoint to the test suite. + main-is: Main.hs + + -- Test dependencies. + build-depends: + base ^>=4.18.3.0, + cube-hs diff --git a/src/Data/Cube.hs b/src/Data/Cube.hs new file mode 100644 --- /dev/null +++ b/src/Data/Cube.hs @@ -0,0 +1,60 @@ +-- | +-- Module : Data.Cube +-- Description : High-performance, type-safe Rubik's Cube library +-- Copyright : (c) coshz, 2026 +-- License : MIT +-- Maintainer : fsinhx@gmail.com +-- Stability : stable +-- +-- This module provides a safe-by-default Haskell interface for 3x3 Rubik's Cube +-- manipulation and solving via C FFI. +-- +-- === Example Usage +-- @ +-- import Data.Cube +-- +-- main :: IO () +-- main = do +-- -- 1. Verify standard solved state representation +-- let initStr = showCube cubeId +-- putStrLn $ "Is initial cube legal? " ++ show (isLegalCubeString initStr) +-- +-- -- 2. Parse standard WCA scramble sequence +-- let scrambledTurns = fromMaybe [] $ parseTurns "U F U' L2 R L' D2 B" +-- putStrLn $ "Is the count of turns is 8? " ++ show (length scrambledTurns == 8) +-- +-- -- 3. Apply group action (&>) to scramble the solved identity cube +-- let scrambledCube = foldl (&>) cubeId scrambledTurns +-- putStrLn $ "Scrambled state: " ++ showCube scrambledCube +-- +-- -- 4. Solve using zero-cost C FFI solver and verify restoration +-- let sol = unsafeSolveFrom scrambledCube +-- putStrLn $ "Optimal solution steps: " ++ showTurns sol +-- putStrLn $ "Is fully restored? " ++ show (applyTurns scrambledCube sol == cubeId) +-- @ + +module Data.Cube +( + -- * Core Types + Turn(..) +, Cube + -- * Identity & Constants +, cubeId + -- * Validation & Formatting +, isLegalCubeString +, showCube +, parseCube + -- * Algebraic Operations & Group Actions +, (&>) +, applyTurns + -- * WCA Turns Representation +, showTurns +, parseTurns + -- * Solving Interface (C FFI) +, solve +, unsafeSolve +, solveFrom +, unsafeSolveFrom +) where + +import Data.Cube.Internal diff --git a/src/Data/Cube/Def.hs b/src/Data/Cube/Def.hs new file mode 100644 --- /dev/null +++ b/src/Data/Cube/Def.hs @@ -0,0 +1,98 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MultiParamTypeClasses #-} + +module Data.Cube.Def where + +import Data.Cube.Raw (rawBase6) + +import Data.Vector.Sized (Vector) +import qualified Data.Vector.Sized as V +import Data.Array (Array, listArray, (!)) +import Data.Maybe (fromMaybe) +import Data.List (sort) + +data Color = U | R | F | D | L | B + deriving (Eq, Show, Enum, Bounded) + +data Face + = U1 | U2 | U3 | U4 | U5 | U6 | U7 | U8 | U9 + | R1 | R2 | R3 | R4 | R5 | R6 | R7 | R8 | R9 + | F1 | F2 | F3 | F4 | F5 | F6 | F7 | F8 | F9 + | D1 | D2 | D3 | D4 | D5 | D6 | D7 | D8 | D9 + | L1 | L2 | L3 | L4 | L5 | L6 | L7 | L8 | L9 + | B1 | B2 | B3 | B4 | B5 | B6 | B7 | B8 | B9 + deriving (Eq, Show, Enum, Bounded) + +data Turn + = Ux1 | Ux2 | Ux3 + | Rx1 | Rx2 | Rx3 + | Fx1 | Fx2 | Fx3 + | Dx1 | Dx2 | Dx3 + | Lx1 | Lx2 | Lx3 + | Bx1 | Bx2 | Bx3 + deriving (Eq, Show, Enum, Bounded) + +newtype Cube = Cube (Vector 54 Color) + deriving (Eq) + +newtype Move = Move (Vector 54 Int) + deriving (Eq) + +instance Semigroup Move where + Move m1 <> Move m2 = Move (V.backpermute m1 m2) + +instance Monoid Move where + mempty = Move (fromMaybe (error "mempty") (V.fromList [0..53])) + +class ActsOn c m where + (&>) :: c -> m -> c + +instance ActsOn Cube Move where + (Cube c) &> (Move p) = Cube (V.backpermute c p) + +class Actionable a where + toMove :: a -> Move + + toAction :: a -> (Cube -> Cube) + toAction a = (&> toMove a) + +instance Actionable a => Actionable [a] where + toMove = mconcat . map toMove + +instance Actionable Move where + toMove = id + +instance Show Cube where + show (Cube v) = "Cube " ++ show (V.toList v) + +instance Show Move where + show (Move v) = "Move " ++ show (map (toEnum :: Int -> Face) (V.toList v)) + +instance ActsOn Cube Turn where + c &> t = c &> toMove t + +instance Actionable Turn where + toMove t = moveTable_ ! fromEnum t + +moveTable_ :: Array Int Move +moveTable_ = listArray(0,17) (concatMap powers base6) where + powers v = [v, v <> v, v <> v <> v] + base6 = map unsafeMoveFromRaw rawBase6 + +moveFaces :: Move -> [Face] +moveFaces (Move v) = map toEnum (V.toList v) + +showAction :: Actionable a => a -> String +showAction a = "Action " ++ show (moveFaces (toMove a)) + +moveFromRaw :: [Int] -> Maybe Move +moveFromRaw xs + | isValidPerm xs = Move <$> V.fromList (map toEnum xs) + | otherwise = Nothing + where + isValidPerm ys = sort ys == [0..53] + +unsafeMoveFromRaw :: [Int] -> Move +unsafeMoveFromRaw xs = case moveFromRaw xs of + Just m -> m + Nothing -> error "unsafeMoveFromRaw: input is not a valid 0..53 permutation" diff --git a/src/Data/Cube/FFI.hs b/src/Data/Cube/FFI.hs new file mode 100644 --- /dev/null +++ b/src/Data/Cube/FFI.hs @@ -0,0 +1,25 @@ +module Data.Cube.FFI where + +import Foreign.C.Types (CInt(..), CBool(..)) +import Foreign.C.String (CString) + +foreign import ccall "solve" + c_solve + :: CString -- buffer + -> CString -- src color + -> CString -- tgt color + -> CInt -- step + -> CBool -- best + -> IO CInt + +foreign import ccall "solvable" + c_solvable :: CString -> IO CBool + +foreign import ccall "permutation" + c_permutation + :: CString -- buffer + -> CString -- cube or maneuver string + -> IO CInt + +foreign import ccall "solve_result_to_string" + c_solve_result_to_string :: CInt -> IO CString diff --git a/src/Data/Cube/Internal.hs b/src/Data/Cube/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Data/Cube/Internal.hs @@ -0,0 +1,132 @@ +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} + +module Data.Cube.Internal +( + Color(..) +, Face(..) +, Turn(..) +, Move(..) +, Cube +, ActsOn(..) +, Actionable(..) +, moveFaces +, moveFromRaw +, unsafeMoveFromRaw +, showAction +, cubeId +, isLegalCubeString +, showCube +, parseCube +, applyTurns +, showTurns +, parseTurns +, solve +, unsafeSolve +, solveFrom +, unsafeSolveFrom +) +where + +import Data.Cube.Def +import Data.Cube.FFI + +import qualified Data.Vector.Sized as V +import Data.Maybe (fromMaybe) +import System.IO.Unsafe (unsafePerformIO) +import Foreign (allocaBytes) +import Foreign.C (peekCString) +import Foreign.C.String (withCString) +import Foreign.C.Types (CBool(..)) + + +cubeId :: Cube +cubeId = Cube (fromMaybe (error "cId") (V.fromList (concatMap (replicate 9) [U .. B]))) + +showCube :: Cube -> String +showCube (Cube v) = concatMap show (V.toList v) + +parseCube :: String -> Maybe Cube +parseCube cubeStr + | isLegalCubeString cubeStr = do + colors <- mapM charToColor cubeStr + Cube <$> V.fromList colors + | otherwise = Nothing + where + charToColor :: Char -> Maybe Color + charToColor c = case c of + 'U' -> Just U + 'R' -> Just R + 'F' -> Just F + 'D' -> Just D + 'L' -> Just L + 'B' -> Just B + _ -> Nothing + +isLegalCubeString :: String -> Bool +isLegalCubeString str = + length str == 54 && + unsafePerformIO (withCString str $ \c_str -> do + CBool res <- c_solvable c_str + return (res /= 0)) + +applyTurns :: Cube -> [Turn] -> Cube +applyTurns = foldl (&>) + +parseTurns :: String -> Maybe [Turn] +parseTurns str = mapM stringToTurn (words str) where + stringToTurn :: String -> Maybe Turn + stringToTurn s = case s of + "U" -> Just Ux1; "U2" -> Just Ux2; "U'" -> Just Ux3 + "R" -> Just Rx1; "R2" -> Just Rx2; "R'" -> Just Rx3 + "F" -> Just Fx1; "F2" -> Just Fx2; "F'" -> Just Fx3 + "D" -> Just Dx1; "D2" -> Just Dx2; "D'" -> Just Dx3 + "L" -> Just Lx1; "L2" -> Just Lx2; "L'" -> Just Lx3 + "B" -> Just Bx1; "B2" -> Just Bx2; "B'" -> Just Bx3 + _ -> Nothing + +showTurns :: [Turn] -> String +showTurns ts = unwords (map turnToString ts) where + turnToString :: Turn -> String + turnToString t = case t of + Ux1 -> "U"; Ux2 -> "U2"; Ux3 -> "U'" + Rx1 -> "R"; Rx2 -> "R2"; Rx3 -> "R'" + Fx1 -> "F"; Fx2 -> "F2"; Fx3 -> "F'" + Dx1 -> "D"; Dx2 -> "D2"; Dx3 -> "D'" + Lx1 -> "L"; Lx2 -> "L2"; Lx3 -> "L'" + Bx1 -> "B"; Bx2 -> "B2"; Bx3 -> "B'" + +solve :: Cube -> Cube -> Either String [Turn] +solve src tgt = unsafePerformIO $ + withCString (showCube src) $ \c_src -> + withCString (showCube tgt) $ \c_tgt -> + allocaBytes 128 $ \c_buf -> do + resCode <- c_solve c_buf c_src c_tgt 30 (CBool 1) + if resCode == 0 + then parseCSolution c_buf + else handleErr resCode + where + parseCSolution buf = do + str <- peekCString buf + return $ case parseTurns str of + Just turns -> Right turns + Nothing -> Left $ "failed to parse solver string: " ++ show str + + handleErr code = do + errPtr <- c_solve_result_to_string code + errStr <- peekCString errPtr + return $ Left $ "Solver error (" ++ show code ++ "): "++ errStr + + +unsafeSolve :: Cube -> Cube -> [Turn] +unsafeSolve src tgt = case solve src tgt of + Left err -> error err + Right ts -> ts + +solveFrom :: Cube -> Either String [Turn] +solveFrom c = solve c cubeId + +unsafeSolveFrom :: Cube -> [Turn] +unsafeSolveFrom c = unsafeSolve c cubeId diff --git a/src/Data/Cube/Raw.hs b/src/Data/Cube/Raw.hs new file mode 100644 --- /dev/null +++ b/src/Data/Cube/Raw.hs @@ -0,0 +1,12 @@ +module Data.Cube.Raw +( rawBase6 +) where + +rawBase6 :: [[Int]] +rawBase6 = [mU,mR,mF,mD,mL,mB] where + mU = [6,3,0,7,4,1,8,5,2,45,46,47,12,13,14,15,16,17,9,10,11,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,18,19,20,39,40,41,42,43,44,36,37,38,48,49,50,51,52,53] + mR = [0,1,20,3,4,23,6,7,26,15,12,9,16,13,10,17,14,11,18,19,29,21,22,32,24,25,35,27,28,51,30,31,48,33,34,45,36,37,38,39,40,41,42,43,44,8,46,47,5,49,50,2,52,53] + mF = [0,1,2,3,4,5,44,41,38,6,10,11,7,13,14,8,16,17,24,21,18,25,22,19,26,23,20,15,12,9,30,31,32,33,34,35,36,37,27,39,40,28,42,43,29,45,46,47,48,49,50,51,52,53] + mD = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,24,25,26,18,19,20,21,22,23,42,43,44,33,30,27,34,31,28,35,32,29,36,37,38,39,40,41,51,52,53,45,46,47,48,49,50,15,16,17] + mL = [53,1,2,50,4,5,47,7,8,9,10,11,12,13,14,15,16,17,0,19,20,3,22,23,6,25,26,18,28,29,21,31,32,24,34,35,42,39,36,43,40,37,44,41,38,45,46,33,48,49,30,51,52,27] + mB = [11,14,17,3,4,5,6,7,8,9,10,35,12,13,34,15,16,33,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,36,39,42,2,37,38,1,40,41,0,43,44,51,48,45,52,49,46,53,50,47] diff --git a/test/Main.hs b/test/Main.hs new file mode 100644 --- /dev/null +++ b/test/Main.hs @@ -0,0 +1,41 @@ +module Main (main) where + +import Data.Cube + +import System.Exit (exitFailure) +import Data.Maybe (fromMaybe) + +assertTest :: String -> Bool -> IO() +assertTest name predicate = do + putStr $ "[Test] -- " ++ name ++ "..." + if predicate + then putStrLn "\ESC[32m[PASSED]\ESC[0m" + else do + putStrLn "\ESC[31m[FAILED]\ESC[0m" + exitFailure + + +main :: IO () +main = do + let initStr = showCube cubeId + assertTest "Initial cube color string matches standard" + (initStr == "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB") + + assertTest "Standard initial cube is legal" + (isLegalCubeString initStr) + + let identityMoves = unsafeSolveFrom cubeId + assertTest "Solving already solved cube returns no moves" + (null identityMoves) + + let scrambledTurns = fromMaybe [] $ parseTurns "U F U' L2 R L' D2 B" + assertTest "Parsing valid turns" + (scrambledTurns == [Ux1, Fx1, Ux3, Lx2, Rx1, Lx3, Dx2, Bx1]) + + let scrambledCube = foldl (&>) cubeId scrambledTurns + assertTest "Verifying scrambled cube string" + (showCube scrambledCube == "FFLBURBURUUFRRRDDBUFBUFDFBRUDFBDFLLRDLLULLBRRULLFBBDDD") + + let sol = unsafeSolveFrom scrambledCube + assertTest "Verifying solution" + (applyTurns scrambledCube sol == cubeId)