suitesparse-metis-for-windows-master

CXSparse: Copyright (c) 2006-2012, Timothy A. Davis. http://www.suitesparse.com Derived from CSparse. Conversion originally by David Bateman, Motorola, and then modified by Tim Davis. ANSI C99 is required, with support for the _Complex data type. (if you use a C++ compiler, the C++ complex type is used instead). CXSparse is a version of CSparse that operates on both real and complex matrices, using either int or SuiteSparse_long integers. A SuiteSparse_long is normally just a long on most platforms, but becomes __int64 on WIN64. It now includes a MATLAB interface, enabling the use of CXSparse functions on both 32-bit and 64-bit platforms. To install for use in MATLAB, simply type "cs_install" in the MATLAB Command Window, while in the CXSparse/MATLAB directory. (NOTE: Windows users cannot use the "lcc" command; run "mex -setup" first, and select a different compiler). If you use the Unix "make" command in that directory instead and are using a 64-bit platform, then you must edit the CXSparse/MATLAB/Makefile first. Refer to the instructions in that file. Refer to "Direct Methods for Sparse Linear Systems," Timothy A. Davis, SIAM, Philadelphia, 2006. No detailed user guide is included in this package; the user guide is the book itself. To compile the C-library (./Source), C demo programs (./Demo) just type "make" in this directory. To run the exhaustive statement coverage tests, type "make" in the Tcov directory; the Tcov tests assume you are using Linux. To remove all files not in the original distribution, type "make distclean". I recommend that you use a different level of optimization than "cc -O", which was chosen so that the Makefile is portable. See Source/Makefile. If your C compiler does not support the ANSI C99 complex type, the #include <complex.h> statement will fail. If this happens, compile the code with the -DNCOMPLEX flag (the MATLAB cs_install will do this for you). This package is backward compatible with CSparse. That is, user code that uses CSparse may switch to using CXSparse without any changes to the user code. Each CXSparse function has a generic version with the same name as the CSparse function, and four type-specific versions. For example: cs_add same as cs_add_di by default, but can be changed to use SuiteSparse_long integers if user code is compiled with -DCS_LONG, and/or can be changed to operate on complex matrices with -DCS_COMPLEX. cs_di_add double/int version of cs_add cs_dl_add double/SuiteSparse_long version of cs_add cs_ci_add complex/int version of cs_add cs_cl_add complex/SuiteSparse_long version of cs_add The sparse matrix data structures are treated in the same way: cs, css, csn, and csd become cs_di, cs_dis, cs_din, and cs_did for the double/int case, cs_cl, cs_cls, cs_cln, and cs_cld for the complex/SuiteSparse_long case, and so on. See cs_demo.c for a type-generic user program, and cs_cl_demo.c for a type-specific version of the same program (complex/SuiteSparse_long). Several macros are available in CXSparse (but not in CSparse) to allow user code to be written in a type-generic manner: CS_INT int by default, SuiteSparse_long if -DCS_LONG compiler flag is used CS_ENTRY double by default, double complex if -DCS_COMPLEX flag is used. CS_ID "%d" or "%ld", for printf and scanf of the CS_INT type. CS_INT_MAX INT_MAX or LONG_MAX, the largest possible value of CS_INT. CS_REAL(x) x or creal(x) CS_IMAG(x) 0 or cimag(x) CS_CONJ(x) x or conj(x) CS_ABS(x) fabs(x) or cabs(x) Even the name of the include file (cs.h) is the same. To use CXSparse instead of CSparse, simply compile with -ICXSparse/Source instead of -ICSparse/Source, and link against libcxsparse.a instead of the CSparse libcsparse.a library. To determine at compile time if CXSparse or CSparse is being used: #ifdef CXSPARSE CXSparse is in use. The generic functions equivalent to CSparse may be used (cs_add, etc). These generic functions can use different types, depending on the -DCS_LONG and -DCS_COMPLEX compile flags, with the default being double/int. The type-specific functions and data types (cs_di_add, cs_di, CS_INT, etc.) can be used. #else CSparse is in use. Only the generic functions "cs_add", etc., are available, and they are of type double/int. #endif See cs.h for the prototypes of each function, and the book "Direct Methods for Sparse Linear Systems" for full documentation of CSparse and CXSparse. Other changes from CSparse: cs_transpose performs the complex conjugate transpose if values>0 (C=A'), the pattern-only transpose if values=0 (C=spones(A') in MATLAB), and the array transpose if values<0 (C=A.' in MATLAB notation). A set of four conversion routines are included in CXSparse, to convert real matrices to/from complex matrices. The Householder reflection constructed by cs_house.c also differs slightly, to accomodate both the real and complex cases properly. CXSparse is generated automatically from CSparse. Refer to http://www.suitesparse.com for details. -------------------------------------------------------------------------------- Contents: -------------------------------------------------------------------------------- Demo/ demo C programs that use CXSparse Doc/ license and change log Makefile Makefile for the whole package MATLAB/ MATLAB interface, demos, and tests for CXSparse Matrix/ sample matrices (with extra complex matrices for CXSparse) README.txt this file Source/ primary CXSparse source files Tcov/ CXSparse tests -------------------------------------------------------------------------------- ./Doc: license and change log -------------------------------------------------------------------------------- ChangeLog changes in CSparse since first release lesser.txt the GNU LGPL License.txt license (GNU LGPL) -------------------------------------------------------------------------------- ./Source: Primary source code for CXSparse -------------------------------------------------------------------------------- cs_add.c add sparse matrices cs_amd.c approximate minimum degree cs_chol.c sparse Cholesky cs_cholsol.c x=A\b using sparse Cholesky cs_compress.c convert a compress form to compressed-column form cs_counts.c column counts for Cholesky and QR cs_convert.c convert real to complex and complex to real (not in CSparse) cs_cumsum.c cumulative sum cs_dfs.c depth-first-search cs_dmperm.c Dulmage-Mendelsohn permutation cs_droptol.c drop small entries from a sparse matrix cs_dropzeros.c drop zeros from a sparse matrix cs_dupl.c remove (and sum) duplicates cs_entry.c add an entry to a triplet matrix cs_ereach.c nonzero pattern of Cholesky L(k,:) from etree and triu(A(:,k)) cs_etree.c find elimination tree cs_fkeep.c drop entries from a sparse matrix cs_gaxpy.c sparse matrix times dense matrix cs.h include file for CXSparse cs_happly.c apply Householder reflection cs_house.c Householder reflection (*** NOTE: different algo. from CSparse) cs_ipvec.c x(p)=b cs_leaf.c determine if j is a leaf of the skeleton matrix and find lca cs_load.c load a sparse matrix from a file cs_lsolve.c x=L\b cs_ltsolve.c x=L'\b cs_lu.c sparse LU factorization cs_lusol.c x=A\b using sparse LU factorization cs_malloc.c memory manager cs_maxtrans.c maximum transveral (permutation for zero-free diagonal) cs_multiply.c sparse matrix multiply cs_norm.c sparse matrix norm cs_permute.c permute a sparse matrix cs_pinv.c invert a permutation vector cs_post.c postorder an elimination tree cs_print.c print a sparse matrix cs_pvec.c x=b(p) cs_qr.c