!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                   +(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone05I3Evaluate 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.55 is effectively  with a better instance of , built off of an underlying  instead of an underlying .This version of 5- data type is more strict than the one from Data.Semigroup.8Fold an 5 case-wise, just like 2. Eagerly evaluates the value before returning!9Get value from 5E with default value. Eagerly evaluates the value before returning!:Wrap a value into 5; 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 overlap3456789:;<=>?@ABCDEFGHIJK?   #"!&%$)(',+*/.-2103456789:;<=>@  > #"!&%$)(',+*/.-21056789: 34;<=3456789:;<=>?@ABCDEFGHIJK(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone05<=?T}^_`abcdefghijklmnopqrstuvwxyz{|}~!^_`abcdefghijklmnopqrstuvwxyz{|}~!stqropmnklijghefcdab^_`uvwxyz{|}~q^_`abcdefghijklmnopqrstuvwxyz{|}~(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone*+,9:;<=?BDRT Facilities to convert to and from raw byte array. Warning! offsets and sizes are in elements, not in bytes! Therefore one must be really carefull if having a crazy idea of converting between types of different element sizes.!nStore content of a data type in a primitive byte array (ElementOffset, NumberOfElements, ByteArrayContent )"oLoad content of a data type from a primitive byte array (ElementOffset, NumberOfElements, ByteArrayContent )#Size of a data type in bytes$!Alignment of a data type in bytes%)Size of a conainer type elements in bytes&Primitive indexing !"#$%&'()*+,-./01234  &!"#$%'( (' !"#$%& !"#$%&'()*+,-./01234 (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone <=?BOTgh 5RAccess elements. i is an index type x is an element t is a container type/Index an element by its offset in the container!Index an element in the containermap all elements with indexgenerate data from elements2generate data from elements in applicative functorfold all element with indexfold all element with indexBApply an applicative functor on each element (Lens-like traversal) ^Apply an applicative functor on each element with its index (Lens-like indexed traversal)!$Fill a container with a single value"Update a single element5 !"#$%&'()*+,-. 5 !" 5  !"#$%&'()*+,-. (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone*,/9:;<=ABDIQRTf /Use this typeclass constraint in libraries functions if there is a need to select an instance of Array famility at runtime. Combination of < and 7L allows to bring into typechecker's scope any specific typeclass instance7>Pattern match agains result to get actual array dimensionality<9Pattern match against result to get specific element type=[A singleton type used to prove that the given Array family instance has a known instance>7Keep information about the instance behind Array family>Warning! This part of the code is platform and flag dependent.R/Keep information about the array dimensionality>Warning! This part of the code is platform and flag dependent.Y1Keep information about the element type instance.>Warning! This part of the code is platform and flag dependent.0)Specialize scalar type without any arrays1!Full collection of n-order arraysg^Given element type instance and proper dimension list, infer a corresponding array instance2#Indexing over scalars is trivial...~/6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab0cd1effgghijklmnopqrstuvw2xyzg/6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab0cd1fg4/6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY Z[\]^_`abcde3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab0cd1effgghijklmnopqrstuvw2xyz (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf{,Do something in a loop for int i from 0 to n|,Do something in a loop for int i from 0 to n}!Treat a single number as an array~\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for {|}~{|}~(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for           (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!Implement partial ordering for , , , ' and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR #element-wise operations for vectors!Implement partial ordering for , , , - and lexicographical ordering for  "#$%& !'() "#$%& !'()(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR*#element-wise operations for vectors+Implement partial ordering for , , , - and lexicographical ordering for  ,-./0*+123 ,-./0*+123(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR4#element-wise operations for vectors5Implement partial ordering for , , , - and lexicographical ordering for  6789:45;<= 6789:45;<=(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR>#element-wise operations for vectors?Implement partial ordering for , , , - and lexicographical ordering for  @ABCD>?EFG @ABCD>?EFG(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDRH#element-wise operations for vectorsIImplement partial ordering for , , , - and lexicographical ordering for  JKLMNHIOPQ JKLMNHIOPQ(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDRR#element-wise operations for vectorsSImplement partial ordering for , , , - and lexicographical ordering for  TUVWXRSYZ[ TUVWXRSYZ[(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&*+,/9:;<=ABDIQRTfi1Allow some integer-like operations on data framesj.Allow floating-point operations on data framesk*Allow all common operations on data framesl6Allow all numeric operations depending on element typemdKeep data in a primitive data frame and maintain information about Dimensions in the type-system\Partially known at compile time] Completely fixed at compile timehijklm^_`abcdef\] hijklm^_`hijklmabcdef\^]_`(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,-9:;<=?BDQRTfouGeneralization of a matrix product: take scalar product over one dimension and, thus, concatenate other dimesnionspTensor contraction. In particular: 1. matrix-matrix product 2. matrix-vector or vector-matrix product 3. dot product of two vectors.gBDo something in a loop for int i from 0 to n-1 and j from 0 to m-1nophijklmnopqrsgtuvwxyz{|}~nopnophijklmnopqrsgtuvwxyz{|}~p7(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=ABDQRTf 6Write a single element at the specified element offset5Read a single element at the specified element offsetMutable DataFrame typeCreate 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.-Write a single element at the specified index,Read a single element at the specified indexq qq(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,Dt$Alias for zero-dimensional DataFrameu$Convert scalar back to ordinary typev"Convert any type to scalar wrapperrstuvrstuvtuvsrrstuv(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=ABDQRTf w+Mutable DataFrame of unknown dimensionalityyUMutable DataFrame that lives in IO. Internal representation is always a ByteArray.zCreate 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.-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 offsetwxyz{|}~qwxyz{|}~qywxz{|}~ wxyz{|}~(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=ABDQRTf +Mutable DataFrame of unknown dimensionalityUMutable DataFrame that lives in ST. Internal representation is always a ByteArray.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.-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 offsetqq  (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,-9:;<=?BDQRTfOperations 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 subset. 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,Get an element by its index in the dataframeSet 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)^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):Specialized instance of SubSpace for operating on scalars.  44 (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,:DbScalar 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 valuesNorm in Lp spaceCompose 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 3D vector777!None,:<=DRyOperations 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 vectorLRotation 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 vector8Rotation matrix from the Euler angles yaw pitch and rolltCreate 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_TransformationsLAn orthogonal symmetric projection matrix. Right-handed coordinate system. (x - right, y - top) Dhttp://en.wikibooks.org/wiki/GLSL_Programming/Vertex_Transformations'Add one more dimension and set it to 1.'Add one more dimension and set it to 0.}Transform a homogenous vector or point into a normal 3D vector. If the last coordinate is not zero, divide the rest by it.Matrix inverse&Mat with 1 on diagonal and 0 elsewhere3Put the same value on the Mat diagonal, 0 otherwiseDeterminant of MatSum of diagonal elements Transpose MatAlias for DataFrames of rank 2** "(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf ,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!LSwap columns i and j. Does not check if i or j is larger than matrix width mStarting from i-th row and i+1-th column, substract a multiple of i-th column from i+1 .. m columns, such that there are only zeroes in i-th row and i+1..m columns elements.aSubstract a multiple of i-th column from 0 .. i-1 and i+1 .. m columns, such that there are only zeroes in i-th row everywhere except i-th column Assuming that elements in 0..i-1 columnts and in i-th row are zeroes, so they do not affect other columns. After all columns updated, divide i-th row by its diagonal element, so (i,i) element has 1.DRemove a multiple of one row from another one. do: xi = xi - yi*atGives index of maximum (absolute) element in i-th row, starting from i-th element only. If i >= m then returns i.BDo something in a loop for int i from 0 to n-1 and j from 0 to m-1Implement partial ordering for , , , ' and lexicographical ordering for #(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf ,Do something in a loop for int i from 0 to n,Do something in a loop for int i from 0 to n!Treat a single number as an array\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!LSwap columns i and j. Does not check if i or j is larger than matrix width mStarting from i-th row and i+1-th column, substract a multiple of i-th column from i+1 .. m columns, such that there are only zeroes in i-th row and i+1..m columns elements.aSubstract a multiple of i-th column from 0 .. i-1 and i+1 .. m columns, such that there are only zeroes in i-th row everywhere except i-th column Assuming that elements in 0..i-1 columnts and in i-th row are zeroes, so they do not affect other columns. After all columns updated, divide i-th row by its diagonal element, so (i,i) element has 1.DRemove a multiple of one row from another one. do: xi = xi - yi*atGives index of maximum (absolute) element in i-th row, starting from i-th element only. If i >= m then returns i.BDo something in a loop for int i from 0 to n-1 and j from 0 to m-1Implement partial ordering for , , , ' and lexicographical ordering for $None%None&(c) Artem ChirkinBSD3chirkin@arch.ethz.chNoneg/6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab0cd1fg'(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone %&,:<=ADTf4Allow all common operations on available data framesEvidence for ElementWise classEvidence for PrimBytes class((c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&+,9:;<=ABDQRTfImplement function b. We need to create a dedicated type class for this to make it polymorphic over kind k (Nat  - XNat).GUnwrap the last dimension of a DataFrame into a list of smaller framesDAppend one DataFrame to another, adding up their last dimensionalityDAppend one DataFrame to another, adding up their last dimensionalityDAppend one DataFrame to another, adding up their last dimensionalityInput must be parametrized by [Nat] to make sure every element in the input list has the same dimensionality. Output is in [XNat], because the last dimension is unknown at compile time.Broadcast scalar value onto a whole data frame  555(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,:<=ABDRTCompose a 2x2D matrixCompose a 3x3D matrixCompose a 4x4D matrix.p.p(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm^noprstuv_mljihknop5=>?@ABCDEFGHIJKLMNOPQfg6789:RSTUVWX;<YZ[\]^_`abcde)None,DRQuaternion operations5Quaternion 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 argument5Set the quaternion from 4D vector in format (x,y,z,w)9Transform the quaternion to 4D vector in format (x,y,z,w)$Get scalar square of the quaternion. *> realToFrac (square q) == q * conjugate q/Imagine part of quaternion (orientation vector)Real part of the quaternion)Get imagenery 3D vector of the quaternion'Real part of the quaternion into numberi-th componentj-th componentk-th component ,Conjugate quaternion (negate imaginary part) 9Rotates 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) Creates a quaternion q from two vectors a and b. rotScale q a == b Creates 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. Quaternion rotation angle6q /= 0 ==> axisRotation (imVec q) (qArg q) == signum qGCreate 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) >= 0Create 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) >= 0GCreate 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)Create 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)               *None ,9;BDR  +None ,9;BDR7667 (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone          ,-.,/0,/1,/2,-3,/4,-5,-6,-7,-8,-9,-:,-;,-<,-=,->,->,-?,-@,-@,-A,-A,-B,-C,-D,-E,-E,-F,-G,-G,-H,-I,-J,KL,KM,KM,KN,KO,KO,KP,KQ,KQ,KR,KS,KS,KT,KU,KU,KV,KW,KWXXYYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM 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 n o p q r s t u v w x y z { | } ~                                                 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!''''''((((((())) ) ) ) ) )))))))))))))))))*+ ,/!,"#$%&'     (     )  * + , - . / 0 1 2 3 4 5 6  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 l m n o p q r s t u v w x y z { | } ~      $$$$$                l !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI J K"""""L"M"N"O"P""Q,R"""""""S"T"U"V"W"X"Y"Z"["\"]#####L#M#N#O#P##^#######_#`#a#b#c#d#e#f#g#h#i$j$k%j%l(m(n(o(p**q**r*s*t*u*v*w*x*y*z+ +q+{+|+}+~++r+s+t+u+v+w+x++)easytensor-0.3.2.0-1hX3lySMUcuA9vwxsMW3EUNumeric.SemigroupNumeric.Semigroup.StrictTupleNumeric.CommonsNumeric.DataFrameNumeric.MatrixNumeric.DataFrame.IONumeric.ScalarNumeric.DataFrame.STNumeric.VectorNumeric.QuaternionNumeric.Array.ElementWiseNumeric.Array.FamilyNumeric.Array.Family.ArrayINumeric.Array.Family.ArrayI16Numeric.Array.Family.ArrayI32Numeric.Array.Family.ArrayI64Numeric.Array.Family.ArrayI8Numeric.Array.Family.ArrayWNumeric.Array.Family.ArrayW16Numeric.Array.Family.ArrayW32Numeric.Array.Family.ArrayW64Numeric.Array.Family.ArrayW8Numeric.Array.Family.DoubleX2Numeric.Array.Family.DoubleX3Numeric.Array.Family.DoubleX4Numeric.Array.Family.FloatX2Numeric.Array.Family.FloatX3Numeric.Array.Family.FloatX4Numeric.DataFrame.TypeNumeric.DataFrame.ContractionNumeric.DataFrame.MutableNumeric.DataFrame.SubSpaceNumeric.Matrix.ClassNumeric.Array.Family.ArrayDNumeric.Array.Family.ArrayFNumeric.Matrix.Mat44dNumeric.Matrix.Mat44f Numeric.ArrayNumeric.DataFrame.InferenceNumeric.DataFrame.ShapeNumeric.Quaternion.ClassNumeric.Quaternion.QDoubleNumeric.Quaternion.QFloatbaseData.Semigroup<>GHC.Basememptymappendmconcat SemigroupMonoiddiff mtimesDefaultstimesIdempotentstimesIdempotentMonoid stimesMonoidcycle1stimessconcatgetMinMingetMaxMaxArgArgMinArgMaxgetFirstFirstgetLastLast unwrapMonoid WrapMonoid WrappedMonoid Data.MonoidgetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductMinMaxOption getOptionoption fromOptiontoOptionminMaxmmDiffmmAvgfoldMap' $fNumMinMax $fOrdMinMax$fBoundedMinMax$fMonadFixMinMax $fMonadMinMax$fApplicativeMinMax$fFunctorMinMax$fMonoidMinMax$fSemigroupMinMax$fMonoidOption$fSemigroupOption$fTraversableOption$fFoldableOption $fEqOption $fOrdOption $fShowOption $fReadOption $fDataOption$fGenericOption$fGeneric1Option$fFunctorOption$fAlternativeOption$fApplicativeOption $fMonadOption$fMonadFixOption $fEqMinMax $fReadMinMax $fShowMinMax $fDataMinMax$fGenericMinMax$fGeneric1MinMax StrictTuple toStrictTuplefromStrictTupleT9T8T7T6T5T4T3T2T1T0strictT0strictT1strictT2strictT3strictT4strictT5strictT6strictT7strictT8strictT9$fStrictTuple(,,,,,,,,)T9$fStrictTuple(,,,,,,,)T8$fStrictTuple(,,,,,,)T7$fStrictTuple(,,,,,)T6$fStrictTuple(,,,,)T5$fStrictTuple(,,,)T4$fStrictTuple(,,)T3$fStrictTuple(,)T2$fStrictTuple()T0 $fBifunctorT9 $fBifunctorT8 $fBifunctorT7 $fBifunctorT6 $fBifunctorT5 $fBifunctorT4 $fBifunctorT3 $fBifunctorT2$fTraversableT9$fTraversableT8$fTraversableT7$fTraversableT6$fTraversableT5$fTraversableT4$fTraversableT3$fTraversableT2$fTraversableT1 $fFoldableT9 $fFoldableT8 $fFoldableT7 $fFoldableT6 $fFoldableT5 $fFoldableT4 $fFoldableT3 $fFoldableT2 $fFoldableT1 $fBoundedT9 $fBoundedT8 $fBoundedT7 $fBoundedT6 $fBoundedT5 $fBoundedT4 $fBoundedT3 $fBoundedT2 $fBoundedT1 $fBoundedT0 $fMonadT9 $fMonadT8 $fMonadT7 $fMonadT6 $fMonadT5 $fMonadT4 $fMonadT3 $fMonadT2 $fMonadT1$fApplicativeT9$fApplicativeT8$fApplicativeT7$fApplicativeT6$fApplicativeT5$fApplicativeT4$fApplicativeT3$fApplicativeT2$fApplicativeT1 $fFunctorT9 $fFunctorT8 $fFunctorT7 $fFunctorT6 $fFunctorT5 $fFunctorT4 $fFunctorT3 $fFunctorT2 $fFunctorT1 $fMonoidT9 $fMonoidT8 $fMonoidT7 $fMonoidT6 $fMonoidT5 $fMonoidT4 $fMonoidT3 $fMonoidT2 $fMonoidT1 $fMonoidT0 $fSemigroupT9 $fSemigroupT8 $fSemigroupT7 $fSemigroupT6 $fSemigroupT5 $fSemigroupT4 $fSemigroupT3 $fSemigroupT2 $fSemigroupT1 $fSemigroupT0$fEqT0$fShowT0$fReadT0$fOrdT0$fDataT0 $fGenericT0$fEqT1$fShowT1$fReadT1$fOrdT1$fDataT1 $fGenericT1 $fGeneric1T1$fEqT2$fShowT2$fReadT2$fOrdT2$fDataT2 $fGenericT2 $fGeneric1T2$fEqT3$fShowT3$fReadT3$fOrdT3$fDataT3 $fGenericT3 $fGeneric1T3$fEqT4$fShowT4$fReadT4$fOrdT4$fDataT4 $fGenericT4 $fGeneric1T4$fEqT5$fShowT5$fReadT5$fOrdT5$fDataT5 $fGenericT5 $fGeneric1T5$fEqT6$fShowT6$fReadT6$fOrdT6$fDataT6 $fGenericT6 $fGeneric1T6$fEqT7$fShowT7$fReadT7$fOrdT7$fDataT7 $fGenericT7 $fGeneric1T7$fEqT8$fShowT8$fReadT8$fOrdT8$fDataT8 $fGenericT8 $fGeneric1T8$fEqT9$fShowT9$fReadT9$fOrdT9$fDataT9 $fGenericT9 $fGeneric1T9 PrimBytestoBytes fromBytesbyteSize byteAlignelementByteSizeixElemPrimElemRep$fPrimBytesWord64$fPrimBytesWord32$fPrimBytesWord16$fPrimBytesWord8$fPrimBytesWord$fPrimBytesInt64$fPrimBytesInt32$fPrimBytesInt16$fPrimBytesInt8$fPrimBytesInt$fPrimBytesDouble$fPrimBytesFloat ElementWiseArraySizeInferencearraySizeInstanceinferSnocArrayInstanceinferConsArrayInstanceinferInitArrayInstanceElemTypeInferenceelemTypeInstanceArrayInstanceEvidence ArrayInstanceAIScalarAIArrayFAIArrayDAIArrayI AIArrayI8 AIArrayI16 AIArrayI32 AIArrayI64AIArrayW AIArrayW8 AIArrayW16 AIArrayW32 AIArrayW64 AIFloatX2 AIFloatX3 AIFloatX4 AIDoubleX2 AIDoubleX3 AIDoubleX4 ArraySizeASScalarASX2ASX3ASX4ASXNASArrayElemTypeETFloatETDoubleETIntETInt8ETInt16ETInt32ETInt64ETWordETWord8ETWord16ETWord32ETWord64getArrayInstanceinferArrayInstanceNumericVariantFrame IntegralFrameFPFRame CommonOpFrame NumericFrame DataFrame Contractioncontract%* MutableFrameScdScfScalarunScalarscalarSomeIODataFrame IODataFrame newDataFrame copyDataFramecopyMutableDataFrameunsafeFreezeDataFramefreezeDataFrame thawDataFramewriteDataFrame readDataFramewriteDataFrameOffreadDataFrameOffSomeSTDataFrame STDataFrameSubSpace indexOffset#!.updateewmapiwmapewgeniwgenewfoldliwfoldlewfoldriwfoldr elementWise indexWise indexWise_ elementWise_element! ewfoldMap iwfoldMapiwzipewzipVec4dVec3dVec2dVec4fVec3fVec2fVector.*.dot·normL1normL2 normalized normLPInf normLNInfnormLPvec2det2vec3cross×vec4unpackV2unpackV3unpackV4Mat44dMat34dMat24dMat43dMat33dMat23dMat42dMat32dMat22dMat44fMat34fMat24fMat43fMat33fMat23fMat42fMat32fMat22f HomTransform4 translate4 translate3rotateXrotateYrotateZrotate rotateEulerlookAt perspective orthogonal toHomPoint toHomVectorfromHom MatrixInverseinverseSquareMatrixCalculuseyediagdettraceMatrixCalculus transposeMatrixNumericFrameEvidenceElementWiseEvidencePrimBytesEvidenceinferPrimBytesinferElementWiseinferNumericFrameDataFrameToListtoList<:><::><+:>fromList fromScalarmat22mat33mat44 QuaternionQuaterpackQunpackQ fromVecNumfromVec4toVec4squareimreimVectakertakeitakejtakek conjugaterotScale getRotScale axisRotationqArg fromMatrix33 fromMatrix44 toMatrix33 toMatrix44QDoubleQFloatMaybe Data.Maybemaybeghc-prim GHC.TypesEQ strictMinMaxewgenA broadcast$fElementWiseIntWord64Word64$fElementWiseIntWord32Word32$fElementWiseIntWord16Word16$fElementWiseIntWord8Word8$fElementWiseIntWordWord$fElementWiseIntInt64Int64$fElementWiseIntInt32Int32$fElementWiseIntInt16Int16$fElementWiseIntInt8Int8$fElementWiseIntIntInt$fElementWiseIntDoubleDouble$fElementWiseIntFloatFloatArrayInstanceInferenceArray$fElementWiseIdxtScalarDoubleX4 DoubleX4#DoubleX3 DoubleX3#DoubleX2 DoubleX2#FloatX4FloatX4#FloatX3FloatX3#FloatX2FloatX2#ArrayW64 ArrayW64#FromScalarW64#ArrayW32 ArrayW32#FromScalarW32#ArrayW16 ArrayW16#FromScalarW16#ArrayW8ArrayW8# FromScalarW8#ArrayWArrayW# FromScalarW#ArrayI64 ArrayI64#FromScalarI64#ArrayI32 ArrayI32#FromScalarI32#ArrayI16 ArrayI16#FromScalarI16#ArrayI8ArrayI8# FromScalarI8#ArrayIArrayI# FromScalarI#ArrayDArrayD# FromScalarD#ArrayFArrayF# FromScalarF# _unScalarinftyDinftyF"_suppressHlintUnboxedTuplesWarning$fArraySizeInference:$fArraySizeInference:0$fArraySizeInference:1$fArraySizeInference[]$fElemTypeInferenceWord64$fElemTypeInferenceWord32$fElemTypeInferenceWord16$fElemTypeInferenceWord8$fElemTypeInferenceWord$fElemTypeInferenceInt64$fElemTypeInferenceInt32$fElemTypeInferenceInt16$fElemTypeInferenceInt8$fElemTypeInferenceInt$fElemTypeInferenceDouble$fElemTypeInferenceFloat$fBoundedScalar$fBoundedScalar0 $fShowScalarloop1#loop1a#broadcastArrayaccumV2 $fOrdArrayI GHC.Classes><>=<=compare ArrayUpdate#AU#mapVzipVwr$fBoundedArrayI $fNumArrayI$fPrimBytesArrayI $fEqArrayI $fShowArrayI$fElementWiseIdxIntArrayI $fOrdArrayI16$fBoundedArrayI16 $fNumArrayI16$fPrimBytesArrayI16 $fEqArrayI16$fShowArrayI16$fElementWiseIdxInt16ArrayI16 $fOrdArrayI32$fBoundedArrayI32 $fNumArrayI32$fPrimBytesArrayI32 $fEqArrayI32$fShowArrayI32$fElementWiseIdxInt32ArrayI32 $fOrdArrayI64$fBoundedArrayI64 $fNumArrayI64$fPrimBytesArrayI64 $fEqArrayI64$fShowArrayI64$fElementWiseIdxInt64ArrayI64 $fOrdArrayI8$fBoundedArrayI8 $fNumArrayI8$fPrimBytesArrayI8 $fEqArrayI8 $fShowArrayI8$fElementWiseIdxInt8ArrayI8 $fOrdArrayW$fBoundedArrayW $fNumArrayW$fPrimBytesArrayW $fEqArrayW $fShowArrayW$fElementWiseIdxWordArrayW $fOrdArrayW16$fBoundedArrayW16 $fNumArrayW16$fPrimBytesArrayW16 $fEqArrayW16$fShowArrayW16$fElementWiseIdxWord16ArrayW16 $fOrdArrayW32$fBoundedArrayW32 $fNumArrayW32$fPrimBytesArrayW32 $fEqArrayW32$fShowArrayW32$fElementWiseIdxWord32ArrayW32 $fOrdArrayW64$fBoundedArrayW64 $fNumArrayW64$fPrimBytesArrayW64 $fEqArrayW64$fShowArrayW64$fElementWiseIdxWord64ArrayW64 $fOrdArrayW8$fBoundedArrayW8 $fNumArrayW8$fPrimBytesArrayW8 $fEqArrayW8 $fShowArrayW8$fElementWiseIdxWord8ArrayW8 $fNumDoubleX2 $fOrdDoubleX2infty$fElementWiseIdxDoubleDoubleX2$fPrimBytesDoubleX2$fFloatingDoubleX2$fFractionalDoubleX2 $fEqDoubleX2$fShowDoubleX2$fBoundedDoubleX2 $fNumDoubleX3 $fOrdDoubleX3$fElementWiseIdxDoubleDoubleX3$fPrimBytesDoubleX3$fFloatingDoubleX3$fFractionalDoubleX3 $fEqDoubleX3$fShowDoubleX3$fBoundedDoubleX3 $fNumDoubleX4 $fOrdDoubleX4$fElementWiseIdxDoubleDoubleX4$fPrimBytesDoubleX4$fFloatingDoubleX4$fFractionalDoubleX4 $fEqDoubleX4$fShowDoubleX4$fBoundedDoubleX4 $fNumFloatX2 $fOrdFloatX2$fElementWiseIdxFloatFloatX2$fPrimBytesFloatX2$fFloatingFloatX2$fFractionalFloatX2 $fEqFloatX2 $fShowFloatX2$fBoundedFloatX2 $fNumFloatX3 $fOrdFloatX3$fElementWiseIdxFloatFloatX3$fPrimBytesFloatX3$fFloatingFloatX3$fFractionalFloatX3 $fEqFloatX3 $fShowFloatX3$fBoundedFloatX3 $fNumFloatX4 $fOrdFloatX4$fElementWiseIdxFloatFloatX4$fPrimBytesFloatX4$fFloatingFloatX4$fFractionalFloatX4 $fEqFloatX4 $fShowFloatX4$fBoundedFloatX4D:R:DataFrameXNattxns0D:R:DataFrameNattns0 SomeDataFrameKnownDataFrame_getDF$fShowDataFrame $fEqDataFrame$fStorableDataFrame$fElementWiseIdxtDataFrame$fShowDataFrame0loop2#prodFprodDprodIprodI8prodI16prodI32prodI64prodWprodW8prodW16prodW32prodW64$fContractionWord64asbsasbs$fContractionWord32asbsasbs$fContractionWord16asbsasbs$fContractionWord8asbsasbs$fContractionWordasbsasbs$fContractionInt64asbsasbs$fContractionInt32asbsasbs$fContractionInt16asbsasbs$fContractionInt8asbsasbs$fContractionIntasbsasbs$fContractionDoubleasbsasbs$fContractionFloatasbsasbswriteDataFrameOff#readDataFrameOff# MDataFrame newDataFrame#copyDataFrame#copyMDataFrame#unsafeFreezeDataFrame#freezeDataFrame#thawDataFrame#writeDataFrame#readDataFrame# MDataFrame#$fMutableFrameWord64ns$fMutableFrameWord32ns$fMutableFrameWord16ns$fMutableFrameWord8ns$fMutableFrameWordns$fMutableFrameInt64ns$fMutableFrameInt32ns$fMutableFrameInt16ns$fMutableFrameInt8ns$fMutableFrameIntns$fMutableFrameDoublens$fMutableFrameFloatns)dimensions-0.3.2.0-4kEGTueUWNbCc5yzdbtOW4Numeric.Dimensions.DimtotalDim$fSubSpacet[]bsbs$fSubSpacetasbsasbs swapCols# clearRowEnd# clearRowAll# multNRem# maxInRowRem# $fOrdArrayD GHC.TypeLits$fMatrixInverseDoublen$fSquareMatrixCalculusDoublen$fMatrixCalculusDoublenm$fFloatingArrayD$fFractionalArrayD $fNumArrayD$fBoundedArrayD$fPrimBytesArrayD $fEqArrayD $fShowArrayD$fElementWiseIdxDoubleArrayD $fOrdArrayF$fMatrixInverseFloatn$fSquareMatrixCalculusFloatn$fMatrixCalculusFloatnm$fFloatingArrayF$fFractionalArrayF $fNumArrayF$fBoundedArrayF$fPrimBytesArrayF $fEqArrayF $fShowArrayF$fElementWiseIdxFloatArrayFnotYet$fHomTransform4Double$fHomTransform4Float fromListN$fIsListDataFrame$fDataFrameToListXNattxzxns$fDataFrameToListNattznsqdotmax#sign# $fShowQuater $fEqQuater$fFloatingQuater$fFractionalQuater $fNumQuaterD:R:QuaterDouble0$fQuaternionDouble*%-%+%/%D:R:QuaterFloat0$fQuaternionFloat