twisty_puzzles 0.0.1

data/lib/twisty_puzzles/commutator.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'strscan'
+require 'twisty_puzzles/algorithm'
+require 'twisty_puzzles/cube'
+
+module TwistyPuzzles
+  
+    # Base class for Commutators.
+    class Commutator
+      def cancellations(other, cube_size, metric = :htm)
+        algorithm.cancellations(other.algorithm, cube_size, metric)
+      end
+    end
+
+    # Algorithm that is used like a commutator but actually isn't one.
+    class FakeCommutator < Commutator
+      def initialize(algorithm)
+        raise ArgumentError unless algorithm.is_a?(Algorithm)
+
+        @algorithm = algorithm
+      end
+
+      attr_reader :algorithm
+
+      def eql?(other)
+        self.class.equal?(other.class) && @algorithm == other.algorithm
+      end
+
+      alias == eql?
+
+      def hash
+        @hash ||= [self.class, @algorithm].hash
+      end
+
+      def inverse
+        FakeCommutator.new(@algorithm.inverse)
+      end
+
+      def to_s
+        @algorithm.to_s
+      end
+    end
+
+    # Pure commutator of the form A B A' B'.
+    class PureCommutator < Commutator
+      def initialize(first_part, second_part)
+        raise ArgumentError unless first_part.is_a?(Algorithm)
+        raise ArgumentError unless second_part.is_a?(Algorithm)
+
+        @first_part = first_part
+        @second_part = second_part
+      end
+
+      attr_reader :first_part, :second_part
+
+      def eql?(other)
+        self.class.equal?(other.class) && @first_part == other.first_part &&
+          @second_part == other.second_part
+      end
+
+      alias == eql?
+
+      def hash
+        @hash ||= [self.class, @first_part, @second_part].hash
+      end
+
+      def inverse
+        PureCommutator.new(second_part, first_part)
+      end
+
+      def to_s
+        "[#{@first_part}, #{@second_part}]"
+      end
+
+      def algorithm
+        first_part + second_part + first_part.inverse + second_part.inverse
+      end
+    end
+
+    # Setup commutator of the form A B A'.
+    class SetupCommutator < Commutator
+      def initialize(setup, inner_commutator)
+        raise ArgumentError, 'Setup move has to be an algorithm.' unless setup.is_a?(Algorithm)
+        unless inner_commutator.is_a?(Commutator)
+          raise ArgumentError, 'Inner commutator has to be a commutator.'
+        end
+
+        @setup = setup
+        @inner_commutator = inner_commutator
+      end
+
+      attr_reader :setup, :inner_commutator
+
+      def eql?(other)
+        self.class.equal?(other.class) && @setup == other.setup &&
+          @inner_commutator == other.inner_commutator
+      end
+
+      alias == eql?
+
+      def hash
+        @hash ||= [self.class, @setup, @inner_commutator].hash
+      end
+
+      def inverse
+        SetupCommutator.new(setup, @inner_commutator.inverse)
+      end
+
+      def to_s
+        "[#{@setup} : #{@inner_commutator}]"
+      end
+
+      def algorithm
+        setup + inner_commutator.algorithm + setup.inverse
+      end
+    end
+end

data/lib/twisty_puzzles/compiled_algorithm.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/reversible_applyable'
+
+module TwistyPuzzles
+  
+    # Base class for a compiled algorithm for a particular puzzle.
+    class CompiledAlgorithm
+      include ReversibleApplyable
+
+      def initialize(native)
+        raise TypeError unless native.is_a?(self.class::NATIVE_CLASS)
+
+        @native = native
+      end
+
+      attr_reader :native
+
+      def rotate_by(rotation)
+        self.class.new(@native.rotate_by(rotation.axis_face.face_symbol, rotation.direction.value))
+      end
+
+      def mirror(normal_face)
+        self.class.new(@native.mirror(normal_face.face_symbol))
+      end
+
+      def inverse
+        @inverse ||=
+          begin
+                                alg = self.class.new(@native.inverse)
+                                alg.inverse = self
+                                alg
+                              end
+      end
+
+      def +(other)
+        self.class.new(@native + other.native)
+      end
+
+      def apply_to(state)
+        @native.apply_to(state.native)
+      end
+
+      protected
+
+      attr_writer :inverse
+    end
+end

