Rubik.Cube.Facelet

Facelet representation

Facelets faces are unfolded and laid out like this:

      U
    L F R B
      D
  

Faces (or colors) are ordered U, L, F, R, B, D.

A Rubik's cube is a permutation of facelets numbered as follows:

           0  1  2
           3  4  5
           6  7  8

 9 10 11  18 19 20  27 28 29  36 37 38
12 13 14  21 22 23  30 31 32  39 40 41
15 16 17  24 25 26  33 34 35  42 43 44

          45 46 47
          48 49 50
          51 52 53

Facelet permutation

numFacelets :: Int

There are 54 == 6 * 9 facelets.

data Facelets

Cube as a permutation of facelets (replaced-by).

Every facelet is represented as an Int in [0 .. 54].

Instances

Eq Facelets

Show Facelets

Monoid Facelets

Group Facelets

facelets :: Vector Int -> Maybe Facelets

This constructor checks that the input is a permutation of '[0 .. 53]'.

fromFacelets :: Facelets -> Vector Int

The underlying Vector of Int.

Colors

type Color = Int

The standard cube colors are the values between 0 and 5.

colorOf :: Int -> Color

The color of a facelet given its identifier.

colorChar :: Color -> Char

A color is mapped to a face, indicated by a Char:

map colorChar [0..5] == "ULFRBD"

Color list

data ColorFacelets

Cube as a list of facelet colors.

Instances

Eq ColorFacelets

Show ColorFacelets

colorFacelets :: Vector Color -> Maybe ColorFacelets

This constructor checks that only standard colors (in [0 .. 5]) are used, that the argument has length 54 and that the centers are colored in order.

Note that there may still be more or less than 9 colors of a kind, although that cannot be the case in an actual cube.

fromColorFacelets :: ColorFacelets -> Vector Color

The underlying Vector of Color.

colorFaceletsOf :: Facelets -> ColorFacelets

Remove permutation information.

If the argument cube can be obtained from the solved cube with the usual moves, then the original permutation can be recovered with colorFaceletsToCube.

List conversions

fromFacelets' :: Facelets -> [Int]

See fromFacelets'

facelets' :: [Int] -> Maybe Facelets

See facelets.

fromColorFacelets' :: ColorFacelets -> [Color]

See fromColorFacelets.

colorFacelets' :: [Color] -> Maybe ColorFacelets

See colorFacelets.

colorFacelets'' :: Eq a => [a] -> Maybe ColorFacelets

Convert a 6-color list of length 54 in any representation which implements Eq to ColorFacelets.

Pretty conversion

stringOfFacelets :: Facelets -> String

String listing the permutation of facelets numbered in base 9.

Base 9 is convenient here because the first digit directly corresponds to a face and the second to the facelet position in that face.

stringOfColorFacelets :: ColorFacelets -> String

String listing the facelet colors.

stringOfColorFacelets' :: Facelets -> String

Only show the colors of the facelets.

Facelets corresponding to each cubie

The first letter in the name of a cubie is the color of its reference facelet (illustrated at http://kociemba.org/math/cubielevel.htm).

Corner colors are given in clockwise order.

Corners are lexicographically ordered (U>L>F>R>B>D).

Edges are gathered by horizontal slices (U, D, UD).

Centers

centerFacelets :: [Int]

  centerFacelets
  = [ 4,  -- U
      13, -- L
      22, -- F
      31, -- R
      40, -- B
      49] -- D

Corners

cornerFacelets :: [[Int]]

cornerFacelets = [ulb, ufl, urf, ubr, dlf, dfr, drb, dbl]

ulb :: [Int]

Corner facelets

ufl :: [Int]

Corner facelets

urf :: [Int]

Corner facelets

ubr :: [Int]

Corner facelets

dlf :: [Int]

Corner facelets

dfr :: [Int]

Corner facelets

drb :: [Int]

Corner facelets

dbl :: [Int]

Corner facelets

Edges

edgeFacelets :: [[Int]]

edgeFacelets = [ul, uf, ur, ub, dl, df, dr, db, fl, fr, bl, br]

ul :: [Int]

Edge facelets

uf :: [Int]

Edge facelets

ur :: [Int]

Edge facelets

ub :: [Int]

Edge facelets

dl :: [Int]

Edge facelets

df :: [Int]

Edge facelets

dr :: [Int]

Edge facelets

db :: [Int]

Edge facelets

fl :: [Int]

Edge facelets

fr :: [Int]

Edge facelets

bl :: [Int]

Edge facelets

br :: [Int]

Edge facelets