Rubik.Misc

General functions for the twentyseven project

Documentation

flatIndex :: Int -> Int -> Int -> Int

Convert 2D indices to 1D.

\n x y -> x * n + y

Applicative

zipWith' :: Applicative f => (a -> b -> c) -> f a -> f b -> f c

sequence' :: Applicative f => [f a] -> f [a]

Lists

rotate :: Int -> [a] -> [a]

Rotation:

rotate 3 [1,2,3,4,5,6,7] == [4,5,6,7] ++ [1,2,3]

subs :: Int -> a -> [a] -> [a]

Substitute the n-th element.

insert' :: Int -> a -> [a] -> [a]

Insert before the n-th element.

inverseList :: Int -> [Int] -> [Int]

If l is a permutation list (replaced-by) of length n, inverseList n l is its inverse permutation.

composeList :: [a] -> [Int] -> [a]

Backpermute. Substitute every index in the second list with the corresponding element in the first.

listSeq :: [a] -> b -> b

Strict in every element of the list.

Vectors

type Vector = Vector

Unboxed vectors

isPermutationVector :: Vector Int -> Bool

Permutation of [0 .. length v].

signPermutationVector :: Vector Int -> Int

Sign of a permutation vector.

idVector :: Int -> Vector Int

idVector n == fromList [0 .. n - 1]

inverseVector :: Vector Int -> Vector Int

If v is a permutation, inverseVector v is its inverse permutation.

composeVector :: Unbox a => Vector a -> Vector Int -> Vector a

Permutation composition: (p . q) x == p (q x).

composeVector u v ! i == u ! (v ! i)

Groups

class Monoid a => Group a where

Class for groups:

a <> (b <> c) == (a <> b) <> c -- Associative property

a <> iden == a -- Neutral element
iden <> a == a

a <> inverse a == iden -- Inverse
inverse a <> a == iden

Methods

inverse :: a -> a

Instances

Group Facelets

Group Cube

Group Edge

Group EdgePermu

Group Corner

Group CornerPermu

(Group a, Group b) => Group (a, b)

iden :: Group a => a

Alias for mempty

(<>^) :: (Integral int, Group a) => a -> int -> a infixr 8

Exponentiation, negative indices are supported.

conjugate :: Group a => a -> a -> a

Conjugation:

s `conjugate` a = inverse s <> a <> s

(??) :: Group a => a -> a -> a

Conjugation:

s `conjugate` a = inverse s <> a <> s

Combinatorics

fact :: Int -> Int

Factorial

choose :: Int -> Int -> Int

Binomial coefficient:

choose n k == fact n `div` (fact k) * (fact (n - k))

iFind :: (Integral a, Ord a, Vector v a) => a -> v a -> Maybe Int

Interpolation search for Int

bool :: a -> a -> Bool -> a

Flipped "if"

chunk :: Int -> [a] -> [[a]]

Equal sized chunks

partition' :: (a -> a -> Bool) -> [a] -> [[a]]

Generalized partition

tagOf :: tag a b -> tag' a b' -> tag a b

asProxyTypeOf :: a -> proxy a -> a

proxyUnwrap :: proxy (f a) -> Proxy a

(<&>) :: Functor f => f a -> (a -> b) -> f b