Implement metadata-based board solving

board.c

@@ -75,7 +75,14 @@ meta_init (struct metadata *meta)
 void
 board_init (struct board *board)
 {
-  memset (board, 0, sizeof board->elements);
+  struct board_element defval;
+  defval.has_value = false;
+  defval.potential = 0x1FF;
+  defval.complexity = 9;
+
+  for (size_t t = 0; t < (sizeof (board->elements) / sizeof (struct board_element)); ++t)
+    memcpy (&board->elements[t], &defval, sizeof (struct board_element));
+
   board->complexity = 9;
   
   for (unsigned i = 0; i < 9; ++i)
@@ -129,7 +136,7 @@ meta_mark (struct metadata *meta, element_value value, unsigned index)
 void
 board_meta_quad_refresh (struct board *board, board_pos qx, board_pos qy)
 {
-  struct metadata *meta = BOARD_QUAD (board, qx, qy);
+  struct metadata *meta = BOARD_QUAD (board, qx * 3, qy * 3);
   board_pos quad_base_x = qx * 3;
   board_pos quad_base_y = qy * 3;
 
@@ -194,7 +201,7 @@ board_meta_can_set (
     return ! (
       meta_has_value (BOARD_ROW (board, y), value) ||
       meta_has_value (BOARD_COL (board, x), value) ||
-      meta_has_value (BOARD_QUAD (board, TO_QUAD (x), TO_QUAD (y)), value)
+      meta_has_value (BOARD_QUAD (board, x, y), value)
     );
   }
   else ERROR("Invalid parameters to function board_meta_can_set()");
@@ -310,7 +317,7 @@ board_get_value (
 
 bool
 board_is_marked (
-  struct board *board,
+  const struct board *board,
   board_pos x,
   board_pos y,
   element_value value
@@ -330,13 +337,8 @@ board_is_valid (struct board *board)
   for (board_pos y = 0; y < 9; ++y)
     for (board_pos x = 0; x < 9; ++x)
       if (
-            board_has_value (board, x, y) &&
+            !board_has_value (board, x, y) &&
-            ! board_meta_can_set (
+            BOARD_ELEM (board, x, y)->potential == 0
-                board,
-                x,
-                y,
-                BOARD_ELEM (board, x, y)->value
-              )
       )
         return false;
   return true;
@@ -359,7 +361,7 @@ board_update_marks (
     elem->complexity = 0;
 
     /* Check x-axis */
-    elem->potential |= BOARD_QUAD (board, TO_QUAD (x), TO_QUAD (y))->marked;
+    elem->potential |= BOARD_QUAD (board, x, y)->marked;
     elem->potential |= BOARD_ROW (board, y)->marked;
     elem->potential |= BOARD_COL (board, x)->marked;
 
@@ -813,15 +815,16 @@ board_place (
         }
 
       /* Update metadata */
-      meta_set_value (BOARD_QUAD (board, quad_x, quad_y), value);
+      meta_set_value (BOARD_QUAD (board, x, y), value);
       meta_set_value (BOARD_ROW  (board, y), value);
       meta_set_value (BOARD_COL  (board, x), value);
 
       /* Set value */
       board_set (board, x, y, value); 
 
+      return true;
       /* Update board complexity */
-      return board_refresh_complexity (board);
+      //return board_refresh_complexity (board);
     }
     else return false;
   }
@@ -846,9 +849,11 @@ board_place_speculative (
       /* Create duplicate and place value */
       board_copy (board, board_duplicate);
 
-      if (! board_place (board_duplicate, x, y, value))
+      if (! board_place (board_duplicate, x, y, value) || ! board_is_valid (board_duplicate))
         return NULL;
 
+      board_refresh_complexity (board_duplicate);
+
       return board_duplicate;
     }
     else return NULL;
@@ -860,7 +865,7 @@ board_place_speculative (
 bool
 board_refresh_complexity (struct board *board)
 {
-  board_update_all_marks (board);
+  //board_update_all_marks (board);
 
   board->complexity = 10;
   for (board_pos y = 0; y < 9; ++y)

board.h

@@ -14,7 +14,7 @@
 /**
  * Get a `struct metadata`-entry from a specified location on the quadrand grid
  */
-#define BOARD_QUAD(board_ptr, qx, qy) (&(board_ptr)->meta_quad[(qy) * 3 + (qx)])
+#define BOARD_QUAD(board_ptr, x, y) (&(board_ptr)->meta_quad[TO_QUAD ((y)) + ((x) / 3)])
 
 /**
  * Get a `struct metadata`-entry from a specified row value
@@ -74,7 +74,7 @@ struct metadata {
 struct board {
   /* Immediate data*/
   struct board_element elements[81];  /* Game board */
-  unsigned char complexity : 3;       /* Complexity of simplest element */
+  unsigned char complexity : 4;       /* Complexity of simplest element */
 
   /* Metadata */
   struct metadata meta_quad [9];      /* Quadrant metadata */
@@ -224,7 +224,7 @@ board_get_value (
  */
 bool
 board_is_marked (
-  struct board *board,
+  const struct board *board,
   board_pos x,
   board_pos y,
   element_value value

main.c

@@ -30,6 +30,14 @@
 #define DEPTH_INCREMENT 3
 
 
+
+struct args {
+  bool valid;
+  unsigned verbosity : 2;
+  char *file_name;
+};
+
+
 struct boards_table {
   struct board **board_specs;
   unsigned long long max_depth;
@@ -66,11 +74,9 @@ tables_ensure_depth (struct boards_table *board_spec, unsigned long long depth)
 bool
 simplify (
   struct boards_table *board_spec,
-  unsigned long long depth
+  unsigned long long depth,
-#ifdef PRINT_STATUS
+  unsigned long long *counter,
-  ,
+  unsigned verbosity
-  unsigned long long *counter
-#endif
 );
 
 
@@ -163,7 +169,7 @@ copy_to_board (struct board_file file, struct board *board)
       board_pos y = i / 10;
 
       if (data[i - 1] != ' ')
-        board_set (board, x - 1, y, data[i - 1] - '0' - 1);
+        board_place (board, x - 1, y, data[i - 1] - '0' - 1);
     }
 }
 
@@ -191,6 +197,50 @@ ansi_cursor_show (bool show)
     fputs("\e[?25l", stdout);
 }
 
+static void
+print_board_verbose (
+  const struct board *board,
+  unsigned whence_x,
+  unsigned whence_y
+)
+{
+  for (board_pos y = 0; y < 9; ++y)
+  {
+    for (board_pos x = 0; x < 9; ++x)
+    {
+      for (element_value vy = 0; vy < 3; ++vy)
+        for (element_value vx = 0; vx < 3; ++vx)
+        {
+          element_value check = vx + (vy * 3);
+
+          ansi_set_cursor (whence_x + (x * 4) + vx, whence_y + (y * 4) + vy);
+          
+          if (board_has_value (board, x, y))
+            printf ("%u", board_get_value (board, x, y) + 1);
+          else if (board_is_marked (board, x, y, check))
+            printf (COLOUR_RED "%u" COLOUR_RESET, check + 1);
+          else
+            fputs (" ", stdout);
+
+          if (vx == 2 && x != 8)
+            fputs ("|", stdout);
+        }
+    }
+    
+    ansi_set_cursor (0, (y * 4) + 3);
+    if (y != 8)
+    {
+      for (unsigned i = 0; i < (4 * 9) - 1; ++i)
+        if ((i + 1) % 4 == 0)
+          fputs ("+", stdout);
+        else
+          fputs ("-", stdout);
+    }
+  }
+
+  fflush (stdout);
+}
+
 
 static void
 print_board (const struct board *board, const struct board *compare, unsigned whence_x, unsigned whence_y)
@@ -252,7 +302,7 @@ first_potential_value (struct board_element *element, struct board *board, bool
   element_value value = 0;
   while (potential != 0)
   {
-    if (potential & 1 == 1)
+    if ((potential & 1) == 1)
       return value;
     ++value;
     potential >>= 1;
@@ -269,37 +319,33 @@ first_potential_value (struct board_element *element, struct board *board, bool
 bool
 simplify (
   struct boards_table *board_specs,
-  unsigned long long depth
+  unsigned long long depth,
-#ifdef PRINT_STATUS
+  unsigned long long *counter,
-  ,
+  unsigned verbosity
-  unsigned long long *counter
-#endif
 )
 {
-#ifdef PRINT_STATUS
-  if (((*counter) & PRINT_STATUS) == 0) {
-  ansi_set_cursor (0, 18);
-  printf ("Reducing... (%lx)", *counter);
-  }
-
-  if (((*counter) & PRINT_STATUS) == 0)
-    print_board (board_specs->board_specs[depth], board_specs->board_specs[0], 21, 0);
-
-  *counter += 1;
-#endif
-
   /* Get current table */
   struct board *board = board_specs->board_specs[depth];
 
+  if (verbosity > 0)
+  {
+    if ((*counter) & (0xFFFF >> (4 * (4 - verbosity))))
+    {
+      print_board_verbose (board, 0, 0);
+      ansi_set_cursor (0, 35);
+      printf ("Iteration: %lu", *counter);
+    }
+    *counter += 1;
+  }
+
+
   bool error;
 
-  bool placed = false;
   unsigned count = 0;
 
   /* Reduce using low-complexity computation */
   while (board->complexity == 1)
   {
-    placed = false;
     for (board_pos y = 0; y < 9; ++y)
       for (board_pos x = 0; x < 9; ++x)
         if (! board_has_value (board, x, y))
@@ -310,19 +356,21 @@ simplify (
             element_value value = first_potential_value (elem, board, &error);
             if (error) return false;
 
-            placed = true;
             ++count;
 
+            //fprintf (stderr, "Placing (%u, %u)=%u (potential=%u)\n", x, y, value, elem->potential);
+            
             if (! board_place (board, x, y, value))
-              break;
+            {
+              bool rerr = meta_has_value (BOARD_ROW (board, y), value);
+              bool cerr = meta_has_value (BOARD_COL (board, x), value);
+              bool qerr = meta_has_value (BOARD_QUAD (board, TO_QUAD (x), TO_QUAD (y)), value);
+              fprintf (stderr, "Error (%u, %u, %u)\n", rerr, cerr, qerr);
+            }
           }
         }
-    if (! placed)
+
-    {
+    board_refresh_complexity (board);
-      print_board (board_specs->board_specs[depth], board_specs->board_specs[0], 21, 0);
-      printf ("Count: %u\n", count);
-      abort ();
-    }
   }
 
   /* Attempt to reduce with speculative placement */
@@ -332,7 +380,7 @@ simplify (
       for (board_pos x = 0; x < 9; ++x)
       {
         struct board_element *elem = BOARD_ELEM (board, x, y);
-        /* Find a simplest element on the board*/
+        /* Find a simplest element on the board */
         if (
             ! board_has_value (board, x, y) &&
             elem->complexity == board->complexity
@@ -354,24 +402,27 @@ simplify (
 
               /* If speculative placement failed, try another value */
               if (board_spec == NULL)
+              {
+                board_unmark (board, x, y, value);
                 continue;
+              }
 
               /* Found solution */
               if (
                   simplify (
                     board_specs,
-                    depth + 1
+                    depth + 1,
-#ifdef PRINT_STATUS
+                    counter,
-                    ,
+                    verbosity
-                    counter
+                  ) &&
-#endif
+                  board_spec->complexity == 0)
-                  ) && board_spec->complexity == 0)
               {
                 board_copy (board_spec, board);
                 x = 9;
                 y = 9;
                 value = 9;
               }
+              else board_unmark (board, x, y, value);
             }
           }
       }
@@ -380,18 +431,66 @@ simplify (
 }
 
 
+struct args
+argparse (int argc, char **argv)
+{
+  struct args result;
+  result.file_name = NULL;
+  result.valid = true;
+  result.verbosity = 0;
+  if (argc < 2)
+  {
+    result.valid = false;
+    return result;
+  }
+
+  for (int i = 1; i < argc; ++i)
+    if (strncmp (argv[i], "-", 1) == 0)
+    {
+      if (result.verbosity != 0)
+      {
+        result.valid = false;
+        return result;
+      }
+      if (strcmp (argv[i], "-v") == 0)
+        result.verbosity = 1;
+      else if (strcmp (argv[i], "-vv") == 0)
+        result.verbosity = 2;
+      else
+      {
+        result.valid = false;
+        return result;
+      }
+    }
+    else if (result.file_name == NULL)
+      result.file_name = argv[i];
+    else
+    {
+      result.valid = false;
+      return result;
+    }
+  return result;
+}
+
+
+
 int
 main (int argc, char **argv, char **env)
 {
-  if (argc != 2) return -1;
+  struct args args = argparse (argc, argv);
+  if (! args.valid)
+  {
+    fputs ("Badly formatted arguments! Usage:\n\t./sudoku [-v[v]] {file name}\n", stderr);
+    return 1;
+  }
   
-  struct board_file file = load_board_file (argv[1]);
+  struct board_file file = load_board_file (args.file_name);
   if (file.fd == -1 || file.data == NULL)
     return -1;
 
   ansi_cursor_show (false);
 
-  /* Allocate board */
+  /* Allocate boards */
   struct board original;
 
   struct boards_table boards;
@@ -406,47 +505,52 @@ main (int argc, char **argv, char **env)
 
   close_board_file (file);
 
-  board_update_all_marks (root_board);
+
-  
+
   ansi_clear_screen ();
-
+  
-  print_board (root_board, NULL, 0, 0);
-
   if (! board_is_valid (root_board))
   {
-    puts ("Supplied board is not valid!");
+    fputs ("Supplied board is not valid!\n", stderr);
 
     ansi_cursor_show (true);
     
     return 1;
   }
+  
 
-  ansi_set_cursor (0, 18);
+  if (args.verbosity == 0)
-  puts("Reducing...");
+    puts ("Simplifying...");
 
 
+  board_refresh_complexity (root_board);
+
   /* Profiler start time */
   clock_t start_clk = clock ();
 
-#ifdef PRINT_STATUS
   unsigned long long counter = 0;
   
-  simplify (&boards, 0, &counter);
+  simplify (&boards, 0, &counter, args.verbosity);
-
-#else
-
-  simplify (&boards, 0);
-
-#endif
 
   /* Profiler end time */
   clock_t end_clk = clock ();
 
-  print_board (root_board, &original, 21, 0);
+  ansi_clear_screen ();
- 
+
-  ansi_set_cursor (0, 18);
+  if (root_board->complexity == 0)
+  {
+    print_board (&original, NULL, 0, 0);
+    print_board (root_board, &original, 21, 0);
+    ansi_set_cursor (0, 18);
+  }
+  else
+  {
+    print_board_verbose (root_board, 0, 0);
+    ansi_set_cursor (0, 36);
+  }
   printf ("Simplification took %Lf seconds\n", ((long double)(end_clk - start_clk))/CLOCKS_PER_SEC);
 
+
   ansi_cursor_show (true);
 
   return 0;