twisty_puzzles 0.0.2 → 0.0.7

data/ext/twisty_puzzles/native/skewb_layer_fingerprint.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <ruby.h>
+
+void init_skewb_layer_fingerprint_method_under(VALUE module);

data/ext/twisty_puzzles/native/skewb_state.c

@@ -0,0 +1,214 @@
+#include "skewb_state.h"
+
+#include "face_symbols.h"
+
+static VALUE SkewbStateClass = Qnil;
+
+static void SkewbStateData_mark(void* const ptr) {
+  const SkewbStateData* data = ptr;
+  for (size_t i = 0; i < total_skewb_stickers; ++i) {
+    rb_gc_mark(data->stickers[i]);
+  }
+}
+
+static size_t SkewbStateData_size(const void* const ptr) {
+  return sizeof(SkewbStateData);
+}
+
+const rb_data_type_t SkewbStateData_type = {
+  "SkewbTrainer::Native::SkewbStateData",
+  {SkewbStateData_mark, NULL, SkewbStateData_size, NULL},
+  NULL, NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE SkewbState_alloc(const VALUE klass) {
+  SkewbStateData* data;
+  const VALUE object = TypedData_Make_Struct(klass, SkewbStateData, &SkewbStateData_type, data);
+  for (size_t i = 0; i < total_skewb_stickers; ++i) {
+    data->stickers[i] = Qnil;
+  }
+  return object;
+}
+
+static int SkewbState_replace_face(const VALUE key, const VALUE value, const VALUE self) {
+  SkewbStateData* data;
+  GetSkewbStateData(self, data);
+  const face_index_t on_face_index = face_index(key);
+  for (size_t i = 0; i < skewb_stickers_per_face; ++i) {
+    data->stickers[on_face_index * skewb_stickers_per_face + i] = value;
+  }
+  return ST_CONTINUE;
+}
+
+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));
+  }
+  rb_hash_foreach(stickers, SkewbState_replace_face, self);
+  return self;
+}
+
+static VALUE SkewbState_hash(const VALUE self) {
+  const SkewbStateData* data;
+  GetSkewbStateData(self, data);
+
+  st_index_t hash = rb_hash_start((st_index_t)SkewbState_hash);
+  for (size_t i = 0; i < total_skewb_stickers; i++) {
+    const VALUE sub_hash = rb_hash(data->stickers[i]);
+    hash = rb_hash_uint(hash, NUM2LONG(sub_hash));
+  }
+  return ST2FIX(rb_hash_end(hash));
+}
+
+static VALUE SkewbState_eql(const VALUE self, const VALUE other) {
+  if (self == other) {
+    return Qtrue;
+  }
+  if (rb_obj_class(self) != rb_obj_class(other)) {
+    return Qfalse;
+  }
+  const SkewbStateData* self_data;
+  GetSkewbStateData(self, self_data);
+  const SkewbStateData* other_data;
+  GetSkewbStateData(other, other_data);
+  for (size_t i = 0; i < total_skewb_stickers; ++i) {
+    if (!color_eq(self_data->stickers[i], other_data->stickers[i])) {
+      return Qfalse;
+    }
+  }
+  return Qtrue;
+}
+
+static VALUE SkewbState_dup(const VALUE self) {
+  const SkewbStateData* data;
+  GetSkewbStateData(self, data);
+  SkewbStateData* dupped_data;
+  const VALUE dupped = TypedData_Make_Struct(rb_obj_class(self), SkewbStateData, &SkewbStateData_type, dupped_data);
+  *dupped_data = *data;
+  return dupped;
+}
+
+static VALUE SkewbState_entry(const VALUE self, const VALUE coordinate) {
+  const SkewbStateData* data;
+  GetSkewbStateData(self, data);
+  return data->stickers[SkewbCoordinate_sticker_index(coordinate)];
+}
+
+static VALUE SkewbState_store(const VALUE self, const VALUE coordinate, const VALUE value) {
+  SkewbStateData* data;
+  GetSkewbStateData(self, data);
+  return data->stickers[SkewbCoordinate_sticker_index(coordinate)] = value;
+}
+
+static void apply_twisted_corner_cycle(VALUE* const stickers, const Corner corner, const bool invert) {
+  size_t twisted_corner_cycle[3];
+  for (size_t i = 0; i < 3; ++i) {
+    const Corner corner_variant = rotated_corner(corner, i);
+    twisted_corner_cycle[i] = corner_sticker_index(corner_variant);
+  }
+  apply_sticker_cycle(stickers, twisted_corner_cycle, 3, invert);
+}
+
+static void apply_center_cycle(VALUE* const stickers, const Corner corner, const bool invert) {
+  size_t center_cycle[3];
+  for (size_t i = 0; i < 3; ++i) {
+    center_cycle[i] = center_sticker_index(corner.face_indices[i]);
+  }
+  apply_sticker_cycle(stickers, center_cycle, 3, invert);
+}
+
+static void apply_moved_corner_cycles(VALUE* const stickers, const Corner corner, const bool invert) {
+  Corner adjacent_corners[3];
+  for (size_t corner_index = 0; corner_index < 3; ++corner_index) {
+    adjacent_corners[corner_index].face_indices[0] = opposite_face_index(corner.face_indices[corner_index]);
+    adjacent_corners[corner_index].face_indices[1] = corner.face_indices[(corner_index + 2) % 3];
+    adjacent_corners[corner_index].face_indices[2] = corner.face_indices[(corner_index + 1) % 3];
+  }
+  // We have 3 different cycles, one for the outside stickers and one two for the remaining stickers of the
+  // corners that contain the outside stickers.
+  for (size_t cycle_index = 0; cycle_index < 3; ++cycle_index) {
+    size_t sticker_cycle[3];
+    for (size_t corner_index = 0; corner_index < 3; ++corner_index) {
+      // The current corner, but twisted such that the sticker we care about in the current cycle faces up.
+      const Corner current_corner_for_current_cycle = rotated_corner(adjacent_corners[corner_index], cycle_index);
+      sticker_cycle[corner_index] = corner_sticker_index(current_corner_for_current_cycle);
+    }
+    apply_sticker_cycle(stickers, sticker_cycle, 3, invert);
+  }
+}
+
+void rotate_corner_for_skewb_state(const Corner corner, direction_t direction, SkewbStateData* const skewb_state) {
+  direction = CROP_MOD(direction, 3);
+  if (direction == 0) {
+    return;
+  }
+  const bool invert = direction == 2;
+
+  apply_twisted_corner_cycle(skewb_state->stickers, corner, invert);
+  apply_center_cycle(skewb_state->stickers, corner, invert);
+  apply_moved_corner_cycles(skewb_state->stickers, corner, invert);
+}
+
+static void apply_center_rotation(VALUE* const stickers, const face_index_t axis_face_index, const direction_t direction) {
+  Sticker4Cycle center_cycle;
+  for (size_t i = 0; i < 4; ++i) {
+    center_cycle.indices[i] = center_sticker_index(neighbor_face_index(axis_face_index, i));
+  }
+  apply_sticker_4cycle(stickers, center_cycle, direction);
+}
+
+static void apply_corner_rotations(VALUE* const stickers, const face_index_t axis_face_index, const direction_t direction) {
+  Corner corner;
+  corner.face_indices[2] = axis_face_index;
+  for (size_t cycle_index = 0; cycle_index < 3; ++cycle_index) {
+    Sticker4Cycle corner_cycle;
+    for (size_t corner_index = 0; corner_index < 4; ++corner_index) {
+      for (size_t i = 0; i < 2; ++i) {
+        corner.face_indices[i] = neighbor_face_index(axis_face_index, corner_index + i);
+      }
+      corner_cycle.indices[corner_index] = corner_sticker_index(rotated_corner(corner, cycle_index));
+    }
+    apply_sticker_4cycle(stickers, corner_cycle, direction);
+  }
+}
+
+void rotate_skewb_state(const face_index_t axis_face_index, direction_t direction, SkewbStateData* const skewb_state) {
+  direction = CROP_MOD(direction, 4);
+  if (direction == 0) {
+    return;
+  }
+  apply_center_rotation(skewb_state->stickers, axis_face_index, direction);
+  apply_corner_rotations(skewb_state->stickers, axis_face_index, direction);
+  apply_corner_rotations(skewb_state->stickers, opposite_face_index(axis_face_index), invert_cube_direction(direction));
+}
+
+static VALUE SkewbState_face_solved(const VALUE self, const VALUE face_symbol) {
+  const SkewbStateData* data;
+  GetSkewbStateData(self, data);
+  const face_index_t solved_face_index = face_index(face_symbol);
+  const size_t center_index = center_sticker_index(solved_face_index);
+  const VALUE color = data->stickers[center_index];
+  for (int i = 1; i < 5; ++i) {
+    if (!color_eq(data->stickers[center_index + i], color)) {
+      return Qfalse;
+    }
+  }
+  return Qtrue;
+}
+
+void init_skewb_state_class_under(const VALUE module) {
+  SkewbStateClass = rb_define_class_under(module, "SkewbState", rb_cObject);
+  rb_define_alloc_func(SkewbStateClass, SkewbState_alloc);
+  rb_define_method(SkewbStateClass, "initialize", SkewbState_initialize, 1);
+  rb_define_method(SkewbStateClass, "hash", SkewbState_hash, 0);
+  rb_define_method(SkewbStateClass, "eql?", SkewbState_eql, 1);
+  rb_define_alias(SkewbStateClass, "==", "eql?");
+  rb_define_method(SkewbStateClass, "dup", SkewbState_dup, 0);
+  rb_define_method(SkewbStateClass, "[]", SkewbState_entry, 1);
+  rb_define_method(SkewbStateClass, "[]=", SkewbState_store, 2);
+  rb_define_method(SkewbStateClass, "face_solved?", SkewbState_face_solved, 1);
+}

