twisty_puzzles 0.0.6 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59a43662a260f2e013e0b59b6597dbfc4f6b5a04bc9d49b9f350b9c3a050babe
-  data.tar.gz: 98e23ce0bbcb677b9deb490ca02bb2e6c3fbd376c0c5a35dcb79d6e06afbd905
+  metadata.gz: 0f6166de8734039f856869be9f20b6109c194556094bc281ae3138ada4a1ad27
+  data.tar.gz: 6a19cc1ad482ec49831c057d944b9055f70c206882ac618892b0336e8d047e3b
 SHA512:
-  metadata.gz: fb187fa6e58c48444b5629e4ab195f2063d2ad9b0c8f07aa8d3a4e19486c177fb29b38a404e2a80f0690d6491466f94cd638d04fc6d76389ffb915671c2107a4
-  data.tar.gz: 9b89321ce8b01b446b992a318aaf43f2cdc54bc9745d16538f14e2bc93f038a413923a11c0e856e13712e20a29c6d0416344ed577ea5aac642ef295571d489a3
+  metadata.gz: 3ba31f44cb0df6f836d9a9b9908550cd2d6ca0ede672d4784f084b609e1249fd0e8e0f8d6cdc0b09e8faba6a462d49966c698b9d5601a4901aa0ee4eb8bc95c1
+  data.tar.gz: 16727e63c37191c99ed1c185c851c8a541c97f110505f2c6ae5eeeabb186c11c35173d35c2441cc8c15318dd88f380656afc04690d5bb4eaa9b359b9a2725de3

data/ext/twisty_puzzles/native/cube_algorithm.c

@@ -18,12 +18,12 @@ typedef struct {
   CubeMoveType type;
   face_index_t axis_face_index;
   direction_t direction;
-  size_t slice_index;
+  long slice_index;
 } CubeMove;
 
 typedef struct {
   size_t size;
-  size_t cube_size;
+  long cube_size;
   CubeMove* moves;
 } CubeAlgorithmData;
 
@@ -45,15 +45,6 @@ const rb_data_type_t CubeAlgorithmData_type = {
   RUBY_TYPED_FREE_IMMEDIATELY  
 };
 