data/lib/twisty_puzzles/compiled_cube_algorithm.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/compiled_algorithm'
+
+module TwistyPuzzles
+  
+    # Wrapper of the native C implementation of a compiled algorithm for a particular cube size.
+    class CompiledCubeAlgorithm < CompiledAlgorithm
+      def self.transform_rotation(move, cube_size)
+        slice_moves =
+          0.upto(cube_size - 1).map do |i|
+            [:slice, move.axis_face.face_symbol, move.direction.value, i]
+          end
+        [
+          [:face, move.axis_face.face_symbol, move.direction.value],
+          [:face, move.axis_face.opposite.face_symbol, move.direction.inverse.value]
+        ] + slice_moves
+      end
+
+      def self.transform_fat_mslice_move(move, cube_size)
+        1.upto(cube_size - 2).map do |i|
+          [:slice, move.axis_face.face_symbol, move.direction.value, i]
+        end
+      end
+
+      def self.transform_slice_move(move)
+        [
+          [:slice, move.axis_face.face_symbol, move.direction.value, move.slice_index]
+        ]
+      end
+
+      def self.transform_fat_move(move)
+        slice_moves =
+          0.upto(move.width - 1).map do |i|
+            [:slice, move.axis_face.face_symbol, move.direction.value, i]
+          end
+        [
+          [:face, move.axis_face.face_symbol, move.direction.value]
+        ] + slice_moves
+      end
+
+      private_class_method :transform_rotation, :transform_fat_mslice_move, :transform_slice_move,
+                           :transform_fat_move
+
+      def self.transform_move(move, cube_size)
+        decided_move = move.decide_meaning(cube_size)
+        case decided_move
+        when Rotation then transform_rotation(decided_move, cube_size)
+        when FatMSliceMove then transform_fat_mslice_move(decided_move, cube_size)
+        # Note that this also covers InnerMSliceMove
+        when SliceMove then transform_slice_move(decided_move)
+        when FatMove then transform_fat_move(decided_move)
+        else
+          raise TypeError, "Invalid move type #{move.class} that becomes #{decided_move.class} "\
+                           "for cube size #{cube_size}."
+        end
+      end
+
+      def self.for_moves(cube_size, moves)
+        transformed_moves = moves.collect_concat { |m| transform_move(m, cube_size) }
+        native = Native::CubeAlgorithm.new(cube_size, transformed_moves)
+        new(native)
+      end
+
+      NATIVE_CLASS = Native::CubeAlgorithm
+    end
+end

data/lib/twisty_puzzles/compiled_skewb_algorithm.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/compiled_algorithm'
+
+module TwistyPuzzles
+  
+    # Wrapper of the native C implementation of a compiled algorithm for a particular cube size.
+    class CompiledSkewbAlgorithm < CompiledAlgorithm
+      def self.transform_move(move)
+        case move
+        when Rotation
+          [:rotation, move.axis_face.face_symbol, move.direction.value]
+        when SkewbMove
+          [:move, move.axis_corner.face_symbols, move.direction.value]
+        else
+          raise TypeError
+        end
+      end
+
+      def self.for_moves(moves)
+        native = Native::SkewbAlgorithm.new(moves.map { |m| transform_move(m) })
+        new(native)
+      end
+
+      NATIVE_CLASS = Native::SkewbAlgorithm
+      EMPTY = for_moves([])
+    end
+end

