Data.Histogram.Bin.Classes

Type classes for binning algorithms. This is mapping from set of interest to integer indices and approximate reverse.

Bin type class

class Bin b where

This type represent some abstract data binning algorithms. It maps sets/intervals of values of type 'BinValue b' to integer indices.

Following invariant is expected to hold:

 toIndex . fromIndex == id

Associated Types

type BinValue b

Type of value to bin

Methods

toIndex :: b -> BinValue b -> Int

Convert from value to index. Function must not fail for any input and should produce out of range indices for invalid input.

fromIndex :: b -> Int -> BinValue b

Convert from index to value. Returned value should correspond to center of bin. Definition of center is left for definition of instance. Funtion may fail for invalid indices but encouraged not to do so.

nBins :: b -> Int

Total number of bins.

inRange :: b -> BinValue b -> Bool

Check whether value in range. Have default implementation. Should satisfy: inRange b x ⇔ toIndex b x ∈ [0,nBins b)

Instances

Bin BinI

Bin BinInt

Bin BinD

Bin LogBinD

Enum a => Bin (BinEnum a)

RealFrac f => Bin (BinF f)

Bin b => Bin (BinPermute b)

Enum2D i => Bin (BinEnum2D i)

(Bin binX, Bin binY) => Bin (Bin2D binX binY)

binsCenters :: (Bin b, Vector v (BinValue b)) => b -> v (BinValue b)

Return vector of bin centers

1D bins

class Bin b => IntervalBin b where

For binning algorithms which work with bin values which have some natural ordering and every bin is continous interval.

Methods

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

Interval for n'th bin

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

List of all bins. Could be overridden for efficiency.

Instances

IntervalBin BinI

IntervalBin BinInt

IntervalBin BinD

IntervalBin LogBinD

Enum a => IntervalBin (BinEnum a)

RealFrac f => IntervalBin (BinF f)

IntervalBin b => IntervalBin (BinPermute b)

class IntervalBin b => Bin1D b where

IntervalBin which domain is single finite interval

Methods

lowerLimit :: b -> BinValue b

Minimal accepted value of histogram

upperLimit :: b -> BinValue b

Maximal accepted value of histogram

unsafeSliceBin :: Int -> Int -> b -> b

Slice bin by indices. This function doesn't perform any checks and may produce invalid bin

Instances

Bin1D BinI

Bin1D BinInt

Bin1D BinD

Bin1D LogBinD

Enum a => Bin1D (BinEnum a)

RealFrac f => Bin1D (BinF f)

sliceBin :: Bin1D b => Int -> Int -> b -> b

Slice bin using indices

class Bin b => VariableBin b where

1D binning algorithms with variable bin size

Methods

binSizeN :: b -> Int -> BinValue b

Size of n'th bin.

Instances

VariableBin BinI

VariableBin BinInt

VariableBin BinD

VariableBin LogBinD

RealFrac f => VariableBin (BinF f)

VariableBin b => VariableBin (BinPermute b)

class VariableBin b => UniformBin b where

1D binning algorithms with constant size bins. Constant sized bins could be thought as specialization of variable-sized bins therefore a superclass constraint.

Methods

binSize :: b -> BinValue b

Size of bin. Default implementation just uses 0th bin.

Instances

UniformBin BinI

UniformBin BinInt

UniformBin BinD

RealFrac f => UniformBin (BinF f)

UniformBin b => UniformBin (BinPermute b)

class Bin1D b => GrowBin b where

Binning algorithm which allows to append and prepend bins.

Methods

zeroBin :: b -> b

Set number of bins to zero. By convention bins are shrinked to lower bound.

appendBin :: b -> b

Append one bin at upper bound

prependBin :: b -> b

Prepend one bin at lower bin

Instances

GrowBin BinI

GrowBin BinInt

GrowBin BinD

Enum a => GrowBin (BinEnum a)

RealFrac f => GrowBin (BinF f)

Conversion

class (Bin b, Bin b') => ConvertBin b b' where

Class for conversion between binning algorithms.

Methods

convertBin :: b -> b'

Convert bins

Instances

ConvertBin BinI BinD

ConvertBin BinInt BinD

RealFrac f => ConvertBin BinI (BinF f)

RealFrac f => ConvertBin BinInt (BinF f)

(ConvertBin bx bx', ConvertBin by by') => ConvertBin (Bin2D bx by) (Bin2D bx' by')

(ConvertBin by by', Bin bx) => ConvertBin (Bin2D bx by) (Bin2D bx by')

(ConvertBin bx bx', Bin by) => ConvertBin (Bin2D bx by) (Bin2D bx' by)