twisty_puzzles 0.0.15 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5631e9c30819f3520d04ed81aa9b1ceebbee7a3da5c3b51bf2a81947f8fb3a1
-  data.tar.gz: fc4769b6c1ebab5d14cb64ddb3e39356a408750d1d0c7954d4929156296b9f9e
+  metadata.gz: b520c95ebe0051fb847be3781d6f82a6b2f41f00e006e3935157d8c6c3843726
+  data.tar.gz: 8cfb1439b07cf4983d17198952d56ae4b903afa994c67c549ea210063bc42eb9
 SHA512:
-  metadata.gz: c941aaef4dbf2bc8d580d712d669042061c20670aadcf2ee353f353eae4eb31713de9d4791f6d8126e4427ef9e7125562e26b53c85f0a92e09bfe120e8f24f04
-  data.tar.gz: 5e943e567b069fd2b2e21c77fdc7a48ad3e81fb365832439cd1f402da838b5771bc7af4b2293bf635fa1b6de158ddfbea78f9981e690ce3e72a6149c6b042bd2
+  metadata.gz: b841bc0e3f1de064c2bee48eaf041528abeec5b3751486b380933ead4633ea78430445793351bf3a80eff1da9d2b535ecea6dd63ace544c18f0a456b5fd348fe
+  data.tar.gz: 8732d36c49fc52b9292401b82b1b795f6f00994bb0ab80d2cbb029555af383fd20769cb083bb7d2af3348d7fda7811d76b693764f30699a79d239bde2cf93151

data/ext/twisty_puzzles/native/native.c

@@ -9,6 +9,7 @@
 #include "skewb_coordinate.h"
 #include "skewb_layer_fingerprint.h"
 #include "skewb_state.h"
+#include "sticker_cycle.h"
 
 VALUE TwistyPuzzlesModule = Qnil;
 VALUE NativeModule = Qnil;
@@ -25,4 +26,5 @@ void Init_native() {
   init_skewb_coordinate_class_under(NativeModule);
   init_skewb_layer_fingerprint_method_under(NativeModule);
   init_skewb_state_class_under(NativeModule);
+  init_sticker_cycle_class_under(NativeModule);
 }

data/ext/twisty_puzzles/native/sticker_cycle.c

