Reworked moves and transformations, moved some stuff

1 files changed, 375 insertions, 63 deletions

diff --git a/src/cube.c b/src/cube.c
index fc04ee7..bb36447 100644
--- a/src/cube.c
+++ b/src/cube.c
@@ -2,17 +2,121 @@
 #include <stdbool.h>
 #include <string.h>
 
-#ifdef CUBE_AVX2
-#include <immintrin.h>
-#endif
-
 #ifdef DEBUG
 #include <stdio.h>
 #endif
 
+#ifdef AVX2
+#include <immintrin.h>
+#endif
+
 #include "cube.h"
 
-#include "_constants.c"
+#define U  0U
+#define U2 1U
+#define U3 2U
+#define D  3U
+#define D2 4U
+#define D3 5U
+#define R  6U
+#define R2 7U
+#define R3 8U
+#define L  9U
+#define L2 10U
+#define L3 11U
+#define F  12U
+#define F2 13U
+#define F3 14U
+#define B  15U
+#define B2 16U
+#define B3 17U
+
+#define UFr 0
+#define ULr 1
+#define UBr 2
+#define URr 3
+#define DFr 4
+#define DLr 5
+#define DBr 6
+#define DRr 7
+#define RUr 8
+#define RFr 9
+#define RDr 10
+#define RBr 11
+#define LUr 12
+#define LFr 13
+#define LDr 14
+#define LBr 15
+#define FUr 16
+#define FRr 17
+#define FDr 18
+#define FLr 19
+#define BUr 20
+#define BRr 21
+#define BDr 22
+#define BLr 23
+
+#define UFm 24
+#define ULm 25
+#define UBm 26
+#define URm 27
+#define DFm 28
+#define DLm 29
+#define DBm 30
+#define DRm 31
+#define RUm 32
+#define RFm 33
+#define RDm 34
+#define RBm 35
+#define LUm 36
+#define LFm 37
+#define LDm 38
+#define LBm 39
+#define FUm 40
+#define FRm 41
+#define FDm 42
+#define FLm 43
+#define BUm 44
+#define BRm 45
+#define BDm 46
+#define BLm 47
+
+#define errormove 99U
+#define errortrans 99U
+
+#define _c_ufr      0U
+#define _c_ubl      1U
+#define _c_dfl      2U
+#define _c_dbr      3U
+#define _c_ufl      4U
+#define _c_ubr      5U
+#define _c_dfr      6U
+#define _c_dbl      7U
+
+#define _e_uf       0U
+#define _e_ub       1U
+#define _e_db       2U
+#define _e_df       3U
+#define _e_ur       4U
+#define _e_ul       5U
+#define _e_dl       6U
+#define _e_dr       7U
+#define _e_fr       8U
+#define _e_fl       9U
+#define _e_bl       10U
+#define _e_br       11U
+
+#define _eoshift    4U
+#define _coshift    5U
+
+#define _pbits      0xFU
+#define _eobit      0x10U
+#define _cobits     0xF0U
+#define _cobits2    0x60U
+#define _ctwist_cw  0x20U
+#define _ctwist_ccw 0x40U
+#define _eflip      0x10U
+#define _error      0xFFU
 
 cube_arr_t solvedcube_arr = {
         .c = {0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0},
@@ -36,18 +140,133 @@ cube_arr_t zerocube_arr = { .e = {0}, .c = {0} };
     _mm256_andnot_si256(cube, _mm256_slli_si256(_c, 0)), \
     _mm256_and_si256(_mm256_set1_epi8(p), _mm256_slli_si256(_c, 0)))
 
+#include "_moves_avx2.c"
+#include "_trans_avx2.c"
+
 #else
 
 #define setsolved(cube) cube = solvedcube_arr
 #define setzero(cube)   cube = zerocube_arr
-#define _c _mm256_set_epi64x(0, 0, 0, 0xFF)
 #define get_edge(cube, i)      (cube).e[(i)]
 #define get_corner(cube, i)    (cube).c[(i)]
 #define set_edge(cube, i, p)   (cube).e[(i)] = (p)
 #define set_corner(cube, i, p) (cube).c[(i)] = (p)
 
+#include "_moves_arr.c"
+#include "_trans_arr.c"
+
 #endif
 
