/src/controllers/src/lapack.h

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

/*
 * @(#)lapack.h    generated by: makeheader 5.1.5  Tue Aug  3 17:36:45 2010
 *
 *		built from:	../include/copyright.h
 *				//mathworks/hub/3rdparty/R2010b/184443/glnx86/LAPACK/include/lapack.h
 */

#if defined(_MSC_VER)
# pragma once
#endif
#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3))
# pragma once
#endif

#ifndef lapack_h
#define lapack_h


/*
 * Copyright 1984-2003 The MathWorks, Inc.
 * All Rights Reserved.
 */



/*
 *  Header File include/lapack.h
 *  Auto generated by f2h.pl, do not modify by hand
 */

#if defined(_WIN32) || defined(__hpux)
#define FORTRAN_WRAPPER(x) x
#else
#define FORTRAN_WRAPPER(x) x ## _
#endif

#ifndef COMPLEX_TYPES
#define COMPLEX_TYPES
  typedef struct{float r,i;} complex;
  typedef struct{double r,i;} doublecomplex;
#endif

#ifdef __cplusplus
    extern "C" {
#endif


/* Source: dlamch.f */
#define dlamch FORTRAN_WRAPPER(dlamch)
extern double dlamch(
    char   *cmach
);

/* Source: dlamch.f */
#define dlamc1 FORTRAN_WRAPPER(dlamc1)
extern void dlamc1(
    ptrdiff_t *beta,
    ptrdiff_t *t,
    ptrdiff_t *rnd,
    ptrdiff_t *ieee1
);

/* Source: dlamch.f */
#define dlamc2 FORTRAN_WRAPPER(dlamc2)
extern void dlamc2(
    ptrdiff_t *beta,
    ptrdiff_t *t,
    ptrdiff_t *rnd,
    double *eps,
    ptrdiff_t *emin,
    double *rmin,
    ptrdiff_t *emax,
    double *rmax
);

/* Source: dlamch.f */
#define dlamc3 FORTRAN_WRAPPER(dlamc3)
extern double dlamc3(
    double *a,
    double *b
);

/* Source: dlamch.f */
#define dlamc4 FORTRAN_WRAPPER(dlamc4)
extern void dlamc4(
    ptrdiff_t *emin,
    double *start,
    ptrdiff_t *base
);

/* Source: dlamch.f */
#define dlamc5 FORTRAN_WRAPPER(dlamc5)
extern void dlamc5(
    ptrdiff_t *beta,
    ptrdiff_t *p,
    ptrdiff_t *emin,
    ptrdiff_t *ieee,
    ptrdiff_t *emax,
    double *rmax
);

/* Source: slamch.f */
#define slamch FORTRAN_WRAPPER(slamch)
#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double slamch(
#else
extern float slamch(
#endif 
    char   *cmach
);

/* Source: slamch.f */
#define slamc1 FORTRAN_WRAPPER(slamc1)
extern void slamc1(
    ptrdiff_t *beta,
    ptrdiff_t *t,
    ptrdiff_t *rnd,
    ptrdiff_t *ieee1
);

/* Source: slamch.f */
#define slamc2 FORTRAN_WRAPPER(slamc2)
extern void slamc2(
    ptrdiff_t *beta,
    ptrdiff_t *t,
    ptrdiff_t *rnd,
    float  *eps,
    ptrdiff_t *emin,
    float  *rmin,
    ptrdiff_t *emax,
    float  *rmax
);

/* Source: slamch.f */
#define slamc3 FORTRAN_WRAPPER(slamc3)
#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double slamc3(
#else
extern float slamc3(
#endif 
    float  *a,
    float  *b
);

/* Source: slamch.f */
#define slamc4 FORTRAN_WRAPPER(slamc4)
extern void slamc4(
    ptrdiff_t *emin,
    float  *start,
    ptrdiff_t *base
);

/* Source: slamch.f */
#define slamc5 FORTRAN_WRAPPER(slamc5)
extern void slamc5(
    ptrdiff_t *beta,
    ptrdiff_t *p,
    ptrdiff_t *emin,
    ptrdiff_t *ieee,
    ptrdiff_t *emax,
    float  *rmax
);

/* Source: cbdsqr.f */
#define cbdsqr FORTRAN_WRAPPER(cbdsqr)
extern void cbdsqr(
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *ncvt,
    ptrdiff_t *nru,
    ptrdiff_t *ncc,
    float  *d,
    float  *e,
    float  *vt,
    ptrdiff_t *ldvt,
    float  *u,
    ptrdiff_t *ldu,
    float  *c,
    ptrdiff_t *ldc,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgbbrd.f */
#define cgbbrd FORTRAN_WRAPPER(cgbbrd)
extern void cgbbrd(
    char   *vect,
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *ncc,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    float  *ab,
    ptrdiff_t *ldab,
    float  *d,
    float  *e,
    float  *q,
    ptrdiff_t *ldq,
    float  *pt,
    ptrdiff_t *ldpt,
    float  *c,
    ptrdiff_t *ldc,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgbcon.f */
#define cgbcon FORTRAN_WRAPPER(cgbcon)
extern void cgbcon(
    char   *norm,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    float  *ab,
    ptrdiff_t *ldab,
    ptrdiff_t *ipiv,
    float  *anorm,
    float  *rcond,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgbequ.f */
#define cgbequ FORTRAN_WRAPPER(cgbequ)
extern void cgbequ(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    float  *ab,
    ptrdiff_t *ldab,
    float  *r,
    float  *c,
    float  *rowcnd,
    float  *colcnd,
    float  *amax,
    ptrdiff_t *info
);

/* Source: cgbequb.f */
#define cgbequb FORTRAN_WRAPPER(cgbequb)
extern void cgbequb(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    float  *ab,
    ptrdiff_t *ldab,
    float  *r,
    float  *c,
    float  *rowcnd,
    float  *colcnd,
    float  *amax,
    ptrdiff_t *info
);

/* Source: cgbrfs.f */
#define cgbrfs FORTRAN_WRAPPER(cgbrfs)
extern void cgbrfs(
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    ptrdiff_t *nrhs,
    float  *ab,
    ptrdiff_t *ldab,
    float  *afb,
    ptrdiff_t *ldafb,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgbsv.f */
#define cgbsv FORTRAN_WRAPPER(cgbsv)
extern void cgbsv(
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    ptrdiff_t *nrhs,
    float  *ab,
    ptrdiff_t *ldab,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: cgbsvx.f */
#define cgbsvx FORTRAN_WRAPPER(cgbsvx)
extern void cgbsvx(
    char   *fact,
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    ptrdiff_t *nrhs,
    float  *ab,
    ptrdiff_t *ldab,
    float  *afb,
    ptrdiff_t *ldafb,
    ptrdiff_t *ipiv,
    char   *equed,
    float  *r,
    float  *c,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *rcond,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgbtf2.f */
#define cgbtf2 FORTRAN_WRAPPER(cgbtf2)
extern void cgbtf2(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    float  *ab,
    ptrdiff_t *ldab,
    ptrdiff_t *ipiv,
    ptrdiff_t *info
);

/* Source: cgbtrf.f */
#define cgbtrf FORTRAN_WRAPPER(cgbtrf)
extern void cgbtrf(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    float  *ab,
    ptrdiff_t *ldab,
    ptrdiff_t *ipiv,
    ptrdiff_t *info
);

/* Source: cgbtrs.f */
#define cgbtrs FORTRAN_WRAPPER(cgbtrs)
extern void cgbtrs(
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    ptrdiff_t *nrhs,
    float  *ab,
    ptrdiff_t *ldab,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: cgebak.f */
#define cgebak FORTRAN_WRAPPER(cgebak)
extern void cgebak(
    char   *job,
    char   *side,
    ptrdiff_t *n,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *scale,
    ptrdiff_t *m,
    float  *v,
    ptrdiff_t *ldv,
    ptrdiff_t *info
);

/* Source: cgebal.f */
#define cgebal FORTRAN_WRAPPER(cgebal)
extern void cgebal(
    char   *job,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *scale,
    ptrdiff_t *info
);

/* Source: cgebd2.f */
#define cgebd2 FORTRAN_WRAPPER(cgebd2)
extern void cgebd2(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *d,
    float  *e,
    float  *tauq,
    float  *taup,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgebrd.f */
#define cgebrd FORTRAN_WRAPPER(cgebrd)
extern void cgebrd(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *d,
    float  *e,
    float  *tauq,
    float  *taup,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgecon.f */
#define cgecon FORTRAN_WRAPPER(cgecon)
extern void cgecon(
    char   *norm,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *anorm,
    float  *rcond,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgeequ.f */
#define cgeequ FORTRAN_WRAPPER(cgeequ)
extern void cgeequ(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *r,
    float  *c,
    float  *rowcnd,
    float  *colcnd,
    float  *amax,
    ptrdiff_t *info
);

/* Source: cgeequb.f */
#define cgeequb FORTRAN_WRAPPER(cgeequb)
extern void cgeequb(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *r,
    float  *c,
    float  *rowcnd,
    float  *colcnd,
    float  *amax,
    ptrdiff_t *info
);

/* Source: cgees.f */
#define cgees FORTRAN_WRAPPER(cgees)
extern void cgees(
    char   *jobvs,
    char   *sort,
    ptrdiff_t (*select)(),
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *sdim,
    float  *w,
    float  *vs,
    ptrdiff_t *ldvs,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *bwork,
    ptrdiff_t *info
);

/* Source: cgeesx.f */
#define cgeesx FORTRAN_WRAPPER(cgeesx)
extern void cgeesx(
    char   *jobvs,
    char   *sort,
    ptrdiff_t (*select)(),
    char   *sense,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *sdim,
    float  *w,
    float  *vs,
    ptrdiff_t *ldvs,
    float  *rconde,
    float  *rcondv,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *bwork,
    ptrdiff_t *info
);

/* Source: cgeev.f */
#define cgeev FORTRAN_WRAPPER(cgeev)
extern void cgeev(
    char   *jobvl,
    char   *jobvr,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *w,
    float  *vl,
    ptrdiff_t *ldvl,
    float  *vr,
    ptrdiff_t *ldvr,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgeevx.f */
#define cgeevx FORTRAN_WRAPPER(cgeevx)
extern void cgeevx(
    char   *balanc,
    char   *jobvl,
    char   *jobvr,
    char   *sense,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *w,
    float  *vl,
    ptrdiff_t *ldvl,
    float  *vr,
    ptrdiff_t *ldvr,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *scale,
    float  *abnrm,
    float  *rconde,
    float  *rcondv,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgegs.f */
#define cgegs FORTRAN_WRAPPER(cgegs)
extern void cgegs(
    char   *jobvsl,
    char   *jobvsr,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *alpha,
    float  *beta,
    float  *vsl,
    ptrdiff_t *ldvsl,
    float  *vsr,
    ptrdiff_t *ldvsr,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgegv.f */
#define cgegv FORTRAN_WRAPPER(cgegv)
extern void cgegv(
    char   *jobvl,
    char   *jobvr,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *alpha,
    float  *beta,
    float  *vl,
    ptrdiff_t *ldvl,
    float  *vr,
    ptrdiff_t *ldvr,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgehd2.f */
#define cgehd2 FORTRAN_WRAPPER(cgehd2)
extern void cgehd2(
    ptrdiff_t *n,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgehrd.f */
#define cgehrd FORTRAN_WRAPPER(cgehrd)
extern void cgehrd(
    ptrdiff_t *n,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgelq2.f */
#define cgelq2 FORTRAN_WRAPPER(cgelq2)
extern void cgelq2(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgelqf.f */
#define cgelqf FORTRAN_WRAPPER(cgelqf)
extern void cgelqf(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgels.f */
#define cgels FORTRAN_WRAPPER(cgels)
extern void cgels(
    char   *trans,
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgelsd.f */
#define cgelsd FORTRAN_WRAPPER(cgelsd)
extern void cgelsd(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *s,
    float  *rcond,
    ptrdiff_t *rank,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *info
);

/* Source: cgelss.f */
#define cgelss FORTRAN_WRAPPER(cgelss)
extern void cgelss(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *s,
    float  *rcond,
    ptrdiff_t *rank,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgelsx.f */
#define cgelsx FORTRAN_WRAPPER(cgelsx)
extern void cgelsx(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *jpvt,
    float  *rcond,
    ptrdiff_t *rank,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgelsy.f */
#define cgelsy FORTRAN_WRAPPER(cgelsy)
extern void cgelsy(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *jpvt,
    float  *rcond,
    ptrdiff_t *rank,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgeql2.f */
#define cgeql2 FORTRAN_WRAPPER(cgeql2)
extern void cgeql2(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgeqlf.f */
#define cgeqlf FORTRAN_WRAPPER(cgeqlf)
extern void cgeqlf(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgeqp3.f */
#define cgeqp3 FORTRAN_WRAPPER(cgeqp3)
extern void cgeqp3(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *jpvt,
    float  *tau,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgeqpf.f */
#define cgeqpf FORTRAN_WRAPPER(cgeqpf)
extern void cgeqpf(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *jpvt,
    float  *tau,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgeqr2.f */
#define cgeqr2 FORTRAN_WRAPPER(cgeqr2)
extern void cgeqr2(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgeqrf.f */
#define cgeqrf FORTRAN_WRAPPER(cgeqrf)
extern void cgeqrf(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgerfs.f */
#define cgerfs FORTRAN_WRAPPER(cgerfs)
extern void cgerfs(
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *af,
    ptrdiff_t *ldaf,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgerq2.f */
#define cgerq2 FORTRAN_WRAPPER(cgerq2)
extern void cgerq2(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgerqf.f */
#define cgerqf FORTRAN_WRAPPER(cgerqf)
extern void cgerqf(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgesc2.f */
#define cgesc2 FORTRAN_WRAPPER(cgesc2)
extern void cgesc2(
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *rhs,
    ptrdiff_t *ipiv,
    ptrdiff_t *jpiv,
    float  *scale
);

/* Source: cgesdd.f */
#define cgesdd FORTRAN_WRAPPER(cgesdd)
extern void cgesdd(
    char   *jobz,
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *s,
    float  *u,
    ptrdiff_t *ldu,
    float  *vt,
    ptrdiff_t *ldvt,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *info
);

/* Source: cgesv.f */
#define cgesv FORTRAN_WRAPPER(cgesv)
extern void cgesv(
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: cgesvd.f */
#define cgesvd FORTRAN_WRAPPER(cgesvd)
extern void cgesvd(
    char   *jobu,
    char   *jobvt,
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *s,
    float  *u,
    ptrdiff_t *ldu,
    float  *vt,
    ptrdiff_t *ldvt,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgesvx.f */
#define cgesvx FORTRAN_WRAPPER(cgesvx)
extern void cgesvx(
    char   *fact,
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *af,
    ptrdiff_t *ldaf,
    ptrdiff_t *ipiv,
    char   *equed,
    float  *r,
    float  *c,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *rcond,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgetc2.f */
#define cgetc2 FORTRAN_WRAPPER(cgetc2)
extern void cgetc2(
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    ptrdiff_t *jpiv,
    ptrdiff_t *info
);

/* Source: cgetf2.f */
#define cgetf2 FORTRAN_WRAPPER(cgetf2)
extern void cgetf2(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    ptrdiff_t *info
);

/* Source: cgetrf.f */
#define cgetrf FORTRAN_WRAPPER(cgetrf)
extern void cgetrf(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    ptrdiff_t *info
);

/* Source: cgetri.f */
#define cgetri FORTRAN_WRAPPER(cgetri)
extern void cgetri(
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgetrs.f */
#define cgetrs FORTRAN_WRAPPER(cgetrs)
extern void cgetrs(
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: cggbak.f */
#define cggbak FORTRAN_WRAPPER(cggbak)
extern void cggbak(
    char   *job,
    char   *side,
    ptrdiff_t *n,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *lscale,
    float  *rscale,
    ptrdiff_t *m,
    float  *v,
    ptrdiff_t *ldv,
    ptrdiff_t *info
);

/* Source: cggbal.f */
#define cggbal FORTRAN_WRAPPER(cggbal)
extern void cggbal(
    char   *job,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *lscale,
    float  *rscale,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgges.f */
#define cgges FORTRAN_WRAPPER(cgges)
extern void cgges(
    char   *jobvsl,
    char   *jobvsr,
    char   *sort,
    ptrdiff_t (*selctg)(),
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *sdim,
    float  *alpha,
    float  *beta,
    float  *vsl,
    ptrdiff_t *ldvsl,
    float  *vsr,
    ptrdiff_t *ldvsr,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *bwork,
    ptrdiff_t *info
);

/* Source: cggesx.f */
#define cggesx FORTRAN_WRAPPER(cggesx)
extern void cggesx(
    char   *jobvsl,
    char   *jobvsr,
    char   *sort,
    ptrdiff_t (*selctg)(),
    char   *sense,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *sdim,
    float  *alpha,
    float  *beta,
    float  *vsl,
    ptrdiff_t *ldvsl,
    float  *vsr,
    ptrdiff_t *ldvsr,
    float  *rconde,
    float  *rcondv,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *liwork,
    ptrdiff_t *bwork,
    ptrdiff_t *info
);

/* Source: cggev.f */
#define cggev FORTRAN_WRAPPER(cggev)
extern void cggev(
    char   *jobvl,
    char   *jobvr,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *alpha,
    float  *beta,
    float  *vl,
    ptrdiff_t *ldvl,
    float  *vr,
    ptrdiff_t *ldvr,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cggevx.f */
#define cggevx FORTRAN_WRAPPER(cggevx)
extern void cggevx(
    char   *balanc,
    char   *jobvl,
    char   *jobvr,
    char   *sense,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *alpha,
    float  *beta,
    float  *vl,
    ptrdiff_t *ldvl,
    float  *vr,
    ptrdiff_t *ldvr,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *lscale,
    float  *rscale,
    float  *abnrm,
    float  *bbnrm,
    float  *rconde,
    float  *rcondv,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *bwork,
    ptrdiff_t *info
);

/* Source: cggglm.f */
#define cggglm FORTRAN_WRAPPER(cggglm)
extern void cggglm(
    ptrdiff_t *n,
    ptrdiff_t *m,
    ptrdiff_t *p,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *d,
    float  *x,
    float  *y,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cgghrd.f */
#define cgghrd FORTRAN_WRAPPER(cgghrd)
extern void cgghrd(
    char   *compq,
    char   *compz,
    ptrdiff_t *n,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *q,
    ptrdiff_t *ldq,
    float  *z,
    ptrdiff_t *ldz,
    ptrdiff_t *info
);

/* Source: cgglse.f */
#define cgglse FORTRAN_WRAPPER(cgglse)
extern void cgglse(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *p,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *c,
    float  *d,
    float  *x,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cggqrf.f */
#define cggqrf FORTRAN_WRAPPER(cggqrf)
extern void cggqrf(
    ptrdiff_t *n,
    ptrdiff_t *m,
    ptrdiff_t *p,
    float  *a,
    ptrdiff_t *lda,
    float  *taua,
    float  *b,
    ptrdiff_t *ldb,
    float  *taub,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cggrqf.f */
#define cggrqf FORTRAN_WRAPPER(cggrqf)
extern void cggrqf(
    ptrdiff_t *m,
    ptrdiff_t *p,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *taua,
    float  *b,
    ptrdiff_t *ldb,
    float  *taub,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: cggsvd.f */
#define cggsvd FORTRAN_WRAPPER(cggsvd)
extern void cggsvd(
    char   *jobu,
    char   *jobv,
    char   *jobq,
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *p,
    ptrdiff_t *k,
    ptrdiff_t *l,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *alpha,
    float  *beta,
    float  *u,
    ptrdiff_t *ldu,
    float  *v,
    ptrdiff_t *ldv,
    float  *q,
    ptrdiff_t *ldq,
    float  *work,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *info
);

/* Source: cggsvp.f */
#define cggsvp FORTRAN_WRAPPER(cggsvp)
extern void cggsvp(
    char   *jobu,
    char   *jobv,
    char   *jobq,
    ptrdiff_t *m,
    ptrdiff_t *p,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *tola,
    float  *tolb,
    ptrdiff_t *k,
    ptrdiff_t *l,
    float  *u,
    ptrdiff_t *ldu,
    float  *v,
    ptrdiff_t *ldv,
    float  *q,
    ptrdiff_t *ldq,
    ptrdiff_t *iwork,
    float  *rwork,
    float  *tau,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgtcon.f */
#define cgtcon FORTRAN_WRAPPER(cgtcon)
extern void cgtcon(
    char   *norm,
    ptrdiff_t *n,
    float  *dl,
    float  *d,
    float  *du,
    float  *du2,
    ptrdiff_t *ipiv,
    float  *anorm,
    float  *rcond,
    float  *work,
    ptrdiff_t *info
);

/* Source: cgtrfs.f */
#define cgtrfs FORTRAN_WRAPPER(cgtrfs)
extern void cgtrfs(
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *dl,
    float  *d,
    float  *du,
    float  *dlf,
    float  *df,
    float  *duf,
    float  *du2,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgtsv.f */
#define cgtsv FORTRAN_WRAPPER(cgtsv)
extern void cgtsv(
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *dl,
    float  *d,
    float  *du,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: cgtsvx.f */
#define cgtsvx FORTRAN_WRAPPER(cgtsvx)
extern void cgtsvx(
    char   *fact,
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *dl,
    float  *d,
    float  *du,
    float  *dlf,
    float  *df,
    float  *duf,
    float  *du2,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *rcond,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cgttrf.f */
#define cgttrf FORTRAN_WRAPPER(cgttrf)
extern void cgttrf(
    ptrdiff_t *n,
    float  *dl,
    float  *d,
    float  *du,
    float  *du2,
    ptrdiff_t *ipiv,
    ptrdiff_t *info
);

/* Source: cgttrs.f */
#define cgttrs FORTRAN_WRAPPER(cgttrs)
extern void cgttrs(
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *dl,
    float  *d,
    float  *du,
    float  *du2,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: cgtts2.f */
#define cgtts2 FORTRAN_WRAPPER(cgtts2)
extern void cgtts2(
    ptrdiff_t *itrans,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *dl,
    float  *d,
    float  *du,
    float  *du2,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb
);

/* Source: chbev.f */
#define chbev FORTRAN_WRAPPER(chbev)
extern void chbev(
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *kd,
    float  *ab,
    ptrdiff_t *ldab,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chbevd.f */
#define chbevd FORTRAN_WRAPPER(chbevd)
extern void chbevd(
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *kd,
    float  *ab,
    ptrdiff_t *ldab,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *lrwork,
    ptrdiff_t *iwork,
    ptrdiff_t *liwork,
    ptrdiff_t *info
);

/* Source: chbevx.f */
#define chbevx FORTRAN_WRAPPER(chbevx)
extern void chbevx(
    char   *jobz,
    char   *range,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *kd,
    float  *ab,
    ptrdiff_t *ldab,
    float  *q,
    ptrdiff_t *ldq,
    float  *vl,
    float  *vu,
    ptrdiff_t *il,
    ptrdiff_t *iu,
    float  *abstol,
    ptrdiff_t *m,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *ifail,
    ptrdiff_t *info
);

/* Source: chbgst.f */
#define chbgst FORTRAN_WRAPPER(chbgst)
extern void chbgst(
    char   *vect,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *ka,
    ptrdiff_t *kb,
    float  *ab,
    ptrdiff_t *ldab,
    float  *bb,
    ptrdiff_t *ldbb,
    float  *x,
    ptrdiff_t *ldx,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chbgv.f */
#define chbgv FORTRAN_WRAPPER(chbgv)
extern void chbgv(
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *ka,
    ptrdiff_t *kb,
    float  *ab,
    ptrdiff_t *ldab,
    float  *bb,
    ptrdiff_t *ldbb,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chbgvd.f */
#define chbgvd FORTRAN_WRAPPER(chbgvd)
extern void chbgvd(
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *ka,
    ptrdiff_t *kb,
    float  *ab,
    ptrdiff_t *ldab,
    float  *bb,
    ptrdiff_t *ldbb,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *lrwork,
    ptrdiff_t *iwork,
    ptrdiff_t *liwork,
    ptrdiff_t *info
);

/* Source: chbgvx.f */
#define chbgvx FORTRAN_WRAPPER(chbgvx)
extern void chbgvx(
    char   *jobz,
    char   *range,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *ka,
    ptrdiff_t *kb,
    float  *ab,
    ptrdiff_t *ldab,
    float  *bb,
    ptrdiff_t *ldbb,
    float  *q,
    ptrdiff_t *ldq,
    float  *vl,
    float  *vu,
    ptrdiff_t *il,
    ptrdiff_t *iu,
    float  *abstol,
    ptrdiff_t *m,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *ifail,
    ptrdiff_t *info
);

/* Source: chbtrd.f */
#define chbtrd FORTRAN_WRAPPER(chbtrd)
extern void chbtrd(
    char   *vect,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *kd,
    float  *ab,
    ptrdiff_t *ldab,
    float  *d,
    float  *e,
    float  *q,
    ptrdiff_t *ldq,
    float  *work,
    ptrdiff_t *info
);

/* Source: checon.f */
#define checon FORTRAN_WRAPPER(checon)
extern void checon(
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *anorm,
    float  *rcond,
    float  *work,
    ptrdiff_t *info
);

/* Source: cheequb.f */
#define cheequb FORTRAN_WRAPPER(cheequb)
extern void cheequb(
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *s,
    float  *scond,
    float  *amax,
    float  *work,
    ptrdiff_t *info
);

/* Source: cheev.f */
#define cheev FORTRAN_WRAPPER(cheev)
extern void cheev(
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *w,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: cheevd.f */
#define cheevd FORTRAN_WRAPPER(cheevd)
extern void cheevd(
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *w,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *lrwork,
    ptrdiff_t *iwork,
    ptrdiff_t *liwork,
    ptrdiff_t *info
);

/* Source: cheevr.f */
#define cheevr FORTRAN_WRAPPER(cheevr)
extern void cheevr(
    char   *jobz,
    char   *range,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *vl,
    float  *vu,
    ptrdiff_t *il,
    ptrdiff_t *iu,
    float  *abstol,
    ptrdiff_t *m,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    ptrdiff_t *isuppz,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *lrwork,
    ptrdiff_t *iwork,
    ptrdiff_t *liwork,
    ptrdiff_t *info
);

/* Source: cheevx.f */
#define cheevx FORTRAN_WRAPPER(cheevx)
extern void cheevx(
    char   *jobz,
    char   *range,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *vl,
    float  *vu,
    ptrdiff_t *il,
    ptrdiff_t *iu,
    float  *abstol,
    ptrdiff_t *m,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *ifail,
    ptrdiff_t *info
);

/* Source: chegs2.f */
#define chegs2 FORTRAN_WRAPPER(chegs2)
extern void chegs2(
    ptrdiff_t *itype,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: chegst.f */
#define chegst FORTRAN_WRAPPER(chegst)
extern void chegst(
    ptrdiff_t *itype,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: chegv.f */
#define chegv FORTRAN_WRAPPER(chegv)
extern void chegv(
    ptrdiff_t *itype,
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *w,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chegvd.f */
#define chegvd FORTRAN_WRAPPER(chegvd)
extern void chegvd(
    ptrdiff_t *itype,
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *w,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *lrwork,
    ptrdiff_t *iwork,
    ptrdiff_t *liwork,
    ptrdiff_t *info
);

/* Source: chegvx.f */
#define chegvx FORTRAN_WRAPPER(chegvx)
extern void chegvx(
    ptrdiff_t *itype,
    char   *jobz,
    char   *range,
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *vl,
    float  *vu,
    ptrdiff_t *il,
    ptrdiff_t *iu,
    float  *abstol,
    ptrdiff_t *m,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *ifail,
    ptrdiff_t *info
);

/* Source: cherfs.f */
#define cherfs FORTRAN_WRAPPER(cherfs)
extern void cherfs(
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *af,
    ptrdiff_t *ldaf,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chesv.f */
#define chesv FORTRAN_WRAPPER(chesv)
extern void chesv(
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: chesvx.f */
#define chesvx FORTRAN_WRAPPER(chesvx)
extern void chesvx(
    char   *fact,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    float  *af,
    ptrdiff_t *ldaf,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *rcond,
    float  *ferr,
    float  *berr,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chetd2.f */
#define chetd2 FORTRAN_WRAPPER(chetd2)
extern void chetd2(
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *d,
    float  *e,
    float  *tau,
    ptrdiff_t *info
);

/* Source: chetf2.f */
#define chetf2 FORTRAN_WRAPPER(chetf2)
extern void chetf2(
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    ptrdiff_t *info
);

/* Source: chetrd.f */
#define chetrd FORTRAN_WRAPPER(chetrd)
extern void chetrd(
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *d,
    float  *e,
    float  *tau,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: chetrf.f */
#define chetrf FORTRAN_WRAPPER(chetrf)
extern void chetrf(
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: chetri.f */
#define chetri FORTRAN_WRAPPER(chetri)
extern void chetri(
    char   *uplo,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *work,
    ptrdiff_t *info
);

/* Source: chetrs.f */
#define chetrs FORTRAN_WRAPPER(chetrs)
extern void chetrs(
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: chfrk.f */
#define chfrk FORTRAN_WRAPPER(chfrk)
extern void chfrk(
    char   *transr,
    char   *uplo,
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *k,
    float  *alpha,
    float  *a,
    ptrdiff_t *lda,
    float  *beta,
    float  *c
);

/* Source: chgeqz.f */
#define chgeqz FORTRAN_WRAPPER(chgeqz)
extern void chgeqz(
    char   *job,
    char   *compq,
    char   *compz,
    ptrdiff_t *n,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *h,
    ptrdiff_t *ldh,
    float  *t,
    ptrdiff_t *ldt,
    float  *alpha,
    float  *beta,
    float  *q,
    ptrdiff_t *ldq,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chla_transtype.f */
#define chla_transtype FORTRAN_WRAPPER(chla_transtype)
extern char chla_transtype(
    ptrdiff_t *trans
);

/* Source: chpcon.f */
#define chpcon FORTRAN_WRAPPER(chpcon)
extern void chpcon(
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    ptrdiff_t *ipiv,
    float  *anorm,
    float  *rcond,
    float  *work,
    ptrdiff_t *info
);

/* Source: chpev.f */
#define chpev FORTRAN_WRAPPER(chpev)
extern void chpev(
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chpevd.f */
#define chpevd FORTRAN_WRAPPER(chpevd)
extern void chpevd(
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *lrwork,
    ptrdiff_t *iwork,
    ptrdiff_t *liwork,
    ptrdiff_t *info
);

/* Source: chpevx.f */
#define chpevx FORTRAN_WRAPPER(chpevx)
extern void chpevx(
    char   *jobz,
    char   *range,
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    float  *vl,
    float  *vu,
    ptrdiff_t *il,
    ptrdiff_t *iu,
    float  *abstol,
    ptrdiff_t *m,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *ifail,
    ptrdiff_t *info
);

/* Source: chpgst.f */
#define chpgst FORTRAN_WRAPPER(chpgst)
extern void chpgst(
    ptrdiff_t *itype,
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    float  *bp,
    ptrdiff_t *info
);

/* Source: chpgv.f */
#define chpgv FORTRAN_WRAPPER(chpgv)
extern void chpgv(
    ptrdiff_t *itype,
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    float  *bp,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chpgvd.f */
#define chpgvd FORTRAN_WRAPPER(chpgvd)
extern void chpgvd(
    ptrdiff_t *itype,
    char   *jobz,
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    float  *bp,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    ptrdiff_t *lwork,
    float  *rwork,
    ptrdiff_t *lrwork,
    ptrdiff_t *iwork,
    ptrdiff_t *liwork,
    ptrdiff_t *info
);

/* Source: chpgvx.f */
#define chpgvx FORTRAN_WRAPPER(chpgvx)
extern void chpgvx(
    ptrdiff_t *itype,
    char   *jobz,
    char   *range,
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    float  *bp,
    float  *vl,
    float  *vu,
    ptrdiff_t *il,
    ptrdiff_t *iu,
    float  *abstol,
    ptrdiff_t *m,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *ifail,
    ptrdiff_t *info
);

/* Source: chprfs.f */
#define chprfs FORTRAN_WRAPPER(chprfs)
extern void chprfs(
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *ap,
    float  *afp,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chpsv.f */
#define chpsv FORTRAN_WRAPPER(chpsv)
extern void chpsv(
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *ap,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: chpsvx.f */
#define chpsvx FORTRAN_WRAPPER(chpsvx)
extern void chpsvx(
    char   *fact,
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *ap,
    float  *afp,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    float  *x,
    ptrdiff_t *ldx,
    float  *rcond,
    float  *ferr,
    float  *berr,
    float  *work,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: chptrd.f */
#define chptrd FORTRAN_WRAPPER(chptrd)
extern void chptrd(
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    float  *d,
    float  *e,
    float  *tau,
    ptrdiff_t *info
);

/* Source: chptrf.f */
#define chptrf FORTRAN_WRAPPER(chptrf)
extern void chptrf(
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    ptrdiff_t *ipiv,
    ptrdiff_t *info
);

/* Source: chptri.f */
#define chptri FORTRAN_WRAPPER(chptri)
extern void chptri(
    char   *uplo,
    ptrdiff_t *n,
    float  *ap,
    ptrdiff_t *ipiv,
    float  *work,
    ptrdiff_t *info
);

/* Source: chptrs.f */
#define chptrs FORTRAN_WRAPPER(chptrs)
extern void chptrs(
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *ap,
    ptrdiff_t *ipiv,
    float  *b,
    ptrdiff_t *ldb,
    ptrdiff_t *info
);

/* Source: chsein.f */
#define chsein FORTRAN_WRAPPER(chsein)
extern void chsein(
    char   *side,
    char   *eigsrc,
    char   *initv,
    ptrdiff_t *select,
    ptrdiff_t *n,
    float  *h,
    ptrdiff_t *ldh,
    float  *w,
    float  *vl,
    ptrdiff_t *ldvl,
    float  *vr,
    ptrdiff_t *ldvr,
    ptrdiff_t *mm,
    ptrdiff_t *m,
    float  *work,
    float  *rwork,
    ptrdiff_t *ifaill,
    ptrdiff_t *ifailr,
    ptrdiff_t *info
);

/* Source: chseqr.f */
#define chseqr FORTRAN_WRAPPER(chseqr)
extern void chseqr(
    char   *job,
    char   *compz,
    ptrdiff_t *n,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *h,
    ptrdiff_t *ldh,
    float  *w,
    float  *z,
    ptrdiff_t *ldz,
    float  *work,
    ptrdiff_t *lwork,
    ptrdiff_t *info
);

/* Source: clabrd.f */
#define clabrd FORTRAN_WRAPPER(clabrd)
extern void clabrd(
    ptrdiff_t *m,
    ptrdiff_t *n,
    ptrdiff_t *nb,
    float  *a,
    ptrdiff_t *lda,
    float  *d,
    float  *e,
    float  *tauq,
    float  *taup,
    float  *x,
    ptrdiff_t *ldx,
    float  *y,
    ptrdiff_t *ldy
);

/* Source: clacgv.f */
#define clacgv FORTRAN_WRAPPER(clacgv)
extern void clacgv(
    ptrdiff_t *n,
    float  *x,
    ptrdiff_t *incx
);

/* Source: clacn2.f */
#define clacn2 FORTRAN_WRAPPER(clacn2)
extern void clacn2(
    ptrdiff_t *n,
    float  *v,
    float  *x,
    float  *est,
    ptrdiff_t *kase,
    ptrdiff_t *isave
);

/* Source: clacon.f */
#define clacon FORTRAN_WRAPPER(clacon)
extern void clacon(
    ptrdiff_t *n,
    float  *v,
    float  *x,
    float  *est,
    ptrdiff_t *kase
);

/* Source: clacp2.f */
#define clacp2 FORTRAN_WRAPPER(clacp2)
extern void clacp2(
    char   *uplo,
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb
);

/* Source: clacpy.f */
#define clacpy FORTRAN_WRAPPER(clacpy)
extern void clacpy(
    char   *uplo,
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb
);

/* Source: clacrm.f */
#define clacrm FORTRAN_WRAPPER(clacrm)
extern void clacrm(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    float  *b,
    ptrdiff_t *ldb,
    float  *c,
    ptrdiff_t *ldc,
    float  *rwork
);

/* Source: clacrt.f */
#define clacrt FORTRAN_WRAPPER(clacrt)
extern void clacrt(
    ptrdiff_t *n,
    float  *cx,
    ptrdiff_t *incx,
    float  *cy,
    ptrdiff_t *incy,
    float  *c,
    float  *s
);

/* Source: cladiv.f */
#define cladiv FORTRAN_WRAPPER(cladiv)
#ifndef FORTRAN_COMPLEX_FUNCTIONS_RETURN_VOID
extern complex cladiv(
#else
extern void cladiv(
    complex* retval,
#endif 
    float  *x,
    float  *y
);

/* Source: claed0.f */
#define claed0 FORTRAN_WRAPPER(claed0)
extern void claed0(
    ptrdiff_t *qsiz,
    ptrdiff_t *n,
    float  *d,
    float  *e,
    float  *q,
    ptrdiff_t *ldq,
    float  *qstore,
    ptrdiff_t *ldqs,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *info
);

/* Source: claed7.f */
#define claed7 FORTRAN_WRAPPER(claed7)
extern void claed7(
    ptrdiff_t *n,
    ptrdiff_t *cutpnt,
    ptrdiff_t *qsiz,
    ptrdiff_t *tlvls,
    ptrdiff_t *curlvl,
    ptrdiff_t *curpbm,
    float  *d,
    float  *q,
    ptrdiff_t *ldq,
    float  *rho,
    ptrdiff_t *indxq,
    float  *qstore,
    ptrdiff_t *qptr,
    ptrdiff_t *prmptr,
    ptrdiff_t *perm,
    ptrdiff_t *givptr,
    ptrdiff_t *givcol,
    float  *givnum,
    float  *work,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *info
);

/* Source: claed8.f */
#define claed8 FORTRAN_WRAPPER(claed8)
extern void claed8(
    ptrdiff_t *k,
    ptrdiff_t *n,
    ptrdiff_t *qsiz,
    float  *q,
    ptrdiff_t *ldq,
    float  *d,
    float  *rho,
    ptrdiff_t *cutpnt,
    float  *z,
    float  *dlamda,
    float  *q2,
    ptrdiff_t *ldq2,
    float  *w,
    ptrdiff_t *indxp,
    ptrdiff_t *indx,
    ptrdiff_t *indxq,
    ptrdiff_t *perm,
    ptrdiff_t *givptr,
    ptrdiff_t *givcol,
    float  *givnum,
    ptrdiff_t *info
);

/* Source: claein.f */
#define claein FORTRAN_WRAPPER(claein)
extern void claein(
    ptrdiff_t *rightv,
    ptrdiff_t *noinit,
    ptrdiff_t *n,
    float  *h,
    ptrdiff_t *ldh,
    float  *w,
    float  *v,
    float  *b,
    ptrdiff_t *ldb,
    float  *rwork,
    float  *eps3,
    float  *smlnum,
    ptrdiff_t *info
);

/* Source: claesy.f */
#define claesy FORTRAN_WRAPPER(claesy)
extern void claesy(
    float  *a,
    float  *b,
    float  *c,
    float  *rt1,
    float  *rt2,
    float  *evscal,
    float  *cs1,
    float  *sn1
);

/* Source: claev2.f */
#define claev2 FORTRAN_WRAPPER(claev2)
extern void claev2(
    float  *a,
    float  *b,
    float  *c,
    float  *rt1,
    float  *rt2,
    float  *cs1,
    float  *sn1
);

/* Source: clag2z.f */
#define clag2z FORTRAN_WRAPPER(clag2z)
extern void clag2z(
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *sa,
    ptrdiff_t *ldsa,
    double *a,
    ptrdiff_t *lda,
    ptrdiff_t *info
);

/* Source: clags2.f */
#define clags2 FORTRAN_WRAPPER(clags2)
extern void clags2(
    ptrdiff_t *upper,
    float  *a1,
    float  *a2,
    float  *a3,
    float  *b1,
    float  *b2,
    float  *b3,
    float  *csu,
    float  *snu,
    float  *csv,
    float  *snv,
    float  *csq,
    float  *snq
);

/* Source: clagtm.f */
#define clagtm FORTRAN_WRAPPER(clagtm)
extern void clagtm(
    char   *trans,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *alpha,
    float  *dl,
    float  *d,
    float  *du,
    float  *x,
    ptrdiff_t *ldx,
    float  *beta,
    float  *b,
    ptrdiff_t *ldb
);

/* Source: clahef.f */
#define clahef FORTRAN_WRAPPER(clahef)
extern void clahef(
    char   *uplo,
    ptrdiff_t *n,
    ptrdiff_t *nb,
    ptrdiff_t *kb,
    float  *a,
    ptrdiff_t *lda,
    ptrdiff_t *ipiv,
    float  *w,
    ptrdiff_t *ldw,
    ptrdiff_t *info
);

/* Source: clahqr.f */
#define clahqr FORTRAN_WRAPPER(clahqr)
extern void clahqr(
    ptrdiff_t *wantt,
    ptrdiff_t *wantz,
    ptrdiff_t *n,
    ptrdiff_t *ilo,
    ptrdiff_t *ihi,
    float  *h,
    ptrdiff_t *ldh,
    float  *w,
    ptrdiff_t *iloz,
    ptrdiff_t *ihiz,
    float  *z,
    ptrdiff_t *ldz,
    ptrdiff_t *info
);

/* Source: clahr2.f */
#define clahr2 FORTRAN_WRAPPER(clahr2)
extern void clahr2(
    ptrdiff_t *n,
    ptrdiff_t *k,
    ptrdiff_t *nb,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *t,
    ptrdiff_t *ldt,
    float  *y,
    ptrdiff_t *ldy
);

/* Source: clahrd.f */
#define clahrd FORTRAN_WRAPPER(clahrd)
extern void clahrd(
    ptrdiff_t *n,
    ptrdiff_t *k,
    ptrdiff_t *nb,
    float  *a,
    ptrdiff_t *lda,
    float  *tau,
    float  *t,
    ptrdiff_t *ldt,
    float  *y,
    ptrdiff_t *ldy
);

/* Source: claic1.f */
#define claic1 FORTRAN_WRAPPER(claic1)
extern void claic1(
    ptrdiff_t *job,
    ptrdiff_t *j,
    float  *x,
    float  *sest,
    float  *w,
    float  *gamma_,
    float  *sestpr,
    float  *s,
    float  *c
);

/* Source: clals0.f */
#define clals0 FORTRAN_WRAPPER(clals0)
extern void clals0(
    ptrdiff_t *icompq,
    ptrdiff_t *nl,
    ptrdiff_t *nr,
    ptrdiff_t *sqre,
    ptrdiff_t *nrhs,
    float  *b,
    ptrdiff_t *ldb,
    float  *bx,
    ptrdiff_t *ldbx,
    ptrdiff_t *perm,
    ptrdiff_t *givptr,
    ptrdiff_t *givcol,
    ptrdiff_t *ldgcol,
    float  *givnum,
    ptrdiff_t *ldgnum,
    float  *poles,
    float  *difl,
    float  *difr,
    float  *z,
    ptrdiff_t *k,
    float  *c,
    float  *s,
    float  *rwork,
    ptrdiff_t *info
);

/* Source: clalsa.f */
#define clalsa FORTRAN_WRAPPER(clalsa)
extern void clalsa(
    ptrdiff_t *icompq,
    ptrdiff_t *smlsiz,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *b,
    ptrdiff_t *ldb,
    float  *bx,
    ptrdiff_t *ldbx,
    float  *u,
    ptrdiff_t *ldu,
    float  *vt,
    ptrdiff_t *k,
    float  *difl,
    float  *difr,
    float  *z,
    float  *poles,
    ptrdiff_t *givptr,
    ptrdiff_t *givcol,
    ptrdiff_t *ldgcol,
    ptrdiff_t *perm,
    float  *givnum,
    float  *c,
    float  *s,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *info
);

/* Source: clalsd.f */
#define clalsd FORTRAN_WRAPPER(clalsd)
extern void clalsd(
    char   *uplo,
    ptrdiff_t *smlsiz,
    ptrdiff_t *n,
    ptrdiff_t *nrhs,
    float  *d,
    float  *e,
    float  *b,
    ptrdiff_t *ldb,
    float  *rcond,
    ptrdiff_t *rank,
    float  *work,
    float  *rwork,
    ptrdiff_t *iwork,
    ptrdiff_t *info
);

/* Source: clangb.f */
#define clangb FORTRAN_WRAPPER(clangb)
#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double clangb(
#else
extern float clangb(
#endif 
    char   *norm,
    ptrdiff_t *n,
    ptrdiff_t *kl,
    ptrdiff_t *ku,
    float  *ab,
    ptrdiff_t *ldab,
    float  *work
);

/* Source: clange.f */
#define clange FORTRAN_WRAPPER(clange)
#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double clange(
#else
extern float clange(
#endif 
    char   *norm,
    ptrdiff_t *m,
    ptrdiff_t *n,
    float  *a,
    ptrdiff_t *lda,
    fl…