h$eј       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                              ! ! ! ! ! ! ! !None   Safe-Inferred'( !"#$%&'()*+,-./01234 '()-*+!"#$%&,./13204" Safe-InferredJ None5lapack?This shape type wraps any other array shape type. However, its   instance just uses zero-based  1 indices. Thus it can turn any shape type into a  3 one. The main usage is to make an arbitrary shape 8.8lapackClass of shapes where indices still make sense if we permute elements. We use this for all matrix factorisations involving permutations or more generally orthogonal transformations, e.g. eigenvalue and singular value, LU and QR decompositions. E.g. say, we have a square matrix with dimension 'Shape.Enumeration Ordering'. Its vector of eigenvalues has the same dimension, but it does not make sense to access the eigenvalues with indices like   or  . Thus   is no instance of 8- (and you should not add an orphan instance).If you want to factor a matrix with a non-permutable shape, you should convert it temporarily to a permutable one, like   (i.e. #$) or 5.The 8 class has no method, so you could add any shape to it. However, you should use good taste when adding an instance. There is no strict criterion which shape type to add.We tried to use ShapeInt for eigenvalue vectors and  LiberalSquares as transformation matrices of eigenvalue decompositions. However, this way, the type checker cannot infer that the product of the factorisation is a strict square.We also tried to use %&' for eigenvalue vectors with according  LiberalSquares transformations. This has also the problem of inferring squares. Additionally, more such transformations lead to nested %& wrappers and for #$' even the first wrapper is unnecessary.5678985679'NoneG (Nonek ) Safe-Inferred *None '( J KL MNOP Q R S T U V WXYZ [ \ ]^_` +None '(2abedcfihg jklm nopsrqt u vw xyz{|}~             ,None!+  -None!q  .None# lapack0Make a temporary copy only for complex matrices. lapack=m and ldb>=m. lapack*Copy a m-by-n-matrix to ColumnMajor order. lapackUse the foldBalanced trick. lapackIf   would be based on a scalar loop we would not need to cut the vector into chunks. The invariance is: When calling productLoop n xPtr, starting from xPtr there is storage allocated for 2*n-1 elements.: /None$ 0None'($W  9 9 1None'(% None%Eabcdefghijklmnopqrstxyz{|}~~|}z{xyjopqrsnmlkfghitabcde2None >*lapack Admissible tag combinations are: meas vert horiz Shape Small Small - Square Size Small Small - LiberalSquare Size Big Small - Tall Size Small Big - Wide Size Big Big - General,We can enforce this set with the constraints 7(Extent.Measured meas vert, Extent.Measured meas horiz)4However, in some cases it leads to constraints like Measured meas Small or Measured meas Big*. The former one is morally equivalent to  Measure meas- and the latter one is morally equivalent to  meas ~ Size. However, in order to convince the compiler you would have to go through .In order to circumvent this trouble we use internal functions with weaker constraints: 4(Extent.Measure meas, Extent.C vert, Extent.C horiz)This is typesafe whenever the input is based on one of the five admissible extent types. We only need the strict constraints when constructing matrices of arbitrary extent type, i.e. this almost only concerns 3.   None'(2>+klapack is either  or . These are the &s that are preserved in matrix powers. Pun intended.None'(->-lapackFor singular valuesHowever, diagonal matrices produced by singular value decomposition may be non-square and Hermitian must be square.lapackFor Hermitian eigenvaluesuvwuvwNone/J"JKLMNOPQRSTUVWXYZ[\]^_`"OPSTMNQRUXYWZ[\JVL]^_K`4None/ None7vlapack constant () = singleton!However, singleton does not need   constraint.lapackPrecedence and associativity (right) of (List.++). This also matches  .lapack :dot x y = Matrix.toScalar (singleRow x <#> singleColumn y)lapack :dot x y = Matrix.toScalar (singleRow x <#> singleColumn y)lapack inner x y = dot (conjugate x) ylapackSum of the absolute values of real numbers or components of complex numbers. For real numbers it is equivalent to .lapack9Euclidean norm of a vector or Frobenius norm of a matrix.lapackComputes (almost) the infinity norm of the vector. For complex numbers every element is replaced by the sum of the absolute component values first.lapackReturns the index and value of the element with the maximal absolute value. Caution: It actually returns the value of the element, not its absolute value!lapackReturns the index and value of the element with the maximal absolute value. The function does not strictly compare the absolute value of a complex number but the sum of the absolute complex components. Caution: It actually returns the value of the element, not its absolute value!lapackFor restrictions see .lapackFor restrictions see .lapackFor restrictions see .lapackFor restrictions see .lapackIt should hold limits x = Array.limits x. The function is based on fast BLAS functions. It should be faster than  Array.minimum and  Array.maximum although it is certainly not as fast as possible. It is less precise if minimum and maximum differ considerably in magnitude and there are several minimum or maximum candidates of similar value. E.g. you cannot rely on the property that raise (- minimum x) x has only non-negative elements.lapack0\xs ys -> mulConj xs ys == mul (conjugate xs) ys  57766665None: lapack&Number of elements must be maintained. lapack&Number of elements must be maintained.lapackQC.forAll QC.arbitraryBoundedEnum $ \inv -> QC.forAll (QC.arbitrary >>= genPivots) $ \xs -> xs == Perm.toPivots inv (Perm.fromPivots inv xs)lapackQC.forAll genPerm2 $ \(p0,p1) -> determinant (multiply p0 p1) == determinant p0 <> determinant p1lapack #numberFromSign s == (-1)^fromEnum slapackQC.forAll genPerm2 $ \(p0,p1) -> transpose (multiply p0 p1) == multiply (transpose p1) (transpose p0)(        6None '(>;V  7None '(2>;%       8None'(<1 9None?I lapackMultiply two matrices with the same dimension constraints. E.g. you can multiply   and   matrices, or   and   matrices. It may seem to be overly strict in this respect, but that design supports type inference the best. You can lift the restrictions by generalizing operands with :;, #<, #= or #>. lapackMultiply two matrices with the same dimension constraints. E.g. you can multiply   and   matrices, or   and   matrices. It may seem to be overly strict in this respect, but that design supports type inference the best. You can lift the restrictions by generalizing operands with :;, #<, #= or #>.4  ?None? @None? ANone@V BNone@   7CNone'(Ab DNone'(A ENone'(A FNoneBGNoneBHNone'(2Clapack =let b = takeHalf a ==> isTriangular b && a == addTransposed b/INone'(CJNoneCKNone'(C LNone'(D8MNone'(D_NNone'(D ONoneDPNone'(DQNone'(ERNone'(E^SNoneENone '(2>Flapack is a synonym for  but lacks the admissibility check. You may thus fool the type tags. This applies to the other lift functions, too.lapackadaptOrder x y contains the data of y with the layout of x.76666 NoneHNone'(H}TNoneI`lapackWe do not support unit diagonal tag for trapezoids, because unit diagonal is not preserved by multiplication of trapezoids.NoneK'lapackThe number of rows must be maintained by the height mapping function.lapackThe number of columns must be maintained by the width mapping function.lapackconjugate transpose Problem: adjoint a <> a is always square, but how to convince the type checker to choose the Square type? Anser: Use (Hermitian.toSquare $ Hermitian.gramian a instead.  UNoneLlapackThe definiteness tags mean: neg == False: There is no x with x^T * A * x < 0. zero == False: There is no x with x^T * A * x = 0. pos == False: There is no x with x^T * A * x > 0. If a tag is True8 then this imposes no further restriction on the matrix.VNone'(M$9 WNone'(M]9 XNone'(M YNoneM NoneNlapack3The list represents ragged rows of a sparse matrix.lapack#For symmetric eigenvalue problems,  eigensystem and schur coincide.ZNone'(OlapackThe number of rows must be maintained by the height mapping function.lapackThe number of columns must be maintained by the width mapping function. [None '(>PlapackThe number of rows and columns must be maintained by the shape mapping function.lapackThe number of rows and columns must be maintained by the shape mapping function.None'(-TlapackadaptOrder x y contains the data of y with the layout of x.lapack (vr,d,vlAdj) = eigensystem aCounterintuitively, vr0 contains the right eigenvectors as columns and vlAdj contains the left conjugated eigenvectors as rows. The idea is to provide a decomposition of a. If a is diagonalizable, then vr and vlAdj3 are almost inverse to each other. More precisely,  vlAdj <> vr is a diagonal matrix, but not necessarily an identity matrix. This is because all eigenvectors are normalized such that \ is 1. With the following scaling, the decomposition becomes perfect: let scal = takeDiagonal $ vlAdj <> vr a == vr <> diagonal (Vector.divide d scal) <> vlAdjIf a, is non-diagonalizable then some columns of vr and corresponding rows of vlAdj4 are left zero and the above property does not hold.::22None'(X- lapackgramian A = A^T * Alapack-gramianTransposed A = A * A^T = gramian (A^T)lapack$congruenceDiagonal D A = A^T * D * Alapack.congruenceDiagonalTransposed A D = A * D * A^Tlapackcongruence B A = A^T * B * Alapack&congruenceTransposed B A = A * B * A^Tlapack(anticommutator A B = A^T * B + B^T * ANot exactly a matrix anticommutator, thus I like to call it Symmetric anticommutator.lapackanticommutatorTransposed A B = A * B^T + B * A^T = anticommutator (transpose A) (transpose B)lapackaddTransposed A = A^T + A((2None'(YWlapackThe number of rows and columns must be maintained by the shape mapping function.  ]None\lapack0It is an unchecked error if the shapes mismatch.lapackmultiplyStrictPart a b is almost ,multiply (clearDiagonal a) (clearDiagonal b), but it is more lazy since it does not access the elements that are multiplied with zero.lapackLazy implicit solverlapackParlett recursion for lifting a scalar function to an upper triangular matrix.;Given A and the diagonal of f(A) it solves A*f(A) = f(A)*A.Requires distinct values on the diagonal, where even almost close values can produce dramatic errors. But it admits for a nice lazy implicit implementation.^None\FNonecmlapackconjugate transposelapackcongruence B A = A^H * B * AThe meaning and order of matrix factors of these functions is consistent:_`ablapack#congruenceAdjoint A B = A * B * A^HlapackIf (q,r) = schur a, then a = q <> r <> adjoint q, where q is unitary (orthogonal) and r0 is a right-upper triangular matrix for complex a9 and a 1x1-or-2x2-block upper triangular matrix for real a. With takeDiagonal r you get all eigenvalues of a if a5 is complex and the real parts of the eigenvalues if a: is real. Complex conjugated eigenvalues of a real matrix a. are encoded as 2x2 blocks along the diagonal.The meaning and order of matrix factors of these functions is consistent: c cdefglapack (vr,d,vlAdj) = eigensystem aCounterintuitively, vr0 contains the right eigenvectors as columns and vlAdj contains the left conjugated eigenvectors as rows. The idea is to provide a decomposition of a. If a is diagonalizable, then vr and vlAdj3 are almost inverse to each other. More precisely,  vlAdj <> vr is a diagonal matrix, but not necessarily an identity matrix. This is because all eigenvectors are normalized to Euclidean norm 1. With the following scaling, the decomposition becomes perfect: let scal = takeDiagonal $ vlAdj <> vr a == vr #*\ Vector.divide d scal ##*# vlAdjIf a, is non-diagonalizable then some columns of vr and corresponding rows of vlAdj4 are left zero and the above property does not hold.The meaning and order of result matrices of these functions is consistent:chij%%3kNone'(d+None'(dlapack solve a b == solveDecomposed (decompose a) b solve (gramian u) b == solveDecomposed u blapackCholesky decomposition  None'(iB lapack toSquare (stack a b c) = toSquare a ||| b === adjoint b ||| toSquare c It holds order (stack a b c) = order b. The function is most efficient when the order of all blocks match.lapackSub-matrices maintain definiteness of the original matrix. Consider x^* A x > 0. Then y^* (take A) y = x^* A x where some components of x are zero.lapackgramian A = A^H * Alapack*gramianAdjoint A = A * A^H = gramian (A^H)lapack$congruenceDiagonal D A = A^H * D * Alapack+congruenceDiagonalAdjoint A D = A * D * A^Hlapackcongruence B A = A^H * B * Alapack#congruenceAdjoint B A = A * B * A^Hlapack(anticommutator A B = A^H * B + B^H * ANot exactly a matrix anticommutator, thus I like to call it Hermitian anticommutator.lapackanticommutatorAdjoint A B = A * B^H + B * A^H = anticommutator (adjoint A) (adjoint B)lapackaddAdjoint A = A^H + Alapack#For symmetric eigenvalue problems,  eigensystem and schur coincide.662lNonejDNonejlapack solve a b == solveDecomposed (decompose a) b solve (gramian u) b == solveDecomposed u blapackCholesky decomposition  mNonekCNone'(ks&&None'(l/  2nNone'(qlapackThis functions allows to multiply two matrices of arbitrary special features and returns the most special matrix type possible (almost). At the first glance, this is handy. At the second glance, this has some problems. First of all, we may refine the types in future and then multiplication may return a different, more special type than before. Second, if you write code with polymorphic matrix types, then % may leave you with constraints like $ExtentPriv.Multiply vert vert ~ vert. That constraint is always fulfilled but the compiler cannot infer that. Because of these problems you may instead consider using specialised op= functions from the various modules for production use. Btw. MultiplyVector and MultiplySquare are much less problematic, because the input and output are always dense vectors or dense matrices.We require e.g. both #Extent.Multiply vertA vertB ~ vertCand #Extent.Multiply vertB vertA ~ vertCThis makes the combination commutative. At first glance this looks counterintuitive, but this allows the type checker to infer that "shape A" times "square" is "shape A".)qNone '(>q77777rNone'(rlapackWe use the solvers for positive definite Hermitian matrices also for negative definite matrices. We even use them for semidefinite matrices, because semidefinite matrices with full rank are definite.sNone '(>?s7777tNone '(2>s~) NonetClapack HH.minimumNorm (HH.fromMatrix a) b == Ortho.minimumNorm (adjoint a) b uNonet None lapackIf x = leastSquares a b then x minimizes Vector.norm2 (multiply a x sub b).Precondition: a must have full rank and height a >= width a.lapack The vector x with x = minimumNorm a b is the vector with minimal Vector.norm2 x that satisfies multiply a x == b.Precondition: a must have full rank and height a <= width a.lapackIf 1(rank,x) = leastSquaresMinimumNormRCond rcond a b then x is the vector with minimum Vector.norm2 x that minimizes Vector.norm2 (a #*| x sub b).Matrix a can have any rank but you must specify the reciprocal condition of the rank-truncated matrix.lapack project b d x projects x on the plane described by B*x = d.b must have full rank.lapackleastSquaresConstraint a c b d computes x with minimal || c - A*x ||_2 and constraint B*x = d.b must be wide and a===b4 must be tall and both matrices must have full rank.lapackgaussMarkovLinearModel a b d computes (x,y) with minimal  || y ||_2 and constraint  d = A*x + B*y.a must be tall and a|||b4 must be wide and both matrices must have full rank.lapackGramian determinant - works also for non-square matrices, but is sensitive to transposition. determinantAbsolute a = sqrt (Herm.determinant (Herm.gramian a))lapackFor an m-by-n-matrix a7 with m>=n this function computes an m-by-(m-n)-matrix b such that Matrix.multiply (adjoint b) a is a zero matrix. The function does not try to compensate a rank deficiency of a . That is, a|||b has full rank if and only if a has full rank.0For full-rank matrices you might also call this kernel or  nullspace.lapack !affineFrameFromFiber a b == (c,d)Means: An affine subspace is given implicitly by {x : a#*|x == b}. Convert this into an explicit representation {c#*|y|+|d : y}. Matrix a must have full rank, otherwise the explicit representation will miss dimensions and we cannot easily determine the origin d as a minimum norm solution.The computation is like .c = complement $ adjoint a d = minimumNorm a bbut the QR decomposition of a is computed only once.lapack&This conversion is somehow inverse to . However, it is not precisely inverse in either direction. This is because both  and  accept non-orthogonal matrices but always return orthogonal ones.In affineFiberFromFrame c d , matrix c should have full rank, otherwise the implicit representation will miss dimensions.vNone '(-None_None4 lapack&Square matrices will be classified as .lapackTake a left-top aligned square or as much as possible of it. The advantange of this function is that it maintains the matrix size relation, e.g. Square remains Square, Tall remains Tall.lapackDrop the same number of top-most rows and left-most columns. The advantange of this function is that it maintains the matrix size relation, e.g. Square remains Square, Tall remains Tall.lapackThe function is optimized for blocks of consecutive rows. For scattered rows in column major order the function has quite ugly memory access patterns.lapack+Use the element order of the first operand.lapack,Use the element order of the second operand.lapackChoose element order such that, if possible, one part can be copied as one block. For  this means that RowMajor, is chosen whenever at least one operand is RowMajor and  ColumnMajor" is chosen when both operands are  ColumnMajor.lapack tensorProduct order x y = singleColumn order x #*# singleRow order ylapack lapack Caution: LU.determinant . LU.fromMatrix! will fail for singular matrices.NoneqlapackLowerUpper.fromMatrix a) computes the LU decomposition of matrix a with row pivotisation.You can reconstruct a from lu depending on whether a is tall or wide. LU.multiplyP NonInverted lu $ LU.extractL lu ##*# LU.tallExtractU lu LU.multiplyP NonInverted lu $ LU.wideExtractL lu #*## LU.extractU lulapackwideMultiplyL transposed lu a multiplies the square part of lu- containing the lower triangular matrix with a. wideMultiplyL NonTransposed lu a == wideExtractL lu #*## a wideMultiplyL Transposed lu a == Tri.transpose (wideExtractL lu) #*## alapacktallMultiplyU transposed lu a multiplies the square part of lu- containing the upper triangular matrix with a. tallMultiplyU NonTransposed lu a == tallExtractU lu #*## a tallMultiplyU Transposed lu a == Tri.transpose (tallExtractU lu) #*## a None  0 None lapacklet result = iterated expenses0 balances0 in approxVector result $ compensated expenses0 balances0 +++ Vector.zero (Array.shape $ Vector.takeRight result) !None lapackQC.forAll genDD $ \(xs, (ys0,ys1)) -> approxArray (dividedDifferencesMatrix xs (ys0|+|ys1)) (dividedDifferencesMatrix xs ys0 #+# dividedDifferencesMatrix xs ys1)QC.forAll genDD $ \(xs, (ys0,ys1)) -> approxArray (dividedDifferencesMatrix xs (Vector.mul ys0 ys1)) (dividedDifferencesMatrix xs ys0 <> dividedDifferencesMatrix xs ys1) lapackQC.forAll (QC.choose (0,10)) $ \n -> let sh = shapeInt n in QC.forAll (Util.genDistinct [-10..10] [-10..10] sh) $ \xs -> approxArray (DD.parameterDifferencesMatrix xs) (DD.upperFromPyramid sh (Vector.zero sh : DD.parameterDifferences xs))  xyzxy{x|}x|~x|x|x|x|x|&&********%***************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++:++++++++++++++++++++++++++++++,$,---------222                                                                             < ;                                                                      :3=>\555%5%5555555555555p66677777777777#779:  TpUUUUUUUUUUUUUWWXXXXXXXXYYYYYYYYYYYY:YYY              _    cZ;ZZZZ[[[[[[[[[[[[[pc_ba`;<pafch_dbgaf`echp;pqqqqqqqqqqqqqssssssssssssst:ttttttt             v<=>~hjiw:wwwwwww                 #          !!!!!!!!"""""""""xxx'''((((((()))***********************************************:******%*****:***************=*>******3***************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,:,,,,,,,,,<,=,>,,,,,--..........................................................//#/////////000000000000000000000000000000000000000000000000000000000000 0 0 0 0 0 0 0 0 0 0 1 1 1111 1 1 1 1 2 2 2 2 2 2 2 2 2222 2 4 4 44  x 5 55 5 555 5 555 5 5 5 555 5555 5 56 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 666 6 6 6 6 6 77 7 77 7 7 7 7 7 7777 7777 7 7 77 7788888 8 88 8 9p9 9 9 9 9 9 9 9999 99999999999999 99 9999~9 99999999 9 9 999 9 9999 ???h@@;@<@@@@@@@@@@@@@@ @@@@@@a@fAAAAAhAjAiAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCC3CCCCCC CDDDDDDDDDDDEEEEEEEEEEpEFFFFF:FFFFFFFF FFFFF F FFFFpFFFFF;FFG:GGG GGGGG G G G GGG;GGG GGG H H H H HHHHHH H HH H HH HHH H H H H H HH H H H H H H H H_HH H H H H HaHHHH HH IIIIbIJKKKKK KKKLLLMMhNNNNNNOPPhQ QQQ QQQQQQQQQQ_QQQR RSShT T TTTT T TTT TTTTTTpUU U U U U U U U U UUU VV V V V V X X Y Y YZZZZ ZZ [ ]p] ]] ]]] ] ] ]]]] ] ] ] ^^^kkkkhklllhlmm m mn n n n n n n n n n n n n n n n n n n n n nnnnn n n n n n n n n n n n n n n nq q q q qq q q q q q q q q rrrs ttt t t t ttttttt tt tt tt ttt tttt t ttttt uuuuuuuuu v v v vv       wwwwwwwwwwwwww !lapack-0.4-Fp0Th64O66ILCtSwahxjN9Numeric.LAPACK.VectorNumeric.LAPACK.OutputNumeric.LAPACK.ScalarNumeric.LAPACK.ShapeNumeric.LAPACK.Matrix.ExtentNumeric.LAPACK.Matrix.LayoutNumeric.LAPACK.Matrix.ShapeNumeric.LAPACK.MatrixNumeric.LAPACK.Permutation%Numeric.LAPACK.Orthogonal.Householder%Numeric.LAPACK.Matrix.BandedHermitian Numeric.LAPACK.Matrix.Shape.OmniNumeric.LAPACK.FormatNumeric.LAPACK.Matrix.ArrayNumeric.LAPACK.Matrix.Special!Numeric.LAPACK.Matrix.PermutationNumeric.LAPACK.Matrix.Full Numeric.LAPACK.Matrix.TriangularNumeric.LAPACK.Matrix.HermitianNumeric.LAPACK.Matrix.SymmetricNumeric.LAPACK.Matrix.BandedNumeric.LAPACK.Matrix.QuadraticNumeric.LAPACK.Matrix.Square/Numeric.LAPACK.Matrix.HermitianPositiveDefinite5Numeric.LAPACK.Matrix.BandedHermitianPositiveDefiniteNumeric.LAPACK.Matrix.DiagonalNumeric.LAPACK.OrthogonalNumeric.LAPACK.Singular!Numeric.LAPACK.Matrix.SuperscriptNumeric.LAPACK.Matrix.Function Numeric.LAPACK.Linear.LowerUpper)Numeric.LAPACK.Example.EconomicAllocation(Numeric.LAPACK.Example.DividedDifference'Numeric.LAPACK.Matrix.Hermitian.PrivateMatrixShapeIntShape IntIndexedNumeric.LAPACK.Shape.PrivateNumeric.LAPACK.Vector.PrivateNumeric.LAPACK.Wrapper$Numeric.LAPACK.Matrix.Extent.Private$Numeric.LAPACK.Matrix.Layout.PrivateNumeric.LAPACK.Matrix.PrivateNumeric.LAPACK.Matrix.ModifierNumeric.LAPACK.PrivateNumeric.LAPACK.Matrix.RowMajor$Numeric.LAPACK.Matrix.Mosaic.Private#Numeric.LAPACK.Matrix.ModifierTyped#Numeric.LAPACK.Matrix.Extent.Strict fromSquareNumeric.LAPACK.Linear.Private"Numeric.LAPACK.Permutation.Private"Numeric.LAPACK.Matrix.Plain.FormatNumeric.LAPACK.Matrix.Type$Numeric.LAPACK.Matrix.Mosaic.GenericNumeric.LAPACK.Matrix.BasicSquaretoFullfromFullgeneralizeTallgeneralizeWide"Numeric.LAPACK.Matrix.Square.Eigen"Numeric.LAPACK.Matrix.Square.BasicNumeric.LAPACK.Singular.PlainNumeric.LAPACK.Matrix.Plain%Numeric.LAPACK.Matrix.Mosaic.Unpacked#Numeric.LAPACK.Matrix.Mosaic.Packed&Numeric.LAPACK.Matrix.Triangular.Basic"Numeric.LAPACK.Matrix.Banded.BasicNumeric.LAPACK.Split'Numeric.LAPACK.Matrix.Symmetric.Unified%Numeric.LAPACK.Matrix.Symmetric.Basic&Numeric.LAPACK.Matrix.Symmetric.Linear"Numeric.LAPACK.Matrix.Mosaic.Basic'Numeric.LAPACK.Matrix.Triangular.Linear&Numeric.LAPACK.Matrix.Triangular.Eigen%Numeric.LAPACK.Matrix.Hermitian.Basic&Numeric.LAPACK.Matrix.Hermitian.Linear%Numeric.LAPACK.Matrix.Hermitian.Eigen+Numeric.LAPACK.Matrix.BandedHermitian.Basic!Numeric.LAPACK.Matrix.Plain.Class+Numeric.LAPACK.Matrix.BandedHermitian.Eigen$Numeric.LAPACK.Matrix.Array.Unpacked"Numeric.LAPACK.Matrix.Array.Mosaic#Numeric.LAPACK.Matrix.Array.IndexedNumeric.LAPACK.Matrix.Indexed%Numeric.LAPACK.Matrix.Array.Hermitian"Numeric.LAPACK.Matrix.Array.Banded!Numeric.LAPACK.Matrix.Array.BasicNumeric.LAPACK.Matrix.ClassnormInf1*Numeric.LAPACK.Matrix.Lazy.UpperTriangular#Numeric.LAPACK.Matrix.Square.Lineargramiananticommutator congruencecongruenceDiagonal eigensystemgramianAdjointanticommutatorAdjointcongruenceAdjointcongruenceDiagonalAdjoint decompose decomposeTall decomposeWide6Numeric.LAPACK.Matrix.HermitianPositiveDefinite.Linearhyper $fOutputHtml $fOutputBox $fEqSeparator$fOrdSeparator$fShowSeparatorPrecisionSingletonFloatDoubleComplexSingletonRealComplex ComplexOfRealOfcomplexSingletoncomplexSingletonOfcomplexSingletonOfFunctorprecisionSingleton precisionOfprecisionOfFunctorzerooneminusOne selectRealselectFloatingequalisZerofromReal toComplexrealPartabsolutenorm1absoluteSquared conjugatedeconsIntIndexed PermutableshapeInt$fPermutableTagged$fPermutableDeferred$fPermutableCyclic$fPermutableOneBased$fPermutableZeroBased$fPermutableShifted$fPermutableRange$fPermutable()$fPermutableZero$fPermutableIntIndexed$fInvIndexedIntIndexed$fIndexedIntIndexed $fCIntIndexed$fNFDataIntIndexed$fEqIntIndexed$fShowIntIndexedMultiplyMeasureAppend AppendModeMeasure switchMeasureC switchTagSizeSmallBigExtentsquare squareSizeheightwidth dimensions transposefuse appendSame appendLeft appendRight appendAnyBandedHermitianbandedHermitianOffDiagonalsbandedHermitianOrderbandedHermitianSize BandedIndex InsideBoxVertOutsideBoxHorizOutsideBoxDiagonalBandedUpperTriangularBandedLowerTriangular BandedSquare BandedGeneralBandedbandedOffDiagonals bandedOrder bandedExtent UnaryProxyFilledEmptyBands Hermitian HermitianP Symmetric SymmetricPUpperTriangularUpperTriangularPLowerTriangularLowerTriangularP TriangularMirror autoMirrorMirrorSingletonNoMirror SimpleMirrorConjugateMirrorPacking autoPackingPackingSingletonPackedUnpackedMosaic mosaicPack mosaicMirror mosaicUplo mosaicOrder mosaicSizeTriangle ReflectorSplitWideTallGeneralFull fullOrder fullExtentOrderRowMajor ColumnMajor flipOrder fullHeight fullWidthgeneraltallwide liberalSquareupperTriangularlowerTriangularupperTriangularPlowerTriangularP symmetric symmetricP hermitian hermitianPautoUploaddOffDiagonals bandedGeneral bandedSquare Inversion NonInvertedInverted Conjugation NonConjugated Conjugated Transposition NonTransposed Transposed SplitGeneral splitGeneral splitFromFulldiagonalbandedFromFullbandedHermitianMeasuredswitchMeasuredMap MergeUnitUnitIfTriangularMultipliedPropertyMultipliedStripMultipliedBandsToPlaintoPlain FromPlainPlain fromPlain Quadratic quadraticOmniUnitBandedTriangularBandedTriangularSingletonBandedDiagonal BandedUpper BandedLowerBandedTriangularPower PowerIdentity PowerDiagonalPowerUpperTriangularPowerLowerTriangularPowerSymmetricPowerHermitian PowerFullPowerStripSingleton PowerStripswitchPowerStripStripSingleton StripBands StripFilledStrip switchStripPropertySingleton PropArbitraryPropUnit PropSymmetric PropHermitianPropertyHermitianNegativeSemidefiniteHermitianNegativeDefiniteHermitianPositiveSemidefiniteHermitianPositiveDefiniteHermitianUnknownDefiniteness DiagSingletonUnit ArbitraryTriDiag switchTriDiagautoDiagcharFromTriDiag hermitianSetpropertySingletonpropertystripSingletonstripspowerStripSingleton powerStripspackTagpowerSingletonbandedTriangularSingletonuncheckedDiagonaltoBandedtoBandedHermitianextent mapHeightmapWidth mapSquareSizeorder$fNFDataDiagSingleton$fShowDiagSingleton$fEqDiagSingleton$fDefinitenessFalseFalseTrue$fDefinitenessFalseTrueFalse$fDefinitenessTrueFalseFalse$fDefinitenessFalseTrueTrue$fDefinitenessTrueTrueFalse$fDefinitenessTrueTrueTrue$fPropertyHermitian$fPropertySymmetric$fPropertyUnit$fPropertyArbitrary$fTriDiagArbitrary $fTriDiagUnit$fBandedTriangularSuccZero$fBandedTriangularZeroSucc$fBandedTriangularZeroZero $fStripFilled $fStripBands$fCOmni $fNFDataOmni>$fFromPlainPackedHermitianBandsBandsShapeSmallSmallheightwidth9$fFromPlainPackedUnitBandsBandsShapeSmallSmallheightwidth<$fFromPlainPackedArbitraryBandsBandsmeasverthorizheightwidth>$fFromPlainpackHermitianFilledFilledShapeSmallSmallheightwidth>$fFromPlainpackSymmetricFilledFilledShapeSmallSmallheightwidth8$fFromPlainpackdiagFilledBandsShapeSmallSmallheightwidth8$fFromPlainpackdiagBandsFilledShapeSmallSmallheightwidth$fFromPlainUnpackedArbitraryFilledFilledmeasverthorizheightwidth<$fToPlainPackedHermitianBandsBandsShapeSmallSmallheightwidth7$fToPlainPackedUnitBandsBandsShapeSmallSmallheightwidth:$fToPlainPackedArbitraryBandsBandsmeasverthorizheightwidth<$fToPlainpackHermitianFilledFilledShapeSmallSmallheightwidth<$fToPlainpackSymmetricFilledFilledShapeSmallSmallheightwidth6$fToPlainpackdiagFilledBandsShapeSmallSmallheightwidth6$fToPlainpackdiagBandsFilledShapeSmallSmallheightwidth>$fToPlainUnpackedArbitraryFilledFilledmeasverthorizheightwidth$$fQuadraticPackedHermitianBandsBands$fQuadraticPackedUnitBandsBands$$fQuadraticPackedArbitraryBandsBands&$fQuadraticPackedHermitianFilledFilled&$fQuadraticPackedSymmetricFilledFilled $fQuadraticPackeddiagFilledBands $fQuadraticPackeddiagBandsFilled&$fQuadraticUnpackedArbitrarylowerupper,$fConsPackedHermitianBandsBandsmeasverthoriz'$fConsPackedUnitBandsBandsmeasverthoriz,$fConsPackedArbitraryBandsBandsmeasverthoriz.$fConsPackedHermitianFilledFilledmeasverthoriz.$fConsPackedSymmetricFilledFilledmeasverthoriz($fConsPackeddiagFilledBandsmeasverthoriz($fConsPackeddiagBandsFilledmeasverthoriz.$fConsUnpackedArbitraryloweruppermeasverthoriz$fPowerStripFilled$fPowerStripBands $fShowOmni$fEqOmniUpperQuasitriangularPositiveDiagonal RealDiagonalBandedUnitUpperBandedUnitLowerBandedUnitTriangularGenTriangularLoUprunGenTriangularLoUpGenTriangularDiagrunGenTriangularDiag UpLoSingletonLowerUpper DiagUpLoCswitchDiagUpLoDiagUpLoUpLoC switchUpLoUpLoIdentity QuadraticMeas LiberalSquareidentity triangularunitTriangulararbitraryTriangular$fDiagUpLoCFilledBands$fDiagUpLoCBandsFilled$fDiagUpLoCBandsBands$fUpLoCFilledBands$fUpLoCBandsFilled toGeneralfromSquareLiberalfromLiberalSquare weakenTall weakenWideRandomDistribution UniformBox01 UniformBoxPM1Normal UniformDisc UniformCircleVectortoListfromList autoFromListconstantunit+++swap-*|dotinnersumabsSumnorm2 norm2SquarednormInf argAbsMaximumargAbs1Maximumproductminimummaximum argMinimum argMaximumlimits argLimits.*|scale scaleRealaddsub|+||-|macnegateraisemulmulConjdividerecip imaginaryPart zipComplex unzipComplexrandom$fEqRandomDistribution$fOrdRandomDistribution$fShowRandomDistribution$fEnumRandomDistributionElementSignPositiveNegative Permutationsize fromPivotstoPivots determinantnumberFromSigninversionFromTransposition FormatArray formatArraydeflt Transpose mapExtent ToQuadraticBox FormatMatrix formatMatrixScaleindices OrderBias MapExtent SubtractiveAdditive Homogeneous PlainArray FullQuadratic SquareMeas ArrayMatrixArray OmniArrayasPacked asUnpackedrequirePacking plainShapeshapesubBandsSingletonsuperBandsSingletonreshapemapShapetoVectorunwrap fromVectorlift0lift1lift2lift3lift4unlift1unlift2unpackedToVector liftUnpacked0 liftUnpacked1 liftUnpacked2 liftUnpacked3 unliftRow unliftColumndiagTag scaleRealReal.*# forceOrder adaptOrder#+##-# liftOmni1 liftOmni2$fToQuadraticArray$fMultiplySameArrayxlxu$fFormatMatrixArray$fTransposeArray $fBoxArray $fNFDataArray$fHomogeneousHermitian$fHomogeneousSymmetric$fHomogeneousArbitrary$fScaleSymmetric$fScaleArbitrary$fAdditiveHermitian$fAdditiveSymmetric$fAdditiveArbitrary$fSubtractiveHermitian$fSubtractiveSymmetric$fSubtractiveArbitrary$$fMapExtentPackedArbitraryBandsBands($fMapExtentUnpackedArbitraryFilledFilled$fMapExtentArrayxlxulowerupper $fShowMatrixtoMatrixapplyfromPermutation toPermutationtoSquaremultiplyVector multiplyFulladjoint QuasiUpper FlexUpper FlexLower UnitUpper UnitLower FlexHermitianHermitianPosSemidefHermitianPosDefIndexed#! SemidefiniteassureFullRank assureAnyRankrelaxSemidefiniterelaxIndefiniteassurePositiveDefinitenessrelaxDefinitenessasUnknownDefinitenessRectangularDiagonal FlexDiagonal FlexBanded takeDiagonal toHermitian takeTopLefttakeBottomRightsumRank1 eigenvaluesunpackidentityFromShape identityOrder SquareShape identityFromtrace lowerFromList upperFromListautoLowerFromListautoUpperFromListasLowerasUpperrequireUnitDiagonalrequireArbitraryDiagonalpack takeLower takeUpperfromLowerRowMajorfromUpperRowMajortoLowerRowMajortoUpperRowMajorrelaxUnitDiagonalstrictArbitraryDiagonal stackLower#%%% stackUpper%%%# splitLower splitUppertakeBottomLeft takeTopRightsolveinverse fromHermitian fromUpperassureSymmetrystack#%%%#split tensorProductsumRank1NonEmptygramianTransposedcongruenceDiagonalTransposedcongruenceTransposedanticommutatorTransposed addTransposed asDiagonal asSymmetricmapSize$fDiagonalSymmetric$fDiagonalArbitraryliberalFromFull fromScalartoScalaridentityFromWidthidentityFromHeight|=|powerschur schurComplexsolveDecomposed*%%%#outersumRank2sumRank2NonEmpty fromSymmetric addAdjointsquareFromListtoLowerTriangulartoUpperTriangulartakeTopLeftSquaretakeBottomRightSquarenoUnitlift%%%Multiplypowers1MultiplySquareMultiplyVector#*|-*##*####*#powers#*#InverseSolve solveRight solveLeft Determinant#\####/# solveVector#\|-/# HouseholderdeterminantAbsolute fromMatrix leastSquares minimumNormextractQ tallExtractQ tallMultiplyQtallMultiplyQAdjoint multiplyQextractR tallExtractR tallMultiplyR tallSolveRleastSquaresMinimumNormRCondpseudoInverseRCondprojectleastSquaresConstraintgaussMarkovLinearModel householderhouseholderTall complementaffineFrameFromFiberaffineFiberFromFrametallFromGeneralwideFromGeneral asGeneralasTallasWide caseTallWide singleRow singleColumn flattenRow flattenColumnliftRow liftColumnfromRowsNonEmpty fromRowArrayfromRowsNonEmptyContainerfromRowContainerfromRowsfromColumnsNonEmptyfromColumnArrayfromColumnsNonEmptyContainerfromColumnContainer fromColumnstoRows toColumns toRowArray toColumnArraytoRowContainertoColumnContainertakeRow takeColumntakeTop takeBottomtakeRowsdropRows takeColumns dropColumns takeEqually dropEquallyswapRows swapColumns reverseRowsreverseColumns takeRowArraytakeColumnArray fromRowMajor toRowMajor|||===leftBias rightBiascontiguousBiasrowSums columnSumsrowArgAbsMaximumscolumnArgAbsMaximumsmap|*- kronecker scaleRows\*# scaleColumns#*\ scaleRowsRealscaleColumnsReal\\##/\multiplySquarevalues valuesTall valuesWidedecomposePolar PseudoInverse ConjugateAdjointNone SuperscriptExponent#^$fSuperscriptNone$fSuperscriptTranspose$fSuperscriptAdjoint$fSuperscriptConjugate$fSuperscriptInverse$fSuperscriptPseudoInverse$fSuperscriptPowerLiftRealliftRealLoglogExpexpSqRtsqrt sqrtSchursqrtDenmanBeaversexpRealHermitianlogUnipotentUpper$fSqRtHermitian$fSqRtSymmetric$fSqRtArbitrary $fSqRtUnit$fExpSymmetric$fExpHermitian$fExpArbitrary$fLiftRealSymmetric$fLiftRealHermitian$fLiftRealArbitrary$fLogSymmetric$fLogHermitian$fLogArbitrary LowerUpperextractP multiplyPextractL wideExtractL wideMultiplyL wideSolveLextractU tallExtractU tallMultiplyU tallSolveUFormatformatprint##$fFormatMatrix $fFormatArray$fFormatPermutation $fFormat(,,) $fFormat(,) $fFormat[]$fFormatComplex$fFormatDouble $fFormatFloat $fFormatInt SquareMatrixZeroInt2 balances0 expenses0 normalizenormalizeSplitcompleteIdSquareiterated compensatedmain subSlicesparameterDifferencesdividedDifferencesupperFromPyramiddividedDifferencesMatrixparameterDifferencesMatrixgetDeterminant TakeDiagonalrunTakeDiagonal runDiagonalData.Array.Comfort.Shapeghc-prim GHC.TypesIntLTEQ Enumeration ZeroBased UncheckeddeconsUnchecked ArgMaximum runArgMaximumabsMaxuncheckrecheckFlipgetFlipUnifygetUnifyMultiplyMeasureLawgetMultiplyMeasureLaw MeasureFactMultiplyTagLawgetMultiplyTagLawTagFact AppendAny getAppendAnyAccessor getAccessor GenToWide getGenToWide GenToTall getGenToTall WeakenWide getWeakenWide WeakenTall getWeakenTallGenWide getGenWideGenTall getGenTall GenSquare getGenSquareRotLeft3 getRotLeft3Separate switchTagPairswitchMeasureExtenterrorTagTripleAux showConsterrorTagTripleswitchTagTriple genSquaregenLiberalSquare relaxMeasure genToTall genToWidesquareFromFullliberalSquareFromFullshowsPrecSquare showsPrecAnywidenreduceWideHeightreduceConsistentmapWrap recheckAppendrelaxMeasureWith appendLeftAuxstackGenmultiplyTagLaw heightFact widthFactmultiplyMeasureLaw measureFact unifyLeft unifyRightBandedSquareMeas TriTransposed TriangularP splitExtent splitOrdertransposeFromOrderswapOnRowMajorsideSwapFromOrder mapChecked fullIndicesfullIndexFromOffset fullMapExtent splitHeight splitWidthsplitMapExtentcaseTallWideSplit splitPartsquareFromMosaicmosaicFromSquare triangularPsymmetricFromHermitianhermitianFromSymmetric uploFromOrderu0emptytriangularTranspose uploOrderuploCharsquareRootDouble squareExtenttriangleRootDoubletriangleExtenttriangleIndicestriangleOffsettriangleSizeOffsettriangleIndexFromOffset bandedHeight bandedWidthbandedMapExtent bandedBreadthnumOffDiagonals natFromProxybandedTransposediagonalInverserectangularDiagonal outsideOffset bandedOffsetbandedIndicesRowMajorbandedIndexFromOffsetbandedHermitianIndexFromOffset argGeneral argSquare revealOrdertransposeOrderconjugatedOnRowMajorconjugateToTemp copySubMatrixcopyToColumnMajor productLoop ComplexPart ImaginaryPartRealPartLACGVgetLACGVSumrunSum CopyToTemp runCopyToTemprealPtrfill copyBlock copyToTempcomplexConjugateToTemp condConjugate copyConjugatecopyCondConjugatecondConjugateToTempcopyCondConjugateToTempcopySubTrapezoidcopyTransposedcopyToSubColumnMajorcopyToColumnMajorTemp pointerSeqcreateHigherArraysumReal sumComplex sumComplexAltmulRealmulPairslacgvgemvgbmv initializeMVmultiplyMatrixwithAutoWorkspaceInfowithAutoWorkspacewithInfoargMsg errorCodeMsgrankMsg definiteMsgeigenMsgpokeCIntpeekCInt ceilingSizecaseRealComplexFunc getConstFunc decomplex recomplex FunctionArgapplyArgFuncArgUnpacked FuncArgPacked LabelResult FunctionPair FuncUnpacked FuncPackedFuncCont FuncLabelTriArg Labelled2LabelledgetMap MultiplyRightgetMultiplyRight MosaicUpper MosaicLowerMosaicUnpacked MosaicPackeddiagonalPointersdiagonalPointerPairscolumnMajorPointersrowMajorPointers forPointerscopyTriangleToTemp unpackToTemppackRect _unpackZero unpackZero fillTriangle copyTriangleA copyTriangleC copyRectangle fromBanded fromLowerPart leaveDiagonallabelnoLabel runUnlabelledrunLabelledLinearrunLabelledWorkspace$*$** runPacking withPackingwithPackingLineartriArg applyFuncPairSquareTranspositiontransposeTranspositiontransposeSquareExtenttranspositionToUntypedfromSquareTranspositionsquareFromTranspositionCons_ConsgetCons Dimension MeasureTarget RotRight3 getRotRight3 consCheckedunifierssolverwithDeterminantInfo diagonalMsg'netlib-ffi-0.1.1-AMUxC8Tg9qTDOwqEtc3lnTNumeric.Netlib.ClassFloating::+mapSizeUnchecked deconsElement deconsShapefromTruncatedPivots fromPivotsGen condNegateodddropEventransposeToMutablemultiplyUnchecked initMutabledeconsElementPtrToTuple getToTupleTuple TupleShape formatVector formatFullformatHouseholderformatMirroredcomplementTriangleformatDiagonalformatTriangular padTrianglepadUpperTrianglepadLowerTriangleslice padBandedpadBandedHermitianshiftRow splitRows fillTupleprintfFloatingprintfFloatingMaybe printfComplexprintfComplexAux complexTuplewidthToQuadraticheightToQuadraticStaticIdentitystaticIdentity MultiplySame multiplySameNFDatarnfProduct asQuadraticscaleWithCheck swapMultiply unpackDirtyunpackDirtyAuxwithPackrepackmultiplyColumnMajor ScaleRowsRealgetScaleRowsRealContiguousBias RightBiasLeftBias forceRowMajortakeSub stackMosaic stackBiased liftRowMajorscaleRowsComplexscaleColumnsComplexmultiplyVectorUnchecked diagonalOrdermultiplyCompatiblemapExtentSizesidentityFatOrder diagonalFat determinantRextractTrianglemultiplyTriangularsolveTriangulartakeHalfSYRSYMVSPMV narrowMirrorconjugationFromMirror addMirroredcomplementUnpackedmultiplyVectorCont forceUpperupperFromLowerwithSyrSingletonsprsyr outerCont outerUpper upperShape unpackedShapeskipCheckCongruencepostHooktemporaryUnpackedgramianParameters gramianIOscaledAnticommutatorIOscaledAnticommutatorscaledAnticommutatorTransposedcongruenceRealDiagonal congruenceRealDiagonalTransposedblockDiagonalPointers autoWorkspacereunpack StaticVectorcheckLowerTrapezoidUpperTrapezoid fillLower fillUpper FlexUpperP FlexLowerP UnitUpperP UnitLowerPUpperPLowerPFlexHermitianPHermitianPosSemidefPHermitianPosDefPassureMirrored accessBandedboxIx accessAlt accessMaybe checkedZero AnyHermitianP AnyHermitian SymmQuadraticUnitTriangular identityOmnisignNegativeDeterminantMapSizemultiplyStrictPartparlettsample fromStorable toStorablereplaceDiagonal rank2Part rank2DiffPartapplyUncheckedsolveColumnMajor matrixMatrixPackingByStripMultipliedPackingFactor FactorFullFactorUnitBandedTriangularFactorBandedHermitian FactorBandedFactorHermitianFactorSymmetricFactorLowerTriangularFactorUpperTriangularFactorQuadraticfactorSingleton matrixVector vectorMatrixtransposableSquareextentFromSquare fullSquare squareFull vectorSquarepowers1Diagonal powers1Gen asArbitraryunpackedSquaresquareUnpackedunpackedUnpackedunpackedBandedbandedUnpacked bandedBanded bandedUpper bandedLowerprev unifyFactorsunflexflexMultipliedExtra Multiplied IdentityMaesfactorIdentityLeftfactorIdentityRight reshapeHeight reshapeWidth reshapeVectorHouseholderFlex SplitArrayHhsplit_leastSquaresAuxminimumNormAuxaddRows extractQAuxadjointFromTransposeinvCharlayoutTauSquareextractComplementPowerStripFactFillfilledPowerStripFactPseudoInvNTAsqrt2