}]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ <]All scalar type ^_Bounded types `aNumeric types bcNon-numeric types deFloating types fgIntegral types hi+All scalar element types implement Eq, Ord & Enum jkl(Bounded element types implement Bounded mno$Numeric element types implement Num & Real pqr3Non-numeric types supported in array computations. stuvwx6Floating-point types supported in array computations. yz{|}0Integral types supported in array computations. ~S ]^_`abcdefghijklmnopqrstuvwxyz{|}~<]^^_``abbcddeffghhikjjklnmmnoqppqrwvutsstuvwx|{zyyz{|}~~ Mutable array representation Immutable array representation >Safe combination of creating and fast freezing of array data.  LGeneralised 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) 2CSlices -aka generalised indices- as n-tuples and mappings of slice 5 indicies to slices, co-slices, and slice dimensions  /Shapes and indices of multi-dimensional arrays !Number of dimensions of a shape or index (>= 0) "+Magic value identifing 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) HIterate through the entire shape, applying the function; third argument G combines results and fourth is returned in case of an empty iteration 8 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 #$%&'()Segment descriptor *Vectors +Scalars ,.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. -IClass that characterises the types of values that can be array elements. .6Identifier for entire dimensions in slice descriptors /.Representation change for array element types 0 ---------------------------------------------- Type representation mapping The idea is to use '()' and '(,)'* as type-level nil and snoc to construct  snoc-lists of types. Yield an array's shape Array indexing 1Create an array from its representation function 0 Convert an  to an accelerated array. 1#Convert an accelerated array to an  2KConvert a list (with elements in row-major order) to an accelerated array. 3;Convert an accelerated array to a list in row-major order. 0 !"#$%&'()*+,-./01230 !"!"#$%&'()*+,-.//0123  BConversion between surface n-tuples and our tuple representation. *Type-safe projection indicies for tuples. ;NB: We index tuples by starting to count from the *right*! AWe represent tuples as heterogenous lists, typed by a type list.   IPrimitive scalar operations Primitive GPU constants )Expression without free scalar variables  KOpen expressions using de Bruijn indices for variables ranging over tuples G of scalars and arrays of tuples. All code, except Cond, is evaluated 6 eagerly. N-tuples are represented as nested pairs. MThe data type is parametrised over the surface types (not the representation  type).     'Function without free scalar variables Function abstraction -Closed array expression aka an array program @Collective array computations parametrised over array variables % represented with de Bruijn indices. J We have no fold, only scan which returns the fold result and scan array. L We assume that the code generator is clever enough to eliminate any dead 4 code, when only one of the two values is needed. @ 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.) MThe data type is parametrised over the surface types (not the representation  type).  !"#$%&'()*I      !"#$%&'()*I!         '&%$#"!  !"#$%&'(*))* +,-./01234567Show instances  ---------------  P81Conversion from HOAS to de Bruijn expression AST  - 9:4CScalar expressions used to parametrise collective array operations ;<=>?@ABC5%Array-valued collective computations DEFGHIJKLMNOPQR2Conversion from HOAS to de Bruijn computation AST  - @Convert an array expression with given array environment layout S"Convert a closed array expression TU;Convert an open expression with given environment layouts. VConvert a tuple expression W5Convert an expression closed wrt to scalar variables XConvert a closed expression YConvert a unary functions ZConvert a binary functions [9Smart constructors to construct representation AST forms ; --------------------------------------------------------- \]5Smart constructors to construct HOAS AST expressions 7 ----------------------------------------------------- 6Constant scalar expression ^_`abcdefghijklmnopqrstuvwxyz{|}~D4;<=>?@ABC5DEFGHIJKLMNOPQSX]6^_`abcdefghijklmnopqrstuvwxyz{|}~D4 CBA@?>=<;;<=>?@ABC5QPONMLKJIHGFEDDEFGHIJKLMNOPQSX]6^_`abcdefghijklmnopqrstuvwxyz{|}~non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>?7LCharacterises the types that may be returned when running an array program. 8GRun a complete embedded array program using the reference interpreter. 787878  "9:;ITurn a tuple of scalar expressions into a scalar expressions that yields  a tuple. <DTurn a scalar expression that yields a tuple into a tuple of scalar  expressions. =JArray inlet: makes an array available for processing using the Accelerate E language; triggers asynchronous host->device transfer if necessary. >HScalar inlet: injects a scalar (or a tuple of scalars) into a singleton + array for use in the Accelerate language. ?BChange the shape of an array without altering its contents, where % precondition: size dim == size dim' @EReplicate 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 (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. AHIndex 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. BJCombine the elements of two arrays pairwise. The shape of the result is . the intersection of the two argument shapes. CThe converse of B7, but the shape of the two results is identical to the  shape of the argument. D9Apply the given function elementwise to the given array. E?Apply the given binary function elementwise to the two arrays. FPrescan of a vector. The type a* together with the binary function (first F argument) and value (second argument) must form a monoid; i.e., the  function must be  associative and the value must be its neutral element. JThe resulting vector of prescan values has the same size as the argument 7 vector. The resulting scalar is the reduction value. G!Reduction of an array. The type a# together with the binary function M (first argument) and value (second argument) must form a monoid; i.e., the  function must be  associative and the value must be its neutral element. HSegmented reduction. IHForward 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 Z0 by the permutation function are being dropped. combination function array of default values  permutation permuted array JBackward permutation shape of the result array  permutation permuted array KConditional expression. L6Expression form that extracts a scalar from an array. MN-Equality lifted into Accelerate expressions. O/Inequality lifted into Accelerate expressions. P1Smaller-than lifted into Accelerate expressions. Q5Greater-or-equal lifted into Accelerate expressions. R1Greater-than lifted into Accelerate expressions. S5Smaller-or-equal lifted into Accelerate expressions. T&Determine the maximum of two scalars. U&Determine the minimum of two scalars. V Conjunction W Disjunction X Negation YConvert a Boolean value to an , where  turns into '0' and   into '1'. ZKMagic value identifying elements that are ignored in a forward permutation %4569:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"9:;<:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZnon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>[%Array indexing in plain Haskell code \"Array shape in plain Haskell code [  !"#$%&'()*+,-./01234569:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\[ ,+*)- !"./('&%$#\[0123546=>?A@BCDEFGHIJ9:;<KLMNOPSRQTUVWXYZ[\ !"#"$"%"&"'"(")"*"+","-"."/0123456789:;<=>?@ABCCDEFG H I JKL 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 nopqrstuvwxyz{|}~01234567nnAa`M                                       H        M       I              ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6       M  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 lmnopqrstuvwxyz{|}~accelerate-0.6.0.0Data.Array.Accelerate!Data.Array.Accelerate.InterpreterData.Array.Accelerate.Type Data.Array.Accelerate.Array.Data*Data.Array.Accelerate.Array.Representation!Data.Array.Accelerate.Array.Sugar#Data.Array.Accelerate.Array.DelayedData.Array.Accelerate.TupleData.Array.Accelerate.ASTData.Array.Accelerate.PrettyData.Array.Accelerate.SmartData.Array.Accelerate.DebugData.Array.Accelerate.Languageghc-primGHC.BoolBool GHC.TypesCharDoubleFloatIntbaseGHC.IntInt8Int16Int32Int64GHC.WordWordWord8Word16Word32Word64Foreign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleSliceIxSliceCoSliceSliceDim sliceIndexIxdimsizeDIM5DIM4DIM3DIM2DIM1DIM0SegmentsVectorScalarArrayElemAll fromIArraytoIArrayfromListtoListExpAccconstantArraysrunTupleTupleTtupleuntupleuseunitreshape replicateslicezipunzipmapzipWithscanfoldfoldSegpermute backpermute?!shape==*/=*<*>=*>*<=*maxmin&&*||*not boolToIntignore indexArray arrayShapeIsScalar scalarType IsBounded boundedTypeIsNumnumTypeIsNonNum nonNumType IsFloating floatingType IsIntegral integralType ScalarTypeNonNumScalarType NumScalarType BoundedTypeNonNumBoundedTypeIntegralBoundedTypeNumTypeFloatingNumTypeIntegralNumType NonNumType TypeCUChar TypeCSChar TypeCCharTypeCharTypeBool FloatingType TypeCDouble TypeCFloat TypeDouble TypeFloat IntegralType TypeCULLong TypeCLLong TypeCULong TypeCLong TypeCUIntTypeCInt TypeCUShort TypeCShort TypeWord64 TypeWord32 TypeWord16 TypeWord8TypeWord TypeInt64 TypeInt32 TypeInt16TypeInt8TypeInt NonNumDict FloatingDict IntegralDict integralDict floatingDict nonNumDict ArrayElemindexArrayData newArrayData readArrayDatawriteArrayDataunsafeFreezeArrayData GArrayDataMutableArrayData ArrayData runArrayData SliceIndex SliceFixedSliceAllSliceNil intersectindexiter rangeToShape shapeToRange SliceIxConvconvertSliceIndex FromShapeRepr FromShapeBaseShape ShapeBasefromElemtoElem fromElem'toElem' ElemRepr'ElemRepr liftToElem liftToElem2 sinkFromElem sinkFromElem2newArray array-0.3.0.1Data.Array.BaseIArray DelayableDelayeddelayforce DelayedPair DelayedArrayshapeDArepfDA DelayedUnitIsTuple TupleRepr fromTupletoTupleTupleIdx SuccTupIdx ZeroTupIdxSnocTupNilTupPrimFun PrimBoolToInt PrimIntFloatPrimTruncFloatIntPrimRoundFloatIntPrimChrPrimOrdPrimLNotPrimLOrPrimLAndPrimMinPrimMaxPrimNEqPrimEqPrimGtEqPrimLtEqPrimGtPrimLt PrimRecipPrimFDivPrimBNotPrimBXorPrimBOrPrimBAndPrimModPrimIDivPrimRemPrimQuotPrimSigPrimAbsPrimNegPrimMulPrimSubPrimAdd PrimConstPrimPi PrimMaxBound PrimMinBoundOpenExp IndexScalarPrimAppCondPrjConstVarFunOpenFunLamBodyOpenAcc BackpermutePermuteScanFoldSegFoldZipWithMapIndex ReplicateReshapeUnitUseAvarLet2LetIdxSuccIdxZeroIdx prettyAcc prettyArrOpprettyAccParens prettyFun prettyExp prettyTupleprettyTupleIdx prettyConst prettyPrim prettyArraynoParensidxToInt $fShowOpenAccLayout PushLayout EmptyLayoutTagSndArrayFstArrayconvertOpenAcc convertAccprjIdxconvertOpenExp convertTuple convertExpconvertClosedExp convertFun1 convertFun2mkIndex mkReplicateunpairtup2tup3tup4tup5untup2untup3untup4untup5 mkMinBound mkMaxBoundmkPimkAddmkSubmkMulmkNegmkAbsmkSigmkQuotmkRemmkIDivmkModmkBAndmkBOrmkBXormkBNotmkFDivmkRecipmkLtmkGtmkLtEqmkGtEqmkEqmkNEqmkMaxmkMinmkLAndmkLOrmkLNot mkBoolToIntValPushEmptyprj evalOpenAccevalAccunitOp reshapeOp replicateOpindexOpmapOp zipWithOpfoldOp foldSegOpscanOp permuteOp backpermuteOp evalOpenFunevalFun evalOpenExpevalExp evalPrimConstevalPrim evalTupleevalPrjevalLAndevalLOrevalLNotevalOrdevalChrevalRoundFloatIntevalTruncFloatInt evalIntFloat evalBoolToInt evalMinBound evalMaxBoundevalPievalAddevalSubevalMulevalNegevalAbsevalSigevalQuotevalRemevalIDivevalModevalBAndevalBOrevalBXorevalBNotevalFDiv evalRecipevalLtevalGtevalLtEqevalGtEqevalEqevalNEqevalMaxevalMinFalseTrue