@@ -0,0 +1,196 @@
+#include "cube_state.h"
+
+#include "cube_coordinate.h"
+#include "cube_state.h"
+#include "utils.h"
+
+static ID reverse;
+
+typedef struct {
+  long cube_size;
+  size_t length;
+  VALUE coordinates;
+  size_t* indices;
+} StickerCycleData;
+
+extern const rb_data_type_t StickerCycleData_type;
+
+#define GetStickerCycleData(obj, data) \
+  do { \
+    TypedData_Get_Struct((obj), StickerCycleData, &StickerCycleData_type, (data)); \
+  } while (0)
+
+#define GetInitializedStickerCycleData(obj, data)  \
+  do { \
+    GetStickerCycleData((obj), (data)); \
+    if (data->indices == NULL) { \
+      rb_raise(rb_eArgError, "Sticker cycle isn't initialized."); \
+    } \
+  } while(0)
+
+static VALUE StickerCycleClass = Qnil;
+
+static void StickerCycleData_mark(void* const ptr) {
+  const StickerCycleData* data = ptr;
+  rb_gc_mark(data->coordinates);
+}
+
+static void StickerCycleData_free(void* const ptr) {
+  const StickerCycleData* const data = ptr;
+  free(data->indices);
+  free(ptr);
+}
+
+static size_t StickerCycleData_size(const void* const ptr) {
+  const StickerCycleData* const data = ptr;
+  return sizeof(StickerCycleData) + num_stickers(data->cube_size) * sizeof(VALUE);
+}
+
+const rb_data_type_t StickerCycleData_type = {
+  "TwistyPuzzles::Native::StickerCycleData",
+  {StickerCycleData_mark, StickerCycleData_free, StickerCycleData_size, NULL},
+  NULL, NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY  
+};
+
+static VALUE* malloc_indices(const size_t n) {
+  VALUE* const indices = malloc(n * sizeof(size_t));
+  if (indices == NULL) {
+    rb_raise(rb_eNoMemError, "Allocating sticker cycle failed.");
+  }
+  return indices;
+}
+
+static VALUE StickerCycle_alloc(const VALUE klass) {
+  StickerCycleData* data;
+  const VALUE object = TypedData_Make_Struct(klass, StickerCycleData, &StickerCycleData_type, data);
+  data->cube_size = 0;
+  data->length = 0;
+  data->coordinates = Qnil;
+  data->indices = NULL;
+  return object;
+}
+
+static VALUE StickerCycle_initialize(const VALUE self, const VALUE cube_size, const VALUE coordinates) {
+  Check_Type(cube_size, T_FIXNUM);
+  Check_Type(coordinates, T_ARRAY);
+  const long checked_cube_size = FIX2INT(cube_size);
+  check_cube_size(checked_cube_size);
+  const size_t n = RARRAY_LEN(coordinates);
+  StickerCycleData* data;
+  GetStickerCycleData(self, data);
+  data->cube_size = checked_cube_size;
+  data->length = n;
+  data->coordinates = coordinates;
+  data->indices = malloc_indices(data->length);
+  for (size_t i = 0; i < n; ++i) {
+    const VALUE coordinate = rb_ary_entry(coordinates, i);
+    data->indices[i] = CubeCoordinate_sticker_index(coordinate, checked_cube_size);
+  }
+  return self;
+}
+
+static VALUE StickerCycle_apply_to(const VALUE self, const VALUE cube_state) {
+  const StickerCycleData* sticker_cycle_data;
+  GetInitializedStickerCycleData(self, sticker_cycle_data);
+
+  const CubeStateData* cube_state_data;
+  GetInitializedCubeStateData(cube_state, cube_state_data);
+
+  if (cube_state_data->cube_size != sticker_cycle_data->cube_size) {
+    rb_raise(rb_eArgError, "Cube size of sticker cycle must equal cube size of cube state. Got %ld vs %ld.", sticker_cycle_data->cube_size, cube_state_data->cube_size);
+  }
+  if (sticker_cycle_data->length >= 2) {
+    apply_sticker_cycle(cube_state_data->stickers, sticker_cycle_data->indices, sticker_cycle_data->length, false);
+  }
+  return Qnil;
+}
+
+static VALUE StickerCycle_hash(const VALUE self) {
+  const StickerCycleData* data;
+  GetInitializedStickerCycleData(self, data);
+
+  st_index_t hash = rb_hash_start((st_index_t)StickerCycle_hash);
+  hash = rb_hash_uint(hash, data->length);
+  hash = rb_hash_uint(hash, data->cube_size);
+  const size_t n = data->length;
+  for (size_t i = 0; i < n; ++i) {
+    hash = rb_hash_uint(hash, data->indices[i]);
+  }
+  return ST2FIX(rb_hash_end(hash));
+}
+
+static VALUE StickerCycle_eql(const VALUE self, const VALUE other) {
+  if (self == other) {
+    return Qtrue;
+  }
+  if (rb_obj_class(self) != rb_obj_class(other)) {
+    return Qfalse;
+  }
+  const StickerCycleData* self_data;
+  GetInitializedStickerCycleData(self, self_data);
+  const StickerCycleData* other_data;
+  GetInitializedStickerCycleData(other, other_data);
+  if (self_data->cube_size != other_data->cube_size) {
+    return Qfalse;
+  }
+  if (self_data->length != other_data->length) {
+    return Qfalse;
+  }
+  const size_t n = self_data->length;
+  for (size_t i = 0; i < n; ++i) {
+    if (self_data->indices[i] != other_data->indices[i]) {
+      return Qfalse;
+    }
+  }
+  return Qtrue;
+}
+
+static VALUE StickerCycle_cube_size(const VALUE self) {
+  const StickerCycleData* data;
+  GetInitializedStickerCycleData(self, data);
+  return ST2FIX(data->cube_size);
+}
+
+static VALUE StickerCycle_length(const VALUE self) {
+  const StickerCycleData* data;
+  GetInitializedStickerCycleData(self, data);
+  return ST2FIX(data->length);
+}
+
+static VALUE StickerCycle_coordinates(const VALUE self) {
+  const StickerCycleData* data;
+  GetInitializedStickerCycleData(self, data);
+  return data->coordinates;
+}
+
+static VALUE StickerCycle_inverse(const VALUE self) {
+  const StickerCycleData* data;
+  GetInitializedStickerCycleData(self, data);
+  const long n = data->length;
+  StickerCycleData* inverse_data;
+  const VALUE inverse = TypedData_Make_Struct(rb_obj_class(self), StickerCycleData, &StickerCycleData_type, inverse_data);
+  inverse_data->cube_size = data->cube_size;
+  inverse_data->length = n;
+  inverse_data->indices = malloc_indices(n);
+  inverse_data->coordinates = rb_funcall(data->coordinates, reverse, 0);
+  for (int i = 0; i < n; ++i) {
+    inverse_data->indices[i] = data->indices[n - 1 - i];
+  }
+  return inverse;
+}
+
+void init_sticker_cycle_class_under(const VALUE module) {
+  reverse = rb_intern("reverse");
+  StickerCycleClass = rb_define_class_under(module, "StickerCycle", rb_cObject);
+  rb_define_alloc_func(StickerCycleClass, StickerCycle_alloc);
+  rb_define_method(StickerCycleClass, "initialize", StickerCycle_initialize, 2);
+  rb_define_method(StickerCycleClass, "apply_to", StickerCycle_apply_to, 1);
+  rb_define_method(StickerCycleClass, "hash", StickerCycle_hash, 0);
+  rb_define_method(StickerCycleClass, "eql?", StickerCycle_eql, 1);
+  rb_define_alias(StickerCycleClass, "==", "eql?");
+  rb_define_method(StickerCycleClass, "cube_size", StickerCycle_cube_size, 0);
+  rb_define_method(StickerCycleClass, "length", StickerCycle_length, 0);
+  rb_define_method(StickerCycleClass, "coordinates", StickerCycle_coordinates, 0);
+  rb_define_method(StickerCycleClass, "inverse", StickerCycle_inverse, 0);
+}