data/ext/twisty_puzzles/native/skewb_state.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <ruby.h>
+
+#include "skewb_coordinate.h"
+#include "utils.h"
+
+typedef struct {
+  VALUE stickers[total_skewb_stickers];
+} SkewbStateData;
+
+extern const rb_data_type_t SkewbStateData_type;
+
+#define GetSkewbStateData(obj, data)            \
+  do { \
+    TypedData_Get_Struct((obj), SkewbStateData, &SkewbStateData_type, (data)); \
+  } while (0)
+
+void rotate_corner_for_skewb_state(Corner corner, direction_t direction, SkewbStateData* skewb_state);
+
+void rotate_skewb_state(face_index_t axis_face_index, direction_t direction, SkewbStateData* skewb_state);
+
+void init_skewb_state_class_under(VALUE module);

data/ext/twisty_puzzles/native/utils.c

@@ -0,0 +1,76 @@
+#include "utils.h"
+
+static void swap(VALUE* const stickers, size_t i, size_t j) {
+  VALUE buffer;
+  buffer = stickers[i];
+  stickers[i] = stickers[j];
+  stickers[j] = buffer;
+}
+
+direction_t invert_cube_direction(direction_t direction) {
+  return (4 - direction) % 4;
+}
+
+direction_t invert_skewb_direction(direction_t direction) {
+  return (3 - direction) % 3;
+}
+
+void apply_sticker_cycle(VALUE* const stickers, const size_t* const indices, const size_t size, const bool invert) {
+  const size_t direction = invert ? size - 1 : 1;
+  const size_t last_index = (direction * (size - 1)) % size;
+  const VALUE buffer = stickers[indices[last_index]];
+  for (size_t i = size - 1; i >= 1; --i) {
+    const size_t target_index = (direction * i) % size;
+    const size_t source_index = (direction * (i - 1)) % size;
+    stickers[indices[target_index]] = stickers[indices[source_index]];
+  }
+  stickers[indices[0]] = buffer;
+}
+
+void apply_sticker_4cycle(VALUE* const stickers, const Sticker4Cycle cycle, const direction_t direction) {
+  const direction_t d = (direction % 4 + 4) % 4;
+  if (d == 0) {
+    return;
+  } else if (d == 2) {
+    swap(stickers, cycle.indices[0], cycle.indices[2]);
+    swap(stickers, cycle.indices[1], cycle.indices[3]);
+  } else {
+    apply_sticker_cycle(stickers, cycle.indices, 4, d == 3);
+  }
+}
+
+int color_eq(const VALUE left, const VALUE right) {
+  return RTEST(rb_equal(left, right));
+}
+
+// Magic table of values that we use for computing the log2.
+static const int tab64[64] = {
+    63,  0, 58,  1, 59, 47, 53,  2,
+    60, 39, 48, 27, 54, 33, 42,  3,
+    61, 51, 37, 40, 49, 18, 28, 20,
+    55, 30, 34, 11, 43, 14, 22,  4,
+    62, 57, 46, 52, 38, 26, 32, 41,
+    50, 36, 17, 19, 29, 10, 13, 21,
+    56, 45, 25, 31, 35, 16,  9, 12,
+    44, 24, 15,  8, 23,  7,  6,  5};
+
+int log2_64_floor(uint64_t value) {
+    value |= value >> 1;
+    value |= value >> 2;
+    value |= value >> 4;
+    value |= value >> 8;
+    value |= value >> 16;
+    value |= value >> 32;
+    return tab64[((uint64_t)((value - (value >> 1))*0x07EDD5E59A4E28C2)) >> 58];
+}
+
+uint64_t iexp(const uint64_t base, uint32_t exp) {
+  uint64_t result = 1;
+  for (uint32_t m = 1 << 31; m; m >>= 1) {
+    result = result * result;
+    if (m & exp) {
+      result *= base;
+    }
+  }
+  return result;
+}

