Safe Haskell	None
Language	Haskell2010

Rubik.Cube.Cubie.Internal

Contents

UDSlice

Synopsis

Documentation

newtype CornerPermu Source

Cubie permutation is in replaced-by representation.

Constructors

CornerPermu
Fields fromCornerPermu :: Vector Int

Instances

Eq CornerPermu Source
Show CornerPermu Source
Monoid CornerPermu Source
Group CornerPermu Source
CubeAction CornerPermu Source
FromCube CornerPermu Source
RawEncodable CornerPermu Source	The number of elements of every set is given. 8! = 40320

newtype CornerOrien Source

Constructors

CornerOrien
Fields fromCornerOrien :: Vector Int

Instances

Eq CornerOrien Source
Show CornerOrien Source
CubeAction CornerOrien Source
FromCube CornerOrien Source
RawEncodable CornerOrien Source	3^7 = 2187

data Corner Source

Constructors

Corner
Fields cPermu :: CornerPermu cOrien :: CornerOrien

Instances

Eq Corner Source
Show Corner Source
Monoid Corner Source
Group Corner Source
CubeAction Corner Source
FromCube Corner Source

cornerPermu :: Vector Int -> Maybe CornerPermu Source

Check that the argument is a permutation of size 8 and wrap it.

In a solvable Rubik's cube, its parity must be equal to that of the associated EdgePermu.

unsafeCornerPermu :: Vector Int -> CornerPermu Source

unsafeCornerPermu' :: [Int] -> CornerPermu Source

cornerOrien :: Vector Int -> Maybe CornerOrien Source

Check that the argument is a vector of senary (6) values of size 8 and wrap it.

In a solvable Rubik's cube, only ternary values are possible; i.e., all elements must be between 0 and 2. Their sum must also be a multiple of 3.

Orientation encoding

Corner orientations are permutations of 3 facelets.

