v      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuSafe,-FT" HdKeep data in a primitive data frame and maintain information about Dimensions in the type systemHHNone,-DF*0MfLoop with given increment, plus keep the step number in the first argument of the iterated functionN0Do something in a loop for int i from 0 to (n-1)O0Do something in a loop for int i from 0 to (n-1)P*Same as overDim#, but with no return valueL initial valuestep!final value (LESS THAN condition)M initial valuestep!final value (LESS THAN condition)P#function to map over each dimensionInitial offset offset stepQ#function to map over each dimensionInitial offset IJKLMNOPQ IJKLMNOPQNone&'-7;<=>?DFSTVhG,v Deriving a using genericsw^Number of constructors in the tree of a sum type. This is equal to one for all other types.a1Facilities to convert to and from raw byte array.bWStore content of a data type in a primitive byte array Should be used together with  byteOffset function.c7Load content of a data type from a primitive byte arrayd<Read data from a mutable byte array given an offset in byteseJWrite data into a mutable byte array at a given position (offset in bytes)f"Read data from a specified addressg!Write data to a specified addresshSize of a data type in bytesi&Alignment of a data type in bytes.  byteOffset" should be multiple of this value.jqOffset of the data in a byte array used to store the data, measured in bytes. Should be used together with getBytese function. Unless in case of special data types represented by ByteArrays, it is equal to zero.k$Index array given an element offset. 3indexArray arr i = fromBytes ( i *# byteSize t) arrl-Read a mutable array given an element offset. 2readArray arr i = readBytes arr ( i *# byteSize t)m.Write a mutable array given an element offset. 4writeArray arr i = writeBytes arr ( i *# byteSize t)nThis function allows to find out a type by comparing its tag. This is needed for array overloading, to infer array instances. For non-basic types it defaults to `uIReserve 4 bytes for tag and try to pack alternatives as good as possible.x#Starting value of a constructor tagy#Starting value of a constructor tagz#Starting value of a constructor tag{#Starting value of a constructor tag|#Starting value of a constructor tagcoffset in bytesd source arraybyte offset of the source arrayedestination array$byte offset of the destination arraydata to write into arrayRSTUVWXYZ[\]^_`abcdehijklmfgn&abcdefghijklmbcdefghijRSTUVWXYZ[\]^_`n}~RSTUVWXYZ[\]^_`v xyz{|wabcdefghijklmbcdefghijNone->?ADT Broadcast element into arrayIndex an array given an offset.Generate an array using an accumulator funtion3update a single element in an array given an offset(Offset of an array in number of elementsNumber of elements in an array. Returns zero if this information is not available at runtime. This is possible only if all elements are same in an array.eGet array by its offset and size in a ByteArray. Both offset and size are given in element number.3Index array by an integer offset (starting from 0)..Construct an array from a flat list and lengthJnumber of elements, not checked! Avoid using this argument if possible.Jnumber of elements, not checked! Avoid using this argument if possible. (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone-.;<=>?ADFSTVh|Operations on DataFramesas is an element dimensionalitybs is an indexing dimensionalityt5 is an underlying data type (i.e. Float, Int, Double)Unsafely get a sub-dataframe by its primitive element offset. The offset is not checked to be aligned to the space structure or for bounds. Arguments are zero-based primitive element offset and subset ("as" element) size (aka  of sub dataframe)-Normal indexing can be expressed in terms of : ai !. x = case (# dimVal (dim @as), fromEnum i #) of (# I# n, I# j #) -> indexOffset# (n *# j) n xSet a new value to an element-Map a function over each element of DataFrame<Map a function over each element with its index of DataFrame,Generate a DataFrame by repeating an element?Generate a DataFrame by iterating a function (index -> element)Left-associative fold of a DataFrame. The fold is strict, so accumulater is evaluated to WHNF; but you'd better make sure that the function is strict enough to not produce memory leaks deeply inside the result data type.Left-associative fold of a DataFrame with an index The fold is strict, so accumulater is evaluated to WHNF; but you'd better make sure that the function is strict enough to not produce memory leaks deeply inside the result data type.Right-associative fold of a DataFrame The fold is strict, so accumulater is evaluated to WHNF; but you'd better make sure that the function is strict enough to not produce memory leaks deeply inside the result data type.Right-associative fold of a DataFrame with an index The fold is strict, so accumulater is evaluated to WHNF; but you'd better make sure that the function is strict enough to not produce memory leaks deeply inside the result data type.BApply an applicative functor on each element (Lens-like traversal)^Apply an applicative functor on each element with its index (Lens-like indexed traversal),Get an element by its index in the dataframe^Apply an applicative functor on each element with its index (Lens-like indexed traversal)BApply an applicative functor on each element (Lens-like traversal)3Apply a functor over a single element (simple lens) Index an element (reverse of !.)>Zip two spaces on a specified subspace index-wise (with index)CZip two spaces on a specified subspace element-wise (without index)Prim element offset.Number of prim elements in the prefix subspace 44None ,-0;=>?DFK~-Specialize ScalarBase type without any arrays None->?Dh#element-wise operations for vectorsImplement partial ordering for , , , - and lexicographical ordering for  None>?Dh#element-wise operations for vectorsImplement partial ordering for , , , - and lexicographical ordering for  None>?Dh#element-wise operations for vectorsImplement partial ordering for , , , - and lexicographical ordering for  None>?Dh8#element-wise operations for vectorsImplement partial ordering for , , , - and lexicographical ordering for  None>?Dh#element-wise operations for vectorsImplement partial ordering for , , , - and lexicographical ordering for None>?DhV#element-wise operations for vectorsImplement partial ordering for , , , - and lexicographical ordering for       None&'+,-0;<=>?CDFKQSTVhC@Generic Array implementation. This array can reside in plain  and can share the  ByteArray#6 with other arrays. However, byte offset in the  ByteArray#& must be multiple of the element size.Accumulates only idempotent operations! Being applied to FromScalars, executes only once! Here, idempotance means: assuming  f a b = g ,  g (g x) = g x-Also, I assume the size of arrays is the sameImplement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone&'+,-0;<=>?DFQSTVh*2A framework for using Array type family instances.+Get Array type family instance,This type family aggregates all types used for arrays with different dimensioinality. The family is injective; thus, it is possible to get type family instance given the data constructor (and vice versa). If GHC knows the dimensionality of an array at compile time, it chooses a more efficient specialized instance of Array, e.g. Scalar newtype wrapper. Otherwise, it falls back to the generic ArrayBase implementation.MData family would not work here, because it would give overlapping instances.8This function does GHC's magic to convert user-supplied +& function to create an instance of *d typeclass at runtime. The trick is taken from Edward Kmett's reflection library explained in Chttps://www.schoolofhaskell.com/user/thoughtpolice/using-reflection-Use ! GADT to construct an *5 dictionary. In other words, bring an evidence of *% instance into a scope at runtime..Use ! GADT to construct an * dictionary. The same as -, but relies on a and ./This is a special function, because Scalar does not require PrimBytes. That is why the dimension list in the argument is not empty.!"#$%&'()*+,-./0123456,*+!"#$%&'()-./0162345!"#$%&'()*+None%&'+,-0;<=>?CDFKSTVdhIBring an evidence of *| instance into a scope at runtime. This is often used to let GHC infer other complex type class instances, such as SubSpace.MThis is a special function, because Scalar does not require PrimBytes. That is why the dimension list in the argument nust not be empty.R*DataFrame with its type arguments swapped.SData frame that has an unknown dimensionality at compile time. Pattern-match against its constructor to get a Nat-indexed data frameUEmpty MultiFrameVConstructing a  MultiFrame using DataFrame columnsd A wrapper on he A wrapper on if+Number of elements along the 1st dimension.g+Number of elements along the 2nd dimension.h+Number of elements along the 3rd dimension. Single frame3Multiple "columns" of data frames of the same shapeData frame with some dimensions missing at compile time. Pattern-match against its constructor to get a Nat-indexed data frame.H54367?:>=<8;9FDEGA@CBHBCDEFGHILMJKNOPQRSTUVWXYZ[\]^_`abcdefgh?HSTRVUQPONHIJKLM`abcWXYZ[\]^_FGDEBCfghdeG@ABC543FED76?9;:8<=> BCDEFGHIJKLMRSTV6(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,-;<=>?CDFSTVho_Mutable DataFrame type. Keeps element offset, number of elements, and a mutable byte storageCreate a new mutable DataFrame.Create a new mutable DataFrame.HCopy one DataFrame into another mutable DataFrame at specified position.PCopy one mutable DataFrame into another mutable DataFrame at specified position.4Make a mutable DataFrame immutable, without copying.CCopy content of a mutable DataFrame into a new immutable DataFrame.JCreate a new mutable DataFrame and copy content of immutable one in there.uCreate a new mutable DataFrame and copy content of immutable one in there. The result array is pinned and aligned.'UnsafeCoerces an underlying byte array.6Write a single element at the specified element offset-Write a single element at the specified index5Read a single element at the specified element offset,Read a single element at the specified index\Allow arbitrary operations on a pointer to the beginning of the data. Only possible with RealWord state (thus, in IO) due to semantics of touch#< operation that keeps the data from being garbage collected.fCheck if the byte array wrapped by this DataFrame is pinned, which means cannot be relocated by GC.(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,-;<=>?CDFSTVh?+Mutable DataFrame of unknown dimensionality\Mutable DataFrame that lives in ST. Internal representation is always a MutableByteArray.Create a new mutable DataFrame.Create a new mutable DataFrame.HCopy one DataFrame into another mutable DataFrame at specified position.PCopy one mutable DataFrame into another mutable DataFrame at specified position.4Make a mutable DataFrame immutable, without copying.CCopy content of a mutable DataFrame into a new immutable DataFrame.JCreate a new mutable DataFrame and copy content of immutable one in there.uCreate a new mutable DataFrame and copy content of immutable one in there. The result array is pinned and aligned.'UnsafeCoerces an underlying byte array.-Write a single element at the specified index,Read a single element at the specified index6Write a single element at the specified element offset5Read a single element at the specified element offsetfCheck if the byte array wrapped by this DataFrame is pinned, which means cannot be relocated by GC.Data frame with some dimensions missing at compile time. Pattern-match against its constructor to get a Nat-indexed mutable data frame.$Pure wrapper on a mutable byte array(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone!"#$%&'()*+,-./0123456(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone-.;<=>?ADFSTVhuGeneralization of a matrix product: take scalar product over one dimension and, thus, concatenate other dimesnionsTensor contraction. In particular: 1. matrix-matrix product 2. matrix-vector or vector-matrix product 3. dot product of two vectors.7(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,-;<=>?CDFSTVh +Mutable DataFrame of unknown dimensionality\Mutable DataFrame that lives in IO. Internal representation is always a MutableByteArray.Create a new mutable DataFrame.Create a new mutable DataFrame.HCopy one DataFrame into another mutable DataFrame at specified position.PCopy one mutable DataFrame into another mutable DataFrame at specified position.4Make a mutable DataFrame immutable, without copying.CCopy content of a mutable DataFrame into a new immutable DataFrame.JCreate a new mutable DataFrame and copy content of immutable one in there.uCreate a new mutable DataFrame and copy content of immutable one in there. The result array is pinned and aligned.'UnsafeCoerces an underlying byte array.-Write a single element at the specified index,Read a single element at the specified index6Write a single element at the specified element offset5Read a single element at the specified element offsetAllow arbitrary IO operations on a pointer to the beginning of the data keeping the data from garbage collecting until the arg function returns.Warning: do not let Ptr t\ leave the scope of the arg function, the data may be garbage-collected by then.Warning: use this function on a pinned DataFrame only; otherwise, the data may be relocated before the arg fun finishes.fCheck if the byte array wrapped by this DataFrame is pinned, which means cannot be relocated by GC.Data frame with some dimensions missing at compile time. Pattern-match against its constructor to get a Nat-indexed mutable data frame.$Pure wrapper on a mutable byte arrayNone-<DF>$Alias for zero-dimensional DataFrame$Convert scalar back to ordinary type"Convert any type to scalar wrapper.Broadcast scalar value onto a whole data frame(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone16K$Evaluate minimum and maximum at the same time. Arithmetics and semigroup operations are eager, functorial operations are lazy.mThis data type is especially useful for calculating bounds of foldable containers with numeric data using foldMap minMax. is effectively  with a better instance of , built off of an underlying  instead of an underlying .This version of - data type is more strict than the one from Data.Semigroup.Fold an  case-wise, just like 2. Eagerly evaluates the value before returning!Get value from E with default value. Eagerly evaluates the value before returning!Wrap a value into ; container. Eagerly evaluates the value before wrapping!JMap each element of the structure to a monoid, and combine the results.This function differs from Data.Foldable.foldMap in that uses foldl' instead of foldrF inside. This makes this function suitable for Monoids with strict  operation. For example, /foldMap' Sum $ take 1000000000 ([1..] :: [Int])(runs in constant memory, whereas normal foldMap! would cause a memory leak there.%MinMax checks whether bounds overlap.6Strict inequality means that intervals do not overlap.PNon-strict inequality means non-strict inequality in both constructor arguments. means intervals overlap?   #"!&%$)(',+*/.-210@   #"!&%$)(',+*/.-210 None&',-<F/bScalar product -- sum of Vecs' components products, propagated into whole Vec>Scalar product -- sum of Vecs' components products -- a scalarDot product of two vectorsSum of absolute values'hypot function (square root of squares).Normalize vector w.r.t. Euclidean metric (L2).Maximum of absolute valuesMinimum of absolute values Norm in Lp space Compose a 2D vector [Take a determinant of a matrix composed from two 2D vectors. Like a cross product in 2D. Compose a 3D vector  Cross product#Cross product for two vectors in 3DCompose a 4D vector          777None ,-0<>?FTR%yOperations on 4x4 transformation matrices and vectors in homogeneous coordinates. All angles are specified in radians.&)Create a translation matrix from a vector')Create a translation matrix from a vector(LRotation matrix for a rotation around the X axis, angle is given in radians.)LRotation matrix for a rotation around the Y axis, angle is given in radians.*LRotation matrix for a rotation around the Z axis, angle is given in radians.+DRotation matrix for a rotation around an arbitrary normalized vector,8Rotation matrix from the Euler angles yaw pitch and roll-tCreate a transform matrix using up direction, camera position and a point to look at. Just the same as GluLookAt..LA perspective symmetric projection matrix. Right-handed coordinate system. (x - right, y - top) Dhttp://en.wikibooks.org/wiki/GLSL_Programming/Vertex_Transformations/LAn orthogonal symmetric projection matrix. Right-handed coordinate system. (x - right, y - top) Dhttp://en.wikibooks.org/wiki/GLSL_Programming/Vertex_Transformations0'Add one more dimension and set it to 1.1'Add one more dimension and set it to 0.2}Transform a homogenous vector or point into a normal 3D vector. If the last coordinate is not zero, divide the rest by it.4.Compute LU factorization with Partial Pivoting54Result of LU factorization with Partial Pivoting  PA = LU .7Lower triangular matrix L%. All elements on the diagonal of L equal 1.8Upper triangular matrix U9Row permutation matrix P:Sign of permutation luPermSign == det . luPerm<Matrix inverse>Determinant of Mat@&Mat with 1 on diagonal and 0 elsewhereA3Put the same value on the Mat diagonal, 0 otherwiseBSum of diagonal elementsD Transpose MatEAlias for DataFrames of rank 2-OThe up direction, not necessary unit length or perpendicular to the view vectorThe viewers positionThe point to look at..Near plane clipping distance (always positive)-Far plane clipping distance (always positive)'Field of view of the y axis, in radians(Aspect ratio, i.e. screen's width/height/Near plane clipping distanceFar plane clipping distancewidthheight3 !"#$%+&'()*,-./0123456789:;<=>?B@ACDE3CD?@AB=>;<3456789:E%&'()*+,-./012$!# "% &'()*+,-./0123456789:;<=>?@ABCD(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone&',-;<=>?CDFSTVhh HImplement function Ib. We need to create a dedicated type class for this to make it polymorphic over kind k (Nat  - XNat).IGUnwrap the last dimension of a DataFrame into a list of smaller framesJ6Append one DataFrame to another, sum up last dimensionK0Append one DataFrame to another, add another Dim = 2 to their dimension list.LaGrow the first DataFrame by adding the second one to it incrementing the last Dim in the list.MConcatenate a list of  DataFrames. Returns Nothing+ if the list does not have enough elements.Input must be parametrized by [Nat]^ to make sure every element in the input list has the same dimensionality. Output is in [XNat]8, because the last dimension is unknown at compile time.NConcatenate a list of  DataFrames. Returns NothingO if the list does not have enough elements or if provided length is invalid.M$Minimum number of elements in a listList of frames to concatenateN$Minimum number of elements in a listAHow many elements of a list to take. Must be not smaller than m and not greater than  length ns.List of frames to concatenateHIJKLMNJKLHINMHIJ5K5L5(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone"#,-;<=>?CDFTVhoiQCompose a 2x2D matrixRCompose a 3x3D matrixSCompose a 4x4D matrixTSolve Ax = b% problem given LU decomposition of A.UMPermute rows that the largest magnitude elements in columns are on diagonals.Invariants of result matrix: * forall j >= i: |M[i,i]| >= M[j,i] * if M[i,i] == 0 then forall j >= i: |M[i+1,i+1]| >= M[j,i+1]+ !"#$3456789:;<=>?B@ACDEQRSTU+CD?@AB=>;<3456789:E$!# "QRSUTNone-FT\Quaternion operations]5Quaternion data type. The ordering of coordinates is x y z w , where w is an argument, and x y z are components of a 3D vector^&Set the quaternion in format (x,y,z,w)_4Get the values of the quaternion in format (x,y,z,w)`3Set the quaternion from 3D axis vector and argumenta5Set the quaternion from 4D vector in format (x,y,z,w)b9Transform the quaternion to 4D vector in format (x,y,z,w)c$Get scalar square of the quaternion. *> realToFrac (square q) == q * conjugate qd/Imagine part of quaternion (orientation vector)eReal part of the quaternionf)Get imagenery 3D vector of the quaterniong'Real part of the quaternion into numberhi-th componentij-th componentjk-th componentk,Conjugate quaternion (negate imaginary part)l9Rotates and scales vector in 3D using quaternion. Let q = (cos (a/2), sin (a/2) * v); then the rotation angle is a, and the axis of rotation is v . Scaling is proportional to |v|^2.%rotScale q x == q * x * (conjugate q)mCreates a quaternion q from two vectors a and b. rotScale q a == bnCreates a rotation versor from an axis vector and an angle in radians. Result is always a unit quaternion (versor). If the argument vector is zero, then result is a real unit quaternion.oQuaternion rotation angle6q /= 0 ==> axisRotation (imVec q) (qArg q) == signum qpGCreate a quaternion from a rotation matrix. Note, that rotations of q and `-q`r are equivalent, there result of this function may be ambiguious. I decided to force its real part be positive:taker (fromMatrix33 m) >= 0qCreate a quaternion from a homogenious coordinates trasform matrix. Ignores matrix translation transform. Note, that rotations of q and `-q`r are equivalent, there result of this function may be ambiguious. I decided to force its real part be positive:taker (fromMatrix44 m) >= 0rGCreate a rotation matrix from a quaternion. Note, that rotations of q and `-q`1 are equivalent, so the following property holds:toMatrix33 q == toMatrix33 (-q)sCreate a homogenious coordinates trasform matrix from a quaternion. Translation of the output matrix is zero. Note, that rotations of q and `-q`1 are equivalent, so the following property holds:toMatrix44 q == toMatrix44 (-q)\]k^_`abcdefghijlmnopqrs\]^_`abcdefghijklmnopqrsNone,-0;<=>?DFKT]t7667None,-0;<=>?DFKT-]u(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone&\]k^_`abcdefghijlmnopqrstu\]^_`abcdefghijklmnopqrsutNoned654367?:>=<8;9FDEGA@CBHBCDEFGHILMJKNOPQRSTUVWXYZ[\]^_`abcdefgh      !"#$3456789:;<=>?B@ACDEHIJKLMNQRSTU !" #$ #% #& !' #( !) !* !+ !, !- !. !/ !0 !1 !2 !2 !3 !4 !4 !5 !5 !6 !7 !8 !9 !9 !: !; !; !< != !> ?@ ?A ?A ?B ?C ?C ?D ?E ?E ?F ?G ?G ?H ?I ?I ?J ?K ?KLMNLMOLMOLMPLQRLSTLSULSVLSWLSXLSYLSZLS[L\]L\^L\_L\`L\aL\bL\cL\]defghijklmnopqrstuvwxyz{|}~                                      ! " #$%&'()*+,-.//0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abHKPJIcdefghhijklmnopqrsLMNOtuvwxyz{|}~      !"#$%&'()*+,-./01233456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~LQLQLQLQRLQLQg # qr)easytensor-1.0.0.0-EQwktdQmboTKiXgeNLMQfGNumeric.SemigroupNumeric.DataFrame.TypeNumeric.DataFrame.Family(Numeric.DataFrame.Internal.Array.PrimOpsNumeric.PrimBytes&Numeric.DataFrame.Internal.Array.ClassNumeric.DataFrame.SubSpace2Numeric.DataFrame.Internal.Array.Family.ScalarBase/Numeric.DataFrame.Internal.Array.Family.FloatX4/Numeric.DataFrame.Internal.Array.Family.FloatX3/Numeric.DataFrame.Internal.Array.Family.FloatX20Numeric.DataFrame.Internal.Array.Family.DoubleX40Numeric.DataFrame.Internal.Array.Family.DoubleX30Numeric.DataFrame.Internal.Array.Family.DoubleX21Numeric.DataFrame.Internal.Array.Family.ArrayBase'Numeric.DataFrame.Internal.Array.Family"Numeric.DataFrame.Internal.MutableNumeric.DataFrame.STNumeric.DataFrame.ContractionNumeric.DataFrame.IONumeric.ScalarNumeric.VectorNumeric.Matrix.ClassNumeric.DataFrame.ShapeNumeric.MatrixNumeric.Quaternion Numeric.DataFrame.Internal.ArrayNumeric.Quaternion.ClassNumeric.Quaternion.QFloatNumeric.Quaternion.QDoubleNumeric.DataFramebaseData.Semigroup<>GHC.Basememptymappendmconcat SemigroupMonoiddiff mtimesDefaultstimesIdempotentstimesIdempotentMonoid stimesMonoidcycle1stimessconcatgetMinMingetMaxMaxArgArgMinArgMaxgetFirstFirstgetLastLast unwrapMonoid WrapMonoid WrappedMonoid Data.MonoidgetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProduct)dimensions-1.0.0.0-JqapYVXbO0lFbcgM5G0LVGNumeric.Dimensions.IdxsunIdxIdxIdxsNumeric.Dimensions.DimsDimsNumeric.TypedListTypeListUEmpty:*ConsSnocReverse TypedList Numeric.DimDimDDnDxNXNXNat DataFrameinftyDinftyFminInt#loop# loopWithI#loop1#loop1a# overDim_# overDim_'#PrimTag PTagFloat PTagDoublePTagIntPTagInt8 PTagInt16 PTagInt32 PTagInt64PTagWord PTagWord8 PTagWord16 PTagWord32 PTagWord64PTagPtr PTagOther PrimBytesgetBytes fromBytes readBytes writeBytesreadAddr writeAddrbyteSize byteAlign byteOffset indexArray readArray writeArrayprimTag$fGPrimBytesURec$fGPrimBytesURec0$fGPrimBytesURec1$fGPrimBytesURec2$fGPrimBytesURec3$fGPrimBytesURec4$fGPrimBytes:+:$fGPrimBytes:*:$fGPrimBytesM1$fGPrimBytesU1$fGPrimBytesV1$fPrimTaggedPtr$fPrimTaggedWord64$fPrimTaggedWord32$fPrimTaggedWord16$fPrimTaggedWord8$fPrimTaggedWord$fPrimTaggedInt64$fPrimTaggedInt32$fPrimTaggedInt16$fPrimTaggedInt8$fPrimTaggedInt$fPrimTaggedDouble$fPrimTaggedFloat $fPrimTaggeda $fPrimBytes[]$fPrimBytesEither$fPrimBytesMaybe$fPrimBytesTypedList$fPrimBytesTypedList0$fPrimBytesTypedList1$fPrimBytesIdx$fPrimBytesWord64$fPrimBytesWord32$fPrimBytesWord16$fPrimBytesWord8$fPrimBytesInt64$fPrimBytesInt32$fPrimBytesInt16$fPrimBytesInt8$fPrimBytesPtr$fPrimBytesDouble$fPrimBytesFloat$fPrimBytesInt$fPrimBytesWord$fGPrimBytesK1 PrimArray broadcastix#gen#upd# elemOffset elemSize0 fromElemsixOffunsafeFromFlatListSubSpace indexOffset#updateewmapiwmapewgeniwgenewfoldliwfoldlewfoldriwfoldr elementWise indexWise!. indexWise_ elementWise_element! ewfoldMap iwfoldMapiwzipewzip$fSubSpacetasbsasbs ScalarBase _unScalarBase$fPrimArraytScalarBase$fBoundedScalarBase$fBoundedScalarBase0$fShowScalarBase$fEnumScalarBase$fEqScalarBase$fIntegralScalarBase$fNumScalarBase$fFractionalScalarBase$fFloatingScalarBase$fOrdScalarBase$fReadScalarBase$fRealScalarBase$fRealFracScalarBase$fRealFloatScalarBase$fPrimBytesScalarBase$fBoundedScalarBase1FloatX4FloatX4#$fPrimArrayFloatFloatX4$fPrimBytesFloatX4$fFloatingFloatX4$fFractionalFloatX4 $fNumFloatX4 $fOrdFloatX4 $fEqFloatX4 $fShowFloatX4$fBoundedFloatX4FloatX3FloatX3#$fPrimArrayFloatFloatX3$fPrimBytesFloatX3$fFloatingFloatX3$fFractionalFloatX3 $fNumFloatX3 $fOrdFloatX3 $fEqFloatX3 $fShowFloatX3$fBoundedFloatX3FloatX2FloatX2#$fPrimArrayFloatFloatX2$fPrimBytesFloatX2$fFloatingFloatX2$fFractionalFloatX2 $fNumFloatX2 $fOrdFloatX2 $fEqFloatX2 $fShowFloatX2$fBoundedFloatX2DoubleX4 DoubleX4#$fPrimArrayDoubleDoubleX4$fPrimBytesDoubleX4$fFloatingDoubleX4$fFractionalDoubleX4 $fNumDoubleX4 $fOrdDoubleX4 $fEqDoubleX4$fShowDoubleX4$fBoundedDoubleX4DoubleX3 DoubleX3#$fPrimArrayDoubleDoubleX3$fPrimBytesDoubleX3$fFloatingDoubleX3$fFractionalDoubleX3 $fNumDoubleX3 $fOrdDoubleX3 $fEqDoubleX3$fShowDoubleX3$fBoundedDoubleX3DoubleX2 DoubleX2#$fPrimArrayDoubleDoubleX2$fPrimBytesDoubleX2$fFloatingDoubleX2$fFractionalDoubleX2 $fNumDoubleX2 $fOrdDoubleX2 $fEqDoubleX2$fShowDoubleX2$fBoundedDoubleX2 ArrayBase$fPrimArraytArrayBase$fFloatingArrayBase$fFractionalArrayBase$fNumArrayBase$fBoundedArrayBase$fBoundedArrayBase0$fBoundedArrayBase1$fShowArrayBase$fOrdArrayBase $fEqArrayBase$fPrimBytesArrayBase ArraySingAScalarAF2AF3AF4AD2AD3AD4ABaseArraySingletonaSingArrayaSingEv inferASing inferPrimElem inferPriminferEqinferOrdinferNuminferFractional inferFloating inferShow$fArraySingletonDouble:$fArraySingletonDouble:0$fArraySingletonDouble:1$fArraySingletonFloat:$fArraySingletonFloat:0$fArraySingletonFloat:1$fArraySingletont[]$fArraySingletontds$fShowArraySing$fOrdArraySing $fEqArraySingDim3dim3Dim2dim2Dim1dim1DataFrameInference PrimFramesArraySingletons ImplAllowsAllTypes DataFrame' SomeDataFrameZ:*: inferOrd' inferNum'inferFractional'inferFloating' inferASing'inferEq' inferShow' inferPrim'inferPrimElem'bSizeOfbAlignOfdimSize1dimSize2dimSize3$fStorableDataFrame$fShowDataFrame$fShowDataFrame0 $fEqDataFrame$fDataFrameInference[]ts$fDataFrameInferenceTYPEt$fShowSomeDataFrame$fShowDataFrame1$fEqSomeDataFrame$fEqDataFrame0$fDim1XNatDataFrame:$fDim1kTypedList: $fDim1kt:$fDim2XNatDataFrame:$fDim2kTypedList: $fDim2kt:$fDim3XNatDataFrame:$fDim3kTypedList: $fDim3kt:$fPrimBytesDataFrame$fPrimArrayDataFrame$fRealFloatDataFrame$fRealFracDataFrame$fRealDataFrame$fReadDataFrame$fOrdDataFrame$fFloatingDataFrame$fFractionalDataFrame$fNumDataFrame$fIntegralDataFrame$fEnumDataFrame$fBoundedDataFrame$fEqDataFrame1 MDataFrame newDataFrame#newPinnedDataFrame#copyDataFrame#copyMDataFrame#unsafeFreezeDataFrame#freezeDataFrame#thawDataFrame#thawPinDataFrame#unsafeThawDataFrame#writeDataFrameOff#writeDataFrame#readDataFrameOff#readDataFrame#withDataFramePtr#isDataFramePinned#SomeSTDataFrame STDataFrame newDataFramenewPinnedDataFrame copyDataFramecopyMutableDataFrameunsafeFreezeDataFramefreezeDataFrame thawDataFramethawPinDataFrameunsafeThawDataFramewriteDataFrame readDataFramewriteDataFrameOffreadDataFrameOffisDataFramePinned Contractioncontract%*$fContractiontasbsasbsSomeIODataFrame IODataFramewithDataFramePtrScwSciScdScfScalarunScalarscalar fromScalarMinMaxOption getOptionoption fromOptiontoOptionminMaxmmDiffmmAvgfoldMap'$fMonoidOption$fSemigroupOption$fTraversableOption$fFoldableOption $fNumMinMax $fOrdMinMax$fBoundedMinMax$fMonadFixMinMax $fMonadMinMax$fApplicativeMinMax$fFunctorMinMax$fMonoidMinMax$fSemigroupMinMax $fEqOption $fOrdOption $fShowOption $fReadOption $fDataOption$fGenericOption$fGeneric1Option$fFunctorOption$fAlternativeOption$fApplicativeOption $fMonadOption$fMonadFixOption $fEqMinMax $fReadMinMax $fShowMinMax $fDataMinMax$fGenericMinMax$fGeneric1MinMaxVec4wVec3wVec2wVec4iVec3iVec2iVec4dVec3dVec2dVec4fVec3fVec2fVector.*.dot·normL1normL2 normalized normLPInf normLNInfnormLPvec2det2vec3cross×vec4unpackV2unpackV3unpackV4Mat44dMat34dMat24dMat43dMat33dMat23dMat42dMat32dMat22dMat44fMat34fMat24fMat43fMat33fMat23fMat42fMat32fMat22f HomTransform4 translate4 translate3rotateXrotateYrotateZrotate rotateEulerlookAt perspective orthogonal toHomPoint toHomVectorfromHomMatrixLUluLUFactluLowerluUpperluPerm luPermSign MatrixInverseinverseMatrixDeterminantdet SquareMatrixeyediagtraceMatrixTranspose transposeMatrix $fEqLUFact $fShowLUFactDataFrameToListtoList<:><::><+:>fromList fromListN$fDataFrameToListXNattxnsxz$fDataFrameToListNattnszmat22mat33mat44luSolvepivotMat $fMatrixLUtn$fMatrixDeterminanttn$fMatrixInverseTYPEtn$fSquareMatrixtn$fMatrixTransposeTYPEXNattxnxm$fMatrixTransposeTYPENattnm QuaternionQuaterpackQunpackQ fromVecNumfromVec4toVec4squareimreimVectakertakeitakejtakek conjugaterotScale getRotScale axisRotationqArg fromMatrix33 fromMatrix44 toMatrix33 toMatrix44QFloatQDouble GPrimBytesgconTags gfromBytes greadBytes gwriteBytes greadAddr gwriteAddr PrimTaggedprimTag' ggetBytes gbyteSize gbyteAlign gbyteOffsettotalDimghc-prim GHC.Classes><>=<=compareGHC.Prim ByteArray#accumV2IdempotentreifyArraySing DimensionsMagicArraySingD:R:DataFrameTYPENattns0D:R:DataFrame[]Nattsns0D:R:DataFramelXNattsxns0AsXDimsXDims KnownDims SingleFrame MultiFrameXFrame_getDF_getDFS MDataFrame#D:R:STDataFrameXNatstxs0D:R:STDataFrameNatstns0XSTFrameT#D:R:IODataFrameXNattxs0D:R:IODataFrameNattns0XIOFrameMaybe Data.Maybemaybe GHC.TypesEQ$fQuaternionFloatD:R:QuaterFloat0*%-%+%/%$fQuaternionDoubleD:R:QuaterDouble0