void SolveRealByLU(int numberOfRows, int numberOfColumn, int nnz, int *Ti, int *Tj, double *Tx, double *X, double *b)
{
//创建 Compressed Row Storage 存储结构
int *Ai = (int*)malloc(sizeof(int)*(nnz));
int *Ap = (int*)malloc(sizeof(int)*(numberOfRows + 1));
double *Ax = (double*)malloc(sizeof(double)*(nnz));
//转换 triplet 到 CRS
int staus = umfpack_di_triplet_to_col(numberOfRows, numberOfColumn, nnz, Ti, Tj, Tx, Ap, Ai, Ax, NULL);
if (staus != UMFPACK_OK){
return;
}
//因子化
void *Symbolic, *Numeric;
umfpack_di_symbolic(numberOfRows, numberOfColumn, Ap, Ai, Ax, &Symbolic, NULL, NULL);
umfpack_di_numeric(Ap, Ai, Ax, Symbolic, &Numeric, NULL, NULL);
umfpack_di_solve(UMFPACK_A, Ap, Ai, Ax, X, b, Numeric, NULL, NULL);
umfpack_di_free_symbolic(&Symbolic);
umfpack_di_free_numeric(&Numeric);
if (Ai != NULL)
free(Ai);
if (Ap != NULL)
free(Ap);
if (Ax != NULL)
free(Ax);
}
DllExport void* CreateSolverLUUMFPACK(int numberOfRows, int numberOfNoneZero, int *Ti, int *Tj, double *Tx)
{
//创建 Compressed Row Storage 存储结构
int *Ai = (int*)malloc(sizeof(int)*(numberOfNoneZero));
int *Ap = (int*)malloc(sizeof(int)*(numberOfRows + 1));
double *Ax = (double*)malloc(sizeof(double)*(numberOfNoneZero));
//转换 triplet 到 CRS
int staus = umfpack_di_triplet_to_col(numberOfRows, numberOfRows, numberOfNoneZero, Ti, Tj, Tx, Ap, Ai, Ax, NULL);
if (staus != UMFPACK_OK){
return NULL;
}
//创建 solver
UmfpackSolver *umpsolver = (UmfpackSolver*)malloc(sizeof(UmfpackSolver));
//设置 solver
umpsolver->Ai = Ai;
umpsolver->Ap = Ap;
umpsolver->Ax = Ax;
umpsolver->AiSize = umpsolver->AxSize = numberOfNoneZero;
umpsolver->ApSize = numberOfRows + 1;
umpsolver->n = numberOfRows;
umpsolver->m = numberOfRows;
//因子化
void *Symbolic, *Numeric;
(void)umfpack_di_symbolic(numberOfRows, numberOfRows, Ap, Ai, Ax, &Symbolic, NULL, NULL);
(void)umfpack_di_numeric(Ap, Ai, Ax, Symbolic, &Numeric, NULL, NULL);
umfpack_di_free_symbolic(&Symbolic);
umpsolver->Numeric = Numeric;
return umpsolver;
};
int UMF::Factor() {
int status;
double Info[UMFPACK_INFO]; // UMF internal communcation array
double Control[UMFPACK_CONTROL];
memcpy(&_rows[0], _rows_ptr, _nnz*sizeof(int));
memcpy(&_cols[0], _cols_ptr, _nnz*sizeof(int));
memcpy(&_vals[0], _vals_ptr, _nnz*sizeof(double));
_Ap.size(_dim+1);
_Ai.size(_nnz);
_Ax.size(_nnz);
_NRC = _nnz;
/* get the default control parameters */
umfpack_di_defaults (Control) ;
/* convert to column form */
status = umfpack_di_triplet_to_col(_dim, _dim, _NRC,
&_rows[0], &_cols[0],
&_vals[0], &_Ap[0], &_Ai[0], &_Ax[0], (int*)NULL) ;
if (status < 0 ) {
umfpack_di_report_status (Control, status) ;
fprintf(stderr,"umfpack_di_triplet_to_col failed\n");
return (-1);
}
/* ---------------------------------------------------------------------- */
/* symbolic factorization */
/* ---------------------------------------------------------------------- */
if ( _Symbolic == NULL ) { // skip the symbolic factorization steps except the very first one
status = umfpack_di_symbolic (_dim, _dim, &_Ap[0], &_Ai[0], &_Ax[0], &_Symbolic, Control, Info) ;
if (status < 0 ) {
umfpack_di_report_info (Control, Info) ;
umfpack_di_report_status (Control, status) ;
fprintf(stderr,"umfpack_di_symbolic failed\n");
return (-1);
}
}
/* ---------------------------------------------------------------------- */
/* numeric factorization */
/* ---------------------------------------------------------------------- */
if ( _Numeric ) umfpack_di_free_numeric (&_Numeric);
status = umfpack_di_numeric (&_Ap[0], &_Ai[0], &_Ax[0], _Symbolic, &_Numeric, Control, Info) ;
if (status < 0 ) {
umfpack_di_report_info (Control, Info) ;
umfpack_di_report_status (Control, status) ;
fprintf(stderr,"umfpack_di_numeric failed\n") ;
return (-1);
}
_is_factored = 1;
return 0;
}
inline
int triplet_to_col (int n_row, int n_col, int nz,
int const* Ti, int const* Tj, double const* Tx,
int* Ap, int* Ai, double* Ax, int* Map)
{
return umfpack_di_triplet_to_col (n_row, n_col, nz,
Ti, Tj, Tx,
Ap, Ai, Ax, Map);
}
/***
KLU
***/
int KLU::Factor() {
int status;
int ndim;
_NRC = _nnz;
ndim = _dim;
memcpy(&_rows[0], _rows_ptr, _nnz*sizeof(int));
memcpy(&_cols[0], _cols_ptr, _nnz*sizeof(int));
memcpy(&_vals[0], _vals_ptr, _nnz*sizeof(double));
_Ap.size(_dim+1);
_Ai.size(_nnz);
_Ax.size(_nnz);
status = umfpack_di_triplet_to_col (ndim,ndim, _NRC, &_rows[0], &_cols[0], &_vals[0],
&_Ap[0], &_Ai[0], &_Ax[0], (int*)NULL) ;
if (status < 0 ) {
fprintf(stderr,"KLU: umfpack_di_triplet_to_col failed\n");
return (-1);
}
klu_common Common;
klu_defaults( &Common );
klu_numeric *Num;
if ( _Symbolic == NULL ) _Symbolic = (void*)klu_analyze(ndim, &_Ap[0], &_Ai[0], &Common);
if ( _Symbolic == NULL ) {
fprintf(stderr,"KLU: symbolic analysis failed\n");
return (-1);
}
if ( _Numeric ) {
Num = (klu_numeric*)_Numeric;
klu_free_numeric( &Num, &Common);
}
_Numeric = (void*)klu_factor(&_Ap[0], &_Ai[0], &_Ax[0], (klu_symbolic*)_Symbolic, &Common);
if ( _Numeric == NULL ) {
fprintf(stderr,"KLU: numeric factorization failed\n");
return (-1);
}
_is_factored = 1;
return 0;
}
int main (void) {
double **Y = new_square_matrix(n);
Y[0][0] = 1; Y[0][1] = 0; Y[0][2] = 0;
Y[1][0] = 0; Y[1][1] = 0.2; Y[1][2] = 1;
Y[2][0] = 0; Y[2][1] = 1; Y[2][2] = 0;
int nz = count_entry(Y,n);
int Ti[nz];
int Tj[nz];
double Tx[nz];
matrix_to_triplet(Ti,Tj,Tx,nz,Y,n);
int n_row = n;
int n_col = n;
int * Ap = new int [n_col+1];
int * Ai = new int [nz];
double * Ax = new double [nz];
int status;
double Control [UMFPACK_CONTROL];
umfpack_di_defaults (Control) ;
status = umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx,
Ap, Ai, Ax, (int *) NULL);
if( status < 0 ) {
umfpack_di_report_status (Control, status) ;
report_exit("umfpack_zi_triplet_to_col failed\n") ;
}
double *null = (double *) NULL ;
int i ;
void *Symbolic, *Numeric ;
(void) umfpack_di_symbolic (n, n, Ap, Ai, Ax, &Symbolic, null, null) ;
(void) umfpack_di_numeric (Ap, Ai, Ax, Symbolic, &Numeric, null, null) ;
umfpack_di_free_symbolic (&Symbolic) ;
(void) umfpack_di_solve (UMFPACK_A, Ap, Ai, Ax, v, J, Numeric, null, null) ;
umfpack_di_free_numeric (&Numeric) ;
for (i = 0 ; i < n ; i++) printf ("v [%d] = %lf\n", i, v[i]) ;
delete [] Ap;
delete [] Ai;
delete [] Ax;
return (0) ;
}
int umfpack_solver(struct simulation *sim,int col,int nz,int *Ti,int *Tj, long double *lTx,long double *lb)
{
int i;
void *Symbolic, *Numeric;
int status;
double *dtemp;
int *itemp;
if ((sim->last_col!=col)||(sim->last_nz!=nz))
{
dtemp = realloc(sim->x,col*sizeof(double));
if (dtemp==NULL)
{
ewe(sim,"realloc failed\n");
}else
{
sim->x=dtemp;
}
dtemp = realloc(sim->b,col*sizeof(double));
if (dtemp==NULL)
{
ewe(sim,"realloc failed\n");
}else
{
sim->b=dtemp;
}
itemp = realloc(sim->Ap,(col+1)*sizeof(int));
if (itemp==NULL)
{
ewe(sim,"realloc failed\n");
}else
{
sim->Ap=itemp;
}
itemp = realloc(sim->Ai,(nz)*sizeof(int));
if (itemp==NULL)
{
ewe(sim,"realloc failed\n");
}else
{
sim->Ai=itemp;
}
dtemp = realloc(sim->Ax,(nz)*sizeof(double));
if (dtemp==NULL)
{
ewe(sim,"realloc failed\n");
}else
{
sim->Ax=dtemp;
}
dtemp = realloc(sim->Tx,(nz)*sizeof(double));
if (dtemp==NULL)
{
ewe(sim,"realloc failed\n");
}else
{
sim->Tx=dtemp;
}
sim->last_col=col;
sim->last_nz=nz;
}
for (i=0;i<col;i++)
{
sim->b[i]=(double)lb[i];
}
for (i=0;i<nz;i++)
{
sim->Tx[i]=(double)lTx[i];
}
double Control [UMFPACK_CONTROL],Info [UMFPACK_INFO];
umfpack_di_defaults (Control) ;
Control[UMFPACK_BLOCK_SIZE]=20;
//Control [UMFPACK_STRATEGY]=UMFPACK_STRATEGY_SYMMETRIC;//UMFPACK_STRATEGY_UNSYMMETRIC;
//Control [UMFPACK_ORDERING]=UMFPACK_ORDERING_BEST;//UMFPACK_ORDERING_AMD;//UMFPACK_ORDERING_BEST;//
//printf("%lf\n",Control[UMFPACK_BLOCK_SIZE]);
//Control [UMFPACK_PIVOT_TOLERANCE]=0.0001;
//Control[UMFPACK_SINGLETONS]=1;
//Control[UMFPACK_SCALE]=3;
status = umfpack_di_triplet_to_col(col, col, nz, Ti, Tj, sim->Tx, sim->Ap, sim->Ai, sim->Ax, NULL);
//printf("rod1\n");
//getchar();
if (status != UMFPACK_OK) {
error_report(status, __FILE__, __func__, __LINE__);
return EXIT_FAILURE;
}
// symbolic analysis
//printf("here2 %d\n",col);
status = umfpack_di_symbolic(col, col, sim->Ap, sim->Ai, sim->Ax, &Symbolic, Control, Info);
//printf("rod2\n");
//getchar();
//printf("here3\n");
if (status != UMFPACK_OK) {
error_report(status, __FILE__, __func__, __LINE__);
return EXIT_FAILURE;
}
// LU factorization
umfpack_di_numeric(sim->Ap, sim->Ai, sim->Ax, Symbolic, &Numeric, Control, Info);
//printf("rod5\n");
//getchar();
if (status != UMFPACK_OK) {
error_report(status, __FILE__, __func__, __LINE__);
return EXIT_FAILURE;
}
// solve system
umfpack_di_free_symbolic(&Symbolic);
//printf("rod a\n");
//getchar();
umfpack_di_solve(UMFPACK_A, sim->Ap, sim->Ai, sim->Ax, sim->x, sim->b, Numeric, Control, Info);
//printf("rod b\n");
//getchar();
//printf("%lf\n",Info [UMFPACK_ORDERING_USED]);
if (status != UMFPACK_OK) {
error_report(status, __FILE__, __func__, __LINE__);
return EXIT_FAILURE;
}
umfpack_di_free_numeric(&Numeric);
//printf("rod\n");
//getchar();
for (i=0;i<col;i++)
{
lb[i]=(long double)sim->x[i];
}
//memcpy(b, x, col*sizeof(double));
//umfpack_toc(stats);
return 0;
}
/* This returns an integer identifier that should be unique to your
* system. There were problems with UMF mixing up systems becuase it
* would identify unique systems just by its size.
*
* This unique identifier is passed in as system_id. If you're
* creating the matrix for the first time, then you should pass in a
* -1, otherwise you should pass in the returned value from SL_UMF
* when you created your system.
*
* Note that we don't do this very intelligently. We simply use
* indices sequentially. There is no mechanism to allow re-use.
*/
int
SL_UMF ( int system_id,
int *first,
int *fact_optn,
int *matr_form,
int *nj,
int *nnz_j,
int *row,
int *col,
double *a,
double *b,
double *x )
{
/* Static struct holds all linear systems also keep track of number
* of systems we have set up */
static struct UMF_Linear_Solver_System ums_a[UMF_MAX_SYSTEMS];
static int number_systems = 0;
double Control[UMFPACK_CONTROL], Info[UMFPACK_INFO];
struct UMF_Linear_Solver_System *ums = 0; /* pointer to current system */
int i, j, k, umf_option = 0;
int hit_diag, err;
for (i = 0; i < UMFPACK_CONTROL; i++) {
Control[i] = 0;
}
for (i = 0; i < UMFPACK_INFO; i++) {
Info[i] = 0;
}
#ifdef DEBUG_SL_UMF
fprintf(stderr, "SL_UMF: system_id = %d, *first = %d, *fact_optn = %d\n",
system_id, *first, *fact_optn);
#endif
/* MEMORY */
switch (*first) {
case 1:
/* If *first == 1, then we're creating a new matrix. */
/* If system_id isn't -1, then we're probably making some sort of mistake... */
if(system_id != -1)
EH(-1, "Entered SL_UMF with *first == 1, but system_id != -1");
/* If we've already gone through all of our slots, get out. */
if(number_systems == UMF_MAX_SYSTEMS)
EH(-1, "Already created UMF_MAX_SYSTEMS systems");
system_id = number_systems;
ums = &ums_a[number_systems++];
ums->n = *nj;
ums->nnz = *nnz_j;
/* MATRIX VECTORS */
ums->ap = Ivector_birth(ums->n + 1);
ums->ai = Ivector_birth(ums->nnz);
ums->ax = Dvector_birth(ums->nnz);
/* MSR needs extra allocation for A-transpose */
ums->atp = NULL;
ums->ati = NULL;
ums->atx = NULL;
if ( *matr_form == 1 ) {
ums->atp = Ivector_birth(ums->n + 1);
ums->ati = Ivector_birth(ums->nnz);
ums->atx = Dvector_birth(ums->nnz);
}
break;
case 0:
/* If *first == 0, then we want to just reuse a previously created
* system. */
/* system_id should have the appropriate identifier. */
if(system_id == -1)
EH(-1, "Conflicting orders: system_id == -1 and *first != 1");
if(system_id < 0 || system_id >= UMF_MAX_SYSTEMS)
EH(-1, "Index out of range: system_id");
/* Grab the hopeful system. */
ums = &ums_a[system_id];
/* Run through some sanity checks to help ensure we're dealing
* with the correct system. */
if(ums->n != *nj || ums->nnz != *nnz_j)
EH(-1, "Tried to access a bad system");
break;
case -1:
/* If *first == -1, then we want to free space. */
/* system_id should have the appropriate identifier. */
if(system_id == -1)
EH(-1, "Conflicting orders: system_id == -1 and *first != 1");
if(system_id < 0 || system_id >= UMF_MAX_SYSTEMS)
EH(-1, "Index out of range: system_id");
ums = &ums_a[system_id];
/* Run through some sanity checks to help ensure we're dealing
* with the correct system. */
if(ums->n != *nj || ums->nnz != *nnz_j)
EH(-1, "Tried to free a bad system");
umfpack_di_free_symbolic(&ums->symbolic);
ums->symbolic = NULL;
umfpack_di_free_numeric(&ums->numeric);
ums->numeric = NULL;
Ivector_death(ums->ap, ums->n + 1);
Ivector_death(ums->ai, ums->nnz);
Dvector_death(ums->ax, ums->nnz);
if ( ums->atp != NULL ) {
Ivector_death(ums->atp, ums->n + 1);
Ivector_death(ums->ati, ums->nnz);
Dvector_death(ums->atx, ums->nnz);
}
/* MMH: The fix that changed the world... */
ums->n = 0;
ums->nnz = 0;
/* So things break later in case we actually use the return value
* after deallocating space. */
system_id = -1;
break;
}
/* CONVERT MSR FORMAT TO MATLAB FORMAT IF NEEDED */
if (abs(*fact_optn) < 3) {
switch (*matr_form) {
case 0: /* COORDINATE FORMAT */
umfpack_di_triplet_to_col( ums->n, ums->n, ums->nnz,
row, col, a,
ums->ap, ums->ai, ums->ax,
NULL );
break;
case 1: /* MSR FORMAT */
/* Note: MSR is row-oriented and UMF wants column-oriented data.
So, assemble A-transpose in UMF format, and use umf utility
to get back A in UMF format.
Note also that UMF can operate directly on A-transpose. This
can save having to make another copy of the matrix, but it limited
experiments, I found it to be slower. -DRN
To form A-transpose in UMF format, merge the diagonal entries
back into the rows.
*/
k = 0;
for (i=0;i<ums->n;i++) { /* loop over rows */
ums->atp[i] = k;
hit_diag = FALSE;
for (j=col[i];j<col[i+1];j++) { /* loop over colums within row */
/* if we get to the spot where the diagonal term belongs, merge it in */
if (!hit_diag && col[j] > i ) {
ums->ati[k] = i;
ums->atx[k] = a[i];
k++;
hit_diag = TRUE;
}
ums->ati[k] = col[j];
ums->atx[k] = a[j];
k++;
}
/* if we never got to the diagonal, merge it in now */
if (!hit_diag) {
ums->ati[k] = i;
ums->atx[k] = a[i];
k++;
hit_diag = TRUE;
}
}
ums->atp[ums->n] = ums->nnz;
if (ums->nnz != k) {
DPRINTF(stderr, "E: NNZ=%12d CT=%12d\n", ums->nnz, k);
exit(0);
}
/* transpose matrix */
err = umfpack_di_transpose (ums->n, ums->n, ums->atp, ums->ati, ums->atx,
(int *) NULL, (int *) NULL, ums->ap, ums->ai, ums->ax);
if ( err != UMFPACK_OK )
{
fprintf(stderr,"UMFPACK error = %d\n",err);
EH(-1,"Error computing matrix transpose using umfpack_di_transpose\n");
}
break;
case 2: /* CSR FORMAT - NOT DONE YET */
EH(-1, "Sorry, cannot convert CSR systems");
break;
}
/* SET OPTIONS */
switch (*fact_optn) {
case -2: /* FULL ANALYSIS AND FACTORIZATION */
umf_option = 1;
break;
case -1: /* FACTORIZATION WITH PAST ANALYSIS */
umf_option = 0;
break;
case 0: /* FULL ANALYSIS AND FACTORIZATION */
umf_option = 1;
break;
case 1: /* FACTORIZATION WITH PAST ANALYSIS */
umf_option = 0;
break;
case 3:
umf_option = 0;
break;
default:
EH(-1, "Bad *fact_optn");
}
/* load default control parameters for UMF */
umfpack_di_defaults( Control );
/* optionally can ask for feedback from routines by uncommenting below */
/*Control[UMFPACK_PRL] = 2.;*/
/* optionally force solution strategy */
Control[UMFPACK_STRATEGY] = UMFPACK_STRATEGY_UNSYMMETRIC;
if ( umf_option == 1 ) {
/* analysis */
if ( ums->symbolic != NULL ) {
umfpack_di_free_symbolic(&ums->symbolic);
ums->symbolic = NULL;
}
err = umfpack_di_symbolic( ums->n, ums->n,
ums->ap, ums->ai, ums->ax,
&ums->symbolic, Control, Info );
umfpack_di_report_status(Control, err);
umfpack_di_report_info(Control, Info);
}
/* factorization */
if ( ums->numeric != NULL ) {
umfpack_di_free_numeric(&ums->numeric);
ums->numeric = NULL;
}
err = umfpack_di_numeric( ums->ap, ums->ai, ums->ax,
ums->symbolic, &ums->numeric, Control, Info );
umfpack_di_report_status(Control, err);
umfpack_di_report_info(Control, Info);
}
/* solve */
if ( *fact_optn >= 0 ) {
err = umfpack_di_solve( UMFPACK_A, ums->ap, ums->ai, ums->ax,
x, b,
ums->numeric, Control, Info );
umfpack_di_report_status(Control, err);
umfpack_di_report_info(Control, Info);
}
return system_id;
} /* END of routine SL_UMF */
int main (int argc, char **argv)
{
int i, j, k, n, nz, *Ap, *Ai, *Ti, *Tj, status, *Pamd, nrow, ncol, rhs ;
double *Ax, *b, *x, Control [UMFPACK_CONTROL], Info [UMFPACK_INFO], aij,
*Tx, *r, amd_Control [AMD_CONTROL], amd_Info [AMD_INFO], tamd [2],
stats [2], droptol ;
void *Symbolic, *Numeric ;
FILE *f, *f2 ;
char s [SMAX] ;
/* ---------------------------------------------------------------------- */
/* set controls */
/* ---------------------------------------------------------------------- */
printf ("\n===========================================================\n"
"=== UMFPACK v%d.%d.%d ========================================\n"
"===========================================================\n",
UMFPACK_MAIN_VERSION, UMFPACK_SUB_VERSION, UMFPACK_SUBSUB_VERSION) ;
umfpack_di_defaults (Control) ;
Control [UMFPACK_PRL] = 3 ;
Control [UMFPACK_BLOCK_SIZE] = 32 ;
f = fopen ("tmp/control.umf4", "r") ;
if (f != (FILE *) NULL)
{
printf ("Reading control file tmp/control.umf4\n") ;
for (i = 0 ; i < UMFPACK_CONTROL ; i++)
{
fscanf (f, "%lg\n", & Control [i]) ;
}
fclose (f) ;
}
if (argc > 1)
{
char *t = argv [1] ;
/* get the strategy */
if (t [0] == 'u')
{
Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_UNSYMMETRIC ;
}
else if (t [0] == 'a')
{
Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_AUTO ;
}
else if (t [0] == 's')
{
Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_SYMMETRIC ;
}
else if (t [0] == '2')
{
printf ("unrecognized strategy: %s\n", argv [1]) ;
}
else if (t [0] == 'U')
{
Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_UNSYMMETRIC ;
Control [UMFPACK_SCALE] = UMFPACK_SCALE_MAX ;
}
else if (t [0] == 'A')
{
Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_AUTO ;
Control [UMFPACK_SCALE] = UMFPACK_SCALE_MAX ;
}
else if (t [0] == 'S')
{
Control [UMFPACK_STRATEGY] = UMFPACK_STRATEGY_SYMMETRIC ;
Control [UMFPACK_SCALE] = UMFPACK_SCALE_MAX ;
}
else if (t [0] == 'T')
{
printf ("unrecognized strategy: %s\n", argv [1]) ;
}
else
{
printf ("unrecognized strategy: %s\n", argv [1]) ;
}
if (t [1] == 'n')
{
/* no aggressive absorption */
Control [UMFPACK_AGGRESSIVE] = FALSE ;
}
}
if (argc > 2)
{
/* get the drop tolerance */
sscanf (argv [2], "%lg", &droptol) ;
printf ("droptol %g\n", droptol) ;
Control [UMFPACK_DROPTOL] = droptol ;
}
umfpack_di_report_control (Control) ;
/* ---------------------------------------------------------------------- */
/* open the matrix file (tmp/A) */
/* ---------------------------------------------------------------------- */
printf ("File: tmp/A\n") ;
f = fopen ("tmp/A", "r") ;
if (!f)
{
printf ("Unable to open file\n") ;
exit (1) ;
}
/* ---------------------------------------------------------------------- */
/* get n and nz */
/* ---------------------------------------------------------------------- */
printf ("File: tmp/Asize\n") ;
f2 = fopen ("tmp/Asize", "r") ;
if (f2)
{
fscanf (f2, "%d %d %d\n", &nrow, &ncol, &nz) ;
fclose (f2) ;
}
else
{
nrow = 1 ;
ncol = 1 ;
}
nz = 0 ;
while (fgets (s, SMAX, f) != (char *) NULL)
{
sscanf (s, "%d %d %lg", &i, &j, &aij) ;
#ifdef ZERO_BASED
/* matrix is zero based */
i++ ;
j++ ;
#endif
nrow = MAX (nrow, i) ;
ncol = MAX (ncol, j) ;
nz++ ;
}
fclose (f) ;
n = MAX (nrow, ncol) ;
printf ("n %d nrow %d ncol %d nz %d\n", n, nrow, ncol, nz) ;
/* ---------------------------------------------------------------------- */
/* allocate space for the input triplet form */
/* ---------------------------------------------------------------------- */
Ti = (int *) malloc (nz * sizeof (int)) ;
Tj = (int *) malloc (nz * sizeof (int)) ;
Tx = (double *) malloc (nz * sizeof (double)) ;
if (!Ti || !Tj || !Tx)
{
printf ("out of memory for input matrix\n") ;
exit (1) ;
}
/* ---------------------------------------------------------------------- */
/* read in the triplet form */
/* ---------------------------------------------------------------------- */
f2 = fopen ("tmp/A", "r") ;
if (!f2)
{
printf ("Unable to open file\n") ;
exit (1) ;
}
k = 0 ;
while (fgets (s, SMAX, f2) != (char *) NULL)
{
sscanf (s, "%d %d %lg", &i, &j, &aij) ;
#ifndef ZERO_BASED
i-- ; /* convert to 0-based */
j-- ;
#endif
if (k >= nz)
{
printf ("Error! Matrix size is wrong\n") ;
exit (1) ;
}
Ti [k] = i ;
Tj [k] = j ;
Tx [k] = aij ;
k++ ;
}
fclose (f2) ;
(void) umfpack_di_report_triplet (nrow, ncol, nz, Ti, Tj, Tx, Control) ;
/* ---------------------------------------------------------------------- */
/* convert to column form */
/* ---------------------------------------------------------------------- */
/* convert to column form */
Ap = (int *) malloc ((n+1) * sizeof (int)) ;
Ai = (int *) malloc (nz * sizeof (int)) ;
Ax = (double *) malloc (nz * sizeof (double)) ;
b = (double *) malloc (n * sizeof (double)) ;
r = (double *) malloc (n * sizeof (double)) ;
x = (double *) malloc (n * sizeof (double)) ;
if (!Ap || !Ai || !Ax || !b || !r)
{
printf ("out of memory") ;
exit (1) ;
}
umfpack_tic (stats) ;
status = umfpack_di_triplet_to_col (nrow, ncol, nz, Ti, Tj, Tx, Ap, Ai, Ax,
(int *) NULL) ;
umfpack_toc (stats) ;
printf ("triplet-to-col time: wall %g cpu %g\n", stats [0], stats [1]) ;
if (status != UMFPACK_OK)
{
umfpack_di_report_status (Control, status) ;
printf ("umfpack_di_triplet_to_col failed") ;
exit (1) ;
}
/* print the column-form of A */
(void) umfpack_di_report_matrix (nrow, ncol, Ap, Ai, Ax, 1, Control) ;
/* b = A * xtrue */
rhs = FALSE ;
if (nrow == ncol)
{
f = fopen ("tmp/b", "r") ;
if (f != (FILE *) NULL)
{
printf ("Reading tmp/b\n") ;
rhs = TRUE ;
for (i = 0 ; i < n ; i++)
{
fscanf (f, "%lg\n", &b [i]) ;
}
fclose (f) ;
}
else
{
Atimesx (n, Ap, Ai, Ax, b, FALSE) ;
}
}
/* ---------------------------------------------------------------------- */
/* free the triplet form */
/* ---------------------------------------------------------------------- */
free (Ti) ;
free (Tj) ;
free (Tx) ;
/* ---------------------------------------------------------------------- */
/* symbolic factorization */
/* ---------------------------------------------------------------------- */
status = umfpack_di_symbolic (nrow, ncol, Ap, Ai, Ax, &Symbolic,
Control, Info) ;
umfpack_di_report_info (Control, Info) ;
if (status != UMFPACK_OK)
{
umfpack_di_report_status (Control, status) ;
printf ("umfpack_di_symbolic failed") ;
exit (1) ;
}
/* print the symbolic factorization */
(void) umfpack_di_report_symbolic (Symbolic, Control) ;
/* ---------------------------------------------------------------------- */
/* numeric factorization */
/* ---------------------------------------------------------------------- */
status = umfpack_di_numeric (Ap, Ai, Ax, Symbolic, &Numeric, Control, Info);
if (status < UMFPACK_OK)
{
umfpack_di_report_info (Control, Info) ;
umfpack_di_report_status (Control, status) ;
fprintf (stderr, "umfpack_di_numeric failed: %d\n", status) ;
printf ("umfpack_di_numeric failed\n") ;
exit (1) ;
}
/* print the numeric factorization */
(void) umfpack_di_report_numeric (Numeric, Control) ;
/* ---------------------------------------------------------------------- */
/* solve Ax=b */
/* ---------------------------------------------------------------------- */
if (nrow == ncol && status == UMFPACK_OK)
{
status = umfpack_di_solve (UMFPACK_A, Ap, Ai, Ax, x, b, Numeric,
Control, Info) ;
umfpack_di_report_info (Control, Info) ;
umfpack_di_report_status (Control, status) ;
if (status < UMFPACK_OK)
{
printf ("umfpack_di_solve failed\n") ;
exit (1) ;
}
(void) umfpack_di_report_vector (n, x, Control) ;
printf ("relative maxnorm of residual, ||Ax-b||/||b||: %g\n",
resid (n, Ap, Ai, Ax, x, r, b, FALSE)) ;
if (!rhs)
{
printf ("relative maxnorm of error, ||x-xtrue||/||xtrue||: %g\n\n",
err (n, x)) ;
}
f = fopen ("tmp/x", "w") ;
if (f != (FILE *) NULL)
{
printf ("Writing tmp/x\n") ;
for (i = 0 ; i < n ; i++)
{
fprintf (f, "%30.20e\n", x [i]) ;
}
fclose (f) ;
}
else
{
printf ("Unable to write output x!\n") ;
exit (1) ;
}
f = fopen ("tmp/info.umf4", "w") ;
if (f != (FILE *) NULL)
{
printf ("Writing tmp/info.umf4\n") ;
for (i = 0 ; i < UMFPACK_INFO ; i++)
{
fprintf (f, "%30.20e\n", Info [i]) ;
}
fclose (f) ;
}
else
{
printf ("Unable to write output info!\n") ;
exit (1) ;
}
}
else
{
/* don't solve, just report the results */
umfpack_di_report_info (Control, Info) ;
umfpack_di_report_status (Control, status) ;
}
/* ---------------------------------------------------------------------- */
/* free the Symbolic and Numeric factorization */
/* ---------------------------------------------------------------------- */
umfpack_di_free_symbolic (&Symbolic) ;
umfpack_di_free_numeric (&Numeric) ;
printf ("umf4 done, strategy: %g\n", Control [UMFPACK_STRATEGY]) ;
/* ---------------------------------------------------------------------- */
/* test just AMD ordering (not part of UMFPACK, but a separate test) */
/* ---------------------------------------------------------------------- */
/* first make the matrix square */
if (ncol < n)
{
for (j = ncol+1 ; j <= n ; j++)
{
Ap [j] = Ap [ncol] ;
}
}
printf (
"\n\n===========================================================\n"
"=== AMD ===================================================\n"
"===========================================================\n") ;
printf ("\n\n------- Now trying the AMD ordering. This not part of\n"
"the UMFPACK analysis or factorization, above, but a separate\n"
"test of just the AMD ordering routine.\n") ;
Pamd = (int *) malloc (n * sizeof (int)) ;
if (!Pamd)
{
printf ("out of memory\n") ;
exit (1) ;
}
amd_defaults (amd_Control) ;
amd_control (amd_Control) ;
umfpack_tic (tamd) ;
status = amd_order (n, Ap, Ai, Pamd, amd_Control, amd_Info) ;
umfpack_toc (tamd) ;
printf ("AMD ordering time: cpu %10.2f wall %10.2f\n",
tamd [1], tamd [0]) ;
if (status != AMD_OK)
{
printf ("amd failed: %d\n", status) ;
exit (1) ;
}
amd_info (amd_Info) ;
free (Pamd) ;
printf ("AMD test done\n") ;
free (Ap) ;
free (Ai) ;
free (Ax) ;
free (b) ;
free (r) ;
free (x) ;
return (0) ;
}
void solve_linear_system(const int_vector& lhs_row_index,
const int_vector& lhs_col_index,
const dbl_vector& lhs_values,
dbl_vector rhs,
dbl_vector& out_solution,
void* numeric)
{
// Assume lhs is square.
unsigned long num_nonzero = lhs_values.size();
unsigned long num_rows = rhs.size();
// Convert lhs matrix into the format used in UMFPACK.
int* ti;
int* tj;
double* tx;
int* ap;
int* ai;
double* ax;
double* x;
double* b;
ti = new int[num_nonzero];
ELOG("ti memory allocated...");
tj = new int[num_nonzero];
ELOG("tj memory allocated...");
tx = new double[num_nonzero];
ELOG("tx memory allocated...");
// Copy to input data.
for(unsigned long i = 0; i < num_nonzero; i++) {
ti[i] = lhs_row_index(i);
tj[i] = lhs_col_index(i);
tx[i] = lhs_values(i);
ELOG("ti, tj, tx (", i, ") = ",
ti[i], ", ", tj[i], ", ", tx[i], ", ");
}
ap = new int[num_rows + 1];
ELOG("ap memory allocated...");
ai = new int[num_rows * num_rows];
ELOG("ai memory allocated...");
ax = new double[num_rows * num_rows];
ELOG("ax memory allocated...");
umfpack_di_triplet_to_col(num_rows, num_rows, num_nonzero,
ti, tj, tx,
ap, ai, ax,
null_int);
delete [] ti;
delete [] tj;
delete [] tx;
x = new double[num_rows];
ELOG("x memory allocated...");
b = new double[num_rows];
ELOG("b memory allocated...");
ELOG("Define right hand side...");
// Set right hand side equal to portfolio.
for(unsigned long i = 0; i < num_rows; ++i)
b[i] = rhs(i);
ELOG("Rhs to solve = ", rhs);
#ifdef DEBUG
for(unsigned long i = 0; i < num_rows + 1; ++i)
ELOG("ap[", i, "] = ", ap[i]);
for(unsigned long i_row = 0;
i_row < num_rows; ++i_row) {
for(unsigned long i_col = 0;
i_col < num_rows; ++i_col) {
ELOG("A(", i_row, ",", i_col, ") = ", ax[ap[i_col] + i_row]);
}
ELOG("b(", i_row, ") = ", b[i_row]);
}
#endif
// Sovle system by LU factorization.
void *symbolic;
// If the numeric pointer is void then we need to perform the
// factorization.
if(numeric == null_void) {
umfpack_di_symbolic(num_rows, num_rows,
ap, ai, ax,
&symbolic, null_double, null_double);
umfpack_di_numeric(ap, ai, ax,
symbolic, &numeric, null_double, null_double);
umfpack_di_free_symbolic(&symbolic);
}
umfpack_di_solve(UMFPACK_A, ap, ai, ax, x, b,
numeric, null_double, null_double);
#ifdef DEBUG
// Calculate determinant for diagnostics.
double *det = new double[2];
umfpack_di_get_determinant(det, null_double, numeric, null_double);
ELOG("Determinant of second moment = ", det[0]);
delete[] det;
#endif
// Do not free the numeric pointer because this function does not own it.
// Store the solution in the output argument.
for(unsigned long i = 0; i < num_rows; ++i)
out_solution(i) = x[i];
// Free memory.
delete[] ap;
delete[] ai;
delete[] ax;
delete[] x;
delete[] b;
}
