standard.shar

书名:C语言科学与艺术,以前交钱下载的

X * provided by the <stdlib.h> library and requires an
X * integer argument.  The time function is provided
X * by <time.h>.
X */
X
Xvoid Randomize(void)
X{
X    srand((int) time(NULL));
X}
X
X/*
X * Function: RandomInteger
X * -----------------------
X * This function first obtains a random integer in
X * the range [0..RAND_MAX] by applying four steps:
X * (1) Generate a real number between 0 and 1.
X * (2) Scale it to the appropriate range size.
X * (3) Truncate the value to an integer.
X * (4) Translate it to the appropriate starting point.
X */
X
Xint RandomInteger(int low, int high)
X{
X    int k;
X    double d;
X
X    d = (double) rand() / ((double) RAND_MAX + 1);
X    k = (int) (d * (high - low + 1));
X    return (low + k);
X}
X
X/*
X * Function: RandomReal
X * --------------------
X * The implementation of RandomReal is similar to that
X * of RandomInteger, without the truncation step.
X */
X
Xdouble RandomReal(double low, double high)
X{
X    double d;
X
X    d = (double) rand() / ((double) RAND_MAX + 1);
X    return (low + d * (high - low));
X}
X
X/*
X * Function: RandomChance
X * ----------------------
X * This function uses RandomReal to generate a number
X * between 0 and 100, which it then compares to p.
X */
X
Xbool RandomChance(double p)
X{
X    return (RandomReal(0, 1) < p);
X}
END_OF_FILE
if test 1718 -ne `wc -c <'cslib/random.c'`; then
    echo shar: \"'cslib/random.c'\" unpacked with wrong size!
fi
# end of 'cslib/random.c'
fi
if test -f 'cslib/random.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/random.h'\"
else
echo shar: Extracting \"'cslib/random.h'\" \(1962 characters\)
sed "s/^X//" >'cslib/random.h' <<'END_OF_FILE'
X/*
X * File: random.h
X * Version: 1.0
X * Last modified on Fri Jul 22 16:44:36 1994 by eroberts
X * -----------------------------------------------------
X * This interface provides several functions for generating
X * pseudo-random numbers.
X */
X
X#ifndef _random_h
X#define _random_h
X
X#include "genlib.h"
X#include <stdlib.h>
X
X/*
X * Constant: RAND_MAX
X * ------------------
X * Unfortunately, several libraries that supposedly conform to
X * the ANSI standard do not define RAND_MAX in <stdlib.h>.  To
X * reduce portability problems, this interface defines RAND_MAX
X * to be the largest positive integer if it is undefined.
X */
X
X#ifndef RAND_MAX
X#  define RAND_MAX ((int) ((unsigned) ~0 >> 1))
X#endif
X
X/*
X * Function: Randomize
X * Usage: Randomize();
X * -------------------
X * This function sets the random seed so that the random sequence
X * is unpredictable.  During the debugging phase, it is best not
X * to call this function, so that program behavior is repeatable.
X */
X
Xvoid Randomize(void);
X
X/*
X * Function: RandomInteger
X * Usage: n = RandomInteger(low, high);
X * ------------------------------------
X * This function returns a random integer in the range low to high,
X * inclusive.
X */
X
Xint RandomInteger(int low, int high);
X
X/*
X * Function: RandomReal
X * Usage: d = RandomReal(low, high);
X * ---------------------------------
X * This function returns a random real number in the half-open
X * interval [low .. high), meaning that the result is always
X * greater than or equal to low but strictly less than high.
X */
X
Xdouble RandomReal(double low, double high);
X
X/*
X * Function: RandomChance
X * Usage: if (RandomChance(p)) . . .
X * ---------------------------------
X * The RandomChance function returns TRUE with the probability
X * indicated by p, which should be a floating-point number between
X * 0 (meaning never) and 1 (meaning always).  For example, calling
X * RandomChance(.30) returns TRUE 30 percent of the time.
X */
X
Xbool RandomChance(double p);
X
X#endif
END_OF_FILE
if test 1962 -ne `wc -c <'cslib/random.h'`; then
    echo shar: \"'cslib/random.h'\" unpacked with wrong size!