-static void check_moves(const CubeAlgorithmData* const data, const char* const name) {
-  for (size_t i = 0; i < data->size; ++i) {
-    const CubeMoveType type = data->moves[i].type;
-    if (type != SLICE && type != FACE) {
-      rb_raise(rb_eRuntimeError, "invalid move type %d in %s", type, name);
-    }
-  }
-}
-
 static CubeMove* malloc_moves(const size_t n) {
   CubeMove* const moves = malloc(n * sizeof(CubeMove));
   if (moves == NULL) {
@@ -96,7 +87,7 @@ static CubeMoveType extract_move_type(const VALUE move_symbol) {
   }
 }
 
-static size_t components_for_move_type(const CubeMoveType type) {
+static long components_for_move_type(const CubeMoveType type) {
   switch (type) {
   case SLICE:
     return 4;
@@ -112,24 +103,25 @@ static VALUE CubeAlgorithm_initialize(const VALUE self, const VALUE cube_size, c
   CubeAlgorithmData* data;
   GetCubeAlgorithmData(self, data);
   data->size = RARRAY_LEN(moves);
-  data->cube_size = NUM2INT(cube_size);
+  data->cube_size = FIX2INT(cube_size);
+  check_cube_size(data->cube_size);
   data->moves = malloc_moves(data->size);
-  for (size_t i = 0; i < RARRAY_LEN(moves); ++i) {
+  for (long i = 0; i < RARRAY_LEN(moves); ++i) {
     const VALUE move = rb_ary_entry(moves, i);
     if (RARRAY_LEN(move) < 1) {
       rb_raise(rb_eArgError, "Moves cannot be empty.");
     }
     const CubeMoveType type = extract_move_type(rb_ary_entry(move, 0));
-    const size_t num_components = components_for_move_type(type);
+    const long num_components = components_for_move_type(type);
     if (RARRAY_LEN(move) != num_components) {
       rb_raise(rb_eArgError, "Moves with the given type need to have %ld elements. Got %ld.", num_components, RARRAY_LEN(move));
     }
     data->moves[i].type = type;
     data->moves[i].axis_face_index = face_index(rb_ary_entry(move, 1));
-    data->moves[i].direction = NUM2INT(rb_ary_entry(move, 2));
+    data->moves[i].direction = FIX2INT(rb_ary_entry(move, 2));
     if (type == SLICE) {
-      const size_t slice_index = NUM2INT(rb_ary_entry(move, 3));
-      if (slice_index >= data->cube_size) {
+      const long slice_index = FIX2INT(rb_ary_entry(move, 3));
+      if (slice_index < 0 || slice_index >= data->cube_size) {
         rb_raise(rb_eArgError, "Invalid slice index %ld for cube size %ld.", slice_index, data->cube_size);
       }
       data->moves[i].slice_index = slice_index;

data/ext/twisty_puzzles/native/cube_average.c

@@ -59,7 +59,7 @@ static VALUE CubeAverage_alloc(const VALUE klass) {
 
 static VALUE CubeAverage_initialize(const VALUE self, const VALUE capacity, const VALUE initial_average) {
   Check_Type(capacity, T_FIXNUM);
-  const size_t n = FIX2INT(capacity);
+  const long n = FIX2INT(capacity);
   if (n < 3) {
     rb_raise(rb_eArgError, "The number of elements for a cube average has to be at least 3. Got %ld.", n);
   }
@@ -147,7 +147,7 @@ static VALUE CubeAverage_push_all(const VALUE self, const VALUE new_values) {
   const size_t insert_index = data->insert_index;
   const size_t capacity = data->capacity;
   const size_t start = num_values > capacity ? num_values - capacity : 0;
-  for (size_t i = start; i < RARRAY_LEN(new_values); ++i) {
+  for (long i = start; i < RARRAY_LEN(new_values); ++i) {
     const VALUE new_value = rb_ary_entry(new_values, i);
     data->values[(insert_index + i) % capacity] = NUM2DBL(new_value);
   }

data/ext/twisty_puzzles/native/cube_coordinate.c

@@ -5,7 +5,7 @@
 static VALUE CubeCoordinateClass = Qnil;
 
 typedef struct {
-  size_t cube_size;
+  long cube_size;
   face_index_t on_face_index;
   Point point;
 } CubeCoordinateData;
@@ -26,15 +26,15 @@ const rb_data_type_t CubeCoordinateData_type = {
     TypedData_Get_Struct((obj), CubeCoordinateData, &CubeCoordinateData_type, (data)); \
   } while (0)
 
-size_t num_stickers(const size_t cube_size) {
+size_t num_stickers(const long cube_size) {
   return cube_faces * cube_size * cube_size;
 }
 
-size_t sticker_index(const size_t cube_size, const face_index_t on_face_index, const Point point) {
+size_t sticker_index(const long cube_size, const face_index_t on_face_index, const Point point) {
   return on_face_index * cube_size * cube_size + point.y * cube_size + point.x;
 }
 
-size_t CubeCoordinate_sticker_index(const VALUE self, const size_t cube_size) {
+size_t CubeCoordinate_sticker_index(const VALUE self, const long cube_size) {
   CubeCoordinateData* data;
   GetCubeCoordinateData(self, data);
   if (data->cube_size != cube_size) {
@@ -53,11 +53,11 @@ static VALUE CubeCoordinate_alloc(const VALUE klass) {
   return object;
 }
 
-static size_t inverted_index(const size_t cube_size, const size_t index) {
+static long inverted_index(const long cube_size, const long index) {
   return cube_size - 1 - index;
 }
 
-size_t transform_index(const face_index_t index_base_face_index, const size_t cube_size, const size_t index) {
+long transform_index(const face_index_t index_base_face_index, const long cube_size, const long index) {
   if (index_base_face_index == axis_index(index_base_face_index)) {
     return index;
   } else {
@@ -86,11 +86,11 @@ void check_base_face_indices(const face_index_t on_face_index,
 Point point_on_face(const face_index_t face_index,
                     const face_index_t x_base_face_index,
                     const face_index_t y_base_face_index,
-                    const size_t cube_size,
-                    const size_t untransformed_x,
-                    const size_t untransformed_y) {
-  const size_t transformed_x = transform_index(x_base_face_index, cube_size, untransformed_x);
-  const size_t transformed_y = transform_index(y_base_face_index, cube_size, untransformed_y);
+                    const long cube_size,
+                    const long untransformed_x,
+                    const long untransformed_y) {
+  const long transformed_x = transform_index(x_base_face_index, cube_size, untransformed_x);
+  const long transformed_y = transform_index(y_base_face_index, cube_size, untransformed_y);
   Point point;
   if (switch_axes(x_base_face_index, y_base_face_index)) {
     point.x = transformed_y;
@@ -102,7 +102,7 @@ Point point_on_face(const face_index_t face_index,
   return point;
 }
 
-static void check_cube_index(const size_t cube_size, const size_t index) {
+static void check_cube_index(const long cube_size, const long index) {
   if (index < 0 || index >= cube_size) {
     rb_raise(rb_eArgError, "Invalid value %ld for x with cube size %ld.", index, cube_size);
   }
@@ -121,14 +121,15 @@ static VALUE CubeCoordinate_initialize(const VALUE self,
   Check_Type(y_base_face_symbol, T_SYMBOL);
   Check_Type(x_num, T_FIXNUM);
   Check_Type(y_num, T_FIXNUM);
-  const size_t n = FIX2INT(cube_size);
+  const long n = FIX2INT(cube_size);
+  check_cube_size(n);
   const face_index_t on_face_index = face_index(face_symbol);
   const face_index_t x_base_face_index = face_index(x_base_face_symbol);
   const face_index_t y_base_face_index = face_index(y_base_face_symbol);
   check_base_face_indices(on_face_index, x_base_face_index, y_base_face_index);
-  const size_t untransformed_x = FIX2INT(x_num);
+  const long untransformed_x = FIX2INT(x_num);
   check_cube_index(n, untransformed_x);
-  const size_t untransformed_y = FIX2INT(y_num);
+  const long untransformed_y = FIX2INT(y_num);
   check_cube_index(n, untransformed_y);
   const Point point = point_on_face(on_face_index, x_base_face_index, y_base_face_index, n, untransformed_x, untransformed_y);
   CubeCoordinateData* data;

data/ext/twisty_puzzles/native/cube_coordinate.h

@@ -5,16 +5,16 @@
 #include "face_symbols.h"
 #include "utils.h"
 
-size_t num_stickers(size_t cube_size);
+size_t num_stickers(long cube_size);
 
 typedef struct {
   size_t x;
   size_t y;
 } Point;
 
-size_t sticker_index(size_t cube_size, face_index_t on_face_index, Point point);
+size_t sticker_index(long cube_size, face_index_t on_face_index, Point point);
 
-size_t transform_index(face_index_t index_base_face_index, size_t cube_size, size_t index);
+long transform_index(face_index_t index_base_face_index, long cube_size, long index);
 
 bool switch_axes(face_index_t x_base_face_index, face_index_t y_base_face_index);
 
@@ -25,10 +25,10 @@ void check_base_face_indices(face_index_t on_face_index,
 Point point_on_face(face_index_t on_face_index,
                     face_index_t x_base_face_index,
                     face_index_t y_base_face_index,
-                    size_t cube_size,
-                    size_t untransformed_x,
-                    size_t untransformed_y);
+                    long cube_size,
+                    long untransformed_x,
+                    long untransformed_y);
 
-size_t CubeCoordinate_sticker_index(VALUE self, size_t cube_size);
+size_t CubeCoordinate_sticker_index(VALUE self, long cube_size);
 
 void init_cube_coordinate_class_under(VALUE module);

data/ext/twisty_puzzles/native/cube_state.c

@@ -12,7 +12,7 @@ static VALUE CubeStateClass = Qnil;
 
 static void CubeStateData_mark(void* const ptr) {
   const CubeStateData* data = ptr;
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   for (size_t i = 0; i < num_stickers(n); ++i) {
     rb_gc_mark(data->stickers[i]);
   }
@@ -52,19 +52,10 @@ static VALUE CubeState_alloc(const VALUE klass) {
   return object;
 }
 
-static size_t extract_index_base_face_index(const VALUE face_hash, const VALUE key) {
-  const VALUE index_base_face_symbol = rb_hash_aref(face_hash, key);
-  if (index_base_face_symbol == Qnil) {
-    rb_raise(rb_eTypeError, "Cube faces must have keys called :{x,y}_base_face_symbol that describes which face an x or y value of 0 is close to.");
-  }
-  Check_Type(index_base_face_symbol, T_SYMBOL);
-  return face_index(index_base_face_symbol);
-}
-
 static int CubeState_replace_face(const VALUE key, const VALUE value, const VALUE self) {
   const CubeStateData* data;
   GetInitializedCubeStateData(self, data);
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   Check_Type(value, T_HASH);
   if (RHASH_SIZE(value) != 3) {
     rb_raise(rb_eTypeError, "Cube faces must have 3 entries, got %ld.", RHASH_SIZE(value));
@@ -75,19 +66,17 @@ static int CubeState_replace_face(const VALUE key, const VALUE value, const VALU
   if (stickers == Qnil) {
     rb_raise(rb_eTypeError, "Cube faces must have a key called :stickers that contains the stickers on that face.");
   }
-  const face_index_t x_base_face_index = extract_index_base_face_index(value, ID2SYM(x_base_face_symbol_id));
-  const face_index_t y_base_face_index = extract_index_base_face_index(value, ID2SYM(y_base_face_symbol_id));
   Check_Type(stickers, T_ARRAY);
   if (RARRAY_LEN(stickers) != n) {
       rb_raise(rb_eArgError, "All faces of a %ldx%ld cube must have %ld rows. Got %ld rows.", n, n, n, RARRAY_LEN(stickers));
   }
-  for (size_t y = 0; y < n; ++y) {
+  for (long y = 0; y < n; ++y) {
     const VALUE row = rb_ary_entry(stickers, y);
     Check_Type(row, T_ARRAY);
     if (RARRAY_LEN(row) != n) {
       rb_raise(rb_eArgError, "All rows of a %ldx%ld cube must have %ld cells. Got %ld cells.", n, n, n, RARRAY_LEN(row));
     }
-    for (size_t x = 0; x < n; ++x) {
+    for (long x = 0; x < n; ++x) {
       const VALUE cell = rb_ary_entry(row, x);
       Point point = {x, y};
       data->stickers[sticker_index(n, on_face_index, point)] = cell;
@@ -99,7 +88,8 @@ static int CubeState_replace_face(const VALUE key, const VALUE value, const VALU
 static VALUE CubeState_initialize(const VALUE self, const VALUE cube_size, const VALUE stickers) {
   Check_Type(cube_size, T_FIXNUM);
   Check_Type(stickers, T_HASH);
-  const size_t n = FIX2INT(cube_size);
+  const long n = FIX2INT(cube_size);
+  check_cube_size(n);
   CubeStateData* data;
   GetCubeStateData(self, data);
   data->cube_size = n;
@@ -127,11 +117,11 @@ static VALUE CubeState_sticker_array(const VALUE self,
   check_base_face_indices(on_face_index, x_base_face_index, y_base_face_index);
   const CubeStateData* data;
   GetInitializedCubeStateData(self, data);
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   const VALUE face = rb_ary_new2(n);
-  for (size_t y = 0; y < n; ++y) {
+  for (long y = 0; y < n; ++y) {
     const VALUE row = rb_ary_new2(n);
-    for (size_t x = 0; x < n; ++x) {
+    for (long x = 0; x < n; ++x) {
       const Point point = point_on_face(on_face_index, x_base_face_index, y_base_face_index, n, x, y);
       const VALUE cell = data->stickers[sticker_index(n, on_face_index, point)];
       rb_ary_store(row, x, cell);
@@ -159,7 +149,7 @@ static VALUE CubeState_hash(const VALUE self) {
 
   st_index_t hash = rb_hash_start(data->cube_size);
   hash = rb_hash_uint(hash, (st_index_t)CubeState_hash);
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   for (size_t i = 0; i < num_stickers(n); i++) {
     const VALUE sub_hash = rb_hash(data->stickers[i]);
     hash = rb_hash_uint(hash, NUM2LONG(sub_hash));
@@ -181,7 +171,7 @@ static VALUE CubeState_eql(const VALUE self, const VALUE other) {
   if (self_data->cube_size != other_data->cube_size) {
     return Qfalse;
   }
-  const size_t n = self_data->cube_size;
+  const long n = self_data->cube_size;
   for (size_t i = 0; i < num_stickers(n); ++i) {
     if (!color_eq(self_data->stickers[i], other_data->stickers[i])) {
       return Qfalse;
@@ -193,7 +183,7 @@ static VALUE CubeState_eql(const VALUE self, const VALUE other) {
 static VALUE CubeState_dup(const VALUE self) {
   const CubeStateData* data;
   GetInitializedCubeStateData(self, data);
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   CubeStateData* dupped_data;
   const VALUE dupped = TypedData_Make_Struct(rb_obj_class(self), CubeStateData, &CubeStateData_type, dupped_data);
   dupped_data->cube_size = n;
@@ -208,19 +198,19 @@ static VALUE CubeState_cube_size(const VALUE self) {
   return ST2FIX(data->cube_size);
 }
 
-void rotate_slice_for_cube(const face_index_t turned_face_index, const size_t slice_index, direction_t direction, const CubeStateData* const data) {
+void rotate_slice_for_cube(const face_index_t turned_face_index, const long slice_index, direction_t direction, const CubeStateData* const data) {
   direction = CROP_MOD(direction, 4);
   if (direction == 0) {
     return;
   }
-  const size_t n = data->cube_size;
-  for (size_t i = 0; i < n; ++i) {
+  const long n = data->cube_size;
+  for (long x = 0; x < n; ++x) {
     Sticker4Cycle cycle;
-    for (size_t j = 0; j < neighbor_faces; ++j) {
-      const face_index_t on_face_index = neighbor_face_index(turned_face_index, j);
-      const face_index_t next_face_index = neighbor_face_index(turned_face_index, j + 1);
-      const Point point = point_on_face(on_face_index, turned_face_index, next_face_index, n, slice_index, i);
-      cycle.indices[j] = sticker_index(n, on_face_index, point);
+    for (size_t i = 0; i < neighbor_faces; ++i) {
+      const face_index_t on_face_index = neighbor_face_index(turned_face_index, i);
+      const face_index_t next_face_index = neighbor_face_index(turned_face_index, i + 1);
+      const Point point = point_on_face(on_face_index, turned_face_index, next_face_index, n, slice_index, x);
+      cycle.indices[i] = sticker_index(n, on_face_index, point);
     }
     apply_sticker_4cycle(data->stickers, cycle, direction);
   }  
@@ -231,9 +221,9 @@ void rotate_face_for_cube(const face_index_t turned_face_index, direction_t dire
   if (direction == 0) {
     return;
   }
-  const size_t n = data->cube_size;
-  for (size_t y = 0; y < n / 2; ++y) {
-    for (size_t x = 0; x < (n + 1) / 2; ++x) {
+  const long n = data->cube_size;
+  for (long y = 0; y < n / 2; ++y) {
+    for (long x = 0; x < (n + 1) / 2; ++x) {
       Sticker4Cycle cycle;
       for (size_t j = 0; j < neighbor_faces; ++j) {
         const face_index_t x_face_index = neighbor_face_index(turned_face_index, j);

data/ext/twisty_puzzles/native/cube_state.h

@@ -5,7 +5,7 @@
 #include "face_symbols.h"
 
 typedef struct {
-  size_t cube_size;
+  long cube_size;
   VALUE* stickers;
 } CubeStateData;
 
@@ -24,7 +24,7 @@ extern const rb_data_type_t CubeStateData_type;
     } \
   } while(0)
 
-void rotate_slice_for_cube(face_index_t turned_face_index, size_t slice_index, direction_t direction, const CubeStateData* data);
+void rotate_slice_for_cube(face_index_t turned_face_index, long slice_index, direction_t direction, const CubeStateData* data);
 
 void rotate_face_for_cube(face_index_t turned_face_index, direction_t direction, const CubeStateData* data);
 

data/ext/twisty_puzzles/native/face_symbols.h

@@ -4,8 +4,8 @@
 
 #include "utils.h"
 
-typedef char face_index_t;
-typedef char axis_index_t;
+typedef unsigned char face_index_t;
+typedef unsigned char axis_index_t;
 
 #define cube_faces 6
 #define neighbor_faces 4

data/ext/twisty_puzzles/native/skewb_algorithm.c

@@ -50,15 +50,6 @@ const rb_data_type_t SkewbAlgorithmData_type = {
   RUBY_TYPED_FREE_IMMEDIATELY  
 };
 
-static void check_moves(const SkewbAlgorithmData* const data, const char* const name) {
-  for (size_t i = 0; i < data->size; ++i) {
-    const SkewbMoveType type = data->moves[i].type;
-    if (type != MOVE && type != ROTATION) {
-      rb_raise(rb_eRuntimeError, "invalid move type %d in %s", type, name);
-    }
-  }
-}
-
 static SkewbMove* malloc_moves(const size_t n) {
   SkewbMove* const moves = malloc(n * sizeof(SkewbMove));
   if (moves == NULL) {
@@ -122,7 +113,7 @@ static VALUE SkewbAlgorithm_initialize(const VALUE self, const VALUE moves) {
   data->size = RARRAY_LEN(moves);
   data->initialized = TRUE;
   data->moves = malloc_moves(data->size);
-  for (size_t i = 0; i < RARRAY_LEN(moves); ++i) {
+  for (long i = 0; i < RARRAY_LEN(moves); ++i) {
     const VALUE move = rb_ary_entry(moves, i);
     if (RARRAY_LEN(move) != 3) {
       rb_raise(rb_eArgError, "Moves must have 3 elements. Got %ld.", RARRAY_LEN(moves));
@@ -171,8 +162,8 @@ static face_index_t axis_face_on_corner(const Corner corner, const face_index_t
 
 bool corners_eq(Corner left, Corner right) {
   return left.face_indices[0] == right.face_indices[0] &&
-    (left.face_indices[1] == right.face_indices[1] && left.face_indices[2] == right.face_indices[2] ||
-     left.face_indices[1] == right.face_indices[2] && left.face_indices[2] == right.face_indices[1]);
+    ((left.face_indices[1] == right.face_indices[1] && left.face_indices[2] == right.face_indices[2]) ||
+     (left.face_indices[1] == right.face_indices[2] && left.face_indices[2] == right.face_indices[1]));
 }
 
 size_t equivalent_corner_index(const FaceCorners corners, const Corner corner) {  

data/ext/twisty_puzzles/native/skewb_coordinate.c

@@ -56,17 +56,6 @@ size_t center_sticker_index(const face_index_t on_face_index) {
   return on_face_index * skewb_stickers_per_face;
 }
 
-static VALUE part_type_from_symbol(const VALUE part_type_symbol) {
-  Check_Type(face_symbol, T_SYMBOL);
-  if (SYM2ID(part_type_symbol) == center_part_type_id) {
-    return CENTER;
-  } else if (SYM2ID(part_type_symbol) == corner_part_type_id) {
-    return CORNER;
-  } else {
-    rb_raise(rb_eArgError, "Invalid part type symbol %+"PRIsVALUE"", part_type_symbol);
-  }
-}
-
 static VALUE part_type_to_symbol(const SkewbPartType part_type) {
   // Caching these keys isn't easy because the garbage collector will get them.
   switch (part_type) {

data/ext/twisty_puzzles/native/skewb_layer_fingerprint.c

@@ -32,7 +32,7 @@ static ID times = 848;
 
 typedef struct {
   Corner corner_pairs[max_corner_pair_group_size][2];
-  int num_corner_pairs;
+  size_t num_corner_pairs;
   // Number of different group fingerprints. This can be used to merge several group fingerprints.
   int num_group_fingerprints;
 } CornerPairGroup;
@@ -55,7 +55,7 @@ static bool has_color_at(const ActualCornerStickers actual, const size_t index,
 }
 
 typedef struct {
-  int layer_index;
+  size_t layer_index;
   bool is_oriented;
   bool is_present;
 } ActualCornerStickersInfo;
@@ -268,4 +268,5 @@ void init_skewb_layer_fingerprint_method_under(const VALUE module) {
   plus = rb_intern("+");
   times = rb_intern("*");
   rb_define_singleton_method(module, "skewb_layer_fingerprint", skewb_layer_fingerprint, 2);
+  init_corner_pair_groups();
 }

data/ext/twisty_puzzles/native/skewb_state.c

@@ -43,8 +43,6 @@ static int SkewbState_replace_face(const VALUE key, const VALUE value, const VAL
 
 static VALUE SkewbState_initialize(const VALUE self, const VALUE stickers) {
   Check_Type(stickers, T_HASH);
-  SkewbStateData* data;
-  GetSkewbStateData(self, data);
   if (RHASH_SIZE(stickers) != skewb_faces) {
     rb_raise(rb_eTypeError, "Skewbs must have %d faces. Got %ld.", skewb_faces, RHASH_SIZE(stickers));
   }

data/ext/twisty_puzzles/native/utils.c

@@ -64,7 +64,7 @@ int log2_64_floor(uint64_t value) {
     return tab64[((uint64_t)((value - (value >> 1))*0x07EDD5E59A4E28C2)) >> 58];
 }
 
-uint64_t iexp(const uint64_t base, uint32_t exp) {
+uint64_t iexp(const uint64_t base, const uint32_t exp) {
   uint64_t result = 1;
   for (uint32_t m = 1 << 31; m; m >>= 1) {
     result = result * result;
@@ -74,3 +74,9 @@ uint64_t iexp(const uint64_t base, uint32_t exp) {
   }
   return result;
 }
+
+void check_cube_size(const long cube_size) {
+  if (cube_size <= 0) {
+    rb_raise(rb_eArgError, "Cube size must be positive. Got %ld.", cube_size);
+  }
+}

data/ext/twisty_puzzles/native/utils.h

@@ -5,11 +5,8 @@
 
 #define MIN(a, b) ((a) > (b) ? (b) : (a))
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
-#define FALSE 0
-#define TRUE 1
 #define CROP_MOD(a, b) (((a) % (b) + (b)) % (b))
 
-typedef char bool;
 typedef char direction_t;
 
 typedef struct {
@@ -29,3 +26,5 @@ int color_eq(VALUE left, VALUE right);
 int log2_64_floor(uint64_t value);
 
 uint64_t iexp(uint64_t base, uint32_t exp);
+
+void check_cube_size(long cube_size);

data/lib/twisty_puzzles/abstract_move.rb

@@ -143,6 +143,10 @@ module TwistyPuzzles
       prepend_slice_move(other, cube_size)
     end
 
+    def prepend_slice_move(_other, _cube_size)
+      raise NotImplementedError, "#{self.class}#prepend_slice_move is not implemented"
+    end
+
     private
 
     def move_count_internal(metric, slice_factor, direction_factor)

data/lib/twisty_puzzles/abstract_move_parser.rb

@@ -31,14 +31,14 @@ module TwistyPuzzles
     def parse_move(move_string)
       match = move_string.match(regexp)
       if !match || !match.pre_match.empty? || !match.post_match.empty?
-        raise ArgumentError("Invalid move #{move_string}.")
+        raise ArgumentError, "Invalid move #{move_string}."
       end
 
       parsed_parts = parse_named_captures(match)
       move_type_creators.each do |parser|
         return parser.create(parsed_parts) if parser.applies_to?(parsed_parts)
       end
-      raise "No move type creator applies to #{parsed_parts}"
+      raise ArgumentError, "No move type creator applies to #{parsed_parts}"
     end
   end
 end

data/lib/twisty_puzzles/algorithm_transformation.rb

@@ -4,28 +4,36 @@ require 'twisty_puzzles/cube_direction'
 require 'twisty_puzzles/rotation'
 
 module TwistyPuzzles
-  AlgorithmTransformation =
-    Struct.new(:rotation, :mirror, :mirror_normal_face) do
-      def transformed(algorithm)
-        algorithm = algorithm.mirror(mirror_normal_face) if mirror
-        algorithm.rotate_by(rotation)
-      end
+  # A transformation consisting of mirroring and rotating that can be applied to an algorithm.
+  class AlgorithmTransformation
+    def initialize(rotation, mirror, mirror_normal_face)
+      @rotation = rotation
+      @mirror = mirror
+      @mirror_normal_face = mirror_normal_face
+    end
 
-      def identity?
-        rotation.identity? && !mirror
-      end
+    attr_reader :rotation, :mirror, :mirror_normal_face
 
-      # Returns algorithm transformations that mirror an algorithm and rotate it around a face.
-      def self.around_face(face)
-        around_face_rotations = CubeDirection::ALL_DIRECTIONS.map { |d| Rotation.new(face, d) }
-        mirror_normal_face = face.neighbors.first
-        around_face_rotations.product([true, false]).map do |r, m|
-          AlgorithmTransformation.new(r, m, mirror_normal_face)
-        end
-      end
+    def transformed(algorithm)
+      algorithm = algorithm.mirror(mirror_normal_face) if mirror
+      algorithm.rotate_by(rotation)
+    end
 
-      def self.around_face_without_identity(face)
-        around_face(face).reject(&:identity?)
+    def identity?
+      rotation.identity? && !mirror
+    end
+
+    # Returns algorithm transformations that mirror an algorithm and rotate it around a face.
+    def self.around_face(face)
+      around_face_rotations = CubeDirection::ALL_DIRECTIONS.map { |d| Rotation.new(face, d) }
+      mirror_normal_face = face.neighbors.first
+      around_face_rotations.product([true, false]).map do |r, m|
+        AlgorithmTransformation.new(r, m, mirror_normal_face)
       end
     end
+
+    def self.around_face_without_identity(face)
+      around_face(face).reject(&:identity?)
+    end
+  end
 end

data/lib/twisty_puzzles/axis_face_and_direction_move.rb

@@ -55,7 +55,9 @@ module TwistyPuzzles
         self
       else
         rotation_neighbors = rotation.axis_face.neighbors
-        face_index = rotation_neighbors.index(@axis_face) || raise
+        face_index = rotation_neighbors.index(@axis_face)
+        raise unless face_index
+
         new_axis_face =
           rotation_neighbors[(face_index + rotation.direction.value) % rotation_neighbors.length]
         fields = replace_once(identifying_fields, @axis_face, new_axis_face)

data/lib/twisty_puzzles/color_scheme.rb

@@ -37,7 +37,7 @@ module TwistyPuzzles
     end
 
     def part_for_colors(part_type, colors)
-      raise ArgumentError unless part_type.is_a?(Class)
+      raise ArgumentError unless part_type.is_a?(Class) && (part_type < Part)
 
       part_type.for_face_symbols(colors.map { |c| face_symbol(c) })
     end
@@ -95,10 +95,12 @@ module TwistyPuzzles
 
     def chirality_corner_source_and_unknown_index(obvious_turned_face_symbols_to_colors)
       corner_matcher =
-        CornerMatcher.new(CHIRALITY_FACE_SYMBOLS.map do |s|
-                            # This will return nil for exactly one face that we don't know yet.
-                            @colors_to_face_symbols[obvious_turned_face_symbols_to_colors[s]]
-                          end)
+        CornerMatcher.new(
+          CHIRALITY_FACE_SYMBOLS.map do |s|
+            # This will return nil for exactly one face that we don't know yet.
+            @colors_to_face_symbols[obvious_turned_face_symbols_to_colors[s]]
+          end
+        )
 
       # There should be exactly one corner that gets mapped to the chirality corner.
       chirality_corner_source =
@@ -141,7 +143,7 @@ module TwistyPuzzles
                 "Color #{c} cannot be part of the color scheme because it is a reserved color."
         end
       end
-      raise ArgumentError unless face_symbols_to_colors.values.all? { |c| c.is_a?(Symbol) }
+      raise ArgumentError unless face_symbols_to_colors.values.all?(Symbol)
     end
 
     def add_missing_mappings(turned_face_symbols_to_colors, chirality_corner_source, unknown_index)

data/lib/twisty_puzzles/commutator.rb

@@ -10,6 +10,10 @@ module TwistyPuzzles
     def cancellations(other, cube_size, metric = :htm)
       algorithm.cancellations(other.algorithm, cube_size, metric)
     end
+
+    def algorithm
+      raise NotImplementedError
+    end
   end
 
   # Algorithm that is used like a commutator but actually isn't one.

data/lib/twisty_puzzles/coordinate.rb

@@ -6,6 +6,7 @@ require 'twisty_puzzles/native'
 
 module TwistyPuzzles
   # Coordinate of a sticker on the cube.
+  # rubocop:disable  Metrics/ClassLength
   class Coordinate
     def self.highest_coordinate(cube_size)
       cube_size - 1
@@ -121,6 +122,23 @@ module TwistyPuzzles
       from_indices(face, cube_size, m, m)
     end
 
+    def self.face(face, cube_size)
+      neighbor_a, neighbor_b = face.neighbors[0..1]
+      coordinate_range(cube_size).collect_concat do |x|
+        coordinate_range(cube_size).map do |y|
+          from_face_distances(face, cube_size, neighbor_a => x, neighbor_b => y)
+        end
+      end
+    end
+
+    def self.layer(face, cube_size)
+      face.neighbors.zip(face.neighbors.rotate(1)).collect_concat do |neighbor, next_neighbor|
+        coordinate_range(cube_size).map do |i|
+          from_face_distances(neighbor, cube_size, face => 0, next_neighbor => i)
+        end
+      end + self.face(face, cube_size)
+    end
+
     def self.edges_outside(face, cube_size)
       face.neighbors.zip(face.neighbors.rotate(1)).collect_concat do |neighbor, next_neighbor|
         1.upto(cube_size - 2).map do |i|
@@ -261,6 +279,7 @@ module TwistyPuzzles
       rots
     end
   end
+  # rubocop:enable Metrics/ClassLength
 
   # Coordinate of a sticker on the Skewb.
   class SkewbCoordinate

data/lib/twisty_puzzles/cube.rb

@@ -64,10 +64,18 @@ module TwistyPuzzles
       true
     end
 
+    def num_incarnations(_cube_size)
+      1
+    end
+
     def base_index_on_face(cube_size, incarnation_index)
       base_index_on_other_face(solved_face, cube_size, incarnation_index)
     end
 
+    def base_index_on_other_face(face, cube_size, incarnation_index)
+      raise NotImplementedError
+    end
+
     def self.for_face_symbols_internal(face_symbols)
       raise unless face_symbols.length == self::FACES
 
@@ -82,6 +90,10 @@ module TwistyPuzzles
       self::ELEMENTS[index]
     end
 
+    def self.valid?(_face_symbols)
+      false
+    end
+
     def <=>(other)
       @piece_index <=> other.piece_index
     end
@@ -110,7 +122,7 @@ module TwistyPuzzles
     # Rotate a piece such that the given face symbol is the first face symbol.
     def rotate_face_symbol_up(face_symbol)
       index = @face_symbols.index(face_symbol)
-      raise "Part #{self} doesn't have face symbol #{c}." unless index
+      raise "Part #{self} doesn't have face symbol #{face_symbol}." unless index
 
       rotate_by(index)
     end
@@ -133,10 +145,6 @@ module TwistyPuzzles
       (0...@face_symbols.length).map { |i| rotate_by(i) }
     end
 
-    def self.create_for_face_symbols(face_symbols)
-      new(face_symbols)
-    end
-
     def self.parse(piece_description)
       face_symbols =
         piece_description.upcase.strip.split('').map do |e|
@@ -338,10 +346,6 @@ module TwistyPuzzles
       find_only(self::ELEMENTS) { |e| e.corresponding_part == corresponding_part }
     end
 
-    def self.create_for_face_symbols(face_symbols)
-      new(self::CORRESPONDING_PART_CLASS.create_for_face_symbols(face_symbols))
-    end
-
     def face_symbol
       @face_symbols[0]
     end
@@ -514,7 +518,7 @@ module TwistyPuzzles
     end
 
     def num_incarnations(cube_size)
-      [cube_size / 2 - 1, 0].max
+      cube_size > 3 ? cube_size / 2 - 1 : 0
     end
 
     # One index of such a piece on a on a NxN face.
@@ -530,14 +534,6 @@ module TwistyPuzzles
   class Corner < Part
     FACES = 3
 
-    def self.create_for_face_symbols(face_symbols)
-      piece_candidates =
-        face_symbols[1..].permutation.map do |cs|
-          new([face_symbols[0]] + cs)
-        end
-      find_only(piece_candidates, &:valid?)
-    end
-
     def self.for_face_symbols(face_symbols)
       unless face_symbols.length == FACES
         raise "Invalid number of face_symbols to create a corner: #{face_symbols.inspect}"
@@ -621,7 +617,7 @@ module TwistyPuzzles
     ELEMENTS = generate_parts
 
     def num_incarnations(cube_size)
-      [cube_size / 2 - 1, 0].max
+      cube_size > 3 ? cube_size / 2 - 1 : 0
     end
 
     # One index of such a piece on a on a NxN face.
@@ -644,10 +640,10 @@ module TwistyPuzzles
     end
 
     def num_incarnations(cube_size)
-      if cube_size.even?
+      if cube_size.even? || cube_size <= 3
         0
       else
-        [cube_size / 2 - 1, 0].max
+        cube_size / 2 - 1
       end
     end
 

data/lib/twisty_puzzles/cube_state.rb

@@ -75,6 +75,16 @@ module TwistyPuzzles
 
     alias == eql?
 
+    def rotation_algorithms
+      Rotation::ALL_ROTATIONS.combination(2).reject do |r0, r1|
+        r0.inverse == r1
+      end.map { |rs| Algorithm.new(rs) } # rubocop:disable Style/MultilineBlockChain
+    end
+
+    def equal_modulo_rotations?(other)
+      rotation_algorithms.any? { |r| r.apply_temporarily_to(self) { |state| state == other } }
+    end
+
     def hash
       @hash ||= [self.class, @native].hash
     end

data/lib/twisty_puzzles/move_type_creator.rb

@@ -6,7 +6,7 @@ module TwistyPuzzles
   class MoveTypeCreator
     def initialize(capture_keys, move_class)
       raise TypeError unless move_class.is_a?(Class)
-      raise TypeError unless capture_keys.all? { |k| k.is_a?(Symbol) }
+      raise TypeError unless capture_keys.all?(Symbol)
 
       @capture_keys = capture_keys.freeze
       @move_class = move_class

data/lib/twisty_puzzles/rotation.rb

@@ -35,10 +35,12 @@ module TwistyPuzzles
 
       direction = translated_direction(skewb_direction)
 
-      Algorithm.new([
-                      Rotation.new(corner.faces[skewb_direction.value], direction),
-                      Rotation.new(corner.faces[0], direction)
-                    ])
+      Algorithm.new(
+        [
+          Rotation.new(corner.faces[skewb_direction.value], direction),
+          Rotation.new(corner.faces[0], direction)
+        ]
+      )
     end
 
     def to_s

data/lib/twisty_puzzles/skewb_state.rb

@@ -26,10 +26,12 @@ module TwistyPuzzles
               next unless c2.face_symbols.include?(c1_rot.face_symbols.first)
 
               c2_rot = c2.rotate_face_symbol_up(c1_rot.face_symbols.first)
-              check_parts.push([
-                                 SkewbCoordinate.for_corner(c1_rot),
-                                 SkewbCoordinate.for_corner(c2_rot)
-                               ])
+              check_parts.push(
+                [
+                  SkewbCoordinate.for_corner(c1_rot),
+                  SkewbCoordinate.for_corner(c2_rot)
+                ]
+              )
             end
             matching_corners.push(check_parts)
           end

data/lib/twisty_puzzles/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TwistyPuzzles
-  VERSION = '0.0.6'
+  VERSION = '0.0.11'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twisty_puzzles
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.11
 platform: ruby
 authors:
 - Bernhard F. Brodowsky
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-21 00:00:00.000000000 Z
+date: 2021-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -164,7 +164,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: bernhard.brodowsky@gmail.com
 executables: []
 extensions:
@@ -245,7 +245,7 @@ metadata:
   homepage_uri: https://github.com/Lykos/twisty_puzzles
   source_code_uri: https://github.com/Lykos/twisty_puzzles
   changelog_uri: https://github.com/Lykos/twisty_puzzles/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -253,15 +253,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Gem for my cube_trainer rails app. Some things are better left in a separate
   gem with no rails, e.g. native extensions. The main purpose is to support my Rails