--- inst/include/Matrix/cholmod.h 2024-08-30 23:28:08 +++ inst/include/Matrix/cholmod.h-patched.h 2024-08-30 23:07:12 @@ -46,8 +46,8 @@ // CHOLMOD's Partition Module. // ----------------------------------------------------------------------------- -#ifndef CHOLMOD_H -#define CHOLMOD_H +#ifndef R_MATRIX_CHOLMOD_H +#define R_MATRIX_CHOLMOD_H //------------------------------------------------------------------------------ // CHOLMOD conventions @@ -259,6 +259,8 @@ extern "C" { #endif +#ifndef R_MATRIX_CHOLMOD_H + int cholmod_version // returns CHOLMOD_VERSION, defined above ( // if version is not NULL, then cholmod_version returns its contents as: @@ -268,6 +270,8 @@ int version [3] ) ; int cholmod_l_version (int version [3]) ; + +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ #ifdef __cplusplus } @@ -287,6 +291,8 @@ // particular, you must use -DNLARGEFILE for MATLAB 6.5 or earlier (which does // not have the io64.h include file). +#ifndef R_MATRIX_CHOLMOD_H + // skip all of this if NLARGEFILE is defined at the compiler command line #ifndef NLARGEFILE #if defined(MATLAB_MEX_FILE) || defined(MATHWORKS) @@ -301,10 +307,14 @@ #endif #endif +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + //------------------------------------------------------------------------------ // SuiteSparse_config: definitions for all SuiteSparse packages //------------------------------------------------------------------------------ +#ifndef R_MATRIX_CHOLMOD_H + #include "SuiteSparse_config.h" #define CHOLMOD__VERSION SUITESPARSE__VERCODE(5,2,0) @@ -313,6 +323,13 @@ #error "CHOLMOD 5.2.0 requires SuiteSparse_config 7.6.0 or later" #endif +#else + +#include +#include + +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + //------------------------------------------------------------------------------ // CHOLMOD configuration //------------------------------------------------------------------------------ @@ -354,6 +371,8 @@ // affect the license itself; see CHOLMOD/Doc/License.txt for your actual // license. +#ifndef R_MATRIX_CHOLMOD_H + #ifdef NGPL #undef NMATRIXOPS #define NMATRIXOPS @@ -362,6 +381,8 @@ #undef NSUPERNODAL #define NSUPERNODAL #endif + +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ //============================================================================== // CHOLMOD:Utility Module @@ -926,6 +947,8 @@ #define CHOLMOD_ASSEMBLE_TIME cholmod_assemble_time #define CHOLMOD_ASSEMBLE_TIME2 cholmod_assemble_time2 +#ifndef R_MATRIX_CHOLMOD_H + //------------------------------------------------------------------------------ // cholmod_start: first call to CHOLMOD //------------------------------------------------------------------------------ @@ -1066,6 +1089,8 @@ double *cr, double *ci // c (real, imaginary) ) ; int cholmod_l_divcomplex (double, double, double, double, double *, double *) ; + +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ //============================================================================== // cholmod_sparse: a sparse matrix in compressed-column (CSC) form @@ -1110,6 +1135,8 @@ int packed ; // true if packed (A->nz ignored), false if unpacked } cholmod_sparse ; + +#ifndef R_MATRIX_CHOLMOD_H //------------------------------------------------------------------------------ // cholmod_allocate_sparse: allocate a sparse matrix @@ -1421,8 +1448,8 @@ int sorted, // ignored; C is now always returned as sorted cholmod_common *Common ) ; -cholmod_sparse *cholmod_l_add (cholmod_sparse *, cholmod_sparse *, double *, - double *, int, int, cholmod_common *) ; +cholmod_sparse *cholmod_l_add (cholmod_sparse *, cholmod_sparse *, double [2], + double [2], int, int, cholmod_common *) ; //------------------------------------------------------------------------------ // cholmod_sparse_xtype: change the xtype and/or dtype of a sparse matrix @@ -1438,6 +1465,8 @@ ) ; int cholmod_l_sparse_xtype (int, cholmod_sparse *, cholmod_common *) ; +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + //============================================================================== // cholmod_factor: symbolic or numeric factorization (simplicial or supernodal) //============================================================================== @@ -1558,6 +1587,8 @@ } cholmod_factor ; +#ifndef R_MATRIX_CHOLMOD_H + //------------------------------------------------------------------------------ // cholmod_allocate_factor: allocate a numerical factor //------------------------------------------------------------------------------ @@ -1701,6 +1732,8 @@ ) ; int cholmod_l_factor_xtype (int, cholmod_factor *, cholmod_common *) ; +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + //============================================================================== // cholmod_dense: a dense matrix, held by column //============================================================================== @@ -1718,6 +1751,8 @@ } cholmod_dense ; +#ifndef R_MATRIX_CHOLMOD_H + //------------------------------------------------------------------------------ // cholmod_allocate_dense: allocate a dense matrix (contents not initialized) //------------------------------------------------------------------------------ @@ -1895,6 +1930,8 @@ ) ; int cholmod_l_dense_xtype (int, cholmod_dense *, cholmod_common *) ; +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + //============================================================================= // cholmod_triplet: a sparse matrix in triplet form //============================================================================= @@ -1937,6 +1974,8 @@ } cholmod_triplet ; +#ifndef R_MATRIX_CHOLMOD_H + //------------------------------------------------------------------------------ // cholmod_allocate_triplet: allocate a triplet matrix //------------------------------------------------------------------------------ @@ -2035,6 +2074,8 @@ ) ; int cholmod_l_triplet_xtype (int, cholmod_triplet *, cholmod_common *) ; +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + //------------------------------------------------------------------------------ // memory allocation: malloc/calloc/realloc/free //------------------------------------------------------------------------------ @@ -2048,6 +2089,8 @@ // statistics. cholmod_realloc does not return NULL if it fails; instead, it // returns the pointer to the unmodified block of memory. +#ifndef R_MATRIX_CHOLMOD_H + void *cholmod_malloc // return pointer to newly allocated memory ( // input: @@ -2110,6 +2153,8 @@ int cholmod_l_realloc_multiple (size_t, int, int, void **, void **, void **, void **, size_t *, cholmod_common *) ; +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + //------------------------------------------------------------------------------ // numerical comparisons //------------------------------------------------------------------------------ @@ -2117,6 +2162,8 @@ // These macros were different on Windows for older versions of CHOLMOD. // They are no longer needed but are kept for backward compatibility. +#ifndef R_MATRIX_CHOLMOD_H + #define CHOLMOD_IS_NAN(x) isnan (x) #define CHOLMOD_IS_ZERO(x) ((x) == 0.) #define CHOLMOD_IS_NONZERO(x) ((x) != 0.) @@ -2124,13 +2171,13 @@ #define CHOLMOD_IS_GT_ZERO(x) ((x) > 0.) #define CHOLMOD_IS_LE_ZERO(x) ((x) <= 0.) +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + #endif //============================================================================== // CHOLMOD:Check Module //============================================================================== - -#ifndef NCHECK // Routines that check and print the 5 basic data types in CHOLMOD, and 3 kinds // of integer vectors (subset, perm, and parent), and read in matrices from a @@ -2181,6 +2228,8 @@ // // See cholmod_read.c for a description of the file formats supported by the // cholmod_read_* routines. + +#ifndef R_MATRIX_CHOLMOD_H //------------------------------------------------------------------------------ // cholmod_check_common: check the Common object @@ -2519,6 +2568,8 @@ //------------------------------------------------------------------------------ // cholmod_write_sparse: write a sparse matrix to a file //------------------------------------------------------------------------------ + +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ // return values of cholmod_symmetry and cholmod_write: #define CHOLMOD_MM_RECTANGULAR 1 @@ -2529,6 +2580,8 @@ #define CHOLMOD_MM_SYMMETRIC_POSDIAG 6 #define CHOLMOD_MM_HERMITIAN_POSDIAG 7 +#ifndef R_MATRIX_CHOLMOD_H + int cholmod_write_sparse // see above, or -1 on error ( // input: @@ -2556,14 +2609,12 @@ int cholmod_l_write_dense (FILE *, cholmod_dense *, const char *, cholmod_common *) ; -#endif +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ //============================================================================== // CHOLMOD:Cholesky Module //============================================================================== -#ifndef NCHOLESKY - // Sparse Cholesky routines: analysis, factorization, and solve. // // The primary routines are all that a user requires to order, analyze, and @@ -2604,6 +2655,8 @@ // Optionally uses the Supernodal and Partition modules. // Required by the Partition module. +#ifndef R_MATRIX_CHOLMOD_H + //------------------------------------------------------------------------------ // cholmod_analyze: order and analyze (simplicial or supernodal) //------------------------------------------------------------------------------ @@ -2697,7 +2750,7 @@ cholmod_factor *L, // resulting factorization cholmod_common *Common ) ; -int cholmod_l_factorize_p (cholmod_sparse *, double *, int64_t *, size_t, +int cholmod_l_factorize_p (cholmod_sparse *, double [2], int64_t *, size_t, cholmod_factor *, cholmod_common *) ; //------------------------------------------------------------------------------ @@ -2707,6 +2760,8 @@ // Solves one of many linear systems with a dense right-hand-side, using the // factorization from cholmod_factorize (or as modified by any other CHOLMOD // routine). D is identity for LL' factorizations. + +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ #define CHOLMOD_A 0 /* solve Ax=b */ #define CHOLMOD_LDLt 1 /* solve LDL'x=b */ @@ -2718,6 +2773,8 @@ #define CHOLMOD_P 7 /* permute x=Px */ #define CHOLMOD_Pt 8 /* permute x=P'x */ +#ifndef R_MATRIX_CHOLMOD_H + cholmod_dense *cholmod_solve // returns the solution X ( // input: @@ -2895,7 +2952,7 @@ cholmod_factor *L, cholmod_common *Common ) ; -int cholmod_l_rowfac (cholmod_sparse *, cholmod_sparse *, double *, size_t, +int cholmod_l_rowfac (cholmod_sparse *, cholmod_sparse *, double [2], size_t, size_t, cholmod_factor *, cholmod_common *) ; //------------------------------------------------------------------------------ @@ -2920,7 +2977,7 @@ cholmod_factor *L, cholmod_common *Common ) ; -int cholmod_l_rowfac_mask (cholmod_sparse *, cholmod_sparse *, double *, +int cholmod_l_rowfac_mask (cholmod_sparse *, cholmod_sparse *, double [2], size_t, size_t, int64_t *, int64_t *, cholmod_factor *, cholmod_common *) ; int cholmod_rowfac_mask2 @@ -2939,7 +2996,7 @@ cholmod_factor *L, cholmod_common *Common ) ; -int cholmod_l_rowfac_mask2 (cholmod_sparse *, cholmod_sparse *, double *, +int cholmod_l_rowfac_mask2 (cholmod_sparse *, cholmod_sparse *, double [2], size_t, size_t, int64_t *, int64_t, int64_t *, cholmod_factor *, cholmod_common *) ; @@ -3078,14 +3135,12 @@ int64_t cholmod_l_postorder (int64_t *, size_t, int64_t *, int64_t *, cholmod_common *) ; -#endif +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ //============================================================================== // CHOLMOD:MatrixOps Module //============================================================================== -#ifndef NMATRIXOPS - // Basic operations on sparse and dense matrices. // // cholmod_drop A = entries in A with abs. value >= tol @@ -3104,6 +3159,8 @@ // // Requires the Utility module. Not required by any other CHOLMOD module. +#ifndef R_MATRIX_CHOLMOD_H + //------------------------------------------------------------------------------ // cholmod_drop: drop entries with small absolute value //------------------------------------------------------------------------------ @@ -3169,11 +3226,15 @@ // cholmod_scale: A = diag(s)*A, A*diag(s), s*A or diag(s)*A*diag(s) //------------------------------------------------------------------------------ +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + // scaling modes, selected by the scale input parameter: #define CHOLMOD_SCALAR 0 /* A = s*A */ #define CHOLMOD_ROW 1 /* A = diag(s)*A */ #define CHOLMOD_COL 2 /* A = A*diag(s) */ #define CHOLMOD_SYM 3 /* A = diag(s)*A*diag(s) */ + +#ifndef R_MATRIX_CHOLMOD_H int cholmod_scale ( @@ -3204,7 +3265,7 @@ cholmod_dense *Y, // resulting dense matrix cholmod_common *Common ) ; -int cholmod_l_sdmult (cholmod_sparse *, int, double *, double *, +int cholmod_l_sdmult (cholmod_sparse *, int, double [2], double [2], cholmod_dense *, cholmod_dense *Y, cholmod_common *) ; //------------------------------------------------------------------------------ @@ -3310,14 +3371,12 @@ int cholmod_l_symmetry (cholmod_sparse *, int, int64_t *, int64_t *, int64_t *, int64_t *, cholmod_common *) ; -#endif +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ //============================================================================== // CHOLMOD:Modify Module //============================================================================== -#ifndef NMODIFY - //------------------------------------------------------------------------------ // CHOLMOD:Modify Module. Copyright (C) 2005-2023, Timothy A. Davis and William // W. Hager. http://www.suitesparse.com @@ -3350,6 +3409,8 @@ // cholmod_rowdel_mark delete a row, and downdate solution to partial Lx=b // // Requires the Utility module. Not required by any other CHOLMOD module. + +#ifndef R_MATRIX_CHOLMOD_H //------------------------------------------------------------------------------ // cholmod_updown: multiple rank update/downdate @@ -3504,7 +3565,7 @@ cholmod_dense *DeltaB, // change in b, zero on output cholmod_common *Common ) ; -int cholmod_l_rowadd_solve (size_t, cholmod_sparse *, double *, +int cholmod_l_rowadd_solve (size_t, cholmod_sparse *, double [2], cholmod_factor *, cholmod_dense *, cholmod_dense *, cholmod_common *) ; //------------------------------------------------------------------------------ @@ -3528,7 +3589,7 @@ cholmod_dense *DeltaB, // change in b, zero on output cholmod_common *Common ) ; -int cholmod_l_rowadd_mark (size_t, cholmod_sparse *, double *, int64_t *, +int cholmod_l_rowadd_mark (size_t, cholmod_sparse *, double [2], int64_t *, cholmod_factor *, cholmod_dense *, cholmod_dense *, cholmod_common *) ; //------------------------------------------------------------------------------ @@ -3575,7 +3636,7 @@ cholmod_dense *DeltaB, // change in b, zero on output cholmod_common *Common ) ; -int cholmod_l_rowdel_solve (size_t, cholmod_sparse *, double *, +int cholmod_l_rowdel_solve (size_t, cholmod_sparse *, double [2], cholmod_factor *, cholmod_dense *, cholmod_dense *, cholmod_common *) ; //------------------------------------------------------------------------------ @@ -3599,10 +3660,10 @@ cholmod_dense *DeltaB, // change in b, zero on output cholmod_common *Common ) ; -int cholmod_l_rowdel_mark (size_t, cholmod_sparse *, double *, int64_t *, +int cholmod_l_rowdel_mark (size_t, cholmod_sparse *, double [2], int64_t *, cholmod_factor *, cholmod_dense *, cholmod_dense *, cholmod_common *) ; -#endif +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ //============================================================================== // CHOLMOD:Partition Module (CAMD, CCOLAMD, and CSYMAMD) @@ -3634,7 +3695,7 @@ // Requires the Utility and Cholesky modules, and three packages: METIS, CAMD, // and CCOLAMD. Optionally used by the Cholesky module. -#ifndef NCAMD +#ifndef R_MATRIX_CHOLMOD_H //------------------------------------------------------------------------------ // cholmod_ccolamd @@ -3696,7 +3757,7 @@ int cholmod_l_camd (cholmod_sparse *, int64_t *, size_t, int64_t *, int64_t *, cholmod_common *) ; -#endif +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ //------------------------------------------------------------------------------ // CHOLMOD:Partition Module (graph partition methods) @@ -3705,7 +3766,7 @@ // These routines still exist if CHOLMOD is compiled with -DNPARTITION, // but they return Common->status = CHOLMOD_NOT_INSTALLED in that case. -#if 1 +#ifndef R_MATRIX_CHOLMOD_H //------------------------------------------------------------------------------ // cholmod_nested_dissection @@ -3822,14 +3883,12 @@ int64_t cholmod_l_collapse_septree (size_t, size_t, double, size_t, int64_t *, int64_t *, cholmod_common *) ; -#endif +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ //============================================================================== // CHOLMOD:Supernodal Module //============================================================================== -#ifndef NSUPERNODAL - // 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 @@ -3862,6 +3921,8 @@ // Requires the Utility module, and two external packages: LAPACK and the BLAS. // Optionally used by the Cholesky module. +#ifndef R_MATRIX_CHOLMOD_H + //------------------------------------------------------------------------------ // cholmod_super_symbolic //------------------------------------------------------------------------------ @@ -3890,10 +3951,14 @@ // Analyze for supernodal Cholesky or multifrontal QR +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + #define CHOLMOD_ANALYZE_FOR_SPQR 0 #define CHOLMOD_ANALYZE_FOR_CHOLESKY 1 #define CHOLMOD_ANALYZE_FOR_SPQRGPU 2 +#ifndef R_MATRIX_CHOLMOD_H + int cholmod_super_symbolic2 ( // input: @@ -3929,7 +3994,7 @@ cholmod_factor *L, // factorization cholmod_common *Common ) ; -int cholmod_l_super_numeric (cholmod_sparse *, cholmod_sparse *, double *, +int cholmod_l_super_numeric (cholmod_sparse *, cholmod_sparse *, double [2], cholmod_factor *, cholmod_common *) ; //------------------------------------------------------------------------------ @@ -3974,7 +4039,7 @@ int cholmod_l_super_ltsolve (cholmod_factor *, cholmod_dense *, cholmod_dense *, cholmod_common *) ; -#endif +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ #ifdef __cplusplus } @@ -3998,12 +4063,16 @@ int64_t d ; } descendantScore ; + +#ifndef R_MATRIX_CHOLMOD_H int cholmod_score_comp (struct cholmod_descendant_score_t *i, struct cholmod_descendant_score_t *j) ; int cholmod_l_score_comp (struct cholmod_descendant_score_t *i, struct cholmod_descendant_score_t *j) ; +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + #ifdef __cplusplus } #endif @@ -4051,6 +4120,8 @@ } cholmod_gpu_pointers ; +#ifndef R_MATRIX_CHOLMOD_H + int cholmod_gpu_memorysize // GPU memory size available, 1 if no GPU ( size_t *total_mem, @@ -4080,11 +4151,140 @@ int cholmod_gpu_allocate ( cholmod_common *Common ) ; int cholmod_l_gpu_allocate ( cholmod_common *Common ) ; +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ + #ifdef __cplusplus } #endif #endif +/* <<<< Matrix <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */ + +/* We declare a minimal subset of the above as "API" : */ + +#ifndef R_MATRIX_CHOLMOD +# define R_MATRIX_CHOLMOD(_NAME_) M_cholmod_ ## _NAME_ #endif +#ifndef R_MATRIX_INLINE +# define R_MATRIX_INLINE +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef cholmod_common * CHM_CM; +typedef cholmod_factor * CHM_FR; +typedef cholmod_sparse * CHM_SP; +typedef cholmod_triplet * CHM_TR; +typedef cholmod_dense * CHM_DN; + +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(aat)( + CHM_SP, int *, size_t, int, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(add)( + CHM_SP, CHM_SP, double[2], double[2], int, int, CHM_CM); +R_MATRIX_INLINE CHM_DN R_MATRIX_CHOLMOD(allocate_dense)( + size_t, size_t, size_t, int, CHM_CM); +R_MATRIX_INLINE CHM_FR R_MATRIX_CHOLMOD(allocate_factor)( + size_t, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(allocate_sparse)( + size_t, size_t, size_t, int, int, int, int, CHM_CM); +R_MATRIX_INLINE CHM_TR R_MATRIX_CHOLMOD(allocate_triplet)( + size_t, size_t, size_t, int, int, CHM_CM); +R_MATRIX_INLINE CHM_FR R_MATRIX_CHOLMOD(analyze)( + CHM_SP, CHM_CM); +R_MATRIX_INLINE CHM_FR R_MATRIX_CHOLMOD(analyze_p)( + CHM_SP, int *, int *, size_t, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(band_inplace)( + int, int, int, CHM_SP, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(change_factor)( + int, int, int, int, int, CHM_FR, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(check_common)( + CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(check_dense)( + CHM_DN, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(check_factor)( + CHM_FR, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(check_sparse)( + CHM_SP, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(check_triplet)( + CHM_TR, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(copy)( + CHM_SP, int, int, CHM_CM); +R_MATRIX_INLINE CHM_DN R_MATRIX_CHOLMOD(copy_dense)( + CHM_DN, CHM_CM); +R_MATRIX_INLINE CHM_FR R_MATRIX_CHOLMOD(copy_factor)( + CHM_FR, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(copy_sparse)( + CHM_SP, CHM_CM); +R_MATRIX_INLINE CHM_TR R_MATRIX_CHOLMOD(copy_triplet)( + CHM_TR, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(defaults)( + CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(dense_to_sparse)( + CHM_DN, int, CHM_CM); +R_MATRIX_INLINE void R_MATRIX_CHOLMOD(error_handler)( + int, const char *, int, const char *); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(factor_to_sparse )( + CHM_FR, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(factorize)( + CHM_SP, CHM_FR, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(factorize_p)( + CHM_SP, double[2], int *, size_t, CHM_FR, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(finish)( + CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(free_dense)( + CHM_DN *, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(free_factor)( + CHM_FR *, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(free_sparse)( + CHM_SP *, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(free_triplet)( + CHM_TR *, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(horzcat)( + CHM_SP, CHM_SP, int, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(nnz)( + CHM_SP, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(scale)( + CHM_DN, int, CHM_SP, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(sdmult)( + CHM_SP, int, double[2], double[2], CHM_DN, CHM_DN, CHM_CM); +R_MATRIX_INLINE CHM_DN R_MATRIX_CHOLMOD(solve)( + int, CHM_FR, CHM_DN, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(solve2)( + int, CHM_FR, CHM_DN, CHM_DN *, CHM_DN *, CHM_DN *, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(sort)( + CHM_SP, CHM_CM); +R_MATRIX_INLINE CHM_DN R_MATRIX_CHOLMOD(sparse_to_dense)( + CHM_SP, CHM_CM); +R_MATRIX_INLINE CHM_TR R_MATRIX_CHOLMOD(sparse_to_triplet)( + CHM_SP, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(speye)( + size_t, size_t, int, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(spsolve)( + int, CHM_FR, CHM_SP, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(ssmult)( + CHM_SP, CHM_SP, int, int, int, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(start)( + CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(submatrix)( + CHM_SP, int *, int, int *, int, int, int, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(transpose)( + CHM_SP, int, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(triplet_to_sparse)( + CHM_TR, int, CHM_CM); +R_MATRIX_INLINE int R_MATRIX_CHOLMOD(updown)( + int, CHM_SP, CHM_FR, CHM_CM); +R_MATRIX_INLINE CHM_SP R_MATRIX_CHOLMOD(vertcat)( + CHM_SP, CHM_SP, int, CHM_CM); + +#ifdef __cplusplus +} +#endif + +/* >>>> Matrix >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */ + +#endif /* !defined(R_MATRIX_CHOLMOD_H) */ +