/Include/acml.h

Large files files are truncated, but you can click here to view the full file

/*
 * ACML version 3.6.0 Copyright AMD,NAG 2003,2004,2005
 */

/*
  This is the ACML header file. It contains function prototypes
  to allow a C programmer to call ACML routines via their C
  or Fortran interfaces.

  C interfaces to ACML routines differ from FORTRAN interfaces in
  the following major respects:

    (i) The FORTRAN interface names are appended by an underscore.

   (ii) The C interfaces contain no workspace arguments; all
        workspace memory is allocated internally.

  (iii) Scalar input arguments are passed by value in C interfaces.
        FORTRAN interfaces pass all arguments (except for character
        string "length" arguments that are normally hidden from
        FORTRAN programmers) by reference.

   (iv) Most arguments that are passed as character string pointers
        to FORTRAN interfaces are passed by value as single
        characters to C interfaces. The character string "length"
        arguments of FORTRAN interfaces are not required in the
        C interfaces.

  It is important to note that in both the FORTRAN and C interfaces,
  2-dimensional arrays are assumed to be stored in column-major order.
  e.g. the matrix A = [ 1.0 2.0 ]
                      [ 3.0 4.0 ]
  would be stored in memory as 1.0, 3.0, 2.0, 4.0. This storage order
  corresponds to a FORTRAN-style 2-D array declaration A(2,2), but not
  to an array declared as a[2][2] in C which would be stored in
  row-major order as 1.0, 2.0, 3.0, 4.0.

  As an example, compare the FORTRAN and C interfaces of LAPACK
  routine dsytrf as implemented in ACML.
  FORTRAN:
    void dsytrf_(char *uplo, int *n, double *a, int *lda, int *ipiv,
                 double *work, int *lwork, int *info, int uplo_len);

  C:
    void dsytrf(char uplo, int n, double *a, int lda, int *ipiv, int *info);

  C code calling both the above variants might look like this:

    double *a;
    int *ipiv;
    double *work;
    int n, lda, lwork, info;

    //
    // Assume that all arrays and variables are allocated and initialized
    // as required by dsytrf.
    //
    // Call the FORTRAN version of dsytrf. The first argument is a character
    // string, and the last argument is the length of that string. The input
    // scalar arguments n, lda and lwork, as well as the output scalar
    // argument info, are all passed by reference.
    dsytrf_("Upper", &n, a, &lda, ipiv, work, &lwork, &info, 5);

    //
    // Call the C version of dsytrf. The first argument is a character,
    // workspace is not required, and input scalar arguments n and lda are
    // passed by value. Output scalar argument info is passed by reference.
    dsytrf('U', n, a, lda, ipiv, &info);

*/

#ifndef _ACML_H
#define _ACML_H

/* Under Windows math.h defines "complex" to mean "_complex". */
#include <math.h>
#undef complex

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/* ------------------------------------------------------------------ */

/* A complex datatype for use by the C interfaces to ACML routines */
#ifndef _ACML_COMPLEX
#define _ACML_COMPLEX
typedef struct
{
  float real, imag;
} complex;
typedef struct
{
  double real, imag;
} doublecomplex;
#endif /* !defined(_ACML_COMPLEX) */
/*
   These typedefs are for routines that are arguments to other routines,
   e.g. ACML_CGEES_SELECT describes the argument "select" of routine cgees.
 */
typedef int (* ACML_CGEES_SELECT)(complex *);
typedef int (* ACML_CGEESX_SELECT)(complex *);
typedef int (* ACML_CGGES_SELCTG)(complex *, complex *);
typedef int (* ACML_CGGESX_SELCTG)(complex *, complex *);
typedef int (* ACML_DGEES_SELECT)(double *, double *);
typedef int (* ACML_DGEESX_SELECT)(double *, double *);
typedef int (* ACML_DGGES_DELCTG)(double *, double *, double *);
typedef int (* ACML_DGGESX_DELCTG)(double *, double *, double *);
typedef int (* ACML_SGEES_SELECT)(float *, float *);
typedef int (* ACML_SGEESX_SELECT)(float *, float *);
typedef int (* ACML_SGGES_SELCTG)(float *, float *, float *);
typedef int (* ACML_SGGESX_SELCTG)(float *, float *, float *);
typedef int (* ACML_ZGEES_SELECT)(doublecomplex *);
typedef int (* ACML_ZGEESX_SELECT)(doublecomplex *);
typedef int (* ACML_ZGGES_DELCTG)(doublecomplex *, doublecomplex *);
typedef int (* ACML_ZGGESX_DELCTG)(doublecomplex *, doublecomplex *);
typedef void (* ACML_DRANDINITIALIZEUSER_UINI)(int *, int *, int *, int *, int *, int *, int *);
typedef void (* ACML_DRANDINITIALIZEUSER_UGEN)(int *, int *, double *, int *);
typedef void (* ACML_SRANDINITIALIZEUSER_UINI)(int *, int *, int *, int *, int *, int *, int *);
typedef void (* ACML_SRANDINITIALIZEUSER_UGEN)(int *, int *, float *, int *);

/* ------------------------------------------------------------------ */
/* Below are prototypes for the C interfaces to ACML routines */

