SRC/dldperm.c File Reference

Finds a row permutation so that the matrix has large entries on the diagonal. More...

#include "superlu_ddefs.h"

Include dependency graph for dldperm.c:


Functions

void mc64ad_ (int_t *, int_t *, int_t *, int_t[], int_t[], double[], int_t *, int_t[], int_t *, int_t[], int_t *, double[], int_t[], int_t[])
void dldperm (int_t job, int_t n, int_t nnz, int_t colptr[], int_t adjncy[], double nzval[], int_t *perm, double u[], double v[])

Detailed Description

 -- Distributed SuperLU routine (version 1.0) --
 Lawrence Berkeley National Lab, Univ. of California Berkeley.
 September 1, 1999
 

Function Documentation

void dldperm ( int_t  job,
int_t  n,
int_t  nnz,
int_t  colptr[],
int_t  adjncy[],
double  nzval[],
int_t perm,
double  u[],
double  v[] 
)

 Purpose
 =======

   DLDPERM finds a row permutation so that the matrix has large
   entries on the diagonal.

 Arguments
 =========

 job    (input) int
        Control the action. Possible values for JOB are:
        = 1 : Compute a row permutation of the matrix so that the
              permuted matrix has as many entries on its diagonal as
              possible. The values on the diagonal are of arbitrary size.
              HSL subroutine MC21A/AD is used for this.
        = 2 : Compute a row permutation of the matrix so that the smallest 
              value on the diagonal of the permuted matrix is maximized.
        = 3 : Compute a row permutation of the matrix so that the smallest
              value on the diagonal of the permuted matrix is maximized.
              The algorithm differs from the one used for JOB = 2 and may
              have quite a different performance.
        = 4 : Compute a row permutation of the matrix so that the sum
              of the diagonal entries of the permuted matrix is maximized.
        = 5 : Compute a row permutation of the matrix so that the product
              of the diagonal entries of the permuted matrix is maximized
              and vectors to scale the matrix so that the nonzero diagonal 
              entries of the permuted matrix are one in absolute value and 
              all the off-diagonal entries are less than or equal to one in 
              absolute value.
        Restriction: 1 <= JOB <= 5.

 n      (input) int
        The order of the matrix.

 nnz    (input) int
        The number of nonzeros in the matrix.

 adjncy (input) int*, of size nnz
        The adjacency structure of the matrix, which contains the row
        indices of the nonzeros.

 colptr (input) int*, of size n+1
        The pointers to the beginning of each column in ADJNCY.

 nzval  (input) double*, of size nnz
        The nonzero values of the matrix. nzval[k] is the value of
        the entry corresponding to adjncy[k].
        It is not used if job = 1.

 perm   (output) int*, of size n
        The permutation vector. perm[i] = j means row i in the
        original matrix is in row j of the permuted matrix.

 u      (output) double*, of size n
        If job = 5, the natural logarithms of the row scaling factors.

 v      (output) double*, of size n
        If job = 5, the natural logarithms of the column scaling factors. 
        The scaled matrix B has entries b_ij = a_ij * exp(u_i + v_j).
 

void mc64ad_ ( int_t ,
int_t ,
int_t ,
int_t  [],
int_t  [],
double  [],
int_t ,
int_t  [],
int_t ,
int_t  [],
int_t ,
double  [],
int_t  [],
int_t  [] 
)


Generated on Sat Aug 29 04:21:42 2009 for SuperLUDistributed by  doxygen 1.5.9