Clean up

10 files changed, 380 insertions, 391 deletions

diff --git a/Makefile b/Makefile
index 448c625..5fc8232 100644
--- a/Makefile
+++ b/Makefile
@@ -3,24 +3,27 @@ DBGFLAGS = -std=c99 -pedantic -Wall -Wextra -g3 -DDEBUG
 
 CC = cc
 
-all: cube.o debugcube.o
+all: cleancube cube.o
 
-cube.s: clean
-        ${CC} ${CFLAGS} -c -S -o cube.s cube.c
+cleancube:
+        rm -rf cube.o
 
-cube.o: clean
+cube.o:
         ${CC} ${CFLAGS} -c -o cube.o cube.c
 
-debugcube.o: clean
+cleandebug:
+        rm -rf debugcube.o
+
+debugcube.o:
         ${CC} ${DBGFLAGS} -c -o debugcube.o cube.c
 
 clean:
         rm -rf *.o
 
-test: debugcube.o
+test: cleandebug debugcube.o
         CUBETYPE=${CUBETYPE} TEST=${TEST} ./test/test.sh
 
 benchmark: cube.o
         CUBETYPE=${CUBETYPE} ./benchmark/bench.sh
 
-.PHONY: all clean test benchmark
+.PHONY: all clean cleancube cleandebug test benchmark
diff --git a/README.md b/README.md
index 041b8d3..131c7ed 100644
--- a/README.md
+++ b/README.md
@@ -2,11 +2,30 @@
 
 A simple set of basic routines for working with a 3x3x3 Rubik's Cube.
 
-Work in progress.
-
 ## How to use CubeCore
 
-TODO
+(More details coming soon)
+
+0. Requirements: a C99 compiler (e.g. GCC)
+
+1. Compile CubeCore
+
+```
+$ make
+$ make test # optional
+```
+
+2. Include in your C or C++ project
+
+```
+#include "cube.h"
+```
+
+3. Compile including the `cube.o` file
+
+```
+$ gcc mycode.c cube.o
+```
 
 ## The cube
 
diff --git a/TODO.txt b/TODO.txt
deleted file mode 100644
index e8bf4f7..0000000
--- a/TODO.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-- add public method apply move inplace
-- make apply moves work inplace?
diff --git a/constants.h b/constants.h
index c3b9312..cf584b1 100644
--- a/constants.h
+++ b/constants.h
@@ -45,22 +45,6 @@
 #define _eflip      0x10U
 #define _error      0xFFU
 
