netlib.h

InsightToolkit-1.4.0(有大量的优化算法程序)

              const double* trigs, /*!< (IN) output of dsetgfpa_ (twiddle factors) */
              const int* inc, /*!< (IN) increment within each data vector (normally 1) */
              const int* jump, /*!< (IN) increment between data vectors */
              const int* n, /*!< (IN) length of the transforms; should only have 2,3,5 as prime factors */
              const int* lot, /*!< (IN) number of transforms */
              const int* isign, /*!< (IN) forward transform: +1; backward: -1 */
              const int* npqr, /*!< (IN) 3-array with the number of factors of 2,3,5 */
              int* info); /*!< (OUT) 0 if no problems */

  /*: Self-sorting in-place generalized prime factor (complex) float fft */
  void gpfa_(float* a, float* b, const float* trigs, const int* inc, const int* jump,
             const int* n, const int* lot, const int* isign, const int* nj, int* info);

  /*: Set-up routine for dgpfa_ */
  void dsetgpfa_(double* trigs, const int* n, int* ires, int* info);

  /*: Set-up routine for gpfa_ */
  void setgpfa_(float* trigs, const int* n, int* ires, int* info);

  void gpfa2f_(float *a, float *b, const float *trigs, const int *inc, const int *jump,
               const int *n, const int *mm, const int *lot, const int *isign);
  void gpfa3f_(float *a, float *b, const float *trigs, const int *inc, const int *jump,
               const int *n, const int *mm, const int *lot, const int *isign);
  void gpfa5f_(float *a, float *b, const float *trigs, const int *inc, const int *jump,
               const int *n, const int *mm, const int *lot, const int *isign);
  void dgpfa2f_(double *a, double *b, const double *trigs, const int *inc, const int *jump,
                const int *n, const int *mm, const int *lot, const int *isign);
  void dgpfa3f_(double *a, double *b, const double *trigs, const int *inc, const int *jump,
                const int *n, const int *mm, const int *lot, const int *isign);
  void dgpfa5f_(double *a, double *b, const double *trigs, const int *inc, const int *jump,
                const int *n, const int *mm, const int *lot, const int *isign);

  /*: Finds a few eigenvalues and eigenvectors at either end of the spectrum of a large sparse symmetric matrix.  */
  void dnlaso_(void (*op)(const int* n,const int* m, const double* p, double* q),
               void (*iovect)(const int* n,const int* m, double* q, const int* j, const int* k),
               const int* n, const int* nval, const int* nfig, int* nperm,
               const int* nmval, double* val,
               const int* nmvec, double* vec,
               const int* nblock, const int* maxop, const int* maxj, double* work, int* ind, int* ierr);
  void snlaso_(void (*op)(const int* n,const int* m, const float* p, float* q),
               void (*iovect)(const int* n,const int* m, float* q, const int* j, const int* k),
               const int* n, const int* nval, const int* nfig, int* nperm,
               const int* nmval, float* val,
               const int* nmvec, float* vec,
               const int* nblock, const int* maxop, const int* maxj, float* work, int* ind, int* ierr);

  /*: Factors a symmetric positive definite matrix and estimates the condition of the matrix */
  void dpoco_(double* a, int* lda, int* n, double* rcond, double* z, int* info);

  /*: Computes determinant and inverse of a certain symmetric positive definite matrix using dpoco_, dposa_ or dqrdc_ output */
  void dpodi_(double* a, const int* lda, const int* n, double* det, const int* job);

  /*: Factors a double precision symmetric positive definite matrix */
  void dpofa_(double* a, int* lda, int* n, int* info);

  /*: Solves the symmetric positive definite system a * x = b dpoco or dpofa output */
  void dposl_(const double* a, const int* lda, const int* n, double* b);

  /*: Solves the unconstrained minimization problem min F(x1..xN) */
  void lbfgs_(int* n, int* m, double* x, double* f, double* g,
              logical * diagco, double* diag, int* iprint,
              double* eps, double* xtol, double* w, int* iflag);

  /*: Minimizes the sum of the squares of m nonlin functions in n variables */
  void lmder1_(void (*fcn)(int*,int*,double*,double*,double*,int*,int*),
               int* m, int* n, double* x,
               double* fvec, double* fjac, int* ldfjac,
               double* tol, int* info, int* ipvt, double* wa, int* lwa);
  void lmder_(void (*fcn)(int*,int*,double*,double*,double*,int*,int*),
              int *m, int *n, double *x, double *fvec, double *fjac, int *ldfjac, double *ftol, double *xtol, double *gtol,
              int *maxfev, double *diag, int *mode, double *factor, int *nprint, int *info,
              int *nfev, int *njev, int *ipvt, double *qtf, double *wa1, double *wa2, double *wa3, double *wa4);

  /*: Minimizes the sum of the squares of m nonlin functions in n variables */
  void lmdif_(void (*fcn)(int*,int*,double*,double*,int*),
              int* m, int* n, double* x, double* fvec, double* ftol,
              double* xtol, double* gtol, int* maxfev, double* epsfcn, double* diag,
              int* mode, double* factor, int* nprint, int* info, int* nfev,
              double* fjac, int* ldfjac, int* ipvt, double* qtf,
              double* wa1, double* wa2, double* wa3, double* wa4, double* errors);

  /*: Solves  A*x = b */
  void lsqr_(int* m, int* n,
             void (*aprod)(int*,int*,int*,double*,double*,int*,int*,int*,double*),
             double* damp, int* leniw, int* lenrw,
             int* iw, double* rw, double* u, double* v, double* w, double* x, double* se,
             double* atol, double* btol, double* conlim, int* itnlim, int* nout, int* istop,
             int* itn, double* anorm, double* acond, double* rnorm, double* arnorm, double* xnorm);

  /*: Finds the zeros of a real polynomial */
  void rpoly_(double* op, int* degree, double* zeror, double* zeroi, logical* fail);

  void saxpy_(const int *n, const float *sa, const float *sx, const int *incx, float *sy, const int *incy);
  void daxpy_(const int *n, const double *da, const double *dx, const int *incx, double *dy, const int *incy);
  void caxpy_(const int *n, const cmplx *ca, const cmplx *cx, const int *incx, cmplx *cy, const int *incy);
  void zaxpy_(const int *n, const dcmplx *za, const dcmplx *zx, const int *incx, dcmplx *zy, const int *incy);

  void scopy_(const int *n, const float *sx, const int *incx, float *sy, const int *incy);
  void dcopy_(const int *n, const double *dx, const int *incx, double *dy, const int *incy);
  void ccopy_(const int *n, const cmplx *cx, const int *incx, cmplx *cy, const int *incy);
  void zcopy_(const int *n, const dcmplx *zx, const int *incx, dcmplx *zy, const int *incy);

 float sdot_(const int *n, const float *sx, const int *incx, const float *sy, const int *incy);
