{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE Strict #-}
module Data.FMIndex (
bytestringToBWTToFMIndexB,
bytestringToBWTToFMIndexT,
textToBWTToFMIndexB,
textToBWTToFMIndexT,
textBWTToFMIndexB,
bytestringBWTToFMIndexB,
textBWTToFMIndexT,
bytestringBWTToFMIndexT,
textToFMIndexB,
bytestringToFMIndexB,
textToFMIndexT,
bytestringToFMIndexT,
bytestringFromBWTFromFMIndexB,
bytestringFromBWTFromFMIndexT,
textFromBWTFromFMIndexB,
textFromBWTFromFMIndexT,
textBWTFromFMIndexT,
bytestringBWTFromFMIndexT,
textBWTFromFMIndexB,
bytestringBWTFromFMIndexB,
textFromFMIndexB,
bytestringFromFMIndexB,
textFromFMIndexT,
bytestringFromFMIndexT,
bytestringFMIndexCount,
textFMIndexCount,
bytestringFMIndexLocate,
textFMIndexLocate
) where
import Data.BWT
import Data.BWT.Internal
import Data.FMIndex.Internal
import Control.Monad()
import Control.Monad.ST as CMST
import Control.Monad.State.Strict()
import Data.ByteString as BS
import Data.ByteString.Char8 as BSC8 (singleton,uncons,unpack)
import Data.Char()
import Data.Foldable()
import Data.Maybe as DMaybe (isNothing,fromJust)
import Data.Sequence as DS (Seq(..),ViewL(..),fromList,index,viewl,(<|))
import Data.STRef()
import Data.Text as DText
import Data.Text.Encoding as DTE (decodeUtf8,encodeUtf8)
import Data.Word (Word8)
import Prelude as P
bytestringToBWTToFMIndexB :: ByteString ->
FMIndexB
bytestringToBWTToFMIndexB :: ByteString -> FMIndexB
bytestringToBWTToFMIndexB ByteString
xs = BWTMatrix Word8 -> BWT Word8 -> FMIndexB
bytestringBWTToFMIndexB (forall a. Ord a => [a] -> BWTMatrix a
createBWTMatrix forall a b. (a -> b) -> a -> b
$ ByteString -> [Word8]
BS.unpack ByteString
xs)
(ByteString -> BWT Word8
bytestringToBWT ByteString
xs)
bytestringToBWTToFMIndexT :: ByteString ->
FMIndexT
bytestringToBWTToFMIndexT :: ByteString -> FMIndexT
bytestringToBWTToFMIndexT ByteString
xs = BWTMatrix Word8 -> BWT Word8 -> FMIndexT
bytestringBWTToFMIndexT (forall a. Ord a => [a] -> BWTMatrix a
createBWTMatrix forall a b. (a -> b) -> a -> b
$ ByteString -> [Word8]
BS.unpack ByteString
xs)
(ByteString -> BWT Word8
bytestringToBWT ByteString
xs)
textToBWTToFMIndexB :: Text ->
FMIndexB
textToBWTToFMIndexB :: Text -> FMIndexB
textToBWTToFMIndexB Text
xs = BWTMatrix Word8 -> TextBWT -> FMIndexB
textBWTToFMIndexB (forall a. Ord a => [a] -> BWTMatrix a
createBWTMatrix forall a b. (a -> b) -> a -> b
$ ByteString -> [Word8]
BS.unpack forall a b. (a -> b) -> a -> b
$ Text -> ByteString
DTE.encodeUtf8 Text
xs)
(Text -> TextBWT
textToBWT Text
xs)
textToBWTToFMIndexT :: Text ->
FMIndexT
textToBWTToFMIndexT :: Text -> FMIndexT
textToBWTToFMIndexT Text
xs = BWTMatrix Word8 -> TextBWT -> FMIndexT
textBWTToFMIndexT (forall a. Ord a => [a] -> BWTMatrix a
createBWTMatrix forall a b. (a -> b) -> a -> b
$ ByteString -> [Word8]
BS.unpack forall a b. (a -> b) -> a -> b
$ Text -> ByteString
DTE.encodeUtf8 Text
xs)
(Text -> TextBWT
textToBWT Text
xs)
textBWTToFMIndexB :: BWTMatrix Word8
-> TextBWT
-> FMIndexB
textBWTToFMIndexB :: BWTMatrix Word8 -> TextBWT -> FMIndexB
textBWTToFMIndexB (BWTMatrix Seq (Seq (Maybe Word8))
DS.Empty) TextBWT
_ = (CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB forall a. Seq a
DS.Empty,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB forall a. Seq a
DS.Empty)
textBWTToFMIndexB BWTMatrix Word8
bwm TextBWT
xs = do
let occckb :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
occckb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
PBOccCKSeqB
-> ST s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
seqToOccCKB PBOccCKSeqB
xss
let ccb :: Seq (Int, Maybe ByteString)
ccb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. PBOccCKSeqB -> ST s (Seq (Int, Maybe ByteString))
seqToCcB PBOccCKSeqB
bwmff
(CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB Seq (Int, Maybe ByteString)
ccb,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
occckb)
where
bwmf :: Seq (Maybe Word8)
bwmf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Seq (Maybe Word8)
x -> case forall a. Seq a -> ViewL a
viewl Seq (Maybe Word8)
x of
ViewL (Maybe Word8)
EmptyL -> forall a. Maybe a
Nothing
(Maybe Word8
xh DS.:< Seq (Maybe Word8)
_) -> Maybe Word8
xh
) forall a b. (a -> b) -> a -> b
$
(\(BWTMatrix Seq (Seq (Maybe Word8))
m) -> Seq (Seq (Maybe Word8))
m) BWTMatrix Word8
bwm
bwmff :: PBOccCKSeqB
bwmff = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
) Seq (Maybe Word8)
bwmf
xss :: PBOccCKSeqB
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
)
((\(BWT Seq (Maybe Word8)
t) -> Seq (Maybe Word8)
t) forall a b. (a -> b) -> a -> b
$
((\(TextBWT BWT Word8
t) -> BWT Word8
t) TextBWT
xs))
bytestringBWTToFMIndexB :: BWTMatrix Word8
-> BWT Word8
-> FMIndexB
bytestringBWTToFMIndexB :: BWTMatrix Word8 -> BWT Word8 -> FMIndexB
bytestringBWTToFMIndexB (BWTMatrix Seq (Seq (Maybe Word8))
DS.Empty) BWT Word8
_ = (CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB forall a. Seq a
DS.Empty,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB forall a. Seq a
DS.Empty)
bytestringBWTToFMIndexB BWTMatrix Word8
bwm BWT Word8
xs = do
let occckb :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
occckb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
PBOccCKSeqB
-> ST s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
seqToOccCKB PBOccCKSeqB
xss
let ccb :: Seq (Int, Maybe ByteString)
ccb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. PBOccCKSeqB -> ST s (Seq (Int, Maybe ByteString))
seqToCcB PBOccCKSeqB
bwmff
(CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB Seq (Int, Maybe ByteString)
ccb,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
occckb)
where
bwmf :: Seq (Maybe Word8)
bwmf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Seq (Maybe Word8)
x -> case forall a. Seq a -> ViewL a
viewl Seq (Maybe Word8)
x of
ViewL (Maybe Word8)
EmptyL -> forall a. Maybe a
Nothing
(Maybe Word8
xh DS.:< Seq (Maybe Word8)
_) -> Maybe Word8
xh
) forall a b. (a -> b) -> a -> b
$
(\(BWTMatrix Seq (Seq (Maybe Word8))
m) -> Seq (Seq (Maybe Word8))
m) BWTMatrix Word8
bwm
bwmff :: PBOccCKSeqB
bwmff = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
) Seq (Maybe Word8)
bwmf
xss :: PBOccCKSeqB
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
)
((\(BWT Seq (Maybe Word8)
t) -> Seq (Maybe Word8)
t) BWT Word8
xs)
textBWTToFMIndexT :: BWTMatrix Word8
-> TextBWT
-> FMIndexT
textBWTToFMIndexT :: BWTMatrix Word8 -> TextBWT -> FMIndexT
textBWTToFMIndexT (BWTMatrix Seq (Seq (Maybe Word8))
DS.Empty) TextBWT
_ = (CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT forall a. Seq a
DS.Empty,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT forall a. Seq a
DS.Empty)
textBWTToFMIndexT BWTMatrix Word8
bwm TextBWT
xs = do
let occckt :: Seq (Maybe Text, Seq (Int, Int, Maybe Text))
occckt = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
PTOccCKSeqT -> ST s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
seqToOccCKT PTOccCKSeqT
xss
let cct :: Seq (Int, Maybe Text)
cct = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. PTOccCKSeqT -> ST s (Seq (Int, Maybe Text))
seqToCcT PTOccCKSeqT
bwmff
(CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT Seq (Int, Maybe Text)
cct,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
occckt)
where
bwmf :: Seq (Maybe Word8)
bwmf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Seq (Maybe Word8)
x -> case forall a. Seq a -> ViewL a
viewl Seq (Maybe Word8)
x of
ViewL (Maybe Word8)
EmptyL -> forall a. Maybe a
Nothing
(Maybe Word8
xh DS.:< Seq (Maybe Word8)
_) -> Maybe Word8
xh
) forall a b. (a -> b) -> a -> b
$
(\(BWTMatrix Seq (Seq (Maybe Word8))
m) -> Seq (Seq (Maybe Word8))
m) BWTMatrix Word8
bwm
bwmff :: PTOccCKSeqT
bwmff = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
) Seq (Maybe Word8)
bwmf
xss :: PTOccCKSeqT
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
)
((\(BWT Seq (Maybe Word8)
t) -> Seq (Maybe Word8)
t) forall a b. (a -> b) -> a -> b
$
((\(TextBWT BWT Word8
t) -> BWT Word8
t) TextBWT
xs))
bytestringBWTToFMIndexT :: BWTMatrix Word8
-> BWT Word8
-> FMIndexT
bytestringBWTToFMIndexT :: BWTMatrix Word8 -> BWT Word8 -> FMIndexT
bytestringBWTToFMIndexT (BWTMatrix Seq (Seq (Maybe Word8))
DS.Empty) BWT Word8
_ = (CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT forall a. Seq a
DS.Empty,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT forall a. Seq a
DS.Empty)
bytestringBWTToFMIndexT BWTMatrix Word8
bwm BWT Word8
xs = do
let occckt :: Seq (Maybe Text, Seq (Int, Int, Maybe Text))
occckt = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
PTOccCKSeqT -> ST s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
seqToOccCKT PTOccCKSeqT
xss
let cct :: Seq (Int, Maybe Text)
cct = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. PTOccCKSeqT -> ST s (Seq (Int, Maybe Text))
seqToCcT PTOccCKSeqT
bwmff
(CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT Seq (Int, Maybe Text)
cct,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
occckt)
where
bwmf :: Seq (Maybe Word8)
bwmf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Seq (Maybe Word8)
x -> case forall a. Seq a -> ViewL a
viewl Seq (Maybe Word8)
x of
ViewL (Maybe Word8)
EmptyL -> forall a. Maybe a
Nothing
(Maybe Word8
xh DS.:< Seq (Maybe Word8)
_) -> Maybe Word8
xh
) forall a b. (a -> b) -> a -> b
$
(\(BWTMatrix Seq (Seq (Maybe Word8))
m) -> Seq (Seq (Maybe Word8))
m) BWTMatrix Word8
bwm
bwmff :: PTOccCKSeqT
bwmff = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
) Seq (Maybe Word8)
bwmf
xss :: PTOccCKSeqT
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
)
((\(BWT Seq (Maybe Word8)
t) -> Seq (Maybe Word8)
t) BWT Word8
xs)
textToFMIndexB :: BWTMatrix Text
-> Seq (Maybe Text)
-> FMIndexB
textToFMIndexB :: BWTMatrix Text -> PTOccCKSeqT -> FMIndexB
textToFMIndexB (BWTMatrix Seq PTOccCKSeqT
DS.Empty) PTOccCKSeqT
_ = (CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB forall a. Seq a
DS.Empty,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB forall a. Seq a
DS.Empty)
textToFMIndexB BWTMatrix Text
_ PTOccCKSeqT
DS.Empty = (CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB forall a. Seq a
DS.Empty,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB forall a. Seq a
DS.Empty)
textToFMIndexB BWTMatrix Text
bwm PTOccCKSeqT
xs = do
let occckb :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
occckb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
PBOccCKSeqB
-> ST s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
seqToOccCKB PBOccCKSeqB
xss
let ccb :: Seq (Int, Maybe ByteString)
ccb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. PBOccCKSeqB -> ST s (Seq (Int, Maybe ByteString))
seqToCcB PBOccCKSeqB
bwmff
(CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB Seq (Int, Maybe ByteString)
ccb,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
occckb)
where
bwmf :: PTOccCKSeqT
bwmf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\PTOccCKSeqT
x -> case forall a. Seq a -> ViewL a
viewl PTOccCKSeqT
x of
ViewL (Maybe Text)
EmptyL -> forall a. Maybe a
Nothing
(Maybe Text
xh DS.:< PTOccCKSeqT
_) -> Maybe Text
xh
) forall a b. (a -> b) -> a -> b
$
(\(BWTMatrix Seq PTOccCKSeqT
m) -> Seq PTOccCKSeqT
m) BWTMatrix Text
bwm
bwmff :: PBOccCKSeqB
bwmff = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x
) PTOccCKSeqT
bwmf
xss :: PBOccCKSeqB
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x
)
PTOccCKSeqT
xs
bytestringToFMIndexB :: BWTMatrix ByteString
-> Seq (Maybe ByteString)
-> FMIndexB
bytestringToFMIndexB :: BWTMatrix ByteString -> PBOccCKSeqB -> FMIndexB
bytestringToFMIndexB (BWTMatrix Seq PBOccCKSeqB
DS.Empty) PBOccCKSeqB
_ = (CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB forall a. Seq a
DS.Empty,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB forall a. Seq a
DS.Empty)
bytestringToFMIndexB BWTMatrix ByteString
_ PBOccCKSeqB
DS.Empty = (CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB forall a. Seq a
DS.Empty,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB forall a. Seq a
DS.Empty)
bytestringToFMIndexB BWTMatrix ByteString
bwm PBOccCKSeqB
xs = do
let occckb :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
occckb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
PBOccCKSeqB
-> ST s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
seqToOccCKB PBOccCKSeqB
xs
let ccb :: Seq (Int, Maybe ByteString)
ccb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. PBOccCKSeqB -> ST s (Seq (Int, Maybe ByteString))
seqToCcB PBOccCKSeqB
bwmf
(CcB, OccCKB) -> FMIndexB
FMIndexB (Seq (Int, Maybe ByteString) -> CcB
CcB Seq (Int, Maybe ByteString)
ccb,Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> OccCKB
OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
occckb)
where
bwmf :: PBOccCKSeqB
bwmf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\PBOccCKSeqB
x -> case forall a. Seq a -> ViewL a
viewl PBOccCKSeqB
x of
ViewL (Maybe ByteString)
EmptyL -> forall a. Maybe a
Nothing
(Maybe ByteString
xh DS.:< PBOccCKSeqB
_) -> Maybe ByteString
xh
) forall a b. (a -> b) -> a -> b
$
(\(BWTMatrix Seq PBOccCKSeqB
m) -> Seq PBOccCKSeqB
m) BWTMatrix ByteString
bwm
textToFMIndexT :: BWTMatrix Text
-> Seq (Maybe Text)
-> FMIndexT
textToFMIndexT :: BWTMatrix Text -> PTOccCKSeqT -> FMIndexT
textToFMIndexT (BWTMatrix Seq PTOccCKSeqT
DS.Empty) PTOccCKSeqT
_ = (CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT forall a. Seq a
DS.Empty,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT forall a. Seq a
DS.Empty)
textToFMIndexT BWTMatrix Text
_ PTOccCKSeqT
DS.Empty = (CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT forall a. Seq a
DS.Empty,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT forall a. Seq a
DS.Empty)
textToFMIndexT BWTMatrix Text
bwm PTOccCKSeqT
xs = do
let occckt :: Seq (Maybe Text, Seq (Int, Int, Maybe Text))
occckt = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
PTOccCKSeqT -> ST s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
seqToOccCKT PTOccCKSeqT
xs
let cct :: Seq (Int, Maybe Text)
cct = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. PTOccCKSeqT -> ST s (Seq (Int, Maybe Text))
seqToCcT PTOccCKSeqT
bwmf
(CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT Seq (Int, Maybe Text)
cct,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
occckt)
where
bwmf :: PTOccCKSeqT
bwmf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\PTOccCKSeqT
x -> case forall a. Seq a -> ViewL a
viewl PTOccCKSeqT
x of
ViewL (Maybe Text)
EmptyL -> forall a. Maybe a
Nothing
(Maybe Text
xh DS.:< PTOccCKSeqT
_) -> Maybe Text
xh
) forall a b. (a -> b) -> a -> b
$
(\(BWTMatrix Seq PTOccCKSeqT
m) -> Seq PTOccCKSeqT
m) BWTMatrix Text
bwm
bytestringToFMIndexT :: BWTMatrix ByteString
-> Seq (Maybe ByteString)
-> FMIndexT
bytestringToFMIndexT :: BWTMatrix ByteString -> PBOccCKSeqB -> FMIndexT
bytestringToFMIndexT (BWTMatrix Seq PBOccCKSeqB
DS.Empty) PBOccCKSeqB
_ = (CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT forall a. Seq a
DS.Empty,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT forall a. Seq a
DS.Empty)
bytestringToFMIndexT BWTMatrix ByteString
_ PBOccCKSeqB
DS.Empty = (CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT forall a. Seq a
DS.Empty,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT forall a. Seq a
DS.Empty)
bytestringToFMIndexT BWTMatrix ByteString
bwm PBOccCKSeqB
xs = do
let occckt :: Seq (Maybe Text, Seq (Int, Int, Maybe Text))
occckt = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
PTOccCKSeqT -> ST s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
seqToOccCKT PTOccCKSeqT
xss
let cct :: Seq (Int, Maybe Text)
cct = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. PTOccCKSeqT -> ST s (Seq (Int, Maybe Text))
seqToCcT PTOccCKSeqT
bwmff
(CcT, OccCKT) -> FMIndexT
FMIndexT (Seq (Int, Maybe Text) -> CcT
CcT Seq (Int, Maybe Text)
cct,Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> OccCKT
OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
occckt)
where
bwmf :: PBOccCKSeqB
bwmf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\PBOccCKSeqB
x -> case forall a. Seq a -> ViewL a
viewl PBOccCKSeqB
x of
ViewL (Maybe ByteString)
EmptyL -> forall a. Maybe a
Nothing
(Maybe ByteString
xh DS.:< PBOccCKSeqB
_) -> Maybe ByteString
xh
) forall a b. (a -> b) -> a -> b
$
(\(BWTMatrix Seq PBOccCKSeqB
m) -> Seq PBOccCKSeqB
m) BWTMatrix ByteString
bwm
bwmff :: PTOccCKSeqT
bwmff = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe ByteString
x -> if | forall a. Maybe a -> Bool
isNothing Maybe ByteString
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
x
) PBOccCKSeqB
bwmf
xss :: PTOccCKSeqT
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe ByteString
x -> if | forall a. Maybe a -> Bool
isNothing Maybe ByteString
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
x
)
PBOccCKSeqB
xs
bytestringFromBWTFromFMIndexB :: FMIndexB
-> ByteString
bytestringFromBWTFromFMIndexB :: FMIndexB -> ByteString
bytestringFromBWTFromFMIndexB = BWT ByteString -> ByteString
bytestringFromByteStringBWT forall b c a. (b -> c) -> (a -> b) -> a -> c
. FMIndexB -> BWT ByteString
bytestringBWTFromFMIndexB
bytestringFromBWTFromFMIndexT :: FMIndexT
-> ByteString
bytestringFromBWTFromFMIndexT :: FMIndexT -> ByteString
bytestringFromBWTFromFMIndexT FMIndexT
xs = BWT ByteString -> ByteString
bytestringFromByteStringBWT forall a b. (a -> b) -> a -> b
$
forall a. Seq (Maybe a) -> BWT a
BWT forall a b. (a -> b) -> a -> b
$
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x
)
forall a b. (a -> b) -> a -> b
$
((\(BWT PTOccCKSeqT
t) -> PTOccCKSeqT
t) (FMIndexT -> BWT Text
textBWTFromFMIndexT FMIndexT
xs))
textFromBWTFromFMIndexB :: FMIndexB
-> Text
textFromBWTFromFMIndexB :: FMIndexB -> Text
textFromBWTFromFMIndexB = ByteString -> Text
DTE.decodeUtf8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. BWT ByteString -> ByteString
bytestringFromByteStringBWT forall b c a. (b -> c) -> (a -> b) -> a -> c
. FMIndexB -> BWT ByteString
bytestringBWTFromFMIndexB
textFromBWTFromFMIndexT :: FMIndexT
-> Text
textFromBWTFromFMIndexT :: FMIndexT -> Text
textFromBWTFromFMIndexT = ByteString -> Text
DTE.decodeUtf8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. BWT ByteString -> ByteString
bytestringFromByteStringBWT forall b c a. (b -> c) -> (a -> b) -> a -> c
. FMIndexT -> BWT ByteString
bytestringBWTFromFMIndexT
textBWTFromFMIndexT :: FMIndexT
-> BWT Text
textBWTFromFMIndexT :: FMIndexT -> BWT Text
textBWTFromFMIndexT (FMIndexT (CcT Seq (Int, Maybe Text)
DS.Empty,OccCKT
_)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
textBWTFromFMIndexT (FMIndexT (CcT
_,OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
DS.Empty)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
textBWTFromFMIndexT FMIndexT
xs =
forall a. Seq (Maybe a) -> BWT a
BWT (FMIndexT -> PTOccCKSeqT
seqFromFMIndexT FMIndexT
xs)
bytestringBWTFromFMIndexT :: FMIndexT
-> BWT ByteString
bytestringBWTFromFMIndexT :: FMIndexT -> BWT ByteString
bytestringBWTFromFMIndexT (FMIndexT (CcT Seq (Int, Maybe Text)
DS.Empty,OccCKT
_)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
bytestringBWTFromFMIndexT (FMIndexT (CcT
_,OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
DS.Empty)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
bytestringBWTFromFMIndexT FMIndexT
xs = do
let originalbwtb :: PTOccCKSeqT
originalbwtb = FMIndexT -> PTOccCKSeqT
seqFromFMIndexT FMIndexT
xs
forall a. Seq (Maybe a) -> BWT a
BWT (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x
) PTOccCKSeqT
originalbwtb)
textBWTFromFMIndexB :: FMIndexB
-> BWT Text
textBWTFromFMIndexB :: FMIndexB -> BWT Text
textBWTFromFMIndexB (FMIndexB (CcB Seq (Int, Maybe ByteString)
DS.Empty,OccCKB
_)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
textBWTFromFMIndexB (FMIndexB (CcB
_,OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
DS.Empty)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
textBWTFromFMIndexB FMIndexB
xs = do
let originalbwtt :: PBOccCKSeqB
originalbwtt = FMIndexB -> PBOccCKSeqB
seqFromFMIndexB FMIndexB
xs
forall a. Seq (Maybe a) -> BWT a
BWT (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe ByteString
x -> if | forall a. Maybe a -> Bool
isNothing Maybe ByteString
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
x
) PBOccCKSeqB
originalbwtt)
bytestringBWTFromFMIndexB :: FMIndexB
-> BWT ByteString
bytestringBWTFromFMIndexB :: FMIndexB -> BWT ByteString
bytestringBWTFromFMIndexB (FMIndexB (CcB Seq (Int, Maybe ByteString)
DS.Empty,OccCKB
_)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
bytestringBWTFromFMIndexB (FMIndexB (CcB
_,OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
DS.Empty)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
bytestringBWTFromFMIndexB FMIndexB
xs =
forall a. Seq (Maybe a) -> BWT a
BWT (FMIndexB -> PBOccCKSeqB
seqFromFMIndexB FMIndexB
xs)
textFromFMIndexB :: FMIndexB
-> Seq (Maybe Text)
textFromFMIndexB :: FMIndexB -> PTOccCKSeqT
textFromFMIndexB (FMIndexB (CcB Seq (Int, Maybe ByteString)
DS.Empty,OccCKB
_)) = forall a. Seq a
DS.Empty
textFromFMIndexB (FMIndexB (CcB
_,OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
DS.Empty)) = forall a. Seq a
DS.Empty
textFromFMIndexB FMIndexB
xs = do
let originalt :: PBOccCKSeqB
originalt = FMIndexB -> PBOccCKSeqB
seqFromFMIndexB FMIndexB
xs
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe ByteString
x -> if | forall a. Maybe a -> Bool
isNothing Maybe ByteString
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
x
) PBOccCKSeqB
originalt
bytestringFromFMIndexB :: FMIndexB
-> Seq (Maybe ByteString)
bytestringFromFMIndexB :: FMIndexB -> PBOccCKSeqB
bytestringFromFMIndexB (FMIndexB (CcB Seq (Int, Maybe ByteString)
DS.Empty,OccCKB
_)) = forall a. Seq a
DS.Empty
bytestringFromFMIndexB (FMIndexB (CcB
_,OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
DS.Empty)) = forall a. Seq a
DS.Empty
bytestringFromFMIndexB FMIndexB
xs =
FMIndexB -> PBOccCKSeqB
seqFromFMIndexB FMIndexB
xs
textFromFMIndexT :: FMIndexT
-> Seq (Maybe Text)
textFromFMIndexT :: FMIndexT -> PTOccCKSeqT
textFromFMIndexT (FMIndexT (CcT Seq (Int, Maybe Text)
DS.Empty,OccCKT
_)) = forall a. Seq a
DS.Empty
textFromFMIndexT (FMIndexT (CcT
_,OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
DS.Empty)) = forall a. Seq a
DS.Empty
textFromFMIndexT FMIndexT
xs =
FMIndexT -> PTOccCKSeqT
seqFromFMIndexT FMIndexT
xs
bytestringFromFMIndexT :: FMIndexT
-> Seq (Maybe ByteString)
bytestringFromFMIndexT :: FMIndexT -> PBOccCKSeqB
bytestringFromFMIndexT (FMIndexT (CcT Seq (Int, Maybe Text)
DS.Empty,OccCKT
_)) = forall a. Seq a
DS.Empty
bytestringFromFMIndexT (FMIndexT (CcT
_,OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
DS.Empty)) = forall a. Seq a
DS.Empty
bytestringFromFMIndexT FMIndexT
xs = do
let originalb :: PTOccCKSeqT
originalb = FMIndexT -> PTOccCKSeqT
seqFromFMIndexT FMIndexT
xs
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x
) PTOccCKSeqT
originalb
bytestringFMIndexCount :: [ByteString]
-> ByteString
-> Seq (ByteString,CIntB)
bytestringFMIndexCount :: [ByteString] -> ByteString -> Seq (ByteString, CIntB)
bytestringFMIndexCount [] ByteString
_ = forall a. Seq a
DS.Empty
bytestringFMIndexCount [ByteString]
_ (ByteString -> Maybe (Char, ByteString)
BSC8.uncons -> Maybe (Char, ByteString)
Nothing) = forall a. Seq a
DS.Empty
bytestringFMIndexCount [ByteString]
allpats ByteString
input = do
let bfmindex :: FMIndexB
bfmindex = ByteString -> FMIndexB
bytestringToBWTToFMIndexB ByteString
input
[ByteString] -> FMIndexB -> Seq (ByteString, CIntB)
iBFMC [ByteString]
allpats
FMIndexB
bfmindex
where
iBFMC :: [ByteString] -> FMIndexB -> Seq (ByteString, CIntB)
iBFMC [] FMIndexB
_ = forall a. Seq a
DS.Empty
iBFMC (ByteString
currentpat:[ByteString]
restofpats) FMIndexB
bfmi = do
let patternf :: Seq ByteString
patternf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char -> ByteString
BSC8.singleton) forall a b. (a -> b) -> a -> b
$
forall a. [a] -> Seq a
DS.fromList forall a b. (a -> b) -> a -> b
$
ByteString -> [Char]
BSC8.unpack ByteString
currentpat
let countf :: CIntB
countf = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ forall s. Seq ByteString -> FMIndexB -> ST s CIntB
countFMIndexB Seq ByteString
patternf
FMIndexB
bfmi
(ByteString
currentpat,CIntB
countf) forall a. a -> Seq a -> Seq a
DS.<| ([ByteString] -> FMIndexB -> Seq (ByteString, CIntB)
iBFMC [ByteString]
restofpats FMIndexB
bfmi)
textFMIndexCount :: [Text]
-> Text
-> Seq (Text,CIntT)
textFMIndexCount :: [Text] -> Text -> Seq (Text, CIntB)
textFMIndexCount [] Text
_ = forall a. Seq a
DS.Empty
textFMIndexCount [Text]
_ Text
"" = forall a. Seq a
DS.Empty
textFMIndexCount [Text]
allpats Text
input = do
let tfmindex :: FMIndexT
tfmindex = Text -> FMIndexT
textToBWTToFMIndexT Text
input
[Text] -> FMIndexT -> Seq (Text, CIntB)
iTFMC [Text]
allpats
FMIndexT
tfmindex
where
iTFMC :: [Text] -> FMIndexT -> Seq (Text, CIntB)
iTFMC [] FMIndexT
_ = forall a. Seq a
DS.Empty
iTFMC (Text
currentpat:[Text]
restofpats) FMIndexT
tfmi = do
let patternf :: Seq Text
patternf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char -> Text
DText.singleton) forall a b. (a -> b) -> a -> b
$
forall a. [a] -> Seq a
DS.fromList forall a b. (a -> b) -> a -> b
$
Text -> [Char]
DText.unpack Text
currentpat
let countf :: CIntB
countf = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ forall s. Seq Text -> FMIndexT -> ST s CIntB
countFMIndexT Seq Text
patternf
FMIndexT
tfmi
(Text
currentpat,CIntB
countf) forall a. a -> Seq a -> Seq a
DS.<| ([Text] -> FMIndexT -> Seq (Text, CIntB)
iTFMC [Text]
restofpats FMIndexT
tfmi)
bytestringFMIndexLocate :: [ByteString]
-> ByteString
-> Seq (ByteString,LIntB)
bytestringFMIndexLocate :: [ByteString] -> ByteString -> Seq (ByteString, LIntB)
bytestringFMIndexLocate [] ByteString
_ = forall a. Seq a
DS.Empty
bytestringFMIndexLocate [ByteString]
_ (ByteString -> Maybe (Char, ByteString)
BSC8.uncons -> Maybe (Char, ByteString)
Nothing) = forall a. Seq a
DS.Empty
bytestringFMIndexLocate [ByteString]
allpats ByteString
input = do
let bytestringsa :: SuffixArray ByteString
bytestringsa = forall a. Ord a => Seq a -> SuffixArray a
createSuffixArray forall a b. (a -> b) -> a -> b
$
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Word8 -> ByteString
BS.singleton) forall a b. (a -> b) -> a -> b
$
forall a. [a] -> Seq a
DS.fromList forall a b. (a -> b) -> a -> b
$
ByteString -> [Word8]
BS.unpack ByteString
input
let bfmindex :: FMIndexB
bfmindex = ByteString -> FMIndexB
bytestringToBWTToFMIndexB ByteString
input
forall {a}.
[ByteString]
-> Seq (Suffix a) -> FMIndexB -> Seq (ByteString, LIntB)
iBFML [ByteString]
allpats
SuffixArray ByteString
bytestringsa
FMIndexB
bfmindex
where
iBFML :: [ByteString]
-> Seq (Suffix a) -> FMIndexB -> Seq (ByteString, LIntB)
iBFML [] Seq (Suffix a)
_ FMIndexB
_ = forall a. Seq a
DS.Empty
iBFML (ByteString
currentpat:[ByteString]
restofpats) Seq (Suffix a)
bsa FMIndexB
bfmi = do
let patternf :: Seq ByteString
patternf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char -> ByteString
BSC8.singleton) forall a b. (a -> b) -> a -> b
$
forall a. [a] -> Seq a
DS.fromList forall a b. (a -> b) -> a -> b
$
ByteString -> [Char]
BSC8.unpack ByteString
currentpat
let indices :: LIntB
indices = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ forall s. Seq ByteString -> FMIndexB -> ST s LIntB
locateFMIndexB Seq ByteString
patternf
FMIndexB
bfmi
let indicesf :: LIntB
indicesf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\CIntB
x -> if | forall a. Maybe a -> Bool
isNothing CIntB
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
forall a. Suffix a -> Int
suffixstartpos forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index Seq (Suffix a)
bsa ((forall a. HasCallStack => Maybe a -> a
fromJust CIntB
x) forall a. Num a => a -> a -> a
- Int
1)
) LIntB
indices
(ByteString
currentpat,LIntB
indicesf) forall a. a -> Seq a -> Seq a
DS.<| ([ByteString]
-> Seq (Suffix a) -> FMIndexB -> Seq (ByteString, LIntB)
iBFML [ByteString]
restofpats Seq (Suffix a)
bsa FMIndexB
bfmi)
textFMIndexLocate :: [Text]
-> Text
-> Seq (Text,LIntT)
textFMIndexLocate :: [Text] -> Text -> Seq (Text, LIntB)
textFMIndexLocate [] Text
_ = forall a. Seq a
DS.Empty
textFMIndexLocate [Text]
_ Text
"" = forall a. Seq a
DS.Empty
textFMIndexLocate [Text]
allpats Text
input = do
let textsa :: SuffixArray Text
textsa = forall a. Ord a => Seq a -> SuffixArray a
createSuffixArray forall a b. (a -> b) -> a -> b
$
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char -> Text
DText.singleton) forall a b. (a -> b) -> a -> b
$
forall a. [a] -> Seq a
DS.fromList forall a b. (a -> b) -> a -> b
$
Text -> [Char]
DText.unpack Text
input
let tfmindex :: FMIndexT
tfmindex = Text -> FMIndexT
textToBWTToFMIndexT Text
input
forall {a}.
[Text] -> Seq (Suffix a) -> FMIndexT -> Seq (Text, LIntB)
iTFML [Text]
allpats
SuffixArray Text
textsa
FMIndexT
tfmindex
where
iTFML :: [Text] -> Seq (Suffix a) -> FMIndexT -> Seq (Text, LIntB)
iTFML [] Seq (Suffix a)
_ FMIndexT
_ = forall a. Seq a
DS.Empty
iTFML (Text
currentpat:[Text]
restofpats) Seq (Suffix a)
tsa FMIndexT
tfmi = do
let patternf :: Seq Text
patternf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char -> Text
DText.singleton) forall a b. (a -> b) -> a -> b
$
forall a. [a] -> Seq a
DS.fromList forall a b. (a -> b) -> a -> b
$
Text -> [Char]
DText.unpack Text
currentpat
let indices :: LIntB
indices = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ forall s. Seq Text -> FMIndexT -> ST s LIntB
locateFMIndexT Seq Text
patternf
FMIndexT
tfmi
let indicesf :: LIntB
indicesf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\CIntB
x -> if | forall a. Maybe a -> Bool
isNothing CIntB
x
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
forall a. Suffix a -> Int
suffixstartpos forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index Seq (Suffix a)
tsa ((forall a. HasCallStack => Maybe a -> a
fromJust CIntB
x) forall a. Num a => a -> a -> a
- Int
1)
) LIntB
indices
(Text
currentpat,LIntB
indicesf) forall a. a -> Seq a -> Seq a
DS.<| ([Text] -> Seq (Suffix a) -> FMIndexT -> Seq (Text, LIntB)
iTFML [Text]
restofpats Seq (Suffix a)
tsa FMIndexT
tfmi)