data/ext/twisty_puzzles/native/sticker_cycle.h

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

data/lib/twisty_puzzles/abstract_direction.rb

@@ -4,7 +4,7 @@ module TwistyPuzzles
   # Base class for directions.
   class AbstractDirection
     include Comparable
-    POSSIBLE_DIRECTION_NAMES = [[''], ['2', '2\''], ['\'', '3']].freeze
+    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

data/lib/twisty_puzzles/color_scheme.rb

@@ -28,6 +28,16 @@ module TwistyPuzzles
       @colors_to_face_symbols = face_symbols_to_colors.invert
     end
 
+    def eql?(other)
+      self.class.equal?(other.class) && colors == other.colors
+    end
+
+    alias == eql?
+
+    def hash
+      @hash ||= ([self.class] + colors).hash
+    end
+
     def color(face_symbol)
       @face_symbols_to_colors[face_symbol]
     end

data/lib/twisty_puzzles/cube_state.rb

@@ -4,7 +4,6 @@ require 'twisty_puzzles/cube'
 require 'twisty_puzzles/cube_constants'
 require 'twisty_puzzles/coordinate'
 require 'twisty_puzzles/cube_print_helper'
-require 'twisty_puzzles/state_helper'
 require 'twisty_puzzles/utils/array_helper'
 require 'twisty_puzzles/native'
 
@@ -13,7 +12,6 @@ module TwistyPuzzles
   class CubeState
     include Utils::ArrayHelper
     include CubePrintHelper
-    include StateHelper
     include CubeConstants
 
     def self.check_cube_size(cube_size)
@@ -75,6 +73,10 @@ module TwistyPuzzles
 
     alias == eql?
 
+    def hash
+      @hash ||= [self.class, @native].hash
+    end
+
     def rotation_algorithms
       Rotation::ALL_ROTATIONS.combination(2).reject do |r0, r1|
         r0.inverse == r1
@@ -85,10 +87,6 @@ module TwistyPuzzles
       rotation_algorithms.any? { |r| r.apply_temporarily_to(self) { |state| state == other } }
     end
 
-    def hash
-      @hash ||= [self.class, @native].hash
-    end
-
     # TODO: Get rid of this backwards compatibility artifact
     def sticker_array(face)
       raise TypeError unless face.is_a?(Face)

data/lib/twisty_puzzles/parser.rb

@@ -95,6 +95,8 @@ module TwistyPuzzles # rubocop:disable Style/Documentation
       while (m = begin skip_spaces; parse_move_internal end)
         moves.push(m)
       end
+      skip_spaces
+      moves *= parse_multiplier if @scanner.peek(1) == TIMES
       Algorithm.new(moves)
     end
 

