twisty_puzzles 0.0.1 → 0.0.6

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,31 @@
+#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 FALSE 0
+#define TRUE 1
+#define CROP_MOD(a, b) (((a) % (b) + (b)) % (b))
+
+typedef char bool;
+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

@@ -1,5 +1,43 @@
 # frozen_string_literal: true
 
+require 'twisty_puzzles/abstract_direction'
+require 'twisty_puzzles/abstract_move'
+require 'twisty_puzzles/abstract_move_parser'
+require 'twisty_puzzles/algorithm'
+require 'twisty_puzzles/algorithm_transformation'
+require 'twisty_puzzles/axis_face_and_direction_move'
+require 'twisty_puzzles/cancellation_helper'
+require 'twisty_puzzles/color_scheme'
+require 'twisty_puzzles/commutator'
+require 'twisty_puzzles/compiled_algorithm'
+require 'twisty_puzzles/compiled_cube_algorithm'
+require 'twisty_puzzles/compiled_skewb_algorithm'
+require 'twisty_puzzles/coordinate'
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/cube_constants'
+require 'twisty_puzzles/cube_direction'
+require 'twisty_puzzles/cube_move'
+require 'twisty_puzzles/cube_move_parser'
+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'
+require 'twisty_puzzles/reversible_applyable'
+require 'twisty_puzzles/rotation'
+require 'twisty_puzzles/skewb_direction'
+require 'twisty_puzzles/skewb_move'
+require 'twisty_puzzles/skewb_move_parser'
+require 'twisty_puzzles/skewb_notation'
+require 'twisty_puzzles/skewb_state'
+require 'twisty_puzzles/state_helper'
+require 'twisty_puzzles/sticker_cycle'
+require 'twisty_puzzles/twisty_puzzles_error'
+require 'twisty_puzzles/version'
+
 # Libraries for the twisty puzzles.
 module TwistyPuzzles
 end

data/lib/twisty_puzzles/abstract_direction.rb

@@ -1,54 +1,53 @@
 # frozen_string_literal: true
 
 module TwistyPuzzles
-  
-    # Base class for directions.
-    class AbstractDirection
-      include Comparable
-      POSSIBLE_DIRECTION_NAMES = [[''], ['2', '2\''], ['\'', '3']].freeze
-      SIMPLE_DIRECTION_NAMES = (['0'] + POSSIBLE_DIRECTION_NAMES.map(&:first)).freeze
-      POSSIBLE_SKEWB_DIRECTION_NAMES = [['', '2\''], ['\'', '2']].freeze
-      SIMPLE_SKEWB_DIRECTION_NAMES = (['0'] + POSSIBLE_SKEWB_DIRECTION_NAMES.map(&:first)).freeze
-
-      def initialize(value)
-        raise TypeError, "Direction value #{value} isn't an integer." unless value.is_a?(Integer)
-        unless value >= 0 && value < self.class::NUM_DIRECTIONS
-          raise ArgumentError, "Invalid direction value #{value}."
-        end
-
-        @value = value
+  # Base class for directions.
+  class AbstractDirection
+    include Comparable
+    POSSIBLE_DIRECTION_NAMES = [[''], ['2', '2\''], ['\'', '3']].freeze
+    SIMPLE_DIRECTION_NAMES = (['0'] + POSSIBLE_DIRECTION_NAMES.map(&:first)).freeze
+    POSSIBLE_SKEWB_DIRECTION_NAMES = [['', '2\''], ['\'', '2']].freeze
+    SIMPLE_SKEWB_DIRECTION_NAMES = (['0'] + POSSIBLE_SKEWB_DIRECTION_NAMES.map(&:first)).freeze
+
+    def initialize(value)
+      raise TypeError, "Direction value #{value} isn't an integer." unless value.is_a?(Integer)
+      unless value >= 0 && value < self.class::NUM_DIRECTIONS
+        raise ArgumentError, "Invalid direction value #{value}."
       end
 
-      attr_reader :value
+      @value = value
+    end
 
-      def <=>(other)
-        @value <=> other.value
-      end
+    attr_reader :value
 
-      def zero?
-        @value.zero?
-      end
+    def <=>(other)
+      @value <=> other.value
+    end
 
-      def non_zero?
-        @value.positive?
-      end
+    def zero?
+      @value.zero?
+    end
 
-      def inverse
-        self.class.new((self.class::NUM_DIRECTIONS - @value) % self.class::NUM_DIRECTIONS)
-      end
+    def non_zero?
+      @value.positive?
+    end
 
-      def +(other)
-        self.class.new((@value + other.value) % self.class::NUM_DIRECTIONS)
-      end
+    def inverse
+      self.class.new((self.class::NUM_DIRECTIONS - @value) % self.class::NUM_DIRECTIONS)
+    end
 
-      def eql?(other)
-        self.class.equal?(other.class) && @value == other.value
-      end
+    def +(other)
+      self.class.new((@value + other.value) % self.class::NUM_DIRECTIONS)
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) && @value == other.value
+    end
 
-      alias == eql?
+    alias == eql?
 
-      def hash
-        @value.hash
-      end
+    def hash
+      @value.hash
     end
+  end
 end