Data.Histogram.Bin.Extra

Extra binning algorithms

Documentation

class Enum2D a where

Type class very similar to Enum but elements of type are enumerated on 2-dimensional grid

Minimal complete definition

fromEnum2D, toEnum2D

Methods

fromEnum2D :: a -> (Int, Int)

Convert value to index

toEnum2D :: (Int, Int) -> a

Convert index to value

Instances

(Enum a, Enum b) => Enum2D (a, b)

Methods

fromEnum2D :: (a, b) -> (Int, Int)

toEnum2D :: (Int, Int) -> (a, b)

data BinEnum2D i

Binning for 2D enumerations

Instances

Eq (BinEnum2D i)

Methods

(==) :: BinEnum2D i -> BinEnum2D i -> Bool

(/=) :: BinEnum2D i -> BinEnum2D i -> Bool

Data i => Data (BinEnum2D i)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BinEnum2D i -> c (BinEnum2D i)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BinEnum2D i)

toConstr :: BinEnum2D i -> Constr

dataTypeOf :: BinEnum2D i -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (BinEnum2D i))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BinEnum2D i))

gmapT :: (forall b. Data b => b -> b) -> BinEnum2D i -> BinEnum2D i

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BinEnum2D i -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BinEnum2D i -> r

gmapQ :: (forall d. Data d => d -> u) -> BinEnum2D i -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> BinEnum2D i -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BinEnum2D i -> m (BinEnum2D i)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BinEnum2D i -> m (BinEnum2D i)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BinEnum2D i -> m (BinEnum2D i)

(Read i, Enum2D i) => Read (BinEnum2D i)

Methods

readsPrec :: Int -> ReadS (BinEnum2D i)

readList :: ReadS [BinEnum2D i]

readPrec :: ReadPrec (BinEnum2D i)

readListPrec :: ReadPrec [BinEnum2D i]

(Show i, Enum2D i) => Show (BinEnum2D i)

Methods

showsPrec :: Int -> BinEnum2D i -> ShowS

show :: BinEnum2D i -> String

showList :: [BinEnum2D i] -> ShowS

NFData (BinEnum2D i)

Methods

rnf :: BinEnum2D i -> ()

Enum2D i => Bin (BinEnum2D i)

Associated Types

type BinValue (BinEnum2D i) :: *

Methods

toIndex :: BinEnum2D i -> BinValue (BinEnum2D i) -> Int

fromIndex :: BinEnum2D i -> Int -> BinValue (BinEnum2D i)

nBins :: BinEnum2D i -> Int

inRange :: BinEnum2D i -> BinValue (BinEnum2D i) -> Bool

type BinValue (BinEnum2D i)

type BinValue (BinEnum2D i) = i

binEnum2D :: Enum2D i => i -> i -> BinEnum2D i

Construct indexed bin

data BinPermute b

Direct permutation of indices.

Instances

Eq b => Eq (BinPermute b)

Methods

(==) :: BinPermute b -> BinPermute b -> Bool

(/=) :: BinPermute b -> BinPermute b -> Bool

Data b => Data (BinPermute b)

Methods

gfoldl :: (forall d a. Data d => c (d -> a) -> d -> c a) -> (forall g. g -> c g) -> BinPermute b -> c (BinPermute b)

gunfold :: (forall a r. Data a => c (a -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BinPermute b)

toConstr :: BinPermute b -> Constr

dataTypeOf :: BinPermute b -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (BinPermute b))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BinPermute b))

gmapT :: (forall a. Data a => a -> a) -> BinPermute b -> BinPermute b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BinPermute b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BinPermute b -> r

gmapQ :: (forall d. Data d => d -> u) -> BinPermute b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> BinPermute b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BinPermute b -> m (BinPermute b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BinPermute b -> m (BinPermute b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BinPermute b -> m (BinPermute b)

Read BinI => Read (BinPermute BinI)

Methods

readsPrec :: Int -> ReadS (BinPermute BinI)

readList :: ReadS [BinPermute BinI]

readPrec :: ReadPrec (BinPermute BinI)

readListPrec :: ReadPrec [BinPermute BinI]

Show b => Show (BinPermute b)

Methods

showsPrec :: Int -> BinPermute b -> ShowS

show :: BinPermute b -> String

showList :: [BinPermute b] -> ShowS

NFData b => NFData (BinPermute b)

Methods

rnf :: BinPermute b -> ()

UniformBin b => UniformBin (BinPermute b)

Methods

binSize :: BinPermute b -> BinValue (BinPermute b)

VariableBin b => VariableBin (BinPermute b)

Methods

binSizeN :: BinPermute b -> Int -> BinValue (BinPermute b)

IntervalBin b => IntervalBin (BinPermute b)

Methods

binInterval :: BinPermute b -> Int -> (BinValue (BinPermute b), BinValue (BinPermute b))

binsList :: Vector v (BinValue (BinPermute b), BinValue (BinPermute b)) => BinPermute b -> v (BinValue (BinPermute b), BinValue (BinPermute b))

Bin b => Bin (BinPermute b)

Associated Types

type BinValue (BinPermute b) :: *

Methods

toIndex :: BinPermute b -> BinValue (BinPermute b) -> Int

fromIndex :: BinPermute b -> Int -> BinValue (BinPermute b)

nBins :: BinPermute b -> Int

inRange :: BinPermute b -> BinValue (BinPermute b) -> Bool

type BinValue (BinPermute b)

type BinValue (BinPermute b) = BinValue b

permuteByTable :: Bin b => b -> Vector Int -> Maybe (BinPermute b)

Constuct bin permutation from table

permuteBin :: Bin b => b -> (Int -> Int) -> Maybe (BinPermute b)

Constuct bin permutation from function.