SuperLU: SRC/dldperm.c File Reference

# SRC/dldperm.c File Reference

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

`#include "slu_ddefs.h"`

## Functions
int_t | mc64id_ (int_t *)
int_t | 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[])
int | 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

     -- SuperLU routine (version 4.0) --
     Lawrence Berkeley National Laboratory.
     June 30, 2009

## Function Documentation

int 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).

int_t 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 | [] |
| ) |  |  |

int_t mc64id_ | ( | int_t * |  | ) |