fi
# end of 'cslib/random.h'
fi
if test -f 'cslib/simpio.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/simpio.c'\"
else
echo shar: Extracting \"'cslib/simpio.c'\" \(3581 characters\)
sed "s/^X//" >'cslib/simpio.c' <<'END_OF_FILE'
X/*
X * File: simpio.c
X * Version: 1.0
X * Last modified on Fri Jul 15 14:10:41 1994 by eroberts
X * -----------------------------------------------------
X * This file implements the simpio.h interface.
X */
X
X#include <stdio.h>
X#include <string.h>
X
X#include "genlib.h"
X#include "strlib.h"
X#include "simpio.h"
X
X/*
X * Constants:
X * ----------
X * InitialBufferSize -- Initial buffer size for ReadLine
X */
X
X#define InitialBufferSize 120
X
X/* Exported entries */
X
X/*
X * Functions: GetInteger, GetLong, GetReal
X * ---------------------------------------
X * These functions first read a line and then call sscanf to
X * translate the number.  Reading an entire line is essential to
X * good error recovery, because the characters after the point of
X * error would otherwise remain in the input buffer and confuse
X * subsequent input operations.  The sscanf line allows white space
X * before and after the number but no other extraneous characters.
X */
X
Xint GetInteger(void)
X{
X    string line;
X    int value;
X    char termch;
X
X    while (TRUE) {
X        line = GetLine();
X        switch (sscanf(line, " %d %c", &value, &termch)) {
X          case 1:
X            FreeBlock(line);
X            return (value);
X          case 2:
X            printf("Unexpected character: '%c'\n", termch);
X            break;
X          default:
X            printf("Please enter an integer\n");
X            break;
X        }
X        FreeBlock(line);
X        printf("Retry: ");
X    }
X}
X
Xlong GetLong(void)
X{
X    string line;
X    long value;
X    char termch;
X
X    while (TRUE) {
X        line = GetLine();
X        switch (sscanf(line, " %ld %c", &value, &termch)) {
X          case 1:
X            FreeBlock(line);
X            return (value);
X          case 2:
X            printf("Unexpected character: '%c'\n", termch);
X            break;
X          default:
X            printf("Please enter an integer\n");
X            break;
X        }
X        FreeBlock(line);
X        printf("Retry: ");
X    }
X}
X
Xdouble GetReal(void)
X{
X    string line;
X    double value;
X    char termch;
X
X    while (TRUE) {
X        line = GetLine();
X        switch (sscanf(line, " %lf %c", &value, &termch)) {
X          case 1:
X            FreeBlock(line);
X            return (value);
X          case 2:
X            printf("Unexpected character: '%c'\n", termch);
X            break;
X          default:
X            printf("Please enter a real number\n");
X            break;
X        }
X        FreeBlock(line);
X        printf("Retry: ");
X    }
X}
X
X/*
X * Function: GetLine
X * -----------------
X * This function is a simple wrapper; all the work is done by
X * ReadLine.
X */
X
Xstring GetLine(void)
X{
X    return (ReadLine(stdin));
X}
X
X/*
X * Function: ReadLine
X * ------------------
X * This function operates by reading characters from the file
X * into a dynamically allocated buffer.  If the buffer becomes
X * full before the end of the line is reached, a new buffer
X * twice the size of the previous one is allocated.
X */
X
Xstring ReadLine(FILE *infile)
X{
X    string line, nline;
X    int n, ch, size;
X
X    n = 0;
X    size = InitialBufferSize;
X    line = GetBlock(size + 1);
X    while ((ch = getc(infile)) != '\n' && ch != EOF) {
X        if (n == size) {
X            size *= 2;
X            nline = (string) GetBlock(size + 1);
X            strncpy(nline, line, n);
X            FreeBlock(line);
X            line = nline;
X        }
X        line[n++] = ch;
X    }
X    if (n == 0 && ch == EOF) {
X        FreeBlock(line);
X        return (NULL);
X    }
X    line[n] = '\0';
X    nline = (string) GetBlock(n + 1);
X    strcpy(nline, line);
X    FreeBlock(line);
X    return (nline);
X}
END_OF_FILE
if test 3581 -ne `wc -c <'cslib/simpio.c'`; then
    echo shar: \"'cslib/simpio.c'\" unpacked with wrong size!
