twisty_puzzles 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b7934b9679e720f3675ce3f9db174f4ab9bbc1e028654f4d29aed727a90f052
-  data.tar.gz: ab7e60a7d07dbaa3d164fb0fcd74e89871241bfb2b54b0354ab4d093b137f667
+  metadata.gz: be6ba7974d92dd52a2b5b6307c38aae5695147003ed5f41c4fc36862ada74fb9
+  data.tar.gz: 8a6e4e82d8a76432c4a4e526fa664886aa2da41e4018ff260894cb4f3f96daec
 SHA512:
-  metadata.gz: 991e8297413b4a86b12b463e5ed06c489936ec988ac4816d93350603debc8280399bb7d2e98ff8e1863da7dacd6eafbd7a4d304e9d056f64ea3e477c67d53664
-  data.tar.gz: f30d251aa0aeaab5af7bf32475e01c04cede2e8a0863790eeaeb805f004acb3fcae041d71217a9a79ccd673e1777b1e324a9317b21c3b151783772bbb1c699fe
+  metadata.gz: 478cc39f6e3e15184cac71f77680165735638a20f4fa431a311f544e0c0a44ea344d12d043fa318e6bbfd25dc76af7c2baef90ae286612c4d8cf18921c371520
+  data.tar.gz: d2b1dbefc310a59df6fe927951d8e1fdec5d553f6a4ce4d54c6caec51f0d7a69e688fedac652f32153ebbeb71459fd2f2e042d65f1febd45169c8f8a5f6a8cb6

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

@@ -26,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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twisty_puzzles
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Bernhard F. Brodowsky