Rewritten from scratch. Welocme nissy 2.0!

1 files changed, 372 insertions, 0 deletions

diff --git a/old/2021-11-10-beforeremovingchecker/trans.c b/old/2021-11-10-beforeremovingchecker/trans.c
new file mode 100644
index 0000000..ff3cdbb
--- /dev/null
+++ b/old/2021-11-10-beforeremovingchecker/trans.c
@@ -0,0 +1,372 @@
+#include "trans.h"
+
+/* Local functions ***********************************************************/
+
+static bool        read_ttables_file();
+static Cube        rotate_via_compose(Trans r, Cube c, PieceFilter f);
+static bool        write_ttables_file();
+
+/* Tables and other data *****************************************************/
+
+static int              ep_mirror[12] = {
+        [UF] = UF, [UL] = UR, [UB] = UB, [UR] = UL,
+        [DF] = DF, [DL] = DR, [DB] = DB, [DR] = DL,
+        [FR] = FL, [FL] = FR, [BL] = BR, [BR] = BL
+};
+
+static int              cp_mirror[8] = {
+        [UFR] = UFL, [UFL] = UFR, [UBL] = UBR, [UBR] = UBL,
+        [DFR] = DFL, [DFL] = DFR, [DBL] = DBR, [DBR] = DBL
+};
+
+static int              cpos_mirror[6] = {
+        [U_center] = U_center, [D_center] = D_center,
+        [R_center] = L_center, [L_center] = R_center,
+        [F_center] = F_center, [B_center] = B_center
+};
+
+/* TODO Is there a more elegant way? */
+static char             rotation_alg_string[100][NROTATIONS] = {
+        [uf] = "",     [ur] = "y",    [ub] = "y2",    [ul] = "y3",
+        [df] = "z2",   [dr] = "y z2", [db] = "x2",    [dl] = "y3 z2",
+        [rf] = "z3",   [rd] = "z3 y", [rb] = "z3 y2", [ru] = "z3 y3",
+        [lf] = "z",    [ld] = "z y3", [lb] = "z y2",  [lu] = "z y",
+        [fu] = "x y2", [fr] = "x y",  [fd] = "x",     [fl] = "x y3",
+        [bu] = "x3",   [br] = "x3 y", [bd] = "x3 y2", [bl] = "x3 y3",
+};
+
+static int              epose_source[NTRANS];  /* 0=epose, 1=eposs, 2=eposm */
+static int              eposs_source[NTRANS];
+static int              eposm_source[NTRANS];
+static int              eofb_source[NTRANS];   /* 0=eoud,  1=eorl,  2=eofb  */
+static int              eorl_source[NTRANS];
+static int              eoud_source[NTRANS];
+static int              coud_source[NTRANS];   /* 0=coud,  1=corl,  2=cofb  */
+static int              cofb_source[NTRANS];
+static int              corl_source[NTRANS];
+
+static int              epose_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
+static int              eposs_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
+static int              eposm_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
+static int              eo_ttable[NTRANS][POW2TO11];
+static int              cp_ttable[NTRANS][FACTORIAL8];
+static int              co_ttable[NTRANS][POW3TO7];
+static int              cpos_ttable[NTRANS][FACTORIAL6];
+static Move             moves_ttable[NTRANS][NMOVES];
+
+/* Local functions implementation ********************************************/
+
+void
+init_trans() {
+        static bool initialized = false;
+        if (initialized)
+                return;
+        initialized = true;
+
+        Cube aux, cube, c[3];
+        CubeArray epcp;
+        int i, eparr[12], eoarr[12], cparr[8], coarr[8];
+        unsigned int ui;
+        Move mi, move;
+        Trans m;
+
+        /* Compute sources */
+        for (i = 0; i < NTRANS; i++) {
+                cube = apply_alg(rotation_alg(i), (Cube){0});
+
+                epose_source[i] = edge_slice(what_edge_at(cube, FR));
+                eposs_source[i] = edge_slice(what_edge_at(cube, UR));
+                eposm_source[i] = edge_slice(what_edge_at(cube, UF));
+                eofb_source[i]  = what_center_at(cube, F_center)/2;
+                eorl_source[i]  = what_center_at(cube, R_center)/2;
+                eoud_source[i]  = what_center_at(cube, U_center)/2;
+                coud_source[i]  = what_center_at(cube, U_center)/2;
+                cofb_source[i]  = what_center_at(cube, F_center)/2;
+                corl_source[i]  = what_center_at(cube, R_center)/2;
+        }
+
+        if (read_ttables_file())
+                return;
+
+        fprintf(stderr, "Cannot load %s, generating it\n", "ttables"); 
+
+        /* Initialize tables */
+        for (m = 0; m < NTRANS; m++) {
+                epcp = (CubeArray){ .ep = eparr, .cp = cparr };
+                cube = apply_alg(rotation_alg(m), (Cube){0});
+                cube_to_arrays(cube, &epcp, pf_epcp);
+                if (m >= NROTATIONS) {
+                        apply_permutation(ep_mirror, eparr, 12);
+                        apply_permutation(cp_mirror, cparr,  8);
+                }
+
+                for (ui = 0; ui < FACTORIAL12/FACTORIAL8; ui++) {
+                        c[0] = admissible_ep((Cube){ .epose = ui }, pf_e);
+                        c[1] = admissible_ep((Cube){ .eposs = ui }, pf_s);
+                        c[2] = admissible_ep((Cube){ .eposm = ui }, pf_m);
+
+                        cube = rotate_via_compose(m,c[epose_source[m]],pf_ep);
+                        epose_ttable[m][ui] = cube.epose;
+
+                        cube = rotate_via_compose(m,c[eposs_source[m]],pf_ep);
+                        eposs_ttable[m][ui] = cube.eposs;
+
+                        cube = rotate_via_compose(m,c[eposm_source[m]],pf_ep);
+                        eposm_ttable[m][ui] = cube.eposm;
+                }
+                for (ui = 0; ui < POW2TO11; ui++ ) {
+                        int_to_sum_zero_array(ui, 2, 12, eoarr);
+                        apply_permutation(eparr, eoarr, 12);
+                        eo_ttable[m][ui] = digit_array_to_int(eoarr, 11, 2);
+                }
+                for (ui = 0; ui < POW3TO7; ui++) {
+                        int_to_sum_zero_array(ui, 3, 8, coarr);
+                        apply_permutation(cparr, coarr, 8);
+                        co_ttable[m][ui] = digit_array_to_int(coarr, 7, 3);
+                        if (m >= NROTATIONS)
+                                co_ttable[m][ui] =
+                                        invert_digits(co_ttable[m][ui], 3, 7);
+                }
+                for (ui = 0; ui < FACTORIAL8; ui++) {
+                        cube = (Cube){ .cp = ui };
+                        cube = rotate_via_compose(m, cube, pf_cp);
+                        cp_ttable[m][ui] = cube.cp;
+                }
+                for (ui = 0; ui < FACTORIAL6; ui++) {
+                        cube = (Cube){ .cpos = ui };
+                        cube = rotate_via_compose(m, cube, pf_cpos);
+                        cpos_ttable[m][ui] = cube.cpos;
+                }
+                for (mi = 0; mi < NMOVES; mi++) {
+                        /* Old version:
+                         *
+                        aux = apply_trans(m, apply_move(mi, (Cube){0}));
+                        for (move = 0; move < NMOVES; move++) {
+                                cube = apply_move(inverse_move(move), aux);
+                                mirr = apply_trans(uf_mirror, cube);
+                                if (is_solved(cube) || is_solved(mirr))
+                                        moves_ttable[m][mi] = move;
+                        }
+                        */
+
+                        aux = apply_trans(m, apply_move(mi, (Cube){0}));
+                        for (move = 0; move < NMOVES; move++) {
+                                cube = apply_move(inverse_move(move), aux);
+                                if (is_solved(cube)) {
+                                        moves_ttable[m][mi] = move;
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        if (!write_ttables_file())
+                fprintf(stderr, "Error writing ttables\n");
+}
+
+static bool
+read_ttables_file()
+{
+        init_env();
+
+        FILE *f;
+        char fname[strlen(tabledir)+20];
+        int b = sizeof(int);
+        bool r = true;
+        Move m;
+
+        /* Table sizes, used for reading and writing files */
+        uint64_t me[11] = {
+                [0] = FACTORIAL12/FACTORIAL8,
+                [1] = FACTORIAL12/FACTORIAL8,
+                [2] = FACTORIAL12/FACTORIAL8,
+                [3] = POW2TO11,
+                [4] = FACTORIAL8,
+                [5] = POW3TO7,
+                [6] = FACTORIAL6,
+                [7] = NMOVES
+        };
+
+        strcpy(fname, tabledir);
+        strcat(fname, "/");
+        strcat(fname, "ttables");
+
+        if ((f = fopen(fname, "rb")) == NULL)
+                return false;
+
+        for (m = 0; m < NTRANS; m++) {
+                r = r && fread(epose_ttable[m], b, me[0], f) == me[0];
+                r = r && fread(eposs_ttable[m], b, me[1], f) == me[1];
+                r = r && fread(eposm_ttable[m], b, me[2], f) == me[2];
+                r = r && fread(eo_ttable[m],    b, me[3], f) == me[3];
+                r = r && fread(cp_ttable[m],    b, me[4], f) == me[4];
+                r = r && fread(co_ttable[m],    b, me[5], f) == me[5];
+                r = r && fread(cpos_ttable[m],  b, me[6], f) == me[6];
+                r = r && fread(moves_ttable[m], b, me[7], f) == me[7];
+        }
+
+        fclose(f);
+        return r;
+}
+
+static Cube
+rotate_via_compose(Trans r, Cube c, PieceFilter f)
+{
+        static int zero12[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        static int zero8[8]   = { 0, 0, 0, 0, 0, 0, 0, 0 };
+        static CubeArray ma = {
+                .ep   = ep_mirror,
+                .eofb = zero12,
+                .eorl = zero12,
+                .eoud = zero12,
+                .cp   = cp_mirror,
+                .coud = zero8,
+                .corl = zero8,
+                .cofb = zero8,
+                .cpos = cpos_mirror
+        };
+
+        Alg *inv = inverse_alg(rotation_alg(r));
+        Cube ret = {0};
+
+        if (r >= NROTATIONS)
+                ret = move_via_arrays(&ma, ret, f);
+        ret = apply_alg_generic(inv, ret, f, true);
+
+        ret = compose_filtered(c, ret, f);
+
+        ret = apply_alg_generic(rotation_alg(r), ret, f, true);
+        if (r >= NROTATIONS)
+                ret = move_via_arrays(&ma, ret, f);
+
+        free_alg(inv);
+        return ret;
+}
+
+static bool
+write_ttables_file()
+{
+        init_env();
+
+        FILE *f;
+        char fname[strlen(tabledir)+20];
+        bool r = true;
+        int b = sizeof(int);
+        Move m;
+
+        /* Table sizes, used for reading and writing files */
+        uint64_t me[11] = {
+                [0] = FACTORIAL12/FACTORIAL8,
+                [1] = FACTORIAL12/FACTORIAL8,
+                [2] = FACTORIAL12/FACTORIAL8,
+                [3] = POW2TO11,
+                [4] = FACTORIAL8,
+                [5] = POW3TO7,
+                [6] = FACTORIAL6,
+                [7] = NMOVES
+        };
+
+        strcpy(fname, tabledir);
+        strcat(fname, "/ttables");
+
+        if ((f = fopen(fname, "wb")) == NULL)
+                return false;
+
+        for (m = 0; m < NTRANS; m++) {
+                r = r && fwrite(epose_ttable[m], b, me[0], f) == me[0];
+                r = r && fwrite(eposs_ttable[m], b, me[1], f) == me[1];
+                r = r && fwrite(eposm_ttable[m], b, me[2], f) == me[2];
+                r = r && fwrite(eo_ttable[m],    b, me[3], f) == me[3];
+                r = r && fwrite(cp_ttable[m],    b, me[4], f) == me[4];
+                r = r && fwrite(co_ttable[m],    b, me[5], f) == me[5];
+                r = r && fwrite(cpos_ttable[m],  b, me[6], f) == me[6];
+                r = r && fwrite(moves_ttable[m], b, me[7], f) == me[7];
+        }
+
+        fclose(f);
+        return r;
+}
+
+/* Public functions **********************************************************/
+
+Cube
+apply_trans(Trans t, Cube cube)
+{
+        /*init_trans();*/
+
+        int aux_epos[3] = { cube.epose, cube.eposs, cube.eposm };
+        int aux_eo[3]   = { cube.eoud,  cube.eorl,  cube.eofb  };
+        int aux_co[3]   = { cube.coud,  cube.corl,  cube.cofb  };
+
+        return (Cube) {
+                .epose = epose_ttable[t][aux_epos[epose_source[t]]],
+                .eposs = eposs_ttable[t][aux_epos[eposs_source[t]]],
+                .eposm = eposm_ttable[t][aux_epos[eposm_source[t]]],
+                .eofb  = eo_ttable[t][aux_eo[eofb_source[t]]],
+                .eorl  = eo_ttable[t][aux_eo[eorl_source[t]]],
+                .eoud  = eo_ttable[t][aux_eo[eoud_source[t]]],
+                .coud  = co_ttable[t][aux_co[coud_source[t]]],
+                .corl  = co_ttable[t][aux_co[corl_source[t]]],
+                .cofb  = co_ttable[t][aux_co[cofb_source[t]]],
+                .cp    = cp_ttable[t][cube.cp],
+                .cpos  = cpos_ttable[t][cube.cpos]
+        };
+}
+
+Trans
+inverse_trans(Trans t)
+{
+        /* TODO is there a more elegant way? */
+        static Trans inverse_trans_aux[NTRANS] = {
+                [uf] = uf, [ur] = ul, [ul] = ur, [ub] = ub,
+                [df] = df, [dr] = dr, [dl] = dl, [db] = db,
+                [rf] = lf, [rd] = bl, [rb] = rb, [ru] = fr,
+                [lf] = rf, [ld] = br, [lb] = lb, [lu] = fl,
+                [fu] = fu, [fr] = ru, [fd] = bu, [fl] = lu,
+                [bu] = fd, [br] = ld, [bd] = bd, [bl] = rd,
+
+                [uf_mirror] = uf_mirror, [ur_mirror] = ur_mirror,
+                [ul_mirror] = ul_mirror, [ub_mirror] = ub_mirror,
+                [df_mirror] = df_mirror, [dr_mirror] = dl_mirror,
+                [dl_mirror] = dr_mirror, [db_mirror] = db_mirror,
+                [rf_mirror] = rf_mirror, [rd_mirror] = br_mirror,
+                [rb_mirror] = lb_mirror, [ru_mirror] = fl_mirror,
+                [lf_mirror] = lf_mirror, [ld_mirror] = bl_mirror,
+                [lb_mirror] = rb_mirror, [lu_mirror] = fr_mirror,
+                [fu_mirror] = fu_mirror, [fr_mirror] = lu_mirror,
+                [fd_mirror] = bu_mirror, [fl_mirror] = ru_mirror,
+                [bu_mirror] = fd_mirror, [br_mirror] = rd_mirror,
+                [bd_mirror] = bd_mirror, [bl_mirror] = ld_mirror
+        };
+
+        return inverse_trans_aux[t];
+}
+
+Alg *
+rotation_alg(Trans t)
+{
+        int i;
+
+        static Alg *rotation_alg_arr[NROTATIONS];
+        static bool initialized = false;
+
+        if (!initialized) {
+                for (i = 0; i < NROTATIONS; i++)
+                        rotation_alg_arr[i] = new_alg(rotation_alg_string[i]);
+
+                initialized = true;
+        }
+
+        return rotation_alg_arr[t % NROTATIONS];
+}
+
+void
+transform_alg(Trans t, Alg *alg)
+{
+        int i;
+
+        /*init_trans();*/
+        
+        for (i = 0; i < alg->len; i++)
+                alg->move[i] = moves_ttable[t][alg->move[i]];
+}