Copyright | (c) 2009 2010 2011 Bryan O'Sullivan |
---|---|

License | BSD3 |

Maintainer | bos@serpentine.com |

Stability | experimental |

Portability | portable |

Safe Haskell | None |

Language | Haskell2010 |

Useful functions.

## Synopsis

- minMax :: Vector v Double => v Double -> (Double, Double)
- sort :: Vector Double -> Vector Double
- gsort :: (Ord e, Vector v e) => v e -> v e
- sortBy :: Vector v e => Comparison e -> v e -> v e
- partialSort :: (Vector v e, Ord e) => Int -> v e -> v e
- indexed :: (Vector v e, Vector v Int, Vector v (Int, e)) => v e -> v (Int, e)
- indices :: (Vector v a, Vector v Int) => v a -> v Int
- nextHighestPowerOfTwo :: Int -> Int
- within :: Int -> Double -> Double -> Bool
- square :: Double -> Double
- unsafeModify :: MVector s Double -> Int -> (Double -> Double) -> ST s ()
- for :: Monad m => Int -> Int -> (Int -> m ()) -> m ()
- rfor :: Monad m => Int -> Int -> (Int -> m ()) -> m ()

# Scanning

minMax :: Vector v Double => v Double -> (Double, Double) Source #

Compute the minimum and maximum of a vector in one pass.

# Sorting

sortBy :: Vector v e => Comparison e -> v e -> v e Source #

Sort a vector using a custom ordering.

Partially sort a vector, such that the least *k* elements will be
at the front.

# Indexing

indexed :: (Vector v e, Vector v Int, Vector v (Int, e)) => v e -> v (Int, e) Source #

Zip a vector with its indices.

# Bit twiddling

nextHighestPowerOfTwo :: Int -> Int Source #

Efficiently compute the next highest power of two for a non-negative integer. If the given value is already a power of two, it is returned unchanged. If negative, zero is returned.

# Comparison

Compare two `Double`

values for approximate equality, using
Dawson's method.

The required accuracy is specified in ULPs (units of least
precision). If the two numbers differ by the given number of ULPs
or less, this function returns `True`

.