!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None non-portable (GHC extensions) /Scalar types supported in array computations/ Integral types: Int, Int8, Int16, Int32, Int64, Word, Word8, Word16, Word32, Word64, CShort, CUShort, CInt, CUInt, CLong, CULong, CLLong, CULLong Floating types: Float, Double, CFloat, CDouble Non-numeric types: Bool, Char, CChar, CSChar, CUChar 'Int' has the same bitwidth as in plain Haskell computations, and 'Float' and 'Double' represent IEEE single and double precision floating point numbers, respectively. experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None9Boundary condition specification for stencil operations. /use a constant value for outlying coordinates *wrap coordinates around on each dimension +mirror coordinates beyond the array extent -clamp coordinates to the extent of the array All scalar type !Bounded types "Numeric types #Non-numeric types $Floating types %Integral types +All scalar element types implement Eq, Ord & Enum (Bounded element types implement Bounded $Numeric element types implement Num & Real 3Non-numeric types supported in array computations. 6Floating-point types supported in array computations. 0Integral types supported in array computations.  !"#$%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~c  !"#$%      !"#$%&'()*+,-. !"#$%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneLGeneralised array index, which may index only in a subset of the dimensions  of a shape. Slice representation 8Class of slice representations (which are nested pairs) Index representation 8Class of index representations (which are nested pairs) /number of dimensions (>= 0); rank of the array -total number of elements in an array of this shape   non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneGADT to reify the  class. Mutable array representation Immutable array representation >Safe combination of creating and fast freezing of array data. 82 non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None!&$Slices, aka generalised indices, as n1-tuples and mappings of slice indices to slices, ! co-slices, and slice dimensions +/Shapes and indices of multi-dimensional arrays Number of dimensions of a shape or index (>= 0). 2Total number of elements in an array of the given shape. ,Magic value identifying elements ignored in permute. ?Map a multi-dimensional index into one in a linear, row-major 4 representation of the array (first argument is the shape , second  argument is the index). (Apply a boundary condition to an index. HIterate through the entire shape, applying the function; third argument G combines results and fourth is returned in case of an empty iteration 9 space; the index space is traversed in row-major order. )Convert a minpoint-maxpoint index into a shape.  Convert a shape! into a minpoint-maxpoint index. )Convert a shape to a list of dimensions.  +Convert a list of dimensions into a shape.  $The slice index for slice specifier 'Any sh' 6/Segment descriptor (vector of segment lengths) ^To represent nested one-dimensional arrays, we use a flat array of data values in conjunction  with a segment descriptor-, which stores the lengths of the subarrays. 7Vectors 8Scalars 9.Multi-dimensional arrays for array processing K If device and host memory are separate, arrays will be transferred to the J device when necessary (if possible asynchronously and in parallel with L other tasks) and cached on the device if sufficient memory is available. ;^Class that characterises the types of values that can be array elements, and hence, appear in  scalar Accelerate expressions.  Type representation mapping We represent tuples by using '()' and '(,)'7 as type-level nil and snoc to construct snoc-lists of  types. <1Marker for arbitrary shapes in slice descriptors >2Marker for entire dimensions in slice descriptors @(Increase an index rank by one dimension B#Array indices are snoc type lists. 2 For example, the type of a rank-2 array index is Z :.Int :. Int.  Rank-0 index  Convenience functions  Yield an array's shape Array indexing 1Create an array from its representation function /Creates a new, uninitialized Accelerate array. D Convert an  to an accelerated array. E#Convert an accelerated array to an  FKConvert a list (with elements in row-major order) to an accelerated array. G;Convert an accelerated array to a list in row-major order. "Nicely format a shape as a string y&'()*+  ,-./0123456789:; !"#$%& <=>?@ABC '()* DEFG+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWK&'()*+  ,-./0123456789:; !"#$%& <=>?@ABC'()* DEFGV&'()*+   ,-./0123456789:; !"#$%& <=>?@ABC '()* DEFG+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWnon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneXBConversion between surface n-tuples and our tuple representation. Y)Type-safe projection indices for tuples. ;NB: We index tuples by starting to count from the *right*! ZAWe represent tuples as heterogenous lists, typed by a type list. X[\]Y^_`abZcdefghijklm X[\]Y^_`abZcd X[\]Y_^`baZdcefghijklm non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NonenPrimitive scalar operations oPrimitive GPU constants p1Vanilla expression without free scalar variables q6Parametrised expression without free scalar variables rVanilla open expression sXParametrised open expressions using de Bruijn indices for variables ranging over tuples ^ of scalars and arrays of tuples. All code, except Cond, is evaluated eagerly. N-tuples are  represented as nested pairs. TThe data type is parametrised over the surface types (not the representation type). t/Vanilla function without free scalar variables u4Parametrised function without free scalar variables v"Vanilla open function abstraction w'Parametrised open function abstraction xGADT reifying the y class. yOperations on stencils. z-Closed array expression aka an array program {@Collective array computations parametrised over array variables % represented with de Bruijn indices. @ Scalar functions and expressions embedded in well-formed array I computations cannot contain free scalar variable indices. The latter J cannot be bound in array computations, and hence, cannot appear in any  well-formed program. D The let-form is used to represent the sharing discovered by common J subexpression elimination as well as to control evaluation order. (We M need to hoist array expressions out of scalar expressions - they occur in 8 scalar indexing and in determining an arrays shape.) NThe data type is parameterised over the surface types (not the representation  type). `We use a non-recursive variant parametrised over the recursive closure, to facilitate attribute  calculation in the backend. |@Vanilla array-computation function without free array variables }EParametrised array-computation function without free array variables ~:Function abstraction over parametrised array computations nopqrstuvwxyz{|}~ nopqrstuvwxyz{|}~"n6opqrstuvwxyz{|}~ non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None DReify the dimensionality of the result type of an array computation  MReify dimensionality of a computation parameterised over a recursive closure            non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneJCalculate the offset coordinates for each stencil element relative to the H focal point. The coordinates are returned as a flattened list from the N bottom-left element to the top-right. This ordering matches the Var indexing  order. 0Position calculation on reified stencil values.  non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None%Determine the type of an expressions ' ------------------------------------- Determine an array type  ------------------------ $Reify the element type of an array. >Reify the element type of the result of an array computation. ]Reify the element type of the result of an array computation using the array computation AST  before tying the knot. .Reify the result type of a scalar expression. [Reify the result types of of a scalar expression using the expression AST before tying the  knot. Size of a tuple type, in bytes  non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None  !"#non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None$%&'()*+,-./01234567 $%&)*+,-.6$%&'()*+,-./01234567non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None8Show instances  --------------- 9:8 $%&)*+,-.69:8non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneHInitialise the  trace flag?, which determines whether tracing messages should be emitted. ;Read the value of the  trace flag. <Emit a trace message if the  trace flag5 is set. The first string indicates the location of a the message. The second one is the message itself. The output is formatted to be on one line. =Emit a trace message if the  trace flag5 is set. The first string indicates the location of \ the message. The second one is the message itself. The output is formatted over multiple  lines. >Perform < in a pure computation. ?H;<=>H;<=>?H;<=>non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneJ1Scalar expressions for plain array computations. @]Scalar expressions to parametrise collective array operations, themselves parameterised over * the type of collective array operations. K%Array-valued collective computations A>Array-valued collective computations without a recursive knot Note [Pipe and sharing recovery] " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  The BQ constructor is special. It is the only form that contains functions over array ? computations and these functions are fixed to be over vanilla K types. This enables us to C perform sharing recovery independently from the context for them. C2Conversion from HOAS to de Bruijn computation AST  - UConvert a closed array expression to de Bruijn form while also incorporating sharing  information. DTConvert an open array expression to de Bruijn form while also incorporating sharing  information. E1Convert a unary function over array computations F]Convert an array expression with given array environment layout and sharing information into Z de Bruijn form while recovering sharing at the same time (by introducing appropriate let H bindings). The latter implements the third phase of sharing recovery. The sharing environment envD keeps track of all currently bound sharing variables, keeping them P in reverse chronological order (outermost variable is at the end of the list). GConvert a boundary condition H1Conversion from HOAS to de Bruijn expression AST  - WConvert an open expression with given environment layouts and sharing information into Z de Bruijn form while recovering sharing at the same time (by introducing appropriate let H bindings). The latter implements the third phase of sharing recovery. The sharing environments env and aenv6 keep track of all currently bound sharing variables, ] keeping them in reverse chronological order (outermost variable is at the end of the list). IConvert a tuple expression J5Convert an expression closed wrt to scalar variables KConvert a unary functions LConvert a binary functions MTRecover sharing information and annotate the HOAS AST with variable and let binding [ annotations. The first argument determines whether array computations are floated out of > expressions irrespective of whether they are shared or not  N implies floating them out. Also returns the O s of all P. leaves in environment order  they represent  the free variables of the AST. YNB: Strictly speaking, this function is not deterministic, as it uses stable pointers to W determine the sharing of subterms. The stable pointer API does not guarantee its a completeness; i.e., it may miss some equalities, which implies that we may fail to discover Z some sharing. However, sharing does not affect the denotational meaning of an array H computation; hence, we do not compromise denotational correctness. .There is one caveat: We currently rely on the P and Q leaves representing free ` variables to be shared if any of them is used more than once. If one is duplicated, the ^ environment for de Bruijn conversion will have a duplicate entry, and hence, be of the ( wrong size, which is fatal. (The 'buildInitialEnv*'# functions will already bail out.) LConstant scalar expression IRSTUVWXYZ[\]^_`aObcdefghijklmnJo@pqrstuvwxyz{|}QK~ABPCDEFGHIJKLML      !"#$%&'()*+,-./012345678IRSJo@pqrstuvwxyz{|}QK~ABPCEL      !"#$%&'IRSTVUWXYZ\[]`_^aObcfedghijklmnJo@Q}|{zyxwvutsrqpK~APBCDEFGHIJKLML      !"#$%&'()*+,-./012345678non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneMGRun a complete embedded array program using the reference interpreter. NEStream a lazily read list of input arrays through the given program,  collecting results as we go a9MN:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZOP[Q\]^_`abcdefghijklmnopqrstuvwxyz{|}~:MNOPQ:MNPOQa9MN:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZOP[Q\]^_`abcdefghijklmnopqrstuvwxyz{|}~non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>Nonenon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None=SHUnlift the outermost constructor through the surface type. This is only M possible if the constructor is fully determined by its type - i.e., it is a  singleton. V)Lift the given value into a surface type c --- either J for scalar  expressions or K7 for array computations. The value may already contain  subexpressions in c. gJArray inlet: makes an array available for processing using the Accelerate E language; triggers asynchronous host->device transfer if necessary. hHScalar inlet: injects a scalar (or a tuple of scalars) into a singleton + array for use in the Accelerate language. iEReplicate an array across one or more dimensions as specified by the ; *generalised* array index provided as the first argument. For example, assuming arr& is a vector (one-dimensional array),  ! replicate (Z :.2 :.All :.3) arr (yields a three dimensional array, where arr is replicated twice across the 3 first and three times across the third dimension. j<Construct a new array by applying a function to each index. AFor example, the following will generate a one-dimensional array  (7#) of three floating point numbers:  ! generate (index1 3) (\_ -> 1.2) Or, equivalently:  1 generate (constant (Z :. (3::Int))) (\_ -> 1.2) :Finally, the following will create an array equivalent to '[1..10]':  generate (index1 10) $ \ ix -> # let (Z :. i) = unlift ix  in fromIntegral i kBChange the shape of an array without altering its contents, where # precondition: size ix == size ix' lHIndex an array with a *generalised* array index (supplied as the second I argument). The result is a new array (possibly a singleton) containing # all dimensions in their entirety. m:Apply the given function element-wise to the given array. n]Apply the given binary function element-wise to the two arrays. The extent of the resulting D array is the intersection of the extents of the two source arrays. oaReduction of the innermost dimension of an array of arbitrary rank. The first argument needs to  be an  associative: function to enable an efficient parallel implementation. p Variant of o: that requires the reduced array to be non-empty and doesn't need an default  value. qZSegmented reduction along the innermost dimension. Performs one individual reduction per E segment of the source array. These reductions proceed in parallel. 1The source array must have at least rank 1. The 6% array determines the lengths of the 9 logical sub-arrays, each of which is folded separately. r Variant of q that requires all3 segments of the reduced array to be non-empty and  doesn't need a default value. 0The source array must have at least rank 1. The 6% array determines the lengths of the 9 logical sub-arrays, each of which is folded separately. sN-style left-to-right scan, but with the additional restriction that the first  argument needs to be an  associative: function to enable an efficient parallel implementation. 7 The initial value (second argument) may be arbitrary. t Variant of sB, where the final result of the reduction is returned separately.  Denotationally, we have 9 scanl' f e arr = (crop 0 (len - 1) res, unit (res!len))  where  len = shape arr  res = scanl f e arr uU style left-to-right scan without an initial value (aka inclusive scan). Again, the  first argument needs to be an  associative$ function. Denotationally, we have ! scanl1 f e arr = crop 1 len res  where  len = shape arr  res = scanl f e arr vRight-to-left variant of s. wRight-to-left variant of t. xRight-to-left variant of u. yHForward permutation specified by an index mapping. The result array is N initialised with the given defaults and any further values that are permuted F into the result array are added to the current value using the given  combination function. !The combination function must be  associative. Elements that are mapped to  the magic value 0 by the permutation function are being dropped. zBackward permutation {-Map a stencil over an array. In contrast to m), the domain of a stencil function is an  entire  neighbourhoodH of each array element. Neighbourhoods are sub-arrays centred around a _ focal point. They are not necessarily rectangular, but they are symmetric in each dimension a and have an extent of at least three in each dimensions  due to the symmetry requirement, the ^ extent is necessarily odd. The focal point is the array position that is determined by the  stencil. \For those array positions where the neighbourhood extends past the boundaries of the source Y array, a boundary condition determines the contents of the out-of-bounds neighbourhood  positions. |\Map a binary stencil of an array. The extent of the resulting array is the intersection of ' the extents of the two source arrays. }&Pipelining of two array computations. Denotationally, we have  8 (acc1 >-> acc2) arrs = let tmp = acc1 arrs in acc2 tmp &Operationally, the array computations acc1 and acc2& will not share any sub-computations, ` neither between each other nor with the environment. This makes them truly independent stages / that only communicate by way of the result of acc1& which is being fed as an argument to acc2. ~'An array-level if-then-else construct. Infix version of ~. Lift a unary function into J. Lift a binary function into J. <Lift a unary function to a computation over rank-1 indices. =Lift a binary function to a computation over rank-1 indices. 'Extract the first component of a pair. (Extract the second component of a pair. 6Converts an uncurried function to a curried function. 4Converts a curried function to a function on pairs. "The one index for a rank-0 array. Turn an / expression into a rank-1 indexing expression. *Turn a rank-1 indexing expression into an  expression. 'Creates a rank-2 index from two Exp Int`s 3Destructs a rank-2 index to an Exp tuple of two Int`s. Conditional expression. 6Expression form that extracts a scalar from an array. 0Extraction of the element in a singleton array. 3Expression form that yields the shape of an array. 2Expression form that yields the size of an array.  The same as 2 but not operates directly on a shape without the  array. -Equality lifted into Accelerate expressions. /Inequality lifted into Accelerate expressions. 1Smaller-than lifted into Accelerate expressions. 5Greater-or-equal lifted into Accelerate expressions. 1Greater-than lifted into Accelerate expressions. 5Smaller-or-equal lifted into Accelerate expressions. &Determine the maximum of two scalars. &Determine the minimum of two scalars. $Conversions from the RealFrac class  Conjunction  Disjunction  Negation Convert a Boolean value to an , where  turns into '0' and N  into '1'. %General coercion from integral types KMagic value identifying elements that are ignored in a forward permutation RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxycombination function array of default values  permutation array to be permuted zshape of the result array  permutation  source array {stencil function boundary condition  source array destination array |binary stencil function boundary condition #1  source array #1 boundary condition #2  source array #2 destination array }~ if-condition  then-array  else-array gIJKLRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None&ICombine the elements of two arrays pairwise. The shape of the result is . the intersection of the two argument shapes. HTake three arrays and and return an array of triples, analogous to zip. KTake three arrays and and return an array of quadruples, analogous to zip. The converse of 7, but the shape of the two results is identical to the  shape of the argument. FTake an array of triples and return three arrays, analogous to unzip. HTake an array of quadruples and return four arrays, analogous to unzip. bReduction of an array of arbitrary rank to a single scalar value. The first argument needs to be  an  associative: function to enable an efficient parallel implementation.  Variant of : that requires the reduced array to be non-empty and doesn't need an default  value. 4Left-to-right prescan (aka exclusive scan). As for scan , the first argument must be an   associative$ function. Denotationally, we have ) prescanl f e = Prelude.fst . scanl' f e %Left-to-right postscan, a variant of u1 with an initial value. Denotationally, we have ( postscanl f e = map (e `f`) . scanl1 f 4Right-to-left prescan (aka exclusive scan). As for scan , the first argument must be an   associative$ function. Denotationally, we have ) prescanr f e = Prelude.fst . scanr' f e %Right-to-left postscan, a variant of x1 with an initial value. Denotationally, we have ( postscanr f e = map (e `f`) . scanr1 f Segmented version of s. Segmented version of t. LThe first element of the resulting tuple is a vector of scanned values. The L second element is a vector of segment scan totals and has the same size as  the segment vector. Segmented version of u. Segmented version of . Segmented version of . Segmented version of v. Segmented version of w. Segmented version of x. Segmented version of . Segmented version of . >Compute head flags vector from segment vector for left-scans. ?Compute tail flags vector from segment vector for right-scans. YConstruct a segmented version of apply from a non-segmented version. The segmented apply & operates on a head-flag value tuple. /Flattens a given array of arbitrary dimension. 7Create an array where all elements are the same value. ICreate an array of the given shape containing the values x, x+1, etc (in  row-major order). LCreate an array of the given shape containing the values x, x+y, x+y+y, etc  (in row-major order). NCopy elements from source array to destination array according to a map. This & is a backpermute operation where a m# vector encodes the ouput to input  index mapping. For example: #input = [1, 9, 6, 4, 4, 2, 0, 1, 2]  map = [1, 3, 7, 2, 5, 3] output = [9, 4, 1, 6, 2, 4] MConditionally copy elements from source array to destination array according 6 to a map. This is a backpermute opereation where a m vector encdes the : output to input index mapping. In addition, there is a mask vector, and an N associated predication function, that specifies whether an element will be E copied. If not copied, the output array assumes the default vector' s value.  For example: default = [6, 6, 6, 6, 6, 6]  map = [1, 3, 7, 2, 5, 3]  mask = [3, 4, 9, 2, 7, 5]  pred = (> 4) ( input = [1, 9, 6, 4, 4, 2, 0, 1, 2] output = [6, 6, 1, 6, 2, 4] NCopy elements from source array to destination array according to a map. This * is a forward-permute operation where a m# vector encodes an input to output M index mapping. Output elements for indices that are not mapped assume the  default vector's value. For example: $default = [0, 0, 0, 0, 0, 0, 0, 0, 0]  map = [1, 3, 7, 2, 5, 8] " input = [1, 9, 6, 4, 4, 2, 5] $output = [0, 1, 4, 9, 0, 4, 0, 6, 2] HNote if the same index appears in the map more than once, the result is E undefined. The map vector cannot be larger than the input vector. MConditionally copy elements from source array to destination array according 9 to a map. This is a forward-permute operation where a m vector encodes an : input to output index mapping. In addition, there is a mask vector, and an M associated predicate function, that specifies whether an elements will be E copied. If not copied, the output array assumes the default vector' s value.  For example: $default = [0, 0, 0, 0, 0, 0, 0, 0, 0]  map = [1, 3, 7, 2, 5, 8]  mask = [3, 4, 9, 2, 7, 5]  pred = (> 4)  input = [1, 9, 6, 4, 4, 2] $output = [0, 0, 0, 0, 0, 4, 0, 6, 2] HNote if the same index appears in the map more than once, the result is C undefined. The map and input vector must be of the same length. Yield the first n7 elements of the input vector. The vector must contain  no more than n elements. Yield all but the first n/ elements of the input vector. The vector must  contain no more than n elements. GYield all but the last element of the input vector. The vector may not  be empty. HYield all but the first element of the input vector. The vector may not  be empty. GYield a slit (slice) from the vector. The vector must contain at least  i + n elements. 'x y map input output map mask  predicate default input output map default input output map mask  predicate default input output #'non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None%Array indexing in plain Haskell code "Array shape in plain Haskell code   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  "!%$#:9876;BC@A+>?<=&'()*543210/.-,DEFGKJIfedcba`_^]\[ZYXWLghijklmnopqrstuvwxyz{|}~TUVRSH  !"#$%&%'%(%)*+*,*-*.*/*0*1*2*3*4*5*6*789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYYZZ[[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012345678899::;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~CHDEFG     V !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop q r c s t u v w x y z b d { | } ~                                                           H   r        ]                  b                        c                                                     !"#$%&'()*+,-./012345678s9:;<=>?@ABCDEFGHIJKLMNOPPQRSTUVWXGYZ[\]^_`aabbcHr]dbccdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~accelerate-0.12.2.0Data.Array.Accelerate!Data.Array.Accelerate.Interpreter$Data.Array.Accelerate.Internal.CheckData.Array.Accelerate.Type*Data.Array.Accelerate.Array.Representation Data.Array.Accelerate.Array.Data!Data.Array.Accelerate.Array.SugarData.Array.Accelerate.TupleData.Array.Accelerate.AST$Data.Array.Accelerate.Analysis.Shape&Data.Array.Accelerate.Analysis.Stencil#Data.Array.Accelerate.Analysis.Type#Data.Array.Accelerate.Array.Delayed"Data.Array.Accelerate.Pretty.PrintData.Array.Accelerate.PrettyData.Array.Accelerate.DebugData.Array.Accelerate.Smart%Data.Array.Accelerate.Pretty.TraverseData.Array.Accelerate.LanguageDataListData.Array.Accelerate.Preludeghc-prim GHC.TypesBoolCharDoubleFloatIntbaseGHC.IntInt8Int16Int32Int64WordGHC.WordWord8Word16Word32Word64Foreign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleBoundaryConstantWrapMirrorClampIsScalar IsBoundedIsNumIsNonNum IsFloating IsIntegralSlice SliceShape CoSliceShape FullShape sliceIndexShapeDIM9DIM8DIM7DIM6DIM5DIM4DIM3DIM2DIM1DIM0SegmentsVectorScalarArrayArraysEltAnyAll:.Z fromIArraytoIArrayfromListtoList initTraceStencilExpAccconstantrunstream evalPrimConstevalPrimevalPrjUnliftunliftLiftPlainlift Stencil5x5x5 Stencil3x5x5 Stencil5x3x5 Stencil5x5x3 Stencil3x3x5 Stencil3x5x3 Stencil5x3x3 Stencil3x3x3 Stencil5x5 Stencil3x5 Stencil5x3 Stencil3x3Stencil9Stencil7Stencil5Stencil3useunit replicategeneratereshapeslicemapzipWithfoldfold1foldSegfold1Segscanlscanl'scanl1scanrscanr'scanr1permute backpermutestencilstencil2>->cond?|lift1lift2ilift1ilift2fstsndcurryuncurryindex0index1unindex1index2unindex2?!theshapesize shapeSizeshiftshiftLshiftRrotaterotateLrotateRbitsetBitclearBit complementBittestBit==*/=*<*>=*>*<=*maxmintruncateroundfloorceiling&&*||*not boolToInt fromIntegralignorezipzip3zip4unzipunzip3unzip4foldAllfold1Allprescanl postscanlprescanr postscanrscanlSeg scanl'Seg scanl1Seg prescanlSeg postscanlSegscanrSeg scanr'Seg scanr1Seg prescanrSeg postscanrSegflattenfill enumFromN enumFromStepNgathergatherIfscatter scatterIftakedropinittailslitSliceIxIxElem indexArray arrayShapearrayDim arraySizetupleuntupleChecksInternalUnsafeBoundsdoBoundsChecksdoUnsafeChecksdoInternalChecksdoCheckserrorcheck assert_msgassertcheckIndex_msg checkIndexcheckLength_msg checkLengthcheckSlice_msg checkSlice ScalarType BoundedTypeNumType NonNumType FloatingType IntegralType TupleType PairTuple SingleTuple UnitTuple scalarType boundedTypenumType nonNumType floatingType integralTypeNonNumScalarType NumScalarTypeNonNumBoundedTypeIntegralBoundedTypeFloatingNumTypeIntegralNumType TypeCUChar TypeCSChar TypeCCharTypeCharTypeBool TypeCDouble TypeCFloat TypeDouble TypeFloat TypeCULLong TypeCLLong TypeCULong TypeCLong TypeCUIntTypeCInt TypeCUShort TypeCShort TypeWord64 TypeWord32 TypeWord16 TypeWord8TypeWord TypeInt64 TypeInt32 TypeInt16TypeInt8TypeInt NonNumDict FloatingDict IntegralDict Typeable9typeOf9 Typeable8typeOf8 myMkTyContypeOf7DefaulttypeOf8Default integralDict floatingDict nonNumDict$fIsScalarCUChar$fIsScalarCSChar$fIsScalarCChar$fIsScalarChar$fIsScalarBool$fIsScalarCDouble$fIsScalarCFloat$fIsScalarDouble$fIsScalarFloat$fIsScalarCULLong$fIsScalarCLLong$fIsScalarCULong$fIsScalarCLong$fIsScalarCUInt$fIsScalarCInt$fIsScalarCUShort$fIsScalarCShort$fIsScalarWord64$fIsScalarWord32$fIsScalarWord16$fIsScalarWord8$fIsScalarWord$fIsScalarInt64$fIsScalarInt32$fIsScalarInt16$fIsScalarInt8 $fIsScalarInt$fIsBoundedCUChar$fIsBoundedCSChar$fIsBoundedCChar$fIsBoundedChar$fIsBoundedBool$fIsBoundedCULLong$fIsBoundedCLLong$fIsBoundedCULong$fIsBoundedCLong$fIsBoundedCUInt$fIsBoundedCInt$fIsBoundedCUShort$fIsBoundedCShort$fIsBoundedWord64$fIsBoundedWord32$fIsBoundedWord16$fIsBoundedWord8$fIsBoundedWord$fIsBoundedInt64$fIsBoundedInt32$fIsBoundedInt16$fIsBoundedInt8$fIsBoundedInt$fIsNumCDouble $fIsNumCFloat $fIsNumDouble $fIsNumFloat$fIsNumCULLong $fIsNumCLLong $fIsNumCULong $fIsNumCLong $fIsNumCUInt $fIsNumCInt$fIsNumCUShort $fIsNumCShort $fIsNumWord64 $fIsNumWord32 $fIsNumWord16 $fIsNumWord8 $fIsNumWord $fIsNumInt64 $fIsNumInt32 $fIsNumInt16 $fIsNumInt8 $fIsNumInt$fIsNonNumCUChar$fIsNonNumCSChar$fIsNonNumCChar$fIsNonNumChar$fIsNonNumBool$fIsFloatingCDouble$fIsFloatingCFloat$fIsFloatingDouble$fIsFloatingFloat$fIsIntegralCULLong$fIsIntegralCLLong$fIsIntegralCULong$fIsIntegralCLong$fIsIntegralCUInt$fIsIntegralCInt$fIsIntegralCUShort$fIsIntegralCShort$fIsIntegralWord64$fIsIntegralWord32$fIsIntegralWord16$fIsIntegralWord8$fIsIntegralWord$fIsIntegralInt64$fIsIntegralInt32$fIsIntegralInt16$fIsIntegralInt8$fIsIntegralInt$fShowScalarType$fShowBoundedType $fShowNumType$fShowNonNumType$fShowFloatingType$fShowIntegralType $fTypeable8s$fTypeable9(,,,,,,,,) $fTypeable7s$fTypeable8(,,,,,,,) SliceIndex SliceFixedSliceAllSliceNildim intersectindexbounditeriter1 rangeToShape shapeToRange shapeToList listToShape$fShowSliceIndex $fSlice(,) $fSlice(,)0 $fSlice() $fShape(,) $fShape() ArrayEltRArrayEltMutableArrayData ArrayData runArrayData ArrayPtrsindexArrayDataptrsOfArrayData newArrayData readArrayDatawriteArrayDataunsafeFreezeArrayDataptrsOfMutableArrayDataarrayElt ArrayEltRpair ArrayEltRchar ArrayEltRboolArrayEltRdoubleArrayEltRfloatArrayEltRword64ArrayEltRword32ArrayEltRword16ArrayEltRword8 ArrayEltRwordArrayEltRint64ArrayEltRint32ArrayEltRint16 ArrayEltRint8 ArrayEltRint ArrayEltRunit GArrayDatatoBoolfromBool fstArrayData sndArrayData pairArrayDataunsafeNewArray_ uArrayPtr sTUArrayPtr $fArrayElt(,)$fArrayEltChar$fArrayEltBool$fArrayEltDouble$fArrayEltFloat$fArrayEltWord64$fArrayEltWord32$fArrayEltWord16$fArrayEltWord8$fArrayEltWord$fArrayEltInt64$fArrayEltInt32$fArrayEltInt16$fArrayEltInt8 $fArrayEltInt $fArrayElt()$fTypeableGArrayDataAD_PairAD_CharAD_Bool AD_DoubleAD_Float AD_Word64 AD_Word32 AD_Word16AD_Word8AD_WordAD_Int64AD_Int32AD_Int16AD_Int8AD_IntAD_Unit sliceAnyIndexEltReprsingletonScalarTypenewArray allocateArray array-0.4.0.1Data.Array.BaseIArray showShapearraysarrays'toArrtoArr'fromArrfromArr'ArraysR ArraysRpair ArraysRarray ArraysRunitArrRepr'ArrRepreltTypefromElttoElteltType'fromElt'toElt'EltRepr' liftToElt liftToElt2 sinkFromElt sinkFromElt2 $fShowArray $fSliceAny $fSlice:. $fSlice:.0$fSliceZ $fShape:.$fShapeZ$fArrays(,,,,,,,,)$fArrays(,,,,,,,)$fArrays(,,,,,,)$fArrays(,,,,,)$fArrays(,,,,) $fArrays(,,,) $fArrays(,,) $fArrays(,) $fArraysArray $fArrays()$fElt(,,,,,,,,)$fElt(,,,,,,,) $fElt(,,,,,,) $fElt(,,,,,) $fElt(,,,,) $fElt(,,,) $fElt(,,)$fElt(,) $fEltChar $fEltBool $fEltDouble $fEltFloat $fEltWord64 $fEltWord32 $fEltWord16 $fEltWord8 $fEltWord $fEltInt64 $fEltInt32 $fEltInt16 $fEltInt8$fEltInt$fEltAny $fEltAny0$fEltAll$fElt:.$fEltZ$fElt()IsTupleTupleIdxTuple TupleRepr fromTupletoTuple SuccTupIdx ZeroTupIdxAtupleSnocAtupNilAtupSnocTupNilTup$fIsTuple(,,,,,,,,)$fIsTuple(,,,,,,,)$fIsTuple(,,,,,,)$fIsTuple(,,,,,)$fIsTuple(,,,,)$fIsTuple(,,,) $fIsTuple(,,) $fIsTuple(,) $fIsTuple()PrimFun PrimConstPreExpOpenExp PreOpenExpFunPreFunOpenFun PreOpenFunStencilR PreOpenAccAfunPreAfun PreOpenAfunPrimFromIntegral PrimBoolToIntPrimChrPrimOrdPrimLNotPrimLOrPrimLAndPrimMinPrimMaxPrimNEqPrimEqPrimGtEqPrimLtEqPrimGtPrimLt PrimCeiling PrimFloor PrimRound PrimTruncate PrimAtan2 PrimLogBasePrimFPowPrimLogPrimSqrtPrimExpFloating PrimAtanh PrimAcosh PrimAsinhPrimAtanPrimAcosPrimAsinPrimTanPrimCosPrimSin PrimRecipPrimFDiv PrimBRotateR PrimBRotateL PrimBShiftR PrimBShiftLPrimBNotPrimBXorPrimBOrPrimBAndPrimModPrimIDivPrimRemPrimQuotPrimSigPrimAbsPrimNegPrimMulPrimSubPrimAddPrimPi PrimMaxBound PrimMinBound ShapeSize IndexScalarPrimAppCondIndexAny IndexTail IndexHead IndexConsIndexNilPrjConstVarLetLamBody StencilRtup9 StencilRtup7 StencilRtup5 StencilRtup3 StencilRunit9 StencilRunit7 StencilRunit5 StencilRunit3 stencilAccessOpenAccStencil2 BackpermutePermuteScanr1Scanr'ScanrScanl1Scanl'ScanlFold1SegFoldSegFold1FoldZipWithMapIndex ReplicateGenerateReshapeUnitUseAcondApplyAprjAvarAletOpenAfunAlamAbodyValEltPushEltEmptyEltValPushEmptyIdxSuccIdxZeroIdxidxToIntprjprjElt invertShape$fStencil:.a(,,,,,,,,)$fStencil:.a(,,,,,,)$fStencil:.a(,,,,)$fStencil:.a(,,)$fStencil:.e(,,,,,,,,)$fStencil:.e(,,,,,,)$fStencil:.e(,,,,)$fStencil:.e(,,)accDim preAccDimAccDimndimoffsets positionsRoffsets2AccType arrayTypeaccType preAccTypeexpType preExpTypesizeOf DelayableDelayeddelayforce$fDelayable(,)$fDelayableArray $fDelayable() DelayedPair DelayedArrayshapeDArepfDA DelayedUnit PrettyAcc prettyAcc prettyPreAccprettyBoundary prettyArrOp prettyAfun prettyPreAfun prettyFun prettyPreFun prettyExp prettyPreExp prettyAtuple prettyTupleprettyTupleIdx prettyConst prettyPrim prettyArrays prettyArraynoParens encloseSep $fShowOpenAcc$fShowPreOpenExp$fShowPreOpenFun queryTrace traceLine traceChunk tracePure traceFlagPreAccPipe convertAccconvertOpenAccconvertAccFun1convertSharingAccconvertBoundaryconvertSharingExp convertTuple convertExp convertFun1 convertFun2recoverSharingAccTrueStableSharingAccAtagTag StencilRepr stencilPrj NodeCount ExpNodeCount AccNodeCount NodeCountsStableSharingExpRootExpEnvExp OccMapExp SharingExp ExpSharing LetSharing VarSharing StableExpName SharingAcc AccSharing AletSharing AvarSharing StableAccNameOccMap OccMapHash ASTHashTableStableNameHeight StableASTNameLevelLayout PushLayout EmptyLayoutrecoverAccSharingfloatOutAccFromExprecoverExpSharingprjIdxpossiblyNestedErr incLayoutconvertSharingAtupleconvertStencilFunconvertStencilFun2 makeStableAST higherSNHhashStableNameHeightnewASTHashTableenterOcc freezeOccMaplookupWithASTNamelookupWithSharingAcclookupWithSharingExp higherSSAmatchStableAccnoStableAccName higherSSEmatchStableExpnoStableExpName makeOccMap noNodeCounts accNodeCount expNodeCount+++buildInitialEnvAccbuildInitialEnvExp isFreeVardetermineScopes showPreAccOp showArraysshowShortendArr_showSharingAccOp showPreExpOpmkIndex mkReplicateatup2atup3atup4atup5atup6atup7atup8atup9unatup2unatup3unatup4unatup5unatup6unatup7unatup8unatup9tix0tix1tix2tix3tix4tix5tix6tix7tix8tup2tup3tup4tup5tup6tup7tup8tup9untup2untup3untup4untup5untup6untup7untup8untup9 mkMinBound mkMaxBoundmkPimkSinmkCosmkTanmkAsinmkAcosmkAtanmkAsinhmkAcoshmkAtanh mkExpFloatingmkSqrtmkLogmkFPow mkLogBasemkAddmkSubmkMulmkNegmkAbsmkSigmkQuotmkRemmkIDivmkModmkBAndmkBOrmkBXormkBNot mkBShiftL mkBShiftR mkBRotateL mkBRotateRmkFDivmkRecip mkTruncatemkRoundmkFloor mkCeilingmkAtan2mkLtmkGtmkLtEqmkGtEqmkEqmkNEqmkMaxmkMinmkLAndmkLOrmkLNotmkFromIntegral mkBoolToInt$$$$$$$$$$$$$$ $fShowExp $fShowAcc$fEqStableSharingExp$fShowStableSharingExp$fEqStableSharingAcc$fShowStableSharingAcc$fEqStableNameHeight$fEqStableASTName$fShowStableASTName evalOpenAccevalPreOpenAccevalAcc evalAtupleunitOp generateOp reshapeOp replicateOpindexOpmapOp zipWithOpfoldOpfold1Op foldSegOp foldSegOp' fold1SegOp fold1SegOp'scanlOpscanl'Opscanl1OpscanrOpscanr'Opscanr1Op permuteOp backpermuteOp stencilOp stencil2Op evalOpenFunevalFun evalOpenExpevalExp evalTupleevalLAndevalLOrevalLNotevalOrdevalChr evalBoolToIntevalFromIntegral evalMinBound evalMaxBoundevalPievalSinevalCosevalTanevalAsinevalAcosevalAtan evalAsinh evalAcosh evalAtanhevalExpFloatingevalSqrtevalLogevalFPow evalLogBase evalTruncate evalRound evalFloor evalCeiling evalAtan2evalAddevalSubevalMulevalNegevalAbsevalSigevalQuotevalRemevalIDivevalModevalBAndevalBOrevalBXorevalBNot evalBShiftL evalBShiftR evalBRotateL evalBRotateRevalFDiv evalRecipevalLtevalGtevalLtEqevalGtEqevalEqevalNEqevalMaxevalMinLabels accFormat expFormat funFormat tupleFormat arrayFormatboundaryFormat primFunFormatcattravAcctravExptravAfun travArrays travArray travBoundary travAtupletravFun travTuplelabelForPrimFun labelForConst tupleIdxToIntFalse$fRealFloatExp $fRealFracExp$fFractionalExp $fFloatingExp $fIntegralExp $fRealExp$fNumExp $fBitsExp$fOrdExp$fEqExp $fEnumExp $fBoundedExp$fUnliftAcc(,,,,,,,,)$fLiftAcc(,,,,,,,,)$fUnliftAcc(,,,,,,,)$fLiftAcc(,,,,,,,)$fUnliftAcc(,,,,,,)$fLiftAcc(,,,,,,)$fUnliftAcc(,,,,,)$fLiftAcc(,,,,,)$fUnliftAcc(,,,,)$fLiftAcc(,,,,)$fUnliftAcc(,,,)$fLiftAcc(,,,)$fUnliftAcc(,,) $fLiftAcc(,,)$fUnliftAcc(,) $fLiftAcc(,)$fLiftAccArray $fLiftAccAcc $fLiftExpExp$fUnliftExp(,,,,,,,,)$fLiftExp(,,,,,,,,)$fUnliftExp(,,,,,,,)$fLiftExp(,,,,,,,)$fUnliftExp(,,,,,,)$fLiftExp(,,,,,,)$fUnliftExp(,,,,,)$fLiftExp(,,,,,)$fUnliftExp(,,,,)$fLiftExp(,,,,)$fUnliftExp(,,,)$fLiftExp(,,,)$fUnliftExp(,,) $fLiftExp(,,)$fUnliftExp(,) $fLiftExp(,) $fLiftExpChar $fLiftExpBool$fLiftExpDouble$fLiftExpFloat$fLiftExpWord64$fLiftExpWord32$fLiftExpWord16$fLiftExpWord8 $fLiftExpWord$fLiftExpInt64$fLiftExpInt32$fLiftExpInt16 $fLiftExpInt8 $fLiftExpInt $fLiftExpAny $fUnliftExp:. $fLiftExp:. $fLiftExp:.0 $fLiftExp:.1 $fUnliftExpZ $fLiftExpZ $fUnliftExp() $fLiftExp() mkHeadFlags mkTailFlags mkSegApplyindex1' $fSliceIxsh$fIxsh$fEleme