programs.shar

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

X    }
X}
X
X/*
X * Function: Factorial
X * Usage: f = Factorial(n);
X * ------------------------
X * This function returns the factorial of n, which is defined
X * as the product of all integers from 1 up to n.
X */
X
Xint Factorial(int n)
X{
X    int product, i;
X
X    product = 1;
X    for (i = 1; i <= n; i++) {
X        product *= i;
X    }
X    return (product);
X}
END_OF_FILE
if test 970 -ne `wc -c <'programs/05-Functions/fact.c'`; then
    echo shar: \"'programs/05-Functions/fact.c'\" unpacked with wrong size!
fi
# end of 'programs/05-Functions/fact.c'
fi
if test -f 'programs/05-Functions/gameloop.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'programs/05-Functions/gameloop.c'\"
else
echo shar: Extracting \"'programs/05-Functions/gameloop.c'\" \(711 characters\)
sed "s/^X//" >'programs/05-Functions/gameloop.c' <<'END_OF_FILE'
X/*
X * File: gameloop.c
X * ----------------
X * This program is used as an illustration of the
X * StringEqual function.
X */
X
X#include <stdio.h>
X#include "genlib.h"
X#include "simpio.h"
X#include "strlib.h"
X
X/* Function prototypes */
X
Xvoid PlayOneGame(void);
X
X/* Main program */
X
Xmain()
X{
X    string answer;
X
X    while (TRUE) {
X        PlayOneGame();
X        printf("Would you like to play again? ");
X        answer = GetLine();
X        if (StringEqual(answer, "no")) break;
X    }
X}
X
X/*
X * Function: PlayOneGame
X * Usage: PlayOneGame();
X * ---------------------
X * This is a dummy function that could be replaced by
X * any game-playing program.
X */
X
Xvoid PlayOneGame()
X{
X    printf(". . . play the game . . .\n");
X}
END_OF_FILE
if test 711 -ne `wc -c <'programs/05-Functions/gameloop.c'`; then
    echo shar: \"'programs/05-Functions/gameloop.c'\" unpacked with wrong size!
fi
# end of 'programs/05-Functions/gameloop.c'
fi
if test -f 'programs/05-Functions/iseven.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'programs/05-Functions/iseven.c'\"
else
echo shar: Extracting \"'programs/05-Functions/iseven.c'\" \(656 characters\)
sed "s/^X//" >'programs/05-Functions/iseven.c' <<'END_OF_FILE'
X/*
X * File: iseven.c
X * --------------
X * This program prints a list of the even numbers between
X * 1 and 10.  In an ideal implementation, constants would
X * be used for the limits, but this program is designed to
X * match the program example in the text.
X */
X
X#include <stdio.h>
X#include "genlib.h"
X
X/* Function prototypes */
X
Xbool IsEven(int n);
X
X/* Main program */
X
Xmain()
X{
X    int i;
X
X    for (i = 1; i <= 10; i++) {
X        if (IsEven(i)) printf("%2d\n", i);
X    }
X}
X
X/*
X * Function: IsEven
X * Usage: if (IsEven(n)) . . .
X * ---------------------------
X * This function returns TRUE if n is even.
X */
X
Xbool IsEven(int n)
X{
X    return (n % 2 == 0);
X}
END_OF_FILE
if test 656 -ne `wc -c <'programs/05-Functions/iseven.c'`; then
    echo shar: \"'programs/05-Functions/iseven.c'\" unpacked with wrong size!