They are mapped to integers in [0 .. 5] such that [0, 1, 2] are rotations (even permutations) and [3, 4, 5] are transpositions (although impossible in a Rubik's cube).

0. identity
1. counter-clockwise
2. clockwise
3. left facelet fixed
4. right facelet fixed
5. top (reference) facelet fixed

unsafeCornerOrien :: Vector Int -> CornerOrien Source

unsafeCornerOrien' :: [Int] -> CornerOrien Source

newtype EdgePermu Source

Cubie permutation is in replaced-by representation.

Constructors

EdgePermu
Fields fromEdgePermu :: Vector Int

Instances

Eq EdgePermu Source
Show EdgePermu Source
Monoid EdgePermu Source
Group EdgePermu Source
CubeAction EdgePermu Source
FromCube EdgePermu Source
RawEncodable EdgePermu Source	12! = 479001600 A bit too much to hold in memory. Holds just right in a Haskell `Int` (`maxInt >= 2^29 - 1`).

newtype EdgeOrien Source

Constructors

EdgeOrien
Fields fromEdgeOrien :: Vector Int

Instances

Eq EdgeOrien Source
Show EdgeOrien Source
CubeAction EdgeOrien Source
FromCube EdgeOrien Source
RawEncodable EdgeOrien Source	2^11 = 2048

data Edge Source

Constructors

Edge
Fields ePermu :: EdgePermu eOrien :: EdgeOrien

Instances

Eq Edge Source
Show Edge Source
Monoid Edge Source
Group Edge Source
CubeAction Edge Source
FromCube Edge Source

edgePermu :: Vector Int -> Maybe EdgePermu Source

Check that the argument is a permutation of size 12 and wrap it.

In a solvable Rubik's cube, its parity must be equal to that of the associated CornerPermu.

unsafeEdgePermu :: Vector Int -> EdgePermu Source

unsafeEdgePermu' :: [Int] -> EdgePermu Source

edgeOrien :: Vector Int -> Maybe EdgeOrien Source

Check that the argument is a vector of binary values of size 12 and wrap it.

In a solvable Rubik's cube, their sum must be even.

unsafeEdgeOrien :: Vector Int -> EdgeOrien Source

unsafeEdgeOrien' :: [Int] -> EdgeOrien Source

data Cube Source

A cube is given by the positions of its corners and edges.

Cubes are identified with the permutations that produce them starting from the solved cube.

The cube permutation composition (class Group Cube) is defined "in left to right order", so that the sequence of movements "x then y then z" is represented by x <> y <> z.

Constructors

Cube
Fields corner :: Corner edge :: Edge

Instances

Eq Cube Source
Show Cube Source
Monoid Cube Source
Group Cube Source

class FromCube a where Source

Methods

fromCube :: Cube -> a Source

class CubeAction a where Source

Group action of Cube on type a

 x `cubeAction` iden == x
(x `cubeAction` a) `cubeAction` b == x `cubeAction (a <> b)

It seems that with proper additional laws between FromCube and Group instances, it may be possible to automatically deduce a default CubeAction instance.

cubeAction a = (a <>) . fromCube

This module defines representations of right cosets (Hg where g :: Cube) of certain subgroups H of the Rubik group Cube, which acts on the right of the set of cosets.

Methods

cubeAction :: a -> Cube -> a Source

cube :: Vector Int -> Vector Int -> Vector Int -> Vector Int -> Maybe Cube Source

cube' :: [Int] -> [Int] -> [Int] -> [Int] -> Maybe Cube Source

unsafeCube :: Vector Int -> Vector Int -> Vector Int -> Vector Int -> Cube Source

unsafeCube' :: [Int] -> [Int] -> [Int] -> [Int] -> Cube Source

numCorners :: Int Source

numCorners = 8

numEdges :: Int Source

numEdges = 12

oPlus :: Integral a => a -> a -> a Source

oInv :: (Num a, Ord a) => a -> a Source

actionCorner :: CornerOrien -> Corner -> CornerOrien Source

actionEdge :: EdgeOrien -> Edge -> EdgeOrien Source

solvable :: Cube -> Bool Source

Tests whether a cube can be solved with the standard set of moves.

symRotate :: Int -> [Int] -> [Int] Source

0 <= o < 6

toFacelet :: Cube -> Facelets Source

colorFaceletsToCube :: ColorFacelets -> Either [Int] (Maybe Cube) Source

Convert from facelet to cubie permutation.

Evaluates to a Left error if a combination of colors does not correspond to a regular cubie from the solved cube: the colors of the facelets on one cubie must be unique, and must not contain facelets of opposite faces. The error is the list of indices of facelets of such an invalid cubie.

Another possible error is that the resulting configuration is not a permutation of cubies (at least one cubie is absent, and one is duplicated). In that case, the result is Right Nothing.

stringOfCubeColors :: Cube -> String Source

UDSlice

newtype UDSlicePermu Source

Position of the 4 UDSlice edges (carried-to)

Constructors

UDSlicePermu
Fields fromUDSlicePermu :: Vector Int

Instances

Eq UDSlicePermu Source
Show UDSlicePermu Source
CubeAction UDSlicePermu Source
FromCube UDSlicePermu Source
RawEncodable UDSlicePermu Source	12! / 8! = 11880

newtype UDSlice Source

Position of the 4 UDSlice edges up to permutation (carried-to). The vector is always sorted.

Constructors

UDSlice
Fields fromUDSlice :: Vector Int

Instances

Eq UDSlice Source
Show UDSlice Source
CubeAction UDSlice Source
FromCube UDSlice Source
RawEncodable UDSlice Source	12C4 = 495

newtype UDSlicePermu2 Source

Position of the 4 UDSlice edges (replaced-by), assuming they are all in that slice already.

Constructors

UDSlicePermu2
Fields fromUDSlicePermu2 :: Vector Int

Instances

Eq UDSlicePermu2 Source
Show UDSlicePermu2 Source
CubeAction UDSlicePermu2 Source
FromCube UDSlicePermu2 Source
RawEncodable UDSlicePermu2 Source	4! = 24

newtype UDEdgePermu2 Source

Position of the 8 other edges (replaced-by), assuming UDSlice edges are in that slice already.

Constructors

UDEdgePermu2
Fields fromUDEdgePermu2 :: Vector Int

Instances

Eq UDEdgePermu2 Source
Show UDEdgePermu2 Source
CubeAction UDEdgePermu2 Source
FromCube UDEdgePermu2 Source
RawEncodable UDEdgePermu2 Source	8! = 40320

type FlipUDSlice = (UDSlice, EdgeOrien) Source

type FlipUDSlicePermu = (UDSlicePermu, EdgeOrien) Source

numUDSliceEdges :: Int Source

numUDSliceEdges = 4

unsafeUDSlicePermu :: Vector Int -> UDSlicePermu Source

unsafeUDSlicePermu' :: [Int] -> UDSlicePermu Source

uDSlicePermu :: Vector Int -> Maybe UDSlicePermu Source

uDSlice :: Vector Int -> Maybe UDSlice Source

Wrap an increasing list of 4 elements in [0 .. 11].

unsafeUDSlice :: Vector Int -> UDSlice Source

unsafeUDSlice' :: [Int] -> UDSlice Source

uDSlicePermu2 :: Vector Int -> Maybe UDSlicePermu2 Source

Wrap a permutation of size 4.

unsafeUDSlicePermu2 :: Vector Int -> UDSlicePermu2 Source

unsafeUDSlicePermu2' :: [Int] -> UDSlicePermu2 Source

uDEdgePermu2 :: Vector Int -> Maybe UDEdgePermu2 Source

Wrap a permutation of size 8.

unsafeUDEdgePermu2 :: Vector Int -> UDEdgePermu2 Source

unsafeUDEdgePermu2' :: [Int] -> UDEdgePermu2 Source

vSort :: Vector Int -> Vector Int Source

unpermuUDSlice :: UDSlicePermu -> UDSlice Source

edgePermu2 :: UDSlicePermu2 -> UDEdgePermu2 -> EdgePermu Source

neutralUDSlicePermu :: UDSlicePermu Source

neutralUDSlice :: UDSlice Source

neutralUDSlicePermu2 :: UDSlicePermu2 Source

neutralUDEdgePermu2 :: UDEdgePermu2 Source

actionUDSlicePermu' :: EdgePermu -> Vector Int -> Vector Int Source

actionUDSlicePermu :: UDSlicePermu -> EdgePermu -> UDSlicePermu Source

actionUDSlice :: UDSlice -> EdgePermu -> UDSlice Source

actionUDSlicePermu2 :: UDSlicePermu2 -> EdgePermu -> UDSlicePermu2 Source

actionUDEdgePermu2 :: UDEdgePermu2 -> EdgePermu -> UDEdgePermu2 Source

conjugateFlipUDSlice :: Cube -> FlipUDSlice -> FlipUDSlice Source

The conjugation is only compatible when the Cube symmetry leaves UDSlice edges stable, and either flips them all or none of them, and either flips all 8 non-UDSlice edges or none of them.

conjugateFlipUDSlicePermu :: Cube -> FlipUDSlicePermu -> FlipUDSlicePermu Source

Expects UDSlice-stable symmetry

conjugateEdgeOrien' :: Cube -> FlipUDSlicePermu -> EdgeOrien Source

conjugateUDSlicePermu :: Cube -> UDSlicePermu -> UDSlicePermu Source

conjugateCornerOrien :: Cube -> CornerOrien -> CornerOrien Source

Expects UDSlice-stable symmetry.