data/ext/twisty_puzzles/native/utils.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <ruby.h>
+#include <stdint.h>
+
+#define MIN(a, b) ((a) > (b) ? (b) : (a))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define CROP_MOD(a, b) (((a) % (b) + (b)) % (b))
+
+typedef char direction_t;
+
+typedef struct {
+  size_t indices[4];
+} Sticker4Cycle;
+
+direction_t invert_cube_direction(direction_t direction);
+
+direction_t invert_skewb_direction(direction_t direction);
+
+void apply_sticker_cycle(VALUE* stickers, const size_t* indices, size_t size, bool invert);
+
+void apply_sticker_4cycle(VALUE* stickers, Sticker4Cycle cycle, direction_t direction);
+
+int color_eq(VALUE left, VALUE right);
+
+int log2_64_floor(uint64_t value);
+
+uint64_t iexp(uint64_t base, uint32_t exp);

data/lib/twisty_puzzles.rb

@@ -22,6 +22,7 @@ require 'twisty_puzzles/cube_print_helper'
 require 'twisty_puzzles/cube_state'
 require 'twisty_puzzles/letter_scheme'
 require 'twisty_puzzles/move_type_creator'
+require 'twisty_puzzles/native'
 require 'twisty_puzzles/parser'
 require 'twisty_puzzles/part_cycle_factory'
 require 'twisty_puzzles/puzzle'

