݌      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a b c d e f g h i j k l m nop q r s t u v w x y z { | } ~    & Safe-Inferred  &*123468;<=FHJKMCommon display formats. &How a given value should be displayed. %Display a string with the given mode.4Examine a string to decide how we should display it.6Left justify some text in a column of the given width.7Right justify some text in a column of the given width.         Safe-Inferred  &*123468;<=FHJKM1Our index type, used for both shapes and indices.An index of dimension zero<Class of types that can be used as array shapes and indices.(Get the number of dimensions in a shape.GThe shape of an array of size zero, with a particular dimensionality.IThe shape of an array with size one, with a particular dimensionality.'Compute the intersection of two shapes. /Add the coordinates of two shapes componentwise!=Get the total number of elements in an array with this shape."LGiven a starting and ending index, check if some index is with that range.#,Convert a shape into its list of dimensions.$'Convert a list of dimensions to a shape%HGiven an array shape and index, check whether the index is in the shape.&!Nicely format a shape as a string !"#$%&'()*+, !"#$%&'()*+,  !"#$%&'()*+, Safe-Inferred  &*123468;<=FHJKM.BA layout provides a total order on the elements of an index space._We can talk about the n-th element of an array, independent of its shape and dimensionality./NShort name for a layout which does not include details of the exact extent.0*Type used to index into this array layout.1 O(1). Proxy for the layout name.22O(1). Create a default layout of the given extent.3%O(1). Yield the extent of the layout.42O(1). Convert a polymorphic index to a linear one.52O(1). Convert a linear index to a polymorphic one. -./012345 -./012345-./012345 Safe-Inferred  &*123468;<=FHJKM6.Unpack the pieces of a structure into a tuple.bThis is used in a low-level fusion optimisation to ensure that intermediate values are unboxed.678678678678 Safe-Inferred  &*123468;<=FHJKM 98Constraint synonym that requires an integer index space.:]Class of array representations that we can read elements from in a random-access manner. ;%An Array supplies an element of type a? to each position in the index space associated with layout l.<!O(1). Get the layout of an array.=O(1). Get an element from an array. If the provided index is outside the extent of the array then the result depends on the layout.>O(1). Alias for =.?-O(1). Get the number of elements in an array.@Convert an array to a list.%Convert a nested array to some lists.6Convert a triply nested array to a triply nested list. 9:;<=>?@ Source array. Result list. Source array. Result list. 9:;<=>?@9:;<=>?@None  &*123468;<=FHJKMFWA row-wise layout that maps higher rank indices to linear ones in a row-major order.HIndices are ordered so the inner-most coordinate varies most frequently: > Prelude.map (fromIndex (RowWise (ish2 2 3))) [0..5] [(Z :. 0) :. 0, (Z :. 0) :. 1, (Z :. 0) :. 2, (Z :. 1) :. 0, (Z :. 1) :. 1, (Z :. 1) :. 2]aIndexing is not bounds checked. Indexing outside the extent yields the corresponding index.IUConstruct a rowWise array that produces the corresponding index for every element. > toList $ rowWise (ish2 3 2) [(Z :. 0) :. 0, (Z :. 0) :. 1, (Z :. 1) :. 0, (Z :. 1) :. 1, (Z :. 2) :. 0, (Z :. 2) :. 1]Row-wise arrays.ABCDEFGHIJKLMN/;ABCDEFGHIJKLMNFGHIEDCBAJKLMNABCDEFGHIJKLMN Safe-Inferred  &*123468;<=FHJKM% !"#$%&'()*+,-./012345% !"#$%&'()*+,./012345- Safe-Inferred  &*123468;<=FHJKMO,Class of index types that can map to slices.P9Map an index of a full shape onto an index of some slice.Q8Map an index of a slice onto an index of the full shape.RRMap the type of an index in the slice, to the type of the index in the full shape.SQMap a type of the index in the full shape, to the type of the index in the slice.T$Place holder for any possible shape.V)Select all indices at a certain position.OPQRSTUVW   OPQRSTUVW VWTUSROPQOPQRSTUVW    Safe-Inferred  &*123468;<=FHJKMX=Class of array representations that can be windowed directly.qThe underlying representation can encode the window, without needing to add a wrapper to the existing layout._&Wrap a window around an exiting array.`HWrap a window around an existing array that encompases the entire array. Windows are windowable. Windowed arrays.Windowed arrays.XYZ[\]^_`   ;XYZ[\]^_` Z[\]^XY_`XYZ[\]^_`  None  &*123468;<=FHJKMa8Constraint synonym that requires an integer index space.c]Class of manifest array representations that can be constructed in a random-access manner.d-Mutable buffer for some array representation.e3Allocate a new mutable buffer for the given layout.>UNSAFE: The integer must be positive, but this is not checked.f(Read an element from the mutable buffer.)UNSAFE: The index bounds are not checked.g)Write an element into the mutable buffer.)UNSAFE: The index bounds are not checked.hVO(n). Copy the contents of a buffer that is larger by the given number of elements.>UNSAFE: The integer must be positive, but this is not checked.i2O(1). Yield a slice of the buffer without copying.UNSAFE: The given starting position and length must be within the bounds of the of the source buffer, but this is not checked.j;O(1). Freeze a mutable buffer into an immutable Repa array.UNSAFE: If the buffer is mutated further then the result of reading from the returned array will be non-deterministic.k*O(1). Thaw an Array into a mutable buffer.+UNSAFE: The Array is no longer safe to use.l{Ensure the array is still live at this point. Sometimes needed when the mutable buffer is a ForeignPtr with a finalizer.m#O(1). Get the layout from a Buffer.n@O(length src). Construct a linear array from a list of elements.o^O(length src). Construct an array from a list of elements, and give it the provided layout.The B of the provided shape must match the length of the list, else .abcdefghijklmnoabcdefghijklmnoabc defghijklmno None  &*123468;<=FHJKMp1Layout an array as flat vector of boxed elements.|UNSAFE: Indexing into raw material arrays is not bounds checked. You may want to wrap this with a Checked layout as well.s&O(1). Wrap a boxed vector as an array.t*O(1). Unwrap a boxed vector from an array.uScan through an array from front to back. For pairs of successive elements, drop the second one when the given predicate returns true.CThis function can be used to remove duplicates from a sorted array.&TODO: generalise to other array types.Boxed buffers.Boxed windows. Boxed arrays. Boxed arrays.pqrstu /;dpqrstupqrstu pqrstuNone  &*123468;<=FHJKMvfCompute all elements defined by a delayed array and write them to a manifest target representation.The instances of this class require that the source array has a delayed representation. If you want to use a pre-existing manifest array as the source then delay it first.w"Fill an entire array sequentially.x!Fill an entire array in parallel.vwxvwxvwx None  &*123468;<=FHJKMyrDelayed arrays wrap functions from an index to element value. The index space is specified by an inner layout, l.XEvery time you index into a delayed array the element at that position is recomputed.|#Wrap a function as a delayed array. S> toList $ fromFunction (Linear 10) (* 2) = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]}SProduce the extent of an array, and a function to retrieve an arbitrary element.~(Wrap an existing array in a delayed one.bApply a worker function to each element of an array, yielding a new array with the same extent.qThe resulting array is delayed, meaning every time you index into it the element at that index is recomputed.  Delayed arrays.!Delayed arrays.yz{"#|}~$% &! ;yz{"|}~yz{|}~yz{|}~$ %"!&# None  &*123468;<=FHJKM Layout for Foreign arrays.|UNSAFE: Indexing into raw material arrays is not bounds checked. You may want to wrap this with a Checked layout as well. O(1). Wrap a ' as an array.,O(1). Convert a foreign array to a storable Vector.O(1). Convert a storable Vector to a foreign ;O(1). Convert a foreign Vector to a (.O(1). Convert a ( to an foreign ;.)Unpack Foreign buffers*Foreign buffers+Windowing Foreign arrays.,Foreign arrays.-Foreign arrays../01)2*+34,5-/;d"./0 1)*2.+3,4/-50None  &*123468;<=FHJKM5Layout an array as a flat vector of unboxed elements.=This is the most efficient representation for numerical data.The implementation uses Data.Vector.Unboxed which picks an efficient, specialised representation for every element type. In particular, unboxed vectors of pairs are represented as pairs of unboxed vectors.|UNSAFE: Indexing into raw material arrays is not bounds checked. You may want to wrap this with a Checked layout as well.)O(1). Wrap an unboxed vector as an array.-O(1). Unwrap an unboxed vector from an array.6Unboxed buffers.7Windowing Unboxed arrays.8Unboxed arrays.9Unboxed arrays.:;<=>67?@8A9/;d":;< =6>:7?8@;9A< None  &*123468;<=FHJKM Produce a Stream% for the elements of the given array.None  &*123468;<=FHJKMcNested array represented as a flat array of elements, and a segment descriptor that describes how the elements are partitioned into the sub-arrays. Using this representation for multidimentional arrays is significantly more efficient than using a boxed array of arrays, as there is no need to allocate the sub-arrays individually in the heap.With a nested type like: Array N (Array N (Array U Int)), the concrete representation consists of five flat unboxed vectors: two for each of the segment descriptors associated with each level of nesting, and one unboxed vector to hold all the integer elements.|UNSAFE: Indexing into raw material arrays is not bounds checked. You may want to wrap this with a Checked layout as well.1O(size src) Convert some lists to a nested array.BO(size src) Convert a triply nested list to a triply nested array.cApply a function to all the elements of a doubly nested array, preserving the nesting structure.JO(1). Produce a nested array by taking slices from some array of elements.This is a constant time operation, as the representation for nested vectors just wraps the starts, lengths and elements vectors._Segmented concatenation. Concatenate triply nested vector, producing a doubly nested vector.Unlike the plain B function, this operation is performed entirely on the segment descriptors of the nested arrays, and does not require the inner array elements to be copied. > import Data.Repa.Nice > nice $ concats $ fromListss U [["red", "green", "blue"], ["grey", "white"], [], ["black"]] ["red","green","blue","grey","white","black"] zO(len src). Given predicates which detect the start and end of a segment, split an vector into the indicated segments.EO(len src). Given a terminating value, split an vector into segments.2The result segments do not include the terminator. > import Data.Repa.Nice > nice $ segmentOn (== ' ') (fromList U "fresh fried fish ") ["fresh "," "," ","fried ","fish "," "] O(len src). Like !, but cut the source array twice.\O(len src). Given field and row terminating values, split an array into rows and fields.zFor each segment of a nested vector, trim elements off the start and end of the segment that match the given predicate.qFor each segment of a nested vector, trim elements off the end of the segment that match the given predicate.rFor each segment of a nested vector, trim elements off the start of the segment that match the given predicate.*Ragged transpose of a triply nested array.This operation is performed entirely on the segment descriptors of the nested arrays, and does not require the inner array elements to be copied.CWindowing Nested arrays.DNested arrays.ENested arrays.FGSegment starting positions.Segment lengths.Array elements.Detect the start of a segment.Detect the end of a segment.Vector to segment.Detect the end of a segment.Vector to segment.%Detect the start of an inner segment.%Detect the end of an inner segment.%Detect the start of an outer segment.%Detect the end of an outer segment.Array to dice.'Terminating element for inner segments.'Terminating element for outer segments.Vector to dice.CHDIE/;";<FGCDHFEIGNone  &*123468;<=FHJKM1/;pqrstu"/0;<FG%pqrstuNone  &*123468;<=FHJKM[The Dense layout maps a higher-ranked index space to some underlying linear index space.oFor example, we can create a dense 2D row-wise array where the elements are stored in a flat unboxed vector: > import Data.Repa.Array.Material > let Just arr = fromListInto (matrix U 10 10) [1000..1099 :: Float] > :type arr arr :: Array (E U (RW DIM2) Float > arr ! (Z :. 5 :. 4) > 1054.0 6Yield a layout for a dense vector of the given length.\The first argument is the name of the underlying linear layout which stores the elements.IYield a layout for a matrix with the given number of rows and columns.PYield a layout for a cube with the given number of planes, rows, and columns.JDense buffers.K Dense arrays.L Dense arrays.MNOPQJRKSL/;dMNOPJQMKRNLSONone  &*123468;<=FHJKMA delayed array formed from two source arrays. The source arrays can have different layouts but must have the same extent.,Wrap two existing arrays in a delayed array.@Combine two arrays element-wise using the given worker function.6The two source arrays must have the same extent, else .TDelayed arrays.UDelayed arrays. VWXYTZU;VXTYVUZWNone  &*123468;<=FHJKMYTupled arrays where the components are unpacked and can have separate representations.(Tuple two arrays into an array of pairs.The two argument arrays must have the same index type, but can have different extents. The extent of the result is the intersection of the extents of the two argument arrays.3Untuple an array of tuples in to a tuple of arrays.The two returned components may have different extents, though they are guaranteed to be at least as big as the argument array. This is the key property that makes  different from unzip.[Tupled buffers.\Tupled windows.]Tupled arrays.^_`ab[\c]de /;d^_`a[b^\]c_ed` Safe-Inferred  &*123468;<=FHJKM6A linear layout with the elements indexed by integers.`Indexing is not bounds checked. Indexing outside the extent yields the corresponding index.TConstruct a linear array that produces the corresponding index for every element. 6> toList $ linear 10 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]fLinear arrays.gLinear layout. hijfkg/;hifjhgki None  &*123468;<=FHJKMTake a desired number of segments, and array of key value pairs where the key is the segment number. Partition the values into the stated number of segments, discarding values where the key falls outside the given range.This function operates by first allocating a buffer of size (segs * len src) and filling it with a default value. Both the worst case runtime and memory use will be poor for a large number of destination segments. TODO: we need the pre-init because otherwise unused values in the elems array are undefined. We could avoid this by copying out the used elements after the partition loop finishes. Use a segmented extract function. This would also remove the dependency on the l class.Like R but use the provided function to compute the segment number for each element. Like  but use the provided function to compute the segment number for each element. The function is given the index of the each element, along with the element itself.Name of destination layout.Total number of segments.Segment numbers and values. Result arrayName of destination layout.Total number of Segments.(Get the segment number for this element.Source values.Name of destination layout.Total number of Segments.(Get the segment number for this element.Source values. None  &*123468;<=FHJKM1Sequential computation of delayed array elements.nElements of the source array are computed sequentially and written to a new array of the specified layout.Like ( but use the provided desination layout.TThe size of the destination layout must match the size of the source array, else .abcdefghijklmvwxcdefghijklmabvwxNone  &*123468;<=FHJKM Produce a m for the elements of the given array. The order in which the elements appear in the chain is determined by the layout of the array.n%Lift a pure chain to a monadic chain.Compute the elements of a pure m#, writing them into a new array ;.Compute the elements of an o m, writing them to a new ;.nn!None  &*123468;<=FHJKM/Dictionaries needed to perform a concatenation.(O(len result) Concatenate nested arrays. > import Data.Repa.Array.Material > let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]] > toList $ concat U arrs [1,2,3,5,6,7] O(len result) Concatenate the elements of some nested vector, inserting a copy of the provided separator array between each element. > import Data.Repa.Array.Material > let sep = fromList U [0, 0, 0] > let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]] > toList $ concatWith U sep arrs [1,2,3,0,0,0,5,6,7,0,0,0]  Perform a ?, adding a newline character to the end of each inner array.tO(len result) Insert a copy of the separator array between the elements of the second and concatenate the result. > import Data.Repa.Array.Material > let sep = fromList U [0, 0, 0] > let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]] > toList $ intercalate U sep arrs [1,2,3,0,0,0,5,6,7] Layout for destination.Arrays to concatenate.Result representation.Separator array.Arrays to concatenate.Result representation.Arrays to concatenate.Result representation.Separator array.Arrays to concatenate."None  &*123468;<=FHJKM(Dictionaries need to perform a grouping.xFrom a stream of values which has consecutive runs of idential values, produce a stream of the lengths of these runs. j> import Data.Repa.Array.Material > import Data.Repa.Nice > nice $ groups U U (fromList U "waaabllle") ([(w,1),(a,3),(b,1),(l ,3)],Just (e,1)) Like , but use the given function to determine whether two consecutive elements should be in the same group. Also take an initial starting group and count. ^> import Data.Repa.Array.Material > import Data.Repa.Nice > nice $ groupsWith U U (==) (Just (w", 5)) (fromList U "waaabllle") ([(w,6),(a,3),(b,1),(l ,3)],Just (e,1)) Layout for group names.Layout gor group lengths.Input elements.Layout for group names.Layour for group lengths.Comparison function.Starting element and count.Input elements.#None  &*123468;<=FHJKM.Dictionaries need to perform a segmented fold.@Segmented fold over vectors of segment lengths and input values.lThe total lengths of all segments need not match the length of the input elements vector. The returned  state can be inspected to determine whether all segments were completely folded, or the vector of segment lengths or elements was too short relative to the other. > import Data.Repa.Array.Material > import Data.Repa.Nice > let segs = fromList B [("red", 3), ("green", 5)] > let vals = fromList U [0..100 :: Int] > nice $ fst $ folds B U (+) 0 segs vals [("red",3),("green",25)] Like 2, but take an initial state for the first segment. > import Data.Repa.Array.Material > import Data.Repa.Nice > let state = Just ("white", 4, 100) > let segs = fromList B [("red", 3), ("green", 5)] > let vals = fromList U [0..100 :: Int] > nice $ fst $ foldsWith B U (+) 0 state segs vals [("white",106),("red",15),("green",45)] Layout for group names.Layout for fold results.Worker function.$Initial state when folding segments.Segment names and lengths. Elements.Layout for group names.Layout for fold results.Worker function.$Initial state when folding segments.1Name, length and initial state for first segment.Segment names and lengths. Elements. $None  &*123468;<=FHJKM4Left fold of all elements in an array, sequentially.%None  &*123468;<=FHJKM=Keep the elements of an array that match the given predicate.None  &*123468;<=FHJKM2Classes supported by all material representations.}We can index them in a random-access manner, window them in constant time, and use them as targets for a computation.eIn particular, delayed arrays are not material as we cannot use them as targets for a computation.5O(1). View the elements of a vector in reverse order. H> toList $ reverse $ fromList U [0..10 :: Int] [10,9,8,7,6,5,4,3,2,1,0] O(len src) Yield p= the index of the first element matching the predicate or  if no such element exists.Like , but immediately  the result.Like , but immediately  the result.Name of destination layout.Worker function. Source array.Name of destination layout.Worker function. Source array. Source array{ !"#$%&'()*+,-./0123459:;<=>?@FGHIXYZ[\]^_`cnovyz{|}~O`iQ:;<=9>?FGHIyz{|}~Z[\]^XY_`no@vcNone  &*123468;<=FHJKM!A date packed into a 32-bit word.The bitwise format is: I 32 16 8 0 | year | month | day | Pros: Packing and unpacking a Date32 is simpler than using other formats that represent dates as a number of days from some epoch. We can also avoid worrying about what the epoch should be, and the representation will not overflow until year 65536. Cons: Computing a range of dates is slower than with representations using an epoch, as we cannot simply add one to get to the next valid date."Pack a year, month and day into a q. If any components of the date are out-of-range then they will be bit-wise truncated so they fit in their destination fields. Inverse of .<This function does a simple bit-wise unpacking of the given qo, and does not guarantee that the returned fields are within a valid range for the given calendar date."Yield the next date in the series.hThis assumes leap years occur every four years, which is valid after year 1900 and before year 2100.HYield an array containing a range of dates, inclusive of the end points.Read a D in ASCII YYYYsMMsDD format, using the given separator character s.rrNone  &*123468;<=FHJKM6Get data from a file, up to the given number of bytes.IData is read into foreign memory without copying it through the GHC heap.uGet data from a file, up to the given number of bytes, also copying the given data to the front of the new buffer.IData is read into foreign memory without copying it through the GHC heap.Write data into a file.cData is written to file directly from foreign memory, without copying it through the GHC heap.PRead a CSV file as a nested array. We get an array of rows:fields:characters.QWrite a nested array as a CSV file. The array contains rows:fields:characters.None  &*123468;<=FHJKM3Convert a foreign vector of characters to a Double.The standard Haskell sD type is four bytes in length. If you already have a vector of t then use & instead to avoid the conversion..Convert a foreign vector of bytes to a Double. Convert a u% to ASCII text packed into a foreign Vector. Convert a u% to ASCII text packed into a foreign Vector.Like >, but use a fixed number of digits after the decimal point.Like >, but use a fixed number of digits after the decimal point.vvNone  &*123468;<=FHJKM"Convert some value to a nice form.In particular:kNested Arrays are converted to nested lists, so that they are easier to work with on the ghci console.)Lists of characters are wrapped into the X data type, so that they can be pretty printed differently by follow-on processing.1As ghci automatically pretty prints lists, using nice is more fun than trying to show$ the raw Repa array representations.aWrapper to indicate a list of characters should be printed as a string, without double quotes.cWrapper to indicate a list of characters should be printed as a string, including double quotes.!wxyz{|}~wxyz{|}~None  &*123468;<=FHJKM 5Convert some value to a form presentable to the user.Like ` but we allow the nesting structure to be preserved so it can be displayed in tabular format.A value, wrapped up nicely.7Some different things, to display with tuple brackets  (.. , ..)6Many of the same thing, to display with list brackets  [.. , ..]An atomic thing.Yield the nesting depth of a /Strip the top two layers of nesting into lists.+Strip the top layer of nesting into a list.Flatten a present into textNone  &*123468;<=FHJKM4Print a nested value to the console in tabular form.The first two layers of nesting are displayed as rows and columns. Numeric data is right-justified, while the rest is left-justified. ^> tab [[10, 20, 302], [40, 50], [60, 7001, 80, 90 :: Int]] 10 20 302 40 50 60 7001 80 90 5Deeper layers of nesting are preserved in the output: k> tab [[[10], [20, 21]], [[30, 31], [40, 41, 41], [50 :: Int]]] [10] [20,21] [30,31] [40,41,41] [50] 7By default, strings are printed as lists of characters: > tab [[("red", 10), ("green", 20), ("blue", 30)], [("grey", 40), ("white", 50 :: Int)]] (['r','e','d'],10) (['g','r','e','e','n'],20) (['b','l','u','e'],30) (['g','r','e','y'],40) (['w','h','i','t','e'],50) 7If you want double-quotes then wrap the strings with a Str constructor: > tab [[(Str "red", 10), (Str "green", 20), (Str "blue", 30)], [(Str "grey", 40), (Str "white", 50 :: Int)]] ("red",10) ("green",20) ("blue",30) ("grey",40) ("white",50) 3If you don't want any quotes then wrap them with a Tok constructor: > tab [[(Tok "red", 10), (Tok "green", 20), (Tok "blue", 30)], [(Tok "grey", 40), (Tok "white", 50 :: Int)]] (red,10) (green,20) (blue,30) (grey,40) (white,50) 'Display a nested value in tabular form.& Safe-Inferred  &*123468;<=FHJKM '()'(*'(+'(,'(-'(.'(./01234556789:;<=>?@@AABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{{||}~          !!!!!"""###$%^      !"#$%&'()*+,-./012345f467 8 9 : ; < =  > ? @ A B C D  E F G4HIJKL > M N O P Q R  S T U V WXYZ[\]>^U_`45abcdefghijbklmnopqrstuvwxykz{|}~'46444&&&&&&&&&repa-array-4.0.0.2Data.Repa.Array Data.Repa.Array.Material.UnboxedData.Repa.Nice.DisplayData.Repa.Array.IndexData.Repa.Fusion.UnpackData.Repa.Array.RowWiseData.Repa.Array.Index.SliceData.Repa.Array.WindowData.Repa.Eval.ArrayData.Repa.Array.Material.BoxedData.Repa.Array.Delayed Data.Repa.Array.Material.ForeignData.Repa.Eval.StreamData.Repa.Array.Material.NestedData.Repa.Array.DenseData.Repa.Array.Delayed2Data.Repa.Array.TupleData.Repa.Array.LinearData.Repa.Eval.ChainData.Repa.Bits.Date32Data.Repa.IO.ArrayData.Repa.IO.ConvertData.Repa.NiceData.Repa.Nice.PresentData.Repa.Nice.TabulateData.Repa.Array.Internals.Shape Data.Repa.Array.Internals.LayoutData.Repa.Array.Internals.Bulk Data.Repa.Array.Internals.TargetData.Repa.Array.Internals.LoadData.Repa.Array.Material,Data.Repa.Array.Internals.Operator.Partition)Data.Repa.Array.Internals.Operator.Concat(Data.Repa.Array.Internals.Operator.Group'Data.Repa.Array.Internals.Operator.Fold)Data.Repa.Array.Internals.Operator.Reduce)Data.Repa.Array.Internals.Operator.FilterData.Repa.Array.Internals.Checkrepa-stream-4.0.0.1Data.Repa.Chain.Folds_valSeg_lenSeg_nameSeg _stateVals _stateLensFoldsvector-0.10.12.2Data.Vector.Unboxed.BaseUnboxFormat FormatText FormatNumericDisplaydisplay takeDisplaypadLpadRSH5SH4SH3SH2SH1SH0:.ZShaperankzeroDimunitDim intersectDimaddDimsize inShapeRange listOfShape shapeOfListinShape showShapeish0ish1ish2ish3ish4ish5LayoutILayoutNameIndexnamecreateextenttoIndex fromIndexUnpackunpackrepackBulkIBulkArraylayoutindex!lengthtoListDIM5DIM4DIM3DIM2DIM1RWRowWise rowWiseShaperowWiseix1ix2ix3ix4ix5Slice sliceOfFull fullOfSlice SliceShape FullShapeAnyAll WindowablewindowWWindow windowStart windowSize windowInnerwindowedentireTargetIIOBufferTargetBufferunsafeNewBufferunsafeReadBufferunsafeWriteBufferunsafeGrowBufferunsafeSliceBufferunsafeFreezeBufferunsafeThawBuffer touchBuffer bufferLayoutfromList fromListIntoBBoxed boxedLength fromBoxedtoBoxeddecimateLoadloadSloadPDDelayed delayedLayout fromFunction toFunctiondelaymapFForeign foreignLengthfromForeignPtr toForeignPtrtoStorableVectorfromStorableVector toByteStringfromByteStringUUnboxed unboxedLength fromUnboxed toUnboxed streamOfArrayNNested nestedLength fromLists fromListssmapElemsslicesconcatssegment segmentOndicediceSeptrimstrimEnds trimStarts ragspose3EDensevectormatrixcubeD2Delayed2delayed2Layout1delayed2Layout2delay2map2T2Tup2tup2untup2LLinear linearLengthlinear partition partitionBy partitionByIxcomputeS computeIntoS chainOfArrayunchainToArrayunchainToArrayIO ConcatDictconcat concatWithunlines intercalate GroupsDictgroups groupsWith FoldsDictfolds foldsWithfoldlfilterMaterialreverse findIndexmapSmap2SDate32packnextrangereadYYYYsMMsDD hGetArray hGetArrayPre hPutArrayhGetArrayFromCSVhPutArrayAsCSV readDoublereadDoubleFromBytes showDoubleshowDoubleAsBytesshowDoubleFixedshowDoubleFixedAsBytesNicerNiceniceTokStr PresentablepresentPresentSomeManyAtomdepthstrip2strip1flattentabtabulate$fMonoidDisplay $fShape:.$fShapeZ $fShapeInttoListstoListss $fBulkRWshRArrayRCRZTFCo:R:ArrayRWsh TFCo:R:NameRW $fLayoutRWTFCo:R:NameRW0 $fLayoutRW0 $fShapeRW $fSlice:. $fSlice:.0 $fSliceAny$fSliceZTFCo:R:SliceShape:.TFCo:R:SliceShape:.0TFCo:R:SliceShapeAnyTFCo:R:SliceShapeZTFCo:R:FullShape:.TFCo:R:FullShape:.0TFCo:R:FullShapeAnyTFCo:R:FullShapeZ$fWindowableWa$fBulkWa $fLayoutWWArrayTFCo:R:ArrayWa TFCo:R:NameWbaseGHC.List Data.MaybeNothing $fTargetBa$fWindowableBa$fBulkBa $fLayoutBBBufferBArray$fUnpackBufferMVectorTFCo:R:BuffersBaTFCo:R:ArrayBa TFCo:R:NameB$fBulkDa $fLayoutDADelayed $fLoadDl2aTFCo:R:ArrayDa TFCo:R:NameDGHC.ForeignPtr ForeignPtrbytestring-0.10.4.0Data.ByteString.Internal ByteString $fTargetFa$fWindowableFa$fBulkFa $fLayoutFFBufferFArray $fEqArrayTFCo:R:BuffersFa$fUnpackArrayVectorTFCo:R:ArrayFa TFCo:R:NameF $fTargetUa$fWindowableUa$fBulkUa $fLayoutUUBufferUArrayTFCo:R:BuffersUaTFCo:R:ArrayUa TFCo:R:NameU$fWindowableNArray $fBulkNArray $fLayoutNNArrayTFCo:R:ArrayNArray TFCo:R:NameN $fTargetEa$fBulkEa $fLayoutEEBuffer$fUnpackBuffer(,)TFCo:R:BuffersEaTFCo:R:ArrayEa TFCo:R:NameE $fBulkD2a $fLayoutD2 ADelayed2 $fLoadD2lDstaTFCo:R:ArrayD2a TFCo:R:NameD2 $fTargetT2(,)$fWindowableT2(,) $fBulkT2(,)T2BufferT2ArrayTFCo:R:BuffersT2(,)TFCo:R:ArrayT2(,) TFCo:R:NameT2 $fLayoutT2 $fBulkLInt $fLayoutLLArrayTFCo:R:ArrayLInt TFCo:R:NameLrepa-eval-4.0.0.1Data.Repa.Eval.EltEltData.Repa.Chain.BaseChain liftChainghc-prim GHC.TypesIOJustGHC.WordWord32next'CharWord8Doublestrtod $fNicer[] $fNicer[]0 $fNicer[]1 $fNicer[]2 $fNicerArray $fNicer(,) $fNicerMaybe $fNicer[]3 $fNicer[]4 $fNicer[]5 $fNicer[]6 $fNicer[]7 $fNicer[]8 $fNicer[]9 $fNicer[]10 $fNicerWord64 $fNicerWord32 $fNicerWord16 $fNicerWord8 $fNicerChar $fNicerDouble $fNicerFloat $fNicerInt $fNicer() $fShowTok $fShowStrGHC.Showshow$fPresentable(,,,,)$fPresentable(,,,)$fPresentable(,,)$fPresentable(,)$fPresentable[]$fPresentableTok$fPresentableStr$fPresentableWord64$fPresentableWord32$fPresentableWord16$fPresentableWord8$fPresentableDouble$fPresentableFloat$fPresentableInt$fPresentableChar tabulate1 tabulate2UnsafeSafeCheckmethodcheck $fCheckUnsafe $fCheckSafe