Amesos Package Browser (Single Doxygen Collection) Development
amesos_cholmod_check.h
Go to the documentation of this file.
00001 /* ========================================================================== */
00002 /* === Include/cholmod_check.h ============================================== */
00003 /* ========================================================================== */
00004 
00005 /* -----------------------------------------------------------------------------
00006  * CHOLMOD/Include/cholmod_check.h.  Copyright (C) 2005-2006, Timothy A. Davis
00007  * CHOLMOD/Include/cholmod_check.h is licensed under Version 2.1 of the GNU
00008  * Lesser General Public License.  See lesser.txt for a text of the license.
00009  * CHOLMOD is also available under other licenses; contact authors for details.
00010  * http://www.cise.ufl.edu/research/sparse
00011  * -------------------------------------------------------------------------- */
00012 
00013 /* CHOLMOD Check module.
00014  *
00015  * Routines that check and print the 5 basic data types in CHOLMOD, and 3 kinds
00016  * of integer vectors (subset, perm, and parent), and read in matrices from a
00017  * file:
00018  *
00019  * cholmod_check_common     check/print the Common object
00020  * cholmod_print_common
00021  *
00022  * cholmod_check_sparse     check/print a sparse matrix in column-oriented form
00023  * cholmod_print_sparse
00024  *
00025  * cholmod_check_dense      check/print a dense matrix
00026  * cholmod_print_dense
00027  *
00028  * cholmod_check_factor     check/print a Cholesky factorization
00029  * cholmod_print_factor
00030  *
00031  * cholmod_check_triplet    check/print a sparse matrix in triplet form
00032  * cholmod_print_triplet
00033  *
00034  * cholmod_check_subset     check/print a subset (integer vector in given range)
00035  * cholmod_print_subset
00036  *
00037  * cholmod_check_perm     check/print a permutation (an integer vector)
00038  * cholmod_print_perm
00039  *
00040  * cholmod_check_parent     check/print an elimination tree (an integer vector)
00041  * cholmod_print_parent
00042  *
00043  * cholmod_print_common and cholmod_check_common are the only two routines that
00044  * you may call after calling cholmod_finish.
00045  *
00046  * Requires the Core module.  Not required by any CHOLMOD module, except when
00047  * debugging is enabled (in which case all modules require the Check module).
00048  *
00049  */
00050 
00051 #ifndef AMESOS_CHOLMOD_CHECK_H
00052 #define AMESOS_CHOLMOD_CHECK_H
00053 
00054 #include "amesos_cholmod_core.h"
00055 #include <stdio.h>
00056 
00057 /* -------------------------------------------------------------------------- */
00058 /* cholmod_check_common:  check the Common object */
00059 /* -------------------------------------------------------------------------- */
00060 
00061 int cholmod_check_common
00062 (
00063     cholmod_common *Common
00064 ) ;
00065 
00066 int cholmod_l_check_common (cholmod_common *) ;
00067 
00068 /* -------------------------------------------------------------------------- */
00069 /* cholmod_print_common:  print the Common object */
00070 /* -------------------------------------------------------------------------- */
00071 
00072 int cholmod_print_common
00073 (
00074     /* ---- input ---- */
00075     char *name,   /* printed name of Common object */
00076     /* --------------- */
00077     cholmod_common *Common
00078 ) ;
00079 
00080 int cholmod_l_print_common (char *, cholmod_common *) ;
00081 
00082 /* -------------------------------------------------------------------------- */
00083 /* cholmod_check_sparse:  check a sparse matrix */
00084 /* -------------------------------------------------------------------------- */
00085 
00086 int cholmod_check_sparse
00087 (
00088     /* ---- input ---- */
00089     cholmod_sparse *A,  /* sparse matrix to check */
00090     /* --------------- */
00091     cholmod_common *Common
00092 ) ;
00093 
00094 int cholmod_l_check_sparse (cholmod_sparse *, cholmod_common *) ;
00095 
00096 /* -------------------------------------------------------------------------- */
00097 /* cholmod_print_sparse */
00098 /* -------------------------------------------------------------------------- */
00099 
00100 int cholmod_print_sparse
00101 (
00102     /* ---- input ---- */
00103     cholmod_sparse *A,  /* sparse matrix to print */
00104     char *name,   /* printed name of sparse matrix */
00105     /* --------------- */
00106     cholmod_common *Common
00107 ) ;
00108 
00109 int cholmod_l_print_sparse (cholmod_sparse *, char *, cholmod_common *) ;
00110 
00111 /* -------------------------------------------------------------------------- */
00112 /* cholmod_check_dense:  check a dense matrix */
00113 /* -------------------------------------------------------------------------- */
00114 
00115 int cholmod_check_dense
00116 (
00117     /* ---- input ---- */
00118     cholmod_dense *X, /* dense matrix to check */
00119     /* --------------- */
00120     cholmod_common *Common
00121 ) ;
00122 
00123 int cholmod_l_check_dense (cholmod_dense *, cholmod_common *) ;
00124 
00125 /* -------------------------------------------------------------------------- */
00126 /* cholmod_print_dense:  print a dense matrix */
00127 /* -------------------------------------------------------------------------- */
00128 
00129 int cholmod_print_dense
00130 (
00131     /* ---- input ---- */
00132     cholmod_dense *X, /* dense matrix to print */
00133     char *name,   /* printed name of dense matrix */
00134     /* --------------- */
00135     cholmod_common *Common
00136 ) ;
00137 
00138 int cholmod_l_print_dense (cholmod_dense *, char *, cholmod_common *) ;
00139 
00140 /* -------------------------------------------------------------------------- */
00141 /* cholmod_check_factor:  check a factor */
00142 /* -------------------------------------------------------------------------- */
00143 
00144 int cholmod_check_factor
00145 (
00146     /* ---- input ---- */
00147     cholmod_factor *L,  /* factor to check */
00148     /* --------------- */
00149     cholmod_common *Common
00150 ) ;
00151 
00152 int cholmod_l_check_factor (cholmod_factor *, cholmod_common *) ;
00153 
00154 /* -------------------------------------------------------------------------- */
00155 /* cholmod_print_factor:  print a factor */
00156 /* -------------------------------------------------------------------------- */
00157 
00158 int cholmod_print_factor
00159 (
00160     /* ---- input ---- */
00161     cholmod_factor *L,  /* factor to print */
00162     char *name,   /* printed name of factor */
00163     /* --------------- */
00164     cholmod_common *Common
00165 ) ;
00166 
00167 int cholmod_l_print_factor (cholmod_factor *, char *, cholmod_common *) ;
00168 
00169 /* -------------------------------------------------------------------------- */
00170 /* cholmod_check_triplet:  check a sparse matrix in triplet form */
00171 /* -------------------------------------------------------------------------- */
00172 
00173 int cholmod_check_triplet
00174 (
00175     /* ---- input ---- */
00176     cholmod_triplet *T, /* triplet matrix to check */
00177     /* --------------- */
00178     cholmod_common *Common
00179 ) ;
00180 
00181 int cholmod_l_check_triplet (cholmod_triplet *, cholmod_common *) ;
00182 
00183 /* -------------------------------------------------------------------------- */
00184 /* cholmod_print_triplet:  print a triplet matrix */
00185 /* -------------------------------------------------------------------------- */
00186 
00187 int cholmod_print_triplet
00188 (
00189     /* ---- input ---- */
00190     cholmod_triplet *T, /* triplet matrix to print */
00191     char *name,   /* printed name of triplet matrix */
00192     /* --------------- */
00193     cholmod_common *Common
00194 ) ;
00195 
00196 int cholmod_l_print_triplet (cholmod_triplet *, char *, cholmod_common *) ;
00197 
00198 /* -------------------------------------------------------------------------- */
00199 /* cholmod_check_subset:  check a subset */
00200 /* -------------------------------------------------------------------------- */
00201 
00202 int cholmod_check_subset
00203 (
00204     /* ---- input ---- */
00205     int *Set,   /* Set [0:len-1] is a subset of 0:n-1.  Duplicates OK */
00206     UF_long len,  /* size of Set (an integer array) */
00207     size_t n,   /* 0:n-1 is valid range */
00208     /* --------------- */
00209     cholmod_common *Common
00210 ) ;
00211 
00212 int cholmod_l_check_subset (UF_long *, UF_long, size_t, cholmod_common *) ;
00213 
00214 /* -------------------------------------------------------------------------- */
00215 /* cholmod_print_subset:  print a subset */
00216 /* -------------------------------------------------------------------------- */
00217 
00218 int cholmod_print_subset
00219 (
00220     /* ---- input ---- */
00221     int *Set,   /* Set [0:len-1] is a subset of 0:n-1.  Duplicates OK */
00222     UF_long len,  /* size of Set (an integer array) */
00223     size_t n,   /* 0:n-1 is valid range */
00224     char *name,   /* printed name of Set */
00225     /* --------------- */
00226     cholmod_common *Common
00227 ) ;
00228 
00229 int cholmod_l_print_subset (UF_long *, UF_long, size_t, char *,
00230     cholmod_common *) ;
00231 
00232 /* -------------------------------------------------------------------------- */
00233 /* cholmod_check_perm:  check a permutation */
00234 /* -------------------------------------------------------------------------- */
00235 
00236 int cholmod_check_perm
00237 (
00238     /* ---- input ---- */
00239     int *Perm,    /* Perm [0:len-1] is a permutation of subset of 0:n-1 */
00240     size_t len,   /* size of Perm (an integer array) */
00241     size_t n,   /* 0:n-1 is valid range */
00242     /* --------------- */
00243     cholmod_common *Common
00244 ) ;
00245 
00246 int cholmod_l_check_perm (UF_long *, size_t, size_t, cholmod_common *) ;
00247 
00248 /* -------------------------------------------------------------------------- */
00249 /* cholmod_print_perm:  print a permutation vector */
00250 /* -------------------------------------------------------------------------- */
00251 
00252 int cholmod_print_perm
00253 (
00254     /* ---- input ---- */
00255     int *Perm,    /* Perm [0:len-1] is a permutation of subset of 0:n-1 */
00256     size_t len,   /* size of Perm (an integer array) */
00257     size_t n,   /* 0:n-1 is valid range */
00258     char *name,   /* printed name of Perm */
00259     /* --------------- */
00260     cholmod_common *Common
00261 ) ;
00262 
00263 int cholmod_l_print_perm (UF_long *, size_t, size_t, char *, cholmod_common *) ;
00264 
00265 /* -------------------------------------------------------------------------- */
00266 /* cholmod_check_parent:  check an elimination tree */
00267 /* -------------------------------------------------------------------------- */
00268 
00269 int cholmod_check_parent
00270 (
00271     /* ---- input ---- */
00272     int *Parent,  /* Parent [0:n-1] is an elimination tree */
00273     size_t n,   /* size of Parent */
00274     /* --------------- */
00275     cholmod_common *Common
00276 ) ;
00277 
00278 int cholmod_l_check_parent (UF_long *, size_t, cholmod_common *) ;
00279 
00280 /* -------------------------------------------------------------------------- */
00281 /* cholmod_print_parent */
00282 /* -------------------------------------------------------------------------- */
00283 
00284 int cholmod_print_parent
00285 (
00286     /* ---- input ---- */
00287     int *Parent,  /* Parent [0:n-1] is an elimination tree */
00288     size_t n,   /* size of Parent */
00289     char *name,   /* printed name of Parent */
00290     /* --------------- */
00291     cholmod_common *Common
00292 ) ;
00293 
00294 int cholmod_l_print_parent (UF_long *, size_t, char *, cholmod_common *) ;
00295 
00296 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines