sdrvrf1.c

Go to the documentation of this file.

/* sdrvrf1.f -- translated by f2c (version 20061008).
   You must link the resulting object file with libf2c:
        on Microsoft Windows system, link with libf2c.lib;
        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
        or, if you install libf2c.a in a standard place, with -lf2c -lm
        -- in that order, at the end of the command line, as in
                cc *.o -lf2c -lm
        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

                http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"
#include "blaswrap.h"

/* Common Block Declarations */

struct {
    char srnamt[32];
} srnamc_;

#define srnamc_1 srnamc_

/* Table of constant values */

static integer c__2 = 2;
static integer c__1 = 1;

/* Subroutine */ int sdrvrf1_(integer *nout, integer *nn, integer *nval, real 
        *thresh, real *a, integer *lda, real *arf, real *work)
{
    /* Initialized data */

    static integer iseedy[4] = { 1988,1989,1990,1991 };
    static char uplos[1*2] = "U" "L";
    static char forms[1*2] = "N" "T";
    static char norms[1*4] = "M" "1" "I" "F";

    /* Format strings */
    static char fmt_9999[] = "(1x,\002 *** Error(s) or Failure(s) while test"
            "ing SLANSF              ***\002)";
    static char fmt_9998[] = "(1x,\002     Error in \002,a6,\002 with UPLO="
            "'\002,a1,\002', FORM='\002,a1,\002', N=\002,i5)";
    static char fmt_9997[] = "(1x,\002     Failure in \002,a6,\002 N=\002,"
            "i5,\002 TYPE=\002,i5,\002 UPLO='\002,a1,\002', FORM ='\002,a1"
            ",\002', NORM='\002,a1,\002', test=\002,g12.5)";
    static char fmt_9996[] = "(1x,\002All tests for \002,a6,\002 auxiliary r"
            "outine passed the \002,\002threshold (\002,i5,\002 tests run)"
            "\002)";
    static char fmt_9995[] = "(1x,a6,\002 auxiliary routine:\002,i5,\002 out"
            " of \002,i5,\002 tests failed to pass the threshold\002)";
    static char fmt_9994[] = "(26x,i5,\002 error message recorded (\002,a6"
            ",\002)\002)";

    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;

    /* Builtin functions */
    /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
    integer s_wsle(cilist *), e_wsle(void), s_wsfe(cilist *), e_wsfe(void), 
            do_fio(integer *, char *, ftnlen);

    /* Local variables */
    integer i__, j, n, iin, iit;
    real eps;
    integer info;
    char norm[1], uplo[1];
    integer nrun, nfail;
    real large;
    integer iseed[4];
    char cform[1];
    real small;
    integer iform;
    real norma;
    integer inorm, iuplo, nerrs;
    extern doublereal slamch_(char *), slarnd_(integer *, integer *), 
            slansf_(char *, char *, char *, integer *, real *, real *), slansy_(char *, char *, integer *, real *, 
            integer *, real *);
    real result[1];
    extern /* Subroutine */ int strttf_(char *, char *, integer *, real *, 
            integer *, real *, integer *);
    real normarf;

    /* Fortran I/O blocks */
    static cilist io___22 = { 0, 0, 0, 0, 0 };
    static cilist io___23 = { 0, 0, 0, fmt_9999, 0 };
    static cilist io___24 = { 0, 0, 0, fmt_9998, 0 };
    static cilist io___30 = { 0, 0, 0, 0, 0 };
    static cilist io___31 = { 0, 0, 0, fmt_9999, 0 };
    static cilist io___32 = { 0, 0, 0, fmt_9997, 0 };
    static cilist io___33 = { 0, 0, 0, fmt_9996, 0 };
    static cilist io___34 = { 0, 0, 0, fmt_9995, 0 };
    static cilist io___35 = { 0, 0, 0, fmt_9994, 0 };



/*  -- LAPACK test routine (version 3.2.0) -- */
/*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/*     November 2008 */

/*     .. Scalar Arguments .. */
/*     .. */
/*     .. Array Arguments .. */
/*     .. */

/*  Purpose */
/*  ======= */

/*  SDRVRF1 tests the LAPACK RFP routines: */
/*      SLANSF */

/*  Arguments */
/*  ========= */

/*  NOUT          (input) INTEGER */
/*                The unit number for output. */

/*  NN            (input) INTEGER */
/*                The number of values of N contained in the vector NVAL. */

/*  NVAL          (input) INTEGER array, dimension (NN) */
/*                The values of the matrix dimension N. */

/*  THRESH        (input) REAL */
/*                The threshold value for the test ratios.  A result is */
/*                included in the output file if RESULT >= THRESH.  To have */
/*                every test ratio printed, use THRESH = 0. */

/*  A             (workspace) REAL array, dimension (LDA,NMAX) */

/*  LDA           (input) INTEGER */
/*                The leading dimension of the array A.  LDA >= max(1,NMAX). */

/*  ARF           (workspace) REAL array, dimension ((NMAX*(NMAX+1))/2). */

/*  WORK          (workspace) REAL array, dimension ( NMAX ) */

/*  ===================================================================== */
/*     .. */
/*     .. Parameters .. */
/*     .. */
/*     .. Local Scalars .. */
/*     .. */
/*     .. Local Arrays .. */
/*     .. */
/*     .. External Functions .. */
/*     .. */
/*     .. External Subroutines .. */
/*     .. */
/*     .. Scalars in Common .. */
/*     .. */
/*     .. Common blocks .. */
/*     .. */
/*     .. Data statements .. */
    /* Parameter adjustments */
    --nval;
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --arf;
    --work;

    /* Function Body */
/*     .. */
/*     .. Executable Statements .. */

/*     Initialize constants and the random number seed. */

    nrun = 0;
    nfail = 0;
    nerrs = 0;
    info = 0;
    for (i__ = 1; i__ <= 4; ++i__) {
        iseed[i__ - 1] = iseedy[i__ - 1];
/* L10: */
    }

    eps = slamch_("Precision");
    small = slamch_("Safe minimum");
    large = 1.f / small;
    small = small * *lda * *lda;
    large = large / *lda / *lda;

    i__1 = *nn;
    for (iin = 1; iin <= i__1; ++iin) {

        n = nval[iin];

        for (iit = 1; iit <= 3; ++iit) {

/*           IIT = 1 : random matrix */
/*           IIT = 2 : random matrix scaled near underflow */
/*           IIT = 3 : random matrix scaled near overflow */

            i__2 = n;
            for (j = 1; j <= i__2; ++j) {
                i__3 = n;
                for (i__ = 1; i__ <= i__3; ++i__) {
                    a[i__ + j * a_dim1] = slarnd_(&c__2, iseed);
                }
            }

            if (iit == 2) {
                i__2 = n;
                for (j = 1; j <= i__2; ++j) {
                    i__3 = n;
                    for (i__ = 1; i__ <= i__3; ++i__) {
                        a[i__ + j * a_dim1] *= large;
                    }
                }
            }

            if (iit == 3) {
                i__2 = n;
                for (j = 1; j <= i__2; ++j) {
                    i__3 = n;
                    for (i__ = 1; i__ <= i__3; ++i__) {
                        a[i__ + j * a_dim1] *= small;
                    }
                }
            }

/*           Do first for UPLO = 'U', then for UPLO = 'L' */

            for (iuplo = 1; iuplo <= 2; ++iuplo) {

                *(unsigned char *)uplo = *(unsigned char *)&uplos[iuplo - 1];

/*              Do first for CFORM = 'N', then for CFORM = 'C' */

                for (iform = 1; iform <= 2; ++iform) {

                    *(unsigned char *)cform = *(unsigned char *)&forms[iform 
                            - 1];

                    s_copy(srnamc_1.srnamt, "STRTTF", (ftnlen)32, (ftnlen)6);
                    strttf_(cform, uplo, &n, &a[a_offset], lda, &arf[1], &
                            info);

/*                 Check error code from STRTTF */

                    if (info != 0) {
                        if (nfail == 0 && nerrs == 0) {
                            io___22.ciunit = *nout;
                            s_wsle(&io___22);
                            e_wsle();
                            io___23.ciunit = *nout;
                            s_wsfe(&io___23);
                            e_wsfe();
                        }
                        io___24.ciunit = *nout;
                        s_wsfe(&io___24);
                        do_fio(&c__1, srnamc_1.srnamt, (ftnlen)32);
                        do_fio(&c__1, uplo, (ftnlen)1);
                        do_fio(&c__1, cform, (ftnlen)1);
                        do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
                        e_wsfe();
                        ++nerrs;
                        goto L100;
                    }

                    for (inorm = 1; inorm <= 4; ++inorm) {

/*                    Check all four norms: 'M', '1', 'I', 'F' */

                        *(unsigned char *)norm = *(unsigned char *)&norms[
                                inorm - 1];
                        normarf = slansf_(norm, cform, uplo, &n, &arf[1], &
                                work[1]);
                        norma = slansy_(norm, uplo, &n, &a[a_offset], lda, &
                                work[1]);

                        result[0] = (norma - normarf) / norma / eps;
                        ++nrun;

                        if (result[0] >= *thresh) {
                            if (nfail == 0 && nerrs == 0) {
                                io___30.ciunit = *nout;
                                s_wsle(&io___30);
                                e_wsle();
                                io___31.ciunit = *nout;
                                s_wsfe(&io___31);
                                e_wsfe();
                            }
                            io___32.ciunit = *nout;
                            s_wsfe(&io___32);
                            do_fio(&c__1, "SLANSF", (ftnlen)6);
                            do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer))
                                    ;
                            do_fio(&c__1, (char *)&iit, (ftnlen)sizeof(
                                    integer));
                            do_fio(&c__1, uplo, (ftnlen)1);
                            do_fio(&c__1, cform, (ftnlen)1);
                            do_fio(&c__1, norm, (ftnlen)1);
                            do_fio(&c__1, (char *)&result[0], (ftnlen)sizeof(
                                    real));
                            e_wsfe();
                            ++nfail;
                        }
/* L90: */
                    }
L100:
                    ;
                }
/* L110: */
            }
/* L120: */
        }
/* L130: */
    }

/*     Print a summary of the results. */

    if (nfail == 0) {
        io___33.ciunit = *nout;
        s_wsfe(&io___33);
        do_fio(&c__1, "SLANSF", (ftnlen)6);
        do_fio(&c__1, (char *)&nrun, (ftnlen)sizeof(integer));
        e_wsfe();
    } else {
        io___34.ciunit = *nout;
        s_wsfe(&io___34);
        do_fio(&c__1, "SLANSF", (ftnlen)6);
        do_fio(&c__1, (char *)&nfail, (ftnlen)sizeof(integer));
        do_fio(&c__1, (char *)&nrun, (ftnlen)sizeof(integer));
        e_wsfe();
    }
    if (nerrs != 0) {
        io___35.ciunit = *nout;
        s_wsfe(&io___35);
        do_fio(&c__1, (char *)&nerrs, (ftnlen)sizeof(integer));
        do_fio(&c__1, "SLANSF", (ftnlen)6);
        e_wsfe();
    }


    return 0;

/*     End of SDRVRF1 */

} /* sdrvrf1_ */