From 0e8d73bb3edcc8bdff6e3ded442b66f68265059a Mon Sep 17 00:00:00 2001 From: Sebastiano Tronto Date: Sun, 21 Jun 2020 23:01:57 +0200 Subject: First push --- src/coordinates.c | 288 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 288 insertions(+) create mode 100644 src/coordinates.c (limited to 'src/coordinates.c') diff --git a/src/coordinates.c b/src/coordinates.c new file mode 100644 index 0000000..284aaaa --- /dev/null +++ b/src/coordinates.c @@ -0,0 +1,288 @@ +/* blabla */ + +#include + +#include "utils.h" +#include "coordinates.h" + +/* Names of pieces and moves. */ +char edge_string_list[12][5] = { + "UF", "UL", "UB", "UR", "DF", "DL", "DB", "DR", "FR", "FL", "BL", "BR" +}; + +char corner_string_list[8][5] = { + "UFR", "UFL", "UBL", "UBR", "DFR", "DFL", "DBL", "DBR" +}; + +char move_string_list[19][5] = { + "-", + "U", "U2", "U\'", "D", "D2", "D\'", "R", "R2", "R\'", + "L", "L2", "L\'", "F", "F2", "F\'", "B", "B2", "B\'" +}; + +int inverse_move[19] = { + -1, U3, U2, U, D3, D2, D, R3, R2, R, L3, L2, L, F3, F2, F, B3, B2, B +}; + +/* Convert piece representation from integer to array. + * Come convertions are not "perfect": for example, and epud type of piece + * is represented by a permutation index in 8! elements, but it as an array + * it is converted to the first 8 elements of a 12 elements ep array (with + * meaningless values for the other 4 elements). */ + +void ep_int_to_array(int ep, int a[12]) { + index_to_perm(ep, 12, a); +} + +void epud_int_to_array(int epud, int a[12]) { + index_to_perm(epud, 8, a); /* Last 4 elements are left untouched. */ +} + +void epfb_int_to_array(int epfb, int a[12]) { + int edges[] = {UF, UB, DF, DB, FR, FL, BL, BR}; + int b[8]; + index_to_perm(epfb, 8, b); + for (int i = 0; i < 8; i++) + a[edges[i]] = edges[b[i]]; +} + +void eprl_int_to_array(int eprl, int a[12]) { + int edges[] = {UL, UR, DL, DR, FR, FL, BL, BR}; + int b[8]; + index_to_perm(eprl, 8, b); + for (int i = 0; i < 8; i++) + a[edges[i]] = edges[b[i]]; +} + +void epose_int_to_array(int epos, int a[12]) { + int edges[] = {FR, FL, BL, BR}; + index_to_subset(epos, 12, 4, a); + for (int i = 0, j = 0; i < 12; i++) + a[i] = (a[i] == 1) ? edges[j++] : -1; +} + +void eposs_int_to_array(int epos, int a[12]) { + int edges[] = {UL, UR, DL, DR}; + index_to_subset(epos, 12, 4, a); + for (int i = 0, j = 0; i < 12; i++) + a[i] = (a[i] == 1) ? edges[j++] : -1; + /* Swap with last 4, so 0 is alway solved state */ + for (int i = 0; i < 4; i++) + swap(&a[edges[i]], &a[i+8]); +} + +void eposm_int_to_array(int epos, int a[12]) { + int edges[] = {UF, UB, DF, DB}; + index_to_subset(epos, 12, 4, a); + for (int i = 0, j = 0; i < 12; i++) + a[i] = (a[i] == 1) ? edges[j++] : -1; + /* Swap with last 4, so 0 is alway solved state */ + for (int i = 0; i < 4; i++) + swap(&a[edges[i]], &a[i+8]); +} + +void epe_int_to_array(int epe, int a[12]) { + index_to_perm(epe, 4, a+8); + for (int i = 0; i < 4; i++) + a[i+8] += 8; +} + +void eps_int_to_array(int eps, int a[12]) { + int edges[] = {UL, UR, DL, DR}; + int b[4]; + index_to_perm(eps, 4, b); + for (int i = 0; i < 4; i++) + a[edges[i]] = edges[b[i]]; +} + +void epm_int_to_array(int epm, int a[12]) { + int edges[] = {UF, UB, DF, DB}; + int b[4]; + index_to_perm(epm, 4, b); + for (int i = 0; i < 4; i++) + a[edges[i]] = edges[b[i]]; +} + +void emslices_int_to_array(int emslices, int a[12]) { + int b[] = {0,0,0,0,0,0,0,0}; + int eslice[] = {FR, FL, BL, BR}; + int mslice[] = {UF, UB, DF, DB}; + + index_to_subset(emslices % binom12on4, 12, 4, a); + index_to_subset(emslices / binom12on4, 8, 4, b); + + if (emslices % binom12on4 == 0) { + swap(&b[UF], &b[DL]); + swap(&b[UB], &b[DR]); + /*for (int i = 0; i < 4; i++) + swap(&b[mslice[i]], &b[i+4]);*/ + } + + for (int i = 0, j = 0; j < 8; i++, j++) { + while (a[i]) + i++; + a[i] = b[j] ? 2 : -1; + } + for (int i = 0, j1 = 0, j2 = 0; i < 12; i++) { + if (a[i] == 1) + a[i] = eslice[j1++]; + if (a[i] == 2) + a[i] = mslice[j2++]; + } +} + +void cp_int_to_array(int cp, int a[8]) { + index_to_perm(cp, 8, a); +} + +void eo_11bits_to_array(int eo, int a[12]) { + int_to_sum_zero_array(eo, 2, 12, a); +} + +void co_7trits_to_array(int co, int a[8]) { + int_to_sum_zero_array(co, 3, 8, a); +} + + + + + +int ep_array_to_int(int ep[12]) { + return perm_to_index(ep, 12); +} + +int epud_array_to_int(int ep[12]) { + return perm_to_index(ep, 8); /* Last 4 elements are ignored */ +} + +int epfb_array_to_int(int ep[12]) { + int index[] = {0, -1, 1, -1, 2, -1, 3, -1, 4, 5, 6, 7}; + int b[8]; + for (int i = 0; i < 12; i++) + if (index[i] != -1) + b[index[i]] = index[ep[i]]; + return perm_to_index(b, 8); +} + +int eprl_array_to_int(int ep[12]) { + int index[] = {-1, 0, -1, 1, -1, 2, -1, 3, 4, 5, 6, 7}; + int b[8]; + for (int i = 0; i < 12; i++) + if (index[i] != -1) + b[index[i]] = index[ep[i]]; + return perm_to_index(b, 8); +} + +int epose_array_to_int(int ep[12]) { + int a[12]; + for (int i = 0; i < 12; i++) + a[i] = (ep[i] >= FR); + return subset_to_index(a, 12, 4); +} + +int eposs_array_to_int(int ep[12]) { + int a[12]; + int edges[] = {UL, UR, DL, DR}; + for (int i = 0; i < 12; i++) + a[i] = (ep[i] == UL || ep[i] == UR || ep[i] == DL || ep[i] == DR); + /* Swap with last 4, so 0 is alway solved state */ + for (int i = 0; i < 4; i++) + swap(&a[edges[i]], &a[i+8]); + return subset_to_index(a, 12, 4); +} + +int eposm_array_to_int(int ep[12]) { + int a[12]; + int edges[] = {UF, UB, DF, DB}; + for (int i = 0; i < 12; i++) + a[i] = (ep[i] == UF || ep[i] == UB || ep[i] == DF || ep[i] == DB); + /* Swap with last 4, so 0 is alway solved state */ + for (int i = 0; i < 4; i++) + swap(&a[edges[i]], &a[i+8]); + return subset_to_index(a, 12, 4); +} + +int epe_array_to_int(int ep[12]) { + int b[4]; + for (int i = 0; i < 4; i++) + b[i] = ep[i+8] - 8; + return perm_to_index(b, 4); +} + +int eps_array_to_int(int ep[12]) { + int index[] = {-1, 0, -1, 1, -1, 2, -1, 3, -1, -1, -1, -1}; + int b[4]; + for (int i = 0; i < 12; i++) + if (index[i] != -1) + b[index[i]] = index[ep[i]]; + return perm_to_index(b, 4); +} + +int epm_array_to_int(int ep[12]) { + int index[] = {0, -1, 1, -1, 2, -1, 3, -1, -1, -1, -1, -1}; + int b[4]; + for (int i = 0; i < 12; i++) + if (index[i] != -1) + b[index[i]] = index[ep[i]]; + return perm_to_index(b, 4); +} + +int emslices_array_to_int(int ep[12]) { + int a[12], b[12], c[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + /*int edges[] = {UF, UB, DF, DB};*/ + for (int i = 0; i < 12; i++) { + a[i] = (ep[i] >= FR) ? 1 : 0; + b[i] = (ep[i] == UF || ep[i] == UB || ep[i] == DF || ep[i] == DB) ? 1 : 0; + } + + /*for ( int i = 0; i < 12; i++) + printf("%d ", ep[i]); + printf("\n");*/ + + for (int i = 0, j = 0; i < 12; i++, j++) { + if (a[i]) + j--; + if (b[i]) + c[j] = 1; + } + + int epose = subset_to_index(a, 12, 4); + + /*if (epose == 0) { + printf("Before: "); + for (int i = 0; i < 8; i++) + printf("%d ", c[i]); + printf("\n"); + for (int i = 0; i < 4; i++) + swap(&c[edges[i]], &c[i+4]); + printf("After: "); + for (int i = 0; i < 8; i++) + printf("%d ", c[i]); + printf("\n"); + }*/ + if (epose == 0) { + swap(&c[UF], &c[DL]); + swap(&c[UB], &c[DR]); + } + + /*for ( int i = 0; i < 8; i++) + printf("%d ", c[i]); + printf("\n");*/ + int eposm = subset_to_index(c, 8, 4); + + return epose + 495*eposm; +} + + +int cp_array_to_int(int cp[8]) { + return perm_to_index(cp, 8); +} + +int eo_array_to_11bits(int a[12]) { + return digit_array_to_int(a, 11, 2); +} + +int co_array_to_7trits(int a[8]) { + return digit_array_to_int(a, 7, 3); +} + -- cgit v1.3