V91      !"#$%&'()*+,-./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 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.3/Keep information about the array dimensionality>Warning! This part of the code is platform and flag dependent.:1Keep 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 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 -.()*+/01234,567-.()*+/01234,567 (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTf8,Do something in a loop for int i from 0 to n9,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 =>89:;?@ABCD<EFG=>89:;?@ABCD<EFG (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTfH,Do something in a loop for int i from 0 to nI,Do something in a loop for int i from 0 to nJ!Treat a single number as an arrayK\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!LImplement partial ordering for , , , ' and lexicographical ordering for MNHIJKOPQRSTLUVWMNHIJKOPQRSTLUVW(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTfX,Do something in a loop for int i from 0 to nY,Do something in a loop for int i from 0 to nZ!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 ]^XYZ[_`abcd\efg]^XYZ[_`abcd\efg(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTfh,Do something in a loop for int i from 0 to ni,Do something in a loop for int i from 0 to nj!Treat a single number as an arrayk\Accumulates only idempotent operations! Being applied to FromScalars, executes only once!lImplement partial ordering for , , , ' and lexicographical ordering for mnhijkopqrstluvwmnhijkopqrstluvw(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone%&,9:;<=BDQRTfx,Do something in a loop for int i from 0 to ny,Do something in a loop for int i from 0 to nz!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 }~xyz{|}~xyz{|(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 DataFramesas is an element dimensionalitybs is an indexing dimensionalityt5 is an underlying data type (i.e. Float, Int, Double)oUnsafely 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 element offset and element size (aka  of sub dataframe)-Normal indexing can be expressed in terms of o: ai !. x = case (# dimVal (dim @as), fromEnum i #) of (# I# n, I# j #) -> indexOffset# (n *# j) n xp,Get an element by its index in the dataframeqSet a new value to an elementr-Map a function over each element of DataFrames<Map a function over each element with its index of DataFramet,Generate a DataFrame by repeating an elementu?Generate a DataFrame by iterating a function (index -> element)vLeft-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.wLeft-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.xRight-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.yRight-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.zBApply 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):Specialized instance of SubSpace for operating on scalars.nopqrstuvwxyz{|}~nortvxz{qpsuwy|}~ n opqrstuvwxyz{|}~p4}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!0LSwap columns i and j. Does not check if i or j is larger than matrix width m1Starting 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.2aSubstract 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.3DRemove a multiple of one row from another one. do: xi = xi - yi*a4tGives index of maximum (absolute) element in i-th row, starting from i-th element only. If i >= m then returns i.5BDo something in a loop for int i from 0 to n-1 and j from 0 to m-16Implement partial ordering for , , , ' and lexicographical ordering for 78,-./9:;012345<=>?@AB6CDE78,-./9:;012345<=>?@AB6CDE(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 FGHI FGHI555(c) Artem ChirkinBSD3chirkin@arch.ethz.chNone ,:<=ABDRTCompose a 2x2D matrixCompose a 3x3D matrixCompose a 4x4D matrix QQ (c) Artem ChirkinBSD3chirkin@arch.ethz.chNone !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQSTUVWnortvxz{qpsuwy|}~ZNMKJILnopqrstuvwxyz{}|~OPQ!"#$%&'()*+,-./012GH3456789 :;<=>?@ABCDEFJ!"#$%&'()*+,-./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 !"K+,-./LMNOPQ !"R+,-./STUVWX !"Y+,-./Z[\]^_ !"`+,-./abcdef !"g+,-./hijklm !"n+,-./opqrstuvwxyz{|}~ y !")+,-./ !"+,-./    (easytensor-0.3.0.0-8Aydy1NBfiFekwsfEm0iXNumeric.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 indexOffset#!.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)dimensions-0.3.0.0-4vIdDQdBUEG4R8Qyzv7TBmNumeric.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$fElementWiseIdxFloatArrayF fromListN$fIsListDataFrame$fDataFrameToListXNattxzxns$fDataFrameToListNattzns