src

sparse.h File Reference

Go to the source code of this file.

Data Structures

struct  sparse
void BiCGSTAB_sparse (vector sol, const sparse A, const vector b, double *state, void prec(vector, const vector))
void CGSSolve_sparse (vector sol, const sparse A, const vector b, double *state)
void check1 (long n, long m, long *I, long *J, long nz)
int check_sparse_system (const vector sol, const sparse A, const sparse PC, const vector b)
void construct_sparse (sparse *A, long n, long m, long nz)
void construct_sparse_copy (sparse *A, const sparse B)
void construct_sparse_fast_transpose (sparse *AT, const sparse)
void construct_sparse_ij (sparse *A, long n, long m, long nz, long *_I, long *_J)
void construct_sparse_ijvaladd (sparse *A, long n, long m, long nz, long nzmax, long *I, long *J, double *VAL)
void construct_sparse_ILU (sparse *out, const sparse orig)
void construct_sparse_ILU1 (sparse *out, const sparse orig)
void construct_sparse_lumped (sparse *Alum, const sparse A)
void construct_sparse_multiply (sparse *P, const sparse A, const sparse B)
void construct_sparse_multiply_fast (sparse *P, const sparse, const sparse)
void construct_sparse_nonzero_copy (sparse *A, const sparse B)
void construct_sparse_transpose (sparse *A, const sparse B)
long copy_sparse2ijval (const sparse A, long *I, long *J, double *VAL)
void destruct_sparse (sparse *A)
void fill_sparse_ijval (sparse A, long *I, long *J, double *VAL, long nz)
long find_ij (long *I, long *J, long i, long j, long nz)
void GMRESSolve_sparse (vector sol, const sparse A, const vector b, double *state)
void ILU_sparse (sparse M)
void LUsolve_sparse (double *sol, const sparse M, const double *b)
long multiply_sparse (double *out, const sparse A, const double *with)
long multiply_sparse_left (double *out, const double *with, const sparse A)
void multiply_sparse_scalar (sparse A, double t)
void PCGMSolve_sparse (vector sol, const sparse A, const vector b, sparse *PC, double *state)
void PCGSSolve_sparse (vector sol, const sparse A, const vector b, double *state, void prec(vector, const vector))
void PGMRESSolve_fce (vector sol, void mult(vector, const vector), const vector b, void prec(vector, const vector), double *state)
void PGMRESSolve_sparse (vector sol, const sparse A, const vector b, sparse *PC, double *state)
void PGMRESSolve_sparse_right (vector sol, const sparse A, const vector b, void prec(vector), double *state)
void quicksort_ij (long *I, long *J, long lo, long hi)
void quicksort_ijval (long *I, long *J, double *VAL, long lo, long hi)
void quicksort_long (long *I, long lo, long hi)
void reconstruct_sparse_triplet (sparse *A, long n, long m, long nz, long *I, long *J, double *VAL)
void save_sparse (char *fname, const sparse A)
long sparse_lincomb (double *rez, double alpha, const sparse A, const double *v)
void sparse_matrix_add (sparse *A, long i, long j, double val)
double sparse_matrix_get (const sparse A, long i, long j)
void sparse_matrix_insert (sparse *A, long i, long j, double val)
double sparse_matrix_product (const double *u, const sparse A, const double *v)
void sparse_matrix_set (sparse *A, long i, long j, double val)
long sparse_nonzero (const sparse A)
long sparse_nonzerosmultiply (const sparse A, const sparse B)
long sparse_reziduum (double *rez, const sparse A, const double *v)
void UMFPACKSolve_normal_equations (vector sol, const sparse A, const vector b)
void UMFPACKSolve_sparse (vector sol, const sparse A, const vector b)
long unique (long *I, long *J, long nz)
long unique_long (long *I, long nz)
long unique_val (long *I, long *J, double *VAL, long nz)
void vypis_ij (long *I, long *J, long nz)
void vypis_ijval (long *I, long *J, double *VAL, long nz)
void vypis_sparse (const sparse A)
void zeroize_sparse (sparse A)

Function Documentation

void check1 (  long  n,
long  m,
long *  I,
long *  J,
long  nz
) 
 