data/lib/twisty_puzzles/part_cycle.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/utils/array_helper'
+require 'twisty_puzzles/sticker_cycle_factory'
+require 'twisty_puzzles/cube'
+
+module TwistyPuzzles
+  # A cycle of parts of the cube, e.g. a corner 3 cycle.
+  # Note that this is abstract and contains no information on the cube size.
+  # E.g. for wings on a 7x7, it's not clear whether inner or outer wings are used.
+  # Check StickerCycleFactory for making it concrete and applyable.
+  class PartCycle
+    include Utils::ArrayHelper
+
+    def initialize(parts)
+      check_types(parts, Part)
+      check_type_consistency(parts)
+
+      @parts = parts
+    end
+
+    attr_reader :parts
+
+    def eql?(other)
+      self.class.equal?(other.class) && @parts == other.parts
+    end
+
+    alias == eql?
+
+    def hash
+      @hash ||= ([self.class] + @parts).hash
+    end
+
+    def check_type_consistency(parts)
+      return unless parts.any? { |p| p.class != parts.first.class }
+
+      raise TypeError, "Cycles of heterogenous piece types #{parts.inspect} are not supported."
+    end
+  end
+end

data/lib/twisty_puzzles/rotation.rb

@@ -22,6 +22,7 @@ module TwistyPuzzles
       when SkewbDirection::ZERO then CubeDirection::ZERO
       when SkewbDirection::FORWARD then CubeDirection::FORWARD
       when SkewbDirection::BACKWARD then CubeDirection::BACKWARD
+      else raise
       end
     end
 

data/lib/twisty_puzzles/skewb_state.rb

@@ -3,14 +3,12 @@
 require 'twisty_puzzles/coordinate'
 require 'twisty_puzzles/cube'
 require 'twisty_puzzles/cube_print_helper'
-require 'twisty_puzzles/state_helper'
 require 'twisty_puzzles/cube_constants'
 
 module TwistyPuzzles
   # Represents the state (i.e. the sticker positions) of a Skewb.
   class SkewbState
     include CubePrintHelper
-    include StateHelper
     include CubeConstants
     # Pairs of coordinate pairs that should match in case of solved layers.
     MATCHING_CORNERS =
@@ -151,14 +149,5 @@ module TwistyPuzzles
 
       layer_check_neighbors(face).map { |c| self[c] }.uniq.length == 1
     end
-
-    def rotate_face(face, direction)
-      neighbors = face.neighbors
-      inverse_order_face = face.coordinate_index_close_to(neighbors[0]) <
-                           face.coordinate_index_close_to(neighbors[1])
-      direction = direction.inverse if inverse_order_face
-      cycle = SkewbCoordinate.corners_on_face(face)
-      apply_4sticker_cycle(cycle, direction)
-    end
   end
 end

data/lib/twisty_puzzles/sticker_cycle.rb

@@ -10,22 +10,47 @@ module TwistyPuzzles
   class StickerCycle
     include ReversibleApplyable
 
-    def initialize(cube_size, sticker_cycle)
-      @cube_size = cube_size
-      @sticker_cycle = sticker_cycle
+    def self.from_coordinates(cube_size, coordinates)
+      CubeState.check_cube_size(cube_size)
+      raise TypeError unless coordinates.all?(Coordinate)
+
+      new(Native::StickerCycle.new(cube_size, coordinates.map(&:native)))
+    end
+
+    def initialize(native)
+      raise TypeError unless native.is_a?(Native::StickerCycle)
+
+      @native = native
+    end
+
+    attr_reader :native
+
+    def eql?(other)
+      self.class.equal?(other.class) && @native == other.native
     end
 
-    attr_reader :cube_size, :sticker_cycle
+    alias == eql?
+
+    def hash
+      @hash ||= [self.class, @native].hash
+    end
+
+    def cube_size
+      @native.cube_size
+    end
+
+    def length
+      @native.length
+    end
 
     def apply_to(cube_state)
       raise TypeError unless cube_state.is_a?(CubeState)
-      raise ArgumentError unless cube_state.n == @cube_size
 
-      cube_state.apply_sticker_cycle(@sticker_cycle) if @sticker_cycle.length >= 2
+      @native.apply_to(cube_state.native)
     end
 
     def inverse
-      StickerCycle.new(@cube_size, @sticker_cycle.reverse)
+      StickerCycle.new(@native.inverse)
     end
   end
 
@@ -38,7 +63,7 @@ module TwistyPuzzles
       sticker_cycles.each do |c|
         raise TypeError unless c.is_a?(StickerCycle)
 
-        c.sticker_cycle.each do |s|
+        c.native.coordinates.each do |s|
           raise ArgumentError unless affected_set.add?(s)
         end
       end

data/lib/twisty_puzzles/{part_cycle_factory.rb → sticker_cycle_factory.rb}

@@ -2,10 +2,11 @@
 
 require 'twisty_puzzles/sticker_cycle'
 require 'twisty_puzzles/utils/array_helper'
+require 'twisty_puzzles/cube'
 
 module TwistyPuzzles
   # Factory for sticker cycles given part cycles.