-typedef enum {
-        U, U2, U3, D, D2, D3,
-        R, R2, R3, L, L2, L3,
-        F, F2, F3, B, B2, B3
-} move_t;
-
-typedef enum {
-        UFr, ULr, UBr, URr, DFr, DLr, DBr, DRr,
-        RUr, RFr, RDr, RBr, LUr, LFr, LDr, LBr,
-        FUr, FRr, FDr, FLr, BUr, BRr, BDr, BLr,
-
-        UFm, ULm, UBm, URm, DFm, DLm, DBm, DRm,
-        RUm, RFm, RDm, RBm, LUm, LFm, LDm, LBm,
-        FUm, FRm, FDm, FLm, BUm, BRm, BDm, BLm
-} trans_t;
-
 _static cube_t zero = { .corner = {0}, .edge = {0} };
 _static cube_t solved = {
         .corner = {0, 1, 2, 3, 4, 5, 6, 7},
diff --git a/cube.c b/cube.c
index ba65580..f44a7df 100644
--- a/cube.c
+++ b/cube.c
@@ -43,11 +43,265 @@ _static void write_H48(cube_t, char *);
 _static void write_LST(cube_t, char *);
 _static uint8_t readmove(char);
 _static uint8_t readmodifier(char);
-_static uint8_t readtrans(char *);
-_static int writemoves(uint8_t *, int, char *);
-_static void writetrans(uint8_t, char *);
-_static cube_t move(cube_t, move_t);
-_static cube_t transform(cube_t, trans_t);
+
+_static uint8_t
+readco(char *str)
+{
+        if (*str == '0')
+                return 0;
+        if (*str == '1')
+                return _ctwist_cw;
+        if (*str == '2')
+                return _ctwist_ccw;
+
+        DBG_LOG("Error reading CO\n");
+        return _error;
+}
+
+_static uint8_t
+readcp(char *str)
+{
+        uint8_t c;
+
+        for (c = 0; c < 8; c++)
+                if (!strncmp(str, cornerstr[c], 3) ||
+                    !strncmp(str, cornerstralt[c], 3))
+                        return c;
+
+        DBG_LOG("Error reading CP\n");
+        return _error;
+}
+
+_static uint8_t
+readeo(char *str)
+{
+        if (*str == '0')
+                return 0;
+        if (*str == '1')
+                return _eflip;
+
+        DBG_LOG("Error reading EO\n");
+        return _error;
+}
+
+_static uint8_t
+readep(char *str)
+{
+        uint8_t e;
+
+        for (e = 0; e < 12; e++)
+                if (!strncmp(str, edgestr[e], 2))
+                        return e;
+
+        DBG_LOG("Error reading EP\n");
+        return _error;
+}
+
+_static cube_t
+read_H48(char *buf)
+{
+        int i;
+        uint8_t piece, orient;
+        cube_t ret = {0};
+        char *b;
+        
+        b = buf;
+
+        for (i = 0; i < 12; i++) {
+                while (*b == ' ' || *b == '\t' || *b == '\n')
+                        b++;
+                if ((piece = readep(b)) == _error)
+                        return zero;
+                b += 2;
+                if ((orient = readeo(b)) == _error)
+                        return zero;
+                b++;
+                ret.edge[i] = piece | orient;
+        }
+        for (i = 0; i < 8; i++) {
+                while (*b == ' ' || *b == '\t' || *b == '\n')
+                        b++;
+                if ((piece = readcp(b)) == _error)
+                        return zero;
+                b += 3;
+                if ((orient = readco(b)) == _error)
+                        return zero;
+                b++;
+                ret.corner[i] = piece | orient;
+        }
+
+        return ret;
+}
+
+_static uint8_t
+readpiece_LST(char **b)
+{
+        uint8_t ret;
+        bool read;
+
+        while (**b == ',' || **b == ' ' || **b == '\t' || **b == '\n')
+                (*b)++;
+
+        for (ret = 0, read = false; **b >= '0' && **b <= '9'; (*b)++) {
+                read = true;
+                ret = ret * 10 + (**b) - '0';
+        }
+
+        return read ? ret : _error;
+}
+
+_static cube_t
+read_LST(char *buf)
+{
+        int i;
+        cube_t ret = {0};
+
+        for (i = 0; i < 8; i++)
+                ret.corner[i] = readpiece_LST(&buf);
+
+        for (i = 0; i < 12; i++)
+                ret.edge[i] = readpiece_LST(&buf);
+
+        return ret;
+}
+
+_static int
+writepiece_LST(uint8_t piece, char *buf)
+{
+        char digits[3];
+        int i, len = 0;
+
+        while (piece != 0) {
+                digits[len++] = (piece % 10) + '0';
+                piece /= 10;
+        }
+
+        if (len == 0)
+                digits[len++] = '0';
+
+        for (i = 0; i < len; i++)
+                buf[i] = digits[len-i-1];
+
+        buf[len] = ',';
+        buf[len+1] = ' ';
+
+        return len+2;
+}
+
+_static void
+write_H48(cube_t cube, char *buf)
+{
+        uint8_t piece, perm, orient;
+        int i;
+
+        for (i = 0; i < 12; i++) {
+                piece = cube.edge[i];
+                perm = piece & _pbits;
+                orient = (piece & _eobit) >> _eoshift;
+                buf[4*i    ] = edgestr[perm][0];
+                buf[4*i + 1] = edgestr[perm][1];
+                buf[4*i + 2] = orient + '0';
+                buf[4*i + 3] = ' ';
+        }
+        for (i = 0; i < 8; i++) {
+                piece = cube.corner[i];
+                perm = piece & _pbits;
+                orient = (piece & _cobits) >> _coshift;
+                buf[48 + 5*i    ] = cornerstr[perm][0];
+                buf[48 + 5*i + 1] = cornerstr[perm][1];
+                buf[48 + 5*i + 2] = cornerstr[perm][2];
+                buf[48 + 5*i + 3] = orient + '0';
+                buf[48 + 5*i + 4] = ' ';
+        }
+
+        buf[48+39] = '\0';
+}
+
+_static void
+write_LST(cube_t cube, char *buf)
+{
+        int i, ptr;
+        uint8_t piece;
+
+        ptr = 0;
+
+        for (i = 0; i < 8; i++) {
+                piece = cube.corner[i];
+                ptr += writepiece_LST(piece, buf + ptr);
+        }
+
+        for (i = 0; i < 12; i++) {
+                piece = cube.edge[i];
+                ptr += writepiece_LST(piece, buf + ptr);
+        }
+
+        *(buf+ptr-2) = 0;
+}
+
+_static uint8_t
+readmove(char c)
+{
+        switch (c) {
+        case 'U':
+                return U;
+        case 'D':
+                return D;
+        case 'R':
+                return R;
+        case 'L':
+                return L;
+        case 'F':
+                return F;
+        case 'B':
+                return B;
+        default:
+                return _error;
+        }
+}
+
+_static uint8_t
+readmodifier(char c)
+{
+        switch (c) {
+        case '1': /* Fallthrough */
+        case '2': /* Fallthrough */
+        case '3':
+                return c - '0' - 1;
+        case '\'':
+                return 2;
+        default:
+                return 0;
+        }
+}
+
+_static_inline cube_t
+invertco(cube_t c)
+{
+        uint8_t i, piece, orien;
+        cube_t ret;
+
+        ret = c;
+        for (i = 0; i < 8; i++) {
+                piece = c.corner[i];
+                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
+                ret.corner[i] = (piece & _pbits) | orien;
+        }
+
+        return ret;
+}
+
+_static int
+permsign(uint8_t *a, int n)
+{
+        int i, j;
+        uint8_t ret = 0;
+
+        for (i = 0; i < n; i++)
+                for (j = i+1; j < n; j++)
+                        ret += a[i] > a[j] ? 1 : 0;
+
+        return ret % 2;
+}
 
 cube_t
 cube_new(void)
@@ -250,51 +504,22 @@ cube_inverse(cube_t cube)
 }
 
 cube_t