check triplet(I,J,VAL) whether it fits into n x m matrix

void construct_sparse (  sparse *  A,
long  n,
long  m,
long  nz
) 
 

allocate memory for matrix A of n x m with nz nonzeros

void construct_sparse_ij (  sparse *  A,
long  n,
long  m,
long  nz,
long *  _I,
long *  _J
) 
 

construct matrix A of n x m with nz nonzeros and structure given by I-row and J-col

void construct_sparse_ijvaladd (  sparse *  A,
long  n,
long  m,
long  nz,
long  nzmax,
long *  I,
long *  J,
double *  VAL
) 
 

constr. matrix from triplet I,J,VAL, with nz values, max memory allocated as nzmax

void construct_sparse_copy (  sparse *  A,
const sparse  B
) 
 

construct sparse matrix as copy

void construct_sparse_nonzero_copy (  sparse *  A,
const sparse  B
) 
 

construct sparse matrix as copy of only nonzeros

void construct_sparse_transpose (  sparse *  A,
const sparse  B
) 
 

transpose given matrix

void construct_sparse_multiply (  sparse *  P,
const sparse  A,
const sparse  B
) 
 

P=create A * B

void reconstruct_sparse_triplet (  sparse *  A,
long  n,
long  m,
long  nz,
long *  I,
long *  J,
double *  VAL
) 
 

fill matrix A with the triplet value, reallocate memory if needed

void destruct_sparse (  sparse *  A  ) 
 

destruct matrix

void construct_sparse_fast_transpose (  sparse *  AT,
const   sparse
) 
 

construct transpose matrix (through the triplet)

void construct_sparse_multiply_fast (  sparse *  P,
const   sparse,
const   sparse
) 
 

fast version P= create A*B

void construct_sparse_lumped (  sparse *  Alum,
const sparse  A
) 
 

lumped version of A (only diagonal)

long sparse_nonzero (  const sparse  A  ) 
 

compute the number of nonzeros of A

long copy_sparse2ijval (  const sparse  A,
long *  I,
long *  J,
double *  VAL
) 
 

convert A to triplet I J VAL

void vypis_ijval (  long *  I,
long *  J,
double *  VAL,
long  nz
) 
 

prints the triplet to screen

void vypis_ij (  long *  I,
long *  J,
long  nz
) 
 

prints the matrix structure to screen

void vypis_sparse (  const sparse  A  ) 
 

prints the sparse matrix

void save_sparse (  char *  fname,
const sparse  A
) 
 

saving sparse matrix A to file filename

long multiply_sparse (  double *  out,
const sparse  A,
const double *  with
) 
 

out:= A * with

long multiply_sparse_left (  double *  out,
const double *  with,
const sparse  A
) 
 

out:= with * A

long sparse_reziduum (  double *  rez,
const sparse  A,
const double *  v
) 
 

rez:=rez-A*v

long sparse_lincomb (  double *  rez,
double  alpha,
const sparse  A,
const double *  v
) 
 

rez:= alpha*rez+A*v

void fill_sparse_ijval (  sparse  A,
long *  I,
long *  J,
double *  VAL,
long  nz
) 
 

just fill matrix A with the triplet IJVAL

void quicksort_ijval (  long *  I,
long *  J,
double *  VAL,
long  lo,
long  hi
) 
 

sort the triplet I J VAL from lo to high (quicsort) for CCF

void quicksort_ij (  long *  I,
long *  J,
long  lo,
long  hi
) 
 

sort the structure I J from lo to high (quicsort) for CCF

void quicksort_long (  long *  I,
long  lo,
long  hi
) 
 

sort values of I from lo to high (quicksort)

long unique_val (  long *  I,
long *  J,
double *  VAL,
long  nz
) 
 

make unique values by adding together the same indices

long unique (  long *  I,
long *  J,
long  nz
) 
 

make unique values by canceling duplicities

long unique_long (  long *  I,
long  nz
) 
 

make unique values by canceling duplicities

long find_ij (  long *  I,
long *  J,
long  i,
long  j,
long  nz
) 
 

return k such that I[k]=i and J[k]=j, k=-1 if not found