-  class PartCycleFactory
+  class StickerCycleFactory
     include Utils::ArrayHelper
 
     def initialize(cube_size, incarnation_index)
@@ -28,7 +29,7 @@ module TwistyPuzzles
         raise TypeError, 'Twists are only supported for edges and corners.'
       end
 
-      cycles = parts.map { |p| StickerCycle.new(@cube_size, coordinates(p)) }
+      cycles = parts.map { |p| StickerCycle.from_coordinates(@cube_size, coordinates(p)) }
       StickerCycles.new(@cube_size, cycles)
     end
 
@@ -49,7 +50,7 @@ module TwistyPuzzles
       check_types(parts, Part)
       check_type_consistency(parts)
       part_coordinates = parts.map { |p| coordinates(p) }
-      cycles = part_coordinates.transpose.map { |c| StickerCycle.new(@cube_size, c) }
+      cycles = part_coordinates.transpose.map { |c| StickerCycle.from_coordinates(@cube_size, c) }
       StickerCycles.new(@cube_size, cycles)
     end
   end

data/lib/twisty_puzzles/version.rb

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

data/lib/twisty_puzzles.rb

@@ -24,7 +24,7 @@ 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/part_cycle'
 require 'twisty_puzzles/puzzle'
 require 'twisty_puzzles/reversible_applyable'
 require 'twisty_puzzles/rotation'
@@ -33,8 +33,8 @@ 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/sticker_cycle_factory'
 require 'twisty_puzzles/twisty_puzzles_error'
 require 'twisty_puzzles/version'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twisty_puzzles
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.20
 platform: ruby
 authors:
 - Bernhard F. Brodowsky
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-01 00:00:00.000000000 Z
+date: 2021-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -196,6 +196,8 @@ files:
 - ext/twisty_puzzles/native/skewb_layer_fingerprint.h
 - ext/twisty_puzzles/native/skewb_state.c
 - ext/twisty_puzzles/native/skewb_state.h
+- ext/twisty_puzzles/native/sticker_cycle.c
+- ext/twisty_puzzles/native/sticker_cycle.h
 - ext/twisty_puzzles/native/utils.c
 - ext/twisty_puzzles/native/utils.h
 - lib/twisty_puzzles.rb
@@ -222,7 +224,7 @@ files:
 - lib/twisty_puzzles/letter_scheme.rb
 - lib/twisty_puzzles/move_type_creator.rb
 - lib/twisty_puzzles/parser.rb
-- lib/twisty_puzzles/part_cycle_factory.rb
+- lib/twisty_puzzles/part_cycle.rb
 - lib/twisty_puzzles/puzzle.rb
 - lib/twisty_puzzles/reversible_applyable.rb
 - lib/twisty_puzzles/rotation.rb
@@ -231,8 +233,8 @@ files:
 - lib/twisty_puzzles/skewb_move_parser.rb
 - lib/twisty_puzzles/skewb_notation.rb
 - lib/twisty_puzzles/skewb_state.rb
-- lib/twisty_puzzles/state_helper.rb
 - lib/twisty_puzzles/sticker_cycle.rb
+- lib/twisty_puzzles/sticker_cycle_factory.rb
 - lib/twisty_puzzles/twisty_puzzles_error.rb
 - lib/twisty_puzzles/utils.rb
 - lib/twisty_puzzles/utils/array_helper.rb
@@ -260,7 +262,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Gem for my cube_trainer rails app. Some things are better left in a separate

data/lib/twisty_puzzles/state_helper.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'twisty_puzzles/abstract_direction'
-
-module TwistyPuzzles
-  # Common utilities for different puzzle states.
-  # TODO: Remove
-  module StateHelper
-    def apply_sticker_cycle(cycle)
-      last_sticker = self[cycle[-1]]
-      (cycle.length - 1).downto(1) do |i|
-        self[cycle[i]] = self[cycle[i - 1]]
-      end
-      self[cycle[0]] = last_sticker
-    end
-
-    def apply_4sticker_cycle(cycle, direction)
-      raise ArgumentError unless cycle.length == 4
-      raise TypeError unless direction.is_a?(AbstractDirection)
-
-      if direction.double_move?
-        apply_sticker_cycle([cycle[0], cycle[2]])
-        apply_sticker_cycle([cycle[1], cycle[3]])
-      else
-        # Note that we cannot do reverse! because the values are cached.
-        actual_cycle = direction.value == 3 ? cycle.reverse : cycle
-        apply_sticker_cycle(actual_cycle)
-      end
-    end
-  end
-end