!WG      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - ./0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ]^_ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                   None"#&'-1278=>?@ADHMSUVXC PrimitiveArrayStrict pairs -- as in repa. PrimitiveArrayfA different version of strict pairs. Makes for simpler type inference in multi-tape grammars. We use :>i when we have special needs, like non-recursive instances on inductives tuples, as used for set indices. This one is infixr so that in a :> b we can have the main type in a and the specializing types in b and then dispatch on a :> ts with ts maybe a chain of :>.PrimitiveArray4Base data constructor for multi-dimensional indices.3PrimitiveArraylGenerate a stream of indices in correct order for dynamic programming. Since the stream generators require  concatMap / flatten- we have to write more specialized code for (z:.IX) stuff.4PrimitiveArrayGenerate an index stream using ;_s. This prevents having to figure out how the actual limits for complicated index types (like Set) would look like, since for Set, for example, the LimitType Set == Int# provides just the number of bits.,This generates an index stream suitable for forward structure filling. The first index is the smallest (or the first indices considered are all equally small in partially ordered sets). Larger indices follow up until the largest one.5PrimitiveArrayIf 43 generates indices from smallest to largest, then 5 generates indices from largest to smallest. Outside grammars make implicit use of this. Asking for an axiom in backtracking requests the first element from this stream.6PrimitiveArray-The total number of cells that are allocated.8PrimitiveArrayIn case  totalSize? or variants thereof produce a size that is too big to handle.:PrimitiveArrayIndex structures for complex, heterogeneous indexing. Mostly designed for indexing in DP grammars, where the indices work for linear and context-free grammars on one or more tapes, for strings, sets, later on tree structures.;PrimitiveArray7Data structure encoding the upper limit for each array.<PrimitiveArrayGGiven a maximal size, and a current index, calculate the linear index.=PrimitiveArray Given the ;2, return the number of cells required for storage.>PrimitiveArray'Check if an index is within the bounds.?PrimitiveArrayA lower bound of zero@PrimitiveArrayA lower bound of zero but for a  LimitType i.APrimitiveArrayNThe list of cell sizes for each dimension. its product yields the total size.DPrimitiveArray#Given the maximal number of cells (Word, because this is the pointer limit for the machine), and the list of sizes, will check if this is still legal. Consider dividing the Wordi by the actual memory requirements for each cell, to get better exception handling for too large arrays.(One list should be given for each array.! B! C"  3546789:A@?><=;;D  :A@?><=;D896735433 3 3None"#&'-1278=>?@ADHMSUVXhJgPrimitiveArrayi freezes a stack of tables.mPrimitiveArray;Map a function over each element, keeping the shape intact.nPrimitiveArray.The core set of functions on immutable arrays.oPrimitiveArrayBReturns the bounds of an immutable array, again inclusive bounds:  [lb..ub] .pPrimitiveArrayMFreezes a mutable array an returns its immutable version. This operation is O(1)Q and both arrays share the same memory. Do not use the mutable array afterwards.qPrimitiveArrayHThaw an immutable array into a mutable one. Both versions share memory.rPrimitiveArray_Extract a single element from the array. Generally unsafe as not bounds-checking is performed.sPrimitiveArray,Savely transform the shape space of a table.tPrimitiveArray.The core set of operations for monadic arrays.uPrimitiveArrayAReturn the bounds of the array. All bounds are inclusive, as in [lb..ub]vPrimitiveArray+Given lower and upper bounds and a list of all$ elements, produce a mutable array.wPrimitiveArrayjCreates a new array with the given bounds with each element within the array being in an undefined state.xPrimitiveArray5Creates a new array with all elements being equal to elm.yPrimitiveArray$Reads a single element in the array.zPrimitiveArray%Writes a single element in the array.{PrimitiveArrayMutable version of an array.|PrimitiveArray[Infix index operator. Performs minimal bounds-checking using assert in non-optimized code.}PrimitiveArray1Returns true if the index is valid for the array.~PrimitiveArraytConstruct a mutable primitive array from a lower and an upper bound, a default element, and a list of associations.PrimitiveArrayBInitialize an immutable array but stay within the primitive monad m.PrimitiveArray!Safely prepare a primitive array.TODO Check if having a f instance degrades performance. (We should see this once the test with NeedlemanWunsch is under way).PrimitiveArray&Return all associations from an array.PrimitiveArrayXCreates an immutable array from lower and upper bounds and a complete list of elements.PrimitiveArraygCreates an immutable array from lower and upper bounds, a default element, and a list of associations.PrimitiveArray5Returns all elements of an immutable array as a list.gihjklmnsorqptzyxwvu{|}~{tzyxwvunsorqplmjk|}~gihNone"#&'-1278=>?@ADHMSUVXjX{None"#&'-1278=>?@ADHMSUVXnPrimitiveArrayPhantom type for  Complement indices.PrimitiveArrayPhantom type for Outside indices.PrimitiveArrayPhantom type for Inside indices.None"#&'-1278=>?@ADHMSUVXM PrimitiveArrayeCertain sets have an interface, a particular element with special meaning. In this module, certain ` meanings'( are already provided. These include a First element and a Last@ element. We phantom-type these to reduce programming overhead.PrimitiveArrayAssuming a bitset on bits [0 .. highbit]:, we can apply a mask that stretches out those bits over [0 .. higherBit] with highbit <= higherBit2. Any active interfaces are correctly set as well.PrimitiveArrayFixedC allows us to fix some or all bits of a bitset, thereby providing  succ/pred* operations which are only partially free.)The mask is lazy, this allows us to have  undefined for l and h.f = getFixedMask .&. getFixed are the fixed bits. (n = getFixed .&. complement getFixedMask are the free bits. to = complement getFixed is the to move mask n' = popShiftR to n' yields the population after the move p = popPermutation undefined n'( yields the new population permutation p' = popShiftL to p# yields the population moved back final = p' .|. fPrimitiveArray^Masks are used quite often for different types of bitsets. We liberate them as a type family.PrimitiveArraySuccessor and Predecessor for sets. Designed as a class to accomodate sets with interfaces and without interfaces with one function.The functions are not written recursively, as we currently only have three cases, and we do not want to "reset" while generating successors and predecessors.PNote that sets have a partial order. Within the group of element with the same popCount , we use popPermutation. which has the same stepping order for both, setSucc and setPred.PrimitiveArrayuSet successor. The first argument is the lower set limit, the second the upper set limit, the third the current set.PrimitiveArraywSet predecessor. The first argument is the lower set limit, the second the upper set limit, the third the current set.PrimitiveArray(Declare the interface to match anything.+TODO needed? want to use later in ADPfusionPrimitiveArray.Declare the interface to be the end of a path.PrimitiveArray0Declare the interface to be the start of a path.PrimitiveArrayfor ;None"#&'-1278=>?@ADHMSUVXPrimitiveArrayNewtype for a bitset.IntU integrates better with the rest of the framework. But we should consider moving to Word-based indexing, if possible.; None"#&'-1278=>?@ADHMSUVX'PrimitiveArray*The bitset with one interface or boundary.PrimitiveArray/NOTE We linearize a bitset as follows: we need "2^number-of-bits * number-of-bits elements. The first is due to having a binary set structure. The second is due to pointing to each of those elements as being the boundary. This overcommits on memory since only those bits can be a boundary bits that are actually set. Furthermore, in case no bit is set at all, then there should be no boundary. This is currently rather awkwardly done by restricting enumeration and mapping the 0-set to boundary 0.U| TODO The size calculations are off by a factor of two, exactly. Each bitset (say) 00110 has a mirror image 11001, whose elements do not have to be indexed. It has to be investigated if a version with exact memory bounds is slower in indexing.  ;        None"#&'-1278=>?@ADHMSUVX; None"#&'-1278=>?@ADHMSUVXPrimitiveArrayA  behaves exactly like an Int$, but has an attached phantom type p. In particular, the Index and  IndexStream$ instances are the same as for raw Ints../; !"0123  !"0123 None"#&'-1278=>?@ADFHMSUVX{HPrimitiveArray#A point in a right-linear grammars.KPrimitiveArrayQA point in a left-linear grammar. The syntactic symbol is in left-most position.]^;HIJKLMNOP[\_`abKLMNOPHIJ[\_`ab None"#&'-1278=>?@ADHMSUVXyPrimitiveArrayA subword wraps a pair of Int indices i,j with i<=j.sSubwords always yield the upper-triangular part of a rect-angular array. This gives the quite curious effect that (0,N) points to the `largest' index, while #(0,0) ... (1,1) ... (k,k) ... (N,N) point to the smallest. We do, however, use (0,0) as the smallest as (0,k) gives successively smaller upper triangular parts.PrimitiveArray Create a  Subword t where t is inferred.PrimitiveArraygeneric mk for streamUp /  streamDownPrimitiveArray Subword C (complement)PrimitiveArray Subword O (outside).Note: streamUp really needs to use  streamDownMk / streamDownStep! for the right order of indices!PrimitiveArray Subword I (inside);yz{|} yz{|}None"#&'-1278=>?@ADHMSUVX:;None"#&'-1278=>?@ADHMSUVXt]. !B^/ "C  3456789:;=<>?@AD !"HIJKLMNOP[\yz{|}=;  ;./; !"]^;HIJKLMNOP[\;yz{|}None"#&'-1278=>?@ADHMSUVXb !B .] "C /^  3456789:;=<>?@ADghijklmnpqrostuvwxyz{|}~ !"HIJKLMNOP[\yz{|}None"#&'-1278=>?@ADHMSUVXIPrimitiveArray#Bounds-checked version of indexing.First, we check via inBoundsH, second we check if the linear index is outside of the allocated area. !B .] "C /^  3456789:;=<>?@ADghijklmnpqrostuvwxyz{}~ !"HIJKLMNOP[\yz{|} !B .] "C /^  3456789:;=<>?@ADghijklmnpqrostuvwxyz{}~ !"HIJKLMNOP[\yz{|}None"#&'-1278=>?@ADHMSUVX PrimitiveArrayNxN sized score matrices*TODO needs a vector with the column names!PrimitiveArrayGet the distance between edges  (From,To).PrimitiveArray3If the initial node has a "distance", it'll be herePrimitiveArray(Get the name of the node at an row indexPrimitiveArray+Get the name of the node at an column indexPrimitiveArray!Number of rows in a score matrix.PrimitiveArray$Number of columns in a score matrix.PrimitiveArrayTurns a  ScoreMatrixk for distances into one scaled by "temperature" for Inside/Outside calculations. Each value is scaled by k -> exp $ negate k / r * t3 where r = (n-1) * d d = mean of genetic distance3Node scores are turned directly into probabilities.7TODO Again, there is overlap and we should really have newtype Distance and friends.TODO (newtype Temperature = Temperature DoubleTODO fix for rows /= cols!!!PrimitiveArray Import data.#TODO Should be generalized because Lib-BiobaseBlast does almost the same thing.PrimitiveArray temperature !"#$%&'()*+,-./01223456789:;<=>?@ABCDEFGHHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                     n   n      ! " # $ % & ' ( ) * + , - . /   0 1 2 3 4 5 6 7 8 9 : ; p q o n < < = > > ? @ A B C D E F G H I J K L M M N O P Q R   S T U V W X Y Z [ \ ] ^ n o p q _ _ ` a b c d e f g h i j k l m n o p   q r s t u v w x y z { | n o p q}}~nopq     -PrimitiveArray-0.9.0.0-7o4e78MXLzPCxIvR95QAvsData.PrimitiveArray.IndexData.PrimitiveArray.Index.ClassData.PrimitiveArray.CheckedData.PrimitiveArray.ClassData.PrimitiveArray.DenseData.PrimitiveArray.Index.IOC'Data.PrimitiveArray.Index.BitSetClasses!Data.PrimitiveArray.Index.BitSet0!Data.PrimitiveArray.Index.BitSet1Data.PrimitiveArray.Index.Int$Data.PrimitiveArray.Index.PhantomIntData.PrimitiveArray.Index.Point!Data.PrimitiveArray.Index.SubwordData.PrimitiveArray.Index.UnitData.PrimitiveArray.ScoreMatrixTest.QuickCheck ArbitraryData.PrimitiveArray&vector-0.12.0.2-H1Eu1OCXL0L9y980iV8EwUData.Vector.Unboxed.BaseVectorMVector:.$fEq:.$fOrd:.$fShow:. $fGeneric:.$fData:.:> V_StrictPair MV_StrictPair $fArbitrary:. $fNFData:.$fFromJSONKey:. $fToJSONKey:. $fHashable:. $fFromJSON:. $fToJSON:. $fSerialize:. $fBinary:.$fVectorVector:.$fMVectorMVector:. $fUnbox:.$fEq:>$fOrd:>$fShow:> $fGeneric:>$fData:>$fRead:.ZV_StrictIxPairMV_StrictIxPair $fNFData:> $fHashable:> $fFromJSON:> $fToJSON:> $fSerialize:> $fBinary:>$fVectorVector:>$fMVectorMVector:> $fUnbox:>$fEqZ$fOrdZ$fReadZ$fShowZ $fGenericZ$fDataZ$fRead:> IndexStreamstreamUp streamDownCellSize SizeErrorIndex LimitType linearIndexsizeinBounds zeroBound zeroBound' totalSizeV_ZMV_Z sizeIsValid $fNFDataZ $fArbitraryZ $fHashableZ $fFromJSONZ $fToJSONZ $fSerializeZ $fBinaryZ$fVectorVectorZ$fMVectorMVectorZ$fUnboxZ $fIndex:.$fIndexZ$fIndexStreamZ $fEqSizeError$fOrdSizeError$fShowSizeError $fEqCellSize $fOrdCellSize$fShowCellSize $fNumCellSize$fBoundedCellSize$fIntegralCellSize$fRealCellSize$fEnumCellSize$fDataLimitType$fShowLimitType$fReadLimitType$fGenericLimitType $fEqLimitType$fDataLimitType0$fShowLimitType0$fReadLimitType0$fGenericLimitType0$fEqLimitType0 FreezeTablesFrozen freezeTablesPAErrors PAEUpperBound PrimArrayMapmap PrimArrayOps upperBound unsafeFreeze unsafeThaw unsafeIndextransformShape MPrimArrayOps upperBoundM fromListMnewMnewWithMreadMwriteMMutArr! inBoundsM fromAssocsM newWithPA safeNewWithPAassocsfromList fromAssocstoList$fShowPAErrors$fFreezeTablesm:.$fFreezeTablesmZ $fEqPAErrors$fGenericPAErrorsBoxedUnboxedMBoxedMUnboxed$fPrimArrayMapUnboxedshee'$fPrimArrayOpsUnboxedshelm$fMPrimArrayOpsUnboxedshelm$fNFDataMutArr$fNFDataUnboxed$fHashableUnboxed$fFromJSONUnboxed$fToJSONUnboxed$fSerializeUnboxed$fBinaryUnboxed$fPrimArrayMapBoxedshee'$fPrimArrayOpsBoxedshelm$fMPrimArrayOpsBoxedshelm$fNFDataMutArr0 $fNFDataBoxed$fHashableBoxed$fFromJSONBoxed $fToJSONBoxed$fSerializeBoxed $fBinaryBoxed$fGenericMutArr$fGenericMutArr0 $fDataBoxed$fGenericBoxed $fEqBoxed $fShowBoxed $fReadBoxed $fDataUnboxed $fShowUnboxed $fReadUnboxed$fGenericUnboxed $fEqUnboxedCOIBoundary getBoundary$fShowBoundary $fEqBoundary $fOrdBoundary$fGenericBoundary $fNumBoundary ApplyMask applyMaskFixed getFixedMaskgetFixedMask SetPredSuccsetSuccsetPredAnyLastFirst V_Boundary MV_Boundary streamUpBndMkstreamUpBndStepstreamDownBndMkstreamDownBndSteparbitraryBitSetMax$fIndexStreamBoundary$fIndexStream:.$fIndexBoundary$fNFDataBoundary$fHashableBoundary$fFromJSONBoundary$fToJSONBoundary$fSerializeBoundary$fBinaryBoundary$fVectorVectorBoundary$fMVectorMVectorBoundary$fUnboxBoundaryBitSet_bitSet $fEqBitSet $fOrdBitSet$fGenericBitSet$fFiniteBitsBitSet$fRankedBitSet $fNumBitSet $fBitsBitSetbitSet$fHashableBitSet$fSerializeBitSet$fBinaryBitSet$fToJSONKeyBitSet$fToJSONBitSet$fFromJSONKeyBitSet$fFromJSONBitSetV_BitSet MV_BitSet streamUpMk streamUpStep streamDownMkstreamDownStep$fArbitraryBitSet$fIndexStreamBitSet$fIndexStream:.0$fIndexStream:.1$fSetPredSuccBitSet $fIndexBitSet$fNFDataBitSet $fShowBitSet$fVectorVectorBitSet$fMVectorMVectorBitSet $fUnboxBitSetBitSet1_bitset _boundary $fEqBitSet1 $fOrdBitSet1$fGenericBitSet1 $fShowBitSet1bitsetboundary V_BitSet1 MV_BitSet1$fArbitraryBitSet1$fSetPredSuccBitSet1$fIndexStreamBitSet1$fIndexBitSet1$fVectorVectorBitSet1$fMVectorMVectorBitSet1$fUnboxBitSet1$fIndexStreamInt $fIndexIntPIntgetPIntpIntIpIntOpIntC $fReadPInt $fShowPInt$fEqPInt $fOrdPInt $fEnumPInt $fNumPInt$fIntegralPInt $fRealPInt $fGenericPInt $fDataPInt$fIxPIntV_PIntMV_PInt$fIndexStreamPInt $fIndexPInt $fNFDataPInt$fHashablePInt$fToJSONKeyPInt $fToJSONPInt$fFromJSONKeyPInt$fFromJSONPInt$fSerializePInt $fBinaryPInt$fVectorVectorPInt$fMVectorMVectorPInt $fUnboxPIntPointR fromPointRPointL fromPointLpointLIpointLOpointLC $fEqPointL $fOrdPointL $fReadPointL $fShowPointL$fGenericPointL $fEqPointR $fOrdPointR $fReadPointR $fShowPointR$fGenericPointRSPV_PointL MV_PointL$fSerialmPointL$fArbitraryPointL$fIndexStreamPointL $fIndexPointL$fNFDataPointL$fHashablePointL$fToJSONKeyPointL$fToJSONPointL$fFromJSONKeyPointL$fFromJSONPointL$fSerializePointL$fBinaryPointL$fVectorVectorPointL$fMVectorMVectorPointL $fUnboxPointLSubword fromSubwordfromSubwordFstfromSubwordSnd $fEqSubword $fOrdSubword $fShowSubword$fGenericSubword $fReadSubword V_Subword MV_SubwordsubwordsubwordIsubwordOsubwordC$fSerialmSubword$fArbitrarySubword$fIndexStreamSubword$fIndexSubword$fNFDataSubword$fHashableSubword$fToJSONKeySubword$fToJSONSubword$fFromJSONKeySubword$fFromJSONSubword$fSerializeSubword$fBinarySubword$fVectorVectorSubword$fMVectorMVectorSubword$fUnboxSubwordUnit$fEqUnit $fOrdUnit $fShowUnit $fGenericUnit $fReadUnitV_UnitMV_Unit$fArbitraryUnit$fIndexStreamUnit $fIndexUnit $fNFDataUnit$fHashableUnit$fToJSONKeyUnit $fToJSONUnit$fFromJSONKeyUnit$fFromJSONUnit$fSerializeUnit $fBinaryUnit$fVectorVectorUnit$fMVectorMVectorUnit $fUnboxUnit ScoreMatrix scoreMatrix scoreNodesrowNamescolNames.!.nodeDist rowNameOf colNameOfnumRowsnumColslistOfRowNameslistOfColNames toPartMatrixfromFile$fShowScoreMatrixZZ:.. mtl-2.2.2Control.Monad.Error.Class MonadError LtBoundaryLtBitSet LtNumBits1LtIntLtPIntLtPointL LtSubwordLtUnit