)a      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone*+,9:;<=?BDRTFacilities 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 bytesPrimitive indexing     (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone <=?BOTgh RAccess 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 valueUpdate a single element    (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 L allows to bring into typechecker's scope any specific typeclass instance>Pattern match agains result to get actual array dimensionality9Pattern match against result to get specific element type[A singleton type used to prove that the given Array family instance has a known instance7Keep information about the instance behind Array family>Warning! This part of the code is platform and flag dependent.2/Keep information about the array dimensionality>Warning! This part of the code is platform and flag dependent.91Keep information about the element type instance.>Warning! This part of the code is platform and flag dependent. )Specialize scalar type without any arrays !Full collection of n-order arraysG^Given element type instance and proper dimension list, infer a corresponding array instance #Indexing over scalars is trivial...z  !"#$%&'()*+,-./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./0123456789:;< => FG?@ABCDEFGHIJKLMNO Pg  !"#$%&'()*+,-./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./0123456789:;< => FG0  !"#$%&'()*+,-./0123456789 :;<=>?@ABCDE  !"#$%&'()*+,-./0123456789:;< => FG?@ABCDEFGHIJKLMNO P (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTfQ,Do something in a loop for int i from 0 to nR,Do something in a loop for int i from 0 to nS!Treat a single number as an arrayT\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!UImplement partial ordering for V, W, X, Y' and lexicographical ordering for Z[\QRST]^_`abUcde[\QRST]^_`abUcde (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTff,Do something in a loop for int i from 0 to ng,Do something in a loop for int i from 0 to nh!Treat a single number as an arrayi\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!jImplement partial ordering for V, W, X, Y' and lexicographical ordering for Zklfghimnopqrjstuklfghimnopqrjstu (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTfv,Do something in a loop for int i from 0 to nw,Do something in a loop for int i from 0 to nx!Treat a single number as an arrayy\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!zImplement partial ordering for V, W, X, Y' and lexicographical ordering for Z{|vwxy}~z{|vwxy}~z(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 V, W, X, Y' and lexicographical ordering for Z(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 V, W, X, Y' and lexicographical ordering for Z(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 V, W, X, Y' and lexicographical ordering for Z(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 V, W, X, Y' and lexicographical ordering for Z(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 V, W, X, Y' and lexicographical ordering for Z(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 V, W, X, Y' and lexicographical ordering for Z(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 V, W, X, Y' and lexicographical ordering for Z(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR#element-wise operations for vectorsImplement partial ordering for V, W, X, Y- and lexicographical ordering for Z(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR#element-wise operations for vectorsImplement partial ordering for V, W, X, Y- and lexicographical ordering for Z(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR#element-wise operations for vectorsImplement partial ordering for V, W, X, Y- and lexicographical ordering for Z          (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR#element-wise operations for vectorsImplement partial ordering for V, W, X, Y- and lexicographical ordering for Z(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR#element-wise operations for vectorsImplement partial ordering for V, W, X, Y- and lexicographical ordering for Z(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR#element-wise operations for vectorsImplement partial ordering for V, W, X, Y- and lexicographical ordering for Z !"#$% !"#$%(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()*+,-./0&' HIJKLM()*HIJKLM+,-./0&(')*(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.1BDo something in a loop for int i from 0 to n-1 and j from 0 to m-1NOP23456789:;<=1>?@ABCDEFGHINOPNOP23456789:;<=1>?@ABCDEFGHIP7(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=ABDQRTf J6Write a single element at the specified element offsetK5Read a single element at the specified element offsetLMutable DataFrame typeMCreate a new mutable DataFrame.NHCopy one DataFrame into another mutable DataFrame at specified position.OPCopy one mutable DataFrame into another mutable DataFrame at specified position.P4Make a mutable DataFrame immutable, without copying.QCCopy content of a mutable DataFrame into a new immutable DataFrame.RJCreate a new mutable DataFrame and copy content of immutable one in there.S-Write a single element at the specified indexT,Read a single element at the specified indexQJKLUMNOPQRSTVWXYZ[\]^_`a QJKLMNOPQRSTQJKLUMNOPQRSTVWXYZ[\]^_`a(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 indexa,Read a single element at the specified indexb6Write a single element at the specified element offsetc5Read a single element at the specified element offsetWXYbZ[\]^_`abcQWXYZ[\]^_`abcQYWXZ[\]^_`abc WXYbZ[\]^_`abc(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=ABDQRTf d+Mutable DataFrame of unknown dimensionalityfUMutable DataFrame that lives in ST. Internal representation is always a ByteArray.gCreate a new mutable DataFrame.hHCopy one DataFrame into another mutable DataFrame at specified position.iPCopy one mutable DataFrame into another mutable DataFrame at specified position.j4Make a mutable DataFrame immutable, without copying.kCCopy content of a mutable DataFrame into a new immutable DataFrame.lJCreate a new mutable DataFrame and copy content of immutable one in there.m-Write a single element at the specified indexn,Read a single element at the specified indexo6Write a single element at the specified element offsetp5Read a single element at the specified element offsetdefcghijklmnopQdefghijklmnopQfdeghijklmnop defcghijklmnop(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,-9:;<=?BDQRTfqOperations on DataFramesas is an element dimensionalitybs is an indexing dimensionalityt5 is an underlying data type (i.e. Float, Int, Double)rUnsafely 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 d of sub dataframe)-Normal indexing can be expressed in terms of r: ai !. x = case (# dimVal (dim @as), fromEnum i #) of (# I# n, I# j #) -> indexOffset# (n *# j) n xs,Get an element by its index in the dataframetSet a new value to an elementu-Map a function over each element of DataFramev<Map a function over each element with its index of DataFramew,Generate a DataFrame by repeating an elementx?Generate a DataFrame by iterating a function (index -> element)yLeft-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.zLeft-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)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)e:Specialized instance of SubSpace for operating on scalars.qrstuvwxyz{|}~efqruwy{}~tsvxz| q rstuvwxyz{|}~efs44(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 vector777None,:<=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 g,Do something in a loop for int i from 0 to nh,Do something in a loop for int i from 0 to ni!Treat a single number as an arrayj\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!kLSwap columns i and j. Does not check if i or j is larger than matrix width mlStarting 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.maSubstract 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.nDRemove a multiple of one row from another one. do: xi = xi - yi*aotGives index of maximum (absolute) element in i-th row, starting from i-th element only. If i >= m then returns i.pBDo something in a loop for int i from 0 to n-1 and j from 0 to m-1qImplement partial ordering for V, W, X, r' and lexicographical ordering for Zstghijuvwklmnopxyz{|}~qstghijuvwklmnopxyz{|}~q!(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 V, W, X, r' and lexicographical ordering for Z"None#None$(c) Artem ChirkinBSD3chirkin@arch.ethz.chNoneg  !"#$%&'()*+,-./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./0123456789:;< => FG%(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.chNone !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM(NOPRSTUVqruwy{}~tsvxz|]MLJIHKqrstuvwxyz{|}~NOP !"#$%&'()*+,-./01FG23456789:;<=>?@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 == bCreates 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*+,-./0123456789:;<=> ? @ 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 qrstuvwxyz{|}~%%%%%%&&&&&&&'''''''''''''''''''' ' ' ' ' ()                ~   ! " # $ % & ' ( ) * + , - . / 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 hijkijlijmijnijo p q r s t u v w x y z d e f g { p q r s t | } ~    d e f g  p q r s t      defgpqrstdefgpqrstdefgpqrstdefgpqrstdefgpqrstdefgpqrstdefgpqrstR      !"#$%&'() d e f g * + , - .  /01n p q r s t 2 3 4 5 6 7 8 9 : ;!d!e!f!g!*!+!,!-!.!!<!p!q!r!s!t!=!>!?!@!A!B!C!D!E!F"G"H#G#I&J&K&L&M((N(O(P(Q(R(S(T(U(V(W(X))N)Y)Z)[)\)O)P)Q)R)S)T)U)V)])^_)easytensor-0.3.1.0-7gjxgmZ60mtLfIpFxB7GW1Numeric.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.QFloat 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 indexWiseelement! 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 toMatrix44QDoubleQFloatewgenA 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# _unScalar"_suppressHlintUnboxedTuplesWarning$fArraySizeInference:$fArraySizeInference:0$fArraySizeInference:1$fArraySizeInference[]$fElemTypeInferenceWord64$fElemTypeInferenceWord32$fElemTypeInferenceWord16$fElemTypeInferenceWord8$fElemTypeInferenceWord$fElemTypeInferenceInt64$fElemTypeInferenceInt32$fElemTypeInferenceInt16$fElemTypeInferenceInt8$fElemTypeInferenceInt$fElemTypeInferenceDouble$fElemTypeInferenceFloat $fShowScalarloop1#loop1a#broadcastArrayaccumV2 $fOrdArrayIghc-prim 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 $fOrdDoubleX2$fElementWiseIdxDoubleDoubleX2$fPrimBytesDoubleX2$fFloatingDoubleX2$fFractionalDoubleX2 $fEqDoubleX2$fShowDoubleX2 $fNumDoubleX3 $fOrdDoubleX3$fElementWiseIdxDoubleDoubleX3$fPrimBytesDoubleX3$fFloatingDoubleX3$fFractionalDoubleX3 $fEqDoubleX3$fShowDoubleX3 $fNumDoubleX4 $fOrdDoubleX4$fElementWiseIdxDoubleDoubleX4$fPrimBytesDoubleX4$fFloatingDoubleX4$fFractionalDoubleX4 $fEqDoubleX4$fShowDoubleX4 $fNumFloatX2 $fOrdFloatX2$fElementWiseIdxFloatFloatX2$fPrimBytesFloatX2$fFloatingFloatX2$fFractionalFloatX2 $fEqFloatX2 $fShowFloatX2 $fNumFloatX3 $fOrdFloatX3$fElementWiseIdxFloatFloatX3$fPrimBytesFloatX3$fFloatingFloatX3$fFractionalFloatX3 $fEqFloatX3 $fShowFloatX3 $fNumFloatX4 $fOrdFloatX4$fElementWiseIdxFloatFloatX4$fPrimBytesFloatX4$fFloatingFloatX4$fFractionalFloatX4 $fEqFloatX4 $fShowFloatX4D: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.1.0-9Q5O1aXti8OFJ4thj4xq4CNumeric.Dimensions.DimtotalDim$fSubSpacet[]bsbs$fSubSpacetasbsasbs swapCols# clearRowEnd# clearRowAll# multNRem# maxInRowRem# $fOrdArrayDbase GHC.TypeLits$fMatrixInverseDoublen$fSquareMatrixCalculusDoublen$fMatrixCalculusDoublenm$fFloatingArrayD$fFractionalArrayD $fNumArrayD$fPrimBytesArrayD $fEqArrayD $fShowArrayD$fElementWiseIdxDoubleArrayD $fOrdArrayF$fMatrixInverseFloatn$fSquareMatrixCalculusFloatn$fMatrixCalculusFloatnm$fFloatingArrayF$fFractionalArrayF $fNumArrayF$fPrimBytesArrayF $fEqArrayF $fShowArrayF$fElementWiseIdxFloatArrayFnotYet$fHomTransform4Double$fHomTransform4Float fromListN$fIsListDataFrame$fDataFrameToListXNattxzxns$fDataFrameToListNattznsqdotinftymax#sign# $fShowQuater $fEqQuater$fFloatingQuater$fFractionalQuater $fNumQuaterD:R:QuaterDouble0$fQuaternionDouble*%-%+%/%D:R:QuaterFloat0$fQuaternionFloat