BiobaseTurner 0.0.2.2 → 0.1.0.0

raw patch · 4 files changed

+269/−306 lines, 4 filesdep +BiobaseXNAdep +bytestringdep +bytestring-lexingdep −Biobasedep −HsToolsdep −ParsecToolsdep ~PrimitiveArraydep ~basedep ~splitPVP ok

version bump matches the API change (PVP)

Dependencies added: BiobaseXNA, bytestring, bytestring-lexing, filepath, iteratee

Dependencies removed: Biobase, HsTools, ParsecTools, filemanip, parsec, primitive

Dependency ranges changed: PrimitiveArray, base, split

API changes (from Hackage documentation)

Files

• Biobase/Turner.hs +58/−33
• Biobase/Turner/Import.hs +188/−121
• Biobase/Turner/Tables.hs +0/−133
• BiobaseTurner.cabal +23/−19

@@ -1,41 +1,66 @@-{-# LANGUAGE TypeSynonymInstances #-} --- | Mathews / Turner nearest neighbor energy tables for interactions between--- RNA-RNA and DNA-DNA. Using lazy tables for easy filling of missing data.--- Transform tables into uvectors for efficient access.--module Biobase.Turner where--import Biobase.RNA (Nucleotide)-import qualified Biobase.Turner.Tables as T------ | Data structure containing all necessary tables for the Turner 2004 model.--- Note the temperature, using an additional function, rescaling becomes--- possible. A Show and a Read instance are automatically derived but one--- should use the Turner and/or Vienna import/export facilities. All data uses--- complete tables, where any base can pair with any other. Missing data ('.'--- in tables) is given by 'Nothing', otherwise we have 'Just Int'.--- +-- | The 'Turner2004' data structure reflects the RNA (and DNA) energy+-- parameters known as the Turner 2004 data set.+-- -- In general, have a look here:--- \url{http://rna.urmc.rochester.edu/NNDB/turner04/index.html} where--- parameters are explained.--- --- Conversion from Turner to Vienna is only possible in one direction as a--- number of parameters are not used in Vienna RNA Folding.+-- <http://rna.urmc.rochester.edu/NNDB/turner04/index.html> where parameters+-- are explained. +module Biobase.Turner where +import Data.ByteString+import Data.Map as M --- We are missing tables for DNA-RNA data: helixdr.dat, stackdr.dat,--- stackdr.dh.  Several other files have unknown data, too. These are:--- dnadynalign*, fam\_hmm\_pars.dat, helix.dat, int22-exp.dh+import Biobase.Primary+import Biobase.Secondary+import Data.PrimitiveArray+import Data.PrimitiveArray.Ix -type TurnerTables = T.Turner2004 Basepair Nucleotide Double+-- | The parameters. Turner parameters are set by the Import module for+-- nucleotides n,a,c,g,u. All values that are not read (or are ".") will end up+-- with a value > 100K.+--+-- [1] Yes, such instances are easily created, but I don't want to pull in+-- another library and I don't want to create an Ix instance here.+--+-- TODO use 'Energy' instead of 'Double' -type TurnerEntropy  = TurnerTables-type TurnerEnthalpy = TurnerTables-type Temperature    = Double-type TurnerSet      = (Temperature,TurnerEntropy,TurnerEnthalpy)+data Turner2004 = Turner2004+  { stack :: PrimArray (Pair,Pair) Double+  , dangle3 :: PrimArray PN Double+  , dangle5 :: PrimArray PN Double+  , hairpinL :: PrimArray Int Double+  , hairpinMM :: PrimArray PNN Double+  , hairpinLookup :: M.Map ByteString Double+  , hairpinGGG :: Double+  , hairpinCslope :: Double+  , hairpinCintercept :: Double+  , hairpinC3 :: Double+  , bulgeL :: PrimArray Int Double+  , bulgeSingleC :: Double+  , iloop1x1 :: PrimArray (Pair,Pair,(Nuc,Nuc)) Double+  , iloop2x1 :: PrimArray (Pair,Pair,(Nuc,Nuc,Nuc)) Double+  , iloop2x2 :: PrimArray (Pair,Pair,(Nuc,Nuc,Nuc,Nuc)) Double -- yeah, 6-tuple ix instances :-( [1]+  , iloopMM :: PrimArray PNN Double+  , iloop2x3MM :: PrimArray PNN Double+  , iloop1xnMM :: PrimArray PNN Double+  , iloopL :: PrimArray Int Double+  , multiMM :: PrimArray PNN Double+  , ninio :: Double+  , maxNinio :: Double+  , multiOffset :: Double+  , multiNuc :: Double+  , multiHelix :: Double+  , multiAsym :: Double+  , multiStrain :: Double+  , extMM :: PrimArray PNN Double+  , coaxial :: PrimArray (Pair,Pair) Double -- no intervening unpaired nucleotides+  , coaxStack :: PrimArray PNN Double+  , tStackCoax :: PrimArray PNN Double+  , largeLoop :: Double+  , termAU :: Double+  , intermolecularInit :: Double+  } deriving (Read,Show) -type Basepair = (Nucleotide,Nucleotide)+type PNN = (Pair,Nuc,Nuc)+type PN  = (Pair,Nuc)

@@ -1,8 +1,8 @@ {-# LANGUAGE NoMonomorphismRestriction #-}+{-# LANGUAGE OverloadedStrings #-} --- | Turner file parser. Returns a Turner2004 data structure. We store data in--- the same way it is stored in the ViennaRNA package. Pairs are tuples--- however.+-- | Turner file parser. Returns a Turner2004 data structure. Requires an+-- annoying amount of boilerplate. -- -- How is 'stack' data stored: --@@ -32,145 +32,212 @@ -- --TODO not sure if dangle3/dangle5 are correctly split or if they should switch -module Biobase.Turner.Import-  ( parseTurner-  ) where+module Biobase.Turner.Import where -import Control.Applicative-import Control.Arrow (first)-import Control.Monad-import Data.Either-import Data.List.Split (splitEvery)-import Data.List (transpose)-import qualified Data.Map as M-import System.FilePath.Find-import Text.Parsec hiding ((<|>), many)-import Text.Parsec.String+import Control.Arrow+import Data.ByteString.Char8 as BS+import Data.ByteString.Lex.Double+import Data.Char+import Data.Iteratee as I+import Data.Iteratee.Char as I+import Data.Iteratee.IO as I+import Data.List.Split+import Data.Map as M+import qualified Data.List as L+import System.FilePath.Posix+import Data.Maybe (fromJust) -import Biobase.RNA-import Data.Ix.Tuple+import Biobase.Primary+import Biobase.Secondary import Data.PrimitiveArray-import Data.PrimitiveArray.Ix-import Text.Parsec.Numbers -import Biobase.Turner.Tables+import Biobase.Turner   --- * Associate every file with a parse.+-- * -minp = (nucA,nucA)-maxp = (nucU,nucU)-minpb = (minp,nucA)-maxpb = (maxp,nucU)-minpp = (minp,minp)-maxpp = (maxp,maxp)-minppbb = (minp,minp,nucA,nucA)-maxppbb = (maxp,maxp,nucU,nucU)-minppbbb = (minp,minp,nucA,nucA,nucA)-maxppbbb = (maxp,maxp,nucU,nucU,nucU)-minppbbbb = (minp,minp,nucA,nucA,nucA,nucA)-maxppbbbb = (maxp,maxp,nucU,nucU,nucU,nucU)-minpbb = (minp,nucA,nucA)-maxpbb = (maxp,nucU,nucU)--- (4,3) switched for vienna rna compatibility-keyspp = [((k1,k2),(k4,k3)) | k1 <- acgu, k3 <- acgu, k2 <- acgu, k4 <- acgu]-keyspb = [((k1,k2),k3) | k1 <- acgu, k2 <- acgu, k3 <- acgu]-keyspbb = [((k1,k2),k3,k4) | k1 <- acgu, k3 <- acgu, k2 <- acgu, k4 <- acgu]-plist11 = [(nucA,nucU),(nucC,nucG),(nucG,nucC),(nucU,nucA),(nucG,nucU),(nucU,nucG)]-plist22 = [(nucA,nucU),(nucC,nucG),(nucG,nucC),(nucG,nucU),(nucU,nucA),(nucU,nucG)]--- (4,3) switched for vienna rna compatibility-keysppbb = [((k1,k2),(k4,k3),k5,k6) | (k1,k2) <- plist11, k5 <- acgu, (k3,k4) <- plist11, k6 <- acgu]--- (4,3) switched for vienna rna compatibility-keysppbbb = [((k1,k2),(k4,k3),k5,k6,k7) | (k1,k2) <- plist11, k6 <- acgu, k5 <- acgu, (k3,k4) <- plist11, k7 <- acgu]--- (4,3) switched for vienna rna compatibility, 5786 is 5'3' order top, bottom!-keysppbbbb = [((k1,k2),(k4,k3),k5,k6,k7,k8) | (k1,k2) <- plist22, (k3,k4) <- plist22, k5 <- acgu, k8 <- acgu, k6 <- acgu, k7 <- acgu]-z = 999999+-- | Given a directory, fill in the 'Turner2004' data structure +fromDir :: FilePath -> Prefix -> Suffix -> IO Turner2004+fromDir fp prefix suffix = do+  stack'     <- blockFromFile $ fp </> prefix ++ "stack"    <.> suffix+  dangle'    <- blockFromFile $ fp </> prefix ++ "dangle"   <.> suffix+  loop'      <- blockFromFile $ fp </> prefix ++ "loop"     <.> suffix+  hairpinMM' <- blockFromFile $ fp </> prefix ++ "tstackh"  <.> suffix+  hairpinLk3 <- tabFromFile   $ fp </> prefix ++ "triloop"  <.> suffix+  hairpinLk4 <- tabFromFile   $ fp </> prefix ++ "tloop"    <.> suffix+  hairpinLk6 <- tabFromFile   $ fp </> prefix ++ "hexaloop" <.> suffix+  let (dangle3',dangle5') = L.splitAt (L.length dangle' `div` 2) dangle'+  let (_:iloopL':bulgeL':hairpinL':[]) = L.transpose $ splitEvery 4 loop'+  iloop1x1'   <- blockFromFile $ fp </> prefix ++ "int11" <.> suffix+  iloop2x1'   <- blockFromFile $ fp </> prefix ++ "int21" <.> suffix+  iloop2x2'   <- blockFromFile $ fp </> prefix ++ "int22" <.> suffix+  iloopMM'    <- blockFromFile $ fp </> prefix ++ "tstacki" <.> suffix+  iloop2x3MM' <- blockFromFile $ fp </> prefix ++ "tstacki23" <.> suffix+  iloop1xnMM' <- blockFromFile $ fp </> prefix ++ "tstacki1n" <.> suffix+  multiMM'    <- blockFromFile $ fp </> prefix ++ "tstacki" <.> suffix+  imisc'      <- miscFromFile  $ fp </> prefix ++ "miscloop" <.> suffix+  extMM'      <- blockFromFile $ fp </> prefix ++ "tstack" <.> suffix+  coaxial'    <- blockFromFile $ fp </> prefix ++ "coaxial" <.> suffix+  cstack'     <- blockFromFile $ fp </> prefix ++ "coaxstack" <.> suffix+  tstack'     <- blockFromFile $ fp </> prefix ++ "tstackcoax" <.> suffix+  return Turner2004+    { stack         = fromAssocs minPP  maxPP  infE $ L.zip keysPP  stack'+    , dangle3       = fromAssocs minPB  maxPB  infE $ L.zip keysPB  dangle3'+    , dangle5       = fromAssocs minPB  maxPB  infE $ L.zip keysPB  dangle5'+    , hairpinL      = fromAssocs 0      30     infE $ L.zip [1..30] hairpinL'+    , hairpinMM     = fromAssocs minPBB maxPBB infE $ L.zip keysPBB hairpinMM'+    , hairpinLookup = M.fromList $ hairpinLk3 ++ hairpinLk4 ++ hairpinLk6+    , hairpinGGG    = L.head $ imisc' !! 8+    , hairpinCslope = L.head $ imisc' !! 9+    , hairpinCintercept = L.head $ imisc' !! 10+    , hairpinC3     = L.head $ imisc' !! 11+    , bulgeL        = fromAssocs 0      30     infE $ L.zip [1..30] bulgeL'+    , bulgeSingleC  = L.head $ imisc' !! 13+    , iloop1x1      = fromAssocs minPPBB   maxPPBB   infE $ L.zip keysPPBB   iloop1x1'+    , iloop2x1      = fromAssocs minPPBBB  maxPPBBB  infE $ L.zip keysPPBBB  iloop2x1'+    , iloop2x2      = fromAssocs minPPBBBB maxPPBBBB infE $ L.zip keysPPBBBB iloop2x2'+    , iloopMM       = fromAssocs minPBB    maxPBB    infE $ L.zip keysPBB    iloopMM'+    , iloop2x3MM    = fromAssocs minPBB    maxPBB    infE $ L.zip keysPBB    iloop2x3MM'+    , iloop1xnMM    = fromAssocs minPBB    maxPBB    infE $ L.zip keysPBB    iloop1xnMM'+    , iloopL        = fromAssocs 0      30     infE $ L.zip [1..30] iloopL'+    , multiMM       = fromAssocs minPBB    maxPBB    infE $ L.zip keysPBB    multiMM'+    , ninio = L.head $ imisc' !! 2+    , maxNinio = L.head $ imisc' !! 1+    , multiOffset = (imisc' !! 3) !! 0+    , multiNuc = (imisc' !! 3) !! 1+    , multiHelix = (imisc' !! 3) !! 2+    , multiAsym = L.head $ imisc' !! 5+    , multiStrain = L.head $ imisc' !! 6+    , extMM      = fromAssocs minPBB maxPBB infE $ L.zip keysPBB extMM'+    , coaxial    = fromAssocs minPP  maxPP  infE $ L.zip keysPP  coaxial'+    , coaxStack  = fromAssocs minPBB maxPBB infE $ L.zip keysPBB cstack'+    , tStackCoax = fromAssocs minPBB maxPBB infE $ L.zip keysPBB tstack'+    , largeLoop = L.head $ imisc' !! 0+    , termAU = L.head $ imisc' !! 7+    , intermolecularInit = L.head $ imisc' !! 12+    } +minPP     = (minP,minP)+maxPP     = (maxP,maxP)+minP      = (nN,nN)+maxP      = (nU,nU)+minPB     = (minP,nN)+maxPB     = (maxP,nU)+minPBB    = (minP,nN,nN)+maxPBB    = (maxP,nU,nU)+minPPBB   = (minP,minP,(nN,nN))+maxPPBB   = (maxP,maxP,(nU,nU))+minPPBBB  = (minP,minP,(nN,nN,nN))+maxPPBBB  = (maxP,maxP,(nU,nU,nU))+minPPBBBB = (minP,minP,(nN,nN,nN,nN))+maxPPBBBB = (maxP,maxP,(nU,nU,nU,nU)) --- | Given the base dir and a suffix (.dat/.dh most likely), parse the relevant--- files. The prefix can be used for, eg., dna file+keysPP     = [((k1,k2),(k4,k3)) | k1 <- acgu, k3 <- acgu, k2 <- acgu, k4 <- acgu]+keysPB     = [((k1,k2),k3) | k1 <- acgu, k2 <- acgu, k3 <- acgu]+keysPBB    = [ ((k1,k2),k3,k4)+             | k1 <- acgu, k3 <- acgu, k2 <- acgu, k4 <- acgu]+keysPPBB   = [ ((k1,k2),(k4,k3),(k5,k6))+             | (k1,k2) <- plist11, k5 <- acgu, (k3,k4) <- plist11, k6 <- acgu]+keysPPBBB  = [ ((k1,k2),(k4,k3),(k5,k6,k7))+             | (k1,k2) <- plist11, k6 <- acgu, k5 <- acgu, (k3,k4) <- plist11, k7 <- acgu]+keysPPBBBB = [ ((k1,k2),(k4,k3),(k5,k6,k7,k8))+             | (k1,k2) <- plist22, (k3,k4) <- plist22, k5 <- acgu, k8 <- acgu, k6 <- acgu, k7 <- acgu] -parseTurner prefix basedir fsuffix = do-  vstack <- grabB basedir fsuffix $ prefix ++ "stack"-  vdangles <- grabB basedir fsuffix $ prefix ++ "dangle"-  vlengths <- grabB basedir fsuffix $ prefix ++ "loop"-  vhairmm <- grabB basedir fsuffix $ prefix ++ "tstackh"-  viloopmm <- grabB basedir fsuffix $ prefix ++ "tstacki"-  viloop23mm <- grabB basedir fsuffix $ prefix ++ "tstacki23"-  viloop1nmm <- grabB basedir fsuffix $ prefix ++ "tstacki1n"-  vmultimm <- grabB basedir fsuffix $ prefix ++ "tstackm"-  vextmm <- grabB basedir fsuffix $ prefix ++ "tstack"-  viloop11 <- grabB basedir fsuffix $ prefix ++ "int11"-  viloop12 <- grabB basedir fsuffix $ prefix ++ "int21"-  viloop22 <- grabB basedir fsuffix $ prefix ++ "int22"-  vlookups <- fmap (map (first (map charToNucleotide)) . concat) $ mapM (\f -> grabA basedir fsuffix $ prefix ++ f) ["triloop","tloop","hexaloop"]-  vmisc <- grabB basedir fsuffix $ prefix ++ "miscloop"-  let (vdangle3,vdangle5) = splitAt (length vdangles `div` 2) vdangles-  let (_:viloopl:vbulgel:vhairpinl:[]) = transpose $ splitEvery 4 vlengths-  return $ Turner2004-    { stack = fromAssocs minpp maxpp z $ zip keyspp vstack-    , dangle3 = fromAssocs minpb maxpb z $ zip keyspb vdangle3-    , dangle5 = fromAssocs minpb maxpb z $ zip keyspb vdangle5-    , hairpinL = fromAssocs 0 30 z $ zip [1..] vhairpinl-    , bulgeL = fromAssocs 0 30 z $ zip [1..] vbulgel-    , iloopL = fromAssocs 0 30 z $ zip [1..] viloopl-    , hairpinMM = fromAssocs minpbb maxpbb z $ zip keyspbb vhairmm-    , iloopMM = fromAssocs minpbb maxpbb z $ zip keyspbb viloopmm-    , iloop2x3MM = fromAssocs minpbb maxpbb z $ zip keyspbb viloop23mm-    , iloop1xnMM = fromAssocs minpbb maxpbb z $ zip keyspbb viloop1nmm-    , multiMM = fromAssocs minpbb maxpbb z $ zip keyspbb vmultimm-    , extMM = fromAssocs minpbb maxpbb z $ zip keyspbb vextmm-    , hairpinLookup = M.fromList vlookups-    , iloop1x1 = fromAssocs minppbb   maxppbb   z $ zip keysppbb   viloop11-    , iloop1x2 = fromAssocs minppbbb  maxppbbb  z $ zip keysppbbb  viloop12-    , iloop2x2 = fromAssocs minppbbbb maxppbbbb z $ zip keysppbbbb viloop22-    , ninio = vmisc !! 2-    , maxNinio = vmisc !! 1-    , multiOffset = vmisc !! 6-    , multiNuc = vmisc !! 7-    , multiHelix = vmisc !! 8-    , largeLoop = vmisc !! 0-    , termAU = vmisc !! 14-    , intermolecularInit = vmisc !! 19-    }+plist11 = [(nA,nU),(nC,nG),(nG,nC),(nU,nA),(nG,nU),(nU,nG)]+plist22 = [(nA,nU),(nC,nG),(nG,nC),(nG,nU),(nU,nA),(nU,nG)] -grabB basedir fsuffix fname = do-  p <- parseFromFile pBlockFile (basedir ++ "/" ++ fname ++ fsuffix)-  case p of-    (Right ans) -> return ans-    (Left err)  -> error $ show err+infE = 999999 :: Double -grabA basedir fsuffix fname = do-  p <- parseFromFile pAssocFile (basedir ++ "/" ++ fname ++ fsuffix)-  case p of-    (Right ans) -> return ans-    (Left err)  -> error $ show err+-- * Iteratee stuff +-- | Transform input stream into list of list of doubles +eneeBlocks :: (Functor m, Monad m) => Enumeratee ByteString [[Double]] m a+eneeBlocks = enumLinesBS ><> mapStream f ><> I.filter (not . L.null) where+  f x+    | "5'" `isPrefixOf` y = []+    | "3'" `isPrefixOf` y = []+    | "." `isPrefixOf`  y = values y+    | Just (d,xs) <- readDouble y = values y+    | otherwise = [] -- error $ BS.unpack x+    where y = BS.dropWhile isSpace x --- * File parser: We do not want to understand the format, just extract all--- data.+-- | extract values. "." - values are extracted as > 100k --- | Blocks of data.+values :: ByteString -> [Double]+values xs+  | BS.null ys+    = []+  | "." `isPrefixOf` ys+    = infE : values (BS.drop 1 ys)+  | Just (d,zs) <- readDouble ys+    = d : values zs+  where ys = BS.dropWhile isSpace xs -pBlockFile = concat <$> many (try numberRow <|> infoRow) <* eof where-  -- a line with a least one number-  numberRow = many (char ' ') *> (number <* notFollowedBy (char '\'')) `sepEndBy1` (many $ char ' ') <* newline-  -- a number is a dot or some extended floating point number-  number = (try dotFloat) <|> (999999 <$ char '.') <|> parseExtFloat <?> "floating point number"+-- | Iteratee to parse tabulated loops (hairpins). --- | A File with associations.+iTabulated :: (Functor m, Monad m) => Iteratee ByteString m [(ByteString,Double)]+iTabulated = joinI $ enumLinesBS ><> I.filter (BS.all isSpace) $ g where+  g = do+    I.drop 2+    joinI $ mapStream f stream2stream+  f x+    | Just (d,_) <- readDouble v = (k,d)+    | otherwise = error $ "tabulated: <" ++ BS.unpack x ++ ">"+    where (k,v) = second (BS.dropWhile isSpace) . BS.span (not . isSpace) . BS.dropWhile isSpace $ x -pAssocFile = concat <$> many1 (try assocRow <|> infoRow) where-  -- one assocs of string, value-  assocRow = (\a b -> [(a,b)]) <$ many (char ' ') <*> many1 (oneOf nuc) <* many (char ' ') <*> parseExtFloat <* many (char ' ')+-- | Convenience function --- a line with crap-infoRow = [] <$ anyChar `manyTill` newline+blockFromFile :: FilePath -> IO [Double]+blockFromFile fp = do+  i <- enumFile 8192 fp . joinI $ eneeBlocks stream2list+  xs <- run i+  if (allEq $ L.map L.length xs)+    then return $ L.concat xs+    else error $ "in file: " ++ fp ++ " we have unequal line lengths" --- a rather stupid float-dotFloat = (\s a b -> read $ s:'0':a:b) <$> (char '-' <|> pure ' ') <*> char '.' <*> many1 digit+-- | Parses the miscloop table+--+-- NOTO extra brownie points for miscloop.dat for providing data in a form that+-- does not conform to normal number encoding. -nuc = "ACGUT"+iMiscLoop :: (Functor m, Monad m) => Iteratee ByteString m [[Double]]+iMiscLoop = joinI $ enumLinesBS ><> I.groupBy (\x y -> not $ BS.null y) $ f where+  f = do+    I.drop 1+    xs <- fmap (L.map (L.map (readD) . BS.words . L.last)) $ stream2list+    return xs++-- | Parses stupidly encoded values like ".6" and "-.0".++readD :: ByteString -> Double+readD xs+  | BS.null xs              = error "readD: null"+  | BS.head xs == '.'       = readD $ BS.cons '0' xs+  | "-." `BS.isPrefixOf` xs = readD $ "-0." `BS.append` BS.drop 2 xs+  | Just (d,_) <- readDouble xs = d+  | otherwise = error $ BS.unpack xs++-- |++miscFromFile :: FilePath -> IO [[Double]]+miscFromFile fp = run =<< enumFile 8192 fp iMiscLoop++-- | ++tabFromFile :: FilePath -> IO [(ByteString,Double)]+tabFromFile fp = run =<< enumFile 8192 fp iTabulated++allEq [] = True+allEq (x:xs) = L.all (==x) xs++{-+test1 = blockFromFile "/home/choener/Documents/Workdata/TurnerRNA2004/RNA/loop.dat"+test2 = fromDir "/home/choener/Documents/Workdata/TurnerRNA2004/RNA" "" ".dat"+-}++type Prefix = FilePath+type Suffix = FilePath+

@@ -1,133 +0,0 @@-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE DeriveFunctor #-}-{-# LANGUAGE RecordWildCards #-}-{-# LANGUAGE TypeSynonymInstances #-}---- | Turner Nearest Neighbor Energy Tables}---- TODO (Read) instance? (Vector has no Read instance...)--module Biobase.Turner.Tables where--import qualified Data.Map as M--import Data.PrimitiveArray-import Data.PrimitiveArray.Ix------ | A data structure describing all fields as used by the Turner 2004--- parameter set. Some fields are commented out until they are being used.--data Turner2004 a b c = Turner2004-  { stack :: PrimArray (a,a) c-  , dangle3 :: PrimArray (a,b) c-  , dangle5 :: PrimArray (a,b) c-  , hairpinL :: PrimArray Int c-  , hairpinMM :: PrimArray (a,b,b) c-  , hairpinLookup :: M.Map [b] c---  , hairpinGGG :: c---  , hairpinCslope :: c---  , hairpinCintercept :: c---  , hairpinC3 :: c-  , bulgeL :: PrimArray Int c---  , bulgeSingleC :: c-  , iloop1x1 :: PrimArray (a,a,b,b) c-  , iloop1x2 :: PrimArray (a,a,b,b,b) c-  , iloop2x2 :: PrimArray (a,a,b,b,b,b) c-  , iloopMM :: PrimArray (a,b,b) c-  , iloop2x3MM :: PrimArray (a,b,b) c-  , iloop1xnMM :: PrimArray (a,b,b) c-  , iloopL :: PrimArray Int c-  , multiMM :: PrimArray (a,b,b) c-  , ninio :: c-  , maxNinio :: c-  , multiOffset :: c-  , multiNuc :: c-  , multiHelix :: c---  , multiAsym :: c---  , multiStrain :: c-  , extMM :: PrimArray (a,b,b) c---  , coaxStack :: PrimArray (a,a) c---  , coaxStackOpen :: PrimArray (a,b,b) c---  , coaxStackCont :: PrimArray (a,b,b) c-  , largeLoop :: Double-  , termAU :: c-  , intermolecularInit :: c-  }------ | Map functions over the payload.--dmap f Turner2004{..} = Turner2004-  { stack = amap f stack-  , dangle3 = amap f dangle3-  , dangle5 = amap f dangle5-  , hairpinL = amap f hairpinL-  , hairpinMM = amap f hairpinMM-  , hairpinLookup = fmap f hairpinLookup---  , hairpinGGG = f hairpinGGG---  , hairpinCslope = f hairpinCslope---  , hairpinCintercept = f hairpinCintercept---  , hairpinC3 = f hairpinC3-  , bulgeL = amap f bulgeL---  , bulgeSingleC = f bulgeSingleC-  , iloop1x1 = amap f iloop1x1-  , iloop1x2 = amap f iloop1x2-  , iloop2x2 = amap f iloop2x2-  , iloopMM = amap f iloopMM-  , iloop2x3MM = amap f iloop2x3MM-  , iloop1xnMM = amap f iloop1xnMM-  , iloopL = amap f iloopL-  , multiMM = amap f multiMM-  , ninio = f ninio-  , maxNinio = f maxNinio-  , multiOffset = f multiOffset-  , multiNuc = f multiNuc-  , multiHelix = f multiHelix---  , multiAsym = f multiAsym---  , multiStrain = f multiStrain-  , extMM = amap f extMM---  , coaxStack = amap f coaxStack---  , coaxStackOpen = amap f coaxStackOpen---  , coaxStackCont = amap f coaxStackCont-  , largeLoop = largeLoop-  , termAU = f termAU-  , intermolecularInit = f intermolecularInit-  }------ | Zip two payloads.------ TODO right now, we have undefined behaviour when some arrrays are of different length--dZipWith f t1 t2 = Turner2004-  { stack = zipWithPA f (stack t1) (stack t2)-  , dangle3 = zipWithPA f (dangle3 t1) (dangle3 t2)-  , dangle5 = zipWithPA f (dangle5 t1) (dangle5 t2)-  , hairpinL = zipWithPA f (hairpinL t1) (hairpinL t2)-  , hairpinMM = zipWithPA f (hairpinMM t1) (hairpinMM t2)-  , hairpinLookup = undefined -- zipWithPA f (hairpinLookup t1) (hairpinLookup t2)-  , bulgeL = zipWithPA f (bulgeL t1) (bulgeL t2)-  , iloop1x1 = zipWithPA f (iloop1x1 t1) (iloop1x1 t2)-  , iloop1x2 = zipWithPA f (iloop1x2 t1) (iloop1x2 t2)-  , iloop2x2 = zipWithPA f (iloop2x2 t1) (iloop2x2 t2)-  , iloopMM = zipWithPA f (iloopMM t1) (iloopMM t2)-  , iloop2x3MM = zipWithPA f (iloop2x3MM t1) (iloop2x3MM t2)-  , iloop1xnMM = zipWithPA f (iloop1xnMM t1) (iloop1xnMM t2)-  , iloopL = zipWithPA f (iloopL t1) (iloopL t2)-  , multiMM = zipWithPA f (multiMM t1) (multiMM t2)-  , ninio = f (ninio t1) (ninio t2)-  , maxNinio = f (maxNinio t1) (maxNinio t2)-  , multiOffset = f (multiOffset t1) (multiOffset t2)-  , multiNuc = f (multiNuc t1) (multiNuc t2)-  , multiHelix = f (multiHelix t1) (multiHelix t2)-  , extMM = zipWithPA f (extMM t1) (extMM t2)-  , largeLoop = largeLoop t1 -- no zipping here! TODO make this a constant somewhere!-  , termAU = f (termAU t1) (termAU t2)-  , intermolecularInit = f (intermolecularInit t1) (intermolecularInit t2)-  }--zipWithPA f a1 a2 = let (l,u) = bounds a1 in fromList l u $ zipWith f (toList a1) (toList a2)

@@ -1,39 +1,43 @@ name:           BiobaseTurner-version:        0.0.2.2+version:        0.1.0.0 author:         Christian Hoener zu Siederdissen maintainer:     choener@tbi.univie.ac.at-copyright:      Christian Hoener zu Siederdissen, 2010+homepage:       http://www.tbi.univie.ac.at/~choener/+copyright:      Christian Hoener zu Siederdissen, 2010,2011 category:       Bioinformatics-synopsis:       (deprecated) RNA folding data structures.+synopsis:       Import Turner RNA parameters license:        GPL-3 license-file:   LICENSE build-type:     Simple stability:      experimental-cabal-version:  >= 1.4.0+cabal-version:  >= 1.6.0 description:-                Data structures and parsers for the Turner 2004 set of RNA parameters.-                - http://rna.urmc.rochester.edu/NNDB/index.html--+                A data structure for Mathews / Turner RNA and DNA energy+                parameters. This library currently only provides an importer,+                not export functions. There are two reasons: (i) We currently+                have no use-case where we need more than import facilities (ii)+                The file structure is geared towards humans, not machines. If+                you need to be able to export, send a mail.+                .+                This is the 2011 post-library split version, hence not+                deprecated anymore.  library   build-depends:-    base >=4 && <5,+    base >3 && <5,+    bytestring,+    bytestring-lexing,     containers,-    parsec >=3 && <4,-    primitive >=0.3 && <0.4,-    filemanip >=0.3.3 && <0.4,-    split >=0.1.2 && <0.2,--    Biobase >=0.0.2 && <0.0.3,-    HsTools >=0.0.1.1 && <0.0.2,-    ParsecTools >=0.0.2 && <0.0.3,-    PrimitiveArray >=0.0.2 && <0.0.3+    filepath,+    iteratee,+    split,+    BiobaseXNA,+    PrimitiveArray    exposed-modules:     Biobase.Turner     Biobase.Turner.Import-    Biobase.Turner.Tables    ghc-options:     -O2+