BiomedEngX/CircosHeatmap-aardio
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity
CircosHeatmap-aardio/dist/lib/r/site-library/Matrix/scripts/cholmod.h.patch

705 lines
24 KiB
Diff
Raw Normal View History

首次上传
2025-01-12 00:52:51 +08:00
--- 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 <stdint.h>
+#include <stddef.h>
+
+#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) */
+
Reference in New Issue Copy Permalink