void zeroize_sparse (  sparse  A  ) 
 

make A zero matrix

void multiply_sparse_scalar (  sparse  A,
double  t
) 
 

multiply matrix A with t

long sparse_nonzerosmultiply (  const sparse  A,
const sparse  B
) 
 

estimate for no. of nonzeros for A * B

double sparse_matrix_product (  const double *  u,
const sparse  A,
const double *  v
) 
 

returns value u'*A*v

void sparse_matrix_insert (  sparse *  A,
long  i,
long  j,
double  val
) 
 

insert (i,j,val) into matrix (SLOW!)

void sparse_matrix_set (  sparse *  A,
long  i,
long  j,
double  val
) 
 

set (i,j,val) in matrix (SLOW!)

void sparse_matrix_add (  sparse *  A,
long  i,
long  j,
double  val
) 
 

add (i,j,val) to matrix (SLOW!)

double sparse_matrix_get (  const sparse  A,
long  i,
long  j
) 
 

gets value of A(i,j)

void construct_sparse_ILU1 (  sparse *  out,
const sparse  orig
) 
 

Prepare Incomplete LU decomposition of orig matrix, add 1-neighbours

void construct_sparse_ILU (  sparse *  out,
const sparse  orig
) 
 

Prepare Incomplete LU decomposition of orig matrix, no-fill

void LUsolve_sparse (  double *  sol,
const sparse  M,
const double *  b
) 
 

solve M * sol = b, M - LU decomposed matrix

void ILU_sparse (  sparse  M  ) 
 

Make ILU of M

int check_sparse_system (  const vector  sol,
const sparse  A,
const sparse  PC,
const vector  b
) 
 

Check whether the system A*sol = b can be solved with PC preconditioner

void PCGMSolve_sparse (  vector  sol,
const sparse  A,
const vector  b,
sparse *  PC,
double *  state
) 
 

Solve A*sol=b with PC - preconditioner (either filled or will be returned), state - parameters for solution:

state[0]=MaxIter(max. iterations)

state[1]=epsilon(precision/relative)

state[2]=print residuals each iteration

state[3]=GMRES restarts

state[4]=print residuals each iteration

state[5]=show 1 - header, 2 - convergent, 4 - nonconvergent (logical addition)

state[6]=precision(absolute)

state[7]=

state[8]=OUTPUT: no. of performed iterations

state[9]=achieved precision

void PCGSSolve_sparse (  vector  sol,
const sparse  A,
const vector  b,
double *  state,
void   prec(vector, const vector)
) 
 

void BiCGSTAB_sparse (  vector  sol,
const sparse  A,
const vector  b,
double *  state,
void   prec(vector, const vector)
) 
 

void CGSSolve_sparse (  vector  sol,
const sparse  A,
const vector  b,
double *  state
) 
 

CG method written for normal eqs., for the interpretation of the state variable, see PCGMSolve_sparse

void PGMRESSolve_sparse (  vector  sol,
const sparse  A,
const vector  b,
sparse *  PC,
double *  state
) 
 

Use PGMRES method, the state variable, see PCGMSolve_sparse

void GMRESSolve_sparse (  vector  sol,
const sparse  A,
const vector  b,
double *  state
) 
 

Use GMRES method, the state variable, see PCGMSolve_sparse

void PGMRESSolve_sparse_right (  vector  sol,
const sparse  A,
const vector  b,
void   prec(vector),
double *  state
) 
 

Use PGMRES method, right preconditioner prec(), the state variable, see PCGMSolve_sparse

void PGMRESSolve_fce (  vector  sol,
void   mult(vector, const vector),
const vector  b,
void   prec(vector, const vector),
double *  state
) 
 

Use PGMRES method for matrix and preconditioner given by a function, the state variable, see PCGMSolve_sparse

void UMFPACKSolve_sparse (  vector  sol,
const sparse  A,
const vector  b
) 
 

void UMFPACKSolve_normal_equations (  vector  sol,
const sparse  A,
const vector  b
) 
 

Generated on Sun May 27 11:59:43 2007 for FEMFLUID by  doxygen 1.4.6