int main ( int argc, char *argv[] )
/**********************************************************************/
/*
Purpose:
SUPER_LU_D0 runs a small 5 by 5 example of the use of SUPER_LU.
Modified:
23 April 2004
Reference:
James Demmel, John Gilbert, Xiaoye Li,
SuperLU Users's Guide,
Sections 1 and 2.
*/
{
double *a;
SuperMatrix A;
int *asub;
SuperMatrix B;
int i;
int info;
SuperMatrix L;
int m;
int n;
int nnz;
int nrhs;
superlu_options_t options;
int *perm_c;
int *perm_r;
int permc_spec;
double *rhs;
double sol[5];
SuperLUStat_t stat;
SuperMatrix U;
int *xa;
/*
Say hello.
*/
printf ( "\n" );
printf ( "SUPER_LU_D0:\n" );
printf ( " Simple 5 by 5 example of SUPER_LU solver.\n" );
/*
Initialize parameters.
*/
m = 5;
n = 5;
nnz = 12;
/*
Set aside space for the arrays.
*/
a = doubleMalloc ( nnz );
if ( !a )
{
ABORT ( "Malloc fails for a[]." );
}
asub = intMalloc ( nnz );
if ( !asub )
{
ABORT ( "Malloc fails for asub[]." );
}
xa = intMalloc ( n+1 );
if ( !xa )
{
ABORT ( "Malloc fails for xa[]." );
}
/*
Initialize matrix A.
*/
a[0] = 19.0;
a[1] = 12.0;
a[2] = 12.0;
a[3] = 21.0;
a[4] = 12.0;
a[5] = 12.0;
a[6] = 21.0;
a[7] = 16.0;
a[8] = 21.0;
a[9] = 5.0;
a[10]= 21.0;
a[11]= 18.0;
asub[0] = 0;
asub[1] = 1;
asub[2] = 4;
asub[3] = 1;
asub[4] = 2;
asub[5] = 4;
asub[6] = 0;
asub[7] = 2;
asub[8] = 0;
asub[9] = 3;
asub[10]= 3;
asub[11]= 4;
xa[0] = 0;
xa[1] = 3;
xa[2] = 6;
xa[3] = 8;
xa[4] = 10;
xa[5] = 12;
sol[0] = -0.031250000;
sol[1] = 0.065476190;
sol[2] = 0.013392857;
sol[3] = 0.062500000;
sol[4] = 0.032738095;
/*
Create matrix A in the format expected by SuperLU.
*/
dCreate_CompCol_Matrix ( &A, m, n, nnz, a, asub, xa, SLU_NC, SLU_D, SLU_GE );
/*
Create the right-hand side matrix B.
*/
nrhs = 1;
rhs = doubleMalloc ( m * nrhs );
if ( !rhs )
{
ABORT("Malloc fails for rhs[].");
}
for ( i = 0; i < m; i++ )
{
rhs[i] = 1.0;
}
dCreate_Dense_Matrix ( &B, m, nrhs, rhs, m, SLU_DN, SLU_D, SLU_GE );
/*
Set up the arrays for the permutations.
*/
perm_r = intMalloc ( m );
if ( !perm_r )
{
ABORT ( "Malloc fails for perm_r[]." );
}
perm_c = intMalloc ( n );
if ( !perm_c )
{
ABORT ( "Malloc fails for perm_c[]." );
}
/*
Set the default input options, and then adjust some of them.
*/
set_default_options ( &options );
options.ColPerm = NATURAL;
/*
Initialize the statistics variables.
*/
StatInit ( &stat );
/*
Factor the matrix and solve the linear system.
*/
dgssv ( &options, &A, perm_c, perm_r, &L, &U, &B, &stat, &info );
/*
Print some of the results.
*/
dPrint_CompCol_Matrix ( "Matrix A", &A );
dPrint_SuperNode_Matrix ( "Factor L", &L );
dPrint_CompCol_Matrix ( "Factor U", &U );
dPrint_Dense_Matrix ( "Solution X", &B );
printf ( "\n" );
printf ( " The exact solution:\n" );
printf ( "\n" );
for ( i = 0; i < n; i++ )
{
printf ( "%d %f\n", i, sol[i] );
}
printf ( "\n" );
print_int_vec ( "perm_r", m, perm_r );
/*
De-allocate storage.
*/
SUPERLU_FREE ( rhs );
SUPERLU_FREE ( perm_r );
SUPERLU_FREE ( perm_c );
Destroy_CompCol_Matrix ( &A );
Destroy_SuperMatrix_Store ( &B );
Destroy_SuperNode_Matrix ( &L );
Destroy_CompCol_Matrix ( &U );
StatFree ( &stat );
printf ( "\n" );
printf ( "SUPER_LU_D0:\n" );
printf ( " Normal end of execution.\n" );
return 0;
}
int main ( )
/******************************************************************************/
/*
Purpose:
D_SAMPLE_ST tests the SUPERLU solver with a 5x5 double precision real matrix.
Discussion:
The general (GE) representation of the matrix is:
[ 19 0 21 21 0
12 21 0 0 0
0 12 16 0 0
0 0 0 5 21
12 12 0 0 18 ]
The (0-based) compressed column (CC) representation of this matrix is:
I CC A
-- -- --
0 0 19
1 12
4 12
1 3 21
2 12
4 12
0 6 21
2 16
0 8 21
3 5
3 10 21
4 18
* 12 *
The right hand side B and solution X are
# B X
-- -- ----------
0 1 -0.03125
1 1 0.0654762
2 1 0.0133929
3 1 0.0625
4 1 0.0327381
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
18 July 2014
Author:
John Burkardt
Reference:
James Demmel, John Gilbert, Xiaoye Li,
SuperLU Users's Guide.
*/
{
SuperMatrix A;
double *acc;
double *b;
double *b2;
SuperMatrix B;
int *ccc;
int i;
int *icc;
int info;
int j;
SuperMatrix L;
int m;
int n;
int nrhs = 1;
int ncc;
superlu_options_t options;
int *perm_c;
int permc_spec;
int *perm_r;
SuperLUStat_t stat;
SuperMatrix U;
timestamp ( );
printf ( "\n" );
printf ( "D_SAMPLE_ST:\n" );
printf ( " C version\n" );
printf ( " SUPERLU solves a double precision real linear system.\n" );
printf ( " The matrix is read from a Sparse Triplet (ST) file.\n" );
/*
Read the matrix from a file associated with standard input,
in sparse triplet (ST) format, into compressed column (CC) format.
*/
dreadtriple ( &m, &n, &ncc, &acc, &icc, &ccc );
/*
Print the matrix.
*/
cc_print ( m, n, ncc, icc, ccc, acc, " CC Matrix:" );
/*
Convert the compressed column (CC) matrix into a SuperMatrix A.
*/
dCreate_CompCol_Matrix ( &A, m, n, ncc, acc, icc, ccc, SLU_NC, SLU_D, SLU_GE );
/*
Create the right-hand side matrix.
*/
b = ( double * ) malloc ( m * sizeof ( double ) );
for ( i = 0; i < m; i++ )
{
b[i] = 1.0;
}
printf ( "\n" );
printf ( " Right hand side:\n" );
printf ( "\n" );
for ( i = 0; i < m; i++ )
{
printf ( "%g\n", b[i] );
}
/*
Create Super Right Hand Side.
*/
dCreate_Dense_Matrix ( &B, m, nrhs, b, m, SLU_DN, SLU_D, SLU_GE );
/*
Set space for the permutations.
*/
perm_r = ( int * ) malloc ( m * sizeof ( int ) );
perm_c = ( int * ) malloc ( n * sizeof ( int ) );
/*
Set the input options.
*/
set_default_options ( &options );
options.ColPerm = NATURAL;
/*
Initialize the statistics variables.
*/
StatInit ( &stat );
/*
Solve the linear system.
*/
dgssv ( &options, &A, perm_c, perm_r, &L, &U, &B, &stat, &info );
dPrint_CompCol_Matrix ( ( char * ) "A", &A );
dPrint_CompCol_Matrix ( ( char * ) "U", &U );
dPrint_SuperNode_Matrix ( ( char * ) "L", &L );
print_int_vec ( ( char * ) "\nperm_r", m, perm_r );
/*
By some miracle involving addresses,
the solution has been put into the B vector.
*/
printf ( "\n" );
printf ( " Computed solution:\n" );
printf ( "\n" );
for ( i = 0; i < m; i++ )
{
printf ( "%g\n", b[i] );
}
/*
Demonstrate that RHS is really the solution now.
Multiply it by the matrix.
*/
b2 = cc_mv ( m, n, ncc, icc, ccc, acc, b );
printf ( "\n" );
printf ( " Product A*X:\n" );
printf ( "\n" );
for ( i = 0; i < m; i++ )
{
printf ( "%g\n", b2[i] );
}
/*
Free memory.
*/
free ( b );
free ( b2 );
free ( perm_c );
free ( perm_r );
Destroy_SuperMatrix_Store ( &A );
Destroy_SuperMatrix_Store ( &B );
Destroy_SuperNode_Matrix ( &L );
Destroy_CompCol_Matrix ( &U );
StatFree ( &stat );
/*
Terminate.
*/
printf ( "\n" );
printf ( "D_SAMPLE_ST:\n" );
printf ( " Normal end of execution.\n" );
printf ( "\n" );
timestamp ( );
return 0;
}