data/lib/twisty_puzzles/abstract_move.rb

@@ -150,8 +150,7 @@ module TwistyPuzzles
       when :qtm then slice_factor * direction_factor
       when :htm then slice_factor
       when :stm then 1
-      when :qstm then direction_factor
-      when :sqtm then direction_factor
+      when :qstm, :sqtm then direction_factor
       else raise ArgumentError, "Invalid move metric #{metric.inspect}."
       end
     end

data/lib/twisty_puzzles/abstract_move_parser.rb

@@ -20,7 +20,7 @@ module TwistyPuzzles
     end
 
     def parse_named_captures(match)
-      present_named_captures = match.named_captures.reject { |_n, v| v.nil? }
+      present_named_captures = match.named_captures.compact
       present_named_captures.map do |name, string|
         key = parse_part_key(name).to_sym
         value = parse_move_part(name, string)

data/lib/twisty_puzzles/algorithm.rb

@@ -128,7 +128,7 @@ module TwistyPuzzles
       AbstractMove.check_move_metric(metric)
       return 0 if empty?
 
-      @moves.map { |m| m.move_count(cube_size, metric) }.reduce(:+)
+      @moves.sum { |m| m.move_count(cube_size, metric) }
     end
 
     def *(other)

data/lib/twisty_puzzles/axis_face_and_direction_move.rb

@@ -11,6 +11,7 @@ module TwistyPuzzles
       raise TypeError, "Unsuitable axis face #{axis_face}." unless axis_face.is_a?(Face)
       raise TypeError unless direction.is_a?(CubeDirection)
 
+      super()
       @axis_face = axis_face
       @direction = direction
     end

data/lib/twisty_puzzles/cancellation_helper.rb

@@ -135,7 +135,7 @@ module TwistyPuzzles
     def self.alg_plus_cancelled_move(algorithm, move, cube_size)
       if move.is_a?(Rotation) && (tail_rotations = num_tail_rotations(algorithm)) >= 2
         Algorithm.new(algorithm.moves[0...-tail_rotations]) +
-          cancelled_rotations(algorithm.moves[-tail_rotations..-1] + [move])
+          cancelled_rotations(algorithm.moves[-tail_rotations..] + [move])
       else
         Algorithm.new(algorithm.moves[0...-1]) +
           algorithm.moves[-1].join_with_cancellation(move, cube_size)

data/lib/twisty_puzzles/color_scheme.rb

@@ -56,7 +56,7 @@ module TwistyPuzzles
       raise ArgumentError unless colors.include?(top_color)
       raise ArgumentError unless colors.include?(front_color)
 
-      # Note: The reason that this is so complicated is that we want it to still work if the
+      # NOTE: The reason that this is so complicated is that we want it to still work if the
       # chirality corner gets exchanged.
 
       # Do the obvious and handle opposites of the top and front color so we have no

data/lib/twisty_puzzles/commutator.rb

@@ -17,6 +17,7 @@ module TwistyPuzzles
     def initialize(algorithm)
       raise ArgumentError unless algorithm.is_a?(Algorithm)
 
+      super()
       @algorithm = algorithm
     end
 
@@ -47,6 +48,7 @@ module TwistyPuzzles
       raise ArgumentError unless first_part.is_a?(Algorithm)
       raise ArgumentError unless second_part.is_a?(Algorithm)
 
+      super()
       @first_part = first_part
       @second_part = second_part
     end
@@ -85,6 +87,7 @@ module TwistyPuzzles
         raise ArgumentError, 'Inner commutator has to be a commutator.'
       end
 
+      super()
       @setup = setup
       @inner_commutator = inner_commutator
     end

data/lib/twisty_puzzles/compiled_algorithm.rb

@@ -26,10 +26,10 @@ module TwistyPuzzles
     def inverse
       @inverse ||=
         begin
-                              alg = self.class.new(@native.inverse)
-                              alg.inverse = self
-                              alg
-                            end
+          alg = self.class.new(@native.inverse)
+          alg.inverse = self
+          alg
+        end
     end
 
     def +(other)