net-spider-0.3.3.0: A graph database middleware to maintain a time-varying graph.

MaintainerToshio Ito <toshio9.ito@toshiba.co.jp>
Safe HaskellSafe
LanguageHaskell2010

NetSpider.Interval

Contents

Description

Re-exports of Interval type and additional utility.

Since: 0.3.2.0

Synopsis

Re-exports

data Interval r #

The intervals (i.e. connected and convex subsets) over real numbers R.

Instances
Eq r => Eq (Interval r) 
Instance details

Defined in Data.Interval.Internal

Methods

(==) :: Interval r -> Interval r -> Bool #

(/=) :: Interval r -> Interval r -> Bool #

(Ord r, Data r) => Data (Interval r) 
Instance details

Defined in Data.Interval.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Interval r -> c (Interval r) #

gunfold :: (forall b r0. Data b => c (b -> r0) -> c r0) -> (forall r1. r1 -> c r1) -> Constr -> c (Interval r) #

toConstr :: Interval r -> Constr #

dataTypeOf :: Interval r -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Interval r)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Interval r)) #

gmapT :: (forall b. Data b => b -> b) -> Interval r -> Interval r #

gmapQl :: (r0 -> r' -> r0) -> r0 -> (forall d. Data d => d -> r') -> Interval r -> r0 #

gmapQr :: (r' -> r0 -> r0) -> r0 -> (forall d. Data d => d -> r') -> Interval r -> r0 #

gmapQ :: (forall d. Data d => d -> u) -> Interval r -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Interval r -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Interval r -> m (Interval r) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval r -> m (Interval r) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval r -> m (Interval r) #

Hashable r => Hashable (Interval r) 
Instance details

Defined in Data.Interval.Internal

Methods

hashWithSalt :: Int -> Interval r -> Int #

hash :: Interval r -> Int #

NFData r => NFData (Interval r) 
Instance details

Defined in Data.Interval.Internal

Methods

rnf :: Interval r -> () #

data Extended r #

Extended r is an extension of r with positive/negative infinity (±∞).

Constructors

NegInf

negative infinity (-∞)

Finite !r

finite value

PosInf

positive infinity (+∞)

Instances
Functor Extended 
Instance details

Defined in Data.ExtendedReal

Methods

fmap :: (a -> b) -> Extended a -> Extended b #

(<$) :: a -> Extended b -> Extended a #

Bounded (Extended r) 
Instance details

Defined in Data.ExtendedReal

Eq r => Eq (Extended r) 
Instance details

Defined in Data.ExtendedReal

Methods

(==) :: Extended r -> Extended r -> Bool #

(/=) :: Extended r -> Extended r -> Bool #

(Fractional r, Ord r) => Fractional (Extended r)

Note that Extended r is not a field, nor a ring.

Instance details

Defined in Data.ExtendedReal

Data r => Data (Extended r) 
Instance details

Defined in Data.ExtendedReal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Extended r -> c (Extended r) #

gunfold :: (forall b r0. Data b => c (b -> r0) -> c r0) -> (forall r1. r1 -> c r1) -> Constr -> c (Extended r) #

toConstr :: Extended r -> Constr #

dataTypeOf :: Extended r -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Extended r)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Extended r)) #

gmapT :: (forall b. Data b => b -> b) -> Extended r -> Extended r #

gmapQl :: (r0 -> r' -> r0) -> r0 -> (forall d. Data d => d -> r') -> Extended r -> r0 #

gmapQr :: (r' -> r0 -> r0) -> r0 -> (forall d. Data d => d -> r') -> Extended r -> r0 #

gmapQ :: (forall d. Data d => d -> u) -> Extended r -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Extended r -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Extended r -> m (Extended r) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Extended r -> m (Extended r) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Extended r -> m (Extended r) #

(Num r, Ord r) => Num (Extended r)

Note that Extended r is not a field, nor a ring.

PosInf + NegInf is left undefined as usual, but we define 0 * PosInf = 0 * NegInf = 0 by following the convention of probability or measure theory.

Instance details

Defined in Data.ExtendedReal

Ord r => Ord (Extended r) 
Instance details

Defined in Data.ExtendedReal

Methods

compare :: Extended r -> Extended r -> Ordering #

(<) :: Extended r -> Extended r -> Bool #

(<=) :: Extended r -> Extended r -> Bool #

(>) :: Extended r -> Extended r -> Bool #

(>=) :: Extended r -> Extended r -> Bool #

max :: Extended r -> Extended r -> Extended r #

min :: Extended r -> Extended r -> Extended r #

Read r => Read (Extended r) 
Instance details

Defined in Data.ExtendedReal

Show r => Show (Extended r) 
Instance details

Defined in Data.ExtendedReal

Methods

showsPrec :: Int -> Extended r -> ShowS #

show :: Extended r -> String #

showList :: [Extended r] -> ShowS #

Hashable r => Hashable (Extended r) 
Instance details

Defined in Data.ExtendedReal

Methods

hashWithSalt :: Int -> Extended r -> Int #

hash :: Extended r -> Int #

NFData r => NFData (Extended r) 
Instance details

Defined in Data.ExtendedReal

Methods

rnf :: Extended r -> () #

