//
// functions for symbolic solver
//
DllExport void * CreaterCGSolver
(int n, int nnz, int *rowIndex, int *colIndex, double *value)
{
int currCol = -1;
char* options[] = {"taucs.factor.LLT=true", NULL};
struct CGSolver_tag * s = (struct CGSolver_tag*) malloc(sizeof(struct CGSolver_tag));
if (s == NULL) return NULL;
s->n = n;
s->matrix = NULL;
//open log file
taucs_logfile("c:/log.txt");
// create matrix
s->matrix = taucs_ccs_create(n, n, nnz, TAUCS_DOUBLE|TAUCS_LOWER|TAUCS_SYMMETRIC);
if (s->matrix == NULL) return NULL;
// copy elements to matrix
memcpy(s->matrix->rowind, rowIndex, sizeof(int) * nnz);
memcpy(s->matrix->values.d, value, sizeof(double) * nnz);
memcpy(s->matrix->colptr, colIndex, sizeof(int) * (n+1));
taucs_logfile("none");
return s;
}
DllExport int SolveCG(void * sp, double *x, double *b) {
int rc;
char* options [] = {"taucs.solve.cg=true", NULL};
struct Solver_tag * s = (struct Solver_tag *) sp;
void * F = NULL;
if (s->matrix == NULL || s->factorization == NULL) return -1;
//open log file
taucs_logfile("c:/log.txt");
rc = taucs_linsolve(s->matrix, &F, 1, x, b, options, NULL);
if (rc != TAUCS_SUCCESS) return rc;
taucs_logfile("none");
return 0;
}
int main()
{
int xyz = 20;
int i;
taucs_ccs_matrix* A;
void* f;
void* fc;
double* X;
double* B;
double* Y;
double* Z;
taucs_logfile("stdout");
A = taucs_ccs_generate_mesh3d(xyz,xyz,xyz);
if (!A) {
taucs_printf("Matrix generation failed\n");
return 1;
}
X =(double*)malloc((A->n)*sizeof(double));
B =(double*)malloc((A->n)*sizeof(double));
Y =(double*)malloc((A->n)*sizeof(double));
Z =(double*)malloc((A->n)*sizeof(double));
if (!X || !B || !Y || !Z) {
taucs_printf("Vector allocation failed\n");
return 1;
}
for(i=0; i<A->n; i++) X[i]=((double)random()/RAND_MAX);
taucs_ccs_times_vec(A,X,B);
if (test_spd_factorsolve(A,X,Y,B,Z)) {
printf("SPD FACTOR-SOLVE FAILED\n");
return 1;
}
if (test_spd_orderings(A,X,Y,B,Z)) {
printf("SPD ORDERING FAILED\n");
return 1;
}
if (test_spd_factorizations(A,X,Y,B,Z)) {
printf("SPD FACTORIZATION FAILED\n");
return 1;
}
taucs_printf("test succeeded\n");
return 0;
}
int main()
{
int n;
taucs_logfile("stdout");
taucs_maximize_stacksize();
for (n=1; n<2000000; n *= 2) {
printf("test_stack: depth %d, starting\n",n);
recursive(n,0);
printf("test_stack: depth %d, done\n",n);
}
return 0;
}
int main(int argc, char* argv[])
{
double start;
int rc;
int i,j;
taucs_ccs_matrix* A = NULL;
void* X;
void* B;
void* Y;
void* Z;
void* opt_arg[] = { NULL };
double opt_nrhs = 1.0;
char* opt_ijv = NULL;
char* opt_ijv_zero = NULL;
char* opt_hb = NULL;
char* opt_bin = NULL;
char* opt_log = "stdout";
double opt_3d = -1.0;
double opt_2d = -1.0;
char* opt_2d_type = "dirichlet";
int opt_3d_rand = 0;/*not random*/
double opt_3d_small = -1.0;/*regular*/
double opt_shift = 0.0;
int opt_sreal = 0;
int opt_dreal = 0;
int opt_scomplex = 0;
int opt_dcomplex = 0;
int datatype = TAUCS_DOUBLE;
int opt_all1rhs = 0;
double rerr;
for (i=0; argv[i]; i++) {
int understood = FALSE;
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.sreal",&opt_sreal);
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.dreal",&opt_dreal);
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.scomplex",&opt_scomplex);
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.dcomplex",&opt_dcomplex);
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.ijv",&opt_ijv);
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.ijvz",&opt_ijv_zero);
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.hb", &opt_hb );
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.bin", &opt_bin );
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.log",&opt_log);
understood |= taucs_getopt_double(argv[i],opt_arg,"taucs_run.mesh3d",&opt_3d);
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.mesh3d.rand",&opt_3d_rand);
understood |= taucs_getopt_double(argv[i],opt_arg,"taucs_run.mesh3d.small",&opt_3d_small);
understood |= taucs_getopt_double(argv[i],opt_arg,"taucs_run.mesh2d",&opt_2d);
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.mesh2d.type",&opt_2d_type);
understood |= taucs_getopt_double(argv[i],opt_arg,"taucs_run.shift",&opt_shift);
understood |= taucs_getopt_double(argv[i],opt_arg,"taucs_run.nrhs",&opt_nrhs);
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.params",&gl_parameters);
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.all1rhs",&opt_all1rhs);
if (!understood) taucs_printf("taucs_run: illegal option [%s]\n",
argv[i]);
}
if (opt_sreal ) datatype = TAUCS_SINGLE;
if (opt_dreal ) datatype = TAUCS_DOUBLE;
if (opt_scomplex) datatype = TAUCS_SCOMPLEX;
if (opt_dcomplex) datatype = TAUCS_DCOMPLEX;
taucs_logfile(opt_log);
if (opt_3d > 0) {
if ( opt_3d_small > 0 ) {
A = taucs_ccs_generate_mesh3d_random((int)opt_3d_small,(int)opt_3d,(int)opt_3d,opt_3d_rand);
}
A = taucs_ccs_generate_mesh3d_random((int)opt_3d,(int)opt_3d,(int)opt_3d,opt_3d_rand);
if (!A) {
taucs_printf("Matrix generation failed\n");
return 1;
}
datatype = TAUCS_DOUBLE;
}
if (opt_2d > 0) {
A = taucs_ccs_generate_mesh2d((int)opt_2d,opt_2d_type);
if (!A) {
taucs_printf("Matrix generation failed\n");
return 1;
}
datatype = TAUCS_DOUBLE;
}
if (opt_ijv) {
switch (datatype) {
case TAUCS_SINGLE:
A = taucs_ccs_read_ijv (opt_ijv,TAUCS_SYMMETRIC | TAUCS_SINGLE); break;
break;
case TAUCS_DOUBLE:
A = taucs_ccs_read_ijv (opt_ijv,TAUCS_SYMMETRIC | TAUCS_DOUBLE); break;
break;
case TAUCS_SCOMPLEX:
A = taucs_ccs_read_ijv (opt_ijv,TAUCS_HERMITIAN | TAUCS_SCOMPLEX); break;
break;
case TAUCS_DCOMPLEX:
A = taucs_ccs_read_ijv (opt_ijv,TAUCS_HERMITIAN | TAUCS_DCOMPLEX); break;
break;
default:
taucs_printf("taucs_run: incorrect datatype\n");
return 1;
break;
}
}
if (opt_ijv_zero) {
switch (datatype) {
case TAUCS_SINGLE:
A = taucs_ccs_read_ijv_zero_based (opt_ijv_zero,TAUCS_SYMMETRIC | TAUCS_SINGLE); break;
break;
case TAUCS_DOUBLE:
A = taucs_ccs_read_ijv_zero_based (opt_ijv_zero,TAUCS_SYMMETRIC | TAUCS_DOUBLE); break;
break;
case TAUCS_SCOMPLEX:
A = taucs_ccs_read_ijv_zero_based(opt_ijv_zero,TAUCS_HERMITIAN | TAUCS_SCOMPLEX); break;
break;
case TAUCS_DCOMPLEX:
A = taucs_ccs_read_ijv_zero_based(opt_ijv_zero,TAUCS_HERMITIAN | TAUCS_DCOMPLEX); break;
break;
default:
taucs_printf("taucs_run: incorrect datatype\n");
return 1;
break;
}
}
if (opt_hb) {
switch (datatype) {
case TAUCS_SINGLE:
A = taucs_ccs_read_hb (opt_hb, TAUCS_SINGLE); break;
break;
case TAUCS_DOUBLE:
A = taucs_ccs_read_hb (opt_hb, TAUCS_DOUBLE); break;
break;
case TAUCS_SCOMPLEX:
A = taucs_ccs_read_hb (opt_hb, TAUCS_SCOMPLEX); break;
break;
case TAUCS_DCOMPLEX:
A = taucs_ccs_read_hb (opt_hb, TAUCS_DCOMPLEX); break;
break;
default:
taucs_printf("taucs_run: incorrect datatype\n");
return 1;
break;
}
datatype = A->flags;
}
if (opt_bin) {
A = taucs_ccs_read_binary(opt_bin);
}
if (!A) {
taucs_printf("taucs_run: there is no matrix!\n");
return 1;
}
if (opt_shift) {
int i,j;
int ip;
if (datatype & TAUCS_DOUBLE) {
for (j=0; j<A->n; j++) {
int found = 0;
for (ip = (A->colptr)[j]; ip < (A->colptr)[j+1]; ip++) {
i = (A->rowind)[ip];
if (i == j) {
(A->values.d)[ip] += opt_shift;
found = 1;
break;
}
}
if (!found) {
taucs_printf("taucs_run: the matrix is missing a diagonal element so I can't shift\n");
return 1;
}
}
} else {
taucs_printf("taucs_run: shift only works on double-precision matrices\n");
return 1;
}
}
taucs_printf("taucs_run: matrix dimentions %d by %d with %d nonzeros\n",
A->m, A->n, (A->colptr)[ A->n ]);
X = taucs_vec_create((A->n)*(int)opt_nrhs,A->flags);
B = taucs_vec_create((A->m)*(int)opt_nrhs,A->flags);
Y = taucs_vec_create((A->n)*(int)opt_nrhs,A->flags);
Z = taucs_vec_create((A->m)*(int)opt_nrhs,A->flags);
if (!X || !B || !Y || !Z) {
taucs_printf("taucs_run: vector allocation failed\n");
return 1;
}
if (!opt_all1rhs) {
for(j=0;j<(int)opt_nrhs;j++) {
for(i=0; i<A->n; i++) {
#ifdef TAUCS_SINGLE_IN_BUILD
if (datatype & TAUCS_SINGLE)
((taucs_single*)X)[i+j*(A->n)]=(taucs_single) ((double)rand()/(double)RAND_MAX);
#endif
#ifdef TAUCS_DOUBLE_IN_BUILD
if (datatype & TAUCS_DOUBLE)
//((taucs_double*)X)[i+j*(A->n)]=(taucs_double) ((double)rand()/(double)RAND_MAX);
((taucs_double*)X)[i+j*(A->n)]=0.1 + i * 0.01;
#endif
#ifdef TAUCS_SCOMPLEX_IN_BUILD
if (datatype & TAUCS_SCOMPLEX) {
taucs_single cre,cim;
cre = (taucs_single) ((double)rand()/(double)RAND_MAX);
cim = (taucs_single) ((double)rand()/(double)RAND_MAX);
((taucs_scomplex*)X)[i+j*(A->n)] = taucs_ccomplex_create(cre,cim);
}
#endif
#ifdef TAUCS_DCOMPLEX_IN_BUILD
if (datatype & TAUCS_DCOMPLEX) {
taucs_single zre,zim;
zre = (taucs_double) ((double)rand()/(double)RAND_MAX);
zim = (taucs_double) ((double)rand()/(double)RAND_MAX);
((taucs_dcomplex*)X)[i+j*(A->n)] = taucs_zcomplex_create(zre,zim);
}
#endif
}
}
taucs_ccs_times_vec_many(A,X,B,(int)opt_nrhs);
} else {
for(j=0;j<(int)opt_nrhs;j++) {
for(i=0; i<A->m; i++) {
#ifdef TAUCS_SINGLE_IN_BUILD
if (datatype & TAUCS_SINGLE)
((taucs_single*)B)[i+j*(A->m)]= 1.0;
#endif
#ifdef TAUCS_DOUBLE_IN_BUILD
if (datatype & TAUCS_DOUBLE)
((taucs_double*)B)[i+j*(A->m)]= 1.0;
#endif
#ifdef TAUCS_SCOMPLEX_IN_BUILD
if (datatype & TAUCS_SCOMPLEX) {
taucs_single cre,cim;
cre = 1.0;
cim = 0.0;
((taucs_scomplex*)B)[i+j*(A->m)] = taucs_ccomplex_create(cre,cim);
}
#endif
#ifdef TAUCS_DCOMPLEX_IN_BUILD
if (datatype & TAUCS_DCOMPLEX) {
taucs_single zre,zim;
zre = 1.0;
zim = 0.0;
((taucs_dcomplex*)B)[i+j*(A->m)] = taucs_zcomplex_create(zre,zim);
}
#endif
}
}
}
start = taucs_wtime();
rc = taucs_linsolve(A,NULL,(int)opt_nrhs,Y,B,argv,opt_arg);
taucs_printf("total solve time is %.2e sec\n", taucs_wtime() - start);
if (!opt_all1rhs && opt_nrhs == 1) {
taucs_vec_axpby_many(A->n,A->flags,1.0,X,-1.0,Y,Z,(int)opt_nrhs);
rerr = taucs_vec_norm2(A->n, A->flags,Z) / taucs_vec_norm2(A->n, A->flags, X);
taucs_printf("relative 2-norm of error is %.2e\n", rerr);
}
rnorm_many(A,Y,B,Z,(int)opt_nrhs);
if (opt_nrhs == 1)
{
double xnorm = taucs_vec_norm2(A->n,A->flags,Y);
taucs_printf("2-norm of x is %.2e\n", xnorm);
}
// Silencing valgrind
if (X)
taucs_vec_free(A->flags,X);
if (B)
taucs_vec_free(A->flags,B);
if (Y)
taucs_vec_free(A->flags,Y);
if (Z)
taucs_vec_free(A->flags,Z);
taucs_ccs_free(A);
return 0;
}
int main(int argc, char* argv[])
{
int rc;
int i;
taucs_ccs_matrix* A = NULL;
void* X;
void* B;
void* Y;
void* Z;
void* opt_arg[] = { NULL };
char* opt_ijv = NULL;
char* opt_hb = NULL;
char* opt_log = "stdout";
double opt_3d = -1.0;
double opt_2d = -1.0;
char* opt_2d_type = "dirichlet";
int opt_sreal = 0;
int opt_dreal = 0;
int opt_scomplex = 0;
int opt_dcomplex = 0;
int datatype = TAUCS_DOUBLE;
for (i=0; argv[i]; i++) {
int understood = FALSE;
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.sreal",&opt_sreal);
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.dreal",&opt_dreal);
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.scomplex",&opt_scomplex);
understood |= taucs_getopt_boolean(argv[i],opt_arg,"taucs_run.dcomplex",&opt_dcomplex);
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.ijv",&opt_ijv);
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.hb", &opt_hb );
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.log",&opt_log);
understood |= taucs_getopt_double(argv[i],opt_arg,"taucs_run.mesh3d",&opt_3d);
understood |= taucs_getopt_double(argv[i],opt_arg,"taucs_run.mesh2d",&opt_2d);
understood |= taucs_getopt_string(argv[i],opt_arg,"taucs_run.mesh2d.type",&opt_2d_type);
if (!understood) taucs_printf("taucs_run: illegal option [%s]\n",
argv[i]);
}
if (opt_sreal ) datatype = TAUCS_SINGLE;
if (opt_dreal ) datatype = TAUCS_DOUBLE;
if (opt_scomplex) datatype = TAUCS_SCOMPLEX;
if (opt_dcomplex) datatype = TAUCS_DCOMPLEX;
taucs_logfile(opt_log);
if (opt_3d > 0) {
A = taucs_ccs_generate_mesh3d((int)opt_3d,(int)opt_3d,(int)opt_3d);
if (!A) {
taucs_printf("Matrix generation failed\n");
return 1;
}
datatype = TAUCS_DOUBLE;
}
if (opt_2d > 0) {
A = taucs_ccs_generate_mesh2d((int)opt_2d,opt_2d_type);
if (!A) {
taucs_printf("Matrix generation failed\n");
return 1;
}
datatype = TAUCS_DOUBLE;
}
if (opt_ijv) {
switch (datatype) {
case TAUCS_SINGLE:
A = taucs_ccs_read_ijv (opt_ijv,TAUCS_SYMMETRIC | TAUCS_SINGLE); break;
break;
case TAUCS_DOUBLE:
A = taucs_ccs_read_ijv (opt_ijv,TAUCS_SYMMETRIC | TAUCS_DOUBLE); break;
break;
case TAUCS_SCOMPLEX:
A = taucs_ccs_read_ijv (opt_ijv,TAUCS_HERMITIAN | TAUCS_SCOMPLEX); break;
break;
case TAUCS_DCOMPLEX:
A = taucs_ccs_read_ijv (opt_ijv,TAUCS_HERMITIAN | TAUCS_DCOMPLEX); break;
break;
default:
taucs_printf("taucs_run: incorrect datatype\n");
return 1;
break;
}
}
if (opt_hb) {
switch (datatype) {
case TAUCS_SINGLE:
A = taucs_ccs_read_hb (opt_hb, TAUCS_SINGLE); break;
break;
case TAUCS_DOUBLE:
A = taucs_ccs_read_hb (opt_hb, TAUCS_DOUBLE); break;
break;
case TAUCS_SCOMPLEX:
A = taucs_ccs_read_hb (opt_hb, TAUCS_SCOMPLEX); break;
break;
case TAUCS_DCOMPLEX:
A = taucs_ccs_read_hb (opt_hb, TAUCS_DCOMPLEX); break;
break;
default:
taucs_printf("taucs_run: incorrect datatype\n");
return 1;
break;
}
datatype = A->flags;
}
if (!A) {
taucs_printf("taucs_run: there is no matrix!\n");
return 1;
}
X = taucs_vec_create(A->n,A->flags);
B = taucs_vec_create(A->n,A->flags);
Y = taucs_vec_create(A->n,A->flags);
Z = taucs_vec_create(A->n,A->flags);
if (!X || !B || !Y || !Z) {
taucs_printf("taucs_run: vector allocation failed\n");
return 1;
}
for(i=0; i<A->n; i++) {
if (datatype & TAUCS_SINGLE)
((taucs_single*)X)[i]=(taucs_single) ((double)rand()/(double)RAND_MAX);
if (datatype & TAUCS_DOUBLE)
((taucs_double*)X)[i]=(taucs_double) ((double)rand()/(double)RAND_MAX);
if (datatype & TAUCS_SCOMPLEX) {
taucs_single cre,cim;
cre = (taucs_single) ((double)rand()/(double)RAND_MAX);
cim = (taucs_single) ((double)rand()/(double)RAND_MAX);
((taucs_scomplex*)X)[i] = taucs_ccomplex_create(cre,cim);
}
if (datatype & TAUCS_DCOMPLEX) {
taucs_single zre,zim;
zre = (taucs_double) ((double)rand()/(double)RAND_MAX);
zim = (taucs_double) ((double)rand()/(double)RAND_MAX);
((taucs_dcomplex*)X)[i] = taucs_zcomplex_create(zre,zim);
}
}
taucs_ccs_times_vec(A,X,B);
rc = taucs_linsolve(A,NULL,1,Y,B,argv,opt_arg);
rnorm(A,Y,B,Z);
return 0;
}
/* Actual mex function */
void mexFunction(int nargout, mxArray *argout[], int nargin, const mxArray *argin[])
{
const mxArray *matlab_A;
taucs_ccs_matrix A, *R;
taucs_multiqr_factor *F;
int *column_order, *icol_order;
double *pr, *B, max_kappa_R;
int i, nrhs;
if (nargin > 2)
taucs_logfile("/tmp/taucs_qr.log");
/* Make sure A is sparse */
matlab_A = argin[0];
if (!mxIsSparse(matlab_A))
{
mexPrintf("input matrix A must be sparse\n");
return;
}
max_kappa_R = mxGetScalar(argin[1]);
/* Get B */
if (nargin > 2 && !mxIsEmpty(argin[2]) && mxIsDouble(argin[2]))
{
argout[2] = mxDuplicateArray(argin[2]);
B = mxGetPr(argout[2]);
nrhs = mxGetN(argout[2]);
} else
{
if (nargout > 2)
argout[2] = mxCreateDoubleMatrix(0, 0, mxREAL);
B = NULL;
nrhs = 0;
}
/* now we can convert to matrix */
fill_taucs_ccs_matrix(matlab_A, &A);
/* Run factorizatrization */
double tstart = get_cpu_time();
taucs_ccs_order(&A, &column_order, &icol_order, "colamd");
F = taucs_ccs_factor_pseudo_qr(&A, column_order, max_kappa_R, 0, B, nrhs);
free(column_order);
free(icol_order);
if (F == NULL)
{
mexPrintf("Factorization failed\n");fflush(stdout);
return;
}
if (nargin > 3)
mexPrintf("Actual factor time is %.2es\n", get_cpu_time() - tstart);
/* Copy to matlab allocated structure (just to make sure no problems with free */
tstart = get_cpu_time();
R = taucs_multiqr_get_R(F, &column_order);
argout[0] = convert_taucs_ccs_2_matlab(R);
argout[1] = mxCreateDoubleMatrix(1, A.n, mxREAL);
pr = mxGetPr(argout[1]);
for(i = 0; i < A.n; i++)
pr[i] = column_order[i] + 1;
free(column_order);
if (nargin > 3)
mexPrintf("Getting result time is %.2es\n", get_cpu_time() - tstart);
/* Free TAUCS format */
free_ccs_matrix(R);
if (nargout > 3)
{
int perb_number = taucs_multiqr_get_perb_number(F);
argout[3] = mxCreateDoubleMatrix(1, perb_number, mxREAL);
pr = mxGetPr(argout[3]);
int *indices = malloc(perb_number * sizeof(int));
taucs_multiqr_get_perb_indices(F, indices);
for(i = 0; i < perb_number; i++)
pr[i] = (int)indices[i] + (indices[i] > 0 ? 1 : -1);
}
if (nargout > 4)
argout[4] = mxCreateDoubleScalar(taucs_multiqr_get_perb_value(F));
taucs_multiqr_factor_free(F);
if (nargin > 3)
{
taucs_profile_report();
mexPrintf("Look at more profiling at /tmp/taucs_qr.log\n");
}
}
int actual_main(int argc, char* argv[])
{
double wtime_order;
double wtime_permute;
double wtime_factor;
double wtime_solve;
/*double wtime_precond_create; omer*/
double ctime_factor;
int i;/*,j omer*/
double NormErr;
taucs_ccs_matrix* A = NULL;
taucs_ccs_matrix* PAPT = NULL;
taucs_ccs_matrix* L = NULL;
double* Xd = NULL;
double* Bd = NULL;
double* PXd = NULL;
double* PBd = NULL;
double* NXd = NULL;
float* Xs = NULL;
float* Bs = NULL;
float* PXs = NULL;
float* PBs = NULL;
float* NXs = NULL;
taucs_dcomplex* Xz = NULL;
taucs_dcomplex* Bz = NULL;
taucs_dcomplex* PXz = NULL;
taucs_dcomplex* PBz = NULL;
taucs_dcomplex* NXz = NULL;
char* ordering = "metis";
char* mat_type = "neumann";
int* perm;
int* invperm;
int precision = TAUCS_DOUBLE;
int ldlt_flag = 0;
int snmf_flag = 0;
int snll_flag = 0;
int symb_flag = 0;
int mesh2d_flag = 0,mesh2d_size = 0;
int ooc_flag = 0;
int panelize = 0;
double memory_mb = -1.0;
char* matrixfile = "/tmp/taucs.L";
taucs_io_handle* oocL = NULL;
int (*precond_fn)(void*,void* x,void* b);
void* precond_args;
/***********************************************************/
/* Read arguments: log file, matrix, memory size, ooc name */
/***********************************************************/
if ((argc == 1) ||((argc == 2) && !strncmp(argv[1],"-h",2)))
usage(argc,argv);
A = NULL;
for (i=1; i<argc; i++) {
if (!strcmp(argv[i],"-single")) precision = TAUCS_SINGLE;
if (!strcmp(argv[i],"-dcomplex")) precision = TAUCS_DCOMPLEX;
if (!strcmp(argv[i],"-ldlt")) ldlt_flag = 1;
if (!strcmp(argv[i],"-snmf")) snmf_flag = 1;
if (!strcmp(argv[i],"-snll")) snll_flag = 1;
if (!strcmp(argv[i],"-symb")) symb_flag = 1;
if (!strcmp(argv[i],"-ooc")) ooc_flag = 1;
if (!strcmp(argv[i],"-log") && i <= argc-1 ) {
i++;
taucs_logfile(argv[i]);
}
if (!strcmp(argv[i],"-panelize") && i <= argc-1) {
i++;
if (sscanf(argv[i],"%d",&panelize) != 1) {
taucs_printf("0 (smart), 1 (in-core), or 2 (single supernode) follow -panelize argument\n");
exit(1);
}
}
if (!strcmp(argv[i],"-memory") && i <= argc-1) {
i++;
if (sscanf(argv[i],"%lf",&memory_mb) != 1) {
taucs_printf("memory size in MB must follow -memory argument\n");
exit(1);
}
}
if (!strcmp(argv[i],"-matrixfile") && i <= argc-1 ) {
i++;
matrixfile = argv[i];
}
if (!strcmp(argv[i],"-ordering") && i <= argc-1 ) {
i++;
ordering = argv[i];
}
if (!strcmp(argv[i],"-mat_type") && i <= argc-1 ) {
i++;
mat_type = argv[i];
}
#if 0
if (!strcmp(argv[i],"-hb") && i <= argc-1 ) {
int nrows,ncols,nnz,j;
char fname[256];
char type[3];
i++;
for (j=0; j<256; j++) fname[j] = ' ';
strcpy(fname,argv[i]);
taucs_printf("main: reading HB matrix %s\n",argv[i]);
ireadhb_(fname,type,&nrows,&ncols,&nnz);
A = taucs_dccs_creagte(nrows,ncols,nnz);
if (type[1] == 's' || type[1] == 'S')
A->flags |= TAUCS_SYMMETRIC | TAUCS_LOWER;
dreadhb_(fname,&nrows,&ncols,&nnz,
A->colptr,A->rowind,A->values);
/* make indices 0-based */
for (j=0; j<=ncols; j++) ((A->colptr)[j])--;
for (j=0; j<nnz; j++) ((A->rowind)[j])--;
taucs_printf("main: done reading\n");
}
#endif
if (!strcmp(argv[i],"-hb") && i <= argc-1) {
i++;
taucs_printf("main: reading hb matrix %s\n",argv[i]);
switch (precision) {
case TAUCS_SINGLE:
A = taucs_ccs_read_hb (argv[i], TAUCS_SINGLE); break;
case TAUCS_DOUBLE:
A = taucs_ccs_read_hb (argv[i], TAUCS_DOUBLE); break;
case TAUCS_DCOMPLEX:
A = taucs_ccs_read_hb (argv[i], TAUCS_DCOMPLEX); break;
default:
taucs_printf("main: unknown precision\n");
exit(1);
}
taucs_printf("main: done reading\n");
}
if (!strcmp(argv[i],"-mtx") && i <= argc-1) {
i++;
taucs_printf("main: reading mtx matrix %s\n",argv[i]);
A = taucs_ccs_read_mtx (argv[i],TAUCS_SYMMETRIC | TAUCS_PATTERN);
taucs_printf("main: done reading\n");
}
if (!strcmp(argv[i],"-ijv") && i <= argc-1) {
printf(">>> ijv\n");
i++;
taucs_printf("main: reading ijv matrix %s\n",argv[i]);
switch (precision) {
case TAUCS_SINGLE:
A = taucs_ccs_read_ijv (argv[i],TAUCS_SYMMETRIC | TAUCS_SINGLE); break;
case TAUCS_DOUBLE:
A = taucs_ccs_read_ijv (argv[i],TAUCS_SYMMETRIC | TAUCS_DOUBLE); break;
case TAUCS_DCOMPLEX:
A = taucs_ccs_read_ijv (argv[i],TAUCS_HERMITIAN | TAUCS_DCOMPLEX); break;
default:
taucs_printf("main: unknown precision\n");
exit(1);
}
taucs_printf("main: done reading\n");
}
if (!strcmp(argv[i],"-ccs") && i <= argc-1) {
i++;
taucs_printf("main: reading ccs matrix %s\n",argv[i]);
A = taucs_ccs_read_ccs (argv[i],TAUCS_SYMMETRIC);
taucs_printf("main: done reading\n");
}
if (!strcmp(argv[i],"-mesh2d") && i <= argc-1) {
mesh2d_flag = 1;
taucs_printf("A is a mesh2d\n");
i++;
if (sscanf(argv[i],"%d",&mesh2d_size) != 1) {
taucs_printf("mesh size (n, where the mesh is n-by-n) must follow -mesh2d argument\n");
exit(1);
}
}
if (!strcmp(argv[i],"-mesh3d") && i <= argc-3) {
int X,Y,Z;
taucs_printf("A is a mesh3d\n");
if (sscanf(argv[i+1],"%d",&X) != 1
|| sscanf(argv[i+2],"%d",&Y) != 1
|| sscanf(argv[i+3],"%d",&Z) != 1) {
taucs_printf("mesh size (X Y Z must follow -mesh3d argument\n");
exit(1);
}
i += 3;
taucs_printf("main: creating mesh\n");
A = taucs_ccs_generate_mesh3d(X,Y,Z);
}
if (!strcmp(argv[i],"-n+rhs") && i <= argc-1) {
FILE* f;
int n,j,nnz;
i++;
taucs_printf("main: reading right-hand side %s\n",argv[i]);
f=fopen(argv[i],"r");
assert(f);
fscanf(f,"%d",&n);
Bd=(double*) malloc(n*sizeof(double));
nnz = 0;
for (j=0; j<n; j++) {
fscanf(f,"%lg",(Bd)+j);
if (Bd[j]) nnz++;
}
fclose(f);
taucs_printf("main: done reading rhs, %d nonzeros\n",nnz);
}
}
taucs_printf("Chosen Ordering: %s\n",ordering);
if (mesh2d_flag)
{
taucs_printf("Matrix type is %s\n",mat_type);
taucs_printf("Grid Size is %d\n",mesh2d_size);
A = taucs_ccs_generate_mesh2d(mesh2d_size,mat_type);
}
if (!A) {
taucs_printf("matrix argument not given or matrix file not found\n");
usage(argc,argv);
}
N = M = A->n;
/*taucs_maximize_stacksize();*/
/***********************************************************/
/* Create exact solution, compute right-hand-side */
/***********************************************************/
if (A->flags & TAUCS_SINGLE) {
if (! (Xs)) {
Xs = (float*)malloc(N*sizeof(float));
/*for(i=0; i<N; i++) (Xs)[i]=(double)random()/RAND_MAX; omer*/
for(i=0; i<N; i++) (Xs)[i]=(float)((double)rand()/RAND_MAX);
} else
taucs_printf("iter: not using a random X, already allocated\n");
if (!(Bs)) {
Bs = (float*)malloc(N*sizeof(float));
taucs_ccs_times_vec(A,Xs,Bs);
} else {
/*double zero1 = 0.0;
double nan = zero1 / zero1; omer*/
double nan = taucs_get_nan();
for(i=0; i<N; i++) Xs[i]= (float)nan;
}
NXs=(float*)malloc(N*sizeof(float));
PXs=(float*)malloc(N*sizeof(float));
PBs=(float*)malloc(N*sizeof(float));
}
if (A->flags & TAUCS_DOUBLE) {
if (! (Xd)) {
Xd =(double*)malloc(N*sizeof(double));
/*for(i=0; i<N; i++) (Xd)[i]=(double)rand()/RAND_MAX; omer*/
for(i=0; i<N; i++) (Xd)[i]=(float)((double)rand()/RAND_MAX);
} else
taucs_printf("iter: not using a random X, already allocated\n");
if (!(Bd)) {
Bd =(double*)malloc(N*sizeof(double));
taucs_ccs_times_vec(A,Xd,Bd);
} else {
/*double zero1 = 0.0;
double nan = zero1 / zero1; omer*/
double nan = taucs_get_nan();
for(i=0; i<N; i++) Xd[i]= (float)nan;
}
NXd=(double*)malloc(N*sizeof(double));
PXd=(double*)malloc(N*sizeof(double));
PBd=(double*)malloc(N*sizeof(double));
}
if (A->flags & TAUCS_DCOMPLEX) {
if (!(Xz)) {
double* p;
taucs_printf("direct: creating a random dcomplex X\n");
Xz =(taucs_dcomplex*)malloc(N*sizeof(taucs_dcomplex));
p = (double*) Xz;
for(i=0; i<2*N; i++) p[i] = (double)rand()/RAND_MAX;
} else
taucs_printf("iter: not using a random X, already allocated\n");
if (!(Bz)) {
Bz =(taucs_dcomplex*)malloc(N*sizeof(taucs_dcomplex));
taucs_ccs_times_vec(A,Xz,Bz);
} else {
double* p;
/*double zero1 = 0.0;
double nan = zero1 / zero1; omer*/
double nan = taucs_get_nan();
p = (double*) Xz;
for(i=0; i<2*N; i++) p[i] = nan;
}
NXz=(taucs_dcomplex*)malloc(N*sizeof(taucs_dcomplex));
PXz=(taucs_dcomplex*)malloc(N*sizeof(taucs_dcomplex));
PBz=(taucs_dcomplex*)malloc(N*sizeof(taucs_dcomplex));
}
/***********************************************************/
/* Compute column ordering */
/***********************************************************/
/***********************************************************/
/* factor */
/***********************************************************/
{
int n;
double unit;
n = A->n;
unit = (n-1.)+n;
wtime_order = taucs_wtime();
taucs_ccs_order(A,&perm,&invperm,ordering);
wtime_order = taucs_wtime() - wtime_order;
taucs_printf("\tOrdering time = % 10.3f seconds\n",wtime_order);
if (!perm) {
taucs_printf("\tOrdering Failed\n");
exit(1);
}
if (0) {
int i;
FILE* f;
f=fopen("p.ijv","w");
for (i=0; i<n; i++) fprintf(f,"%d\n",perm[i]+1);
fclose(f);
}
if (A->flags & TAUCS_SYMMETRIC || A->flags & TAUCS_HERMITIAN) {
wtime_permute = taucs_wtime();
PAPT = taucs_ccs_permute_symmetrically(A,perm,invperm);
wtime_permute = taucs_wtime() - wtime_permute;
taucs_printf("\tPermute time = % 10.3f seconds\n",wtime_permute);
}
wtime_factor = taucs_wtime();
ctime_factor = taucs_ctime();
if (ldlt_flag) {
L = taucs_ccs_factor_ldlt(PAPT);
precond_args = L;
precond_fn = taucs_ccs_solve_ldlt;
} else if (snmf_flag) {
/*taucs_ccs_matrix* C;*/
L = taucs_ccs_factor_llt_mf(PAPT);
precond_args = L;
precond_fn = taucs_supernodal_solve_llt;
{
taucs_ccs_matrix* C;
C = taucs_supernodal_factor_to_ccs(L);
/*taucs_ccs_write_ijv(PAPT,"PAPT.ijv");*/
/*C->flags = TAUCS_DCOMPLEX | TAUCS_TRIANGULAR | TAUCS_LOWER;*/
precond_args = C;
precond_fn = taucs_ccs_solve_llt;
/*taucs_ccs_write_ijv(C,"L.ijv");*/
/*
{
int i;
double* diag = taucs_supernodal_factor_get_diag(L);
for (i=0; i<C->n; i++) {
printf("%.2le\n",diag[i]);
}
}
*/
}
} else if (ooc_flag) {
if (A->flags & TAUCS_SYMMETRIC || A->flags & TAUCS_HERMITIAN) {
#define TESTING
#ifdef TESTING
int taucs_ooc_factor_llt_panelchoice(taucs_ccs_matrix* A,
taucs_io_handle* handle,
double memory,
int panelization_method);
/*int c; omer*/
oocL = taucs_io_create_multifile(matrixfile);
assert(oocL);
if (memory_mb == -1.0) memory_mb = taucs_available_memory_size()/1048576.0;
taucs_ooc_factor_llt_panelchoice(PAPT, oocL, memory_mb*1048576.0,panelize);
precond_args = oocL;
precond_fn = taucs_ooc_solve_llt;
#else
/*int c;*/
oocL = taucs_io_create_multifile(matrixfile);
assert(oocL);
if (memory_mb == -1.0) memory_mb = taucs_available_memory_size()/1048576.0;
taucs_ooc_factor_llt(PAPT, oocL, memory_mb*1048576.0);
precond_args = oocL;
precond_fn = taucs_ooc_solve_llt;
#endif
} else {
if (memory_mb == -1.0) memory_mb = taucs_available_memory_size()/1048576.0;
oocL = taucs_io_create_multifile(matrixfile);
taucs_ooc_factor_lu(A, perm, oocL, memory_mb*1048576.0);
precond_args = matrixfile;
precond_fn = NULL;
}
} else if (snll_flag) {
L = taucs_ccs_factor_llt_ll(PAPT);
precond_args = L;
precond_fn = taucs_supernodal_solve_llt;
} else if (symb_flag) {
L = taucs_ccs_factor_llt_symbolic(PAPT);
taucs_ccs_factor_llt_numeric(PAPT,L); /* should check error code */
precond_args = L;
precond_fn = taucs_supernodal_solve_llt;
} else {
L = taucs_ccs_factor_llt(PAPT,0.0,0);
precond_args = L;
precond_fn = taucs_ccs_solve_llt;
}
wtime_factor = taucs_wtime() - wtime_factor;
ctime_factor = taucs_ctime() - ctime_factor;
taucs_printf("\tFactor time = % 10.3f seconds ",wtime_factor);
taucs_printf("(%.3f cpu time)\n",ctime_factor);
}
if (!L && !ooc_flag /* no L in ooc */) {
taucs_printf("\tFactorization Failed\n");
exit(1);
}
/*taucs_ccs_write_ijv(PAPT,"A.ijv",1);*/ /* 1 = complete the upper part */
/*taucs_ccs_write_ijv(L,"L.ijv",0);*/
/***********************************************************/
/* solve */
/***********************************************************/
if (!L) {
taucs_printf("FACTORIZATION FAILED!\n");
exit(1);
}
if (A->flags & TAUCS_SYMMETRIC || A->flags & TAUCS_HERMITIAN) {
if (A->flags & TAUCS_DOUBLE)
taucs_vec_permute(A->n,A->flags,Bd,PBd,perm);
if (A->flags & TAUCS_SINGLE)
taucs_vec_permute(A->n,A->flags,Bs,PBs,perm);
if (A->flags & TAUCS_DCOMPLEX)
taucs_vec_permute(A->n,A->flags,Bz,PBz,perm);
wtime_solve = taucs_wtime();
if (A->flags & TAUCS_DOUBLE)
precond_fn(precond_args,PXd,PBd); /* direct solver */
if (A->flags & TAUCS_SINGLE)
precond_fn(precond_args,PXs,PBs); /* direct solver */
if (A->flags & TAUCS_DCOMPLEX)
precond_fn(precond_args,PXz,PBz); /* direct solver */
#ifdef TAUCS_CONFIG_SINGLE
if (A->flags & TAUCS_SINGLE) {
taucs_sccs_times_vec_dacc(PAPT,PXs,NXs);
for(i=0; i<(A->n); i++) NXs[i] -= PBs[i];
precond_fn(precond_args,PBs,NXs); /* direct solver */
for(i=0; i<(A->n); i++) PXs[i] -= PBs[i];
}
#endif
wtime_solve = taucs_wtime() - wtime_solve;
taucs_printf("\tSolve time = % 10.3f seconds\n",wtime_solve);
if (A->flags & TAUCS_DOUBLE)
taucs_vec_ipermute(A->n,A->flags,PXd,NXd,perm);
if (A->flags & TAUCS_SINGLE)
taucs_vec_ipermute(A->n,A->flags,PXs,NXs,perm);
if (A->flags & TAUCS_DCOMPLEX)
taucs_vec_ipermute(A->n,A->flags,PXz,NXz,perm);
} else {
taucs_ooc_solve_lu(oocL, NXd, Bd);
}
/***********************************************************/
/* delete out-of-core matrices */
/***********************************************************/
if (ooc_flag) {
taucs_io_delete(oocL);
/*taucs_io_close(oocL);*/
}
/***********************************************************/
/* Compute norm of forward error */
/***********************************************************/
if (A->flags & TAUCS_SINGLE) {
float snrm2_();
int one = 1;
NormErr = 0.0;
for(i=0; i<N; i++) NormErr = max(NormErr,fabs((NXs[i]-Xs[i])/Xs[i]));
for(i=0; i<N; i++) PXs[i] = NXs[i]-Xs[i];
taucs_printf("main: max relative error = %1.6e, 2-norm relative error %.2e \n",
NormErr,
snrm2_(&(A->n),PXs,&one)/snrm2_(&(A->n),Xs,&one));
}
if (A->flags & TAUCS_DOUBLE) {
double dnrm2_();
int one = 1;
NormErr = 0.0;
for(i=0; i<N; i++) NormErr = max(NormErr,fabs((NXd[i]-Xd[i])/Xd[i]));
for(i=0; i<N; i++) PXd[i] = NXd[i]-Xd[i];
taucs_printf("main: max relative error = %1.6e, 2-norm relative error %.2e \n",
NormErr,
dnrm2_(&(A->n),PXd,&one)/dnrm2_(&(A->n),Xd,&one));
}
#ifdef TAUCS_CONFIG_DCOMPLEX
if (A->flags & TAUCS_DCOMPLEX) {
double dznrm2_();
int one = 1;
double* pX = (double*) Xz;
double* pNX = (double*) NXz;
double* pPX = (double*) PXz;
taucs_dcomplex zzero = taucs_zzero_const;
taucs_dcomplex zone = taucs_zone_const;
taucs_dcomplex zmone = taucs_zneg(taucs_zone_const);
NormErr = 0.0;
/*
for(i=0; i<N; i++) NormErr = max(NormErr,fabs((NXd[i]-Xd[i])/Xd[i]));
*/
/*for(i=0; i<N; i++) PXd[i] = NXd[i]-Xd[i];*/
/*for(i=0; i<N; i++) PXz[i] = taucs_add(NXz[i],taucs_neg(Xz[i]));*/
zscal_(&(A->n),&zzero,pPX,&one);
zaxpy_(&(A->n),&zone ,pNX,&one,pPX,&one);
zaxpy_(&(A->n),&zmone,pX ,&one,pPX,&one);
taucs_printf("main: max relative error = %1.6e, 2-norm relative error %.2e \n",
NormErr,
dznrm2_(&(A->n),PXz,&one)/dznrm2_(&(A->n),Xz,&one));
}
#endif
/***********************************************************/
/* Exit */
/***********************************************************/
taucs_printf("main: done\n");
return 0;
}
// has to be called in the beginning before starting to work with the library
void InitTaucsInterface(bool enableLog) {
if (enableLog)
taucs_logfile("stdout");
}
