!ͯ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!Safe-.HV"L easytensordKeep data in a primitive data frame and maintain information about Dimensions in the type systemLLNone-.FH-]Q easytensorfLoop with given increment, plus keep the step number in the first argument of the iterated functionR easytensor0Do something in a loop for int i from 0 to (n-1)S easytensor0Do something in a loop for int i from 0 to (n-1)T easytensor*Same as overDim#, but with no return valueP easytensor initial value easytensorstep easytensor!final value (LESS THAN condition)Q easytensor initial value easytensorstep easytensor!final value (LESS THAN condition)T easytensor#function to map over each dimension easytensorInitial offset easytensor offset stepU easytensor#function to map over each dimension easytensorInitial offset MNOPQRSTU MNOPQRSTUNone&'.8=>?@AFHUVXkN easytensor Deriving e using generics easytensor^Number of constructors in the tree of a sum type. This is equal to one for all other types.e easytensor1Facilities to convert to and from raw byte array.f easytensorWStore content of a data type in a primitive byte array Should be used together with  byteOffset function.g easytensor7Load content of a data type from a primitive byte arrayh easytensor<Read data from a mutable byte array given an offset in bytesi easytensorJWrite data into a mutable byte array at a given position (offset in bytes)j easytensor"Read data from a specified addressk easytensor!Write data to a specified addressl easytensorSize of a data type in bytesm easytensor&Alignment of a data type in bytes.  byteOffset" should be multiple of this value.n easytensorqOffset 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.o easytensor$Index array given an element offset. 3indexArray arr i = fromBytes ( i *# byteSize t) arrp easytensor-Read a mutable array given an element offset. 2readArray arr i = readBytes arr ( i *# byteSize t)q easytensor.Write a mutable array given an element offset. 4writeArray arr i = writeBytes arr ( i *# byteSize t)r easytensorThis 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 dy easytensorIReserve 4 bytes for tag and try to pack alternatives as good as possible. easytensor#Starting value of a constructor tag easytensor#Starting value of a constructor tag easytensor#Starting value of a constructor tag easytensor#Starting value of a constructor tag easytensor#Starting value of a constructor tagg easytensoroffset in bytesh easytensor source array easytensorbyte offset of the source arrayi easytensordestination array easytensor$byte offset of the destination array easytensordata to write into arrayVWXYZ[\]^_`abcdefghilmnopqjkrefghilmnopqjkVWXYZ[\]^_`abcdrNone.@ACF]e  easytensorBroadcast element into array easytensorIndex an array given an offset easytensor.Generate an array using an accumulator funtion easytensor3update a single element in an array given an offset easytensor(Offset of an array in number of elements easytensorNumber 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. easytensoreGet array by its offset and size in a ByteArray. Both offset and size are given in element number. easytensor3Index array by an integer offset (starting from 0). easytensor.Construct an array from a flat list and length easytensorJnumber of elements, not checked! Avoid using this argument if possible. easytensorJnumber of elements, not checked! Avoid using this argument if possible. (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone./=>?@ACFHUVXk easytensorOperations on DataFramesas is an element dimensionalitybs is an indexing dimensionalityt5 is an underlying data type (i.e. Float, Int, Double) easytensorUnsafely 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 x easytensorSet a new value to an element easytensor-Map a function over each element of DataFrame easytensor<Map a function over each element with its index of DataFrame easytensor,Generate a DataFrame by repeating an element easytensor?Generate a DataFrame by iterating a function (index -> element) easytensorLeft-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. easytensorLeft-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. easytensorRight-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. easytensorRight-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. easytensorBApply an applicative functor on each element (Lens-like traversal) easytensor^Apply an applicative functor on each element with its index (Lens-like indexed traversal) easytensor,Get an element by its index in the dataframe easytensor^Apply an applicative functor on each element with its index (Lens-like indexed traversal) easytensorBApply an applicative functor on each element (Lens-like traversal) easytensor3Apply a functor over a single element (simple lens) easytensor Index an element (reverse of !.) easytensor>Zip two spaces on a specified subspace index-wise (with index) easytensorCZip two spaces on a specified subspace element-wise (without index) easytensorPrim element offset easytensor.Number of prim elements in the prefix subspace44None -.1=?@AFHM easytensor-Specialize ScalarBase type without any arrays None.@AFk easytensor#element-wise operations for vectors easytensorImplement partial ordering for , , , - and lexicographical ordering for  None@AFk easytensor#element-wise operations for vectors easytensorImplement partial ordering for , , , - and lexicographical ordering for  None@AFk easytensor#element-wise operations for vectors easytensorImplement partial ordering for , , , - and lexicographical ordering for  None@AFkc easytensor#element-wise operations for vectors easytensorImplement partial ordering for , , , - and lexicographical ordering for  None@AFk; easytensor#element-wise operations for vectors  easytensorImplement partial ordering for , , , - and lexicographical ordering for None@AFk easytensor#element-wise operations for vectors easytensorImplement partial ordering for , , , - and lexicographical ordering for   None&',-.=>?@AEFHSUVXko easytensor@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. easytensorAccumulates only idempotent operations! Being applied to FromScalars, executes only once! Here, idempotance means: assuming  f a b = g x,  g (g x) = g x/Also, I assume the sizes of arrays are the same" easytensorImplement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone&',-.1=>?@AFHSUVXk\. easytensor2A framework for using Array type family instances./ easytensorGet Array type family instance0 easytensorThis 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. easytensor8This 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-reflection1 easytensorUse % GADT to construct an .5 dictionary. In other words, bring an evidence of .% instance into a scope at runtime.2 easytensorUse % GADT to construct an . dictionary. The same as 1, but relies on e and .3 easytensorThis is a special function, because Scalar does not require PrimBytes. That is why the dimension list in the argument is not empty.%&'()*+,-./0123456789:0./%&'()*+,-12345:6789None%&',-.1=>?@AEFHMUVXgkM easytensorBring 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.Q easytensorThis is a special function, because Scalar does not require PrimBytes. That is why the dimension list in the argument nust not be empty.V easytensor*DataFrame with its type arguments swapped.W easytensorData frame that has an unknown dimensionality at compile time. Pattern-match against its constructor to get a Nat-indexed data frame^ easytensorEmpty MultiFrame_ easytensorConstructing a  MultiFrame using DataFrame columnsm easytensor A wrapper on ln easytensor A wrapper on mo easytensor+Number of elements along the 1st dimension.p easytensor+Number of elements along the 2nd dimension.q easytensor+Number of elements along the 3rd dimension. easytensor Single frame easytensor3Multiple "columns" of data frames of the same shape easytensorData frame with some dimensions missing at compile time. Pattern-match against its constructor to get a Nat-indexed data frame.H5436;C>BA@<?=:798JHIKEDGFL\ZY][FGHIJKLMPQNORSTUVWX^_`abcdefghijklmnopqWL\ZY][WXV_^UTSRLMPQNOijkl`abcdefghJKHIFGopqmnKEDGFEDGF543JHI;6C>BA@<?=:798>BA@<?=:798_6(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone-.=>?@AEFHUVXk^ easytensor_Mutable DataFrame type. Keeps element offset, number of elements, and a mutable byte storage easytensorCreate a new mutable DataFrame. easytensorCreate a new mutable DataFrame. easytensorHCopy one DataFrame into another mutable DataFrame at specified position. easytensorPCopy one mutable DataFrame into another mutable DataFrame at specified position. easytensor4Make a mutable DataFrame immutable, without copying. easytensorCCopy content of a mutable DataFrame into a new immutable DataFrame. easytensorJCreate a new mutable DataFrame and copy content of immutable one in there. easytensoruCreate a new mutable DataFrame and copy content of immutable one in there. The result array is pinned and aligned. easytensor'UnsafeCoerces an underlying byte array. easytensor6Write a single element at the specified element offset easytensor-Write a single element at the specified index easytensor5Read a single element at the specified element offset easytensor,Read a single element at the specified index easytensor\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. easytensorfCheck if the byte array wrapped by this DataFrame is pinned, which means cannot be relocated by GC.(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone-.=>?@AEFHUVXk easytensor+Mutable DataFrame of unknown dimensionality easytensor\Mutable DataFrame that lives in ST. Internal representation is always a MutableByteArray. easytensorCreate a new mutable DataFrame. easytensorCreate a new mutable DataFrame. easytensorHCopy one DataFrame into another mutable DataFrame at specified position. easytensorPCopy one mutable DataFrame into another mutable DataFrame at specified position. easytensor4Make a mutable DataFrame immutable, without copying. easytensorCCopy content of a mutable DataFrame into a new immutable DataFrame. easytensorJCreate a new mutable DataFrame and copy content of immutable one in there. easytensoruCreate a new mutable DataFrame and copy content of immutable one in there. The result array is pinned and aligned. easytensor'UnsafeCoerces an underlying byte array. easytensor-Write a single element at the specified index easytensor,Read a single element at the specified index easytensor6Write a single element at the specified element offset easytensor5Read a single element at the specified element offset easytensorfCheck if the byte array wrapped by this DataFrame is pinned, which means cannot be relocated by GC. easytensorData frame with some dimensions missing at compile time. Pattern-match against its constructor to get a Nat-indexed mutable data frame. easytensor$Pure wrapper on a mutable byte array(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&'()*+,-./0123456789:(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone./=>?@ACFHUVXk easytensoruGeneralization of a matrix product: take scalar product over one dimension and, thus, concatenate other dimesnions easytensorTensor 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-.=>?@AEFHUVXk$ easytensor+Mutable DataFrame of unknown dimensionality easytensor\Mutable DataFrame that lives in IO. Internal representation is always a MutableByteArray. easytensorCreate a new mutable DataFrame. easytensorCreate a new mutable DataFrame. easytensorHCopy one DataFrame into another mutable DataFrame at specified position. easytensorPCopy one mutable DataFrame into another mutable DataFrame at specified position. easytensor4Make a mutable DataFrame immutable, without copying. easytensorCCopy content of a mutable DataFrame into a new immutable DataFrame. easytensorJCreate a new mutable DataFrame and copy content of immutable one in there. easytensoruCreate a new mutable DataFrame and copy content of immutable one in there. The result array is pinned and aligned. easytensor'UnsafeCoerces an underlying byte array. easytensor-Write a single element at the specified index easytensor,Read a single element at the specified index easytensor6Write a single element at the specified element offset easytensor5Read a single element at the specified element offset easytensorAllow 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. easytensorfCheck if the byte array wrapped by this DataFrame is pinned, which means cannot be relocated by GC. easytensorData frame with some dimensions missing at compile time. Pattern-match against its constructor to get a Nat-indexed mutable data frame. easytensor$Pure wrapper on a mutable byte arrayNone.>FH( easytensor$Alias for zero-dimensional DataFrame easytensor$Convert scalar back to ordinary type easytensor"Convert any type to scalar wrapper easytensor.Broadcast scalar value onto a whole data frame(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone27M? easytensorEvaluate 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. easytensor 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. easytensorFold an  case-wise, just like 2. Eagerly evaluates the value before returning! easytensorGet value from E with default value. Eagerly evaluates the value before returning! easytensorWrap a value into ; container. Eagerly evaluates the value before wrapping! easytensorJMap 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. easytensor%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?10   #"!&%$)(',+*/.-2?102   #"!&%$)(',+*/.-None&'-.>HM  easytensorbScalar product -- sum of Vecs' components products, propagated into whole Vec  easytensor>Scalar product -- sum of Vecs' components products -- a scalar easytensorDot product of two vectors easytensorSum of absolute values easytensor'hypot function (square root of squares) easytensor.Normalize vector w.r.t. Euclidean metric (L2). easytensorMaximum of absolute values easytensorMinimum of absolute values easytensorNorm in Lp space easytensorCompose a 2D vector easytensor[Take a determinant of a matrix composed from two 2D vectors. Like a cross product in 2D. easytensorCompose a 3D vector easytensor Cross product easytensor#Cross product for two vectors in 3D easytensorCompose a 4D vector           777None -.1>@AHV}0 easytensoryOperations on 4x4 transformation matrices and vectors in homogeneous coordinates. All angles are specified in radians.1 easytensorJCreate a translation matrix from a vector. The 4th coordinate is ignored.2 easytensor*Create a translation matrix from a vector.3 easytensorLRotation matrix for a rotation around the X axis, angle is given in radians.4 easytensorLRotation matrix for a rotation around the Y axis, angle is given in radians.5 easytensorLRotation matrix for a rotation around the Z axis, angle is given in radians.6 easytensorDRotation matrix for a rotation around an arbitrary normalized vector7 easytensor1Rotation matrix from the Euler angles roll (axis Z ), yaw (axis Y'), and pitch (axis X''0). This order is known as Tait-Bryan angles (Z-Y'-X''< intrinsic rotations), or nautical angles, or Cardan angles. JrotateEuler pitch yaw roll == rotateX pitch %* rotateY yaw %* rotateZ roll 8https://en.wikipedia.org/wiki/Euler_angles#Conventions_28 easytensortCreate a transform matrix using up direction, camera position and a point to look at. Just the same as GluLookAt.9 easytensorLA perspective symmetric projection matrix. Right-handed coordinate system. (x - right, y - top) Dhttp://en.wikibooks.org/wiki/GLSL_Programming/Vertex_Transformations: easytensorLAn orthogonal symmetric projection matrix. Right-handed coordinate system. (x - right, y - top) Dhttp://en.wikibooks.org/wiki/GLSL_Programming/Vertex_Transformations; easytensor'Add one more dimension and set it to 1.< easytensor'Add one more dimension and set it to 0.= easytensor}Transform a homogenous vector or point into a normal 3D vector. If the last coordinate is not zero, divide the rest by it.? easytensor.Compute LU factorization with Partial Pivoting@ easytensor4Result of LU factorization with Partial Pivoting  PA = LU .B easytensorLower triangular matrix L%. All elements on the diagonal of L equal 1.C easytensorUpper triangular matrix UD easytensorRow permutation matrix PE easytensorSign of permutation luPermSign == det . luPermG easytensorMatrix inverseI easytensorDeterminant of MatK easytensor&Mat with 1 on diagonal and 0 elsewhereL easytensor3Put the same value on the Mat diagonal, 0 otherwiseM easytensorSum of diagonal elementsO easytensor Transpose MatP easytensorAlias for DataFrames of rank 27 easytensor pitch (axis X'') easytensor yaw (axis Y') easytensor roll (axis Z)8 easytensorOThe up direction, not necessary unit length or perpendicular to the view vector easytensorThe viewers position easytensorThe point to look at9 easytensor.Near plane clipping distance (always positive) easytensor-Far plane clipping distance (always positive) easytensor'Field of view of the y axis, in radians easytensor(Aspect ratio, i.e. screen's width/height: easytensorNear plane clipping distance easytensorFar plane clipping distance easytensorwidth easytensorheight3 !"#$%&'()*+,-./0612345789:;<=>?@ABCDEFGHIJMKLNOP3NOJMKLHIFG>?@ABCDEP0612345789:;<=/,).+(-*'&# %"$!NoneFrNoneF(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone&'-.=>?@AEFHUVXkS easytensorImplement function Tb. We need to create a dedicated type class for this to make it polymorphic over kind k (Nat  - XNat).T easytensorGUnwrap the last dimension of a DataFrame into a list of smaller framesU easytensor6Append one DataFrame to another, sum up last dimensionV easytensor0Append one DataFrame to another, add another Dim = 2 to their dimension list.W easytensoraGrow the first DataFrame by adding the second one to it incrementing the last Dim in the list.X easytensorConcatenate 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.Y easytensorConcatenate a list of  DataFrames. Returns NothingO if the list does not have enough elements or if provided length is invalid.X easytensor$Minimum number of elements in a list easytensorList of frames to concatenateY easytensor$Minimum number of elements in a list easytensorAHow many elements of a list to take. Must be not smaller than m and not greater than  length ns. easytensorList of frames to concatenateSTUVWXYUVWSTYXU5V5W5(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone"#-.=>?@AEFHVXk\ easytensorCompose a 2x2D matrix] easytensorCompose a 3x3D matrix^ easytensorCompose a 4x4D matrix_ easytensorSolve Ax = b% problem given LU decomposition of A.` easytensorMPermute 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]9 !"#$%&'()*+,-./0612345789:;<=>?@ABCDEFGHIJMKLNOP\]^_`9NOJMKLHIFG>?@ABCDEP0612345789:;<=/,).+(-*'&# %"$!\]^`_None.HVqg easytensorQuaternion operationsh easytensor5Quaternion 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 vectori easytensor&Set the quaternion in format (x,y,z,w)j easytensor4Get the values of the quaternion in format (x,y,z,w)k easytensor3Set the quaternion from 3D axis vector and argumentl easytensor5Set the quaternion from 4D vector in format (x,y,z,w)m easytensor9Transform the quaternion to 4D vector in format (x,y,z,w)n easytensor$Get scalar square of the quaternion. *> realToFrac (square q) == q * conjugate qo easytensor/Imagine part of quaternion (orientation vector)p easytensorReal part of the quaternionq easytensor)Get imagenery 3D vector of the quaternionr easytensor'Real part of the quaternion into numbers easytensori-th componentt easytensorj-th componentu easytensork-th componentv easytensor,Conjugate quaternion (negate imaginary part)w easytensor9Rotates 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)x easytensorCreates a quaternion q from two vectors a and b. rotScale q a == by easytensorCreates 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.z easytensorQuaternion rotation angle6q /= 0 ==> axisRotation (imVec q) (qArg q) == signum q{ easytensorGCreate 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) >= 0| easytensorCreate 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) >= 0} easytensorGCreate 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)~ easytensorCreate 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)ghvijklmnopqrstuwxyz{|}~None-.1=>?@AFHMVLjh7667 None-.1=>?@AFHMVȗh(c) Artem ChirkinBSD3chirkin@arch.ethz.chNoneɁghvijklmnopqrstuwxyz{|}~ghvijklmnopqrstuwxyz{|}~!Nonegʏ5436;C>BA@<?=:798JHIKEDGFL\ZY][FGHIJKLMPQNORSTUVWX^_`abcdefghijklmnopq      !"#$%&'()*+,-./0612345789:;<=>?@ABCDEFGHIJMKLNOPSTUVWXY\]^_`"#$"#%"#&"#'"#("#)"*+"*,"*-"*."*/"*/"*0"*1"*1"*2"*2"*3"*4"*5"*6"*6"*7"*8"*8"*9"*:"*;"<="<>"<?"<@"<@"<A"<B"<B"<C"<D"<D"<E"<F"<F"<G"<H"<H"<I"<J"<J"#K"#L"<MNOPNOQNOQNORNSTNSUNSVNSWNSTNXYNXZNX[NX\NX]NX^NX_NX`NabNacNadNaeNafNagNahNabijklmnopqrstuvwxyz{|}~                                      ! " # $ % & ' ()*+,-./01234456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgMPUONhijklmmnopqrstuvwxyz{|}QRST~      !"#$%&'()*+,-./0123456789:;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} ~NSNS""} ~)easytensor-1.0.1.0-7D8qQSMGU4QFM9OzQI2DTRNumeric.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.Matrix.Mat44fNumeric.Matrix.Mat44dNumeric.Quaternion.ClassNumeric.Quaternion.QFloatNumeric.Quaternion.QDoubleNumeric.DataFramebaseGHC.Base<>memptymappendmconcat SemigroupMonoidData.Semigroup mtimesDefaultdiffcycle1getMinMingetMaxMaxArgArgMinArgMaxgetFirstFirstgetLastLast unwrapMonoid WrapMonoid WrappedMonoidData.Semigroup.Internal stimesMonoidstimesIdempotentgetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductstimessconcatstimesIdempotentMonoid)dimensions-1.0.1.1-Ae7FIRoDT5FK7pfZMKed84Numeric.Dimensions.IdxsunIdxIdxIdxsNumeric.Dimensions.DimsDims KnownDimsXDimsAsXDimsNumeric.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' SomeDataFrameXFrame MultiFrame_getDFS SingleFrame_getDFZ:*: 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 STDataFrameXSTFrame newDataFramenewPinnedDataFrame copyDataFramecopyMutableDataFrameunsafeFreezeDataFramefreezeDataFrame thawDataFramethawPinDataFrameunsafeThawDataFramewriteDataFrame readDataFramewriteDataFrameOffreadDataFrameOffisDataFramePinned Contractioncontract%*$fContractiontasbsasbsSomeIODataFrame IODataFrameXIOFramewithDataFramePtrScwSciScdScfScalarunScalarscalar 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 gwriteAddrtotalDimghc-prim GHC.Classes><>=<=compareGHC.Prim ByteArray#accumV2IdempotentreifyArraySing DimensionsD:R:DataFrameTYPENattns0D:R:DataFrame[]Nattsns0D:R:DataFramelXNattsxns0D:R:STDataFrameXNatstxs0D:R:STDataFrameNatstns0D:R:IODataFrameXNattxs0D:R:IODataFrameNattns0 GHC.MaybeMaybe Data.Maybemaybe GHC.TypesEQ*%-%+%/%