h$ ml      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                           None  None.  NonelapackUses the indices of the second shape, but the list of indices is restricted by the size of the first shape. "! "!None None/ Safe-Inferredd Safe-Inferred()*+,-./01234567)(*+,0-./1246537  Safe-Inferred !None '(!89:;<=>?@ABCDEFGHIJK"None-ulapackStore the upper triangular half of a real symmetric or complex Hermitian matrix.LMPONQTSRUVWXYZ[^]\_`abcdefghijklmnopsrqtuvxwyz{|}~ Nonelapack; denotes a range starting at zero and has a certain length.#None $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 LMNOPQRSTUVWXYZ[\]^_`acdefghijklmnoptqrsuvwxyz{|}~~}yz{|uvwxoptqrshgfeda`ijmnklZ[\]^YXWVUQRST_cLMNOP None89:;<=>?@ABCDEFGHIJK;<@=>?CDAEFGB:9HIJ8K%None(&None-o''None (None9 )NoneFNone lapack 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.())(5776666*None$lapackQC.forAll QC.arbitraryBoundedEnum $ \inv -> QC.forAll (QC.arbitrary >>= genPivots) $ \xs -> Array.toList xs == Array.toList (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) -> equating (Array.toList . Perm.toPivots NonInverted) (transpose $ multiply p0 p1) (multiply (transpose p1) (transpose p0))%+None-$y# ,None$   None-%0  0-None(t lapackMultiply two matrices with the same dimension constraints. E.g. you can multiply  and  matrices, or Square and Square 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 ./, 01, 02 or 03. lapackMultiply two matrices with the same dimension constraints. E.g. you can multiply  and  matrices, or Square and Square 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 ./, 01, 02 or 03.1  4None(( 5None)# 6None)u ) 7None)  78None*~ 9None-*.b :None+{ lapack =let b = takeHalf a ==> isTriangular b && a == addTransposed b ;None+ <None-+ =None," >None,z! ?None, @None-  ANone'(-6 BNone- lapackadaptOrder x y contains the data of y with the layout of x.     CNone -1tlapackThis class allows to Basic.multiply two matrices of arbitrary special features and returns the most special matrix type possible. 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  = functions from the various modules for production use. Btw.  and  are much less problematic, because the input and output are always dense vectors or dense matrices.     DNone1 ENone2 FNone2* GNone2X HNone2 INone-2 JNone-3 lapackThere is no solver for general banded Hermitian matrices. Thus the instance will fail for an indefinite matrix. lapackThere is no solver for indefinite matrices. Thus the instance will fail for indefinite but solvable systems.    None5 lapack 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.0076666 None6 None6KNone69 LNone7 None-;=lapackadaptOrder x y contains the data of y with the layout of x.lapackInclude symmetric matrices. However, symmetric matrices do not preserve unit diagonals.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 M 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.bb2222NoneClapackconjugate transposelapackcongruence B A = A^H * B * AThe meaning and order of matrix factors of these functions is consistent: N O P Qlapack#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:  RR S T U Vlapack (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:RWXY"("(3ZNoneDQ  NoneFlapackgramian 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)2NoneGlapack solve a b == solveDecomposed (decompose a) b solve (gramian u) b == solveDecomposed u blapackCholesky decomposition NoneK] 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.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.))2[NoneL% \NoneLQ   77777]NoneL 7777^NoneM!    _NoneM~  NoneNlapack HH.minimumNorm (HH.fromMatrix a) b == Ortho.minimumNorm (adjoint a) b NoneX 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 !affineSpanFromKernel 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.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 affineKernelFromSpan c d , matrix c should have full rank, otherwise the implicit representation will miss dimensions.`NoneY  NoneYJaNoneY{NoneZ1lapack solve a b == solveDecomposed (decompose a) b solve (gramian u) b == solveDecomposed u blapackCholesky decompositionNone[lapack3The list represents ragged rows of a sparse matrix.lapack#For symmetric eigenvalue problems,  eigensystem and schur coincide. Nonea lapack&Square matrices will be classified as .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.lapackThe number of rows must be maintained by the height mapping function.lapackThe number of columns must be maintained by the width mapping function.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  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)Noneglapacklet result = iterated expenses0 balances0 in approxVector result $ compensated expenses0 balances0 +++ Vector.zero (Array.shape $ Vector.takeRight result)  Noneh!bNonei lapack Caution: LU.determinant . LU.fromMatrix! will fail for singular matrices.  NonellapackLowerUpper.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 cdecdfcghcgicgjcgkcglcgmcgnopqrstuvwxyz{|}~!!!!!!!!!!!!r!s!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""."""""""""""""""""""""""          #########23%%&&M*****************+++,o,p,q,r,s,,,0,,t-BBBBBBCCCCJJJ.  KKLLLLLLLLLLLLR/PURZZZZZZZZZZZNQPOW                        N S Q V P U O T      R\\\\\\\\\\\]]]]]]]]]]]]]^.^^^^^^^            `aaaaa.aaWNR   1   2 3                                          j i                 x w                         WYX0rs/bbb.bbbb         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!.!!!!!!.!!!!!!!!!!!!!!!!2!3!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""##$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%.%%%%%%%%1%2%3%r%s%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''0'''''''''((())))c********t************+++++++++++++++++++++++++{+|++++++,,,,,,,,,------------------------------j-i------x-w----------444W55/5555555555555555555P5U66666W6Y6X6677777777777777777777777777777777777777777777777888888999999999999999999999999999999999999999999::::.::::::/::::::;;N;;Q;;P;;;<<W====.=====================/>>>>>>>>>>>>>>>>>>>>>>N>S>Q>V>P>U>>>???@@WAAAAAAAAAAANAAABBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDWEEEFFFFWFGGGWGHHHIIIJJJJJJJJZ[[\\\\\\\^^^^^^^^^^^^^^^^^^^^^^^^_________`bbbbbbbbbbbbbb#lapack-0.3.2-DNV5aJVDEIH4HysywHDtQMNumeric.LAPACK.VectorNumeric.LAPACK.Matrix.Shape.BoxNumeric.LAPACK.OutputNumeric.LAPACK.ShapeNumeric.LAPACK.ScalarNumeric.LAPACK.Matrix.ExtentNumeric.LAPACK.Matrix.Shape Numeric.LAPACK.Matrix.TriangularNumeric.LAPACK.ShapeStaticNumeric.LAPACK.Permutation%Numeric.LAPACK.Orthogonal.HouseholderNumeric.LAPACK.Matrix.HermitianNumeric.LAPACK.MatrixNumeric.LAPACK.FormatNumeric.LAPACK.Matrix.ArrayNumeric.LAPACK.Matrix.Special!Numeric.LAPACK.Matrix.PermutationNumeric.LAPACK.Matrix.SquareNumeric.LAPACK.Matrix.Symmetric/Numeric.LAPACK.Matrix.HermitianPositiveDefiniteNumeric.LAPACK.OrthogonalNumeric.LAPACK.Matrix.Banded5Numeric.LAPACK.Matrix.BandedHermitianPositiveDefinite%Numeric.LAPACK.Matrix.BandedHermitianNumeric.LAPACK.Singular(Numeric.LAPACK.Example.DividedDifference)Numeric.LAPACK.Example.EconomicAllocation Numeric.LAPACK.Linear.LowerUpperNumeric.LAPACK.Shape.PrivateNumeric.LAPACK.Vector.PrivateNumeric.LAPACK.Wrapper'Numeric.LAPACK.Matrix.Hermitian.Private$Numeric.LAPACK.Matrix.Extent.Private#Numeric.LAPACK.Matrix.Shape.PrivateNumeric.LAPACK.Matrix.ModifierNumeric.LAPACK.PrivateNumeric.LAPACK.Matrix.Private(Numeric.LAPACK.Matrix.Triangular.PrivateNumeric.LAPACK.Matrix.RowMajor#Numeric.LAPACK.Matrix.Plain.IndexedNumeric.LAPACK.Linear.Private"Numeric.LAPACK.Permutation.Private"Numeric.LAPACK.Matrix.Plain.FormatNumeric.LAPACK.Matrix.TypeNumeric.LAPACK.Matrix.BasicSquaretoFullMatrixfromFullgeneralizeTallgeneralizeWide"Numeric.LAPACK.Matrix.Square.Eigen"Numeric.LAPACK.Matrix.Square.BasicNumeric.LAPACK.Singular.PlainNumeric.LAPACK.Matrix.Plain'Numeric.LAPACK.Matrix.Symmetric.Private&Numeric.LAPACK.Matrix.Triangular.BasicNumeric.LAPACK.Split%Numeric.LAPACK.Matrix.Symmetric.Basic&Numeric.LAPACK.Matrix.Triangular.Eigen"Numeric.LAPACK.Matrix.Banded.Basic%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.Plain.Multiply+Numeric.LAPACK.Matrix.BandedHermitian.Eigen#Numeric.LAPACK.Matrix.Square.Linear6Numeric.LAPACK.Matrix.HermitianPositiveDefinite.Linearhyper $fOutputHtml $fOutputBox $fEqSeparator$fOrdSeparator$fShowSeparatorMin minShape0 minShape1$fInvIndexedMin $fIndexedMin$fCMin$fEqMin $fShowMin ComplexOfRealOfzerooneminusOne selectRealselectFloatingequalisZerofromReal toComplexrealPartabsolutenorm1absoluteSquared conjugateAppend AppendModeGeneralTallWideC switchTagMapSmallBigExtent squareSizesquare dimensions transposefuse appendSame appendLeft appendRight appendAnyBandedHermitianbandedHermitianOffDiagonalsbandedHermitianOrderbandedHermitianSize BandedIndex InsideBoxVertOutsideBoxHorizOutsideBoxBandedDiagonalBandedUpperTriangularBandedLowerTriangular BandedSquare BandedGeneralBandedbandedOffDiagonals bandedOrder bandedExtent UnaryProxyswitchDiagUpLoDiagUpLoUpLoContent SymmetricUpperTriangularLowerTriangularDiagonalIdentityTriDiag switchTriDiagNonUnitUnit TriangulartriangularDiagtriangularUplotriangularOrdertriangularSize HermitianhermitianOrder hermitianSizeTriangle ReflectorSplitWideTallGeneralFull fullOrder fullExtentOrderRowMajor ColumnMajor flipOrder fullHeight fullWidthgeneraltallwideautoDiagswitchDiagUpLoSymautoUploaddOffDiagonals bandedGeneral bandedSquare ZeroBased zeroBasedSizevector$fStaticZeroBased$fInvIndexedZeroBased$fIndexedZeroBased $fCZeroBased $fEqZeroBased$fShowZeroBased Inversion NonInvertedInverted Conjugation NonConjugated Conjugated Transposition NonTransposed Transposed SplitGeneral splitGeneral splitFromFulldiagonallowerTriangularupperTriangular symmetric hermitianbandedFromFullbandedHermitian toGeneral fromSquarefromSquareLiberalShapeIntshapeIntPowerContentDiag PowerDiagRandomDistribution UniformBox01 UniformBoxPM1Normal UniformDisc UniformCircleVectortoListfromList autoFromListconstantunit+++swap-*|dotinnersumabsSumnorm2 norm2SquarednormInf argAbsMaximumargAbs1Maximumproductminimummaximum argMinimum argMaximumlimits argLimits.*|scale scaleRealaddsub|+||-|macnegateraisemuldividerecip imaginaryPart zipComplex unzipComplexrandom$fEqRandomDistribution$fOrdRandomDistribution$fShowRandomDistribution$fEnumRandomDistributionElementShapeSignPositiveNegative Permutationsizeidentity fromPivotstoPivots determinantnumberFromSigninversionFromTranspositionmultiply FormatArray formatArraydeflt FormatMatrix formatMatrixScaleFormatformat##$fFormatMatrix $fFormatArray$fFormatPermutation $fFormat(,,) $fFormat(,) $fFormat[]$fFormatComplex$fFormatDouble $fFormatFloat $fFormatInt OrderBias SquareShapeAdditive ShapeOrder shapeOrder HomogeneousComplexMultiplyPowerMultiplySquareMultiplyVectorInverseSolve Determinant ArrayMatrixArrayshapereshapemapShapetoVector fromVectorlift0lift1lift2lift3lift4unlift1unlift2 unliftRow unliftColumn scaleRealReal.*# forceOrder adaptOrder#+##-#$fStaticIdentityArray$fMultiplySameArray$fFormatMatrixArray $fBoxArray $fNFDataArray $fShowMatrixtoMatrixapplyfromPermutation toPermutationmultiplyVector multiplyFullIndexed#! FlexSymmetric FlexUpper FlexLower FlexDiagonal UnitUpper UnitLowerUpperLoweradjoint lowerFromList upperFromListsymmetricFromListdiagonalFromListautoLowerFromListautoUpperFromListautoSymmetricFromListautoDiagonalFromList asDiagonalasLowerasUpper asSymmetricrequireUnitDiagonalrequireNonUnitDiagonaltoSquare takeLower takeUpperfromLowerRowMajorfromUpperRowMajortoLowerRowMajortoUpperRowMajor takeDiagonalrelaxUnitDiagonalstrictNonUnitDiagonal stackDiagonal%%% stackLower#%%% stackUpper%%%#stackSymmetric#%%%# splitDiagonal splitLower splitUppersplitSymmetric takeTopLefttakeBottomLeft takeTopRighttakeBottomRightsolveinverse eigenvaluesmapSize fromGeneral fromScalartoScalar identityFromidentityFromWidthidentityFromHeighttrace|=|stackpowerschur schurComplex fromHermitiansplitgramianTransposedcongruenceDiagonalTransposedcongruenceTransposedanticommutatorTransposedsolveDecomposed*%%%#outersumRank1sumRank1NonEmptysumRank2sumRank2NonEmpty fromSymmetric addAdjoint#*|-*##*####*##*# solveRight solveLeft#\####/# solveVector#\|-/# Householder mapExtentdeterminantAbsolute fromMatrix leastSquares minimumNormextractQ tallExtractQ tallMultiplyQtallMultiplyQAdjoint multiplyQextractR tallExtractR tallMultiplyR tallSolveRleastSquaresMinimumNormRCondpseudoInverseRCondprojectleastSquaresConstraintgaussMarkovLinearModel householderhouseholderTall complementaffineSpanFromKernelaffineKernelFromSpan toHermitiantoBandedtallFromGeneralwideFromGeneral asGeneralasTallasWide caseTallWide mapHeightmapWidth singleRow singleColumn flattenRow flattenColumnliftRow liftColumnfromRowsNonEmpty fromRowArrayfromRowsNonEmptyContainerfromRowContainerfromRowsfromColumnsNonEmptyfromColumnArrayfromColumnsNonEmptyContainerfromColumnContainer fromColumnstoRows toColumns toRowArray toColumnArraytoRowContainertoColumnContainertakeRow takeColumntakeTop takeBottomtakeRowsdropRows takeColumns dropColumns takeEqually dropEquallyswapRows swapColumns reverseRowsreverseColumns takeRowArraytakeColumnArray fromRowMajor toRowMajor|||===leftBias rightBiascontiguousBiasrowSums columnSumsrowArgAbsMaximumscolumnArgAbsMaximumsmap|*- tensorProduct kronecker scaleRows\*# scaleColumns#*\ scaleRowsRealscaleColumnsReal\\##/\multiplySquarevalues valuesTall valuesWidedecomposePolar subSlicesparameterDifferencesdividedDifferencesdividedDifferencesMatrixparameterDifferencesMatrixmain SquareMatrixZeroInt2 balances0 expenses0 normalizenormalizeSplitcompleteIdSquareiterated compensatedsquareFromListtoLowerTriangulartoUpperTriangular LowerUpperextractP multiplyPextractL wideExtractL wideMultiplyL wideSolveLextractU tallExtractU tallMultiplyU tallSolveU UncheckeddeconsUnchecked ArgMaximum runArgMaximumabsMaxuncheckrecheckFlipgetFlipgetDeterminant TakeDiagonalrunTakeDiagonal runDiagonalUnifygetUnifyMultiplyTagLawgetMultiplyTagLawTagFactStackgetStack AppendAny getAppendAnyFusegetFuse switchTagGTWAdaptgetAdaptWidengetWidenEqualgetEqual Transpose getTransposeAccessor getAccessor GenToWide getGenToWide GenToTall getGenToTallGenWide getGenWideGenTall getGenTall GenSquare getGenSquare CaseTallWidegetCaseTallWide wideWidth wideHeight tallWidth tallHeight generalWidth generalHeight switchTagPair genSquare genToTall genToWidesquareFromGeneralshowsPrecSquare showsPrecAnywidenreduceWideHeightreduceConsistent mapSquareSizemapWrap appendLeftAuxstackGenmultiplyTagLaw heightFact widthFact unifyLeft unifyRightConst2 getConst2UpLoSymC switchUpLoSymUpLoSym DiagUpLoCUpLoC switchUpLo switchContentFilledEmpty splitExtent splitOrdertransposeFromOrderswapOnRowMajorsideSwapFromOrder mapChecked fullIndicesfullIndexFromOffset fullMapExtent splitHeight splitWidthsplitMapExtentcaseTallWideSplit splitParthermitianFromSymmetric uploFromOrdersymmetricFromHermitian caseTriDiagcharFromTriDiagloweruppertriangularTranspose autoContent uploOrder getConstAs caseContentcaseLoUpcaseDiagUpLoSymgetContentConst2 caseUpLoSymtriangleRootDoubletriangleExtenttriangleIndicestriangleOffsettriangleUncheckedOffsettriangleSizeOffsettriangleUncheckedSizeOffsettriangleIndexFromOffset bandedHeight bandedWidthbandedMapExtent bandedBreadthnumOffDiagonals natFromProxybandedTranspose outsideOffset bandedOffsetbandedIndicesRowMajorbandedIndexFromOffsetbandedHermitianIndexFromOffsettransposeOrderconjugatedOnRowMajorconjugateToTemp copySubMatrixcopyToColumnMajor productLoop ComplexPart ImaginaryPartRealPartLACGVgetLACGVSumrunSum CopyToTemp runCopyToTemprealPtrfill copyBlock copyToTempcomplexConjugateToTemp condConjugate copyConjugatecopyCondConjugatecondConjugateToTempcopyCondConjugateToTempcopySubTrapezoidcopyTransposedcopyToSubColumnMajorcopyToColumnMajorTemp pointerSeqcreateHigherArraysumReal sumComplex sumComplexAltmulRealmulPairslacgvgemvgbmv initializeMVmultiplyMatrixwithAutoWorkspaceInfowithAutoWorkspacewithInfoargMsg errorCodeMsgrankMsg definiteMsgeigenMsgpokeCIntpeekCInt ceilingSizecaseRealComplexFunc getConstFunc argGeneral argSquare revealOrdergetPowergetMap MultiplyRightgetMultiplyRightdiagonalPointersdiagonalPointerPairscolumnMajorPointersrowMajorPointers forPointerscopyTriangleToTemp unpackToTempunpackpackpackRect _unpackZero unpackZero fillTriangle copyTriangleA copyTriangleC copyRectangle fromBanded fromUpperPart decomplex recomplex checkedZerosolverwithDeterminantInfo diagonalMsg'netlib-ffi-0.1.1-Dvr875KiF5nAzgJXE5V4PqNumeric.Netlib.ClassFloatingData.Array.Comfort.Shape:+: deconsElement deconsShapefromTruncatedPivots fromPivotsGen condNegateodddropEventransposeToMutablemultiplyUnchecked initMutabledeconsElementPtrToTuple getToTupleTuple TupleShapeFormatTriangulargetFormatTriangular formatVector formatFullformatHouseholderformatHermitianformatSymmetriccomplementTriangleformatDiagonalformatTriangularpadUpperTrianglepadLowerTriangleslice padBandedpadBandedHermitianshiftRow splitRows fillTupleprintfFloatingprintfFloatingMaybe printfComplexprintfComplexAux complexTupleStaticIdentitystaticIdentity MultiplySame multiplySameNFDatarnfscaleWithCheckmultiplyColumnMajor ScaleRowsRealgetScaleRowsRealContiguousBias RightBiasLeftBias swapMultiply forceRowMajortakeSub liftRowMajorscaleRowsComplexscaleColumnsComplexmultiplyVectorUnchecked identityOrderblockDiagonalPointerstakeHalfCorrupt determinantRextractTrianglemultiplyTriangularsolveTriangularscaledAnticommutatorscaledAnticommutatorTransposedidentityFatOrder fromDiagonalscaledAnticommutatorAdjoint StaticVector Admissiblecheck matrixMatrixTriangularTriangularConformgetTriangularTriangularConformComposedTriangularMultipliedDiagMultipliedPartMultipliedTriangularMultiplyTriangulartriangularTriangular Multipliedsame squareFull fullSquaretransposableSquare vectorMatrix matrixVectorbandedGenSquare unifyFactorstriangularTriangularToSquaretriangularTriangularConformsolveColumnMajor$fDeterminantBandedHermitian$fSolveBandedHermitiansplit_tau_Hhextent_addRows extractQAuxadjointFromTransposeinvCharextractComplement