Wumpus.Core.Utils

Utility functions

Component-wise min and max

class CMinMax a where

Component-wise min and max. Standard min and max via Ord are defined lexographically on pairs, e.g.:

 min (1,2) (2,1) = (1,2)

For certain geometrical objects (Points!) we want the (constructed-) componentwise min and max, e.g:

 cmin (1,2) (2,1) = (1,1) 
 cmax (1,2) (2,1) = (2,2)

Methods

cmin :: a -> a -> a

cmax :: a -> a -> a

Instances

Ord a => CMinMax (Point2 a)

(Ord a, Ord b) => CMinMax (a, b)

within :: Eq a => CMinMax a => a -> a -> a -> Bool

Test whether a is within opper and lower.

Three values

max3 :: Ord a => a -> a -> a -> a

max of 3

min3 :: Ord a => a -> a -> a -> a

min of 3

med3 :: Ord a => a -> a -> a -> a

median of 3

Truncate / print a double

class Num a => PSUnit a where

Methods

toDouble :: a -> Double

dtrunc :: a -> String

Instances

PSUnit Double

PSUnit Float

PSUnit (Ratio Int)

PSUnit (Ratio Integer)

truncateDouble :: Double -> String

Truncate the printed decimal representation of a Double. The is prefered to showFFloat from Numeric as it produces shorter representations where appropriate.

1. 000000000 becomes 0.0 rather than however many digs are specified.

roundup :: Double -> String

Take ceilingi and show.

clamp :: Ord a => a -> a -> a -> a

ramp :: Double -> Double

ramp255 :: Double -> Int

Scale a Double between 0.0 and 1.0 to be an Int between 0 and 255.

PostScript timetmap

mkTimeStamp :: IO String

Generate a time stamp for the output files. Note PostScript does no interpretation of the time stamp, it is solely for information and so the representation is arbitrary.

Pretty printers for strings

parens :: String -> String

Enclose string in parens.

hsep :: [String] -> String

Separate with a space.

commasep :: [String] -> String

tupled :: [String] -> String

 (..., ...)

Extras

sequenceA :: Applicative f => [f a] -> f [a]

Applicative version of (monadic) sequence. Because we use MonadLib we don't want to bring in Control.Monad.Instances ()

(<:>) :: Applicative f => f a -> f [a] -> f [a]

Applicative cons.

One type - non-empty list type

data OneList a

Constructors

One a

a :+ (OneList a)

Instances

Eq a => Eq (OneList a)

Show a => Show (OneList a)

mkList2 :: a -> a -> OneList a

onesmapM_ :: Monad m => (a -> m b) -> OneList a -> m ()

toListWith :: (a -> b) -> OneList a -> [b]

toListWithM :: Monad m => (a -> m b) -> OneList a -> m [b]

fromListErr :: String -> [a] -> OneList a