/* BLAS C interfaces */
extern void caxpy(int n, complex *alpha, complex *x, int incx, complex *y, int incy);
extern void ccopy(int n, complex *x, int incx, complex *y, int incy);
extern complex cdotc(int n, complex *x, int incx, complex *y, int incy);
extern complex cdotu(int n, complex *x, int incx, complex *y, int incy);
extern void cgbmv(char transa, int m, int n, int nsub, int nsuper, complex *alpha, complex *a, int lda, complex *x, int incx, complex *beta, complex *y, int incy);
extern void cgemm(char transa, char transb, int m, int n, int k, complex *alpha, complex *a, int lda, complex *b, int ldb, complex *beta, complex *c, int ldc);
extern void cgemv(char transa, int m, int n, complex *alpha, complex *a, int lda, complex *x, int incx, complex *beta, complex *y, int incy);
extern void cgerc(int m, int n, complex *alpha, complex *x, int incx, complex *y, int incy, complex *a, int lda);
extern void cgeru(int m, int n, complex *alpha, complex *x, int incx, complex *y, int incy, complex *a, int lda);
extern void chbmv(char uplo, int n, int ndiag, complex *alpha, complex *a, int lda, complex *x, int incx, complex *beta, complex *y, int incy);
extern void chemm(char side, char uplo, int m, int n, complex *alpha, complex *a, int lda, complex *b, int ldb, complex *beta, complex *c, int ldc);
extern void chemv(char uplo, int n, complex *alpha, complex *a, int lda, complex *x, int incx, complex *beta, complex *y, int incy);
extern void cher(char uplo, int n, float alpha, complex *x, int incx, complex *a, int lda);
extern void cher2(char uplo, int n, complex *alpha, complex *x, int incx, complex *y, int incy, complex *a, int lda);
extern void cher2k(char uplo, char transa, int n, int k, complex *alpha, complex *a, int lda, complex *b, int ldb, float beta, complex *c, int ldc);
extern void cherk(char uplo, char transa, int n, int k, float alpha, complex *a, int lda, float beta, complex *c, int ldc);
extern void chpmv(char uplo, int n, complex *alpha, complex *a, complex *x, int incx, complex *beta, complex *y, int incy);
extern void chpr(char uplo, int n, float alpha, complex *x, int incx, complex *a);
extern void chpr2(char uplo, int n, complex *alpha, complex *x, int incx, complex *y, int incy, complex *a);
extern void crotg(complex *a, complex *b, float *c, complex *s);
extern void cscal(int n, complex *alpha, complex *y, int incy);
extern void csrot(int n, complex *x, int incx, complex *y, int incy, float c, float s);
extern void csscal(int n, float alpha, complex *y, int incy);
extern void cswap(int n, complex *x, int incx, complex *y, int incy);
extern void csymm(char side, char uplo, int m, int n, complex *alpha, complex *a, int lda, complex *b, int ldb, complex *beta, complex *c, int ldc);
extern void csyr2k(char uplo, char transa, int n, int k, complex *alpha, complex *a, int lda, complex *b, int ldb, complex *beta, complex *c, int ldc);
extern void csyrk(char uplo, char transa, int n, int k, complex *alpha, complex *a, int lda, complex *beta, complex *c, int ldc);
extern void ctbmv(char uplo, char transa, char diag, int n, int ndiag, complex *a, int lda, complex *y, int incy);
extern void ctbsv(char uplo, char transa, char diag, int n, int ndiag, complex *a, int lda, complex *y, int incy);
extern void ctpmv(char uplo, char transa, char diag, int n, complex *a, complex *y, int incy);
extern void ctpsv(char uplo, char transa, char diag, int n, complex *a, complex *y, int incy);
extern void ctrmm(char side, char uplo, char transa, char diag, int m, int n, complex *alpha, complex *a, int lda, complex *b, int ldb);
extern void ctrmv(char uplo, char transa, char diag, int n, complex *a, int lda, complex *y, int incy);
extern void ctrsm(char side, char uplo, char transa, char diag, int m, int n, complex *alpha, complex *a, int lda, complex *b, int ldb);
extern void ctrsv(char uplo, char transa, char diag, int n, complex *a, int lda, complex *y, int incy);
extern double dasum(int n, double *x, int incx);
extern void daxpy(int n, double alpha, double *x, int incx, double *y, int incy);
extern void dcopy(int n, double *x, int incx, double *y, int incy);
extern double ddot(int n, double *x, int incx, double *y, int incy);
extern void dgbmv(char transa, int m, int n, int nsub, int nsuper, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy);
extern void dgemm(char transa, char transb, int m, int n, int k, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc);
extern void dgemv(char transa, int m, int n, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy);
extern void dger(int m, int n, double alpha, double *x, int incx, double *y, int incy, double *a, int lda);
extern double dnrm2(int n, double *x, int incx);
extern void drot(int n, double *x, int incx, double *y, int incy, double c, double s);
extern void drotg(double *a, double *b, double *c, double *s);
extern void drotm(int n, double *x, int incx, double *y, int incy, double *param);
extern void drotmg(double d1, double d2, double b1, double b2, double *param);
extern void dsbmv(char uplo, int n, int ndiag, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy);
extern void dscal(int n, double alpha, double *y, int incy);
extern double dsdot(int n, float *x, int incx, float *y, int incy);
extern void dspmv(char uplo, int n, double alpha, double *a, double *x, int incx, double beta, double *y, int incy);
extern void dspr(char uplo, int n, double alpha, double *x, int incx, double *a);
extern void dspr2(char uplo, int n, double alpha, double *x, int incx, double *y, int incy, double *a);
extern void dswap(int n, double *x, int incx, double *y, int incy);
extern void dsymm(char side, char uplo, int m, int n, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc);
extern void dsymv(char uplo, int n, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy);
extern void dsyr(char uplo, int n, double alpha, double *x, int incx, double *a, int lda);
extern void dsyr2(char uplo, int n, double alpha, double *x, int incx, double *y, int incy, double *a, int lda);
extern void dsyr2k(char uplo, char transa, int n, int k, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc);
extern void dsyrk(char uplo, char transa, int n, int k, double alpha, double *a, int lda, double beta, double *c, int ldc);
extern void dtbmv(char uplo, char transa, char diag, int n, int ndiag, double *a, int lda, double *y, int incy);
extern void dtbsv(char uplo, char transa, char diag, int n, int ndiag, double *a, int lda, double *y, int incy);
extern void dtpmv(char uplo, char transa, char diag, int n, double *a, double *y, int incy);
extern void dtpsv(char uplo, char transa, char diag, int n, double *a, double *y, int incy);
extern void dtrmm(char side, char uplo, char transa, char diag, int m, int n, double alpha, double *a, int lda, double *b, int ldb);
extern void dtrmv(char uplo, char transa, char diag, int n, double *a, int lda, double *y, int incy);
extern void dtrsm(char side, char uplo, char transa, char diag, int m, int n, double alpha, double *a, int lda, double *b, int ldb);
extern void dtrsv(char uplo, char transa, char diag, int n, double *a, int lda, double *y, int incy);
extern double dzasum(int n, doublecomplex *x, int incx);
extern double dznrm2(int n, doublecomplex *x, int incx);
extern int icamax(int n, complex *x, int incx);
extern int idamax(int n, double *x, int incx);
extern int isamax(int n, float *x, int incx);
extern int izamax(int n, doublecomplex *x, int incx);
extern int lsame(char ca, char cb);
extern float sasum(int n, float *x, int incx);
extern void saxpy(int n, float alpha, float *x, int incx, float *y, int incy);
extern float scasum(int n, complex *x, int incx);
extern float scnrm2(int n, complex *x, int incx);
extern void scopy(int n, float *x, int incx, float *y, int incy);
extern float sdot(int n, float *x, int incx, float *y, int incy);
extern float sdsdot(int n, float sb, float *sx, int incx, float *sy, int incy);
extern void sgbmv(char transa, int m, int n, int nsub, int nsuper, float alpha, float *a, int lda, float *x, int incx, float beta, float *y, int incy);
extern void sgemm(char transa, char transb, int m, int n, int k, float alpha, float *a, int lda, float *b, int ldb, float beta, float *c, int ldc);
extern void sgemv(char transa, int m, int n, float alpha, float *a, int lda, float *x, int incx, float beta, float *y, int incy);
extern void sger(int m, int n, float alpha, float *x, int incx, float *y, int incy, float *a, int lda);
extern float snrm2(int n, float *x, int incx);
extern void srot(int n, float *x, int incx, float *y, int incy, float c, float s);
extern void srotg(float *a, float *b, float *c, float *s);
extern void srotm(int n, float *x, int incx, float *y, int incy, float *param);
extern void srotmg(float d1, float d2, float b1, float b2, float *param);
extern void ssbmv(char uplo, int n, int ndiag, float alpha, float *a, int lda, float *x, int incx, float beta, float *y, int incy);
extern void sscal(int n, float alpha, float *x, int incx);
extern void sspmv(char uplo, int n, float alpha, float *a, float *x, int incx, float beta, float *y, int incy);
extern void sspr(char uplo, int n, float alpha, float *x, int incx, float *a);
extern void sspr2(char uplo, int n, float alpha, float *x, int incx, float *y, int incy, float *a);
extern void sswap(int n, float *x, int incx, float *y, int incy);
extern void ssymm(char side, char uplo, int m, int n, float alpha, float *a, int lda, float *b, int ldb, float beta, float *c, int ldc);
extern void ssymv(char uplo, int n, float alpha, float *a, int lda, float *x, int incx, float beta, float *y, int incy);
extern void ssyr(char uplo, int n, float alpha, float *x, int incx, float *a, int lda);
extern void ssyr2(char uplo, int n, float alpha, float *x, int incx, float *y, int incy, float *a, int lda);
extern void ssyr2k(char uplo, char transa, int n, int k, float alpha, float *a, int lda, float *b, int ldb, float beta, float *c, int ldc);
extern void ssyrk(char uplo, char transa, int n, int k, float alpha, float *a, int lda, float beta, float *c, int ldc);
extern void stbmv(char uplo, char transa, char diag, int n, int ndiag, float *a, int lda, float *y, int incy);
extern void stbsv(char uplo, char transa, char diag, int n, int ndiag, float *a, int lda, float *y, int incy);
extern void stpmv(char uplo, char transa, char diag, int n, float *a, float *y, int incy);
extern void stpsv(char uplo, char transa, char diag, int n, float *a, float *y, int incy);
extern void strmm(char side, char uplo, char transa, char diag, int m, int n, float alpha, float *a, int lda, float *b, int ldb);
extern void strmv(char uplo, char transa, char diag, int n, float *a, int lda, float *y, int incy);
extern void strsm(char side, char uplo, char transa, char diag, int m, int n, float alpha, float *a, int lda, float *b, int ldb);
extern void strsv(char uplo, char transa, char diag, int n, float *a, int lda, float *y, int incy);
extern void xerbla(const char *srname, int *info);
extern void zaxpy(int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern void zcopy(int n, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern doublecomplex zdotc(int n, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern doublecomplex zdotu(int n, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern void zdrot(int n, doublecomplex *cx, int incx, doublecomplex *cy, int incy, double c, double s);
extern void zdscal(int n, double alpha, doublecomplex *y, int incy);
extern void zgbmv(char transa, int m, int n, int nsub, int nsuper, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zgemm(char transa, char transb, int m, int n, int k, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *beta, doublecomplex *c, int ldc);
extern void zgemv(char transa, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zgerc(int m, int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *a, int lda);
extern void zgeru(int m, int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *a, int lda);
extern void zhbmv(char uplo, int n, int ndiag, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zhemm(char side, char uplo, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *beta, doublecomplex *c, int ldc);
extern void zhemv(char uplo, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zher(char uplo, int n, double alpha, doublecomplex *x, int incx, doublecomplex *a, int lda);
extern void zher2(char uplo, int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *a, int lda);
extern void zher2k(char uplo, char transa, int n, int k, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, double beta, doublecomplex *c, int ldc);
extern void zherk(char uplo, char transa, int n, int k, double alpha, doublecomplex *a, int lda, double beta, doublecomplex *c, int ldc);
extern void zhpmv(char uplo, int n, doublecomplex *alpha, doublecomplex *a, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zhpr(char uplo, int n, double alpha, doublecomplex *x, int incx, doublecomplex *a);
extern void zhpr2(char uplo, int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *a);
extern void zrotg(doublecomplex *a, doublecomplex *b, double *c, doublecomplex *s);
extern void zscal(int n, doublecomplex *alpha, doublecomplex *y, int incy);
extern void zswap(int n, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern void zsymm(char side, char uplo, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *beta, doublecomplex *c, int ldc);
extern void zsyr2k(char uplo, char transa, int n, int k, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *beta, doublecomplex *c, int ldc);
extern void zsyrk(char uplo, char transa, int n, int k, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *beta, doublecomplex *c, int ldc);
extern void ztbmv(char uplo, char transa, char diag, int n, int ndiag, doublecomplex *a, int lda, doublecomplex *y, int incy);
extern void ztbsv(char uplo, char transa, char diag, int n, int ndiag, doublecomplex *a, int lda, doublecomplex *y, int incy);
extern void ztpmv(char uplo, char transa, char diag, int n, doublecomplex *a, doublecomplex *y, int incy);
extern void ztpsv(char uplo, char transa, char diag, int n, doublecomplex *a, doublecomplex *y, int incy);
extern void ztrmm(char side, char uplo, char transa, char diag, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb);
extern void ztrmv(char uplo, char transa, char diag, int n, doublecomplex *a, int lda, doublecomplex *y, int incy);
extern void ztrsm(char side, char uplo, char transa, char diag, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb);
extern void ztrsv(char uplo, char transa, char diag, int n, doublecomplex *a, int lda, doublecomplex *y, int incy);

/* LAPACK C interfaces */
extern int ilaenv(int ispec, const char *name, const char *opts, int n1, int n2, int n3, int n4);
extern void ilaenvset(int ispec, const char *name, const char *opts, int n1, int n2, int n3, int n4, int nvalue, int *info);
extern void cbdsqr(char uplo, int n, int ncvt, int nru, int ncc, float *d, float *e, complex *vt, int ldvt, complex *u, int ldu, complex *c, int ldc, int *info);
extern void cgbbrd(char vect, int m, int n, int ncc, int kl, int ku, complex *ab, int ldab, float *d, float *e, complex *q, int ldq, complex *pt, int ldpt, complex *c, int ldc, int *info);
extern void cgbcon(char norm, int n, int nsub, int nsuper, complex *a, int lda, int *ipiv, float anorm, float *rcond, int *info);
extern void cgbequ(int m, int n, int nsub, int nsuper, complex *a, int lda, float *rowsc, float *colsc, float *rowcnd, float *colcnd, float *amax, int *info);
extern void cgbrfs(char transa, int n, int nsub, int nsuper, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cgbsv(int n, int nsub, int nsuper, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);

/* N.B. In this C interface to cgbsvx, rpvgrw returns what is returned in
   the first element of RWORK by the FORTRAN interface */
extern void cgbsvx(char fact, char transa, int n, int nsub, int nsuper, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, char equed, float *rowsc, float *colsc, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, float *rpvgrw, int *info);

extern void cgbtrf(int m, int n, int nsub, int nsuper, complex *a, int lda, int *ipiv, int *info);
extern void cgbtrs(char transa, int n, int nsub, int nsuper, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void cgebak(char job, char side, int n, int ilo, int ihi, float *scale, int m, complex *v, int ldv, int *info);
extern void cgebal(char job, int n, complex *a, int lda, int *ilo, int *ihi, float *scale, int *info);
extern void cgebrd(int m, int n, complex *a, int lda, float *d, float *e, complex *tauq, complex *taup, int *info);
extern void cgecon(char norm, int n, complex *a, int lda, float anorm, float *rcond, int *info);
extern void cgeequ(int m, int n, complex *a, int lda, float *rowsc, float *colsc, float *rowcnd, float *colcnd, float *amax, int *info);
extern void cgees(char jobz, char sortev, ACML_CGEES_SELECT select, int n, complex *a, int lda, int *nout, complex *w, complex *z, int ldz, int *info);
extern void cgeesx(char jobz, char sortev, ACML_CGEESX_SELECT select, char sense, int n, complex *a, int lda, int *nout, complex *w, complex *z, int ldz, float *rcone, float *rconv, int *info);
extern void cgeev(char jobvl, char jobvr, int n, complex *a, int lda, complex *w, complex *vl, int ldvl, complex *vr, int ldvr, int *info);
extern void cgeevx(char balanc, char jobvl, char jobvr, char sense, int n, complex *a, int lda, complex *w, complex *vl, int ldvl, complex *vr, int ldvr, int *ilo, int *ihi, float *scale, float *abnrm, float *rconde, float *rcondv, int *info);
extern void cgegs(char jobvsl, char jobvsr, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *vsl, int ldvsl, complex *vsr, int ldvsr, int *info);
extern void cgegv(char jobvl, char jobvr, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *vl, int ldvl, complex *vr, int ldvr, int *info);
extern void cgehrd(int n, int ilo, int ihi, complex *a, int lda, complex *tau, int *info);
extern void cgelqf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cgels(char trans, int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cgelsd(int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, float *s, float rcond, int *rank, int *info);
extern void cgelss(int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, float *sing, float rcond, int *irank, int *info);
extern void cgelsx(int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *jpivot, float rcond, int *irank, int *info);
extern void cgelsy(int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *jpvt, float rcond, int *rank, int *info);
extern void cgeqlf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cgeqp3(int m, int n, complex *a, int lda, int *jpvt, complex *tau, int *info);
extern void cgeqpf(int m, int n, complex *a, int lda, int *jpvt, complex *tau, int *info);
extern void cgeqrf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cgerfs(char transa, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cgerqf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cgesdd(char jobz, int m, int n, complex *a, int lda, float *s, complex *u, int ldu, complex *vt, int ldvt, int *info);
extern void cgesv(int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void cgesvd(char jobu, char jobvt, int m, int n, complex *a, int lda, float *sing, complex *u, int ldu, complex *vt, int ldvt, int *info);

/* N.B. In this C interface to cgesvx, rpvgrw returns what is returned in
   the first element of RWORK by the FORTRAN interface */
extern void cgesvx(char fact, char transa, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, char equed, float *rowsc, float *colsc, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, float *rpvgrw, int *info);

extern void cgetrf(int m, int n, complex *a, int lda, int *ipiv, int *info);
extern void cgetri(int n, complex *a, int lda, int *ipiv, int *info);
extern void cgetrs(char transa, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void cggbak(char job, char side, int n, int ilo, int ihi, float *lscale, float *rscale, int m, complex *v, int ldv, int *info);
extern void cggbal(char job, int n, complex *a, int lda, complex *b, int ldb, int *ilo, int *ihi, float *lscale, float *rscale, int *info);
extern void cgges(char jobvsl, char jobvsr, char sort, ACML_CGGES_SELCTG selctg, int n, complex *a, int lda, complex *b, int ldb, int *sdim, complex *alpha, complex *beta, complex *vsl, int ldvsl, complex *vsr, int ldvsr, int *info);
extern void cggesx(char jobvsl, char jobvsr, char sort, ACML_CGGESX_SELCTG selctg, char sense, int n, complex *a, int lda, complex *b, int ldb, int *sdim, complex *alpha, complex *beta, complex *vsl, int ldvsl, complex *vsr, int ldvsr, float *rconde, float *rcondv, int *info);
extern void cggev(char jobvl, char jobvr, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *vl, int ldvl, complex *vr, int ldvr, int *info);
extern void cggevx(char balanc, char jobvl, char jobvr, char sense, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *vl, int ldvl, complex *vr, int ldvr, int *ilo, int *ihi, float *lscale, float *rscale, float *abnrm, float *bbnrm, float *rconde, float *rcondv, int *info);
extern void cggglm(int n, int m, int p, complex *a, int lda, complex *b, int ldb, complex *d, complex *x, complex *y, int *info);
extern void cgghrd(char compq, char compz, int n, int ilo, int ihi, complex *a, int lda, complex *b, int ldb, complex *q, int ldq, complex *z, int ldz, int *info);
extern void cgglse(int m, int n, int p, complex *a, int lda, complex *b, int ldb, complex *c, complex *d, complex *x, int *info);
extern void cggqrf(int n, int m, int p, complex *a, int lda, complex *taua, complex *b, int ldb, complex *taub, int *info);
extern void cggrqf(int m, int p, int n, complex *a, int lda, complex *taua, complex *b, int ldb, complex *taub, int *info);
extern void cggsvd(char jobu, char jobv, char jobq, int m, int n, int p, int *k, int *l, complex *a, int lda, complex *b, int ldb, float *alpha, float *beta, complex *u, int ldu, complex *v, int ldv, complex *q, int ldq, int *iwork, int *info);
extern void cggsvp(char jobu, char jobv, char jobq, int m, int p, int n, complex *a, int lda, complex *b, int ldb, float tola, float tolb, int *k, int *l, complex *u, int ldu, complex *v, int ldv, complex *q, int ldq, int *info);
extern void cgtcon(char norm, int n, complex *low, complex *diag, complex *up1, complex *up2, int *ipiv, float anorm, float *rcond, int *info);
extern void cgtrfs(char transa, int n, int nrhs, complex *low, complex *diag, complex *up, complex *lowf, complex *diagf, complex *upf1, complex *upf2, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cgtsv(int n, int nrhs, complex *low, complex *diag, complex *up, complex *b, int ldb, int *info);
extern void cgtsvx(char fact, char transa, int n, int nrhs, complex *low, complex *diag, complex *up, complex *lowf, complex *diagf, complex *upf1, complex *upf2, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cgttrf(int n, complex *low, complex *diag, complex *up1, complex *up2, int *ipiv, int *info);
extern void cgttrs(char transa, int n, int nrhs, complex *low, complex *diag, complex *up1, complex *up2, int *ipiv, complex *b, int ldb, int *info);
extern void chbev(char jobz, char uplo, int n, int ndiag, complex *a, int lda, float *w, complex *z, int ldz, int *info);
extern void chbevd(char jobz, char uplo, int n, int kd, complex *ab, int ldab, float *w, complex *z, int ldz, int *info);
extern void chbevx(char jobz, char range, char uplo, int n, int ndiag, complex *a, int lda, complex *q, int ldq, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chbgst(char vect, char uplo, int n, int ka, int kb, complex *ab, int ldab, complex *bb, int ldbb, complex *x, int ldx, int *info);
extern void chbgv(char jobz, char uplo, int n, int ka, int kb, complex *ab, int ldab, complex *bb, int ldbb, float *w, complex *z, int ldz, int *info);
extern void chbgvd(char jobz, char uplo, int n, int ka, int kb, complex *ab, int ldab, complex *bb, int ldbb, float *w, complex *z, int ldz, int *info);
extern void chbgvx(char jobz, char range, char uplo, int n, int ka, int kb, complex *ab, int ldab, complex *bb, int ldbb, complex *q, int ldq, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chbtrd(char vect, char uplo, int n, int kd, complex *ab, int ldab, float *d, float *e, complex *q, int ldq, int *info);
extern void checon(char uplo, int n, complex *a, int lda, int *ipiv, float anorm, float *rcond, int *info);
extern void cheev(char jobz, char uplo, int n, complex *a, int lda, float *w, int *info);
extern void cheevd(char jobz, char uplo, int n, complex *a, int lda, float *w, int *info);
extern void cheevr(char jobz, char range, char uplo, int n, complex *a, int lda, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *isuppz, int *info);
extern void cheevx(char jobz, char range, char uplo, int n, complex *a, int lda, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chegst(int itype, char uplo, int n, complex *a, int lda, complex *b, int ldb, int *info);
extern void chegv(int itype, char jobz, char uplo, int n, complex *a, int lda, complex *b, int ldb, float *w, int *info);
extern void chegvd(int itype, char jobz, char uplo, int n, complex *a, int lda, complex *b, int ldb, float *w, int *info);
extern void chegvx(int itype, char jobz, char range, char uplo, int n, complex *a, int lda, complex *b, int ldb, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *ifail, int *info);
extern void cherfs(char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void chesv(char uplo, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void chesvx(char fact, char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void chetrd(char uplo, int n, complex *a, int lda, float *d, float *e, complex *tau, int *info);
extern void chetrf(char uplo, int n, complex *a, int lda, int *ipiv, int *info);
extern void chetri(char uplo, int n, complex *a, int lda, int *ipiv, int *info);
extern void chetrs(char uplo, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void chgeqz(char job, char compq, char compz, int n, int ilo, int ihi, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *q, int ldq, complex *z, int ldz, int *info);
extern void chpcon(char uplo, int n, complex *a, int *ipiv, float anorm, float *rcond, int *info);
extern void chpev(char jobz, char uplo, int n, complex *a, float *w, complex *z, int ldz, int *info);
extern void chpevd(char jobz, char uplo, int n, complex *ap, float *w, complex *z, int ldz, int *info);
extern void chpevx(char jobz, char range, char uplo, int n, complex *a, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chpgst(int itype, char uplo, int n, complex *ap, complex *bp, int *info);
extern void chpgv(int itype, char jobz, char uplo, int n, complex *a, complex *b, float *w, complex *z, int ldz, int *info);
extern void chpgvd(int itype, char jobz, char uplo, int n, complex *ap, complex *bp, float *w, complex *z, int ldz, int *info);
extern void chpgvx(int itype, char jobz, char range, char uplo, int n, complex *ap, complex *bp, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chprfs(char uplo, int n, int nrhs, complex *a, complex *af, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void chpsv(char uplo, int n, int nrhs, complex *a, int *ipiv, complex *b, int ldb, int *info);
extern void chpsvx(char fact, char uplo, int n, int nrhs, complex *a, complex *af, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void chptrd(char uplo, int n, complex *ap, float *d, float *e, complex *tau, int *info);
extern void chptrf(char uplo, int n, complex *a, int *ipiv, int *info);
extern void chptri(char uplo, int n, complex *a, int *ipiv, int *info);
extern void chptrs(char uplo, int n, int nrhs, complex *a, int *ipiv, complex *b, int ldb, int *info);
extern void chsein(char side, char eigsrc, char initv, int *select, int n, complex *h, int ldh, complex *w, complex *vl, int ldvl, complex *vr, int ldvr, int mm, int *m, int *ifaill, int *ifailr, int *info);
extern void chseqr(char job, char compz, int n, int ilo, int ihi, complex *h, int ldh, complex *w, complex *z, int ldz, int *info);
extern void cpbcon(char uplo, int n, int ndiag, complex *a, int lda, float anorm, float *rcond, int *info);
extern void cpbequ(char uplo, int n, int ndiag, complex *a, int lda, float *scale, float *scond, float *amax, int *info);
extern void cpbrfs(char uplo, int n, int ndiag, int nrhs, complex *a, int lda, complex *af, int ldaf, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cpbstf(char uplo, int n, int kd, complex *ab, int ldab, int *info);
extern void cpbsv(char uplo, int n, int ndiag, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cpbsvx(char fact, char uplo, int n, int ndiag, int nrhs, complex *a, int lda, complex *af, int ldaf, char equed, float *scale, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cpbtrf(char uplo, int n, int ndiag, complex *a, int lda, int *info);
extern void cpbtrs(char uplo, int n, int ndiag, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cpocon(char uplo, int n, complex *a, int lda, float anorm, float *rcond, int *info);
extern void cpoequ(int n, complex *a, int lda, float *scale, float *scond, float *amax, int *info);
extern void cporfs(char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cposv(char uplo, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cposvx(char fact, char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, char equed, float *scale, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cpotrf(char uplo, int n, complex *a, int lda, int *info);
extern void cpotri(char uplo, int n, complex *a, int lda, int *info);
extern void cpotrs(char uplo, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cppcon(char uplo, int n, complex *a, float anorm, float *rcond, int *info);
extern void cppequ(char uplo, int n, complex *a, float *scale, float *scond, float *amax, int *info);
extern void cpprfs(char uplo, int n, int nrhs, complex *a, complex *af, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cppsv(char uplo, int n, int nrhs, complex *a, complex *b, int ldb, int *info);
extern void cppsvx(char fact, char uplo, int n, int nrhs, complex *a, complex *af, char equed, float *scale, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cpptrf(char uplo, int n, complex *a, int *info);
extern void cpptri(char uplo, int n, complex *a, int *info);
extern void cpptrs(char uplo, int n, int nrhs, complex *a, complex *b, int ldb, int *info);
extern void cptcon(int n, float *diag, complex *offd, float anorm, float *rcond, int *info);
extern void cpteqr(char compz, int n, float *d, float *e, complex *z, int ldz, int *info);
extern void cptrfs(char uplo, int n, int nrhs, float *diag, complex *offd, float *diagf, complex *offdf, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cptsv(int n, int nrhs, float *diag, complex *sub, complex *b, int ldb, int *info);
extern void cptsvx(char fact, int n, int nrhs, float *diag, complex *sub, float *diagf, complex *subf, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cpttrf(int n, float *diag, complex *offd, int *info);
extern void cpttrs(char uplo, int n, int nrhs, float *diag, complex *offd, complex *b, int ldb, int *info);
extern void cspcon(char uplo, int n, complex *a, int *ipiv, float anorm, float *rcond, int *info);
extern void csprfs(char uplo, int n, int nrhs, complex *a, complex *af, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cspsv(char uplo, int n, int nrhs, complex *a, int *ipiv, complex *b, int ldb, int *info);
extern void cspsvx(char fact, char uplo, int n, int nrhs, complex *a, complex *af, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void csptrf(char uplo, int n, complex *a, int *ipiv, int *info);
extern void csptri(char uplo, int n, complex *a, int *ipiv, int *info);
extern void csptrs(char uplo, int n, int nrhs, complex *a, int *ipiv, complex *b, int ldb, int *info);
extern void cstedc(char compz, int n, float *d, float *e, complex *z, int ldz, int *info);
extern void cstegr(char jobz, char range, int n, float *d, float *e, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *isuppz, int *info);
extern void cstein(int n, float *d, float *e, int m, float *w, int *iblock, int *isplit, complex *z, int ldz, int *ifail, int *info);
extern void csteqr(char compz, int n, float *d, float *e, complex *z, int ldz, int *info);
extern void csycon(char uplo, int n, complex *a, int lda, int *ipiv, float anorm, float *rcond, int *info);
extern void csyrfs(char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void csysv(char uplo, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void csysvx(char fact, char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void csytrf(char uplo, int n, complex *a, int lda, int *ipiv, int *info);
extern void csytri(char uplo, int n, complex *a, int lda, int *ipiv, int *info);
extern void csytrs(char uplo, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void ctbcon(char norm, char uplo, char diag, int n, int ndiag, complex *a, int lda, float *rcond, int *info);
extern void ctbrfs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, complex *a, int lda, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void ctbtrs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void ctgevc(char side, char howmny, int *select, int n, complex *a, int lda, complex *b, int ldb, complex *vl, int ldvl, complex *vr, int ldvr, int mm, int *m, int *info);
extern void ctgexc(int wantq, int wantz, int n, complex *a, int lda, complex *b, int ldb, complex *q, int ldq, complex *z, int ldz, int *ifst, int *ilst, int *info);
extern void ctgsen(int ijob, int wantq, int wantz, int *select, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *q, int ldq, complex *z, int ldz, int *m, float *pl, float *pr, float *dif, int *info);
extern void ctgsja(char jobu, char jobv, char jobq, int m, int p, int n, int k, int l, complex *a, int lda, complex *b, int ldb, float tola, float tolb, float *alpha, float *beta, complex *u, int ldu, complex *v, int ldv, complex *q, int ldq, int *ncycle, int *info);
extern void ctgsna(char job, char howmnt, int *select, int n, complex *a, int lda, complex *b, int ldb, complex *vl, int ldvl, complex *vr, int ldvr, float *s, float *dif, int mm, int *m, int *info);
extern void ctgsyl(char trans, int ijob, int m, int n, complex *a, int lda, complex *b, int ldb, complex *c, int ldc, complex *d, int ldd, complex *e, int lde, complex *f, int ldf, float *scale, float *dif, int *info);
extern void ctpcon(char norm, char uplo, char diag, int n, complex *a, float *rcond, int *info);
extern void ctprfs(char uplo, char transa, char diag, int n, int nrhs, complex *a, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void ctptri(char uplo, char diag, int n, complex *a, int *info);
extern void ctptrs(char uplo, char transa, char diag, int n, int nrhs, complex *a, complex *b, int ldb, int *info);
extern void ctrcon(char norm, char uplo, char diag, int n, complex *a, int lda, float *rcond, int *info);
extern void ctrevc(char side, char howmny, int *select, int n, complex *t, int ldt, complex *vl, int ldvl, complex *vr, int ldvr, int mm, int *m, int *info);
extern void ctrexc(char compq, int n, complex *t, int ldt, complex *q, int ldq, int ifst, int ilst, int *info);
extern void ctrrfs(char uplo, char transa, char diag, int n, int nrhs, complex *a, int lda, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void ctrsen(char job, char compq, int *select, int n, complex *t, int ldt, complex *q, int ldq, complex *w, int *m, float *s, float *sep, int *info);
extern void ctrsna(char job, char howmny, int *select, int n, complex *t, int ldt, complex *vl, int ldvl, complex *vr, int ldvr, float *s, float *sep, int mm, int *m, int *info);
extern void ctrsyl(char trana, char tranb, int isgn, int m, int n, complex *a, int lda, complex *b, int ldb, complex *c, int ldc, float *scale, int *info);
extern void ctrtri(char uplo, char diag, int n, complex *a, int lda, int *info);
extern void ctrtrs(char uplo, char transa, char diag, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void ctzrqf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void ctzrzf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cungbr(char vect, int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cunghr(int n, int ilo, int ihi, complex *a, int lda, complex *tau, int *info);
extern void cunglq(int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cungql(int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cungqr(int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cungrq(int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cungtr(char uplo, int n, complex *a, int lda, complex *tau, int *info);
extern void cunmbr(char vect, char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmhr(char side, char trans, int m, int n, int ilo, int ihi, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmlq(char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmql(char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmqr(char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmrq(char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmrz(char side, char trans, int m, int n, int k, int l, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmtr(char side, char uplo, char trans, int m, int n, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cupgtr(char uplo, int n, complex *ap, complex *tau, complex *q, int ldq, int *info);
extern void cupmtr(char side, char uplo, char trans, int m, int n, complex *ap, complex *tau, complex *c, int ldc, int *info);
extern void dbdsdc(char uplo, char compq, int n, double *d, double *e, double *u, int ldu, double *vt, int ldvt, double *q, int *iq, int *info);
extern void dbdsqr(char uplo, int n, int ncvt, int nru, int ncc, double *d, double *e, double *vt, int ldvt, double *u, int ldu, double *c, int ldc, int *info);
extern void ddisna(char job, int m, int n, double *d, double *sep, int *info);
extern void dgbbrd(char vect, int m, int n, int ncc, int kl, int ku, double *ab, int ldab, double *d, double *e, double *q, int ldq, double *pt, int ldpt, double *c, int ldc, int *info);
extern void dgbcon(char norm, int n, int nsub, int nsuper, double *a, int lda, int *ipiv, double anorm, double *rcond, int *info);
extern void dgbequ(int m, int n, int nsub, int nsuper, double *a, int lda, double *rowsc, double *colsc, double *rowcn, double *colcn, double *amax, int *info);
extern void dgbrfs(char transa, int n, int nsub, int nsuper, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dgbsv(int n, int nsub, int nsuper, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, int *info);

/* N.B. In this C interface to dgbsvx, rpvgrw returns what is returned in
   the first element of WORK by the FORTRAN interface */
extern void dgbsvx(char fact, char transa, int n, int nsub, int nsuper, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, char equed, double *rowsc, double *colsc, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *rpvgrw, int *info);

extern void dgbtrf(int m, int n, int nsub, int nsuper, double *a, int lda, int *ipiv, int *info);
extern void dgbtrs(char transa, int n, int nsub, int nsuper, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, int *info);
extern void dgebak(char job, char side, int n, int ilo, int ihi, double *scale, int m, double *v, int ldv, int *info);
extern void dgebal(char job, int n, double *a, int lda, int *ilo, int *ihi, double *scale, int *info);
extern void dgebrd(int m, int n, double *a, int lda, double *d, double *e, double *tauq, double *taup, int *info);
extern void dgecon(char norm, int n, double *a, int lda, double anorm, double *rcond, int *info);
extern void dgeequ(int m, int n, double *a, int lda, double *rowsc, double *colsc, double *rowcn, double *colcn, double *amax, int *info);
extern void dgees(char jobz, char sortev, ACML_DGEES_SELECT select, int n, double *a, int lda, int *nout, double *wr, double *wi, double *z, int ldz, int *info);
extern void dgeesx(char jobz, char sortev, ACML_DGEESX_SELECT select, char sense, int n, double *a, int lda, int *nout, double *wr, double *wi, double *z, int ldz, double *srcone, double *rconv, int *info);
extern void dgeev(char jobvl, char jobvr, int…