-applymoves(cube_t cube, char *buf)
+cube_move(cube_t c, move_t m)
 {
-        cube_t ret;
-        uint8_t r, m;
-        char *b;
-
-        DBG_ASSERT(cube_consistent(cube), zero,
-            "move error: inconsistent cube\n");
-
-        ret = cube_clone(cube);
-
-        for (b = buf; *b != '\0'; b++) {
-                while (*b == ' ' || *b == '\t' || *b == '\n')
-                        b++;
-                if (*b == '\0')
-                        goto applymoves_finish;
-                if ((r = readmove(*b)) == _error)
-                        goto applymoves_error;
-                if ((m = readmodifier(*(b+1))) != 0)
-                        b++;
-                ret = move(ret, r + m);
-        }
-
-applymoves_finish:
-        return ret;
-
-applymoves_error:
-        DBG_LOG("applymoves error\n");
-        return zero;
+        return cube_compose(c, move_table[m]);
 }
 
 cube_t
-applytrans(cube_t cube, char *buf)
+cube_transform(cube_t c, trans_t t)
 {
-        cube_t ret;
-        uint8_t t;
-
-        DBG_ASSERT(cube_consistent(cube), zero,
-            "transformation error: inconsistent cube\n");
+        cube_t tcube, tinv;
 
-        t = readtrans(buf);
-        ret = cube_clone(cube);
-        ret = transform(ret, t);
+        tcube = trans_table[t][NORMAL];
+        tinv = trans_table[t][INVERSE];
 
-        return cube_clone(ret);
+        return t < 24 ?
+            cube_compose(cube_compose(tcube, c), tinv) :
+            invertco(cube_compose(cube_compose(tcube, c), tinv));
 }
 
 int64_t
