amesos_amd_l_preprocess.c

Go to the documentation of this file.

/* ========================================================================= */
/* === AMD_preprocess ====================================================== */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,              */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* Sorts, removes duplicate entries, and transposes from the nonzero pattern of
 * a column-form matrix A, to obtain the matrix R.  The input matrix can have
 * duplicate entries and/or unsorted columns (AMD_valid (n,Ap,Ai) must not be
 * AMD_INVALID).
 *
 * This input condition is NOT checked.  This routine is not user-callable.
 */

/* This file should make the long int version of AMD */
#define DLONG 1

#include "amesos_amd_internal.h"

/* ========================================================================= */
/* === AMD_preprocess ====================================================== */
/* ========================================================================= */

/* AMD_preprocess does not check its input for errors or allocate workspace.
 * On input, the condition (AMD_valid (n,n,Ap,Ai) != AMD_INVALID) must hold.
 */

GLOBAL void AMD_preprocess
(
    Int n,    /* input matrix: A is n-by-n */
    const Int Ap [ ], /* size n+1 */
    const Int Ai [ ], /* size nz = Ap [n] */

    /* output matrix R: */
    Int Rp [ ],   /* size n+1 */
    Int Ri [ ],   /* size nz (or less, if duplicates present) */

    Int W [ ],    /* workspace of size n */
    Int Flag [ ]  /* workspace of size n */
)
{

    /* --------------------------------------------------------------------- */
    /* local variables */
    /* --------------------------------------------------------------------- */

    Int i, j, p, p2 ;

    ASSERT (AMD_valid (n, n, Ap, Ai) != AMD_INVALID) ;

    /* --------------------------------------------------------------------- */
    /* count the entries in each row of A (excluding duplicates) */
    /* --------------------------------------------------------------------- */

    for (i = 0 ; i < n ; i++)
    {
  W [i] = 0 ;   /* # of nonzeros in row i (excl duplicates) */
  Flag [i] = EMPTY ;  /* Flag [i] = j if i appears in column j */
    }
    for (j = 0 ; j < n ; j++)
    {
  p2 = Ap [j+1] ;
  for (p = Ap [j] ; p < p2 ; p++)
  {
      i = Ai [p] ;
      if (Flag [i] != j)
      {
    /* row index i has not yet appeared in column j */
    W [i]++ ;     /* one more entry in row i */
    Flag [i] = j ;      /* flag row index i as appearing in col j*/
      }
  }
    }

    /* --------------------------------------------------------------------- */
    /* compute the row pointers for R */
    /* --------------------------------------------------------------------- */

    Rp [0] = 0 ;
    for (i = 0 ; i < n ; i++)
    {
  Rp [i+1] = Rp [i] + W [i] ;
    }
    for (i = 0 ; i < n ; i++)
    {
  W [i] = Rp [i] ;
  Flag [i] = EMPTY ;
    }

    /* --------------------------------------------------------------------- */
    /* construct the row form matrix R */
    /* --------------------------------------------------------------------- */

    /* R = row form of pattern of A */
    for (j = 0 ; j < n ; j++)
    {
  p2 = Ap [j+1] ;
  for (p = Ap [j] ; p < p2 ; p++)
  {
      i = Ai [p] ;
      if (Flag [i] != j)
      {
    /* row index i has not yet appeared in column j */
    Ri [W [i]++] = j ;  /* put col j in row i */
    Flag [i] = j ;      /* flag row index i as appearing in col j*/
      }
  }
    }

#ifndef NDEBUG
    ASSERT (AMD_valid (n, n, Rp, Ri) == AMD_OK) ;
    for (j = 0 ; j < n ; j++)
    {
  ASSERT (W [j] == Rp [j+1]) ;
    }
#endif
}