• NAME
• SYNOPSIS
• F95 INTERFACE
• C INTERFACE
• ARGUMENTS
• SEE ALSO

NAME

blas_dsortv - sorts a real (double precision) vector X in increasing or decreasing order using quick sort algorithm and overwrite P with the permutation vector

SYNOPSIS

  SUBROUTINE BLAS_DSORTV( SORT, N, X, INCX, P, INCP)
  INTEGER SORT, N, INCX, INCP
  INTEGER P(*)
  DOUBLE PRECISION X(*)

  SUBROUTINE BLAS_DSORTV_64( SORT, N, X, INCX, P, INCP)
  INTEGER*8 SORT, N, INCX, INCP
  INTEGER*8 P(*)
  DOUBLE PRECISION X(*)

F95 INTERFACE

  SUBROUTINE SORTV( [SORT], [N], X, [INCX], P, [INCP])
  INTEGER :: SORT, N, INCX, INCP
  INTEGER, DIMENSION(:) :: P
  REAL(8), DIMENSION(:) :: X

  SUBROUTINE SORTV_64( [SORT], [N], X, [INCX], P, [INCP])
  INTEGER(8) :: SORT, N, INCX, INCP
  INTEGER(8), DIMENSION(:) :: P
  REAL(8), DIMENSION(:) :: X

C INTERFACE

#include <sunperf.h>

void blas_dsortv(int sort, int n, double *x, int incx, int *p, int incp);

void blas_dsortv_64(long sort, long n, double *x, long incx, long *p, long incp);

ARGUMENTS

• SORT (input)
  SORT = 0, descending

  SORT = 1, ascending

  SORT = other value, error

  SORT is default to 1 for F95 INTERFACE

• N (input)
  If N < = 1, the subroutine returns without trying to sort X.

• X (input/output)
  sorted

  Minimum size (N-1)*|INCX|+1 is required

• INCX (input)
  INCX must not be zero. INCX could be negative. If INCX < 0, change the sorting direction defined by SORT. That is

  If SORT = 0, let SORT = 1, INCX = |INCX|;

  If SORT = 1, let SORT = 0, INCX = |INCX|.

• P (output)
  vector recording the details of the interchanges of the elements of X during sorting. That is X = P*X. In this implementation, P contains the index of sorted X.

• INCP (input)
  INCP must not be zero. INCP could be negative. If INCP < 0, store P(i) in reverse order. That is

  If INCP > 0,

    if INCX  > 0,

      sorted X((i-1)*INCX+1)  = X(P((i-1)*INCP+1)),

    if INCX  < 0,

      sorted X((N-i)*|INCX|+1)  = X(P((i-1)*INCP+1));

  If INCP < 0,

    if INCX  > 0,

      sorted X((i-1)*INCX+1)  = X(P((N-i)*|INCP|+1)),

    if INCX  < 0,

      sorted X((N-i)*|INCX|+1)

            = X(P((N-i)*|INCP|+1)).

SEE ALSO

blas_dsort(3P), blas_dpermute(3P)