double ddot_(const int *n, const double *dx, const int *incx, const double *dy, const int *incy);
  void cdotc_(cmplx *ret_val, const int *n, const cmplx *cx, const int *incx, const cmplx *cy, const int *incy);
  void zdotc_(dcmplx *ret_val, const int *n, const dcmplx *zx, const int *incx, const dcmplx *zy, const int *incy);
  void zdotu_(dcmplx *ret_val, const int *n, const dcmplx *zx, const int *incx, const dcmplx *zy, const int *incy);

  void sscal_(const int *n, const float *sa, float *sx, const int *incx);
  void dscal_(const int *n, const double *da, double *dx, const int *incx);
  void cscal_(const int *n, const cmplx *ca, cmplx *cx, const int *incx);
  void zscal_(const int *n, const dcmplx *za, dcmplx *zx, const int *incx);
  void zdscal_(const int *n, const double *da, dcmplx *zx, const int *incx);

  void sswap_(const int *n, float *sx, const int *incx, float *sy, const int *incy);
  void dswap_(const int *n, double *dx, const int *incx, double *dy, const int *incy);
  void cswap_(const int *n, cmplx *cx, const int *incx, cmplx *cy, const int *incy);
  void zswap_(const int *n, dcmplx *zx, const int *incx, dcmplx *zy, const int *incy);

  void dgecon_(char *norm, int *n, double *a, int *lda, double *anorm, double *rcond, double *work, int *iwork, int *info);

  void dgemm_(const char *transa, const char *transb, const int *m, const int *n, const int *k, double *alpha,
              double *a, const int *lda, double *b, const int *ldb, double *beta, double *c, const int *ldc);
  void zgemm_(const char *transa, const char *transb, const int *m, const int *n, const int *k, dcmplx *alpha,
              dcmplx *a, const int *lda, dcmplx *b, const int *ldb, dcmplx *beta, dcmplx *c, const int *ldc);

  void sgemv_(const char *trans, const int *m, const int *n, float *alpha,
              float *a, const int *lda, float *x, const int *incx, float *beta, float *y, const int *incy);
  void dgemv_(const char *trans, const int *m, const int *n, double *alpha,
              double *a, const int *lda, double *x, const int *incx, double *beta, double *y, const int *incy);
  void zgemv_(const char *trans, const int *m, const int *n, dcmplx *alpha,
              dcmplx *a, const int *lda, dcmplx *x, const int *incx, dcmplx *beta, dcmplx *y, const int *incy);

  void sgeqpf_(int *m, int *n, float *a, int *lda, int *jpvt, float *tau, float *work, int *info);
  void dgeqpf_(int *m, int *n, double *a, int *lda, int *jpvt, double *tau, double *work, int *info);
  void sgeqr2_(int *m, int *n, float *a, int *lda, float *tau, float *work, int *info);
  void dgeqr2_(int *m, int *n, double *a, int *lda, double *tau, double *work, int *info);
  void dgeqrf_(int *m, int *n, double *a, int *lda, double *tau, double *work, int *lwork, int *info);

  void sger_(const int *m, const int *n, float *alpha, float *x, const int *incx, float *y, const int *incy,
             float *a, const int *lda);
  void dger_(const int *m, const int *n, double *alpha, double *x, const int *incx, double *y, const int *incy,
             double *a, const int *lda);
  void zgerc_(const int *m, const int *n, dcmplx *alpha, dcmplx *x, const int *incx, dcmplx *y, const int *incy,
              dcmplx *a, const int *lda);
  void sgerq2_(const int *m, const int *n, float *a, const int *lda, float *tau, float *work, int *info);
  void dgerq2_(const int *m, const int *n, double *a, const int *lda, double *tau, double *work, int *info);

  void dgesc2_(int *n, double *a, int *lda, double *rhs, int *ipiv, int *jpiv, double *scale);
  void dgetc2_(int *n, double *a, int *lda, int *ipiv, int *jpiv, int *info);

  void dggbak_(const char *job, const char *side, const int *n, int *ilo, int *ihi, double *lscale, double *rscale,
               const int *m, double *v, const int *ldv, int *info);
  void zgebak_(const char *job, const char *side, const int *n, int *ilo, int *ihi, double *scale,
               const int *m, dcmplx *v, const int *ldv, int *info);
  void dggbal_(const char *job, const int *n, double *a, const int *lda, double *b, const int *ldb, int *ilo, int *ihi,
               double *lscale, double *rscale, double *work, int *info);
  void zgebal_(const char *job, const int *n, dcmplx *a, const int *lda, int *ilo, int *ihi, double *scale, int *info);

  void dgges_(char *jobvsl, char *jobvsr, char *sort, logical (*delctg)(double*,double*,double*),
              int *n, double *a, int *lda, double *b, int *ldb, int *sdim, double *alphar, double *alphai, double *beta,
              double *vsl, int *ldvsl, double *vsr, int *ldvsr, double *work, int *lwork, logical *bwork, int *info);

  void dgghrd_(const char *compq, const char *compz, const int *n, int *ilo, int *ihi, double *a, const int *lda,
               double *b, const int *ldb, double *q, const int *ldq, double *z, const int *ldz, int *info);
  void zgehrd_(const int *n, int *ilo, int *ihi, dcmplx *a, const int *lda, dcmplx *tau, dcmplx *work, int *lwork, int *info);
  void zgehd2_(const int *n, const int *ilo, const int *ihi, dcmplx *a, const int *lda, dcmplx *tau, dcmplx *work, int *info);

  void sggsvp_(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, float *a, int *lda, float *b, int *ldb,
               float *tola, float *tolb, int *k, int *l, float *u, int *ldu, float *v, int *ldv, float *q, int *ldq,
               int *iwork, float *tau, float *work, int *info);
  void dggsvp_(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, double *a, int *lda, double *b, int *ldb,
               double *tola, double *tolb, int *k, int *l, double *u, int *ldu, double *v, int *ldv, double *q, int *ldq,
               int *iwork, double *tau, double *work, int *info);

  void dhgeqz_(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi,
               double *a, int *lda, double *b, int *ldb, double *alphar, double *alphai, double *beta,
               double *q, int *ldq, double *z, int *ldz, double *work, int *lwork, int *info);

  void dlabad_(double *small, double *large);
  void dlacon_(int *n, double *v, double *x, int *isgn, double *est, int *kase);

  void dlacpy_(const char *uplo, const int *m, const int *n, double *a, const int *lda, double *b, const int *ldb);
  void slacpy_(const char *uplo, const int *m, const int *n, float *a, const int *lda, float *b, const int *ldb);
  void zlacpy_(const char *uplo, const int *m, const int *n, dcmplx *a, const int *lda, dcmplx *b, const int *ldb);

  void dladiv_(const double *a, const double *b, const double *c, const double *d, double *p, double *q);
  void zladiv_(dcmplx *ret_val, const dcmplx *x, const dcmplx *y);

  void dlag2_(double *a, int *lda, double *b, int *ldb, double *safmin, double *scale1, double *scale2,
              double *wr1, double *wr2, double *wi);
  void slags2_(logical *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);
  void dlags2_(logical *upper, double *a1, double *a2, double *a3, double *b1, double *b2, double *b3,
               double *csu, double *snu, double *csv, double *snv, double *csq, double *snq);
  void dlagv2_(double *a, int *lda, double *b, int *ldb, double *alphar, double *alphai, double *beta,
               double *csl, double *snl, double *csr, double *snr);