fi
# end of 'cslib/simpio.c'
fi
if test -f 'cslib/simpio.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/simpio.h'\"
else
echo shar: Extracting \"'cslib/simpio.h'\" \(2008 characters\)
sed "s/^X//" >'cslib/simpio.h' <<'END_OF_FILE'
X/*
X * File: simpio.h
X * Version: 1.0
X * Last modified on Wed Apr 27 07:29:13 1994 by eroberts
X * -----------------------------------------------------
X * This interface provides access to a simple package of
X * functions that simplify the reading of input data.
X */
X
X#ifndef _simpio_h
X#define _simpio_h
X
X#include "genlib.h"
X
X/*
X * Function: GetInteger
X * Usage: i = GetInteger();
X * ------------------------
X * GetInteger reads a line of text from standard input and scans
X * it as an integer.  The integer value is returned.  If an
X * integer cannot be scanned or if more characters follow the
X * number, the user is given a chance to retry.
X */
X
Xint GetInteger(void);
X
X/*
X * Function: GetLong
X * Usage: l = GetLong();
X * ---------------------
X * GetLong reads a line of text from standard input and scans
X * it as a long integer.  The value is returned as a long.
X * If an integer cannot be scanned or if more characters follow
X * the number, the user is given a chance to retry.
X */
X
Xlong GetLong(void);
X
X/*
X * Function: GetReal
X * Usage: x = GetReal();
X * ---------------------
X * GetReal reads a line of text from standard input and scans
X * it as a double.  If the number cannot be scanned or if extra
X * characters follow after the number ends, the user is given
X * a chance to reenter the value.
X */
X
Xdouble GetReal(void);
X
X/*
X * Function: GetLine
X * Usage: s = GetLine();
X * ---------------------
X * GetLine reads a line of text from standard input and returns
X * the line as a string.  The newline character that terminates
X * the input is not stored as part of the string.
X */
X
Xstring GetLine(void);
X
X/*
X * Function: ReadLine
X * Usage: s = ReadLine(infile);
X * ----------------------------
X * ReadLine reads a line of text from the input file and
X * returns the line as a string.  The newline character
X * that terminates the input is not stored as part of the
X * string.  The ReadLine function returns NULL if infile
X * is at the end-of-file position.
X */
X
Xstring ReadLine(FILE *infile);
X
X#endif
END_OF_FILE
if test 2008 -ne `wc -c <'cslib/simpio.h'`; then
    echo shar: \"'cslib/simpio.h'\" unpacked with wrong size!
fi
# end of 'cslib/simpio.h'
fi
if test -f 'cslib/strlib.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/strlib.c'\"
else
echo shar: Extracting \"'cslib/strlib.c'\" \(5382 characters\)
sed "s/^X//" >'cslib/strlib.c' <<'END_OF_FILE'
X/*
X * File: strlib.c
X * Version: 1.0
X * Last modified on Fri Jul 15 14:10:41 1994 by eroberts
X * -----------------------------------------------------
X * This file implements the strlib.h interface.
X */
X
X/*
X * General implementation notes:
X * -----------------------------
X * This module implements the strlib library by mapping all
X * functions into the appropriate calls to the ANSI <string.h>
X * interface.  The implementations of the individual functions
X * are all quite simple and do not require individual comments.
X * For descriptions of the behavior of each function, see the
X * interface.
X */
X
X#include <stdio.h>
X#include <string.h>
X#include <ctype.h>
X
X#include "genlib.h"
X#include "strlib.h"
X
X/*
X * Constant: MaxDigits
X * -------------------
X * This constant must be larger than the maximum
X * number of digits that can appear in a number.
X */
X
X#define MaxDigits 30
X
X/* Private function prototypes */
X
Xstatic string CreateString(int len);
X
X/* Section 1 -- Basic string operations */
X
Xstring Concat(string s1, string s2)
X{
X    string s;