Rs      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr stuvwxyz{|sxyz{|sxyz{|}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) }~}~~@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. W @non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>Mutable array representation Immutable array representation >Safe combination of creating and fast freezing of array data. 6CSlices -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. Convenience functions  - 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. $Reify the element type of an array. 3 !"#$%&'()*+,-./01233 !"!"#$%&'()*+,-.//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.                 `Primitive scalar operations  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGPrimitive GPU constants HIJK)Expression without free scalar variables LKOpen 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). MNOPQRSTUV'Function without free scalar variables WFunction abstraction XYZ-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). \]^_`abcdefghijklmnopqr` !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr`3FEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGJIHHIJKL UTSRQPONMMNOPQRSTUVWYXXYZ[kjihgfedcba`_^]\\]^_`abcdefghijklnmmnoqppqr stuvwxyz{|}~Show instances  ---------------   f1Conversion from HOAS to de Bruijn expression AST  - 4CScalar expressions used to parametrise collective array operations 5%Array-valued collective computations 2Conversion from HOAS to de Bruijn computation AST  - @Convert an array expression with given array environment layout "Convert a closed array expression ;Convert an open expression with given environment layouts. Convert a tuple expression 5Convert an expression closed wrt to scalar variables Convert a closed expression Convert a unary functions Convert a binary functions 9Smart constructors to construct representation AST forms ; --------------------------------------------------------- 5Smart constructors to construct HOAS AST expressions 7 ----------------------------------------------------- 6Constant scalar expression Z456Z4 56non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>N7LCharacterises the types that may be returned when running an array program. 8GRun a complete embedded array program using the reference interpreter. 9:;      !"#$%&'()*+789:;78:9;789:;,>Reify the element type of the result of an array computation. -KReify the element types of the results of an array computation that yields  two arrays. ..Reify the result type of a scalar expression. /-Reify the result type of a tuple projection. 0Size of a tuple type, in bytes ,-.0,-.05<=>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. AHScalar inlet: injects a scalar (or a tuple of scalars) into a singleton + array for use in the Accelerate language. BBChange the shape of an array without altering its contents, where % precondition: size dim == size dim' CEReplicate 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. DHIndex 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. EJCombine the elements of two arrays pairwise. The shape of the result is . the intersection of the two argument shapes. FThe converse of E7, but the shape of the two results is identical to the  shape of the argument. G9Apply the given function elementwise to the given array. H?Apply the given binary function elementwise to the two arrays. IPrescan of a vector. The type 'a'# together with the binary function L (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. JThe resulting vector of prescan values has the same size as the argument 7 vector. The resulting scalar is the reduction value. JThe right-to-left dual of I. K!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. LSegmented reduction. MHForward 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 p0 by the permutation function are being dropped. combination function array of default values  permutation permuted array NBackward permutation shape of the result array  permutation permuted array O&Extract the first component of a pair P'Extract the second component of a pair Q5Converts an uncurried function to a curried function R3Converts a curried function to a function on pairs SConditional expression. T6Expression form that extracts a scalar from an array. UVWXYZ[\]^_`a-Equality lifted into Accelerate expressions. b/Inequality lifted into Accelerate expressions. c1Smaller-than lifted into Accelerate expressions. d5Greater-or-equal lifted into Accelerate expressions. e1Greater-than lifted into Accelerate expressions. f5Smaller-or-equal lifted into Accelerate expressions. g&Determine the maximum of two scalars. h&Determine the minimum of two scalars. i Conjunction j Disjunction k Negation lConvert a Boolean value to an , where 1 turns into '0' and 2  into '1'. mConvert an Int to a Float nRound Float to Int oTruncate Float to Int pKMagic value identifying elements that are ignored in a forward permutation 8456<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop5<=>?=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopnon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>q%Array indexing in plain Haskell code r"Array shape in plain Haskell code n  !"#$%&'()*+,-./0123456<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrn ,+*)- !"./('&%$#rq0123546@ABDCEFGHIJKLMN<=>?OPQRSTUabcfedgh\]^_`VWXYZ[ijklmnopqr3 !"#$%$&$'$($)$*$+$,$-$.$/$0$123456789:;<=>?@ABCDEEFGHI J K LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~23456789Ckj           R              ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M J N  O P J Q R R S T U V W X K 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 { | } ~    O P J Q R R S  Z [ \ ] ^ _ ` a b c d e f                                                                               accelerate-0.7.1.0Data.Array.Accelerate!Data.Array.Accelerate.InterpreterPaths_accelerate*Data.Array.Accelerate.Array.RepresentationData.Array.Accelerate.Type Data.Array.Accelerate.Array.Data!Data.Array.Accelerate.Array.Sugar#Data.Array.Accelerate.Array.DelayedData.Array.Accelerate.TupleData.Array.Accelerate.ASTData.Array.Accelerate.PrettyData.Array.Accelerate.DebugData.Array.Accelerate.Smart#Data.Array.Accelerate.Analysis.TypeData.Array.Accelerate.Languageghc-primGHC.BoolBool GHC.TypesCharDoubleFloatIntbaseGHC.IntInt8Int16Int32Int64GHC.WordWordWord8Word16Word32Word64Foreign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleSliceIxSliceCoSliceSliceDim sliceIndexIxdimsizeDIM5DIM4DIM3DIM2DIM1DIM0SegmentsVectorScalarArrayElemAll fromIArraytoIArrayfromListtoListExpAccconstantArraysrun evalPrimConstevalPrimevalPrjTupleTupleTtupleuntupleuseunitreshape replicateslicezipunzipmapzipWithscanlscanrfoldfoldSegpermute backpermutefstsndcurryuncurry?!shapeshiftshiftLshiftRrotaterotateLrotateRbitsetBitclearBit complementBittestBit==*/=*<*>=*>*<=*maxmin&&*||*not boolToInt intToFloatroundFloatToInttruncateFloatToIntignore indexArray arrayShapeversionbindirlibdirdatadir libexecdir getBinDir getLibDir getDataDir getLibexecDirgetDataFileName SliceIndex SliceFixedSliceAllSliceNil intersectindexiter rangeToShape shapeToRange TupleType PairTuple SingleTuple UnitTupleIsScalar 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 ArrayElem ArrayPtrsindexArrayDataptrsOfArrayData newArrayData readArrayDatawriteArrayDataunsafeFreezeArrayDataptrsOfMutableArrayData GArrayDataMutableArrayData ArrayData runArrayData fstArrayData sndArrayData pairArrayDataunsafeNewArray_ uArrayPtr sTUArrayPtr SliceIxConvconvertSliceIndex FromShapeRepr FromShapeBaseShape ShapeBaseelemTypefromElemtoElem elemType' fromElem'toElem' ElemRepr'ElemReprsingletonScalarType liftToElem liftToElem2 sinkFromElem sinkFromElem2newArray array-0.3.0.1Data.Array.BaseIArray arrayType DelayableDelayeddelayforce DelayedPair DelayedArrayshapeDArepfDA DelayedUnitIsTuple TupleRepr fromTupletoTupleTupleIdx SuccTupIdx ZeroTupIdxSnocTupNilTupPrimFun PrimBoolToInt PrimIntFloatPrimTruncFloatIntPrimRoundFloatIntPrimChrPrimOrdPrimLNotPrimLOrPrimLAndPrimMinPrimMaxPrimNEqPrimEqPrimGtEqPrimLtEqPrimGtPrimLt PrimLogBasePrimFPowPrimLogPrimSqrtPrimExpFloating PrimAtanh PrimAcosh PrimAsinhPrimAtanPrimAcosPrimAsinPrimTanPrimCosPrimSin PrimRecipPrimFDiv PrimBRotateR PrimBRotateL PrimBShiftR PrimBShiftLPrimBNotPrimBXorPrimBOrPrimBAndPrimModPrimIDivPrimRemPrimQuotPrimSigPrimAbsPrimNegPrimMulPrimSubPrimAdd PrimConstPrimPi PrimMaxBound PrimMinBoundOpenExp IndexScalarPrimAppCondPrjConstVarFunOpenFunLamBodyOpenAcc BackpermutePermuteScanrScanlFoldSegFoldZipWithMapIndex ReplicateReshapeUnitUseAvarLet2LetValPushEmptyIdxSuccIdxZeroIdxprj prettyAcc prettyArrOpprettyAccParens prettyFun prettyExp prettyTupleprettyTupleIdx prettyConst prettyPrim prettyArraynoParensidxToInt $fShowOpenAccLayout PushLayout EmptyLayoutTagSndArrayFstArrayconvertOpenAcc convertAccprjIdxconvertOpenExp convertTuple convertExpconvertClosedExp convertFun1 convertFun2mkIndex mkReplicateunpairtup2tup3tup4tup5untup2untup3untup4untup5 mkMinBound mkMaxBoundmkPimkSinmkCosmkTanmkAsinmkAcosmkAtanmkAsinhmkAcoshmkAtanh mkExpFloatingmkSqrtmkLogmkFPow mkLogBasemkAddmkSubmkMulmkNegmkAbsmkSigmkQuotmkRemmkIDivmkModmkBAndmkBOrmkBXormkBNot mkBShiftL mkBShiftR mkBRotateL mkBRotateRmkFDivmkRecipmkLtmkGtmkLtEqmkGtEqmkEqmkNEqmkMaxmkMinmkLAndmkLOrmkLNot mkBoolToInt mkIntFloatmkRoundFloatIntmkTruncFloatInt evalOpenAccevalAccunitOp reshapeOp replicateOpindexOpmapOp zipWithOpfoldOp foldSegOpscanlOpscanrOp permuteOp backpermuteOp evalOpenFunevalFun evalOpenExpevalExp evalTupleevalLAndevalLOrevalLNotevalOrdevalChrevalRoundFloatIntevalTruncFloatInt evalIntFloat evalBoolToInt evalMinBound evalMaxBoundevalPievalSinevalCosevalTanevalAsinevalAcosevalAtan evalAsinh evalAcosh evalAtanhevalExpFloatingevalSqrtevalLogevalFPow evalLogBaseevalAddevalSubevalMulevalNegevalAbsevalSigevalQuotevalRemevalIDivevalModevalBAndevalBOrevalBXorevalBNot evalBShiftL evalBShiftR evalBRotateL evalBRotateRevalFDiv evalRecipevalLtevalGtevalLtEqevalGtEqevalEqevalNEqevalMaxevalMinaccTypeaccType2expType tupleIdxTypesizeOfFalseTrue