interval #

Arguments

:: Ord r 
=> (Extended r, Bool)

lower bound and whether it is included

-> (Extended r, Bool)

upper bound and whether it is included

-> Interval r 

smart constructor for Interval

(<=..<=) infix 5 #

Arguments

:: Ord r 
=> Extended r

lower bound l

-> Extended r

upper bound u

-> Interval r 

closed interval [l,u]

(<..<=) infix 5 #

Arguments

:: Ord r 
=> Extended r

lower bound l

-> Extended r

upper bound u

-> Interval r 

left-open right-closed interval (l,u]

(<=..<) infix 5 #

Arguments

:: Ord r 
=> Extended r

lower bound l

-> Extended r

upper bound u

-> Interval r 

left-closed right-open interval [l, u)

(<..<) infix 5 #

Arguments

:: Ord r 
=> Extended r

lower bound l

-> Extended r

upper bound u

-> Interval r 

open interval (l, u)

Types

type IntervalEnd a = (Extended a, Bool) Source #

Upper or lower end of Interval. The Bool field is True if the end is inclusive.

Since: 0.3.2.0

type ErrorMsg = String Source #

Error message type.

Parsers

parseTimeIntervalEnd :: String -> Either ErrorMsg (IntervalEnd Timestamp) Source #

Parse the String into an end of time interval. It uses parseIntervalEnd.

If the String is prefixed with 'i', the end is inclusive. If the prefix is 'x', the end is exclusive. Without such prefix, the end is inclusive by default.

Timestamp is parsed by parseTimestamp. Positive infinity is expressed as '+inf' (note that '+' is mandatory), and negative infinity as '-inf'.

>>> parseTimeIntervalEnd "2019-10-09T12:03:22"
Right (Finite (Timestamp {epochTime = 1570622602000, timeZone = Nothing}),True)
>>> parseTimeIntervalEnd "i2019-10-09T12:03:22"
Right (Finite (Timestamp {epochTime = 1570622602000, timeZone = Nothing}),True)
>>> parseTimeIntervalEnd "x2019-10-09T12:03:22"
Right (Finite (Timestamp {epochTime = 1570622602000, timeZone = Nothing}),False)
>>> parseTimeIntervalEnd "+inf"
Right (PosInf,True)
>>> parseTimeIntervalEnd "i+inf"
Right (PosInf,True)
>>> parseTimeIntervalEnd "x+inf"
Right (PosInf,False)
>>> parseTimeIntervalEnd "-inf"
Right (NegInf,True)
>>> parseTimeIntervalEnd "i-inf"
Right (NegInf,True)
>>> parseTimeIntervalEnd "x-inf"
Right (NegInf,False)

Since: 0.3.2.0

parseIntervalEnd Source #

Arguments

:: (String -> Either ErrorMsg a)

parser for the type variable a

-> String

input to be parsed

-> Either ErrorMsg (IntervalEnd a) 

Parse the String into IntervalEnd a, with the user-supplied parser for a. See parseTimeIntervalEnd for example.

Since: 0.3.2.0

Utility

secUpTo :: Int64 -> Timestamp -> Interval Timestamp Source #

s secUpTo ts returns the time interval of length s (in seconds) and up to ts. The interval is inclusive for both ends.

Since: 0.2.0.0

secSince Source #

Arguments

:: Int64

duration in seconds

-> IntervalEnd Timestamp

the start of the interval

-> Interval Timestamp 

d secSince ts returns the time interval of length d seconds from the timestamp ts. If ts is inclusive (exclusive), the end of the interval is exclusive (inclusive), respectively.

>>> 60 `secSince` (Finite $ fromEpochMillisecond 1000, True)
Finite (Timestamp {epochTime = 1000, timeZone = Nothing}) <=..< Finite (Timestamp {epochTime = 61000, timeZone = Nothing})
>>> 60 `secSince` (Finite $ fromEpochMillisecond 1000, False)
Finite (Timestamp {epochTime = 1000, timeZone = Nothing}) <..<= Finite (Timestamp {epochTime = 61000, timeZone = Nothing})
>>> 60 `secSince` (PosInf, False)
empty
>>> 60 `secSince` (NegInf, False)
empty

Since: 0.3.3.0

secUntil Source #

Arguments

:: Int64

duration in seconds

-> IntervalEnd Timestamp

the end of the interval

-> Interval Timestamp 

d secUntil ts returns the time interval of length d seconds up to the timestamp ts. If ts is inclusive (exclusive), the start of the interval is exclusive (inclusive), respectively.

>>> 60 `secUntil` (Finite $ fromEpochMillisecond 150000, True)
Finite (Timestamp {epochTime = 90000, timeZone = Nothing}) <..<= Finite (Timestamp {epochTime = 150000, timeZone = Nothing})
>>> 60 `secUntil` (Finite $ fromEpochMillisecond 150000, False)
Finite (Timestamp {epochTime = 90000, timeZone = Nothing}) <=..< Finite (Timestamp {epochTime = 150000, timeZone = Nothing})
>>> 60 `secUntil` (PosInf, False)
empty
>>> 60 `secUntil` (NegInf, False)
empty

Since: 0.3.3.0