+
+static char *cornerstr[] = {
+        [_c_ufr] = "UFR",
+        [_c_ubl] = "UBL",
+        [_c_dfl] = "DFL",
+        [_c_dbr] = "DBR",
+        [_c_ufl] = "UFL",
+        [_c_ubr] = "UBR",
+        [_c_dfr] = "DFR",
+        [_c_dbl] = "DBL"
+};
+
+static char *cornerstralt[] = {
+        [_c_ufr] = "URF",
+        [_c_ubl] = "ULB",
+        [_c_dfl] = "DLF",
+        [_c_dbr] = "DRB",
+        [_c_ufl] = "ULF",
+        [_c_ubr] = "URB",
+        [_c_dfr] = "DRF",
+        [_c_dbl] = "DLB"
+};
+
+static char *edgestr[] = {
+        [_e_uf] = "UF",
+        [_e_ub] = "UB",
+        [_e_db] = "DB",
+        [_e_df] = "DF",
+        [_e_ur] = "UR",
+        [_e_ul] = "UL",
+        [_e_dl] = "DL",
+        [_e_dr] = "DR",
+        [_e_fr] = "FR",
+        [_e_fl] = "FL",
+        [_e_bl] = "BL",
+        [_e_br] = "BR"
+};
+
+static char *movestr[] = {
+        [U]  = "U",
+        [U2] = "U2",
+        [U3] = "U'",
+        [D]  = "D",
+        [D2] = "D2",
+        [D3] = "D'",
+        [R]  = "R",
+        [R2] = "R2",
+        [R3] = "R'",
+        [L]  = "L",
+        [L2] = "L2",
+        [L3] = "L'",
+        [F]  = "F",
+        [F2] = "F2",
+        [F3] = "F'",
+        [B]  = "B",
+        [B2] = "B2",
+        [B3] = "B'",
+};
+
+static char *transstr[] = {
+        [UFr] = "rotation UF",
+        [UFm] = "mirrored UF",
+        [ULr] = "rotation UL",
+        [ULm] = "mirrored UL",
+        [UBr] = "rotation UB",
+        [UBm] = "mirrored UB",
+        [URr] = "rotation UR",
+        [URm] = "mirrored UR",
+        [DFr] = "rotation DF",
+        [DFm] = "mirrored DF",
+        [DLr] = "rotation DL",
+        [DLm] = "mirrored DL",
+        [DBr] = "rotation DB",
+        [DBm] = "mirrored DB",
+        [DRr] = "rotation DR",
+        [DRm] = "mirrored DR",
+        [RUr] = "rotation RU",
+        [RUm] = "mirrored RU",
+        [RFr] = "rotation RF",
+        [RFm] = "mirrored RF",
+        [RDr] = "rotation RD",
+        [RDm] = "mirrored RD",
+        [RBr] = "rotation RB",
+        [RBm] = "mirrored RB",
+        [LUr] = "rotation LU",
+        [LUm] = "mirrored LU",
+        [LFr] = "rotation LF",
+        [LFm] = "mirrored LF",
+        [LDr] = "rotation LD",
+        [LDm] = "mirrored LD",
+        [LBr] = "rotation LB",
+        [LBm] = "mirrored LB",
+        [FUr] = "rotation FU",
+        [FUm] = "mirrored FU",
+        [FRr] = "rotation FR",
+        [FRm] = "mirrored FR",
+        [FDr] = "rotation FD",
+        [FDm] = "mirrored FD",
+        [FLr] = "rotation FL",
+        [FLm] = "mirrored FL",
+        [BUr] = "rotation BU",
+        [BUm] = "mirrored BU",
+        [BRr] = "rotation BR",
+        [BRm] = "mirrored BR",
+        [BDr] = "rotation BD",
+        [BDm] = "mirrored BD",
+        [BLr] = "rotation BL",
+        [BLm] = "mirrored BL",
+};
+
 static bool isconsistent(cube_t);
 static cube_t flipallcorners(cube_t);
 static uint8_t readco(char *);
@@ -187,9 +406,9 @@ readcube(format_t format, char *buf)
                 ret = readcube_H48(buf);
                 break;
         default:
-        #ifdef DEBUG
+#ifdef DEBUG
                 fprintf(stderr, "Cannot read cube in the given format\n");
-        #endif
+#endif
                 setzero(ret);
         }
 
@@ -421,18 +640,6 @@ writetrans(trans_t t, char *buf)
         buf[11] = '\0';
 }
 
-move_t
-inverse_move(move_t m)
-{
-        return inverse_move_arr[m];
-}
-
-trans_t
-inverse_trans(trans_t t)
-{
-        return inverse_trans_arr[t];
-}
-
 static int
 permsign(uint8_t *a, int n)
 {
@@ -617,11 +824,49 @@ move(cube_t c, move_t m)
         }
 #endif
 
-#ifdef CUBE_AVX2
-#include "_move_logic_avx2.c"
-#else
-#include "_move_logic_arr.c"
+        switch (m) {
+        case U:
+                return inline_move_U(c);
+        case U2:
+                return inline_move_U2(c);
+        case U3:
+                return inline_move_U3(c);
+        case D:
+                return inline_move_D(c);
+        case D2:
+                return inline_move_D2(c);
+        case D3:
+                return inline_move_D3(c);
+        case R:
+                return inline_move_R(c);
+        case R2:
+                return inline_move_R2(c);
+        case R3:
+                return inline_move_R3(c);
+        case L:
+                return inline_move_L(c);
+        case L2:
+                return inline_move_L2(c);
+        case L3:
+                return inline_move_L3(c);
+        case F:
+                return inline_move_F(c);
+        case F2:
+                return inline_move_F2(c);
+        case F3:
+                return inline_move_F3(c);
+        case B:
+                return inline_move_B(c);
+        case B2:
+                return inline_move_B2(c);
+        case B3:
+                return inline_move_B3(c);
+        default:
+#ifdef DEBUG
+                fprintf(stderr, "mover error, unknown move\n");
 #endif
+                goto move_error;
+        }
 
 move_error:
         setzero(err);
