h48

A prototype for an optimal Rubik's cube solver, work in progress.
git clone https://git.tronto.net/h48
Download | Log | Files | Refs | README | LICENSE

transform.h (5044B)


      1 STATIC cube_t transform_edges(cube_t, uint8_t);
      2 STATIC cube_t transform_corners(cube_t, uint8_t);
      3 STATIC cube_t transform(cube_t, uint8_t);
      4 STATIC cube_t applytrans(cube_t, const char *);
      5 
      6 static cube_t cube_trans_table[48] = {
      7 	[TRANS_UFr] = TRANS_CUBE_UFr,
      8 	[TRANS_UFm] = TRANS_CUBE_UFm,
      9 	[TRANS_ULr] = TRANS_CUBE_URr,
     10 	[TRANS_ULm] = TRANS_CUBE_ULm,
     11 	[TRANS_UBr] = TRANS_CUBE_UBr,
     12 	[TRANS_UBm] = TRANS_CUBE_UBm,
     13 	[TRANS_URr] = TRANS_CUBE_ULr,
     14 	[TRANS_URm] = TRANS_CUBE_URm,
     15 	[TRANS_DFr] = TRANS_CUBE_DFr,
     16 	[TRANS_DFm] = TRANS_CUBE_DFm,
     17 	[TRANS_DLr] = TRANS_CUBE_DLr,
     18 	[TRANS_DLm] = TRANS_CUBE_DRm,
     19 	[TRANS_DBr] = TRANS_CUBE_DBr,
     20 	[TRANS_DBm] = TRANS_CUBE_DBm,
     21 	[TRANS_DRr] = TRANS_CUBE_DRr,
     22 	[TRANS_DRm] = TRANS_CUBE_DLm,
     23 	[TRANS_RUr] = TRANS_CUBE_FRr,
     24 	[TRANS_RUm] = TRANS_CUBE_FLm,
     25 	[TRANS_RFr] = TRANS_CUBE_LFr,
     26 	[TRANS_RFm] = TRANS_CUBE_RFm,
     27 	[TRANS_RDr] = TRANS_CUBE_BLr,
     28 	[TRANS_RDm] = TRANS_CUBE_BRm,
     29 	[TRANS_RBr] = TRANS_CUBE_RBr,
     30 	[TRANS_RBm] = TRANS_CUBE_LBm,
     31 	[TRANS_LUr] = TRANS_CUBE_FLr,
     32 	[TRANS_LUm] = TRANS_CUBE_FRm,
     33 	[TRANS_LFr] = TRANS_CUBE_RFr,
     34 	[TRANS_LFm] = TRANS_CUBE_LFm,
     35 	[TRANS_LDr] = TRANS_CUBE_BRr,
     36 	[TRANS_LDm] = TRANS_CUBE_BLm,
     37 	[TRANS_LBr] = TRANS_CUBE_LBr,
     38 	[TRANS_LBm] = TRANS_CUBE_RBm,
     39 	[TRANS_FUr] = TRANS_CUBE_FUr,
     40 	[TRANS_FUm] = TRANS_CUBE_FUm,
     41 	[TRANS_FRr] = TRANS_CUBE_RUr,
     42 	[TRANS_FRm] = TRANS_CUBE_LUm,
     43 	[TRANS_FDr] = TRANS_CUBE_BUr,
     44 	[TRANS_FDm] = TRANS_CUBE_BUm,
     45 	[TRANS_FLr] = TRANS_CUBE_LUr,
     46 	[TRANS_FLm] = TRANS_CUBE_RUm,
     47 	[TRANS_BUr] = TRANS_CUBE_FDr,
     48 	[TRANS_BUm] = TRANS_CUBE_FDm,
     49 	[TRANS_BRr] = TRANS_CUBE_LDr,
     50 	[TRANS_BRm] = TRANS_CUBE_RDm,
     51 	[TRANS_BDr] = TRANS_CUBE_BDr,
     52 	[TRANS_BDm] = TRANS_CUBE_BDm,
     53 	[TRANS_BLr] = TRANS_CUBE_RDr,
     54 	[TRANS_BLm] = TRANS_CUBE_LDm,
     55 };
     56 
     57 static cube_t cube_trans_table_inverse[48] = {
     58 	[TRANS_UFr] = TRANS_CUBE_UFr_inverse,
     59 	[TRANS_UFm] = TRANS_CUBE_UFm_inverse,
     60 	[TRANS_ULr] = TRANS_CUBE_URr_inverse,
     61 	[TRANS_ULm] = TRANS_CUBE_ULm_inverse,
     62 	[TRANS_UBr] = TRANS_CUBE_UBr_inverse,
     63 	[TRANS_UBm] = TRANS_CUBE_UBm_inverse,
     64 	[TRANS_URr] = TRANS_CUBE_ULr_inverse,
     65 	[TRANS_URm] = TRANS_CUBE_URm_inverse,
     66 	[TRANS_DFr] = TRANS_CUBE_DFr_inverse,
     67 	[TRANS_DFm] = TRANS_CUBE_DFm_inverse,
     68 	[TRANS_DLr] = TRANS_CUBE_DLr_inverse,
     69 	[TRANS_DLm] = TRANS_CUBE_DRm_inverse,
     70 	[TRANS_DBr] = TRANS_CUBE_DBr_inverse,
     71 	[TRANS_DBm] = TRANS_CUBE_DBm_inverse,
     72 	[TRANS_DRr] = TRANS_CUBE_DRr_inverse,
     73 	[TRANS_DRm] = TRANS_CUBE_DLm_inverse,
     74 	[TRANS_RUr] = TRANS_CUBE_FRr_inverse,
     75 	[TRANS_RUm] = TRANS_CUBE_FLm_inverse,
     76 	[TRANS_RFr] = TRANS_CUBE_LFr_inverse,
     77 	[TRANS_RFm] = TRANS_CUBE_RFm_inverse,
     78 	[TRANS_RDr] = TRANS_CUBE_BLr_inverse,
     79 	[TRANS_RDm] = TRANS_CUBE_BRm_inverse,
     80 	[TRANS_RBr] = TRANS_CUBE_RBr_inverse,
     81 	[TRANS_RBm] = TRANS_CUBE_LBm_inverse,
     82 	[TRANS_LUr] = TRANS_CUBE_FLr_inverse,
     83 	[TRANS_LUm] = TRANS_CUBE_FRm_inverse,
     84 	[TRANS_LFr] = TRANS_CUBE_RFr_inverse,
     85 	[TRANS_LFm] = TRANS_CUBE_LFm_inverse,
     86 	[TRANS_LDr] = TRANS_CUBE_BRr_inverse,
     87 	[TRANS_LDm] = TRANS_CUBE_BLm_inverse,
     88 	[TRANS_LBr] = TRANS_CUBE_LBr_inverse,
     89 	[TRANS_LBm] = TRANS_CUBE_RBm_inverse,
     90 	[TRANS_FUr] = TRANS_CUBE_FUr_inverse,
     91 	[TRANS_FUm] = TRANS_CUBE_FUm_inverse,
     92 	[TRANS_FRr] = TRANS_CUBE_RUr_inverse,
     93 	[TRANS_FRm] = TRANS_CUBE_LUm_inverse,
     94 	[TRANS_FDr] = TRANS_CUBE_BUr_inverse,
     95 	[TRANS_FDm] = TRANS_CUBE_BUm_inverse,
     96 	[TRANS_FLr] = TRANS_CUBE_LUr_inverse,
     97 	[TRANS_FLm] = TRANS_CUBE_RUm_inverse,
     98 	[TRANS_BUr] = TRANS_CUBE_FDr_inverse,
     99 	[TRANS_BUm] = TRANS_CUBE_FDm_inverse,
    100 	[TRANS_BRr] = TRANS_CUBE_LDr_inverse,
    101 	[TRANS_BRm] = TRANS_CUBE_RDm_inverse,
    102 	[TRANS_BDr] = TRANS_CUBE_BDr_inverse,
    103 	[TRANS_BDm] = TRANS_CUBE_BDm_inverse,
    104 	[TRANS_BLr] = TRANS_CUBE_RDr_inverse,
    105 	[TRANS_BLm] = TRANS_CUBE_LDm_inverse,
    106 };
    107 
    108 STATIC cube_t
    109 transform_edges(cube_t c, uint8_t t)
    110 {
    111 	cube_t ret, trans_cube, trans_inv;
    112 
    113 	DBG_ASSERT(t < 48, ZERO_CUBE,
    114 	    "transform: invalid transformation %" PRIu8
    115 	    ", must be between 0 and 47\n", t);
    116 
    117 	trans_cube = cube_trans_table[t];
    118 	trans_inv = cube_trans_table_inverse[t];
    119 
    120 	ret = compose_edges(trans_cube, c);
    121 	ret = compose_edges(ret, trans_inv);
    122 
    123 	return ret;
    124 }
    125 
    126 STATIC cube_t
    127 transform_corners(cube_t c, uint8_t t)
    128 {
    129 	cube_t ret, trans_cube, trans_inv;
    130 
    131 	DBG_ASSERT(t < 48, ZERO_CUBE,
    132 	    "transform: invalid transformation %" PRIu8
    133 	    ", must be between 0 and 47\n", t);
    134 
    135 	trans_cube = cube_trans_table[t];
    136 	trans_inv = cube_trans_table_inverse[t];
    137 
    138 	ret = compose_corners(trans_cube, c);
    139 	ret = compose_corners(ret, trans_inv);
    140 
    141 	return t < 24 ? ret : invertco(ret);
    142 }
    143 
    144 STATIC cube_t
    145 transform(cube_t c, uint8_t t)
    146 {
    147 	cube_t ret, trans_cube, trans_inv;
    148 
    149 	DBG_ASSERT(t < 48, ZERO_CUBE,
    150 	    "transform: invalid transformation %" PRIu8
    151 	    ", must be between 0 and 47\n", t);
    152 
    153 	trans_cube = cube_trans_table[t];
    154 	trans_inv = cube_trans_table_inverse[t];
    155 
    156 	ret = compose(trans_cube, c);
    157 	ret = compose(ret, trans_inv);
    158 
    159 	return t < 24 ? ret : invertco(ret);
    160 }
    161 
    162 STATIC cube_t
    163 applytrans(cube_t cube, const char *buf)
    164 {
    165 	uint8_t t;
    166 
    167 	DBG_ASSERT(isconsistent(cube), ZERO_CUBE,
    168 	    "transformation error: inconsistent cube\n");
    169 
    170 	t = readtrans(buf);
    171 
    172 	return transform(cube, t);
    173 }