/usr/include/suitesparse/cholmod_supernodal.h is in libsuitesparse-dev 1:5.1.2-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 | /* ========================================================================== */
/* === Include/cholmod_supernodal.h ========================================= */
/* ========================================================================== */
/* -----------------------------------------------------------------------------
* CHOLMOD/Include/cholmod_supernodal.h.
* Copyright (C) 2005-2006, Timothy A. Davis
* http://www.suitesparse.com
* -------------------------------------------------------------------------- */
/* CHOLMOD Supernodal module.
*
* Supernodal analysis, factorization, and solve. The simplest way to use
* these routines is via the Cholesky module. It does not provide any
* fill-reducing orderings, but does accept the orderings computed by the
* Cholesky module. It does not require the Cholesky module itself, however.
*
* Primary routines:
* -----------------
* cholmod_super_symbolic supernodal symbolic analysis
* cholmod_super_numeric supernodal numeric factorization
* cholmod_super_lsolve supernodal Lx=b solve
* cholmod_super_ltsolve supernodal L'x=b solve
*
* Prototypes for the BLAS and LAPACK routines that CHOLMOD uses are listed
* below, including how they are used in CHOLMOD.
*
* BLAS routines:
* --------------
* dtrsv solve Lx=b or L'x=b, L non-unit diagonal, x and b stride-1
* dtrsm solve LX=B or L'X=b, L non-unit diagonal
* dgemv y=y-A*x or y=y-A'*x (x and y stride-1)
* dgemm C=A*B', C=C-A*B, or C=C-A'*B
* dsyrk C=tril(A*A')
*
* LAPACK routines:
* ----------------
* dpotrf LAPACK: A=chol(tril(A))
*
* Requires the Core module, and two external packages: LAPACK and the BLAS.
* Optionally used by the Cholesky module.
*/
#ifndef CHOLMOD_SUPERNODAL_H
#define CHOLMOD_SUPERNODAL_H
#include "cholmod_core.h"
/* -------------------------------------------------------------------------- */
/* cholmod_super_symbolic */
/* -------------------------------------------------------------------------- */
/* Analyzes A, AA', or A(:,f)*A(:,f)' in preparation for a supernodal numeric
* factorization. The user need not call this directly; cholmod_analyze is
* a "simple" wrapper for this routine.
*/
int cholmod_super_symbolic
(
/* ---- input ---- */
cholmod_sparse *A, /* matrix to analyze */
cholmod_sparse *F, /* F = A' or A(:,f)' */
int *Parent, /* elimination tree */
/* ---- in/out --- */
cholmod_factor *L, /* simplicial symbolic on input,
* supernodal symbolic on output */
/* --------------- */
cholmod_common *Common
) ;
int cholmod_l_super_symbolic (cholmod_sparse *, cholmod_sparse *,
SuiteSparse_long *, cholmod_factor *, cholmod_common *) ;
/* -------------------------------------------------------------------------- */
/* cholmod_super_symbolic2 */
/* -------------------------------------------------------------------------- */
/* Analyze for supernodal Cholesky or multifrontal QR */
int cholmod_super_symbolic2
(
/* ---- input ---- */
int for_whom, /* FOR_SPQR (0): for SPQR but not GPU-accelerated
FOR_CHOLESKY (1): for Cholesky (GPU or not)
FOR_SPQRGPU (2): for SPQR with GPU acceleration */
cholmod_sparse *A, /* matrix to analyze */
cholmod_sparse *F, /* F = A' or A(:,f)' */
int *Parent, /* elimination tree */
/* ---- in/out --- */
cholmod_factor *L, /* simplicial symbolic on input,
* supernodal symbolic on output */
/* --------------- */
cholmod_common *Common
) ;
int cholmod_l_super_symbolic2 (int, cholmod_sparse *, cholmod_sparse *,
SuiteSparse_long *, cholmod_factor *, cholmod_common *) ;
/* -------------------------------------------------------------------------- */
/* cholmod_super_numeric */
/* -------------------------------------------------------------------------- */
/* Computes the numeric LL' factorization of A, AA', or A(:,f)*A(:,f)' using
* a BLAS-based supernodal method. The user need not call this directly;
* cholmod_factorize is a "simple" wrapper for this routine.
*/
int cholmod_super_numeric
(
/* ---- input ---- */
cholmod_sparse *A, /* matrix to factorize */
cholmod_sparse *F, /* F = A' or A(:,f)' */
double beta [2], /* beta*I is added to diagonal of matrix to factorize */
/* ---- in/out --- */
cholmod_factor *L, /* factorization */
/* --------------- */
cholmod_common *Common
) ;
int cholmod_l_super_numeric (cholmod_sparse *, cholmod_sparse *, double *,
cholmod_factor *, cholmod_common *) ;
/* -------------------------------------------------------------------------- */
/* cholmod_super_lsolve */
/* -------------------------------------------------------------------------- */
/* Solve Lx=b where L is from a supernodal numeric factorization. The user
* need not call this routine directly. cholmod_solve is a "simple" wrapper
* for this routine. */
int cholmod_super_lsolve
(
/* ---- input ---- */
cholmod_factor *L, /* factor to use for the forward solve */
/* ---- output ---- */
cholmod_dense *X, /* b on input, solution to Lx=b on output */
/* ---- workspace */
cholmod_dense *E, /* workspace of size nrhs*(L->maxesize) */
/* --------------- */
cholmod_common *Common
) ;
int cholmod_l_super_lsolve (cholmod_factor *, cholmod_dense *, cholmod_dense *,
cholmod_common *) ;
/* -------------------------------------------------------------------------- */
/* cholmod_super_ltsolve */
/* -------------------------------------------------------------------------- */
/* Solve L'x=b where L is from a supernodal numeric factorization. The user
* need not call this routine directly. cholmod_solve is a "simple" wrapper
* for this routine. */
int cholmod_super_ltsolve
(
/* ---- input ---- */
cholmod_factor *L, /* factor to use for the backsolve */
/* ---- output ---- */
cholmod_dense *X, /* b on input, solution to L'x=b on output */
/* ---- workspace */
cholmod_dense *E, /* workspace of size nrhs*(L->maxesize) */
/* --------------- */
cholmod_common *Common
) ;
int cholmod_l_super_ltsolve (cholmod_factor *, cholmod_dense *, cholmod_dense *,
cholmod_common *) ;
#endif
|