@@ -696,56 +941,123 @@ compose(cube_t c1, cube_t c2)
         return ret;
 }
 
-static cube_t
-flipallcorners(cube_t c)
-{
-/* TODO: optimize for avx2, can be a couple of instructions */
-
-        uint8_t i, piece, orien;
-        cube_t ret;
-
-        ret = c;
-        for (i = 0; i < 8; i++) {
-                piece = get_corner(c, i);
-                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
-                set_corner(ret, i, (piece & _pbits) | orien);
-        }
-
-        return ret;
-}
-
 cube_t
 transform(cube_t c, trans_t t)
 {
-        cube_t ret, solved;
+        cube_t ret;
 
 #ifdef DEBUG
-        setzero(ret);
         if (!isconsistent(c)) {
                 fprintf(stderr, "transform error, inconsistent cube\n");
-                return ret;
-        }
-        if (t >= 48) {
-                fprintf(stderr, "transform error, unknown transformation\n");
-                return ret;
+                goto trans_error;
         }
 #endif
 
-#ifdef CUBE_AVX2
-#include "_trans_move_avx2.c"
-#else
-#include "_trans_move_arr.c"
+        switch (t) {
+        case UFr:
+                return inline_trans_UFr(c);
+        case ULr:
+                return inline_trans_ULr(c);
+        case UBr:
+                return inline_trans_UBr(c);
+        case URr:
+                return inline_trans_URr(c);
+        case DFr:
+                return inline_trans_DFr(c);
+        case DLr:
+                return inline_trans_DLr(c);
+        case DBr:
+                return inline_trans_DBr(c);
+        case DRr:
+                return inline_trans_DRr(c);
+        case RUr:
+                return inline_trans_RUr(c);
+        case RFr:
+                return inline_trans_RFr(c);
+        case RDr:
+                return inline_trans_RDr(c);
+        case RBr:
+                return inline_trans_RBr(c);
+        case LUr:
+                return inline_trans_LUr(c);
+        case LFr:
+                return inline_trans_LFr(c);
+        case LDr:
+                return inline_trans_LDr(c);
+        case LBr:
+                return inline_trans_LBr(c);
+        case FUr:
+                return inline_trans_FUr(c);
+        case FRr:
+                return inline_trans_FRr(c);
+        case FDr:
+                return inline_trans_FDr(c);
+        case FLr:
+                return inline_trans_FLr(c);
+        case BUr:
+                return inline_trans_BUr(c);
+        case BRr:
+                return inline_trans_BRr(c);
+        case BDr:
+                return inline_trans_BDr(c);
+        case BLr:
+                return inline_trans_BLr(c);
+        case UFm:
+                return inline_trans_UFm(c);
+        case ULm:
+                return inline_trans_ULm(c);
+        case UBm:
+                return inline_trans_UBm(c);
+        case URm:
+                return inline_trans_URm(c);
+        case DFm:
+                return inline_trans_DFm(c);
+        case DLm:
+                return inline_trans_DLm(c);
+        case DBm:
+                return inline_trans_DBm(c);
+        case DRm:
+                return inline_trans_DRm(c);
+        case RUm:
+                return inline_trans_RUm(c);
+        case RFm:
+                return inline_trans_RFm(c);
+        case RDm:
+                return inline_trans_RDm(c);
+        case RBm:
+                return inline_trans_RBm(c);
+        case LUm:
+                return inline_trans_LUm(c);
+        case LFm:
+                return inline_trans_LFm(c);
+        case LDm:
+                return inline_trans_LDm(c);
+        case LBm:
+                return inline_trans_LBm(c);
+        case FUm:
+                return inline_trans_FUm(c);
+        case FRm:
+                return inline_trans_FRm(c);
+        case FDm:
+                return inline_trans_FDm(c);
+        case FLm:
+                return inline_trans_FLm(c);
+        case BUm:
+                return inline_trans_BUm(c);
+        case BRm:
+                return inline_trans_BRm(c);
+        case BDm:
+                return inline_trans_BDm(c);
+        case BLm:
+                return inline_trans_BLm(c);
+        default:
+#ifdef DEBUG
+                fprintf(stderr, "transform error, unknown transformation\n");
 #endif
+                goto trans_error;
+        }
 
-        setsolved(solved);
-
-        ret = compose(solved, trans_move_cube[t]);
-        ret = compose(ret, c);
-        ret = compose(ret, trans_move_cube_inverse[t]);
-
-        /* TODO: work out a better way to do this */
-        if (t >= 24)
-                ret = flipallcorners(ret);
-
+trans_error:
+        setzero(ret);
         return ret;
 }