@@ -368,335 +593,65 @@ write_error:
         buf[len+1] = '\0';
 }
 
-_static int
-permsign(uint8_t *a, int n)
-{
-        int i, j;
-        uint8_t ret = 0;
-
-        for (i = 0; i < n; i++)
-                for (j = i+1; j < n; j++)
-                        ret += a[i] > a[j] ? 1 : 0;
-
-        return ret % 2;
-}
-
-_static uint8_t
-readco(char *str)
-{
-        if (*str == '0')
-                return 0;
-        if (*str == '1')
-                return _ctwist_cw;
-        if (*str == '2')
-                return _ctwist_ccw;
-
-        DBG_LOG("Error reading CO\n");
-        return _error;
-}
-
-_static uint8_t
-readcp(char *str)
-{
-        uint8_t c;
-
-        for (c = 0; c < 8; c++)
-                if (!strncmp(str, cornerstr[c], 3) ||
-                    !strncmp(str, cornerstralt[c], 3))
-                        return c;
-
-        DBG_LOG("Error reading CP\n");
-        return _error;
-}
-
-_static uint8_t
-readeo(char *str)
-{
-        if (*str == '0')
-                return 0;
-        if (*str == '1')
-                return _eflip;
-
-        DBG_LOG("Error reading EO\n");
-        return _error;
-}
-
-_static uint8_t
-readep(char *str)
-{
-        uint8_t e;
-
-        for (e = 0; e < 12; e++)
-                if (!strncmp(str, edgestr[e], 2))
-                        return e;
-
-        DBG_LOG("Error reading EP\n");
-        return _error;
-}
-
-_static cube_t
-read_H48(char *buf)
+int
+cube_readmoves(char *buf, move_t *ret)
 {
-        int i;
-        uint8_t piece, orient;
-        cube_t ret = {0};
+        int n;
+        move_t r, m;
         char *b;
-        
-        b = buf;
 
-        for (i = 0; i < 12; i++) {
+        for (n = 0, b = buf; *b != '\0'; b++) {
                 while (*b == ' ' || *b == '\t' || *b == '\n')
                         b++;
-                if ((piece = readep(b)) == _error)
-                        return zero;
-                b += 2;
-                if ((orient = readeo(b)) == _error)
-                        return zero;
-                b++;
-                ret.edge[i] = piece | orient;
-        }
-        for (i = 0; i < 8; i++) {
-                while (*b == ' ' || *b == '\t' || *b == '\n')
+                if (*b == '\0')
+                        goto applymoves_finish;
+                if ((r = readmove(*b)) == _error)
+                        goto applymoves_error;
+                if ((m = readmodifier(*(b+1))) != 0)
                         b++;
-                if ((piece = readcp(b)) == _error)
-                        return zero;
-                b += 3;
-                if ((orient = readco(b)) == _error)
-                        return zero;
-                b++;
-                ret.corner[i] = piece | orient;
-        }
-
-        return ret;
-}
-
-_static uint8_t
-readpiece_LST(char **b)
-{
-        uint8_t ret;
-        bool read;
-
-        while (**b == ',' || **b == ' ' || **b == '\t' || **b == '\n')
-                (*b)++;
-
-        for (ret = 0, read = false; **b >= '0' && **b <= '9'; (*b)++) {
-                read = true;
-                ret = ret * 10 + (**b) - '0';
-        }
-
-        return read ? ret : _error;
-}
-
-_static cube_t
-read_LST(char *buf)
-{
-        int i;
-        cube_t ret = {0};
-
-        for (i = 0; i < 8; i++)
-                ret.corner[i] = readpiece_LST(&buf);
-
-        for (i = 0; i < 12; i++)
-                ret.edge[i] = readpiece_LST(&buf);
-
-        return ret;
-}
-
-_static int
-writepiece_LST(uint8_t piece, char *buf)
-{
-        char digits[3];
-        int i, len = 0;
-
-        while (piece != 0) {
-                digits[len++] = (piece % 10) + '0';
-                piece /= 10;
-        }
-
-        if (len == 0)
-                digits[len++] = '0';
-
-        for (i = 0; i < len; i++)
-                buf[i] = digits[len-i-1];
-
-        buf[len] = ',';
-        buf[len+1] = ' ';
-
-        return len+2;
-}
-
-_static void
-write_H48(cube_t cube, char *buf)
-{
-        uint8_t piece, perm, orient;
-        int i;
-
-        for (i = 0; i < 12; i++) {
-                piece = cube.edge[i];
-                perm = piece & _pbits;
-                orient = (piece & _eobit) >> _eoshift;
-                buf[4*i    ] = edgestr[perm][0];
-                buf[4*i + 1] = edgestr[perm][1];
-                buf[4*i + 2] = orient + '0';
-                buf[4*i + 3] = ' ';
-        }
-        for (i = 0; i < 8; i++) {
-                piece = cube.corner[i];
-                perm = piece & _pbits;
-                orient = (piece & _cobits) >> _coshift;
-                buf[48 + 5*i    ] = cornerstr[perm][0];
-                buf[48 + 5*i + 1] = cornerstr[perm][1];
-                buf[48 + 5*i + 2] = cornerstr[perm][2];
-                buf[48 + 5*i + 3] = orient + '0';
-                buf[48 + 5*i + 4] = ' ';
-        }
-
-        buf[48+39] = '\0';
-}
-
-_static void
-write_LST(cube_t cube, char *buf)
-{
-        int i, ptr;
-        uint8_t piece;
-
-        ptr = 0;
-
-        for (i = 0; i < 8; i++) {
-                piece = cube.corner[i];
-                ptr += writepiece_LST(piece, buf + ptr);
+                ret[n++] = m + r;
         }
 
-        for (i = 0; i < 12; i++) {
-                piece = cube.edge[i];
-                ptr += writepiece_LST(piece, buf + ptr);
-        }
-
-        *(buf+ptr-2) = 0;
-}
-
-_static uint8_t
-readmove(char c)
-{
-        switch (c) {
-        case 'U':
-                return U;
-        case 'D':
-                return D;
-        case 'R':
-                return R;
-        case 'L':
-                return L;
-        case 'F':
-                return F;
-        case 'B':
-                return B;
-        default:
-                return _error;
-        }
-}
+applymoves_finish:
+        return n;
 
-_static uint8_t
-readmodifier(char c)
-{
-        switch (c) {
-        case '1': /* Fallthrough */
-        case '2': /* Fallthrough */
-        case '3':
-                return c - '0' - 1;
-        case '\'':
-                return 2;
-        default:
-                return 0;
-        }
+applymoves_error:
+        DBG_LOG("applymoves error\n");
+        return -1;
 }
 
-_static uint8_t
-readtrans(char *buf)
+trans_t
+cube_readtrans(char *buf)
 {
-        uint8_t t;
+        trans_t t;
 
         for (t = 0; t < 48; t++)
                 if (!strncmp(buf, transstr[t], 11))
                         return t;
 
-        DBG_LOG("readtrans error\n");
-        return _error;
+        return -1;
 }
 
-_static int
-writemoves(uint8_t *m, int n, char *buf)
+char *
+cube_movestr(move_t m)
 {
-        int i;
-        size_t len;
-        char *b, *s;
-
-        for (i = 0, b = buf; i < n; i++, b++) {
-                s = movestr[m[i]];
-                len = strlen(s);
-                memcpy(b, s, len);
-                b += len;       
-                *b = ' ';
-        }
-
-        if (b != buf)
-                b--; /* Remove last space */
-        *b = '\0';
-
-        return b - buf;
+        return movestr[m];
 }
 
-_static void
-writetrans(uint8_t t, char *buf)
+char *
+cube_transstr(trans_t t)
 {
-        if (t >= 48)
-                memcpy(buf, "error trans", 11);
-        else
-                memcpy(buf, transstr[t], 11);
-        buf[11] = '\0';
+        return transstr[t];
 }
 
-_static cube_t
-move(cube_t c, move_t m)
+move_t
+cube_inversemove(move_t m)
 {
-        return cube_compose(c, move_table[m]);
+        return m - 2*(m%3) + 2;
 }
 
-_static_inline cube_t
-invertco(cube_t c)
-{
-        uint8_t i, piece, orien;
-        cube_t ret;
-
-        ret = c;
-        for (i = 0; i < 8; i++) {
-                piece = c.corner[i];
-                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
-                ret.corner[i] = (piece & _pbits) | orien;
-        }
-
-        return ret;
-}
-
-
-_static cube_t
-transform(cube_t c, trans_t t)
-{
-        cube_t tcube, tinv;
-
-        tcube = trans_table[t][NORMAL];
-        tinv = trans_table[t][INVERSE];
-
-        return t < 24 ?
-            cube_compose(cube_compose(tcube, c), tinv) :
-            invertco(cube_compose(cube_compose(tcube, c), tinv));
-}
-
-/* TODO: expose or remove, maybe add inverse move */
-_static_inline uint8_t inverse_trans(uint8_t);
-
-_static_inline uint8_t
-inverse_trans(uint8_t t)
+trans_t
+cube_inversetrans(trans_t t)
 {
         return inverse_trans_table[t];
 }
diff --git a/cube.h b/cube.h
index 5ef23a8..f2330b0 100644
--- a/cube.h
+++ b/cube.h
@@ -1,3 +1,19 @@
+typedef enum {
+        U, U2, U3, D, D2, D3,
+        R, R2, R3, L, L2, L3,
+        F, F2, F3, B, B2, B3
+} move_t;
+
+typedef enum {
+        UFr, ULr, UBr, URr, DFr, DLr, DBr, DRr,
+        RUr, RFr, RDr, RBr, LUr, LFr, LDr, LBr,
+        FUr, FRr, FDr, FLr, BUr, BRr, BDr, BLr,
+
+        UFm, ULm, UBm, URm, DFm, DLm, DBm, DRm,
+        RUm, RFm, RDm, RBm, LUm, LFm, LDm, LBm,
+        FUm, FRm, FDm, FLm, BUm, BRm, BDm, BLm
+} trans_t;
+
 typedef struct {
         uint8_t corner[8];
         uint8_t edge[12];
@@ -12,9 +28,17 @@ bool cube_equal(cube_t, cube_t);
 bool cube_error(cube_t);
 cube_t cube_compose(cube_t, cube_t);
 cube_t cube_inverse(cube_t);
+cube_t cube_move(cube_t, move_t);
+cube_t cube_transform(cube_t, trans_t);
 
 int64_t cube_coord_co(cube_t);
 int64_t cube_coord_eo(cube_t);
 
 cube_t cube_read(char *format, char *buf);
 void cube_write(char *format, cube_t cube, char *buf);
+int cube_readmoves(char *, move_t *);
+char *cube_movestr(move_t);
+trans_t cube_readtrans(char *);
+char *cube_transstr(trans_t);
+move_t cube_inversemove(move_t);
+trans_t cube_inversetrans(trans_t);
diff --git a/cube.o b/cube.o
new file mode 100644
index 0000000..9f4fb3d
--- /dev/null
+++ b/cube.o
diff --git a/test/030_move/move_tests.c b/test/030_move/move_tests.c
index 497ac6c..b940ecb 100644
--- a/test/030_move/move_tests.c
+++ b/test/030_move/move_tests.c
@@ -4,13 +4,21 @@ cube_t applymoves(cube_t, char *);
 
 int main(void) {
         char movestr[STRLENMAX], cubestr[STRLENMAX];
+        int i, n;
+        move_t moves[STRLENMAX];
         cube_t cube;
 
         fgets(movestr, STRLENMAX, stdin);
         fgets(cubestr, STRLENMAX, stdin);
         cube = cube_read("H48", cubestr);
 
-        cube = applymoves(cube, movestr);
+        n = cube_readmoves(movestr, moves);
+
+        if (n == -1)
+                printf("Error reading moves!\n");
+
+        for (i = 0; i < n; i++)
+                cube = cube_move(cube, moves[i]);
 
         if (cube_error(cube)) {
                 printf("Error moving cube\n");
diff --git a/test/060_transform/transform_tests.c b/test/060_transform/transform_tests.c
index 454bc22..1748d6d 100644
--- a/test/060_transform/transform_tests.c
+++ b/test/060_transform/transform_tests.c
@@ -5,12 +5,14 @@ cube_t applytrans(cube_t, char *);
 int main(void) {
         char cubestr[STRLENMAX], transtr[STRLENMAX];
         cube_t cube;
+        trans_t t;
 
         fgets(transtr, STRLENMAX, stdin);
         fgets(cubestr, STRLENMAX, stdin);
         cube = cube_read("H48", cubestr);
 
-        cube = applytrans(cube, transtr);
+        t = cube_readtrans(transtr);
+        cube = cube_transform(cube, t);
 
         if (cube_error(cube)) {
                 printf("Error transforming cube\n");
diff --git a/test/061_inverse_trans/inverse_trans_tests.c b/test/061_inverse_trans/inverse_trans_tests.c
index 7de8f66..725e2f9 100644
--- a/test/061_inverse_trans/inverse_trans_tests.c
+++ b/test/061_inverse_trans/inverse_trans_tests.c
@@ -1,36 +1,32 @@
 #include "../test.h"
 
-uint8_t readtrans(char *);
-uint8_t inverse_trans(uint8_t);
-cube_t applymoves(cube_t, char *);
-cube_t applytrans(cube_t, char *);
-extern char *transstr[];
-
 int main(void) {
-        uint8_t t, tinv;
+        uint8_t t, tinv, tt;
         cube_t cube;
 
         for (t = 0; t < 48; t++) {
                 cube = cube_new();
-                cube = applymoves(cube, "R");
-                cube = applymoves(cube, "U");
-                cube = applymoves(cube, "F");
+                cube = cube_move(cube, R);
+                cube = cube_move(cube, U);
+                cube = cube_move(cube, F);
 
-                cube = applytrans(cube, transstr[t]);
-                tinv = inverse_trans(t);
-                cube = applytrans(cube, transstr[tinv]);
+                tt = cube_readtrans(cube_transstr(t));
+                cube = cube_transform(cube, tt);
+                tinv = cube_inversetrans(t);
+                tt = cube_readtrans(cube_transstr(tinv));
+                cube = cube_transform(cube, tt);
 
                 if (cube_error(cube)) {
                         printf("Error transforming cube\n");
                 } else if (!cube_solvable(cube)) {
                         printf("Transformed cube is not solvable\n");
                 } else {
-                        cube = applymoves(cube, "F'");
-                        cube = applymoves(cube, "U'");
-                        cube = applymoves(cube, "R'");
+                        cube = cube_move(cube, F3);
+                        cube = cube_move(cube, U3);
+                        cube = cube_move(cube, R3);
                         if (!cube_solved(cube))
                                 printf("%s: Error! Got %" PRIu8 "\n",
-                                    transstr[t], tinv);
+                                    cube_transstr(t), tinv);
                 }
         }