twisty_puzzles 0.0.17 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 440643127a42de2937ef3e1b0205f588a7d8624102dcf2596b3ff24050bf57ef
-  data.tar.gz: 8ef01a9cd10f729ed5bbb0f34a36fe75b5fcff2d8c9ee6cc64d4b7faa72e44a1
+  metadata.gz: 64f6766819367eee6807388d640a4302c3268bcf276a2b52fb4ca94ddbb0ebe2
+  data.tar.gz: 0d60796788d180feb10ad42fa74a6b7535092d5d4040a64375f959ac9a2023da
 SHA512:
-  metadata.gz: d247081d421f4b422293dc286e794cda52c04c9cb543d7ac62de8441f94117cbc028ecf7cff0a9c8100e57f1f7f87cfff0dfcfa8932e0fc60b7aa9409fd8d5df
-  data.tar.gz: ff1043f40ba14d3993268b4768ddfc3e8ffc7e84830c21f106a7a64d7b55a774c1120ef880e71feba101ba0f4c48b8ec920711c25a187f93b3412c27bb096002
+  metadata.gz: 36cb5bdc5b75cfcb7d0a832cbff120662426ab8dd1fd1120762c3231973f27b706059f6772193ca76403859a3768d847f9ee34fb4012c52deb19226862b8b38c
+  data.tar.gz: 8e6a49720c6219484741a6d5d3248917c02025def3c0eacac34b0de07529b7fe42802fd5473fb782a19ca34f7bbc7319b8ef4ee705bffd135240f9d12f6eb77c

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/color_scheme.rb

@@ -28,6 +28,17 @@ 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/part_cycle_factory.rb

@@ -28,7 +28,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 +49,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/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/version.rb

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

data/lib/twisty_puzzles.rb

@@ -33,7 +33,6 @@ 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'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twisty_puzzles
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.19
 platform: ruby
 authors:
 - Bernhard F. Brodowsky
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-01 00:00:00.000000000 Z
+date: 2021-11-08 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
@@ -231,7 +233,6 @@ 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/twisty_puzzles_error.rb
 - lib/twisty_puzzles/utils.rb
@@ -260,7 +261,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