src/matrix.c

   1 /*
   2 Generic matrix transformations
   3 */
   4
   5 #include "config.h"
   6
   7 #include <string.h>
   8 #include <stdio.h>
   9 #include <assert.h>
  10
  11 #include "board.h"
  12 #include "matrix.h"
  13 #include "move.h"
  14 #include "types.h"
  15
  16
  17 /*
  18 Rotate square matrix.
  19 */
  20 void matrix_rotate(
  21     u8 dst[static TOTAL_BOARD_SIZ],
  22     const u8 src[static TOTAL_BOARD_SIZ],
  23     u16 side_len,
  24     u8 rotations
  25 ) {
  26     assert(rotations < 4);
  27
  28     u8 x;
  29     u8 y;
  30
  31     switch (rotations) {
  32         case 0:
  33             memcpy(dst, src, side_len * side_len);
  34             break;
  35         case 1:
  36             --side_len;
  37
  38             for (move m = 0; m < TOTAL_BOARD_SIZ; ++m) {
  39                 move_to_coord(m, &x, &y);
  40                 dst[m] = src[coord_to_move(side_len - y, x)];
  41             }
  42             break;
  43         case 2:
  44             --side_len;
  45
  46             for (move m = 0; m < TOTAL_BOARD_SIZ; ++m) {
  47                 dst[m] = src[TOTAL_BOARD_SIZ - 1 - m];
  48             }
  49             break;
  50         case 3:
  51             --side_len;
  52
  53             for (move m = 0; m < TOTAL_BOARD_SIZ; ++m) {
  54                 move_to_coord(m, &x, &y);
  55                 dst[m] = src[coord_to_move(y, side_len - x)];
  56             }
  57             break;
  58     }
  59 }
  60
  61 /*
  62 Rotate contents of an out_board structure.
  63 */
  64 void matrix_rotate2(
  65     out_board * restrict dst,
  66     const out_board * restrict src,
  67     u8 rotations
  68 ) {
  69     assert(rotations < 4);
  70
  71     u8 x;
  72     u8 y;
  73
  74     switch (rotations) {
  75         case 0:
  76             memcpy(dst->value, src->value, TOTAL_BOARD_SIZ * sizeof(double));
  77             memcpy(dst->tested, src->tested, TOTAL_BOARD_SIZ);
  78             break;
  79         case 1:
  80             for (move m = 0; m < TOTAL_BOARD_SIZ; ++m) {
  81                 move_to_coord(m, &x, &y);
  82                 move n = coord_to_move(BOARD_SIZ - 1 - y, x);
  83                 dst->value[m] = src->value[n];
  84                 dst->tested[m] = src->tested[n];
  85             }
  86             break;
  87         case 2:
  88             for (move m = 0; m < TOTAL_BOARD_SIZ; ++m) {
  89                 dst->value[m] = src->value[TOTAL_BOARD_SIZ - 1 - m];
  90                 dst->tested[m] = src->tested[TOTAL_BOARD_SIZ - 1 - m];
  91             }
  92             break;
  93         case 3:
  94             for (move m = 0; m < TOTAL_BOARD_SIZ; ++m) {
  95                 move_to_coord(m, &x, &y);
  96                 move n = coord_to_move(y, BOARD_SIZ - 1 - x);
  97                 dst->value[m] = src->value[n];
  98                 dst->tested[m] = src->tested[n];
  99             }
 100             break;
 101     }
 102
 103     dst->pass = src->pass;
 104 }
 105
 106 /*
 107 Flips a square matrix.
 108 */
 109 void matrix_flip(
 110     u8 dst[static TOTAL_BOARD_SIZ],
 111     const u8 src[static TOTAL_BOARD_SIZ],
 112     u16 side_len
 113 ) {
 114     u8 x;
 115     u8 y;
 116
 117     --side_len;
 118
 119     for (move m = 0; m < TOTAL_BOARD_SIZ; ++m) {
 120         move_to_coord(m, &x, &y);
 121         dst[m] = src[coord_to_move(side_len - x, y)];
 122     }
 123 }
 124
 125 /*
 126 Flips the board contents of an out_board structure.
 127 */
 128 void matrix_flip2(
 129     out_board * restrict dst,
 130     const out_board * restrict src
 131 ) {
 132     u8 x;
 133     u8 y;
 134
 135     for (move m = 0; m < TOTAL_BOARD_SIZ; ++m) {
 136         move_to_coord(m, &x, &y);
 137         move n = coord_to_move(BOARD_SIZ - 1 - x, y);
 138         dst->value[m] = src->value[n];
 139         dst->tested[m] = src->tested[n];
 140     }
 141
 142     dst->pass = src->pass;
 143 }
 144
 145
 146 /*
 147 Produces the move correspondent in the transformed matrix.
 148 */
 149 void reduce_coord(
 150     u8 * restrict x,
 151     u8 * restrict y,
 152     u16 side_len,
 153     d8 method
 154 ) {
 155     if (method == NOREDUCE || *x >= BOARD_SIZ) {
 156         return;
 157     }
 158
 159     if (method < 0) {
 160         method = method * -1;
 161     }
 162
 163     u8 ox = *x;
 164     u8 oy = *y;
 165     u8 ix;
 166     u8 iy;
 167
 168     switch (method) {
 169         case ROTATE90:
 170             ox = *y;
 171             oy = side_len - 1 - *x;
 172             break;
 173         case ROTATE180:
 174             ox = side_len - 1 - *x;
 175             oy = side_len - 1 - *y;
 176             break;
 177         case ROTATE270:
 178             ox = side_len - 1 - *y;
 179             oy = *x;
 180             break;
 181         case ROTFLIP0:
 182             ox = side_len - 1 - *x;
 183             oy = *y;
 184             break;
 185         case ROTFLIP90:
 186             ix = *y;
 187             iy = side_len - 1 - *x;
 188
 189             ox = side_len - 1 - ix;
 190             oy = iy;
 191             break;
 192         case ROTFLIP180:
 193             ix = side_len - 1 - *x;
 194             iy = side_len - 1 - *y;
 195
 196             ox = side_len - 1 - ix;
 197             oy = iy;
 198             break;
 199         case ROTFLIP270:
 200             ix = side_len - 1 - *y;
 201             iy = *x;
 202
 203             ox = side_len - 1 - ix;
 204             oy = iy;
 205     }
 206
 207     *x = ox;
 208     *y = oy;
 209 }
 210
 211