!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None&',-0;<=>?ADFQTV]i0eigen FIXME: Doceigen FIXME: Doceigen FIXME: Doceigen FIXME: Doceigen$Hack used in constructing FFI calls.eigenEncode a C Type as a CInt>Hack used in FFI wrapper functions when constructing FFI callseigen is a closed typeclass that encompasses the properties eigen expects its values to possess, and simplifies the external API quite a bit. eigen FIXME: Doc eigenEComplex number for FFI with the same memory layout as std::complex<T> eigen!Cast to and from a C-FFI type   is a closed typeclass with an associated injective type family. It is closed in the sense that we provide only four types with instances for it; and intend for eigen to only be used with those four types. The injectivity of the type family is then useful for avoiding MPTCs.   has two functions;  and , where \ goes from a Haskell type to its associated C type for internal use, with the C FFI, and 8 goes from the associated C type to the Haskell type.eigenLike , but specialised to .eigenLike , but specialised to .reigenUsed internally. Given a ! constraint, turn the type-level  into an .seigen$Hack used in constructing FFI calls.teigenMachine size of a .ueigen FIXME: Docveigen FIXME: Docweigen'FIXME: replace with unholyPerformIO (?)xeigen FIXME: Doceigen instance for   eigen WARNING! 7 is lossy for any Int greater than (maxBound :: Int32)!  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~r  stuvwxqyponmzl{k|j}ih~gfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! None"#&',-FSTViJIeigenUThis type does not differ from MSparseMatrix, but might be desirable for readability.eigen9A mutable matrix where the state token is specialised to .eigen<Alias for double precision mutable matrix of complex numberseigen<Alias for single precision mutable matrix of complex numberseigen)Alias for double precision mutable matrixeigen)Alias for single precision mutable matrixeigenIUsed internally to track the size and corresponding C type of the matrix.eigenA mutable matrix. See  $ for details about matrix layout.eigenQCreate a mutable matrix of the given size and fill it with 0 as an initial value.eigenLCreate a mutable matrix of the given size and fill it with an initial value.eigen0Set all elements of the matrix to a given value.eigenCopy a matrix.eigen(Yield the element at the given position.eigen*Replace the element at the given position.eigenPass a pointer to the matrix's data to the IO action. Modifying dat through the pointer is unsafe if the matrix could have been frozen before the modification.eigenReturn a mutable storable 6 of the corresponding C types to one's mutable matrix.eigen0Create a mutable matrix from a mutable storable .None&'+-<FQSTV]i@eigen8Provide a view of the matrix for extraction of a subset.eigen)View matrix as a lower triangular matrix.eigen*View matrix as an upper triangular matrix.eigenDView matrix as a lower triangular matrix with zeros on the diagonal.eigenEView matrix as an upper triangular matrix with zeros on the diagonal.eigenCView matrix as a lower triangular matrix with ones on the diagonal.eigenDView matrix as an upper triangular matrix with ones on the diagonal.eigen4Alias for double precision matrix of complex numberseigen4Alias for single precision matrix of complex numberseigen!Alias for double precision matrixeigen!Alias for single precision matrixeigenIUsed internally to track the size and corresponding C type of the matrix.eigen'Matrix to be used in pure computations.!Uses column majour memory layout.Has a copy-free FFI using the  http://eigen.tuxfamily.orgEigen library.eigen-Encode the sparse matrix as a lazy bytestringeigen/Decode the sparse matrix from a lazy bytestring eigenConstruct an empty 0x0 matrix eigenIs matrix empty? eigenIs matrix square? eigen7Matrix where all coeffs are filled with the given value eigen)Matrix where all coeffs are filled with 0eigen)Matrix where all coeffs are filled with 1eigen,The identity matrix (not necessarily square)eigen!The random matrix of a given sizeeigen The number of rows in the matrixeigen"The number of colums in the matrixeigen,Return Matrix size as a pair of (rows, cols)eigen'Return the value at the given position.eigen'Return the value at the given position.eigen}Given a generation function `f :: Int -> Int -> a`, construct a Matrix of known size using points in the matrix as inputs.eigen)The sum of all coefficients in the matrixeigen-The product of all coefficients in the matrixeigen5The arithmetic mean of all coefficients in the matrixeigen>The trace of a matrix is the sum of the diagonal coefficients. m ==  (. m)eigenEGiven a predicate p, determine if all values in the Matrix satisfy p.eigenEGiven a predicate p, determine if any values in the Matrix satisfy p.eigenGGiven a predicate p, determine how many values in the Matrix satisfy p.eigenFor vectors, the l2 norm, and for matrices the Frobenius norm. In both cases, it consists in the square root of the sum of the square of all the matrix entries. For vectors, this is also equals to the square root of the dot product of this with itself.eigenFor vectors, the squared l2 norm, and for matrices the Frobenius norm. In both cases, it consists in the sum of the square of all the matrix entries. For vectors, this is also equals to the dot product of this with itself. eigenThe l2 norm of the matrix using the Blue's algorithm. A Portable Fortran Program to Find the Euclidean Norm of a Vector, ACM TOMS, Vol 4, Issue 1, 1978.!eigenThe l2 norm of the matrix avoiding undeflow and overflow. This version use a concatenation of hypot calls, and it is very slow."eigenThe determinant of the matrix#eigenAdd two matrices.$eigenSubtract two matrices.%eigenMultiply two matrices.&eigenApply a given function to each element of the matrix. Here is an example how to implement scalar matrix multiplication: >>> let a = fromList [[1,2],[3,4]] :: MatrixXf 2 2 >>> a Matrix 2x2 1.0 2.0 3.0 4.0 >>> map (*10) a Matrix 2x2 10.0 20.0 30.0 40.0'eigenQApply a given function to each element of the matrix. Here is an example how upper triangular matrix can be implemented: >>> let a = fromList [[1,2,3],[4,5,6],[7,8,9]] :: MatrixXf >>> a Matrix 3x3 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 >>> imap (row col val -> if row <= col then val else 0) a Matrix 3x3 1.0 2.0 3.0 0.0 5.0 6.0 0.0 0.0 9.0(eigen1Triangular view extracted from the current matrix)eigenGFilter elements in the matrix. Filtered elements will be replaced by 0.*eigenaFilter elements in the matrix with an indexed predicate. Filtered elements will be replaces by 0.+eigenThe length of the matrix.,eigen2Left fold of a matrix, where accumulation is lazy.-eigen5Right fold of a matrix, where accumulation is strict..eigen Return the diagonal of a matrix./eigenInverse of the matrix For small fixed sizes up to 4x4, this method uses cofactors. In the general case, this method uses PartialPivLU decomposition0eigenAdjoint of the matrix1eigenTranspose of the matrix2eigenConjugate of the matrix3eigen+Normalise the matrix by dividing it on its 4eigenApply a destructive operation to a matrix. The operation will be performed in-place, if it is safe to do so - otherwise, it will create a copy of the matrix.5eigenVExtract rectangular block from matrix defined by startRow startCol blockRows blockCols6eigenTurn a mutable matrix into an immutable matrix without copying. The mutable matrix should not be modified after this conversion.7eigengPass a pointer to the matrix's data to the IO action. The data may not be modified through the pointer.8eigenConvert a matrix to a list.9eigen$Convert a list to a matrix. Returns B if the dimensions of the list do not match that of the matrix.5eigen starting roweigen starting coleigen block of rowseigen block of colseigenextract from thiseigen extractionIr      !"#$%&'()*+,-./0123456789Ir     . !"#$%&'()*+,-/0123456798NoneB@eigen1Sets the max number of threads reserved for EigenAeigen1Gets the max number of threads reserved for Eigen@A@ANone&'-0;=>?DFV]DBeigen SDecomposition Requirements on the matrix Speed Accuracy Rank Kernel Image PartialPivLU Invertible ++ + - - - FullPivLU None - +++ + + + HouseholderQR None ++ + - - - ColPivHouseholderQR None + ++ + - - FullPivHouseholderQR None - +++ + - - LLT Positive definite +++ + - - - LDLT Positive or negative semidefinite +++ ++ - - - JacobiSVD None - +++ + - - ZThe best way to do least squares solving for square matrices is with a SVD decomposition (J)Ceigen3LU decomposition of a matrix with partial pivoting.Deigen4LU decomposition of a matrix with complete pivoting.Eeigen)Householder QR decomposition of a matrix.FeigenMHouseholder rank-revealing QR decomposition of a matrix with column-pivoting.GeigenKHouseholder rank-revealing QR decomposition of a matrix with full pivoting.Heigen3Standard Cholesky decomposition (LL^T) of a matrix.Ieigen8Robust Cholesky decomposition of a matrix with pivoting.Jeigen;Two-sided Jacobi SVD decomposition of a rectangular matrix.Keigen x = solve d a bfinds a solution x of ax = b equation using decomposition dLeigen e = relativeError x a b computes norm (ax - b) / norm b where norm is L2 normMeigenThe rank of the matrix.NeigenBReturn the matrix whose columns form a basis of the null-space of A.OeigenBReturn a matrix whose columns form a basis of the column-space of A.Peigen )(coeffs, error) = linearRegression points$computes multiple linear regression #y = a1 x1 + a2 x2 + ... + an xn + b using F decompositionpoint format is  [y, x1..xn]coeffs format is  [b, a1..an]error is calculated using L import Data.Eigen.LA main = print $ linearRegression (Row @5) [ [-4.32, 3.02, 6.89], [-3.79, 2.01, 5.39], [-4.01, 2.41, 6.01], [-3.86, 2.09, 5.55], [-4.10, 2.58, 6.32] ] produces the following output [Just ([-2.3466569233817127,-0.2534897541434826,-0.1749653335680988],1.8905965120153139e-3) BCDEFGHIJKLMNOPBCDEFGHIJKLMNOPNone"#&',-FSTVi(UeigenThis type does not differ from W,, but might be desirable for readability.Veigen8A sparse matrix where the state token is specialised to  ReadWorld.WeigenMutable sparse matrix. See  $ for details about matrix layout.Yeigen/Create a new sparse matrix with the given size  rows x cols.Zeigen)Returns the number of rows of the matrix.[eigen,Returns the number of columns of the matrix.\eigenqReturns the number of rows (resp. columns) of the matrix if the storage order is column majour (resp. row majour)]eigenqReturns the number of columns (resp. rows) of the matrix if the storage order is column majour (resp. row majour)^eigen8Returns whether or not the matrix is in compressed form._eigen(Turns the matrix into compressed format.`eigenDecompresses the matrix.aeigenDRead the value of the matrix at position i,j. This function returns  Scalar(0)! if the element is an explicit 0.beigen+Writes the value of the matrix at position i, jZ. This function turns the matrix into a non compressed form if that was not the case. This is a  O(log(nnz_j))d operation (binary search) plus the cost of element insertion if the element does not already exist.Cost of element insertion is sorted insertion in O(1) if the elements of each inner vector are inserted in increasing inner index order, and in O(nnz_j) for a random insertion.ceigen'Sets the matrix to the identity matrix.deigen0Remove all non zeros, but keep allocated memory.eeigenBPreallocates for non zeros. The matrix must be in compressed mode.feigen+Returns the number of nonzero coefficients.UVWXYZ[\]^_`abcdefWXVUYeZ[\]f^_`abdcNone"#&',-FSTViG5geigen;Alias for double prevision sparse matrix of complex numbersheigen;Alias for single previsiom sparse matrix of complex numbersieigen(Alias for double precision sparse matrixjeigen(Alias for single precision sparse matrixkeigen7A versatible sparse matrix representation. SparseMatrix is the main sparse matrix representation of Eigen's sparse module. It offers high performance and low memory usage. It implements a more versatile variant of the widely-used Compressed Column (or Row) Storage scheme. It consists of four compact arrays: * o4: stores the coefficient values of the non-zeros. * p<: stores the row (resp. column) indices of the non-zeros. * qc: stores for each column (resp. row) the index of the first non-zero in the previous two arrays. * r-: stores the number of non-zeros of each column (resp. row). The word inner refers to an inner vector that is a column for a column-major matrix, or a row for a row-major matrix. The word outer refers to the other direction. This storage scheme is better explained on an example. The following matrix \ 0 3 0 0 0 22 0 0 0 17 7 5 0 1 0 0 0 0 0 0 0 0 14 0 8 ! and one of its possible sparse,  column major representation:  values: 22 7 _ 3 5 14 _ _ 1 _ 17 8 innerIndices: 1 2 _ 0 2 4 _ _ 2 _ 1 4 outerStarts: 0 3 5 8 10 12 innerNNZs: 2 2 1 1 2  Currently the elements of a given inner vector are guaranteed to be always sorted by increasing inner indices. The "_" indicates available free space to quickly insert new elements. Assuming no reallocation is needed, the insertion of a random element is therefore in O(nnz_j) where nnz_j is the number of nonzeros of the respective inner vector. On the other hand, inserting elements with increasing inner indices in a given inner vector is much more efficient since this only requires to increase the respective r entry that is a O(1) operation. The case where no empty space is available is a special case, and is refered as the compressed mode. It corresponds to the widely used Compressed Column (or Row) Storage schemes (CCS or CRS). Any k+ can be turned to this form by calling the }1 function. In this case, one can remark that the r array is redundant with q because we the equality: .InnerNNZs[j] = OuterStarts[j+1]-OuterStarts[j]#. Therefore, in practice a call to } frees this buffer. The results of Eigen's operations always produces compressed sparse matrices. On the other hand, the insertion of a new element into a kU converts this later to the uncompressed mode. For more infomration please see Eigen  >http://eigen.tuxfamily.org/dox/classEigen_1_1SparseMatrix.htmldocumentation page.meigen-Encode the sparse matrix as a lazy bytestringneigen/Decode the sparse matrix from a lazy bytestringoeigen,Get the coefficient values of the non-zeros.peigen%Get the row indices of the non-zeros.qeigenPGets for each column the index of the first non-zero in the previous two arrays.reigenGets the number of non-zeros of each column. The word inner refers to an inner vector that is a column for a column-major matrix, or a row for a row-major matrix. The word outer refers to the other directionseigen#Number of rows in the sparse matrixteigen%Number of colums in the sparse matrixeigen#Number of rows in the sparse matrixeigen%Number of colums in the sparse matrixueigen5Sparse matrix coefficient at the given row and columnveigen.Matrix coefficient at the given row and columnweigenFor vectors, the l2 norm, and for matrices the Frobenius norm. In both cases, it consists in the square root of the sum of the square of all the matrix entries. For vectors, this is also equals to the square root of the dot product of this with itself.xeigenFor vectors, the squared l2 norm, and for matrices the Frobenius norm. In both cases, it consists in the sum of the square of all the matrix entries. For vectors, this is also equals to the dot product of this with itself.yeigenThe l2 norm of the matrix using the Blue's algorithm. A Portable Fortran Program to Find the Euclidean Norm of a Vector, ACM TOMS, Vol 4, Issue 1, 1978.zeigendExtract a rectangular block from the sparse matrix, given a startRow, startCol, blockRows, blockCols{eigen1Number of non-zeros elements in the sparse matrix|eigen8Number of elements in the sparse matrix, including zeros}eigen#The matrix in the compressed format~eigen%The matrix in the uncompressed formateigenIs the matrix compressed?eigen1Minor dimension with respect to the storage ordereigen1Major dimension with respect to the storage ordereigenVSuppresses all nonzeros which are much smaller than the reference under the tolerance epsiloneigen!Multiply matrix on a given scalareigenTranspose of the sparse matrixeigenAdjoint of the sparse matrixeigenEAdd two sparse matrices by adding the corresponding entries together.eigenOSubtract two sparse matrices by subtracting the corresponding entries together.eigenMatrix multiplication.eigenMap a function over the k.eigen!Map an indexed function over the k.eigen_Construct asparse matrix of the given size from the storable vector of triplets (row, col, val)eigenjConvert a sparse matrix to the list of triplets (row, col, val). Compressed elements will not be included.eigenjConvert a sparse matrix to the list of triplets (row, col, val). Compressed elements will not be included.eigen@Construct a sparse matrix from a list of triples (row, val, col)eigen:Convert a sparse matrix to a (n X m) dense list of values.eigenConstruct a sparsematrix from a two-dimensional list of values. If the dimensions of the list do not match that of the list, 0 is returned. Zero values will be compressed.eigen-Construct a dense matrix from a sparse matrixeigenPConstruct a sparse matrix from a dense matrix. zero-elements will be compressed.eigen-Yield an immutable copy of the mutable matrixeigen-Yield a mutable copy of the immutable matrix.eigenUnsafely convert a mutable matrix to an immutable one without copying. The mutable matrix may not be used after this operation.eigenUnsafely convert an immutable matrix to a mutable one without copying. The immutable matrix may not be used after this operation.eigen)Return a single row of the sparse matrix.eigen,Return a single column of the sparse matrix.eigen#Number of rows in the sparse matrixeigen%Number of colums in the sparse matrix2ghijklmnopqrstuvwxyz{|}~2kljihg|opqrtsuvwxyz{}~mnNone"#3;=>?AFKTV%eigenComputation was successful.eigen4The provided data did not satisfy the prerequisites.eigen%Iterative procedure did not converge.eigenThe inputs are invalid, or the algorithm has been improperly called. When assertions are enabled, such errors trigger an error.eigen4Sparse left-looking rank-revealing QR factorization.This class implements a left-looking rank-revealing QR decomposition of sparse matrices. When a column has a norm less than a given tolerance it is implicitly permuted to the end. The QR factorization thus obtained is given by  A*P = Q*R where R$ is upper triangular or trapezoidal.Pi is the column permutation which is the product of the fill-reducing and the rank-revealing permutations.QL is the orthogonal matrix represented as products of Householder reflectors.RG is the sparse triangular or trapezoidal matrix. The later occurs when A is rank-deficient.eigen8Sparse supernodal LU factorization for general matrices.This class implements the supernodal LU factorization for general matrices. It uses the main techniques from the sequential  *http://crd-legacy.lbl.gov/~xiaoye/SuperLU/SuperLU package4. It handles transparently real and complex arithmetics with single and double precision, depending on the scalar type of your input matrix. The code has been optimized to provide BLAS-3 operations during supernode-panel updates. It benefits directly from the built-in high-performant Eigen BLAS routines. Moreover, when the size of a supernode is very small, the BLAS calls are avoided to enable a better optimization from the compiler. For best performance, you should compile it with NDEBUG flag to avoid the numerous bounds checking on vectors.An important parameter of this class is the ordering method. It is used to reorder the columns (and eventually the rows) of the matrix to reduce the number of new elements that are created during numerical factorization. The cheapest method available is COLAMD. See  Bhttp://eigen.tuxfamily.org/dox/group__OrderingMethods__Module.htmlOrderingMethods module< for the list of built-in and external ordering methods.eigenEA bi conjugate gradient stabilized solver for sparse square problems.This class allows to solve for A.x = b\ sparse linear problems using a bi conjugate gradient stabilized algorithm. The vectors x and b can be either dense or sparse.OThe maximal number of iterations and tolerance value can be controlled via the  and ` methods. The defaults are the size of the problem for the maximal number of iterations and epsilon for the toleranceeigen=A conjugate gradient solver for sparse self-adjoint problems.This class allows to solve for A.x = bP sparse linear problems using a conjugate gradient algorithm. The sparse matrix A must be selfadjoint.OThe maximal number of iterations and tolerance value can be controlled via the  and ` methods. The defaults are the size of the problem for the maximal number of iterations and epsilon for the toleranceeigenSometimes, the solution need not be too accurate. In this case, the iterative methods are more suitable and the desired accuracy can be set before the solve step using .eigenFFor direct methods, the solution is computed at the machine precision.eigen-A preconditioner based on the digonal entriesIt allows to approximately solve for A.x = b problems assuming A is a diagonal matrix. In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for: 3 A.diagonal().asDiagonal() . x = b  This preconditioner is suitable for both selfadjoint and general problems. The diagonal entries are pre-inverted and stored into a dense vector.[A variant that has yet to be implemented would attempt to preserve the norm of each column.eigenKA naive preconditioner which approximates any matrix as the identity matrixeigenOrdering methods for sparse matrices. They are typically used to reduce the number of elements during the sparse matrix decomposition (LLT, LU, QR<). Precisely, in a preprocessing step, a permutation matrix P is computed using those ordering methods and applied to the columns of the matrix. Using for instance the sparse Cholesky decomposition, it is expected that the nonzeros elements in LLT(A*P)# will be much smaller than that in LLT(A).eigeniThe column approximate minimum degree ordering The matrix should be in column-major and compressed formateigenThe natural ordering (identity)eigenHInitializes the iterative solver for the sparsity pattern of the matrix A for further solving Ax=b problems.eigenIInitializes the iterative solver with the numerical values of the matrix A for further solving Ax=b problems.eigen1Initializes the iterative solver with the matrix A for further solving Ax=b problems.The & method is equivalent to calling both  and .eigenAn expression of the solution x of Ax=b$ using the current decomposition of A.eigen The solution x of Ax=b$ using the current decomposition of A and x0 as an initial solution. solveWithGuess :: (Solver s, MonadIO p, I.Elem a) => SM.SparseMatrix n m a -> SM.SparseMatrix n m a -> SolverT s a p (SM.SparseMatrix n m a) solveWithGuess (SM.SparseMatrix fb) (SM.SparseMatrix fx0) = SolverT $ ask >>= (i,fs) -> liftIO $ withForeignPtr fs $ s -> withForeignPtr fb $ b -> withForeignPtr fx0 $ x0 -> alloca $ px -> do I.call $ I.sparse_la_solveWithGuess i s b x0 px x <- peek px SM.SparseMatrix  $. FC.newForeignPtr x (I.call $ I.sparse_free x)9 if the iterations converged or computation was succesful1 if the factorization reports a numerical problem$ if the iterations are not converged if the input matrix is invalideigen6The tolerance threshold used by the stopping criteria.eigen;Sets the tolerance threshold used by the stopping criteria.EThis value is used as an upper bound to the relative residual error:  |Ax-b|/|b|6. The default value is the machine precision given by epsiloneigenThe max number of iterations. It is either the value setted by setMaxIterations or, by default, twice the number of columns of the matrix.eigenXSets the max number of iterations. Default is twice the number of columns of the matrix.eigensThe tolerance error reached during the last solve. It is a close approximation of the true relative residual error  |Ax-b|/|b|.eigen8The number of iterations performed during the last solveeigen Returns the b sparse upper triangular matrix R of the QR factorization.eigenReturns the matrix Q. as products of sparse Householder reflectors.eigenaSets the threshold that is used to determine linearly dependent columns during the factorization.In practice, if during the factorization the norm of the column that has to be eliminated is below this threshold, then the entire column is treated as zero, and it is moved at the end.eigen]Returns the number of non linearly dependent columns as determined by the pivoting threshold.eigen:Indicate that the pattern of the input matrix is symmetriceigenReturns the matrix LeigenReturns the matrix UeigenThe determinant of the matrix.eigenlThe natural log of the absolute value of the determinant of the matrix of which this is the QR decompositionsThis method is useful to work around the risk of overflow/underflow that's inherent to the determinant computation.eigen[The absolute value of the determinant of the matrix of which *this is the QR decomposition.A determinant can be very big or small, so for matrices of large enough dimension, there is a risk of overflow/underflow. One way to work around that is to use  instead.eigen1A number representing the sign of the determinant//  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~         !"#$%&'()*+,-./0123456789:;<=>?@AABCDEFGHIJKLMN    OPQR%JSEFDBCTUV'(WXYZ[\&]^_`abbcdefghhiijjkklmnopqrstuvwxyz{|}~  eigen-3.3.4.2-inplaceEigen.InternalEigen.Matrix.Mutable Eigen.MatrixEigen.ParallelEigen.Solver.LAEigen.SparseMatrix.MutableEigen.SparseMatrixEigen.Solver.SparseLAData.Vector.Storable.MutableVectorMatrix SparseMatrix CSolverPtrCSolverCSparseMatrixPtr CSparseMatrix MagicCodeCodecodeElemCTripletCComplexCastCtoCfromCColRowc_sparse_la_signDeterminantc_sparse_la_absDeterminantc_sparse_la_logAbsDeterminantc_sparse_la_determinantc_sparse_la_setSymmetricc_sparse_la_matrixUc_sparse_la_matrixLc_sparse_la_rankc_sparse_la_setPivotThresholdc_sparse_la_matrixRc_sparse_la_matrixQc_sparse_la_solvec_sparse_la_iterationsc_sparse_la_errorc_sparse_la_infoc_sparse_la_setMaxIterationsc_sparse_la_maxIterationsc_sparse_la_setTolerancec_sparse_la_tolerancec_sparse_la_computec_sparse_la_analyzePatternc_sparse_la_factorizec_sparse_la_freeSolverc_sparse_la_newSolverc_sparse_uncompressInplacec_sparse_compressInplacec_sparse_conservativeResizec_sparse_resizec_sparse_reservec_sparse_setIdentityc_sparse_setZeroc_sparse_innerNNZsc_sparse_innerIndicesc_sparse_outerStartsc_sparse_valuesc_sparse_toMatrixc_sparse_fromMatrixc_sparse_block c_sparse_mul c_sparse_sub c_sparse_addc_sparse_blueNormc_sparse_squaredNorm c_sparse_norm c_sparse_rows c_sparse_colsc_sparse_coeffRefc_sparse_coeffc_sparse_outerSizec_sparse_innerSizec_sparse_nonZerosc_sparse_scalec_sparse_prunedRefc_sparse_prunedc_sparse_adjointc_sparse_transposec_sparse_isCompressedc_sparse_uncompressc_sparse_makeCompressed c_sparse_freec_sparse_toListc_sparse_fromListc_sparse_clone c_sparse_newc_relativeErrorc_solvec_kernelc_imagec_rank c_determinant c_hypotNorm c_blueNorm c_squaredNormc_tracec_normc_meanc_prodc_sum c_normalize c_conjugate c_adjoint c_inverse c_transpose c_diagonalc_mulc_subc_add c_identityc_randomc_getNbThreadsc_setNbThreadsfree c_freeStringnatToInt magicCodeintSize encodeInt decodeInt performIOplusForeignPtrcallrandomidentityaddsubmuldiagonal transposeinverseadjoint conjugate normalizesumprodmeannormtrace squaredNormblueNorm hypotNorm determinantrankimagekernelsolve relativeError sparse_new sparse_clonesparse_fromList sparse_toList sparse_freesparse_makeCompressedsparse_uncompresssparse_isCompressedsparse_transposesparse_adjoint sparse_prunedsparse_prunedRef sparse_scalesparse_nonZerossparse_innerSizesparse_outerSize sparse_coeffsparse_coeffRef sparse_cols sparse_rows sparse_normsparse_squaredNormsparse_blueNorm sparse_add sparse_sub sparse_mul sparse_blocksparse_fromMatrixsparse_toMatrix sparse_valuessparse_outerStartssparse_innerIndicessparse_innerNNZssparse_setZerosparse_setIdentitysparse_reserve sparse_resizesparse_conservativeResizesparse_compressInplacesparse_uncompressInplacesparse_la_newSolversparse_la_freeSolversparse_la_factorizesparse_la_analyzePatternsparse_la_computesparse_la_tolerancesparse_la_setTolerancesparse_la_maxIterationssparse_la_setMaxIterationssparse_la_infosparse_la_errorsparse_la_iterationssparse_la_solvesparse_la_matrixQsparse_la_matrixRsparse_la_setPivotThresholdsparse_la_ranksparse_la_matrixLsparse_la_matrixUsparse_la_setSymmetricsparse_la_determinantsparse_la_logAbsDeterminantsparse_la_absDeterminantsparse_la_signDeterminant$fBinaryVector $fCastDouble $fCastFloat $fCastInt$fStorableCComplex $fCastComplex $fCast(,,)$fCodeCComplex$fCodeCComplex0 $fCodeCDouble $fCodeCFloat $fElemComplex$fElemComplex0 $fElemDouble $fElemFloat$fStorableCTriplet$fBinaryMagicCode$fShowCComplex $fEqMagicCode$fShowCTripletSTMatrixIOMatrix MMatrixXcd MMatrixXcf MMatrixXd MMatrixXfMMatrixnew replicatesetcopyreadwrite unsafeWithvals fromVectorTriangularModeLowerUpper StrictlyLower StrictlyUpper UnitLower UnitUpper MatrixXcd MatrixXcfMatrixXdMatrixXfVecencodedecodeemptynullsquareconstantzeroonesrowscolsdims!coeffgenerateallanycountmapimaptriangularViewfilterifilterlengthfoldlfoldl'modifyblock unsafeFreezetoListfromList$fBinaryMatrix $fShowMatrix$fEqTriangularMode$fEnumTriangularMode$fShowTriangularMode$fReadTriangularMode setNbThreads getNbThreads Decomposition PartialPivLU FullPivLU HouseholderQRColPivHouseholderQRFullPivHouseholderQRLLTLDLT JacobiSVDlinearRegression$fEnumDecomposition$fEqDecomposition$fShowDecomposition$fReadDecompositionSTSparseMatrixIOSparseMatrix MSparseMatrix innerSize outerSize compressedcompress uncompress setIdentitysetZeroreservenonZerosSparseMatrixXcdSparseMatrixXcfSparseMatrixXdSparseMatrixXfvalues innerIndices outerStarts innerNNZselemsprunedscaletoVector toDenseList fromDenseListtoMatrix fromMatrixfreezethaw unsafeThawgetRowgetCol$fBinarySparseMatrix$fShowSparseMatrixSolverTComputationInfoSuccessNumericalIssue NoConvergence InvalidInputSparseQRSparseLUBiCGSTABConjugateGradientIterativeSolver DirectSolverSolverPreconditionerDiagonalPreconditionerIdentityPreconditionerOrderingMethodCOLAMDOrderingNaturalOrdering runSolverTanalyzePattern factorizecomputeinfo tolerance setTolerance maxIterationssetMaxIterationserror iterationsmatrixRmatrixQsetPivotThreshold setSymmetricmatrixLmatrixUlogAbsDeterminantabsDeterminantsignDeterminant$fCodeConjugateGradient"$fIterativeSolverConjugateGradient$fSolverConjugateGradient$fCodeBiCGSTAB$fIterativeSolverBiCGSTAB$fSolverBiCGSTAB$fCodeSparseLU$fDirectSolverSparseLU$fSolverSparseLU$fCodeSparseQR$fDirectSolverSparseQR$fSolverSparseQR$fShowOrderingMethod$fReadOrderingMethod$fShowPreconditioner$fReadPreconditioner$fShowConjugateGradient$fReadConjugateGradient$fShowBiCGSTAB$fReadBiCGSTAB$fShowSparseLU$fReadSparseLU$fShowSparseQR$fReadSparseQR$fEqComputationInfo$fEnumComputationInfo$fShowComputationInfo$fReadComputationInfo$fFunctorSolverT$fApplicativeSolverT$fMonadSolverT$fMonadTransSolverTbase Data.ProxyProxyghc-prim GHC.TypesNat GHC.TypeNatsKnownNatIntForeign.C.TypesCIntbinary-0.8.5.1Data.Binary.ClassBinaryGHC.Prim RealWorldPvector-0.12.0.1-905ae50d07ea7532a0af834d2d1d41de85e7a71b58461034445e66f28d276b38MVectorGHC.BaseNothingrows_cols_ _unsafeRows _unsafeCols