data/lib/twisty_puzzles/coordinate.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/cube_constants'
+require 'twisty_puzzles/native'
+
+module TwistyPuzzles
+  
+    # Coordinate of a sticker on the cube.
+    class Coordinate
+      def self.highest_coordinate(cube_size)
+        cube_size - 1
+      end
+
+      def self.invert_coordinate(index, cube_size)
+        highest_coordinate(cube_size) - index
+      end
+
+      def self.coordinate_range(cube_size)
+        0.upto(highest_coordinate(cube_size))
+      end
+
+      def self.middle(cube_size)
+        raise ArgumentError if cube_size.even?
+
+        cube_size / 2
+      end
+
+      # Middle coordinate for uneven numbers, the one before for even numbers
+      def self.middle_or_before(cube_size)
+        cube_size - cube_size / 2 - 1
+      end
+
+      # Middle coordinate for uneven numbers, the one after for even numbers
+      def self.middle_or_after(cube_size)
+        cube_size / 2
+      end
+
+      # The last coordinate that is strictly before the middle
+      def self.last_before_middle(cube_size)
+        cube_size / 2 - 1
+      end
+
+      def self.canonicalize(index, cube_size)
+        raise ArgumentError unless index.is_a?(Integer) && -cube_size <= index && index < cube_size
+
+        index >= 0 ? index : cube_size + index
+      end
+
+      def self.from_face_distances(face, cube_size, face_distances)
+        raise ArgumentError if face_distances.length != 2
+
+        coordinates = [nil, nil]
+        face_distances.each do |neighbor, distance|
+          index = face.coordinate_index_close_to(neighbor)
+          coordinate =
+            if neighbor.close_to_smaller_indices?
+              distance
+            else
+              invert_coordinate(distance, cube_size)
+            end
+          raise ArgumentError if coordinates[index]
+
+          coordinates[index] = coordinate
+        end
+        raise ArgumentError if coordinates.any?(&:nil?)
+
+        from_indices(face, cube_size, *coordinates)
+      end
+
+      def self.match_coordinate_internal(base_coordinate, other_face_symbols)
+        other_face_symbols.sort!
+        coordinate =
+          base_coordinate.rotations.find do |coord|
+            face_symbols_closeby = coord.close_neighbor_faces.map(&:face_symbol)
+            face_symbols_closeby.sort == other_face_symbols
+          end
+        raise "Couldn't find a fitting coordinate on the solved face." if coordinate.nil?
+
+        coordinate
+      end
+
+      # The coordinate of the solved position of the main sticker of this part.
+      def self.solved_position(part, cube_size, incarnation_index)
+        raise TypeError unless part.is_a?(Part)
+        raise unless part.class::ELEMENTS.length == 24
+        raise unless incarnation_index >= 0 && incarnation_index < part.num_incarnations(cube_size)
+
+        # This is a coordinate on the same face and belonging to an equivalent part.
+        # But it might not be the right one.
+        base_coordinate = Coordinate.from_indices(
+          part.solved_face, cube_size, *part.base_index_on_face(cube_size, incarnation_index)
+        )
+        other_face_symbols = part.corresponding_part.face_symbols[1..-1]
+        match_coordinate_internal(base_coordinate, other_face_symbols)
+      end
+
+      # The coordinate of the solved position of all stickers of this part.
+      # rubocop:disable Metrics/AbcSize
+      def self.solved_positions(part, cube_size, incarnation_index)
+        solved_coordinate = solved_position(part, cube_size, incarnation_index)
+        other_coordinates =
+          part.face_symbols[1..-1].map.with_index do |f, i|
+            face = Face.for_face_symbol(f)
+            # The reverse is important for edge like parts. We are not in the same position as usual
+            # solved pieces would be.
+            # For other types of pieces, it doesn't make a difference as the base index will just be
+            # a rotation of the original one, but we will anyway look at all rotations later.
+            base_indices = part.base_index_on_other_face(face, cube_size, incarnation_index).reverse
+            base_coordinate = Coordinate.from_indices(face, cube_size, *base_indices)
+            other_face_symbols = [part.face_symbols[0]] +
+                                 part.corresponding_part.face_symbols[1...i + 1] +
+                                 part.corresponding_part.face_symbols[i + 2..-1]
+            match_coordinate_internal(base_coordinate, other_face_symbols)
+          end
+        [solved_coordinate] + other_coordinates
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def self.center(face, cube_size)
+        m = middle(cube_size)
+        from_indices(face, cube_size, m, m)
+      end
+
+      def self.edges_outside(face, cube_size)
+        face.neighbors.zip(face.neighbors.rotate(1)).collect_concat do |neighbor, next_neighbor|
+          1.upto(cube_size - 2).map do |i|
+            from_face_distances(neighbor, cube_size, face => 0, next_neighbor => i)
+          end
+        end
+      end
+
+      def self.from_indices(face, cube_size, x_index, y_index)
+        raise TypeError, "Unsuitable face #{face.inspect}." unless face.is_a?(Face)
+        raise TypeError unless cube_size.is_a?(Integer)
+        raise ArgumentError unless cube_size.positive?
+
+        x = Coordinate.canonicalize(x_index, cube_size)
+        y = Coordinate.canonicalize(y_index, cube_size)
+        native = Native::CubeCoordinate.new(
+          cube_size,
+          face.face_symbol,
+          face.coordinate_index_base_face(0).face_symbol,
+          face.coordinate_index_base_face(1).face_symbol,
+          x,
+          y
+        )
+        new(native)
+      end
+
+      private_class_method :new
+
+      def initialize(native)
+        raise TypeError unless native.is_a?(Native::CubeCoordinate)
+
+        @native = native
+      end
+
+      attr_reader :native
+
+      def face
+        @face ||= Face.for_face_symbol(@native.face)
+      end
+
+      def cube_size
+        @cube_size ||= @native.cube_size
+      end
+
+      def coordinate(coordinate_index)
+        native.coordinate(face.coordinate_index_base_face(coordinate_index).face_symbol)
+      end
+
+      def coordinates
+        @coordinates ||= [x, y].freeze
+      end
+
+      def x
+        @x ||= coordinate(0)
+      end
+
+      def y
+        @y ||= coordinate(1)
+      end
+
+      def eql?(other)
+        self.class.equal?(other.class) && @native == other.native
+      end
+
+      alias == eql?
+
+      def hash
+        [self.class, @native].hash
+      end
+
+      def can_jump_to?(to_face)
+        raise ArgumentError unless to_face.is_a?(Face)
+
+        jump_coordinate_index = face.coordinate_index_close_to(to_face)
+        jump_coordinate = coordinates[jump_coordinate_index]
+        (jump_coordinate.zero? && to_face.close_to_smaller_indices?) ||
+          (jump_coordinate == Coordinate.highest_coordinate(cube_size) &&
+           !to_face.close_to_smaller_indices?)
+      end
+
+      def jump_to_neighbor(to_face)
+        raise ArgumentError unless to_face.is_a?(Face)
+        raise ArgumentError unless face.neighbors.include?(to_face)
+        raise ArgumentError unless can_jump_to?(to_face)
+
+        new_coordinates = coordinates.dup
+        new_coordinate_index = to_face.coordinate_index_close_to(face)
+        new_coordinate = make_coordinate_at_edge_to(face)
+        new_coordinates.insert(new_coordinate_index, new_coordinate)
+        Coordinate.from_indices(to_face, cube_size, *new_coordinates)
+      end
+
+      def jump_to_coordinates(new_coordinates)
+        Coordinate.from_indices(@face, @cube_size, *new_coordinates)
+      end
+
+      def make_coordinate_at_edge_to(face)
+        face.close_to_smaller_indices? ? 0 : Coordinate.highest_coordinate(cube_size)
+      end
+
+      # Returns neighbor faces that are closer to this coordinate than their opposite face.
+      def close_neighbor_faces
+        face.neighbors.select do |neighbor|
+          coordinate = coordinates[face.coordinate_index_close_to(neighbor)]
+          if neighbor.close_to_smaller_indices?
+            before_middle?(coordinate)
+          else
+            after_middle?(coordinate)
+          end
+        end
+      end
+
+      def after_middle?(index)
+        Coordinate.canonicalize(index, cube_size) > Coordinate.middle_or_before(cube_size)
+      end
+
+      def before_middle?(index)
+        Coordinate.canonicalize(index, cube_size) <= Coordinate.last_before_middle(cube_size)
+      end
+
+      # On a nxn grid with integer coordinates between 0 and n - 1, iterates between the 4 points
+      # that point (x, y) hits if you rotate by 90 degrees.
+      def rotate
+        jump_to_coordinates([y, Coordinate.invert_coordinate(x, cube_size)])
+      end
+
+      # On a nxn grid with integer coordinates between 0 and n - 1, give the 4 points that point
+      # (x, y) hits if you do a full rotation of the face in clockwise order.
+      def rotations
+        rots = []
+        current = self
+        4.times do
+          rots.push(current)
+          current = current.rotate
+        end
+        raise unless current == self
+
+        rots
+      end
+    end
+
+    # Coordinate of a sticker on the Skewb.
+    class SkewbCoordinate
+      include Comparable
+      include CubeConstants
+      def initialize(face, coordinate, native)
+        raise ArgumentError, "Unsuitable face #{face.inspect}." unless face.is_a?(Face)
+        unless coordinate.is_a?(Integer) && coordinate >= 0 && coordinate < SKEWB_STICKERS
+          raise ArgumentError
+        end
+
+        @coordinate = coordinate
+        @native = native
+      end
+
+      attr_reader :native
+
+      private_class_method :new
+
+      def self.for_center(face)
+        native = Native::SkewbCoordinate.for_center(face.face_symbol)
+        new(face, 0, native)
+      end
+
+      def self.corners_on_face(face)
+        face.clockwise_corners.map { |c| for_corner(c) }
+      end
+
+      def self.for_corner(corner)
+        native = Native::SkewbCoordinate.for_corner(corner.face_symbols)
+        new(Face.for_face_symbol(corner.face_symbols.first), 1 + corner.piece_index % 4, native)
+      end
+
+      def hash
+        @hash ||= [self.class, @native].hash
+      end
+
+      def eql?(other)
+        @native.eql?(other.native)
+      end
+
+      alias == eql?
+
+      def <=>(other)
+        @native <=> other.native
+      end
+
+      def face
+        @face ||= Face.for_face_symbol(@native.face)
+      end
+
+      attr_reader :coordinate
+    end
+end