fi
# end of 'programs/05-Functions/iseven.c'
fi
if test -f 'programs/06-Algorithms/Makefile' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'programs/06-Algorithms/Makefile'\"
else
echo shar: Extracting \"'programs/06-Algorithms/Makefile'\" \(1765 characters\)
sed "s/^X//" >'programs/06-Algorithms/Makefile' <<'END_OF_FILE'
X# Makefile for cbook/06-Algorithms/programs
X# Created by the ExportAll facility
X# ***************************************************************
X
XPROGRAMS = \
X    primes1 \
X    primes2 \
X    primes3 \
X    gcd \
X    euclid \
X    nsqrt \
X    zeno \
X    tsqrt 
X
X# ***************************************************************
X# Parameters to control Makefile operation
X# Note that the gccx command script must be defined
X
XCC = gccx
XCFLAGS = 
X
X# ***************************************************************
X# Entry to bring the package up to date
X
Xall: $(PROGRAMS)
X
X# ***************************************************************
X# Standard entries to remove files from the directories
X#    tidy    -- eliminate unwanted files
X#    scratch -- delete derived files in preparation for rebuild
X
Xtidy:
X	rm -f ,* .,* *~ core a.out graphics.ps
X
Xscratch: tidy
X	rm -f *.o *.a $(PROGRAMS)
X
X# ***************************************************************
X# C compilations
X
Xprimes1.o: primes1.c
X	$(CC) $(CFLAGS) -c primes1.c
X
Xprimes2.o: primes2.c
X	$(CC) $(CFLAGS) -c primes2.c
X
Xprimes3.o: primes3.c
X	$(CC) $(CFLAGS) -c primes3.c
X
Xgcd.o: gcd.c
X	$(CC) $(CFLAGS) -c gcd.c
X
Xeuclid.o: euclid.c
X	$(CC) $(CFLAGS) -c euclid.c
X
Xnsqrt.o: nsqrt.c
X	$(CC) $(CFLAGS) -c nsqrt.c
X
Xzeno.o: zeno.c
X	$(CC) $(CFLAGS) -c zeno.c
X
Xtsqrt.o: tsqrt.c
X	$(CC) $(CFLAGS) -c tsqrt.c
X
X
Xprimes1: primes1.o
X	$(CC) $(CFLAGS) -o primes1 primes1.o
X
Xprimes2: primes2.o
X	$(CC) $(CFLAGS) -o primes2 primes2.o
X
Xprimes3: primes3.o
X	$(CC) $(CFLAGS) -o primes3 primes3.o
X
Xgcd: gcd.o
X	$(CC) $(CFLAGS) -o gcd gcd.o
X
Xeuclid: euclid.o
X	$(CC) $(CFLAGS) -o euclid euclid.o
X
Xnsqrt: nsqrt.o
X	$(CC) $(CFLAGS) -o nsqrt nsqrt.o
X
Xzeno: zeno.o
X	$(CC) $(CFLAGS) -o zeno zeno.o
X
Xtsqrt: tsqrt.o
X	$(CC) $(CFLAGS) -o tsqrt tsqrt.o
END_OF_FILE
if test 1765 -ne `wc -c <'programs/06-Algorithms/Makefile'`; then
    echo shar: \"'programs/06-Algorithms/Makefile'\" unpacked with wrong size!
fi
# end of 'programs/06-Algorithms/Makefile'
fi
if test -f 'programs/06-Algorithms/euclid.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'programs/06-Algorithms/euclid.c'\"
else
echo shar: Extracting \"'programs/06-Algorithms/euclid.c'\" \(938 characters\)
sed "s/^X//" >'programs/06-Algorithms/euclid.c' <<'END_OF_FILE'
X/*
X * File: euclid.c
X * --------------
X * This program computes a greates common divisor using
X * Euclid's algorithm.
X */
X
X#include <stdio.h>
X#include "genlib.h"
X#include "simpio.h"
X
X/* Function prototypes */
X
Xint GCD(int x, int y);
X
X/* Main program */
X
Xmain()
X{
X    int x, y;
X
X    printf("This program calculates greatest common divisors.\n");
X    printf("Enter two integers, x and y.\n");
X    printf("x = ? ");
X    x = GetInteger();
X    printf("y = ? ");
X    y = GetInteger();
X    printf("The gcd of %d and %d is %d.\n", x, y, GCD(x, y));
X}
X
X/*
X * Function: GCD
X * Usage: gcd = GCD(x, y);
X * -----------------------
X * Returns the greatest common divisor of x and y,
X * calculated by Euclid's algorithm, which is discussed
X * as Proposition 7 in Book II of Euclid's Elements.
X */
X
Xint GCD(int x, int y)
X{
X    int r;
X
X    while (TRUE) {
X        r = x % y;
X        if (r == 0) break;
X        x = y;
X        y = r;
X    }
X    return (y);
X}
END_OF_FILE
if test 938 -ne `wc -c <'programs/06-Algorithms/euclid.c'`; then
    echo shar: \"'programs/06-Algorithms/euclid.c'\" unpacked with wrong size!
