/** ======================================================================* NIST Guide to Available Math Software.* Fullsource for module SSYEVX.C from package CLAPACK.* Retrieved from NETLIB on Fri Mar 10 14:23:44 2000.* ======================================================================*/#include <f2c.h>integer ilaenv_(integer *ispec, char *name, char *opts, integer *n1, integer *	n2, integer *n3, integer *n4, ftnlen name_len, ftnlen opts_len){/*  -- LAPACK auxiliary routine (version 2.0) --          Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,          Courant Institute, Argonne National Lab, and Rice University          September 30, 1994       Purpose       =======       ILAENV is called from the LAPACK routines to choose problem-dependent       parameters for the local environment.  See ISPEC for a description of       the parameters.       This version provides a set of parameters which should give good,       but not optimal, performance on many of the currently available       computers.  Users are encouraged to modify this subroutine to set       the tuning parameters for their particular machine using the option       and problem size information in the arguments.       This routine will not function correctly if it is converted to all       lower case.  Converting it to all upper case is allowed.       Arguments       =========       ISPEC   (input) INTEGER               Specifies the parameter to be returned as the value of               ILAENV.               = 1: the optimal blocksize; if this value is 1, an unblocked                    algorithm will give the best performance.               = 2: the minimum block size for which the block routine                    should be used; if the usable block size is less than                    this value, an unblocked routine should be used.               = 3: the crossover point (in a block routine, for N less                    than this value, an unblocked routine should be used)               = 4: the number of shifts, used in the nonsymmetric                    eigenvalue routines               = 5: the minimum column dimension for blocking to be used;                    rectangular blocks must have dimension at least k by m,                    where k is given by ILAENV(2,...) and m by ILAENV(5,...)               = 6: the crossover point for the SVD (when reducing an m by n                    matrix to bidiagonal form, if max(m,n)/min(m,n) exceeds                    this value, a QR factorization is used first to reduce                    the matrix to a triangular form.)               = 7: the number of processors               = 8: the crossover point for the multishift QR and QZ methods                    for nonsymmetric eigenvalue problems.       NAME    (input) CHARACTER*(*)               The name of the calling subroutine, in either upper case or               lower case.       OPTS    (input) CHARACTER*(*)               The character options to the subroutine NAME, concatenated               into a single character string.  For example, UPLO = 'U',               TRANS = 'T', and DIAG = 'N' for a triangular routine would               be specified as OPTS = 'UTN'.       N1      (input) INTEGER       N2      (input) INTEGER       N3      (input) INTEGER       N4      (input) INTEGER               Problem dimensions for the subroutine NAME; these may not all               be required.      (ILAENV) (output) INTEGER               >= 0: the value of the parameter specified by ISPEC               < 0:  if ILAENV = -k, the k-th argument had an illegal value.       Further Details       ===============       The following conventions have been used when calling ILAENV from the       LAPACK routines:       1)  OPTS is a concatenation of all of the character options to           subroutine NAME, in the same order that they appear in the           argument list for NAME, even if they are not used in determining           the value of the parameter specified by ISPEC.       2)  The problem dimensions N1, N2, N3, N4 are specified in the order           that they appear in the argument list for NAME.  N1 is used           first, N2 second, and so on, and unused problem dimensions are           passed a value of -1.       3)  The parameter value returned by ILAENV is checked for validity in           the calling subroutine.  For example, ILAENV is used to retrieve           the optimal blocksize for STRTRI as follows:           NB = ILAENV( 1, 'STRTRI', UPLO // DIAG, N, -1, -1, -1 )           IF( NB.LE.1 ) NB = MAX( 1, N )       ===================================================================== *//* >>Start of File<<          System generated locals */    integer ret_val;    /* Builtin functions          Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);    integer s_cmp(char *, char *, ftnlen, ftnlen);    /* Local variables */    static integer i;    static logical cname, sname;    static integer nbmin;    static char c1[1], c2[2], c3[3], c4[2];    static integer ic, nb, iz, nx;    static char subnam[6];    switch (*ispec) {	case 1:  goto L100;	case 2:  goto L100;	case 3:  goto L100;	case 4:  goto L400;	case 5:  goto L500;	case 6:  goto L600;	case 7:  goto L700;	case 8:  goto L800;    }/*     Invalid value for ISPEC */    ret_val = -1;    return ret_val;L100:/*     Convert NAME to upper case if the first character is lower case. */    ret_val = 1;    s_copy(subnam, name, 6L, name_len);    ic = *(unsigned char *)subnam;    iz = 'Z';    if (iz == 90 || iz == 122) {/*        ASCII character set */	if (ic >= 97 && ic <= 122) {	    *(unsigned char *)subnam = (char) (ic - 32);	    for (i = 2; i <= 6; ++i) {		ic = *(unsigned char *)&subnam[i - 1];		if (ic >= 97 && ic <= 122) {		    *(unsigned char *)&subnam[i - 1] = (char) (ic - 32);		}/* L10: */	    }	}    } else if (iz == 233 || iz == 169) {/*        EBCDIC character set */	if (ic >= 129 && ic <= 137 || ic >= 145 && ic <= 153 || ic >= 162 && 		ic <= 169) {	    *(unsigned char *)subnam = (char) (ic + 64);	    for (i = 2; i <= 6; ++i) {		ic = *(unsigned char *)&subnam[i - 1];		if (ic >= 129 && ic <= 137 || ic >= 145 && ic <= 153 || ic >= 			162 && ic <= 169) {		    *(unsigned char *)&subnam[i - 1] = (char) (ic + 64);		}/* L20: */	    }	}    } else if (iz == 218 || iz == 250) {/*        Prime machines:  ASCII+128 */	if (ic >= 225 && ic <= 250) {	    *(unsigned char *)subnam = (char) (ic - 32);	    for (i = 2; i <= 6; ++i) {		ic = *(unsigned char *)&subnam[i - 1];		if (ic >= 225 && ic <= 250) {		    *(unsigned char *)&subnam[i - 1] = (char) (ic - 32);		}/* L30: */	    }	}    }    *(unsigned char *)c1 = *(unsigned char *)subnam;    sname = *(unsigned char *)c1 == 'S' || *(unsigned char *)c1 == 'D';    cname = *(unsigned char *)c1 == 'C' || *(unsigned char *)c1 == 'Z';    if (! (cname || sname)) {	return ret_val;    }    s_copy(c2, subnam + 1, 2L, 2L);    s_copy(c3, subnam + 3, 3L, 3L);    s_copy(c4, c3 + 1, 2L, 2L);    switch (*ispec) {	case 1:  goto L110;	case 2:  goto L200;	case 3:  goto L300;    }L110:/*     ISPEC = 1:  block size          In these examples, separate code is provided for setting NB for          real and complex.  We assume that NB will take the same value in          single or double precision. */    nb = 1;    if (s_cmp(c2, "GE", 2L, 2L) == 0) {	if (s_cmp(c3, "TRF", 3L, 3L) == 0) {	    if (sname) {		nb = 64;	    } else {		nb = 64;	    }	} else if (s_cmp(c3, "QRF", 3L, 3L) == 0 || s_cmp(c3, "RQF", 3L, 3L) 		== 0 || s_cmp(c3, "LQF", 3L, 3L) == 0 || s_cmp(c3, "QLF", 3L, 		3L) == 0) {	    if (sname) {		nb = 32;	    } else {		nb = 32;	    }	} else if (s_cmp(c3, "HRD", 3L, 3L) == 0) {	    if (sname) {		nb = 32;	    } else {		nb = 32;	    }	} else if (s_cmp(c3, "BRD", 3L, 3L) == 0) {	    if (sname) {		nb = 32;	    } else {		nb = 32;	    }	} else if (s_cmp(c3, "TRI", 3L, 3L) == 0) {	    if (sname) {		nb = 64;	    } else {		nb = 64;	    }	}    } else if (s_cmp(c2, "PO", 2L, 2L) == 0) {	if (s_cmp(c3, "TRF", 3L, 3L) == 0) {	    if (sname) {		nb = 64;	    } else {		nb = 64;	    }	}    } else if (s_cmp(c2, "SY", 2L, 2L) == 0) {	if (s_cmp(c3, "TRF", 3L, 3L) == 0) {	    if (sname) {		nb = 64;	    } else {		nb = 64;	    }