1 files changed, 307 insertions, 0 deletions

diff --git a/old/2021-06-30-reached/steps.c b/old/2021-06-30-reached/steps.c
new file mode 100644
index 0000000..bc833cb
--- /dev/null
+++ b/old/2021-06-30-reached/steps.c
@@ -0,0 +1,307 @@
+#include "steps.h"
+
+/* Standard checkers (return lower bound) ************************************/
+
+static int              estimate_eofb_HTM(CubeTarget ct);
+static int              estimate_coud_HTM(CubeTarget ct);
+static int              estimate_coud_URF(CubeTarget ct);
+static int              estimate_corners_HTM(CubeTarget ct);
+static int              estimate_cornershtr_HTM(CubeTarget ct);
+static int              estimate_corners_URF(CubeTarget ct);
+static int              estimate_cornershtr_URF(CubeTarget ct);
+static int              estimate_drud_HTM(CubeTarget ct);
+static int              estimate_optimal_HTM(CubeTarget ct);
+
+/* Steps *********************************************************************/
+
+Step
+eofb_HTM = {
+        .estimate  = estimate_eofb_HTM,
+        .ready     = check_centers,
+        .moveset   = moveset_HTM
+};
+
+Step
+coud_HTM = {
+        .estimate  = estimate_coud_HTM,
+        .ready     = check_centers,
+        .moveset   = moveset_HTM
+};
+
+Step
+coud_URF = {
+        .estimate  = estimate_coud_URF,
+        .ready     = check_nothing,
+        .moveset   = moveset_URF
+};
+
+Step
+corners_HTM = {
+        .estimate  = estimate_corners_HTM,
+        .ready     = check_centers,
+        .moveset   = moveset_HTM
+};
+
+Step
+cornershtr_HTM = {
+        .estimate  = estimate_cornershtr_HTM,
+        .ready     = check_centers,
+        .moveset   = moveset_HTM
+};
+
+Step
+cornershtr_URF = {
+        .estimate  = estimate_cornershtr_URF,
+        .ready     = check_nothing,
+        .moveset   = moveset_URF
+};
+
+Step
+corners_URF = {
+        .estimate  = estimate_corners_URF,
+        .ready     = check_nothing,
+        .moveset   = moveset_URF
+};
+
+Step
+drud_HTM = {
+        .estimate  = estimate_drud_HTM,
+        .ready     = check_centers,
+        .moveset   = moveset_HTM
+};
+
+Step
+optimal_HTM = {
+        .estimate  = estimate_optimal_HTM,
+        .ready     = check_centers,
+        .moveset   = moveset_HTM
+};
+
+
+/* Pruning tables ************************************************************/
+
+PruneData
+pd_eofb_HTM = {
+        .filename = "ptable_eofb_HTM",
+        .coord    = &coord_eofb,
+        .moveset  = moveset_HTM
+};
+
+PruneData
+pd_coud_HTM = {
+        .filename = "ptable_coud_HTM",
+        .coord    = &coord_coud,
+        .moveset  = moveset_HTM
+};
+
+PruneData
+pd_cornershtr_HTM = {
+        .filename = "ptable_cornershtr_withcosets_HTM",
+        .coord    = &coord_cornershtr,
+        .moveset  = moveset_HTM
+};
+
+PruneData
+pd_corners_HTM = {
+        .filename = "ptable_corners_HTM",
+        .coord    = &coord_corners,
+        .moveset  = moveset_HTM
+};
+
+PruneData
+pd_drud_HTM = {
+        .filename = "ptable_drud_HTM",
+        .coord    = &coord_drud,
+        .moveset  = moveset_HTM
+};
+
+PruneData
+pd_drud_sym16_HTM = {
+        .filename = "pd_drud_sym16_HTM",
+        .coord    = &coord_drud_sym16,
+        .moveset  = moveset_HTM,
+};
+
+PruneData
+pd_khuge_HTM = {
+        .filename = "pd_khuge_HTM",
+        .coord    = &coord_khuge,
+        .moveset  = moveset_HTM
+};
+
+
+/* Standard checkers (return lower bound) ************************************/
+
+static int
+estimate_eofb_HTM(CubeTarget ct)
+{
+        if (!pd_eofb_HTM.generated)
+                genptable(&pd_eofb_HTM);
+
+        return ptableval(&pd_eofb_HTM, ct.cube);
+}
+
+static int
+estimate_coud_HTM(CubeTarget ct)
+{
+        if (!pd_coud_HTM.generated)
+                genptable(&pd_coud_HTM);
+
+        return ptableval(&pd_coud_HTM, ct.cube);
+}
+
+static int
+estimate_coud_URF(CubeTarget ct)
+{
+        /* TODO: I can improve this by checking first the orientation of
+         * the corner in DBL and use that as a reference */
+
+        CubeTarget ct2 = {.cube = apply_move(z, ct.cube), .target = ct.target};
+        CubeTarget ct3 = {.cube = apply_move(x, ct.cube), .target = ct.target};
+
+        int ud = estimate_coud_HTM(ct);
+        int rl = estimate_coud_HTM(ct2);
+        int fb = estimate_coud_HTM(ct3);
+
+        return MIN(ud, MIN(rl, fb));
+}
+
+static int
+estimate_corners_HTM(CubeTarget ct)
+{
+        if (!pd_corners_HTM.generated)
+                genptable(&pd_corners_HTM);
+
+        return ptableval(&pd_corners_HTM, ct.cube);
+}
+
+static int
+estimate_cornershtr_HTM(CubeTarget ct)
+{
+        if (!pd_cornershtr_HTM.generated)
+                genptable(&pd_cornershtr_HTM);
+
+        return ptableval(&pd_cornershtr_HTM, ct.cube);
+}
+
+static int
+estimate_cornershtr_URF(CubeTarget ct)
+{
+        /* TODO: I can improve this by checking first the corner in DBL
+         * and use that as a reference */
+
+        int c, ret = 15;
+        Trans i;
+
+        for (i = 0; i < NROTATIONS; i++) {
+                ct.cube = apply_alg(rotation_alg(i), ct.cube);
+                c = estimate_cornershtr_HTM(ct);
+                ret = MIN(ret, c);
+        }
+
+        return ret;
+}
+
+static int
+estimate_corners_URF(CubeTarget ct)
+{
+        /* TODO: I can improve this by checking first the corner in DBL
+         * and use that as a reference */
+
+        int c, ret = 15;
+        Trans i;
+
+        for (i = 0; i < NROTATIONS; i++) {
+                ct.cube = apply_alg(rotation_alg(i), ct.cube);
+                c = estimate_corners_HTM(ct);
+                ret = MIN(ret, c);
+        }
+
+        return ret;
+}
+
+static int
+estimate_drud_HTM(CubeTarget ct)
+{
+/*
+        if (!pd_drud_HTM.generated)
+                genptable(&pd_drud_HTM);
+
+        return ptableval(&pd_drud_HTM, ct.cube);
+*/
+
+        if (!pd_drud_sym16_HTM.generated)
+                genptable(&pd_drud_sym16_HTM);
+
+        return ptableval(&pd_drud_sym16_HTM, ct.cube);
+}
+
+/* TODO: if lucky, remove this */
+/*
+static int
+estimate_optimal_HTM(CubeTarget ct)
+{
+        static Trans t1 = { .rot = rf, .mirror = false };
+        static Trans t2 = { .rot = bd, .mirror = false };
+        int dr1, dr2, dr3, cor, ret;
+        Cube cube = ct.cube;
+
+        dr1 = estimate_drud_HTM(ct);
+        cor = estimate_corners_HTM(ct);
+        ret = MAX(dr1, cor);
+
+        if (ret > ct.target)
+                return ret;
+
+        ct.cube = apply_trans(t1, cube);
+        dr2 = estimate_drud_HTM(ct);
+        ret = MAX(ret, dr2);
+
+        if (ret > ct.target)
+                return ret;
+
+        ct.cube = apply_trans(t2, cube);
+        dr3 = estimate_drud_HTM(ct);
+
+        if (dr1 == dr2 && dr2 == dr3 && dr1 != 0)
+                dr3++;
+
+        ret = MAX(ret, dr3);
+
+        if (ret == 0)
+                return check_ep(cube) ? 0 : 6;
+
+        return ret; 
+}
+*/
+
+static int
+estimate_optimal_HTM(CubeTarget ct)
+{
+        static Trans t2 = rf, t3 = bd;
+
+        int dr1, dr2, dr3, cor, ret;
+        Cube cube = ct.cube;
+
+        if (!pd_khuge_HTM.generated)
+                genptable(&pd_khuge_HTM);
+
+        dr1 = ptableval(&pd_khuge_HTM, cube);
+        cor = estimate_corners_HTM(ct);
+        ret = MAX(dr1, cor);
+
+        if (ret > ct.target)
+                return ret;
+
+        cube = apply_trans(t2, ct.cube);
+        dr2 = ptableval(&pd_khuge_HTM, cube);
+        ret = MAX(ret, dr2);
+
+        if (ret > ct.target)
+                return ret;
+
+        cube = apply_trans(t3, ct.cube);
+        dr3 = ptableval(&pd_khuge_HTM, cube);
+
+        return MAX(ret, dr3);
+}