futhark-0.16.3: An optimising compiler for a functional, array-oriented language.
Safe HaskellSafe-Inferred



A rearrangement is a generalisation of transposition, where the dimensions are arbitrarily permuted.



rearrangeShape :: [Int] -> [a] -> [a] Source #

Calculate the given permutation of the list. It is an error if the permutation goes out of bounds.

rearrangeInverse :: [Int] -> [Int] Source #

Produce the inverse permutation.

rearrangeReach :: [Int] -> Int Source #

Return the first dimension not affected by the permutation. For example, the permutation [1,0,2] would return 2.

rearrangeCompose :: [Int] -> [Int] -> [Int] Source #

Compose two permutations, with the second given permutation being applied first.

isPermutationOf :: Eq a => [a] -> [a] -> Maybe [Int] Source #

Check whether the first list is a permutation of the second, and if so, return the permutation. This will also find identity permutations (i.e. the lists are the same) The implementation is naive and slow.

transposeIndex :: Int -> Int -> [a] -> [a] Source #

If l is an index into the array a, then transposeIndex k n l is an index to the same element in the array transposeArray k n a.

isMapTranspose :: [Int] -> Maybe (Int, Int, Int) Source #

If perm is conceptually a map of a transposition, isMapTranspose perm returns the number of dimensions being mapped and the number dimension being transposed. For example, we can consider the permutation [0,1,4,5,2,3] as a map of a transpose, by considering dimensions [0,1], [4,5], and [2,3] as single dimensions each.

If the input is not a valid permutation, then the result is undefined.