zldperm.c File Reference

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

#include "slu_zdefs.h"

Include dependency graph for zldperm.c:

Functions
int_t	mc64id_ (int_t *)
int_t	mc64ad_ (int_t *job, int_t *n, int_t *ne, int_t *ip, int_t *irn, double *a, int_t *num, int *cperm, int_t *liw, int_t *iw, int_t *ldw, double *dw, int_t *icntl, int_t *info)
int	zldperm (int job, int n, int_t nnz, int_t colptr[], int_t adjncy[], doublecomplex nzval[], int *perm, double u[], double v[])

Detailed Description

Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)

All rights reserved.

The source code is distributed under BSD license, see the file License.txt at the top-level directory.

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

Function Documentation

mc64ad_()

int_t mc64ad_	(	int_t *	job,
		int_t *	n,
		int_t *	ne,
		int_t *	ip,
		int_t *	irn,
		double *	a,
		int_t *	num,
		int *	cperm,
		int_t *	liw,
		int_t *	iw,
		int_t *	ldw,
		double *	dw,
		int_t *	icntl,
		int_t *	info
	)

mc64id_()

int_t mc64id_

(

int_t *

icntl

)

zldperm()

int zldperm	(	int	job,
		int	n,
		int_t	nnz,
		int_t	colptr[],
		int_t	adjncy[],
		doublecomplex	nzval[],
		int *	perm,
		double	u[],
		double	v[]
	)

Purpose
=======

  ZLDPERM 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) doublecomplex*, 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).

Here is the call graph for this function: