Rj      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  NoneZThis data type is for parameters of parameterized signal generators and causal processes. 0It is better than using plain functions of type p -> a &since it allows for numeric instances and we can make explicit, !whether a parameter is constant. 1We recommend to use parameters for atomic types. Although a parameter of type  T p (a,b) is possible, .it means that the whole parameter is variable .if only one of the pair elements is variable. %This way you may miss optimizations.  The call  value param v requires that v represents the same value as valueTupleOf (get param p) for some p. However v) might be the result of a load operation and param might be a constant. )In this case it is more efficient to use "valueTupleOf (get param undefined) 5since the constant is translated to an LLVM constant 'that allows for certain optimizations. GThis is the main function for taking advantage of a constant parameter in low-level implementations. JFor simplicity we do not omit constant parameters in the parameter struct Ksince this would mean to construct types at runtime and might become ugly. Instead we just check using value& at the according places in LLVM code  whether a parameter is constant 7and ignore the parameter from the struct in this case. -In many cases there will be no speed benefit ;because the parameter will be loaded to a register anyway. 9It can only lead to speed-up if subsequent optimizations %can precompute constant expressions. Another example is 9 where a loop with constant loop count can be generated. JFor small loop counts and simple loop bodies the loop might get unrolled. /This function provides specialised variants of  and value, %that use the unit type for constants -and thus save space in parameter structures. Useful for combining T p a and T p b to  T p (a,b) using  liftA2 (,). &However, we do not recommend to do so 2because the result parameter can only be constant if both operands are constant. Useful for splitting  T p (a,b) into T p a and T p b using fmap fst and fmap snd. arrA is useful for lifting parameter selectors to our parameter type $without relying on the constructor. .> can be used for fetching a parameter from a super-parameter.      None Analogous to .  A nested %. < Analogus to . >,You can construct complex numbers this way, "but they will not make you happy, <because the numeric operations require a RealFloat instance :that we could only provide with lots of undefined methods (also in its superclasses). *You may either define your own arithmetic (or use the NumericPrelude type classes. XLike Y+ but computes both alternative expressions and then uses LLVM' s efficient select instruction. [ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYK !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYK !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMRQPONSTUVWXYQ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYNoneZZ< denotes a range defined by the start index and the length. ^^! denotes an inclusive range like !those of the Haskell 98 standard Array type from the array package. E.g. the shape type (Range Int32, Range Int64) is equivalent to the ix type (Int32, Int64) for Arrays. h Result is (size, flattenedIndex).  size must equal the result of f. 1 We use this for sharing intermediate results. 1Array dimensions and indexes cannot be negative, Bbut computations in indices may temporarily yield negative values .or we want to add negative values to indices. 7Maybe we should better have type Index Word64 = Int64? 0Z[\]^_`abcdefghijklmn     Z[\]^_`abcdefghijklmncdefghijklmn^_Z[\]`ab#Z[\]^_`abcdefghijklmn     None   Noneo<This class allows to implement functions without parameters *for both simple and parameterized arrays. 7Use this for combining several dimension manipulators. E.g.  < apply (passAny $:. pick 3 $:. pass $:. replicate 10) array The constraint (Process proc0, Process proc1) is a bit weak. 2We like to enforce that the type constructor like Slice.T is the same in proc0 and proc1", and only the parameters differ. &Currently this coherence is achieved, *because we only provide functions of type proc0 -> proc1 with this condition. !opqrs"#$tuvwxyz{|}%~&'!opqrs"#$tuvwxyz{|}%~&!opqrs"#$tuvwxyz{|}%~&'NoneThis is between  and . )You can access the shapes of two arrays, %but only the content of one of them. LThis is necessary if the second array contributes only a virtual dimension. Noneopqrstuvwxyz{|}~sopqrtuvwxyz{|}~None=The symbolic array is only valid inside the enclosed action. ()*+ ()*+None,Equivalent to liftA2 f (expHull p) but saves us an empty context. !-./01234567,89:;<=>?@ABC-./01234567,89:;<=>?@-./01234567,89:;<=>?@ABCNone None DEFGH DEFGH NoneIJKLMNOPQRSTUVW IJKLMNOPQRSTUVW None XYZ[\]^ XYZ[\]^ Noneq_`abcdefghijklmnopqrstuvwxyz{|}~ L_`abcdefghijklmnopqrstuvwxyz{|}~NoneThis is essentially a . Like Any in  accelerate. Like All in  accelerate. Like Int in  accelerate/slice. Like Int in  accelerate/ replicate.  None None   !"#$%&'()*+,--./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkklmnnopqrstuvwxyz{|}r()*~789~~~    Q  s        r | y z   Q }    #~~             r       ! " # $ % & ' ( ) * + , , - . . / 0 0 1   2 3 3 4 5 5 6 7 7 8 9 9 : ; ; < = = > ? ? @ A A B C D E " # F G H I J J K K L M M N O O P Q R S T U V W X { Y v Z [ x \ ] ^ _ ` a b c d e fg  h gijk gl knead-0.2.2Data.Array.Knead.ParameterData.Array.Knead.Expression#Data.Array.Knead.Index.Nested.Shape Data.Array.Knead.Simple.SymbolicData.Array.Knead.Simple.Slice&Data.Array.Knead.Simple.ShapeDependent Data.Array.Knead.Simple.Physical'Data.Array.Knead.Parameterized.Symbolic'Data.Array.Knead.Parameterized.Physical%Data.Array.Knead.Parameterized.Render!Data.Array.Knead.Index.Linear.IntData.Array.Knead.Index.LinearData.Array.Knead.Simple.Fold$Data.Array.Knead.Parameterized.Slice MultiValuemodifyMultiValueData.Array.Knead.CodeData.Array.Knead.Simple.Private&Data.Array.Knead.Parameterized.PrivateTunnelTVariableConstantget valueTuple multiValue genericValue withTuple withMultiwithtunnelword32$# Decompose decomposeComposeComposedcomposeValuelift0lift1lift2lift3lift4ExpunExpliftMliftM2liftM3unliftM1unliftM2unliftM3minmaxzipzip3zip4unzipunzip3unzip4fstsndmapFstmapSndswapcurryuncurryfst3snd3thd3mapFst3mapSnd3mapThd3modifyMultiValue2modifyMultiValueMmodifyMultiValueM2modifymodify2 consComplex deconsComplexconsunitzeroaddsubmulsqrsqrtidivirem fromInteger' fromRational'cmp==*/=*<*>=*>*<=*truefalse&&*||*notselect ifThenElseShifted shiftedOffset shiftedSizeRangeScalarscalar zeroIndexCIndex intersectCodesizeCodesizeflattenIndexRecloopvalue paramWithload intersect flattenIndexArrayshape!the fromScalarfillgather backpermute2idmap mapWithIndexfold1$:. backpermutebackpermuteExtrazipWithzipWith3zipWith4fold1AllbuffertoListfromListvectorFromListrenderscanl1scatterpermuteextendParameterwithExpwithExp2withExp3feed renderShaperunSingle switchSingleIntdeconsStructShapeCons:.Zswitch switchIntindex#:.zheadtailswitchRloadMultiValuestoreMultiValuepeekpoke computeSizeconstantLinearapplypassAnypasspickextrudefoldbaseGHC.Listdrop$fApplicativeT $fFunctorT$fArrowT $fCategoryT $fFractionalT$fNumT$fMonadTllvm-extra-0.7.2LLVM.Extra.Multi.Value$fFractionalExp$fNumExp$fDecomposeComplex$fComposeComplex$fDecompose(,,,)$fCompose(,,,)$fDecompose(,,) $fCompose(,,)$fDecompose(,) $fCompose(,) $fDecompose() $fCompose()$fDecomposeAtom $fComposeExp $fValueExp$fValueT$fCInt32ToSizetoSize loopPrimitive loopStartsingletonRange rangeSizesingletonShifted$fC(,,)$fC(,) $fCShifted$fDecomposeShifted$fComposeShifted $fCShifted0$fCRange$fDecomposeRange$fComposeRange $fCRange0 $fToSizeInt64 $fToSizeInt32$fToSizeWord64$fToSizeWord32$fCInt64 $fCWord64 $fCWord32 $fScalar()$fC()ImporterExec getElementPtrcompilecreateFunctionProcessCodeVal fold1Code$fCArray callRenderer callShaper materializemapHullWithExpHullhullCorehullCreateContexthullDeleteContextcore createContext deleteContextliftexpHull arrayHullrunHull extendHullexpParam createPlain deletePlain combineCreate combineDelete$fApplicativeHull $fFunctorHull callScatterercallTheArgumentPlainArgbuildArgPlainbuild singleton_example$fArgument(,,) $fArgument(,) $fArgumentExp$fArgumentArray$fC(->)$fCExp$fComparisonInt$fIntegerConstantInt $fRealInt$fPseudoRingInt $fAdditiveInt$fCInt $fSingleIntLooprunLoopPhisrunPhisAddPhis runAddPhis getConstant ComputeSizerunComputeSizeSizerunSizeStorerunStoreLoadrunLoadPokerunPokePeekrunPeekRankrunRank FlattenIndexrunFlattenIndexReprTagUnwrap Decomposed PatternTupleIndexTagShapeTagStructFieldsProp MakeValue runMakeValueOp2runOp2 SwitchInt runSwitchInt_value_structFieldsPropstructFieldsPropFwithStructFieldsPropFFstructFieldsRecsuccStructFieldsProprank castPtrValuestoreaddPhisphis$fCT$fCT0$fCT1 $fStorableT $fDecomposeT $fCompose:.$fDecomposetag:.$fDecomposetagAtom $fScalarT$fC:.$fCZ $fProcessTfold1CodeLinear_core_createContext_deleteContext