{"id":15716378,"url":"https://github.com/drtimothyaldendavis/suitesparse","last_synced_at":"2025-05-13T18:12:01.159Z","repository":{"id":40687665,"uuid":"216246672","full_name":"DrTimothyAldenDavis/SuiteSparse","owner":"DrTimothyAldenDavis","description":"The official SuiteSparse library: a suite of sparse matrix algorithms authored or co-authored by Tim Davis, Texas A\u0026M University.","archived":false,"fork":false,"pushed_at":"2025-05-05T13:40:26.000Z","size":271083,"stargazers_count":1285,"open_issues_count":24,"forks_count":281,"subscribers_count":36,"default_branch":"dev","last_synced_at":"2025-05-05T14:33:11.338Z","etag":null,"topics":["c","cholmod","colamd","cpp","csparse","graph-algorithms","graphblas","klu","mathematics","matlab","sparse-matrix","spqr","suitesparse","umfpack"],"latest_commit_sha":null,"homepage":"https://people.engr.tamu.edu/davis/suitesparse.html","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/DrTimothyAldenDavis.png","metadata":{"files":{"readme":"README.md","changelog":"ChangeLog","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.txt","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":"CITATION.bib","codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2019-10-19T17:43:53.000Z","updated_at":"2025-05-03T06:13:49.000Z","dependencies_parsed_at":"2024-11-21T13:01:36.261Z","dependency_job_id":"abe9d9bb-f0fe-492d-b59a-c04442e57481","html_url":"https://github.com/DrTimothyAldenDavis/SuiteSparse","commit_stats":{"total_commits":1987,"total_committers":31,"mean_commits":64.09677419354838,"dds":0.5344740815299447,"last_synced_commit":"8ac3f515ad91ae3d0137fe98239e52d2a689eac3"},"previous_names":[],"tags_count":125,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/DrTimothyAldenDavis%2FSuiteSparse","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/DrTimothyAldenDavis%2FSuiteSparse/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/DrTimothyAldenDavis%2FSuiteSparse/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/DrTimothyAldenDavis%2FSuiteSparse/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/DrTimothyAldenDavis","download_url":"https://codeload.github.com/DrTimothyAldenDavis/SuiteSparse/tar.gz/refs/heads/dev","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254000857,"owners_count":21997442,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["c","cholmod","colamd","cpp","csparse","graph-algorithms","graphblas","klu","mathematics","matlab","sparse-matrix","spqr","suitesparse","umfpack"],"created_at":"2024-10-03T21:45:18.632Z","updated_at":"2025-05-13T18:11:56.129Z","avatar_url":"https://github.com/DrTimothyAldenDavis.png","language":"C","funding_links":[],"categories":[],"sub_categories":[],"readme":"-----------------------------------------------------------------------------\nSuiteSparse:  A Suite of Sparse matrix packages at http://suitesparse.com\n-----------------------------------------------------------------------------\n\nMar 6, 2025, SuiteSparse VERSION 7.10.1\n\nSuiteSparse is a set of sparse-matrix-related packages written or co-authored\nby Tim Davis, available at https://github.com/DrTimothyAldenDavis/SuiteSparse .\n\nPrimary author of SuiteSparse (codes and algorithms, excl. METIS): Tim Davis\n\nCode co-authors, in alphabetical order (not including METIS or LAGraph):\n    Patrick Amestoy, Mohsen Aznaveh, David Bateman, Jinhao Chen, Yanqing Chen,\n    Iain Duff, Joe Eaton, Les Foster, William Hager, Raye Kimmerer, Scott\n    Kolodziej, Chris Lourenco, Stefan Larimore, Lorena Mejia Domenzain, Erick\n    Moreno-Centeno, Markus Mützel, Corey Nolel, Ekanathan Palamadai,\n    Sivasankaran Rajamanickam, Sanjay Ranka, Wissam Sid-Lakhdar, and\n    Nuri Yeralan.\n\nLAGraph has been developed by the highest number of developers of any of\nthe packages in SuiteSparse and deserves its own list.  The list also\nappears in LAGraph/Contibutors.txt:\n\n    Janos B. Antal,    Budapest University of Technology and Economics, Hungary\n    Mohsen Aznaveh,    Texas A\u0026M University\n    David A. Bader     New Jersey Institute of Technology\n    Aydin Buluc,       Lawrence Berkeley National Lab\n    Jinhao Chen,       Texas A\u0026M University\n    Tim Davis,         Texas A\u0026M University\n    Florentin Dorre,   Technische Univeritat Dresden, Neo4j\n    Marton Elekes,     Budapest University of Technology and Economics, Hungary\n    Balint Hegyi,      Budapest University of Technology and Economics, Hungary\n    Tanner Hoke,       Texas A\u0026M University\n    James Kitchen,     Anaconda\n    Scott Kolodziej,   Texas A\u0026M University\n    Pranav Konduri,    Texas A\u0026M University\n    Roi Lipman,        Redis Labs (now FalkorDB)\n    Tze Meng Low,      Carnegie Mellon University\n    Tim Mattson,       Intel\n    Scott McMillan,    Carnegie Mellon University\n    Markus Muetzel\n    Michel Pelletier,  Graphegon\n    Gabor Szarnyas,    CWI Amsterdam, The Netherlands\n    Erik Welch,        Anaconda, NVIDIA\n    Carl Yang,         University of California at Davis, Waymo\n    Yongzhe Zhang,     SOKENDAI, Japan\n\nMETIS is authored by George Karypis.\n\nAdditional algorithm designers: Esmond Ng and John Gilbert.\n\nRefer to each package for license, copyright, and author information.\n\n-----------------------------------------------------------------------------\nDocumentation\n-----------------------------------------------------------------------------\n\nRefer to each package for the documentation on each package, typically in the\nDoc subfolder.\n\n-----------------------------------------------------------------------------\nSuiteSparse branches\n-----------------------------------------------------------------------------\n\n* dev: the default branch, with recent updates of features to appear in\n    the next stable release.  The intent is to keep this branch in\n    fully working order at all times, but the features will not be\n    finalized at any given time.\n* stable: the most recent stable release.\n* dev2: working branch.  All submitted PRs should made to this branch.\n    This branch might not always be in working order.\n\n-----------------------------------------------------------------------------\nSuiteSparse Packages\n-----------------------------------------------------------------------------\n\nPackages in SuiteSparse, and files in this directory:\n\n* `AMD`\n\n  approximate minimum degree ordering.  This is the built-in AMD function in\n  MATLAB.\n\n  authors: Tim Davis, Patrick Amestoy, Iain Duff\n\n* `bin`\n\n  where programs are placed when compiled, for `make local`\n\n* `BTF`\n\n  permutation to block triangular form\n\n  authors: Tim Davis, Ekanathan Palamadai\n\n* `build`\n\n  folder for default build tree\n\n* `CAMD`\n\n  constrained approximate minimum degree ordering\n\n  authors: Tim Davis, Patrick Amestoy, Iain Duff, Yanqing Chen\n\n* `CCOLAMD`\n\n  constrained column approximate minimum degree ordering\n\n  authors: Tim Davis, Sivasankaran Rajamanickam, Stefan Larimore.\n\n  Algorithm design collaborators: Esmond Ng, John Gilbert (for COLAMD)\n\n* `ChangeLog`\n\n  a summary of changes to SuiteSparse.  See `*/Doc/ChangeLog` for details for\n  each package.\n\n* `CHOLMOD`\n\n  sparse Cholesky factorization.  Requires AMD, COLAMD, CCOLAMD, the BLAS, and\n  LAPACK.  Optionally uses METIS.  This is `chol` and `x=A\\b` in MATLAB.\n\n  author for all modules: Tim Davis\n\n  CHOLMOD/Modify module authors: Tim Davis and William W. Hager\n\n  CHOLMOD/SuiteSparse_metis: a modified version of METIS, embedded into the\n  CHOLMOD library.  See the README.txt files for details.  author: George\n  Karypis.  This is a slightly modified copy included with SuiteSparse via the\n  open-source license provided by George Karypis.  SuiteSparse cannot use an\n  unmodified copy of METIS.\n\n* `CITATION.bib`\n\n  citations for SuiteSparse packages, in bibtex format.\n\n* `CMakeLists.txt`\n\n  optional, to compile all of SuiteSparse.  See below.\n\n* `CODE_OF_CONDUCT.md`\n\n  community guidelines\n\n* `COLAMD`\n\n  column approximate minimum degree ordering.  This is the built-in COLAMD\n  function in MATLAB.\n\n  authors (of the code): Tim Davis and Stefan Larimore\n\n  Algorithm design collaborators: Esmond Ng, John Gilbert\n\n* `Contents.m`\n\n  a list of contents for 'help SuiteSparse' in MATLAB.\n\n* `CONTRIBUTING.md`\n\n  how to contribute to SuiteSparse\n\n* `CONTRIBUTOR-LICENSE.txt`\n\n  required contributor agreement\n\n* `CSparse`\n\n  a concise sparse matrix package, developed for my book, \"Direct Methods for\n  Sparse Linear Systems\", published by SIAM.  Intended primarily for teaching.\n  Note that the code is (c) Tim Davis, as stated in the book.\n\n  For production, use CXSparse instead.  In particular, both CSparse and\n  CXSparse have the same include filename: `cs.h`.  This package is used for\n  the built-in DMPERM in MATLAB.\n\n  author: Tim Davis\n\n* `CXSparse`\n\n  CSparse Extended.  Includes support for complex matrices and both int or long\n  integers.  Use this instead of CSparse for production use; it creates a\n  libcsparse.so (or dylib on the Mac) with the same name as CSparse.  It is a\n  superset of CSparse.  Any code that links against CSparse should also be able\n  to link against CXSparse instead.\n\n  author: Tim Davis, David Bateman\n\n* `Example`\n\n  a simple package that relies on almost all of SuiteSparse\n\n* `.github`\n\n  workflows for CI testing on GitHub.\n\n* `GraphBLAS`\n\n  graph algorithms in the language of linear algebra.\n\n  https://graphblas.org\n\n  authors: Tim Davis, Joe Eaton, Corey Nolet\n\n* `include`\n\n  `make install` places user-visible include files for each package here, after\n  `make local`.\n\n* `KLU`\n\n  sparse LU factorization, primarily for circuit simulation.  Requires AMD,\n  COLAMD, and BTF.  Optionally uses CHOLMOD, CAMD, CCOLAMD, and METIS.\n\n  authors: Tim Davis, Ekanathan Palamadai\n\n* `LAGraph`\n\n  a graph algorithms library based on GraphBLAS.  See also\n  https://github.com/GraphBLAS/LAGraph\n\n  Authors: many.\n\n* `LDL`\n\n  a very concise LDL' factorization package\n\n  author: Tim Davis\n\n* `lib`\n\n  `make install` places shared libraries for each package here, after\n  `make local`.\n\n* `LICENSE.txt`\n\n  collected licenses for each package.\n\n* `Makefile`\n\n  optional, to compile all of SuiteSparse using `make`, which is used as a\n  simple wrapper for `cmake` in each subproject.\n\n  * `make`\n\n    compiles SuiteSparse libraries.  Subsequent `make install` will install\n    in `CMAKE_INSTALL_PATH` (might default to `/usr/local/lib` on Linux or Mac).\n\n  * `make local`\n\n    compiles SuiteSparse.  Subsequent `make install` will install in `./lib`,\n    `./include`.  Does not install in `CMAKE_INSTALL_PATH`.\n\n  * `make global`\n\n    compiles SuiteSparse libraries.  Subsequent `make install` will install in\n    `/usr/local/lib` (or whatever the configured `CMAKE_INSTALL_PREFIX` is).\n    Does not install in `./lib` and `./include`.\n\n  * `make install`\n\n    installs in the current directory (`./lib`, `./include`), or in\n    `/usr/local/lib` and `/usr/local/include`, (the latter defined by\n    `CMAKE_INSTALL_PREFIX`) depending on whether `make`, `make local`, or\n    `make global` has been done.\n\n  * `make uninstall`\n\n    undoes `make install`.\n\n  * `make distclean`\n\n    removes all files not in distribution, including `./bin`, `./share`,\n    `./lib`, and `./include`.\n\n  * `make purge`\n\n    same as `make distclean`.\n\n  * `make clean`\n\n    removes all files not in distribution, but keeps compiled libraries and\n    demos, `./lib`, `./share`, and `./include`.\n\n  Each individual subproject also has each of the above `make` targets.\n\n  Things you don't need to do:\n\n  * `make docs`\n\n    creates user guides from LaTeX files\n\n  * `make cov`\n\n    runs statement coverage tests (Linux only)\n\n* `MATLAB_Tools`\n\n  various m-files for use in MATLAB\n\n  author: Tim Davis (all parts)\n\n  for `spqr_rank`: author Les Foster and Tim Davis\n\n  * `Contents.m`\n\n    list of contents\n\n  * `dimacs10`\n\n    loads matrices for DIMACS10 collection\n\n  * `Factorize`\n\n    object-oriented `x=A\\b` for MATLAB\n\n  * `find_components`\n\n    finds connected components in an image\n\n  * `GEE`\n\n    simple Gaussian elimination\n\n  * `getversion.m`\n\n    determine MATLAB version\n\n  * `gipper.m`\n\n    create MATLAB archive\n\n  * `hprintf.m`\n\n    print hyperlinks in command window\n\n  * `LINFACTOR`\n\n    predecessor to `Factorize` package\n\n  * `MESHND`\n\n    nested dissection ordering of regular meshes\n\n  * `pagerankdemo.m`\n\n    illustrates how PageRank works\n\n  * `SFMULT`\n\n    `C=S*F` where `S` is sparse and `F` is full\n\n  * `shellgui`\n\n    display a seashell\n\n  * `sparseinv`\n\n    sparse inverse subset\n\n  * `spok`\n\n    check if a sparse matrix is valid\n\n  * `spqr_rank`\n\n    SPQR_RANK package.  MATLAB toolbox for rank deficient sparse matrices: null\n    spaces, reliable factorizations, etc.  With Leslie Foster, San Jose State\n    Univ.\n\n  * `SSMULT`\n\n    `C=A*B` where `A` and `B` are both sparse.\n    This was the basis for the built-in `C=A*B` in MATLAB, until it was\n    superseded by GraphBLAS in MATLAB R2021a.\n\n  * `SuiteSparseCollection`\n\n    for the SuiteSparse Matrix Collection\n\n  * `waitmex`\n\n    waitbar for use inside a mexFunction\n\n* `Mongoose`\n\n  graph partitioning.\n\n  authors: Nuri Yeralan, Scott Kolodziej, William Hager, Tim Davis\n\n* `ParU`\n\n  a parallel unsymmetric pattern multifrontal method.\n\n  Currently a pre-release.\n\n  authors: Mohsen Aznaveh and Tim Davis\n\n* `RBio`\n\n  read/write sparse matrices in Rutherford/Boeing format\n\n  author: Tim Davis\n\n* `README.md`\n\n  this file\n\n* `SPEX`\n\n  solves sparse linear systems in exact arithmetic.\n\n  Requires the GNU GMP and MPRF libraries.\n\n  This will be soon replaced by a more general package, SPEX v3 that includes\n  this method (exact sparse LU) and others (sparse exact Cholesky, and sparse\n  exact update/downdate).  The API of v3 will be changing significantly.\n\n  authors: Chris Lourenco, Jinhao Chen, Erick Moreno-Centeno,\n  Lorena Lorena Mejia Domenzain, and Tim Davis.\n\n  See https://github.com/clouren/SPEX for the latest version.\n\n* `SPQR`\n\n  sparse QR factorization.  This the built-in `qr` and `x=A\\b` in MATLAB.  Also\n  called SuiteSparseQR.\n\n  Includes two GPU libraries: `SPQR/GPUQREngine` and\n  `SPQR/SuiteSparse_GPURuntime`.\n\n  author of the CPU code: Tim Davis\n\n  author of GPU modules: Tim Davis, Nuri Yeralan, Wissam Sid-Lakhdar,\n  Sanjay Ranka\n\n* `ssget`\n\n  MATLAB interface to the SuiteSparse Matrix Collection\n\n  author: Tim Davis\n\n* `SuiteSparse_config`\n\n  library with common functions and configuration for all the above packages.\n  `CSparse`, `GraphBLAS`, `LAGraph`, and `MATLAB_Tools` do not use\n  `SuiteSparse_config`.\n\n  author: Tim Davis\n\n* `SuiteSparse_demo.m`\n\n  a demo of SuiteSparse for MATLAB\n\n* `SuiteSparse_install.m`\n\n  install SuiteSparse for MATLAB\n\n* `SuiteSparse_paths.m`\n\n  set paths for SuiteSparse MATLAB mexFunctions\n\n* `SuiteSparse_test.m`\n\n  exhaustive test for SuiteSparse in MATLAB\n\n* `UMFPACK`\n\n  sparse LU factorization.  Requires `AMD` and the `BLAS`.\n\n  This is the built-in `lu` and `x=A\\b` in MATLAB.\n\n  author: Tim Davis\n\n  algorithm design collaboration: Iain Duff\n\nRefer to each package for license, copyright, and author information.  All\ncodes are authored or co-authored by Timothy A. Davis (email: davis@tamu.edu),\nexcept for METIS (by George Karypis), `GraphBLAS/cpu_features` (by Google),\nGraphBLAS/lz4, zstd, and xxHash (by Yann Collet, now at Facebook), and\nGraphBLAS/CUDA/jitify.hpp (by NVIDIA).  Parts of GraphBLAS/CUDA are\nCopyright (c) by NVIDIA.  Please refer to each of these licenses.\n\n-----------------------------------------------------------------------------\nFor distro maintainers (Linux, homebrew, spack, R, Octave, Trilinos, ...):\n-----------------------------------------------------------------------------\n\nThanks for packaging SuiteSparse!  Here are some suggestions:\n\n* GraphBLAS takes a long time to compile because it creates many fast\n  \"FactoryKernels\" at compile-time.  If you want to reduce the compile time and\n  library size, enable the `GRAPHBLAS_COMPACT` mode, but keep the JIT compiler\n  enabled.  Then GraphBLAS will compile the kernels it needs at run-time, via\n  its JIT compiler.  Performance will be the same as the FactoryKernels once\n  the JIT kernels are compiled.  User compiled kernels are placed in\n  `~/.SuiteSparse`, by default.  You do not need to distribute the source for\n  GraphBLAS to enable the JIT compiler: just `libgraphblas.so` and\n  `GraphBLAS.h` is enough.\n\n* GraphBLAS needs OpenMP!  It's fundamentally a parallel code so please\n  distribute it with OpenMP enabled.  Performance will suffer otherwise.\n\n* CUDA acceleration:  CHOLMOD and SPQR can benefit from their CUDA kernels.  If\n  you do not have CUDA or do not want to include it in your distro, this\n  version of SuiteSparse skips the building of the `CHOLMOD_CUDA` and `SPQR_CUDA`\n  libraries, and does not link against the `GPUQREngine` and\n  `SuiteSparse_GPURuntime` libraries.\n\n-----------------------------------------------------------------------------\nHow to cite the SuiteSparse meta-package and its component packages:\n-----------------------------------------------------------------------------\n\nSuiteSparse is a meta-package of many packages, each with their own published\npapers.  To cite the whole collection, use the URLs:\n\n* https://github.com/DrTimothyAldenDavis/SuiteSparse\n* http://suitesparse.com (which is a forwarding URL\n        to https://people.engr.tamu.edu/davis/suitesparse.html)\n\nPlease also cite the specific papers for the packages you use.  This is a long\nlist; if you want a shorter list, just cite the most recent \"Algorithm XXX:\"\npapers in ACM TOMS, for each package.\n\n* For the MATLAB x=A\\b, see below for AMD, COLAMD, CHOLMOD, UMFPACK,\n    and SuiteSparseQR (SPQR).\n\n* for GraphBLAS, and C=AB in MATLAB (sparse-times-sparse):\n\n  T. A. Davis. Algorithm 1037: SuiteSparse:GraphBLAS: Parallel Graph Algorithms\n  in the Language of Sparse Linear Algebra. ACM Trans. Math.  Softw. 49, 3,\n  Article 28 (September 2023), 30 pages.  https://doi.org/10.1145/3577195\n\n  T. Davis, Algorithm 1000: SuiteSparse:GraphBLAS: graph algorithms in the\n  language of sparse linear algebra, ACM Trans on Mathematical Software, vol\n  45, no 4, Dec. 2019, Article No 44.  https://doi.org/10.1145/3322125.\n\n* for LAGraph:\n\n  G. Szárnyas et al., \"LAGraph: Linear Algebra, Network Analysis Libraries, and\n  the Study of Graph Algorithms,\" 2021 IEEE International Parallel and\n  Distributed Processing Symposium Workshops (IPDPSW), Portland, OR, USA, 2021,\n  pp. 243-252. https://doi.org/10.1109/IPDPSW52791.2021.00046.\n\n* for CSparse/CXSParse:\n\n  T. A. Davis, Direct Methods for Sparse Linear Systems, SIAM Series on the\n  Fundamentals of Algorithms, SIAM, Philadelphia, PA, 2006.\n  https://doi.org/10.1137/1.9780898718881\n\n* for SuiteSparseQR (SPQR): (also cite AMD, COLAMD):\n\n  T. A. Davis, Algorithm 915: SuiteSparseQR: Multifrontal multithreaded\n  rank-revealing sparse QR factorization, ACM Trans. on Mathematical Software,\n  38(1), 2011, pp. 8:1--8:22.  https://doi.org/10.1145/2049662.2049670\n\n* for SuiteSparseQR/GPU:\n\n  Sencer Nuri Yeralan, T. A. Davis, Wissam M. Sid-Lakhdar, and Sanjay Ranka.\n  2017. Algorithm 980: Sparse QR Factorization on the GPU.  ACM Trans. Math.\n  Softw. 44, 2, Article 17 (June 2018), 29 pages.\n  https://doi.org/10.1145/3065870\n\n* for CHOLMOD: (also cite AMD, COLAMD):\n\n  Y. Chen, T. A. Davis, W. W. Hager, and S. Rajamanickam, Algorithm 887:\n  CHOLMOD, supernodal sparse Cholesky factorization and update/downdate, ACM\n  Trans. on Mathematical Software, 35(3), 2008, pp. 22:1--22:14.\n  https://dl.acm.org/doi/abs/10.1145/1391989.1391995\n\n  T. A. Davis and W. W. Hager, Dynamic supernodes in sparse Cholesky\n  update/downdate and triangular solves, ACM Trans. on Mathematical Software,\n  35(4), 2009, pp. 27:1--27:23.  https://doi.org/10.1145/1462173.1462176\n\n* for CHOLMOD/Modify Module: (also cite AMD, COLAMD):\n\n  T. A. Davis and William W. Hager, Row Modifications of a Sparse Cholesky\n  Factorization SIAM Journal on Matrix Analysis and Applications 2005 26:3,\n  621-639.  https://doi.org/10.1137/S089547980343641X\n\n  T. A. Davis and William W. Hager, Multiple-Rank Modifications of a Sparse\n  Cholesky Factorization SIAM Journal on Matrix Analysis and Applications 2001\n  22:4, 997-1013.  https://doi.org/10.1137/S0895479899357346\n\n  T. A. Davis and William W. Hager, Modifying a Sparse Cholesky Factorization,\n  SIAM Journal on Matrix Analysis and Applications 1999 20:3, 606-627.\n  https://doi.org/10.1137/S0895479897321076\n\n* for CHOLMOD/GPU Modules:\n\n  Steven C. Rennich, Darko Stosic, Timothy A. Davis, Accelerating sparse\n  Cholesky factorization on GPUs, Parallel Computing, Vol 59, 2016, pp 140-150.\n  https://doi.org/10.1016/j.parco.2016.06.004\n\n* for AMD and CAMD:\n\n  P. Amestoy, T. A. Davis, and I. S. Duff, Algorithm 837: An approximate\n  minimum degree ordering algorithm, ACM Trans. on Mathematical Software,\n  30(3), 2004, pp. 381--388.\n  https://dl.acm.org/doi/abs/10.1145/1024074.1024081\n\n  P. Amestoy, T. A. Davis, and I. S. Duff, An approximate minimum degree\n  ordering algorithm, SIAM J. Matrix Analysis and Applications, 17(4), 1996,\n  pp. 886--905.  https://doi.org/10.1137/S0895479894278952\n\n* for COLAMD, SYMAMD, CCOLAMD, and CSYMAMD:\n\n  T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, Algorithm 836:  COLAMD, an\n  approximate column minimum degree ordering algorithm, ACM Trans. on\n  Mathematical Software, 30(3), 2004, pp. 377--380.\n  https://doi.org/10.1145/1024074.1024080\n\n  T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, A column approximate minimum\n  degree ordering algorithm, ACM Trans. on Mathematical Software, 30(3), 2004,\n  pp. 353--376.  https://doi.org/10.1145/1024074.1024079\n\n* for UMFPACK: (also cite AMD and COLAMD):\n\n  T. A. Davis, Algorithm 832:  UMFPACK - an unsymmetric-pattern multifrontal\n  method with a column pre-ordering strategy, ACM Trans. on Mathematical\n  Software, 30(2), 2004, pp. 196--199.\n  https://dl.acm.org/doi/abs/10.1145/992200.992206\n\n  T. A. Davis, A column pre-ordering strategy for the unsymmetric-pattern\n  multifrontal method, ACM Trans. on Mathematical Software, 30(2), 2004, pp.\n  165--195.  https://dl.acm.org/doi/abs/10.1145/992200.992205\n\n  T. A. Davis and I. S. Duff, A combined unifrontal/multifrontal method for\n  unsymmetric sparse matrices, ACM Trans. on Mathematical Software, 25(1),\n  1999, pp. 1--19.  https://doi.org/10.1145/305658.287640\n\n  T. A. Davis and I. S. Duff, An unsymmetric-pattern multifrontal method for\n  sparse LU factorization, SIAM J. Matrix Analysis and Computations, 18(1),\n  1997, pp. 140--158.  https://doi.org/10.1137/S0895479894246905\n\n* for the FACTORIZE m-file:\n\n  T. A. Davis, Algorithm 930: FACTORIZE, an object-oriented linear system\n  solver for MATLAB, ACM Trans. on Mathematical Software, 39(4), 2013, pp.\n  28:1-28:18.  https://doi.org/10.1145/2491491.2491498\n\n* for KLU and BTF (also cite AMD and COLAMD):\n\n  T. A. Davis and Ekanathan Palamadai Natarajan. 2010. Algorithm 907: KLU, A\n  Direct Sparse Solver for Circuit Simulation Problems. ACM Trans.  Math.\n  Softw. 37, 3, Article 36 (September 2010), 17 pages.\n  https://dl.acm.org/doi/abs/10.1145/1824801.1824814\n\n* for LDL:\n\n  T. A. Davis. Algorithm 849: A concise sparse Cholesky factorization package.\n  ACM Trans. Math. Softw. 31, 4 (December 2005), 587–591.\n  https://doi.org/10.1145/1114268.1114277\n\n* for ssget and the SuiteSparse Matrix Collection:\n\n  T. A. Davis and Yifan Hu. 2011. The University of Florida sparse matrix\n  collection. ACM Trans. Math. Softw. 38, 1, Article 1 (November 2011), 25\n  pages.  https://doi.org/10.1145/2049662.2049663\n\n  Kolodziej et al., (2019). The SuiteSparse Matrix Collection Website\n  Interface. Journal of Open Source Software, 4(35), 1244.\n  https://doi.org/10.21105/joss.01244\n\n* for `spqr_rank`:\n\n  Leslie V. Foster and T. A. Davis. 2013. Algorithm 933: Reliable calculation\n  of numerical rank, null space bases, pseudoinverse solutions, and basic\n  solutions using suitesparseQR. ACM Trans. Math.  Softw. 40, 1, Article 7\n  (September 2013), 23 pages.  https://doi.org/10.1145/2513109.2513116\n\n* for Mongoose:\n\n  T. A. Davis, William W. Hager, Scott P. Kolodziej, and S. Nuri Yeralan.\n  2020. Algorithm 1003: Mongoose, a Graph Coarsening and Partitioning Library.\n  ACM Trans. Math. Softw. 46, 1, Article 7 (March 2020), 18 pages.\n  https://doi.org/10.1145/3337792\n\n* for SPEX:\n\n  Christopher Lourenco, Jinhao Chen, Erick Moreno-Centeno, and T. A.  Davis.\n  2022. Algorithm 1021: SPEX Left LU, Exactly Solving Sparse Linear Systems via\n  a Sparse Left-Looking Integer-Preserving LU Factorization. ACM Trans. Math.\n  Softw. June 2022.  https://doi.org/10.1145/3519024\n\n-----------------------------------------------------------------------------\nAbout the BLAS and LAPACK libraries\n-----------------------------------------------------------------------------\n\nNOTE: if you use OpenBLAS, be sure to use version 0.3.27 or later.\n\nTo select your BLAS/LAPACK, see the instructions in SuiteSparseBLAS.cmake in\n`SuiteSparse_config/cmake_modules`.  If `SuiteSparse_config` finds a BLAS with\n64-bit integers (such as the Intel MKL ilp64 BLAS), it configures\n`SuiteSparse_config.h` with the `SUITESPARSE_BLAS_INT` defined as `int64_t`.\nOtherwise, if a 32-bit BLAS is found, this type is defined as `int32_t`.  If\nlater on, UMFPACK, CHOLMOD, or SPQR are compiled and linked  with a BLAS that\nhas a different integer size, you must override the definition with `-DBLAS64`\n(to assert the use of 64-bit integers in the BLAS) or `-DBLAS32`, (to assert\nthe use of 32-bit integers in the BLAS).\n\nThe size of the BLAS integer has nothing to do with `sizeof(void *)`.\n\nWhen distributed in a binary form (such as a Debian, Ubuntu, Spack, or Brew\npackage), SuiteSparse should probably be compiled to expect a 32-bit BLAS,\nsince this is the most common case.  The default is to use a 32-bit BLAS, but\nthis can be changed by setting the cmake variable\n`SUITESPARSE_USE_64BIT_BLAS` to `ON`.\n\nBy default, SuiteSparse hunts for a suitable BLAS library.  To enforce a\nparticular BLAS library use either:\n\n    CMAKE_OPTIONS=\"-DBLA_VENDOR=OpenBLAS\" make\n    cd Package ; cmake -DBLA_VENDOR=OpenBLAS .. make\n\nTo use the default (hunt for a BLAS), do not set `BLA_VENDOR`, or set it to\nan empty string.  In this case, if `SUITESPARSE_USE_64BIT_BLAS` is ON,\npreference is given to a 64-bit BLAS, but a 32-bit BLAS library will be used if\nno 64-bit library is found.  However, if both `SUITESPARSE_USE_64BIT_BLAS` and\n`SUITESPARSE_USE_STRICT` are ON, then only a 64-bit BLAS is considered.\n\nWhen selecting a particular BLAS library, the `SUITESPARSE_USE_64BIT_BLAS`\nsetting is strictly followed.  If set to true, only a 64-bit BLAS library will\nbe used.  If false (the default), only a 32-bit BLAS library will be used.  If\nno such BLAS is found, the build will fail.\n\n-----------------------------------------------------------------------------\nQUICK START FOR THE C/C++ LIBRARIES:\n-----------------------------------------------------------------------------\n\nType the following in this directory (requires system priviledge to do the\n`sudo make install`):\n```\n    mkdir -p build \u0026\u0026 cd build\n    cmake ..\n    cmake --build .\n    sudo cmake --install .\n```\n\nAll libraries will be created and installed into the default system-wide folder\n(/usr/local/lib on Linux).  All include files needed by the applications that\nuse SuiteSparse are installed into /usr/local/include/suitesparse (on Linux).\n\nTo build only a subset of libraries, set `SUITESPARSE_ENABLE_PROJECTS` when\nconfiguring with CMake.  E.g., to build and install CHOLMOD and CXSparse\n(including their dependencies), use the following commands:\n```\n    mkdir -p build \u0026\u0026 cd build\n    cmake -DSUITESPARSE_ENABLE_PROJECTS=\"cholmod;cxsparse\" ..\n    cmake --build .\n    sudo cmake --install .\n```\n\nFor Windows (MSVC), import the `CMakeLists.txt` file into MS Visual Studio.\nBe sure to specify the build type as Release; for example, to build SuiteSparse\non Windows in the command window, run:\n```\n    mkdir -p build \u0026\u0026 cd build\n    cmake ..\n    cmake --build . --config Release\n    cmake --install .\n```\n\nBe sure to first install all required libraries:  BLAS and LAPACK for UMFPACK,\nCHOLMOD, and SPQR, and GMP and MPFR for SPEX.  Be sure to use the latest\nlibraries; SPEX requires MPFR 4.0.2 and GMP 6.1.2 (these version numbers\ndo NOT correspond to the X.Y.Z suffix of libgmp.so.X.Y.Z and libmpfr.so.X.Y.Z;\nsee the SPEX user guide for details).\n\nTo compile the libraries and install them only in SuiteSparse/lib (not\n/usr/local/lib), do this instead in the top-level of SuiteSparse:\n```\n    mkdir -p build \u0026\u0026 cd build\n    cmake -DCMAKE_INSTALL_PREFIX=.. ..\n    cmake --build .\n    cmake --install .\n```\n\nIf you add /home/me/SuiteSparse/lib to your library search path\n(`LD_LIBRARY_PATH` in Linux), you can do the following (for example):\n```\n    S = /home/me/SuiteSparse\n    cc myprogram.c -I$(S)/include/suitesparse -lumfpack -lamd -lcholmod -lsuitesparseconfig -lm\n```\n\nTo change the C and C++ compilers, and to compile in parallel use:\n```\n    cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER==g++ ..\n```\n\nfor example, which changes the compiler to gcc and g++.\n\nThis will work on Linux/Unix and the Mac.  It should automatically detect if\nyou have the Intel compilers or not, and whether or not you have CUDA.\n\nSee `SuiteSparse_config/cmake_modules/SuiteSparsePolicy.cmake` to select your BLAS.\n\nYou may also need to add SuiteSparse/lib to your path.  If your copy of\nSuiteSparse is in /home/me/SuiteSparse, for example, then add this to your\n`~/.bashrc` file:\n\n```\nLD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/me/SuiteSparse/lib\nexport LD_LIBRARY_PATH\n```\n\nFor the Mac, use this instead:\n```\nDYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/home/me/SuiteSparse/lib\nexport DYLD_LIBRARY_PATH\n```\n\nDefault install location of files is below, where PACKAGE is one of the\npackages in SuiteSparse:\n\n    * `CMAKE_INSTALL_PREFIX/include/suitesparse/`: include files\n    * `CMAKE_INSTALL_PREFIX/lib/`: compiled libraries\n    * `CMAKE_INSTALL_PREFIX/lib/cmake/SuiteSparse/`: `*.cmake` scripts\n        for all of SuiteSparse\n    * `CMAKE_INSTALL_PREFIX/lib/cmake/PACKAGE/`: `*Config.cmake` scripts for a\n        specific package\n    * `CMAKE_INSTALL_PREFIX/lib/pkgconfig/PACKAGE.pc`: `.pc` scripts for\n        a specific package pkgconfig\n\n-----------------------------------------------------------------------------\nQUICK START FOR MATLAB USERS (Linux or Mac):\n-----------------------------------------------------------------------------\n\nSuppose you place SuiteSparse in the `/home/me/SuiteSparse` folder.\n\nAdd the `SuiteSparse/lib` folder to your run-time library path.  On Linux, add\nthis to your `~/.bashrc` script, assuming `/home/me/SuiteSparse` is the\nlocation of your copy of SuiteSparse:\n```\n    LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/me/SuiteSparse/lib\n    export LD_LIBRARY_PATH\n```\n\nFor the Mac, use this instead, in your `~/.zshrc` script, assuming you place\nSuiteSparse in `/Users/me/SuiteSparse`:\n```\n    DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/Users/me/SuiteSparse/lib\n    export DYLD_LIBRARY_PATH\n```\n\nCompile all of SuiteSparse with `make local`.\n\nNext, compile the GraphBLAS MATLAB library.  In the system shell while in the\nSuiteSparse folder, type `make gbmatlab` if you want to install it system-wide\nwith `make install`, or `make gblocal` if you want to use the library in\nyour own SuiteSparse/lib.\n\nThen in the MATLAB Command Window, cd to the SuiteSparse directory and type\n`SuiteSparse_install`.  All packages will be compiled, and several demos will be\nrun.  To run a (long!) exhaustive test, do `SuiteSparse_test`.\n\nSave your MATLAB path for future sessions with the MATLAB pathtool or savepath\ncommands.  If those methods fail because you don't have system-wide permission,\nadd the new paths to your startup.m file, normally in\nDocuments/MATLAB/startup.m.  You can also use the `SuiteSparse_paths` m-file to\nset all your paths at the start of each MATLAB session.\n\n-----------------------------------------------------------------------------\nCompilation options\n-----------------------------------------------------------------------------\n\nYou can set specific options for CMake with the command (for example):\n```\n    cmake -DCHOLMOD_PARTITION=OFF -DBUILD_STATIC_LIBS=OFF -DCMAKE_BUILD_TYPE=Debug ..\n```\n\nThat command will compile all of SuiteSparse except for CHOLMOD/Partition\nModule (because of `-DCHOLMOD_PARTITION=OFF`).  Debug mode will be used (the\nbuild type).  The static libraries will not be built (since\n`-DBUILD_STATIC_LIBS=OFF` is set).\n\n* `SUITESPARSE_ENABLE_PROJECTS`:\n\n  Semicolon separated list of projects to be built or `all`.\n  Default: `all` in which case the following projects are built:\n\n  `suitesparse_config;mongoose;amd;btf;camd;ccolamd;colamd;cholmod;cxsparse;ldl;klu;umfpack;paru;rbio;spqr;spex;graphblas;lagraph`\n\n  Additionally, `csparse` can be included in that list to build CSparse.\n\n* `CMAKE_BUILD_TYPE`:\n\n  Default: `Release`, use `Debug` for debugging.\n\n* `SUITESPARSE_USE_STRICT`:\n\n  SuiteSparse has many user-definable settings of the form `SUITESPARSE_USE_*`\n  or `(package)_USE_*` for some particular package.  In general, these settings\n  are not strict.  For example, if `SUITESPARSE_USE_OPENMP` is `ON` then OpenMP\n  is preferred, but SuiteSparse can be used without OpenMP so no error is\n  generated if OpenMP is not found.  However, if `SUITESPARSE_USE_STRICT` is\n  `ON` then all `*_USE_*` settings are treated strictly and an error occurs\n  if any are set to `ON` but the corresponding package or setting is not\n  available.  The `*_USE_SYSTEM_*` settings are always treated as strict.\n  Default: `OFF`.\n\n* `SUITESPARSE_USE_CUDA`:\n\n  If set to `ON`, CUDA is enabled for all of SuiteSparse.  Default: `ON`,\n\n  CUDA on Windows with MSVC appears to be working with this release, but it\n  should be considered as a prototype and may not be fully functional.  I have\n  limited resources for testing CUDA on Windows.  If you encounter issues,\n  disable CUDA and post this as an issue on GitHub.\n\n* `CHOLMOD_USE_CUDA`:\n\n  Default: `ON`.  Both `SUITESPARSE_USE_CUDA` and `CHOLMOD_USE_CUDA` must be\n  enabled to use CUDA in CHOLMOD.\n\n* `SPQR_USE_CUDA`:\n\n  Default: `ON`.  Both `SUITESPARSE_USE_CUDA` and `SPQR_USE_CUDA` must be\n  enabled to use CUDA in SPQR.\n\n* `CMAKE_INSTALL_PREFIX`:\n\n  Defines the install location (default on Linux is `/usr/local`).  For example,\n  this command while in a folder `build` in the top level SuiteSparse folder\n  will set the install directory to `/stuff`, used by the subsequent\n  `sudo cmake --install .`:\n```\n    cmake -DCMAKE_INSTALL_PREFIX=/stuff ..\n    sudo cmake --install .\n```\n\n* `SUITESPARSE_PKGFILEDIR`:\n\n  Directory where CMake Config and pkg-config files will be installed.  By\n  default, CMake Config files will be installed in the subfolder `cmake` of the\n  directory where the (static) libraries will be installed (e.g., `lib`).  The\n  `.pc` files for pkg-config will be installed in the subfolder `pkgconfig` of\n  the directory where the (static) libraries will be installed.\n\n  This option allows to install them at a location different from the (static)\n  libraries.  This allows to install multiple configurations of the SuiteSparse\n  libraries at the same time (e.g., by also setting a different\n  `CMAKE_RELEASE_POSTFIX` and `CMAKE_INSTALL_LIBDIR` for each of them).  To pick\n  up the respective configuration in downstream projects, set, e.g.,\n  `CMAKE_PREFIX_PATH` (for CMake) or `PKG_CONFIG_PATH` (for build systems using\n  pkg-config) to the path containing the respective CMake Config files or\n  pkg-config files.\n\n* `SUITESPARSE_INCLUDEDIR_POSTFIX`:\n\n  Postfix for installation target of header from SuiteSparse. Default:\n  suitesparse, so the default include directory is:\n  `CMAKE_INSTALL_PREFIX/include/suitesparse`\n\n* `BUILD_SHARED_LIBS`:\n\n  If `ON`, shared libraries are built.\n  Default: `ON`.\n\n* `BUILD_STATIC_LIBS`:\n\n  If `ON`, static libraries are built.\n  Default: `ON`, except for GraphBLAS, which takes a long time to compile so\n  the default for GraphBLAS is `OFF` unless `BUILD_SHARED_LIBS` is `OFF`.\n\n* `SUITESPARSE_CUDA_ARCHITECTURES`:\n\n  A string, such as `\"all\"` or `\"35;50;75;80\"` that lists the CUDA\n  architectures to use when compiling CUDA kernels with `nvcc`.  The `\"all\"`\n  option requires CMake 3.23 or later.  Default: `\"52;75;80\"`.\n\n* `BLA_VENDOR`:\n\n  A string.  Leave unset, or use `\"ANY\"` to select any BLAS library (the\n  default).  Or set to the name of a `BLA_VENDOR` defined by FindBLAS.cmake.\n  See:\n  https://cmake.org/cmake/help/latest/module/FindBLAS.html#blas-lapack-vendors\n\n* `SUITESPARSE_USE_64BIT_BLAS`:\n\n  If `ON`, look for a 64-bit BLAS.  If `OFF`: 32-bit only.  Default: `OFF`.\n\n* `SUITESPARSE_USE_PYTHON`:\n\n  If `ON`, build Python interfaces for any package in SuiteSparse that has\n  one (currently only SPEX).  If `OFF`: do not build any Python interface.\n  Default: `ON`.\n\n* `SUITESPARSE_USE_OPENMP`:\n\n  If `ON`, OpenMP is used by default if it is available.  Default: `ON`.\n\n  GraphBLAS, LAGraph, and ParU will be vastly slower if OpenMP is not used.\n  CHOLMOD will be somewhat slower without OpenMP (as long as it still has a\n  parallel BLAS/LAPACK).  Three packages (UMFPACK, CHOLMOD, and SPQR) rely\n  heavily on parallel BLAS/LAPACK libraries and those libraries may use OpenMP\n  internally.  If you wish to disable OpenMP in an entire application, select a\n  single-threaded BLAS/LAPACK, or a parallel BLAS/LAPACK that does not use\n  OpenMP (such as the Apple Accelerate Framework).  Using a single-threaded\n  BLAS/LAPACK library will cause UMFPACK, CHOLMOD, and SPQR to be vastly\n  slower.\n\n  WARNING: GraphBLAS may not be thread-safe if built without OpenMP or pthreads\n  (see the GraphBLAS User Guide for details).\n\n* `SUITESPARSE_CONFIG_USE_OPENMP`:\n\n  If `ON`, `SuiteSparse_config` uses OpenMP if it is available.\n  Default: `SUITESPARSE_USE_OPENMP`.\n  It is not essential and only used to let `SuiteSparse_time` call\n  `omp_get_wtime`.\n\n* `CHOLMOD_USE_OPENMP`:\n\n  If `ON`, OpenMP is used in CHOLMOD if it is available.\n  Default: `SUITESPARSE_USE_OPENMP`.\n\n* `GRAPHBLAS_USE_OPENMP`:\n\n  If `ON`, OpenMP is used in GraphBLAS if it is available.\n  Default: `SUITESPARSE_USE_OPENMP`.\n\n* `LAGRAPH_USE_OPENMP`:\n\n  If `ON`, OpenMP is used in LAGraph if it is available.\n  Default: `SUITESPARSE_USE_OPENMP`.\n\n* `PARU_USE_OPENMP`:\n\n  If `ON`, OpenMP is used in ParU if it is available.\n  Default: `SUITESPARSE_USE_OPENMP`.\n\n* `SPEX_USE_OPENMP`:\n\n  If `ON`, OpenMP is used in SPEX if it is available.\n  Default: `SUITESPARSE_USE_OPENMP`.\n\n* `SUITESPARSE_DEMOS`:\n\n  If `ON`, build the demo programs for each package.  Default: `OFF`.\n\n* `SUITESPARSE_USE_SYSTEM_BTF`:\n\n  If `ON`, use BTF libraries installed on the build system. If `OFF`,\n  automatically build BTF as dependency if needed. Default: `OFF`.\n\n* `SUITESPARSE_USE_SYSTEM_CHOLMOD`:\n\n  If `ON`, use CHOLMOD libraries installed on the build system. If `OFF`,\n  automatically build CHOLMOD as dependency if needed. Default: `OFF`.\n\n* `SUITESPARSE_USE_SYSTEM_AMD`:\n\n  If `ON`, use AMD libraries installed on the build system. If `OFF`,\n  automatically build AMD as dependency if needed. Default: `OFF`.\n\n* `SUITESPARSE_USE_SYSTEM_COLAMD`:\n\n  If `ON`, use COLAMD libraries installed on the build system. If `OFF`,\n  automatically build COLAMD as dependency if needed. Default: `OFF`.\n\n* `SUITESPARSE_USE_SYSTEM_CAMD`:\n\n  If `ON`, use CAMD libraries installed on the build system. If `OFF`,\n  automatically build CAMD as dependency if needed. Default: `OFF`.\n\n* `SUITESPARSE_USE_SYSTEM_CCOLAMD`:\n\n  If `ON`, use CCOLAMD libraries installed on the build system. If `OFF`,\n  automatically build CCOLAMD as dependency if needed. Default: `OFF`.\n\n* `SUITESPARSE_USE_SYSTEM_GRAPHBLAS`:\n\n  If `ON`, use GraphBLAS libraries installed on the build system. If `OFF`,\n  automatically build GraphBLAS as dependency if needed. Default: `OFF`.\n\n* `SUITESPARSE_USE_SYSTEM_SUITESPARSE_CONFIG`:\n\n  If `ON`, use `SuiteSparse_config` libraries installed on the build system. If\n  `OFF`, automatically build `SuiteSparse_config` as dependency if needed.\n  Default: `OFF`.\n\n* `SUITESPARSE_USE_FORTRAN`\n\n  If `ON`, use the Fortran compiler to determine how C calls Fortan, and to\n  build several optional Fortran routines. If `OFF`, use\n  `SUITESPARSE_C_TO_FORTRAN` to define how C calls Fortran.\n  Default: `ON`.\n\n* `SUITESPARSE_C_TO_FORTRAN`\n\n  A string that defines how C calls Fortran (i.e., functions exported by the\n  BLAS library).  This setting is used if no working Fortran compiler could be\n  detected or `SUITESPARSE_USE_FORTRAN` is set to `OFF`.  This string is to be\n  read as the argument list and the body of a preprocessor macro.  The first\n  argument to that macro is any Fortran function name in lowercase letters.\n  The second argument is the same function name in uppercase letters.  The body\n  defines by which function name Fortran functions are called.  This is\n  necessary because Fortran is case-insensitive, and different Fortran\n  compilers use different name mangling conventions.  If a MSVC C/C++ compiler\n  is used, this defaults to `\"(name,NAME) name\"` (i.e., lower case without\n  trailing underscore).  That is the name mangling convention for the Intel\n  Fortran compiler on Windows.  If any other C/C++ compilers are used, this\n  defaults to `\"(name,NAME) name##_\"` (i.e., lower case with trailing\n  underscore).  That is the name mangling convention for most of the commonly\n  used Fortran compilers (like `ifx` on platforms other than Windows,\n  `gfortran`, `flang`, ...).  The latter name mangling convention is also used\n  by default by OpenBLAS (independent on the platform or the compiler used to\n  build OpenBLAS).  You might need to configure with\n  `-DSUITESPARSE_C_TO_FORTRAN=\"(name,NAME) name##_\"` if you'd like to build\n  SuiteSparse using a MSVC compiler and link to OpenBLAS.\n\nAdditional options are available for specific packages:\n\n* `UMFPACK_USE_CHOLMOD`:\n\n  If `ON`, UMFPACK uses CHOLMOD for additional (optional)\n  ordering options.  Default: `ON`.\n\n* `KLU_USE_CHOLMOD`:\n\n  If `ON`, KLU uses CHOLMOD for additional (optional)\n  ordering options.  Default: `ON`.\n\nCHOLMOD is composed of a set of Modules that can be independently selected;\nall options default to `ON`:\n\n* `CHOLMOD_GPL`\n\n  If `OFF`, do not build any GPL-licensed module (MatrixOps, Modify, Supernodal,\n  and GPU modules)\n\n* `CHOLMOD_CHECK`\n\n  If `OFF`, do not build the Check module.\n\n* `CHOLMOD_MATRIXOPS`\n\n  If `OFF`, do not build the MatrixOps module.\n\n* `CHOLMOD_CHOLESKY`\n  If `OFF`, do not build the Cholesky module. This also disables the Supernodal\n  and Modify modules.\n\n* `CHOLMOD_MODIFY`\n\n  If `OFF`, do not build the Modify module.\n\n* `CHOLMOD_CAMD`\n\n  If `OFF`, do not link against CAMD and CCOLAMD. This also disables the\n  Partition module.\n\n* `CHOLMOD_PARTITION`\n\n  If `OFF`, do not build the Partition module.\n\n* `CHOLMOD_SUPERNODAL`\n\n  If `OFF`, do not build the Supernodal module.\n\n-----------------------------------------------------------------------------\nPossible build/install issues\n-----------------------------------------------------------------------------\n\nOne common issue can affect all packages:  getting the right #include files\nthat match the current libraries being built.  It's possible that your Linux\ndistro has an older copy of SuiteSparse headers in /usr/include or\n/usr/local/include, or that Homebrew has installed its suite-sparse bundle into\n/opt/homebrew/include or other places.  Old libraries can appear in in\n/usr/local/lib, /usr/lib, etc.  When building a new copy of SuiteSparse, the\ncmake build system is normally (or always?) able to avoid these, and use the\nright header for the right version of each library.\n\nAs an additional guard against this possible error, each time one SuiteSparse\npackage #include's a header from another one, it checks the version number in\nthe header file, and reports an #error to the compiler if a stale version is\ndetected.  In addition, the Example package checks both the header version and\nthe library version (by calling a function in each library).  If the versions\nmismatch in any way, the Example package reports an error at run time.\n\nFor example, CHOLMOD 5.1.0 requires AMD 3.3.0 or later.  If it detects an\nolder one in `amd.h`, it will report an `#error`:\n\n```\n    #include \"amd.h\"\n    #if ( ... AMD version is stale ... )\n    #error \"CHOLMOD 5.1.0 requires AMD 3.3.0 or later\"\n    #endif\n```\n\nand the compilation will fail.  The Example package makes another check,\nby calling `amd_version` and comparing it with the versions from the `amd.h`\nheader file.\n\nIf this error or one like it occurs, check to see if you have an old copy of\nSuiteSparse, and uninstall it before compiling your new copy of SuiteSparse.\n\nThere are other many possible build/install issues that are covered by the\ncorresponding user guides for each package, such as finding the right BLAS,\nOpenMP, and other libraries, and how to compile on the Mac when using GraphBLAS\ninside MATLAB, and so on.  Refer to the User Guides for more details.\n\n-----------------------------------------------------------------------------\nInterfaces to SuiteSparse\n-----------------------------------------------------------------------------\n\nMATLAB/Octave/R/Mathematica interfaces:\n\n  Many built-in methods in MATLAB and Octave rely on SuiteSparse, including\n  `C=A*B` `x=A\\b`, `L=chol(A)`, `[L,U,P,Q]=lu(A)`, `R=qr(A)`, `dmperm(A)`,\n  `p=amd(A)`, `p=colamd(A)`, ...\n  See also Mathematica, R, and many many more.  The list is too long.\n\nJulia interface:\n\n  https://github.com/JuliaSparse/SparseArrays.jl\n\nPython interface to GraphBLAS by Anaconda and NVIDIA:\n\n  https://pypi.org/project/python-graphblas\n\nIntel's Go interface to GraphBLAS:\n\n  https://pkg.go.dev/github.com/intel/forGraphBLASGo\n\nSee scikit-sparse and scikit-umfpack for the Python interface via SciPy:\n\n  https://github.com/scikit-sparse/scikit-sparse\n  https://github.com/scikit-umfpack/scikit-umfpack\n\nSee math.js by Jos de Jong for a JavaScript port of CSparse:\n\n  https://github.com/josdejong/mathjs\n\nSee russell for a Rust interface:\n\n  https://github.com/cpmech/russell\n\n-----------------------------------------------------------------------------\nAcknowledgements\n-----------------------------------------------------------------------------\n\nMarkus Mützel contributed the most recent update of the SuiteSparse build\nsystem for all SuiteSparse packages, extensively porting it and modernizing it.\n\nI would also like to thank François Bissey, Sebastien Villemot, Erik Welch, Jim\nKitchen, and Fabian Wein for their valuable feedback on the\nSuiteSparse build system and how it works with various Linux / Python distros\nand other package managers.  If you are a maintainer of a SuiteSparse packaging\nfor a Linux distro, conda-forge, R, spack, brew, vcpkg, etc, please feel free\nto contact me if there's anything I can do to make your life easier.\nI would also like to thank Raye Kimmerer for adding support for 32-bit\nrow/column indices in SPQR v4.2.0.\n\nSee also the various Acknowledgements within each package.\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdrtimothyaldendavis%2Fsuitesparse","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fdrtimothyaldendavis%2Fsuitesparse","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdrtimothyaldendavis%2Fsuitesparse/lists"}