fi
# end of 'programs/06-Algorithms/euclid.c'
fi
if test -f 'programs/06-Algorithms/gcd.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'programs/06-Algorithms/gcd.c'\"
else
echo shar: Extracting \"'programs/06-Algorithms/gcd.c'\" \(870 characters\)
sed "s/^X//" >'programs/06-Algorithms/gcd.c' <<'END_OF_FILE'
X/*
X * File: gcd.c
X * -----------
X * This program computes a greatest common divisor using
X * a brute-force algorithm.
X */
X
X#include <stdio.h>
X#include "genlib.h"
X#include "simpio.h"
X
X/* Function prototypes */
X
Xint GCD(int x, int y);
X
X/* Main program */
X
Xmain()
X{
X    int x, y;
X
X    printf("This program calculates greatest common divisors.\n");
X    printf("Enter two integers, x and y.\n");
X    printf("x = ? ");
X    x = GetInteger();
X    printf("y = ? ");
X    y = GetInteger();
X    printf("The gcd of %d and %d is %d.\n", x, y, GCD(x, y));
X}
X
X/*
X * Function: GCD
X * Usage: gcd = GCD(x, y);
X * -----------------------
X * Returns the greatest common divisor of x and y,
X * calculated by the brute-force method of testing
X * every possibility.
X */
X
Xint GCD(int x, int y)
X{
X    int g;
X
X    g = x;
X    while (x % g != 0 || y % g != 0) {
X        g--;
X    }
X    return (g);
X}
END_OF_FILE
if test 870 -ne `wc -c <'programs/06-Algorithms/gcd.c'`; then
    echo shar: \"'programs/06-Algorithms/gcd.c'\" unpacked with wrong size!
fi
# end of 'programs/06-Algorithms/gcd.c'
fi
if test -f 'programs/06-Algorithms/nsqrt.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'programs/06-Algorithms/nsqrt.c'\"
else
echo shar: Extracting \"'programs/06-Algorithms/nsqrt.c'\" \(2633 characters\)
sed "s/^X//" >'programs/06-Algorithms/nsqrt.c' <<'END_OF_FILE'
X/*
X * File: nsqrt.c
X * -------------
X * This program calculates square roots using Newton's
X * method for successive approximation.
X */
X
X#include <stdio.h>
X#include <math.h>
X#include "genlib.h"
X
X/*
X * Constants:
X * ----------
X * Epsilon -- The acceptable fraction of difference between
X *            two values that are approximately equal.
X */
X
X#define Epsilon 0.0000000001
X
X/* Function prototypes */
X
Xvoid TestSqrt(double x);
Xdouble Sqrt(double x);
Xbool ApproximatelyEqual(double x, double y);
Xdouble MinF(double x, double y);
X
X/* Main program */
X
Xmain()
X{
X    TestSqrt(0.0);
X    TestSqrt(0.25);
X    TestSqrt(1);
X    TestSqrt(2);
X    TestSqrt(3);
X    TestSqrt(4);
X    TestSqrt(49);
X    TestSqrt(200);
X    TestSqrt(1.0E10);
X}
X
X/*
X * Function: TestSqrt
X * Usage: TestSqrt(x);
X * -------------------
X * Generates a line of the test table.
X */
X
Xvoid TestSqrt(double x)
X{
X    double computed, actual;
X
X    computed = Sqrt(x);
X    actual = sqrt(x);
X    printf("Sqrt(%g) = %g  sqrt(%g) = %g\n", x, computed, x, actual);
X    if (!ApproximatelyEqual(computed, actual)) {
X        printf("Warning! Computed value does not match actual!\n");
X    }
X}
X
X/*
X * Function: Sqrt
X * Usage: root = Sqrt(x);
X * ----------------------
X * Returns the square root of x, calculated using
X * Newton's algorithm, as described in the text.
X */
X
Xdouble Sqrt(double x)
X{
X    double g;
X
X    if (x == 0) return (0);
X    if (x < 0) Error("Sqrt called with negative argument %g", x);
X    g = x;
X    while (!ApproximatelyEqual(x, g * g)) {
X        g = (g + x / g) / 2;
X    }
X    return (g);
X}
X
X/*
X * Function: ApproximatelyEqual
X * Usage: if (ApproximatelyEqual(x, y)) . . .
X * ------------------------------------------
X * Returns TRUE if x and y are approximately equal, as
X * indicated by the formula:
X *
X *       | x - y |
X *     -------------  <  Epsilon
X *     min(|x|, |y|)
X *
X * To avoid the possibility of division by 0, the function
X * first tests to make sure that adding the denominator to
X * the numerator of this fraction changes the nominator.
X * This test has the same p