L$.      !"#$%&'()*+,-./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.chSafe<=?OTgh RAccess elements. i is an index type x is an element t is a container typeIndex a 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 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 family3/Keep information about the array dimensionality:0Keep information about the element type instance)Specialize scalar type without any arrays!Full collection of n-order arraysH^Given element type instance and proper dimension list, infer a corresponding array instance#Indexing over scalars is trivial...q !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH     ^ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH- !"#$%&'()*+,-./0123456789: ;<=>?@ABCDEFGH      (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 +,&'()-./012*345+,&'()-./012*345 (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf6,Do something in a loop for int i from 0 to n7,Do something in a loop for int i from 0 to n8!Treat a single number as an array9\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!:Implement partial ordering for , , , ' and lexicographical ordering for ;<6789=>?@AB:CDE;<6789=>?@AB:CDE (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 , , , ' and lexicographical ordering for KLFGHIMNOPQRJSTUKLFGHIMNOPQRJSTU(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 , , , ' and lexicographical ordering for [\VWXY]^_`abZcde[\VWXY]^_`abZcde(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 , , , ' and lexicographical ordering for klfghimnopqrjstuklfghimnopqrjstu(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 , , , ' and lexicographical ordering for {|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 , , , ' 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 vectorsImplement partial ordering for , , , - and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR#element-wise operations for vectorsImplement partial ordering for , , , - and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,9;<=BDR#element-wise operations for vectorsImplement partial ordering for , , , - and lexicographical ordering for (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&*+,/9:;<=ABDIQRTfJ1Allow some integer-like operations on data framesK.Allow floating-point operations on data framesL*Allow all common operations on data framesM6Allow all numeric operations depending on element typeNdKeep data in a primitive data frame and maintain information about Dimensions in the type-systemPartially known at compile time Completely fixed at compile timeIJKLMN IJKLMNIJKLMN(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=?BDQRTfPuGeneralization of a matrix product: take scalar product over one dimension and, thus, concatenate other dimesnionsQTensor contraction. In particular: 1. matrix-matrix product 2. matrix-vector or vector-matrix product 3. dot product of two vectors.BDo something in a loop for int i from 0 to n-1 and j from 0 to m-1OPQOPQOPQQ7(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=ABDRTf 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 indexR RR (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,DU$Alias for zero-dimensional DataFrameV$Convert scalar back to ordinary typeW"Convert any type to scalar wrapperSTUVWSTUVWUVWTSSTUVW(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=ABDRTf XUMutable DataFrame that lives in IO. Internal representation is always a ByteArray.YCreate a new mutable DataFrame.ZHCopy 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 indexa6Write a single element at the specified element offsetb5Read a single element at the specified element offset X YZ[\]^_`ab RXYZ[\]^_`ab RXYZ[\]^_`ab X YZ[\]^_`ab(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,9:;<=ABDRTf cUMutable DataFrame that lives in ST. Internal representation is always a ByteArray.dCreate a new mutable DataFrame.eHCopy one DataFrame into another mutable DataFrame at specified position.fPCopy one mutable DataFrame into another mutable DataFrame at specified position.g4Make a mutable DataFrame immutable, without copying.hCCopy content of a mutable DataFrame into a new immutable DataFrame.iJCreate a new mutable DataFrame and copy content of immutable one in there.j-Write a single element at the specified indexk,Read a single element at the specified indexl6Write a single element at the specified element offsetm5Read a single element at the specified element offset c defghijklm Rcdefghijklm Rcdefghijklm c defghijklm(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,-9:;<=?BDQRTfnOperations on DataFrames as is an element dimensionality bs is an indexing dimensionality t is an underlying data type (i.e. Float, Int, Double)oGet an elementpSet a new value to an elementq-Map a function over each element of DataFramer<Map a function over each element with its index of DataFrames,Generate a DataFrame by repeating an elementt?Generate a DataFrame by iterating a function (index -> element)uLeft-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.vLeft-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.wRight-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.xRight-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.yBApply an applicative functor on each element (Lens-like traversal)z^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) :Specialized instance of SubSpace for operating on scalars.nopqrstuvwxyz{|}~  nqsuwyzportvx{|}~ n opqrstuvwxyz{|}~  o4|4(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone,:<=DRMatrix 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 m.Starting 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.0DRemove a multiple of one row from another one. do: xi = xi - yi*a1tGives index of maximum (absolute) element in i-th row, starting from i-th element only. If i >= m then returns i.2BDo something in a loop for int i from 0 to n-1 and j from 0 to m-13Implement partial ordering for , , , ' and lexicographical ordering for 45)*+,678-./0129:;<=>?3@AB45)*+,678-./0129:;<=>?3@AB(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)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(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone^ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH(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 CDEF CDEF555(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,:<=ABDRTCompose a 2x2D matrixCompose a 3x3D matrixCompose a 4x4D matrix QQ (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQSTUVWnqsuwyzportvx{|}~YNMKJILnopqrstuvwxyz|{}~OPQ!"#$%&'()*+,-./012GH3456789 :;<=>?@ABCDEFG!"#$%&'()*+,-./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 ijklmnopqrstuvwxyz{|}~z{|}~    v                                            v                       ! "#$%#$&#$'#$(#$) * + , - . / 0 1 2 3 4    ! 5 * + , - . 6 7 8 9 : ;    ! < * + , - . = > ? @ A B    ! C * + , - . D E F G H I !J*+,-.KLMNOP !Q*+,-.RSTUVW !X*+,-.YZ[\]^ !_*+,-.`abcde !f*+,-.ghijkl !m*+,-.nopqrstuvwxyz{|}~ y !(*+,-. !*+,-.    )easytensor-0.2.0.0-6WGgsR1DVEsCSKIqoSde5VNumeric.CommonsNumeric.DataFrameNumeric.MatrixNumeric.DataFrame.IONumeric.ScalarNumeric.DataFrame.STNumeric.VectorNumeric.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.FloatX2Numeric.Array.Family.FloatX3Numeric.Array.Family.FloatX4Numeric.DataFrame.TypeNumeric.DataFrame.ContractionNumeric.DataFrame.MutableNumeric.DataFrame.SubSpaceNumeric.Matrix.TypeNumeric.Array.Family.ArrayDNumeric.Array.Family.ArrayF Numeric.ArrayNumeric.DataFrame.InferenceNumeric.DataFrame.Shape PrimBytestoBytes fromBytesbyteSize byteAlignelementByteSizeix WordBytesIntBytes DoubleBytes FloatBytesElemPrimElemRep$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 ArraySizeASScalarASX2ASX3ASX4ASXNASArrayElemTypeETFloatETDoubleETIntETInt8ETInt16ETInt32ETInt64ETWordETWord8ETWord16ETWord32ETWord64getArrayInstanceinferArrayInstanceNumericVariantFrame IntegralFrameFPFRame CommonOpFrame NumericFrame DataFrame Contractioncontract%* MutableFrameScdScfScalarunScalarscalar IODataFrame newDataFrame copyDataFramecopyMutableDataFrameunsafeFreezeDataFramefreezeDataFrame thawDataFramewriteDataFrame readDataFramewriteDataFrameOffreadDataFrameOff STDataFrameSubSpace!.updateewmapiwmapewgeniwgenewfoldliwfoldlewfoldriwfoldr elementWise indexWiseelement! ewfoldMap iwfoldMapiwzipewzip MatrixInverseinverseSquareMatrixCalculuseyediagdettraceMatrixCalculus transposeMatrixVec4dVec3dVec2dVec4fVec3fVec2fVector.*.dot·normL1normL2 normLPInf normLNInfnormLPvec2det2vec3cross×vec4NumericFrameEvidenceElementWiseEvidencePrimBytesEvidenceinferPrimBytesinferElementWiseinferNumericFrameDataFrameToListtoList<:><::><+:>fromList fromScalarMat44fMat34fMat24fMat43fMat33fMat23fMat42fMat32fMat22fmat22mat33mat44ewgenA broadcast$fElementWiseIntWord64Word64$fElementWiseIntWord32Word32$fElementWiseIntWord16Word16$fElementWiseIntWord8Word8$fElementWiseIntWordWord$fElementWiseIntInt64Int64$fElementWiseIntInt32Int32$fElementWiseIntInt16Int16$fElementWiseIntInt8Int8$fElementWiseIntIntInt$fElementWiseIntDoubleDouble$fElementWiseIntFloatFloatArrayInstanceInferenceArray$fElementWiseIdxtScalarFloatX4FloatX4#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 $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$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$fElementWiseIdxFloatArrayF fromListN$fIsListDataFrame$fDataFrameToListXNattxzxns$fDataFrameToListNattzns