Agda - Agda.Utils.Permutation  

permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] More precisely, permute indices list = sublist, generates sublist from list by picking the elements of list as indicated by indices. permute [1,3,0] [x0,x1,x2,x3] = [x1,x3,x0]

Agda typing: permute (Perm {m} n is) : Vec A m -> Vec A n

permute :: (Shape ix, Shape ix', Elt a)=> (Exp a -> Exp a -> Exp a)-> Acc (Array ix' a)-> (Exp ix -> Exp ix')-> Acc (Array ix a)-> Acc (Array ix' a)

accelerate - Data.Array.Accelerate  

Forward permutation specified by an index mapping. The result array is initialised with the given defaults and any further values that are permuted into the result array are added to the current value using the given combination function.

The combination function must be associative and commutative. Elements that are mapped to the magic value ignore by the permutation function are dropped.

permute :: Permutation -> Array Int a -> Array Int a

combinat - Math.Combinat.Permutations  

Action of a permutation on a set. If our permutation is encoded with the sequence [p1,p2,...,pn], then in the two-line notation we have

( 1  2  3  ... n  )
( p1 p2 p3 ... pn )

We adopt the convention that permutations act on the left (as opposed to Knuth, where they act on the right). Thus,

permute pi1 (permute pi2 set) == permute (pi1 `multiply` pi2) set

The second argument should be an array with bounds (1,n). The function checks the array bounds.

permute :: DDManager -> DDNode -> [Int] -> DDNode
permute :: Elt a=> Array a-> Array Int-> Array a

dph-prim-interface - Data.Array.Parallel.Unlifted  

O(length result). Forwards permutation of array elements.

permute :: Elt a=> Array a-> Array Int-> Array a

dph-prim-par - Data.Array.Parallel.Unlifted  

O(length result). Forwards permutation of array elements.

permute :: Elt a=> Array a-> Array Int-> Array a

dph-prim-seq - Data.Array.Parallel.Unlifted  

O(length result). Forwards permutation of array elements.

permute :: (Data Length -> Data Index -> Data Index) -> Vector DIM1 a -> Vector DIM1 a

feldspar-language - Feldspar.Repa  

Permute a vector

permute :: Syntax a => (Data Length -> Data Index -> Data Index) -> Vector a -> Vector a
permute :: IsStrategy f => [f a] -> Strategy a

ideas - Ideas.Common.Strategy.Combinators  Ideas.Common.Strategy  

Allows all permutations of the list

permute :: Alternative p => PermParser p a -> p a

parco - Text.Parco.Perm  

The parser permute perm parses a permutation of parsers described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

  test  = permute (tuple <$?> ("",many1 (char 'a'))
                         <||> char 'b'
                         <|?> ('_',char 'c'))
        where
          tuple a b c  = (a,b,c)
permute :: Stream s Identity tok => StreamPermParser s st a -> Parsec s st a

parsec - Text.Parsec.Perm  Text.ParserCombinators.Parsec.Perm  

The parser permute perm parses a permutation of parser described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

 test  = permute (tuple <$?> ("",many1 (char 'a'))
                        <||> char 'b' 
                        <|?> ('_',char 'c'))
       where
         tuple a b c  = (a,b,c)
permute :: PermParser tok st a -> GenParser tok st a

parsec2 - Text.ParserCombinators.Parsec.Perm  

The parser permute perm parses a permutation of parser described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

  test  = permute (tuple <$?> ("",many1 (char 'a'))
                         <||> char 'b'
                         <|?> ('_',char 'c'))
        where
          tuple a b c  = (a,b,c)
permute :: Alternative m => Permutation m a -> m a

parsers - Text.Parser.Permutation  

The parser permute perm parses a permutation of parser described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

 test  = permute (tuple <$?> ("",some (char 'a'))
                        <||> char 'b'
                        <|?> ('_',char 'c'))
       where
         tuple a b c  = (a,b,c)
permute :: v s -> v s -> v s Class Method

scan-vector-machine - Control.Parallel.ScanVectorMachine.ScanVectorMachine  

Permutation: permute v1 v2 returns a vector v3 where v3[v2[i]] = v1[i] for all i. Both vectors must be the same length and the elements of v2 must all be distinct, non-negative, and less than the lengths of the vectors.

base - System.Console.GetOpt  

freely intersperse options and non-options