Portable Math Library in C (Part 6 of 6)
f...@mcdsun.uucp
several years since I had any interest in doing any more work on it, and
people may find it useful, I have decided to post it. There should be
a lead-in posting (part 0 of 6?) containing a README file and commands
to make the directories for the regular parts 1-6. Be sure to read the
README file in 'part 0'.
-Fred Fish
=============== Cut here and feed to the shell ========================
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 6 (of 6)."
# Contents: tests/c2c.c tests/cc2c.c
# Wrapped by fnf@mcdsun on Fri Apr 10 16:21:49 1987
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f tests/c2c.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"tests/c2c.c\"
else
echo shar: Extracting \"tests/c2c.c\" \(11638 characters\)
sed "s/^X//" >tests/c2c.c <<'END_OF_tests/c2c.c'
X/************************************************************************
X * *
X * N O T I C E *
X * *
X * Copyright Abandoned, 1987, Fred Fish *
X * *
X * This previously copyrighted work has been placed into the *
X * public domain by the author (Fred Fish) and may be freely used *
X * for any purpose, private or commercial. I would appreciate *
X * it, as a courtesy, if this notice is left in all copies and *
X * derivative works. Thank you, and enjoy... *
X * *
X * The author makes no warranty of any kind with respect to this *
X * product and explicitly disclaims any implied warranties of *
X * merchantability or fitness for any particular purpose. *
X * *
X ************************************************************************
X */
X
X/*
X * FILE
X *
X * c2c.c test complex to complex math functions
X *
X * KEY WORDS
X *
X * portable math library
X * test functions
X *
X * DESCRIPTION
X *
X * Tests double precision functions for the Portable Math
X * Library. Tests those functions which expect a single
X * double precision complex argument and return a double
X * precision complex result.
X *
X * Most of the test data in the current data file (c2c.dat)
X * was generated using double precision FORTRAN arithmetic
X * on a Decsystem-20.
X *
X * Note that the ordering of functions is important for
X * optimum error information. Since some functions call
X * others in the library, the functions being called should
X * be tested first. Naturally, an error in a lower level
X * function will cause propagation of errors up to higher
X * level functions.
X *
X * USAGE
X *
X * c2c [-esv] [-l limit]
X *
X * -e => force error for each test
X * to verify error handling
X *
X * -l => report errors greater than
X * specified limit (default 10**-6)
X *
X * -s => print summary after tests
X *
X * -v => print each function, argument,
X * and result
X *
X * Test directives are read from the standard input, which
X * may be redirected to the provided test file (c2c.dat),
X * and any relative errors are automatically written to standard
X * output if they exceed a maximum allowable limit.
X * Each test directive has the form:
X *
X * <name> <argument> <expected result>
X *
X * Each field is separated by a one or more space character(s).
X * Both the argument and the expected result are given
X * in the form:
X *
X * <real> <imag>
X *
X * where <real> is the real part and <imag> is the
X * imaginary part, separated by one or more spaces.
X *
X *
X * NOTE
X *
X * This program uses both the csubt and the cdiv routines,
X * which are pml functions!. Thus if either of these screw
X * up, the results will be unpredictable. BEWARE!
X *
X * PROGRAMMER
X *
X * Fred Fish
X * Tempe, Az 85281
X *
X */
X
X
X#include <stdio.h>
X#include <pmluser.h>
X
X#ifndef NODBG
X#include <dbg.h>
X#else
X#include "dbg.h"
X#endif
X
X#define TRUE 1 /* This really should be in stdio.h */
X#define FALSE 0 /* This too */
X#define MAX_ABS_ERR 1.0e-6 /* Set to catch only gross errors */
X
Xstatic int vflag; /* Flag for verbose option */
Xstatic int eflag; /* Simulate an error to error printout */
Xstatic int sflag; /* Flag to show final statistics */
X
Xstatic double max_abs_err = MAX_ABS_ERR;
X
X/*
X * External functions which are used internally.
X */
X
Xextern char *strtok ();
Xextern double atof ();
Xextern double cabs ();
Xextern COMPLEX csubt ();
Xextern COMPLEX cdiv ();
X
X/*
X * External functions to be tested.
X */
X
Xextern COMPLEX cacos();
Xextern COMPLEX casin();
Xextern COMPLEX catan();
Xextern COMPLEX ccos();
Xextern COMPLEX ccosh();
Xextern COMPLEX cexp();
Xextern COMPLEX clog();
Xextern COMPLEX crcp();
Xextern COMPLEX csin();
Xextern COMPLEX csinh();
Xextern COMPLEX csqrt();
Xextern COMPLEX ctan();
Xextern COMPLEX ctanh();
X
X
X/*
X * Define all recognized test functions. Each function
X * must have an entry in this table, where each
X * entry contains the information specified in the
X * structure "test".
X *
X */
X
Xstruct test { /* Structure of each function to be tested */
X char *name; /* Name of the function to test */
X COMPLEX (*func)(); /* Pointer to the function's entry point */
X double max_err; /* Error accumulator for this function */
X};
X
Xstatic struct test tests[] = { /* Table of all recognized functions */
X "cacos", cacos, 0.0, /* Complex arc cosine */
X "casin", casin, 0.0, /* Complex arc sine */
X "catan", catan, 0.0, /* Complex arc tangent */
X "ccos", ccos, 0.0, /* Complex cosine */
X "ccosh", ccosh, 0.0, /* Complex hyperbolic cosine */
X "cexp", cexp, 0.0, /* Complex exponential */
X "clog", clog, 0.0, /* Complex natural logarithm */
X "crcp", crcp, 0.0, /* Complex reciprocal */
X "csin", csin, 0.0, /* Complex sine */
X "csinh", csinh, 0.0, /* Complex hyperbolic sine */
X "csqrt", csqrt, 0.0, /* Complex square root */
X "ctan", ctan, 0.0, /* Complex tangent */
X "ctanh", ctanh, 0.0, /* Complex hyperbolic tangent */
X NULL, NULL, 0.0 /* Function list end marker */
X};
X
X
X/*
X * FUNCTION
X *
X * main entry point for c2c test utility
X *
X * PSEUDO CODE
X *
X * Begin main
X * Process any options in command line.
X * Do all tests requested by stdin directives.
X * Report final statistics (if enabled).
X * End main
X *
X */
X
Xmain (argc, argv)
Xint argc;
Xchar *argv[];
X{
X ENTER ("main");
X DEBUGWHO (argv[0]);
X options (argc, argv);
X dotests (argv);
X statistics ();
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * dotests process each test from stdin directives
X *
X * ERROR REPORTING
X *
X * Note that in most cases, the error criterion is based
X * on relative error, defined as:
X *
X * error = (result - expected) / expected
X *
X * Naturally, if the expected result is zero, some
X * other criterion must be used. In this case, the
X * absolute error is used. That is:
X *
X * error = result
X *
X * PSEUDO CODE
X *
X * Begin dotests
X * While a test directive is successfully read from stdin
X * Default function name to "{null}"
X * Default real part of argument to 0.0
X * Default imaginary part of argument to 0.0
X * Default expected result to 0.0
X * Extract function name, argument and expected result
X * Lookup test in available test list
X * If no test was found then
X * Tell user that unknown function was specified
X * Else
X * Call function with argument and save result
X * If the verify flag is set then
X * Print function name, argument, and result
X * End if
X * If the expected result is not zero then
X * Compute the relative error
X * Else
X * Use the absolute error
X * End if
X * Get absolute value of error
X * If error exceeds limit or error force flag set
X * Print error notification on stderr
X * End if
X * If this error is max for given function then
X * Remember this error for summary
X * End if
X * End if
X * End while
X * End dotests
X *
X */
X
X
Xdotests (argv)
Xchar *argv[];
X{
X char buffer[256]; /* Directive buffer */
X char function[64]; /* Specified function name */
X COMPLEX argument; /* Specified function argument */
X COMPLEX expected; /* Specified expected result */
X COMPLEX result; /* Actual result */
X COMPLEX error; /* Relative or absolute error */
X double abs_err; /* Absolute value of error */
X struct test *testp; /* Pointer to function test */
X struct test *lookup (); /* Returns function test pointer */
X register char *strp; /* Pointer to next token in string */
X
X ENTER ("dotests");
X while (fgets (buffer, sizeof(buffer), stdin) != NULL) {
X strcpy (function, "{null}");
X argument.real = argument.imag = 0.0;
X expected.real = expected.imag = 0.0;
X sscanf (buffer, "%s %le %le %le %le", function,
X &argument.real, &argument.imag, &expected.real, &expected.imag);
X testp = lookup (function);
X if (testp == NULL) {
X fprintf (stderr, "%s: unknown function \"%s\".\n",
X argv[0], function);
X } else {
X result = (*testp -> func)(argument);
X if (vflag) {
X printf ("%s(%le + j %le) \n = %30.23le + j %30.23le.\n",
X function, argument.real, argument.imag, result.real,
X result.imag);
X }
X if (expected.real != 0.0 || expected.imag != 0.0) {
X error = csubt (result, expected);
X error = cdiv (error, expected);
X } else {
X error = result;
X }
X abs_err = cabs (error);
X if ((abs_err > max_abs_err) || eflag) {
X fprintf (stderr, "%s: error in \"%s\"\n", argv[0], function);
X fprintf (stderr, "\treal (arg)\t\t%25.20le\n", argument.real);
X fprintf (stderr, "\timag (arg)\t\t%25.20le\n", argument.imag);
X fprintf (stderr, "\treal (result)\t\t%25.20le\n",result.real);
X fprintf (stderr, "\timag (result)\t\t%25.20le\n",result.imag);
X fprintf (stderr, "\treal (expected)\t\t%25.20le\n",expected.real);
X fprintf (stderr, "\timag (expected)\t\t%25.20le\n",expected.imag);
X }
X if (abs_err > testp -> max_err) {
X testp -> max_err = abs_err;
X }
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * options process command line options
X *
X * PSEUDO CODE
X *
X * Begin options
X * Reset all flags to FALSE by default
X * Initialize flag argument scan pointer
X * If there is a second command line argument then
X * If the argument specifies flags then
X * While there is an unprocessed flag
X * Switch on flag
X * Case "force error flag":
X * Set the "force error" flag
X * Break switch
X * Case "print summary":
X * Set "print summary" flag
X * Break switch
X * Case "verbose":
X * Set "verbose" flag
X * Break switch
X * Default:
X * Tell user unknown flag
X * Break switch
X * End switch
X * End while
X * End if
X * End if
X * End options
X *
X */
X
X
Xoptions (argc, argv)
Xint argc;
Xchar *argv[];
X{
X register int flag;
X extern int getopt ();
X extern char *optarg;
X
X ENTER ("options");
X eflag = sflag = vflag = FALSE;
X while ((flag = getopt (argc, argv, "#:el:sv")) != EOF) {
X switch (flag) {
X case '#':
X DEBUGPUSH (optarg);
X break;
X case 'e':
X eflag = TRUE;
X break;
X case 'l':
X sscanf (optarg, "%le", &max_abs_err);
X DEBUG3 ("args", "max_abs_err = %le", max_abs_err);
X break;
X case 's':
X sflag = TRUE;
X break;
X case 'v':
X vflag = TRUE;
X break;
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * loopup lookup test in known test list
X *
X * DESCRIPTION
X *
X * Given the name of a desired test, looks up the test
X * in the known test list and returns a pointer to the
X * test structure.
X *
X * Since the table is so small we simply use a linear
X * search.
X *
X * PSEUDO CODE
X *
X * Begin lookup
X * For each known test
X * If the test's name matches the desired test name
X * Return pointer to the test structure
X * End if
X * End for
X * End lookup
X *
X */
X
Xstruct test *lookup (funcname)
Xchar *funcname;
X{
X struct test *testp;
X struct test *rtnval;
X
X ENTER ("lookup");
X rtnval = (struct test *) NULL;
X for (testp = tests; testp -> name != NULL && rtnval == NULL; testp++) {
X if (!strcmp (testp -> name, funcname)) {
X rtnval = testp;
X }
X }
X LEAVE ();
X return (rtnval);
X}
X
X
X/*
X * FUNCTION
X *
X * statistics print final statistics if desired
X *
X * PSEUDO CODE
X *
X * Begin statistics
X * If a final statistics (summary) is desired then
X * For each test in the known test list
X * Print the maximum error encountered
X * End for
X * End if
X * End statistics
X *
X */
X
Xstatistics ()
X{
X struct test *tp;
X
X ENTER ("statistics");
X if (sflag) {
X for (tp = tests; tp -> name != NULL; tp++) {
X printf ("%s:\tmaximum relative error %le\n",
X tp -> name, tp -> max_err);
X }
X }
X LEAVE ();
X}
END_OF_tests/c2c.c
if test 11638 -ne `wc -c <tests/c2c.c`; then
echo shar: \"tests/c2c.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f tests/cc2c.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"tests/cc2c.c\"
else
echo shar: Extracting \"tests/cc2c.c\" \(11225 characters\)
sed "s/^X//" >tests/cc2c.c <<'END_OF_tests/cc2c.c'
X/************************************************************************
X * *
X * N O T I C E *
X * *
X * Copyright Abandoned, 1987, Fred Fish *
X * *
X * This previously copyrighted work has been placed into the *
X * public domain by the author (Fred Fish) and may be freely used *
X * for any purpose, private or commercial. I would appreciate *
X * it, as a courtesy, if this notice is left in all copies and *
X * derivative works. Thank you, and enjoy... *
X * *
X * The author makes no warranty of any kind with respect to this *
X * product and explicitly disclaims any implied warranties of *
X * merchantability or fitness for any particular purpose. *
X * *
X ************************************************************************
X */
X
X/*
X * FILE
X *
X * cc2c.c test complex to complex math functions
X *
X * KEY WORDS
X *
X * portable math library
X * test functions
X *
X * DESCRIPTION
X *
X * Tests double precision functions for the Portable Math
X * Library. Tests those functions which expect two
X * double precision complex arguments and return a double
X * precision complex result.
X *
X * Most of the test data in the current data file (cc2c.dat)
X * was generated using double precision FORTRAN arithmetic
X * on a Decsystem-20.
X *
X * Note that the ordering of functions is important for
X * optimum error information. Since some functions call
X * others in the library, the functions being called should
X * be tested first. Naturally, an error in a lower level
X * function will cause propagation of errors up to higher
X * level functions.
X *
X * USAGE
X *
X * cc2c [-esv] [-l limit]
X *
X * -e => force error for each test
X * to verify error handling
X *
X * -l => report errors greater than
X * specified limit (default 10**-6)
X *
X * -s => print summary after tests
X *
X * -v => print each function, argument,
X * and result
X *
X * Test directives are read from the standard input, which
X * may be redirected to the provided test file (cc2c.dat),
X * and any relative errors are automatically written to standard
X * output if they exceed a maximum allowable limit.
X * Each test directive has the form:
X *
X * <name> <arg1> <arg2> <expected result>
X *
X * Each field is separated by a one or more space character(s).
X * Both the argument and the expected result are given
X * in the form:
X *
X * <real> <imag>
X *
X * where <real> is the real part and <imag> is the
X * imaginary part, separated by one or more spaces.
X *
X *
X * NOTE
X *
X * This program uses both the csubt and the cdiv routines,
X * which are pml functions!. Thus if either of these screw
X * up, the results will be unpredictable. BEWARE!
X *
X * PROGRAMMER
X *
X * Fred Fish
X * Tempe, Az 85281
X *
X */
X
X
X#include <stdio.h>
X#include <pmluser.h>
X
X#ifndef NODBG
X#include <dbg.h>
X#else
X#include "dbg.h"
X#endif
X
X#define TRUE 1 /* This really should be in stdio.h */
X#define FALSE 0 /* This too */
X#define MAX_ABS_ERR 1.0e-6 /* Set to catch only gross errors */
X
Xstatic int vflag; /* Flag for verbose option */
Xstatic int eflag; /* Simulate an error to error printout */
Xstatic int sflag; /* Flag to show final statistics */
X
Xstatic double max_abs_err = MAX_ABS_ERR;
X
X/*
X * External functions which are used internally.
X */
X
Xextern char *strtok ();
Xextern double atof ();
Xextern double cabs ();
Xextern COMPLEX csubt ();
Xextern COMPLEX cdiv ();
X
X/*
X * External functions to be tested.
X */
X
Xextern COMPLEX cadd();
Xextern COMPLEX csubt();
Xextern COMPLEX cdiv();
Xextern COMPLEX cmult();
X
X
X/*
X * Define all recognized test functions. Each function
X * must have an entry in this table, where each
X * entry contains the information specified in the
X * structure "test".
X *
X */
X
Xstruct test { /* Structure of each function to be tested */
X char *name; /* Name of the function to test */
X COMPLEX (*func)(); /* Pointer to the function's entry point */
X double max_err; /* Error accumulator for this function */
X};
X
Xstatic struct test tests[] = { /* Table of all recognized functions */
X "cadd", cadd, 0.0, /* Complex addition */
X "csubt", csubt, 0.0, /* Complex subtraction */
X "cdiv", cdiv, 0.0, /* Complex division */
X "cmult", cmult, 0.0, /* Complex multiplication */
X NULL, NULL, 0.0 /* Function list end marker */
X};
X
X
X/*
X * FUNCTION
X *
X * main entry point for cc2c test utility
X *
X * PSEUDO CODE
X *
X * Begin main
X * Process any options in command line.
X * Do all tests requested by stdin directives.
X * Report final statistics (if enabled).
X * End main
X *
X */
X
Xmain (argc, argv)
Xint argc;
Xchar *argv[];
X{
X ENTER ("main");
X DEBUGWHO (argv[0]);
X options (argc, argv);
X dotests (argv);
X statistics ();
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * dotests process each test from stdin directives
X *
X * ERROR REPORTING
X *
X * Note that in most cases, the error criterion is based
X * on relative error, defined as:
X *
X * error = (result - expected) / expected
X *
X * Naturally, if the expected result is zero, some
X * other criterion must be used. In this case, the
X * absolute error is used. That is:
X *
X * error = result
X *
X * PSEUDO CODE
X *
X * Begin dotests
X * While a test directive is successfully read from stdin
X * Default function name to "{null}"
X * Default real part of argument to 0.0
X * Default imaginary part of argument to 0.0
X * Default expected result to 0.0
X * Extract function name, argument and expected result
X * Lookup test in available test list
X * If no test was found then
X * Tell user that unknown function was specified
X * Else
X * Call function with argument and save result
X * If the verify flag is set then
X * Print function name, argument, and result
X * End if
X * If the expected result is not zero then
X * Compute the relative error
X * Else
X * Use the absolute error
X * End if
X * Get absolute value of error
X * If error exceeds limit or error force flag set
X * Print error notification on stderr
X * End if
X * If this error is max for given function then
X * Remember this error for summary
X * End if
X * End if
X * End while
X * End dotests
X *
X */
X
X
Xdotests (argv)
Xchar *argv[];
X{
X char buffer[256]; /* Directive buffer */
X char function[64]; /* Specified function name */
X COMPLEX arg1; /* Specified function argument 1 */
X COMPLEX arg2; /* Specified function argument 2 */
X COMPLEX expected; /* Specified expected result */
X COMPLEX result; /* Actual result */
X COMPLEX error; /* Relative or absolute error */
X double abs_err; /* Absolute value of error */
X struct test *testp; /* Pointer to function test */
X struct test *lookup (); /* Returns function test pointer */
X register char *strp; /* Pointer to next token in string */
X
X ENTER ("dotests");
X while (fgets (buffer, sizeof(buffer), stdin) != NULL) {
X strcpy (function, "{null}");
X arg1.real = arg1.imag = 0.0;
X arg2.real = arg2.imag = 0.0;
X expected.real = expected.imag = 0.0;
X sscanf (buffer, "%s %le %le %le %le %le %le", function,
X &arg1.real, &arg1.imag, &arg2.real, &arg2.imag,
X &expected.real, &expected.imag);
X testp = lookup (function);
X if (testp == NULL) {
X fprintf (stderr, "%s: unknown function \"%s\".\n",
X argv[0], function);
X } else {
X result = (*testp -> func)(arg1, arg2);
X if (vflag) {
X printf ("%s(%le + j %le, %le + j %le)\n",
X function, arg1.real, arg1.imag, arg2.real, arg2.imag);
X printf (" = %30.23le + j %30.23le.\n", result.real,
X result.imag);
X }
X if (expected.real != 0.0 || expected.imag != 0.0) {
X error = csubt (result, expected);
X error = cdiv (error, expected);
X } else {
X error = result;
X }
X abs_err = cabs (error);
X if ((abs_err > max_abs_err) || eflag) {
X fprintf (stderr, "%s: error in \"%s\"\n", argv[0], function);
X fprintf (stderr, "\treal (arg1)\t\t%25.20le\n", arg1.real);
X fprintf (stderr, "\timag (arg1)\t\t%25.20le\n", arg1.imag);
X fprintf (stderr, "\treal (arg2)\t\t%25.20le\n", arg2.real);
X fprintf (stderr, "\timag (arg2)\t\t%25.20le\n", arg2.imag);
X fprintf (stderr, "\treal (result)\t\t%25.20le\n",result.real);
X fprintf (stderr, "\timag (result)\t\t%25.20le\n",result.imag);
X fprintf (stderr, "\treal (expected)\t\t%25.20le\n",expected.real);
X fprintf (stderr, "\timag (expected)\t\t%25.20le\n",expected.imag);
X }
X if (abs_err > testp -> max_err) {
X testp -> max_err = abs_err;
X }
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * options process command line options
X *
X * PSEUDO CODE
X *
X * Begin options
X * Reset all flags to FALSE by default
X * Initialize flag argument scan pointer
X * If there is a second command line argument then
X * If the argument specifies flags then
X * While there is an unprocessed flag
X * Switch on flag
X * Case "force error flag":
X * Set the "force error" flag
X * Break switch
X * Case "print summary":
X * Set "print summary" flag
X * Break switch
X * Case "verbose":
X * Set "verbose" flag
X * Break switch
X * Default:
X * Tell user unknown flag
X * Break switch
X * End switch
X * End while
X * End if
X * End if
X * End options
X *
X */
X
X
Xoptions (argc, argv)
Xint argc;
Xchar *argv[];
X{
X register int flag;
X extern int getopt ();
X extern char *optarg;
X
X ENTER ("options");
X eflag = sflag = vflag = FALSE;
X while ((flag = getopt (argc, argv, "#:el:sv")) != EOF) {
X switch (flag) {
X case '#':
X DEBUGPUSH (optarg);
X break;
X case 'e':
X eflag = TRUE;
X break;
X case 'l':
X sscanf (optarg, "%le", &max_abs_err);
X DEBUG3 ("args", "max_abs_err = %le", max_abs_err);
X break;
X case 's':
X sflag = TRUE;
X break;
X case 'v':
X vflag = TRUE;
X break;
X }
X }
X LEAVE ();
X}
X
X
X/*
X * FUNCTION
X *
X * loopup lookup test in known test list
X *
X * DESCRIPTION
X *
X * Given the name of a desired test, looks up the test
X * in the known test list and returns a pointer to the
X * test structure.
X *
X * Since the table is so small we simply use a linear
X * search.
X *
X * PSEUDO CODE
X *
X * Begin lookup
X * For each known test
X * If the test's name matches the desired test name
X * Return pointer to the test structure
X * End if
X * End for
X * End lookup
X *
X */
X
Xstruct test *lookup (funcname)
Xchar *funcname;
X{
X struct test *testp;
X struct test *rtnval;
X
X ENTER ("lookup");
X rtnval = (struct test *) NULL;
X for (testp = tests; testp -> name != NULL && rtnval == NULL; testp++) {
X if (!strcmp (testp -> name, funcname)) {
X rtnval = testp;
X }
X }
X LEAVE ();
X return (rtnval);
X}
X
X
X/*
X * FUNCTION
X *
X * statistics print final statistics if desired
X *
X * PSEUDO CODE
X *
X * Begin statistics
X * If a final statistics (summary) is desired then
X * For each test in the known test list
X * Print the maximum error encountered
X * End for
X * End if
X * End statistics
X *
X */
X
Xstatistics ()
X{
X struct test *tp;
X
X ENTER ("statistics");
X if (sflag) {
X for (tp = tests; tp -> name != NULL; tp++) {
X printf ("%s:\tmaximum relative error %le\n",
X tp -> name, tp -> max_err);
X }
X }
X LEAVE ();
X}
END_OF_tests/cc2c.c
if test 11225 -ne `wc -c <tests/cc2c.c`; then
echo shar: \"tests/cc2c.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 6 \(of 6\).
cp /dev/null ark6isdone
MISSING=""
for I in 1 2 3 4 5 6 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 6 archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
--
= Drug tests; just say *NO*! (Moto just announced new drug testing program) =
= Fred Fish Motorola Computer Division, 3013 S 52nd St, Tempe, Az 85282 USA =
= seismo!noao!mcdsun!fnf (602) 438-5976 =