base -System.Console.GetOpt  

<p>freely intersperse options and non-options</p>
permute :: Stream s Identity tok => StreamPermParser s st a -> Parsec s st a

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

<p>The parser <code>permute perm</code> parses a permutation of parser described by <code>perm</code>. For example, suppose we want to parse a permutation of: an optional string of <code>a</code>'s, the character <code>b</code> and an optional <code>c</code>. This can be described by:</p><pre> test = permute (tuple <$?> ("",many1 (char 'a')) <||> char 'b' <|?> ('_',char 'c')) where tuple a b c = (a,b,c)</pre>
permute :: Alternative m => Permutation m a -> m a

parsers -Text.Parser.Permutation  

<p>The parser <code>permute perm</code> parses a permutation of parser described by <code>perm</code>. For example, suppose we want to parse a permutation of: an optional string of <code>a</code>'s, the character <code>b</code> and an optional <code>c</code>. This can be described by:</p><pre> test = permute (tuple <$?> ("",some (char 'a')) <||> char 'b' <|?> ('_',char 'c')) where tuple a b c = (a,b,c)</pre>
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  

<p>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.</p><p>The combination function must be <em>associative</em> and <em>commutative</em>. Elements that are mapped to the magic value <code><a href="/?query=%28%28name%3A%28%21ignore%29%20package%3A%28%21accelerate%29%20module%3A%28%21Data.Array.Accelerate%29%29%5E100.0%29%20OR%20%28%28name%3A%28%21ignore%29%20package%3A%28%21accelerate%29%29%5E10.0%29%20OR%20name%3A%28%21ignore%29">ignore</a></code> by the permutation function are dropped.</p>
permute :: Elt a=> Array a-> Array Int-> Array a

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

<p>O(length result). Forwards permutation of array elements. </p>

permutation -Data.Permute  

<p>Construct an identity permutation of the given size.</p>
permute :: Elt a=> Array a-> Array Int-> Array a

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

<p>O(length result). Forwards permutation of array elements. </p>
permute :: Elt a=> Array a-> Array Int-> Array a

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

<p>O(length result). Forwards permutation of array elements. </p>
permute :: Permutation -> Array Int a -> Array Int a

combinat -Math.Combinat.Permutations  

<p>Action of a permutation on a set. If our permutation is encoded with the sequence <code>[p1,p2,...,pn]</code>, then in the two-line notation we have</p><pre>( 1 2 3 ... n ) ( p1 p2 p3 ... pn )</pre><p>We adopt the convention that permutations act <em>on the left</em> (as opposed to Knuth, where they act on the right). Thus, </p><pre>permute pi1 (permute pi2 set) == permute (pi1 `multiply` pi2) set</pre><p>The second argument should be an array with bounds <code>(1,n)</code>. The function checks the array bounds.</p>
permute :: Stream s Identity tok => StreamPermParser s st a -> Parsec s st a

parsec3 -Text.Parsec.Perm  

<p>The parser <code>permute perm</code> parses a permutation of parser described by <code>perm</code>. For example, suppose we want to parse a permutation of: an optional string of <code>a</code>'s, the character <code>b</code> and an optional <code>c</code>. This can be described by:</p><pre> test = permute (tuple <$?> ("",many1 (char 'a')) <||> char 'b' <|?> ('_',char 'c')) where tuple a b c = (a,b,c)</pre>
permute :: Permutation -> Vector Double -> Vector Double

hmatrix-gsl-stats -Numeric.GSL.Permutation  

<p>apply the permutation to a vector</p>
permute :: PermParser tok st a -> GenParser tok st a

parsec2 -Text.ParserCombinators.Parsec.Perm  

<p>The parser <code>permute perm</code> parses a permutation of parser described by <code>perm</code>. For example, suppose we want to parse a permutation of: an optional string of <code>a</code>'s, the character <code>b</code> and an optional <code>c</code>. This can be described by: </p><pre> test = permute (tuple <$?> ("",many1 (char 'a')) <||> char 'b' <|?> ('_',char 'c')) where tuple a b c = (a,b,c) </pre>
permute :: (Data Length -> Data Index -> Data Index) -> Vector DIM1 a -> Vector DIM1 a

feldspar-language -Feldspar.Repa  

<p>Permute a vector </p>
permute :: Syntax a => (Data Length -> Data Index -> Data Index) -> Vector a -> Vector a

feldspar-language -Feldspar.Vector.Internal  

<p>Permute a vector </p>

permutation -Data.Permute  

<div class="doc"><p>Immutable permutations.</p></div>

permutation -Data.Permute  

<p>The immutable permutation data type. Internally, a permutation of size <code>n</code> is stored as an <code>0</code>-based array of <code>n</code> <code><a href="/?query=%28%28name%3A%28%21Int%29%20package%3A%28%21base%29%20module%3A%28%21Data.Int%29%29%5E100.0%29%20OR%20%28%28name%3A%28%21Int%29%20package%3A%28%21base%29%29%5E10.0%29%20OR%20name%3A%28%21Int%29">Int</a></code>s. The permutation represents a reordering of the integers <code>0, ..., (n-1)</code>. The permutation sents the value p[i] to <code>i</code>. </p>
Generalised permutation parser combinator
permute :: (Alternative p, Monad p) => PermParser p a -> p a

permute -Text.ParserCombinators.Perm  

<p>The parser <code>permute perm</code> parses a permutation of parser described by <code>perm</code>. For example, suppose we want to parse a permutation of: an optional string of <code>a</code>'s, the character <code>b</code> and an optional <code>c</code>. This can be described by: </p><pre> test = permute (tuple <$?> ("",many1 (char 'a')) <||> char 'b' <|?> ('_',char 'c')) where tuple a b c = (a,b,c) </pre>