Numerical Analysis

Algorithms in C

Version 4.2

 

 

 

 

 

 

 

 

 

 

User's Manual

For

"Numerical Analysis", fourth edition

Richard L. Burden and J. Douglas Faires

1988

 

 

 

 

 

Written by:

Harold A. Toomey, MSEE

Care-Free Software

3rd Quarter 1991

 

 

 

Technical Publications:

Harold A. Toomey

 

Programming:

Harold A. Toomey

 

 

© Copyright 1988-1993, Harold A. Toomey - All rights reserved

 

This document contains proprietary information of Harold A. Toomey and is protected by Federal copyright law.  The information may not be disclosed to third parties or copied or duplicated in any form, in whole or in part, without prior written consent of Harold A. Toomey.  Limited rights exist for individual and university site licenses.  The software may be used or copied only in accordance with the terms of the license agreement.  Students may copy this software with the intent to join the $20.00 Club, paying for the right to use this software.  See the sample license agreements in this document.

 

The information in this document is subject to change without notice.

 

 

"Numerical Analysis Algorithms in C" User's Manual

Version 4.2

Document Number 9307-42C-UM2

 

 

Care-Free Software

Attn: Harold Allen Toomey

1376 N. 1100 E.

American Fork, UT  84003

1-801-492-1526

 

 

IBM is a trademark of International Business Machines Corporation.

Microsoft and MS-DOS are registered trademarks.

UNIX is a registered trademark of AT&T Bell Laboratories.

VAX and VMS are registered trademarks of Digital Equipment Corporation.

 


This collection of C programs is dedicated to my wife, Holly and to my son, David.  They gave me the privacy I needed to program, and they listened attentively, sharing my enthusiasm, whenever I expounded on what I had programmed—even though they hadn't the foggiest idea what I was talking about.


 

 

 

PREFACE

 

 

About the Author

 

Harold A. Toomey, M.S. in Electrical and Computer Engineering, is currently a Software Engineer for Novell in Provo, Utah.  While minoring in mathematics at Brigham Young University, he tutored students in calculus, then tutored C programming at BYU's Electrical Engineering Department.  Not content with the provided FORTRAN algorithms while taking several numerical methods courses, he began coding numerical algorithms in C.  The introductory text used for these numerical analysis courses was "Numerical Analysis."

 

 

History of "Numerical Analysis Algorithms in C"

 

BYU's mathematics department expressed an interest in having all of the algorithms found in the "Numerical Analysis" text programmed in C, along with a few of their favorites still in FORTRAN.  Version 3.0 was finally completed in December 1988.  BYU was the first university to purchase a university site license.  This software is being used for their numerical methods courses today and has been tested by hundreds of students.  Their input has resulted in several other versions, culminating into version 4.2.  Version 4.0 became necessary for the fourth edition of the "Numerical Analysis" text.  Since 1988, several universities and scores of students have purchased these programs to be used in college course work and on the job.  See the file "revhist.doc" (for revision history) for a complete overview of the history of "Numerical Analysis Algorithms in C."

 

 

Acknowledgements

 

The author would like to express his appreciation to the many individuals who made suggestions for improvement on the previous versions of these algorithms.  These include the professor who gave directions for the first version: G. S. Gill, Brigham Young University (also a reviewer for the third edition of the text), and Bruce Cardwell who supervises the Numerical Analysis Laboratory also at Brigham Young University.  Special thanks also go to Jay Lawlor, M.S. Electrical Engineering, for giving timely feedback while using the algorithms for a numerical methods class at BYU.  In particular, thanks also goes to Holly Z. Toomey for typesetting previous versions of the Examples Book.

 


 

 

 

CONTENTS

 

PREFACE                ‑iv‑

 

1.    Introduction     1‑1

1.1     Getting Started         1‑1

1.2     Purpose of the Programs    1‑2

1.3     For Instructors          1‑2

1.3.1       "Numerical Analysis" Authors' Recommendations           1‑2

1.3.2       Homework Helpers            1‑2

1.3.3       Modifying Programs           1‑3

1.3.4       Intentionally Introducing Errors      1‑3

1.4     Product Support       1‑3

 

2.    Installation       2‑1

2.1     Basic Installation Procedures          2‑1

2.2     Uploading to Mainframe Computers            2‑2

 

3.    "Numerical Analysis Algorithms in C" Files     3‑1

3.1     Algorithm Files         3‑1

3.3     Supporting C Source Code              3‑5

3.4     Documentation Files            3‑6

3.5     Utility Files    3‑6

3.6     Batch, Script and Command Files              3‑7

3.7     File Structure Chart              3‑8

3.8     File Name Translation Table from 3rd to 4th Edition           3‑8

3.9     4th Edition Differences         3‑9

 

4.    Step-By-Step Examples on Various Computers         4‑1

4.1     Need List      4‑1

4.2     Customizing Naautil.c          4‑1

4.3     Example Using MS-DOS, Microsoft C and the P-Edit Editor          4‑2

4.4     Example Using UNIX, cc and the vi Editor   4‑5

4.5     Example Using a Macintosh and THINK C              4‑8

4.6     Example Using VAX/VMS, CC and the EDIT/EDT Editor    4‑12

 

5.    For Those New to C        5‑1

5.1     Mathematical Operators      5‑1

5.2     Mathematical Functions       5‑2

5.3     General Language Hints      5‑5

5.4     Language Transition Kit       5‑6

 

6.    Helps and Hints   6‑1

6.1     Generally Nice To Know      6‑1

6.1.1       Professor's Favorites, Must Have, Algorithms      6‑1

6.1.2       Homework Helper Algorithms        6‑1

6.1.3       Optional Title          6‑1

6.1.4       Optional File Saving           6‑2

6.1.5       Finding Functions              6‑2

6.1.6       Using Default Inputs          6‑2

6.1.7       Changing Arithmetic Precision      6‑2

6.1.8       Using Floating-Point Numbers in Functions          6‑3

6.1.9       The Pow() Function           6‑4

6.1.10     Implementing SIG-Digit Rounding/Truncation       6‑4

6.1.11     Floating-Point Output Alignment    6‑5

6.2     Converting Programs into Functions           6‑5

6.2.1       An Example Using Simpson's Rule          6‑7

6.3     Using Input Files (*.IN)         6‑8

6.4     Using Output Files (*.OUT)              6‑10

6.5     Explanation of the Naautil.c File       6‑10

6.5.1       #Define Flags        6‑10

6.5.2       Flag Default Settings         6‑11

6.5.3       Description of the Routines           6‑12

6.6     Using Naautil.c as Object Code       6‑14

6.6.1       MS-DOS    6‑15

6.6.2       UNIX           6‑15

6.6.3       Macintosh              6‑15

6.6.4       VAX/VMS    6‑16

6.7     Supporting C Source Code Usage List       6‑16

6.8     "Numerical Analysis" Text Errors and Corrections              6‑17

6.8.1       3rd Edition Errors              6‑17

6.8.2       4th Edition Errors   6‑18

6.9     Watch for These Run-Time Errors              6‑20

6.9.1       Stack Space          6‑20

6.9.2       Division By Zero     6‑20

6.9.3       Null Pointer Assignments              6‑20

6.9.4       No Disk Space       6‑21

6.9.5       Floating-Point Accuracy    6‑21

6.9.6       Program Stuck in an Infinite Loop             6‑21

 

7.    Useful Utilities     7‑1

7.1     Convert.c - Converting Files from Extended ASCII to Standard ASCII        7‑1

7.1.1       Why Convert.c is Needed             7‑1

7.1.2       How to Use Convert.c       7‑2

7.2     List.com - A Better TYPE Command          7‑3

7.3     Time-Saving Batch, Script and Command Files     7‑3

7.3.1       CC.BAT     7‑3

7.3.2       CCC           7‑5

7.3.3       VAXCC.COM         7‑6

 

8.    The Equation Evaluator Routines        8‑1

8.1     What the Routines Do         8‑1

8.2     How to Insert the Routines into a Program              8‑1

8.3     An Example Using Simpson's Rule             8‑2

8.4     Using Eqeval.c As Pre-Compiled Object Code       8‑2

8.5     Valid Math Operators and Functions           8‑3

8.6     Sample Equations    8‑4

8.7     Possible Error Messages    8‑4

8.8     List of Algorithms Using the Equation Evaluator Routines              8‑5

8.9     Limitations    8‑6

8.10   Trade-Offs    8‑6

 

9.    Portability        9‑1

9.1     C vs ANSI C             9‑2

9.2     IBM PCs and MS-DOS        9‑3

9.3     UNIX Workstations   9‑3

9.4     Macintosh Computers          9‑4

9.5     VAX Mainframes       9‑5

9.6     Tested Compilers    9‑5

 

10.  Sample License Agreements     10‑1

10.1   Individual License Sample   10‑1

10.2   University/Corporation Site License Sample           10‑3

 

11.  Packaging Information    11‑1

11.1   MS-DOS Diskettes              11‑1

11.1.1     5¼" 1.2M High Density Diskettes              11‑1

11.1.2     5¼" 360K Low Density Diskettes              11‑2

11.1.3     3½" 1.44M High Density Diskettes            11‑2

11.1.4     3½" 720K Low Density Diskettes              11‑2

11.2   Macintosh Diskettes             11‑2

11.2.1     3½" 800K Macintosh Diskettes     11‑3

 

12.  Purchasing Information              12‑1

12.1   $20.00 Club              12‑1

12.2   Order Form              12‑1

 

References             12‑2

 

Appendix A:           C Source Code for 041.C           A‑1

 

Appendix B:          C Source Code for NAAUTIL.C             B‑1

 

Appendix C:          Language Comparison Charts              C‑1

C.1    C vs Ada       C‑2

C.2    C vs BASIC              C‑8

C.3    C vs C++      C‑13

C.4    C vs FORTRAN 77              C‑14

C.5    C vs Pascal              C‑20

 

Appendix D:          Sample Programs in Other Languages            D‑1

D.1    Ada          D‑2

D.1.1      SIMPSON.ADA      D‑2

D.1.2      NAAUTIL.ADA        D‑4

D.1.3      SIMPSON.IN          D‑6

D.1.4      SIMPSON.OUT      D‑6

D.2    BASIC      D‑7

D.2.1      SIMPSON.BAS      D‑7

D.2.2      SIMPSON.IN          D‑8

D.2.3      SIMPSON.OUT      D‑9

D.3    C              D‑10

D.3.1      SIMPSON.C           D‑10

D.3.2      NAAUTIL.H             D‑11

D.3.3      SIMPSON.IN          D‑14

D.3.4      SIMPSON.OUT      D‑14

D.4    C++         D‑15

D.4.1      SIMPSON.CPP      D‑15

D.4.2      NAAUTIL.HPP        D‑16

D.4.3      SIMPSON.IN          D‑18

D.4.4      SIMPSON.OUT      D‑18

D.5    FORTRAN 77           D‑19

D.5.1      SIMPSON.FOR     D‑19

D.5.2      SIMPSON.IN          D‑21

D.5.3      SIMPSON.OUT      D‑21

D.6    Pascal     D‑22

D.6.1      SIMPSON.PAS      D‑22

D.6.2      NAAUTIL.INC         D‑24

D.6.3      NAAMATH.INC       D‑25

D.6.4      SIMPSON.IN          D‑25

D.6.5      SIMPSON.OUT      D‑25

 

 



 

 

 

1.  Introduction

 

 

"Numerical Analysis Algorithms in C" contains 116 stand-alone programs implementing the algorithms found in the texts:

 

"Numerical Analysis", third and fourth edition,

Richard L. Burden & J. Douglas Faires, 1988.

 

Each program is written in ANSI C to make them more portable to other computer systems.  They should run on any computer with a reasonable C compiler, such as IBM PCs, UNIX workstations, VAXes, and Macintoshes.

 

The "Numerical Analysis" text, hereafter referred to as "the text", covers the following numerical topics:

 

          Chapter 1   - Mathematical Preliminaries

          Chapter 2   - Solutions of equations in one variable

          Chapter 3   - Interpolation and polynomial approximation

          Chapter 4   - Numerical differentiation and integration

          Chapter 5   - Initial-value problems for ordinary differential equations

          Chapter 6   - Direct methods for solving linear systems

          Chapter 7   - Iterative techniques in matrix algebra

          Chapter 8   - Approximation theory

          Chapter 9   - Approximating eigenvalues

          Chapter 10 - Numerical solutions of nonlinear systems of equations

          Chapter 11 - Boundary-value problems for ordinary differential equations

          Chapter 12 - Numerical solutions to partial differential equations

 

From these topics, "Numerical Analysis Algorithms in C" has programmed routines for: vector and matrix manipulation, linear equations (LU decomposition/backsolving, matrix inversion, etc.), matrix/vector norms, eigenvalue/vectors, complex number and polynomial manipulation, least-square polynomial approximation, FFTs, numerical integration, root finding, solution of nonlinear equations, Taylor polynomial approximation, cubic splines, derivatives, ordinary and partial differentiation.

 

This User's Manual will help you to use these programs to their fullest potential.  It will walk you through an example, tutor you if you are unfamiliar with the C language, introduce you to several useful utilities, and assist you when running these programs on different computer systems.

 

 

1.1 Getting Started

 

To install "Numerical Analysis Algorithms in C" onto your computer system, see Chapter 2 - "Installation."  If you are new to the C programming language, you may wish to read through Chapter 5 - "For Those New to C."  If you want a detailed example using various C compilers and operating systems, see Chapter 4 - "Step-By-Step Examples on Various Computer Systems."

 

This software package contains about 1.5M bytes of files.  If disk space is limited, then just copy the eight supporting ".c" files ("complex.c", "eqeval.c", "gaussj.c", "naautil.c", "naautil2.c", "naautil3.c", "round.c" and "trunc.c") and the desired algorithms onto your disk.  The eight supporting files require about 100K of disk space.  If you are running these algorithms from a floppy disk, be sure to leave the write protect tab off so the programs can save their output to a file.  If this is undesirable, see Sub-Section 6.1.4 - "Optional File Saving."

 

If you feel comfortable with C, go ahead and compile and run an algorithm.  The source code is very readable and user friendly.  To see what the algorithm numbers correspond to, see Section 3.1 - "Algorithm Files."  This is the most important list in this manual and should be printed out for frequent reference.  Section 3.1 is also given in the file "readme.doc" for your convenience.

 

 

1.2 Purpose of the Programs

 

These programs are fast, but are not optimized for speed.  As stated by the authors in the text's preface:

 

"Although the algorithms will lead to correct programs for the examples and exercises in the text, it must be emphasized that there has been no attempt to write general-purpose software.  In particular, the algorithms have not always been listed in the form that leads to the most efficient program in terms of either time or storage requirements."

 

The purpose of these programs is to teach students numerical methods, not programming and optimization skills.  For a good book of general-purpose mathematical software, see the book "Numerical Recipes in C" listed in the references.  These programs can also be used as a tool for building other programs.  Once the algorithms are understood, they can be more easily enhanced for general-purpose applications.

 

 

1.3 For Instructors

 

This software package is intended to be used by instructors of numerical methods/analysis courses.  The best way to learn numerical methods is to program the algorithms from scratch and have them run on a computer.  This is a time consuming process and may take a "good" programmer from 1 to 5 hours per program.  Students can best benefit from these programs AFTER taking the appropriate numerical analysis courses.

 

 

1.3.1        "Numerical Analysis" Authors' Recommendations

 

The authors of the text "Numerical Analysis" mention in the preface that:

 

"Actual programs are not included because, in our experience, this encourages some students to generate results without fully understanding the method involved."

 

In other words, as an instructor, you may consider giving your students only selected main algorithms, and definitely not the "Homework Helpers" algorithms as discussed below.

 

 

1.3.2        Homework Helpers

 

Roughly half of the included programs are labeled as "Homework Helpers."  Most of these programs modify the given text algorithms to satisfy the homework exercises in the text.  An example of this is turning Algorithm 2.4 - Secant Method ("024.c") into the Method of False Position ("024B.c").  Use these "homework helpers" to correct homework assignments.  Do NOT just give these out to your students.  Most modifications will take only a short time to implement, once the algorithm is understood.

 

 

1.3.3        Modifying Programs

 

These algorithms are given as a learning tool.  Modifying them is part of the learning process.  These algorithms may be modified by the instructor or by the students, even though this package is copyrighted.  They may not, however, be altered to be resold for profit without prior written consent from the programmer.  See the sample licensing agreements in Chapter 10 for more details.

 

 

1.3.4        Intentionally Introducing Errors

 

As an alternative to withholding these programs from your students, you may wish to give them a copy with intentionally introduced errors.  This would cause them to search the entire program over for correctness, bridging the gap between giving too little or too much information.

 

 

1.4 Product Support

 

If questions arise, ranging from getting these algorithms to work with your compiler to adapting a particular algorithm to a specific application, just call CARE-FREE SOFTWARE at 1-801-785-0464.  The programmer will answer your questions at no charge other than the normal phone charges on your monthly phone statement.  Enhancements, recommendations and bug reports are always welcomed.



 

 

 

2.  Installation

 

 

2.1 Basic Installation Procedures

 

 

The "Numerical Analysis Algorithms in C" programs do not come with an installation program.  To install these algorithms onto your computer, do the following steps:

 

1.       Make a set of backup diskettes.  See your operating system manual for specifics.

 

2.       Make another set of "working" diskettes or copy the diskettes onto your hard disk.  All 500+ files combined require less than 1.5M bytes of disk space.  Only a couple of the files are required at a time to get the algorithms to work properly, making them useful even on systems without a hard disk.

 

3.       You may want to convert each file on the "working" disk from extended ASCII to standard ASCII.  This is usually required for Macintoshes, most UNIX computers, and VAXes.  Failure to do so may result in scrambled looking output characters.  Use "convert.exe", as explained in Section 7.1, to do this task relatively easily.  Macintosh disks ordered from Care-Free Software have had this step done already.

 

4.       It is recommended that the algorithms be placed in their own sub-directory (or Macintosh folder), such as "naa42."  This sub-directory can be created and entered by typing one of the following sets of commands:

 

          MS-DOS:

                   C:\> MD NAA42                                   - make directory

                   C:\> CD NAA42                                   - change directory

                   C:\NAA42> DIR /P                           - show directory contents

 

          UNIX:

                   % mkdir naa42                                   - make directory

                   % chdir naa42                                   - change directory

                   % pwd                                                       - show current directory

                   % ls -alF                                             - show directory contents

 

          VAX/VMS:

                   $ CREATE/DIR [SMITH.NAA42]  - make directory

                   $ SET DEFAULT [.NAA42]            - change directory

                   $ SHOW DEFAULT                                - show current directory

                   $ DIR/SIZE/DATE                              - show directory contents

 

5.       To be able to run every program from a floppy diskette, eight support files are required:

 

        complex.c      naautil.c      round.c

        eqeval.c       naautil2.c     trunc.c

        gaussj.c    naautil3.c 

 

These files require about 100K bytes of disk space.  The desired algorithm files such as "041.c" are also needed.  The majority of the algorithms need only "naautil.c" which is about 20K bytes large.

 

6.       If the programs do not compile correctly, you may need to change some flags inside the "naautil.c" file.  Use your text editor to modify this file.  The contents of "naautil.c" should be self-documenting.  These flags are defined near the top of the file.  See Section 6.5 - "Explanation of the Naautil.c File" if more detailed information is desired.

 

In the event that nothing seems to be working, you can set both the EQ_EVAL and the FILE_SAVE flags to FALSE.  This will disable the options to save the output to a file and to use the Equation Evaluator routines, but the algorithms will usually work.  These two options use variable length argument lists, which may not work on older compilers.

 

7.       If all else fails, ask another C programmer for help or call CARE-FREE SOFTWARE for free technical support.

 

 

2.2 Uploading to Mainframe Computers

 

To get these programs onto many workstations or mainframe computers, communications software is usually required.  A well-supported communications protocol is known as Kermit.  An example using Kermit looks something like this:

 

NOTE:        This example uses CALL/ProComm to transfer files onto a VAX/UNIX workstation.

 

1.       Log onto the mainframe using CALL, ProComm or your favorite communications package.  Select kermit as the transfer protocol.  Use binary mode to send files containing extended ASCII characters.  Use ASCII mode if the files have been converted to standard ASCII by the "convert.exe" program.  Binary mode is slower than ASCII mode.  Remember that C files are case sensitive.

 

2.       On the mainframe, change to an appropriate directory and type:

 

For a VAX, type:

$ use kermit                                               (Do NOT type "$ kermit")

Kermit-32> set file_type binary         (or:  set file_type ascii)

Kermit-32> receive

 

For a UNIX workstation, type:

% kermit

Kermit-32> set binary                        (or:  set ascii)

Kermit-32> receive

 

3.       On your PC, immediately issue the file sending commands.

 

For CALL, type:

[F9] File Send Kermit

File to transfer: filename

 

For ProComm, type:

[ALT] K

                   2) Send

Please enter filespec: filename

 

4.       Patiently wait as the file(s) are transferred to the mainframe.  The use of wild cards is recommended (ie - *.C instead of filename).

 

5.       Exit kermit on the mainframe.

Kermit-32> exit

$ logout

 

A host full of other issues have been left to the user, such as baud rate, parity, stop bits, duplex, use of wild cards, etc.  These are unique to each computer system and communications software package.

 

You may want to convert the files from extended ASCII to standard ASCII (using "convert.c") before uploading them to a mainframe computer.  If you plan to view and print your work on an IBM PC but compile and run the algorithms on a mainframe, you may want to keep the files in extended ASCII.

 

Test your preferences using Algorithm 4.1 ("041.c").  It uses three different extended ASCII characters to form an integral sign: '!', '#' and '"'.  "Convert.c" changes these three characters into standard ASCII: '[', '|' and ']'.



 

 

 

3.  "Numerical Analysis Algorithms in C" Files

 

 

This software package contains 116 algorithms.  Each algorithm has been coded as a stand-alone program.  Each program prompts for input, executes the algorithm as described in the text "Numerical Analysis", and prints the results.  Other math packages provide only subroutines, requiring a programmer to insert them inside a program and either hard code or prompt for the inputs and print the outputs.

 

The files are catagorized as follows, where "nnn" represent algorithm numbers like "041" for Algorithm 4.1:

 

a.       nnn.C          Algorithms from the text "Numerical Analysis" fourth edition.  (57 total)

 

b.       nnnA.C       Algorithms not found in the text.  Included as "Professor Favorites, Must Have" as recommended by mathematics professors at Brigham Young University.  (6 total)

 

c.       nnnB.C, nnnC.C, and nnnD.C

Algorithms included as "Homework Helpers."  Some are asked for in the homework exercises while others are for helping with important concepts covered in the text.  These can save hours of coding on the homework exercises.  (53 total)

 

d.       *.C              NAA supporting files containing 57 functions.  (8 total)

 

e.       *.IN              Input files used to test each algorithm.  They match the inputs to the example problems presented after each algorithm in the text.  (116 total)

 

f.        *.OUT         Output files used to test each algorithm.  They match the outputs to the example problems presented after each algorithm in the text.  (116 total)

 

g.       *.EXE                   Executable programs for each algorithm.  The default functions (like f(x)) are the same as those used in the example problems presented after each algorithm in the text.  These programs must be purchased separately and are currently available only for MS-DOS and Macintosh computers.  (116 total)

 

h.       *.DOC        Documentation in simple text file format.  Includes "readme.doc", "revhist.doc" and "usersman.doc."

 

Each program was tested on the sample problems given in the text just after the algorithm description.  These sample solutions are found in the OUT sub-directory in files named with a ".out" extension.  Their inputs are found in the IN sub-directory in files named with a ".in" extension.

 

Over two-thirds of the algorithms need to be compiled only once.  They are marked with an asterisk (*) on the table below.  Of these algorithms, nearly half are able to prompt you for an equation during run-time.  See Chapter 8 - "The Equation Evaluator Routines" for more details.

 

 

3.1 Algorithm Files

 

 

CHAPTER 1      Mathematical Preliminaries

 

COMPLEX.C     - "Numerical Recipes in C" Complex Number Routines

EQEVAL.C        - Equation Evaluator Routines

GAUSSJ.C         - "Numerical Recipes in C" Gauss-Jordan Matrix Solver

NAAUTIL.C        - "Numerical Analysis Algorithms in C" Utilities I             (standard)

NAAUTIL2.C      - "Numerical Analysis Algorithms in C" Utilities II            (extended)

NAAUTIL3.C      - "Numerical Analysis Algorithms in C" Utilities III            (complex)

ROUND.C         - Rounds a floating-point value to SIG significant digits

TRUNC.C          - Truncates a floating-point value to SIG significant digits

011B.C*             - Taylor Polynomial Approximation                                                     Algorithm 1.1B

 

 

CHAPTER 2      Solutions of Equations in One Variable

 

021.C*               -  Bisection (or Binary-Search)                                        Algorithm 2.1

022.C*               -  Fixed-Point                                                                                       Algorithm 2.2

023.C                 -  Newton-Raphson                                                                             Algorithm 2.3

024.C*               -  Secant                                                                                             Algorithm 2.4

024B.C*             -  Method of False Position (or Regula Falsi)                                     Algorithm 2.4B

024C.C              -  Modified Newton-Raphson Method                                                  Algorithm 2.4C

025.C*               -  Steffensen                                                                                       Algorithm 2.5

026.C*               -  Horner                                                                                              Algorithm 2.6

027.C*               -  Müller                                                                                               Algorithm 2.7

028A.C*             +  Complex Polynomial Solver (CPOLY)                                           Algorithm 2.8A

 

 

CHAPTER 3      Interpolation and Polynomial Approximation

 

031.C*               -  Neville's Iterated Interpolation                                                          Algorithm 3.1

031B.C*             -  Neville's Iterated Interpolation (with rounding)                                 Algorithm 3.1B

031C.C*             -  Aitken's Iterated Interpolation                                        Algorithm 3.1C

032.C*               -  Newton's Interpolatory Divided-Difference Formula    Algorithm 3.2

033.C*               -  Hermite Interpolation                                                                        Algorithm 3.3

034.C*               -  Natural Cubic Spline                                                                        Algorithm 3.4

035.C*               -  Clamped Cubic Spline                                                                    Algorithm 3.5

 

 

CHAPTER 4      Numerical Differentiation and Integration

 

040B1.C            -  1st Derivative Approximation (for functions)                                   Algorithm 4.0B1

040B2.C*           -  1st Derivative Approximation (for tabulated data)        Algorithm 4.0B2

040B3.C            -  1st Derivative Approximation (for functions w/TOL)    Algorithm 4.0B3

040C1.C            -  2nd Derivative Approximation (for functions)                                  Algorithm 4.0C1

040C2.C*           -  2nd Derivative Approximation (for tabulated data)       Algorithm 4.0C2

040D1.C*           -  Richardson's Extrapolation                                                             Algorithm 4.0D1

040D2.C*           -  Richardson's Extrapolation (with rounding)                                    Algorithm 4.0D2

041.C*               -  Composite Simpson's Rule                                                            Algorithm 4.1

041B.C*             -  Composite Trapezoidal Rule                                       Algorithm 4.1B

041C.C*             -  Composite Midpoint Rule                                                                Algorithm 4.1C

041D.C*             -  Newton-Cotes Formulas for Integrals (8 total)                                Algorithm 4.1D

042.C*               -  Adaptive Quadrature                                                                        Algorithm 4.2

043.C*               -  Romberg                                                                                          Algorithm 4.3

043B.C*             -  Gaussian Quadrature                                                                      Algorithm 4.3B

044.C                 -  Composite Simpson's Rule for Double Integrals                            Algorithm 4.4

044B.C              -  Composite Trapezoid Rule for Double Integrals                             Algorithm 4.4B

044C.C              -  Gaussian Quadrature for Double Integrals                                     Algorithm 4.4C

045.C                 -  Composite Simpson's Rule for Triple Integrals                              Algorithm 4.5

045B.C              -  Composite Trapezoid Rule for Triple Integrals                               Algorithm 4.5B

045C.C              -  Gaussian Quadrature for Triple Integrals                     Algorithm 4.5C

 

 

CHAPTER 5      Initial-Value Problems for Ordinary Differential Equations

 

051.C*               -  Euler                                                                                                                 Algorithm 5.1

051B.C*             -  Midpoint, Modified Euler, and Heun's Methods                                Algorithm 5.1B

052.C*               -  Runge-Kutta (Order Four)                                                               Algorithm 5.2

053.C                 -  Runge-Kutta-Fehlberg                                                                     Algorithm 5.3

054.C*               -  Adam's Fourth-Order Predictor-Corrector                                      Algorithm 5.4

054B.C*             -  Adams-Bashforth (all four) and Milne's Methods                            Algorithm 5.4B

054C.C*             -  Milne-Simpson Predictor-Corrector                                                Algorithm 5.4C

055.C*               -  Adam's Variable Step-Size Predictor-Corrector                             Algorithm 5.5

056.C*               +  Extrapolation                                                                                   Algorithm 5.6

057.C                 -  Runge-Kutta for Systems of Differential Equations                        Algorithm 5.7

057B.C              -  Euler's Variable Step-Size for Systems                                          Algorithm 5.7B

058.C                 -  Trapezoidal with Newton Iteration                                                   Algorithm 5.8

 

 

CHAPTER 6      Direct Methods for Solving Linear Systems

 

060B.C*             -  Matrix Inverter                                                                                  Algorithm 6.0B

060C.C*             -  Determinant of a Matrix                                                                   Algorithm 6.0C

060D.C*             -  Matrix Multiplier                                                                                Algorithm 6.0D

061.C*               -  Gaussian Elimination with Backward Substitution                          Algorithm 6.1

061B.C*             -  Gaussian Elimination with Backward Substitution                          Algorithm 6.1B 

                              (with rounding)

061C1.C*           - Gauss-Jordan Method                                                                      Algorithm 6.1C1

061C2.C*           - Gauss-Jordan Method (with rounding)                          Algorithm 6.1C2

061D1.C*           - Gaussian-Elimination - Gauss-Jordan Hybrid Method  Algorithm 6.1D1

061D2.C*           - Gaussian-Elimination - Gauss-Jordan Hybrid Method  Algorithm 6.1D2

                             (with rounding)

062.C*               -  Gaussian Elimination with Maximal Column Pivoting  Algorithm 6.2

062B.C*             -  Gaussian Elimination with Maximal Column Pivoting  Algorithm 6.2B

                              (with rounding)

063.C*               -  Gaussian Elimination with Scaled Column Pivoting    Algorithm 6.3

063B.C*             -  Gaussian Elimination with Scaled Column Pivoting    Algorithm 6.3B

                              (with rounding)

064.C*               -  Direct Factorization                                                                         Algorithm 6.4

064B.C*             -  Direct Factorization which solves AX=B                      Algorithm 6.4B

064C.C*             -  Direct Factorization with Maximal Column Pivoting     Algorithm 6.4C

                              (3rd edition)

065.C*               -  LDLt Factorization                                                                           Algorithm 6.5

065B.C*             -  LDLt Factorization which solves AX=B                                           Algorithm 6.5B

066.C*               -  Choleski                                                                                           Algorithm 6.6

066B.C*             -  Choleski which solves AX=B                                       Algorithm 6.6B

067.C*               -  Crout Reduction for Tridiagonal Linear Systems                            Algorithm 6.7

 

 

CHAPTER 7      Iterative Techniques in Matrix Algebra

 

070B.C*             -  Vector and Matrix Norms                                                                 Algorithm 7.0B

071.C*               -  Jacobi Iterative                                                                                 Algorithm 7.1

072.C*               -  Gauss-Seidel Iterative                                                                     Algorithm 7.2

073.C*               -  Successive Over Relaxation (SOR)                                               Algorithm 7.3

074.C*               -  Iterative Refinement (with rounding)                                                Algorithm 7.4

074B.C*             -  Iterative Refinement (single-precision)                        Algorithm 7.4B

 

 

CHAPTER 8      Approximation Theory

 

080B.C*             -  Least-Squares Polynomial Approximation                                      Algorithm 8.0B

081.C*               +  Fast Fourier Transformation                                       Algorithm 8.1

 

 

CHAPTER 9      Approximating Eigenvalues

 

091.C*               -  Power Method                                                                                  Algorithm 9.1

091B.C*             -  Power Method with Aitken's Delta2 Method                                     Algorithm 9.1B

092.C*               -  Symmetric Power Method                                                               Algorithm 9.2

093.C*               -  Inverse Power Method                                                                     Algorithm 9.3

094.C*               -  Wielandt's Deflation                                                                         Algorithm 9.4

094B.C*             -  Wielandt's Deflation using Power Method for lambda1                  Algorithm 9.4B

O095.C*            -  Householder Method                                                                        Algorithm 9.5

095B.C*             -  Householder Method (3rd edition)                                                   Algorithm 9.5B

095C.C*             -  Householder Method for Non-Symmetric Matrices      Algorithm 9.5C

                              (Upper Hessenberg)

095D.C*             -  Householder Method (with rounding)                                               Algorithm 9.5D

096.C*               -  QR Algorithm                                                                                   Algorithm 9.6

096B.C*             -  QL Algorithm (3rd edition)                                                               Algorithm 9.6B

 

 

CHAPTER 10    Numerical Solutions of Nonlinear Systems of Equations

 

101.C                 -  Newton's Method for Systems                                                        Algorithm 10.1

101A.C               -  Steffensen's Method for Systems                                                   Algorithm 10.1A

102.C                 -  Broyden's Method for Systems                                                       Algorithm 10.2

103.C                 -  Steepest Descent Method (with F(x) and J(x))                               Algorithm 10.3

103B.C              -  Steepest Descent Method (with G(x) and gradG(x))   Algorithm 10.3B

 

 

CHAPTER 11    Boundary-Value Problems for Ordinary Differential Equations

 

111.C                 -  Linear Shooting                                                                                Algorithm 11.1

112.C                 -  Nonlinear Shooting with Newton's Method                                      Algorithm 11.2

112B.C              -  Nonlinear Shooting with Secant Method                      Algorithm 11.2B

113.C                 -  Linear Finite Difference                                                                   Algorithm 11.3

113B.C              -  Linear Finite Difference (Richardson's Extrapolation) Algorithm 11.3B

114.C                 -  Nonlinear Finite Difference                                                              Algorithm 11.4

114B.C              -  Nonlinear Finite Difference (Richardson's Extrapolation)               Algorithm 11.4B

115.C                 -  Piecewise Linear Rayleigh-Ritz                                                      Algorithm 11.5

116.C                 -  Cubic Spline Rayleigh-Ritz                                                              Algorithm 11.6

 

 

CHAPTER 12    Numerical Solutions to Partial-Differential Equations

 

121.C                 -  Poisson Equation Finite-Difference (Elliptic)                                   Algorithm 12.1

122.C*               -  Heat Equation Backward-Difference (Parabolic)                            Algorithm 12.2

122B.C*             -  Heat Equation Forward-Difference (Parabolic)                               Algorithm 12.2B

122C.C*             -  Heat Equation Richardson's Method (Parabolic)                            Algorithm 12.2C

123.C*               -  Crank-Nicolson (Parabolic)                                          Algorithm 12.3

124.C                 -  Wave Equation Finite-Difference (Hyperbolic)                                Algorithm 12.4

125.C                 -  Finite-Element                                                                                 Algorithm 12.5

126A.C               -  Parabolic Equations With Newton Iteration in 1-D       Algorithm 12.6A

127A.C               -  Parabolic Equations With Newton Iteration in 2-D       Algorithm 12.7A

128A.C               -  Elliptic Equations With Newton Iteration in 2-D                               Algorithm 12.8A

129A.C               -  Biharmonic Equation Using Gauss-Jordan Method     Algorithm 12.9A

 

The '+'s above mean the program may need a larger stack when compiled and linked.

The '*'s above mean the program needs to be compiled only once.

 

 

3.3 Supporting C Source Code

 

The eight files below are needed to compile each and every program.  Most algorithms require only one or two of them at a time.

 

COMPLEX.C

"Complex.c" contain several routines for operating on complex numbers.  It originated from the book "Numerical Recipes in C" and is only used in "naautil3.c."

 

EQEVAL.C

"Eqeval.c" contains the Equation Evaluator routines.  These routines enable a program to enter and evaluate an equation during run-time. It is useful within algorithms that need to evaluate a single function such as f(x) or f(y,t).  It is used by 34 algorithms.  See Chapter 8 - "The Equation Evaluator Routines" for more details on this file.

 

GAUSSJ.C

"Gaussj.c" is a Gauss-Jordan matrix solver routine.  It originated from the book "Numerical Recipes in C."  It is used by only 9 of the algorithms.

 

NAAUTIL.C

"Naautil.c" contain important routines used by all of the algorithms.  Most are for dynamically allocating memory for arrays.  Some of the routines originated from the book "Numerical Recipes in C."  See Section 6.5 - "Explanation of the Naautil.c File."

 

NAAUTIL2.C

"Naautil2.c" contains more dynamically allocated memory routines for less-used data types.  it is used only 2 times.

 

NAAUTIL3.C

"Naautil3.c" contains more dynamically allocated memory routines for complex data types.  It is used only 3 times.

 

ROUND.C

"Round.c" rounds a floating-point value to SIG significant digits.  Only 9 algorithms currently use this function.  See Sub-Section 6.1.10 to see how this file is used.

 

TRUNC.C

"Trunc.c" truncates, or chops, a floating-point value to SIG significant digits.  None of the algorithms use this function, but it can easily replace "round.c."

 

 

3.4 Documentation Files

 

Previous versions of "Numerical Analysis Algorithms in C" consisted of only two document files: "readme.doc" and "math.doc."  With version 4.2, these documents have been consolidated and greatly expanded into this User's Manual ("usersman.doc").  Three document files are included as listed below.

 

README.DOC

"Readme.doc" gives a list of all the algorithms as well as an order form.  This information can also be found inside the User's Manual.

 

REVHIST.DOC

"Revhist.doc" gives a detailed list of all changes made to each version of "Numerical Analysis Algorithms in C".  It lists the additions, corrections, and changes made to each algorithm, to the supporting files, and to the documentation.

 

USERSMAN.DOC

"Usersman.doc" is this User's Manual in DOS text format.  This format is readable by all text editors and word processors.  It can be read using MS-DOS's "type" command or the "list.com" utility included with the diskettes.

 

 

3.5 Utility Files

 

041EE.C

"041ee.c" is an example of how to integrate the equation evaluator routines into an algorithm.

 

041FUN.C

"041fun.c" is an example of Algorithm 4.1 turned into a stand-alone function.

 

CONVERT.C

"Convert.c" is the C source code for a utility which translates text files into standard seven-bit ASCII files.  It is useful before placing these algorithms on non-MS-DOS computers, such as UNIX and VAX computers.  See Section 7.1 - "Convert.c - Converting Files from Extended ASCII to Standard ASCII."

 

CONVERT.EXE

"Convert.exe" is the MS-DOS executable of "convert.c."

 

LISTALL

"Listall" is a text file listing all source code files on the root directory of the distribution disks.  It can be used with "convert.exe" to convert all the programs at once.

 

LISTOUT

"Listout" is a text file listing all output files in the OUT sub-directory of the distribution disks.  It can be used with "convert.exe" to convert all of the output files at once.

 

LIST.COM

"List.com" is an MS-DOS program which acts as a better "TYPE" command.  It uses the arrow keys and other editing keys to view text files.  "List.com" does not allow you to edit files, just view them.  It is a public domain program.  See Section 7.2 - "List.com - A better TYPE Command" for instructions on how to use it.

 

 

3.6 Batch, Script and Command Files

 

Three commands text files are included to simplify the task of compiling and running the algorithms on different computer systems.

 

CC.BAT

"Cc.bat" is an MS-DOS batch file used for compiling, running and viewing a Microsoft C 5.0 program.  It can be easily altered to allow for linking to "naautil.c" and "eqeval.c" object files, speeding up the compile time.  It can also be altered to increase the stack size of a program.

 

CCC

"Ccc" is a UNIX script file used for compiling, running, and viewing a C program.  It can be easily altered to allow for linking to "naautil.c" object code, speeding up the compile time.

 

VAXCC.COM

"Vaxcc.com" is a VAX/VMS command file used for compiling and linking a mathematical VAX C program.  It can be easily altered to allow for linking to "naautil.c" object code, speeding up the compile time.


3.7 File Structure Chart

 

The chart below describes how the files are organized on the distribution diskettes.

 

                                 / (root)

                                    *

      +))))))))0))))))))0))))))))0))2)))))0))))))))0)))))))),

      *        *        *        *        *        *        *                *.C     *.DOC     UTIL    LANGS     IN       OUT      EXE                                  *        *        *        *        *

                        *        *        *        *        *

                       *.*       *       *.IN    *.OUT    *.EXE

                                 *                      (OPTIONAL)

                                 *                                 

   +)))))))))))0)))))))))))0)))))2)))))0)))))))))))0))))))))))),  

   *           *           *           *           *           *

  ADA        BASIC         C          CPP       FORTRAN      PASCAL 

   *           *           *           *           *           *

SIMPSON.ADA SIMPSON.BAS SIMPSON.C  SIMPSON.CPP SIMPSON.FOR SIMPSON.PAS

NAAUTIL.ADA SIMPSON.IN  SIMPSON.H  SIMPSON.HPP SIMPSON.IN  NAAUTIL.INC

SIMPSON.IN  SIMPSON.OUT SIMPSON.IN SIMPSON.IN  SIMPSON.OUT NAAMATH.INC

SIMPSON.OUT            SIMPSON.OUT SIMPSON.OUT             SIMPSON.IN

                                                           SIMPSON.OUT

 

 

3.8 File Name Translation Table from 3rd to 4th Edition

 

This translation table correlates the third edition text algorithms with the fourth edition text algorithms.  The B and C extensions indicate algorithms that were changed or replaced from the third edition and retained with the fourth edition algorithms.           

                                                       

Edition * Edition       Edition * Edition       Edition * Edition

  3rd   *   4th           3rd   *   4th           3rd   *   4th

))))))))3)))))))))      ))))))))3)))))))))      ))))))))3)))))))))

  2.1   *   2.1           5.3   *   5.3           8.6   *   9.2

  2.2   *   2.2           5.4   *   5.4           8.7   *   9.3

  2.3   *   2.3           5.5   *   5.5           8.8   *   9.4

  2.4   *   2.4           5.6   *   5.6           8.9   *   9.5

  2.5   *   2.5           5.7   *   5.7           8.10  *   9.6B

  2.6   *   2.6           5.8   *   5.8           9.1   *  10.1

  2.7   *   2.7           6.1   *   6.1           9.2   *  10.2

  3.1   *   3.1           6.2   *   6.2           9.3   *  10.3

  3.2   *   3.2           6.3   *   6.3          10.1   *  11.1

  3.3   *   3.3           6.4   *   6.4          10.2   *  11.2

  3.4   *   3.4           6.5   *   6.4C         10.3   *  11.3

  3.5   *   3.5           6.6   *   6.6          10.4   *  11.4

  4.1   *   4.1           6.7   *   6.7          10.5   *  11.5

  4.2   *   4.2           8.1   *   7.1          10.6   *  11.6

  4.3   *   4.3           8.1   *   7.1          11.1   *  12.1

  4.4   *   4.4           8.2   *   7.2          11.2   *  12.2

  5.1   *   5.1           8.3   *   7.3          11.3   *  12.3

  5.2   *   5.2           8.4   *   7.4          11.4   *  12.4

                          8.5   *   9.1          11.5   *  12.5

                                                       

 

3.9 4th Edition Differences                             

                                                        

In the fourth edition's PREFACE, pages vii-viii list the "CHANGES IN THE FOURTH EDITION".  The specifics of these changes are listed below.

 

Renamed Algorithms:                      4.1, 4.4, 7.1, 7.2, 9.2, 10.1, 11.2

New to 4th Edition:                           4.5, 6.5, 9.6

Modified in 4th Edition:            9.5B

Discontinued in 4th Edition:              6.4C, 9.6B



 

 

 

4.  Step-By-Step Examples on Various Computers

 

 

This chapter gives four step-by-step examples on several different computer systems.  The example will use Algorithm 4.1 - Composite Simpson's Rule for Integration ("041.c") and will compute the integral of f(x) = 2*cos(x) from 1 to 2 using 20 intervals.

 

Eight steps are typical every time an algorithm is used.  These steps are:

 

          Step #1 - Change to Correct Directory      (operating system)

          Step #2 - Retrieve Algorithm                      (editor)

          Step #3 - Edit Algorithm                                       (editor)

          Step #4 - Save Modifications                     (editor)

          Step #5 - Compile Algorithm                      (compiler)

          Step #6 - Run Program                              (operating system)

          Step #7 - View Output                                (operating system)

          Step #8 - Print Output                                (operating system)

 

For two-thirds of the algorithms, Steps 2-4 are unnecessary and Step 5 needs to be done only once.  These files are marked with an asterisk ('*') in the table in Section 3.1.

 

The examples below will cover these eight steps on four different computer systems:  MS-DOS PCs, UNIX, Macintoshes, and VAXes.  Before following any of these examples, first check the need list below and configure your "naautil.c" file.

 

 

4.1 Need List

 

For this example the files "naautil.c" and "041.c" are needed.  "Naautil.c" and "041.c" are listed in Appendices A and B to be conveniently referred to during this example.  A simple text editor and a C compiler are also required.  The C compiler should be ANSI compatible if at all possible.  This will save you from possible incompatibility problems.

 

It is recommended that you try this example out on your computer system as you read this section.  Be sure to modify only COPIES of the original algorithms so the algorithms can be used over and over again without problems.

 

 

4.2 Customizing Naautil.c

 

The first decisions to be made are what options and flags you would like to use or set inside the "naautil.c" file.  These flags are usually set only once.  An explanation of each flag is given below.

 

ANSI:

If your compiler supports the ANSI C standard, then set ANSI to TRUE.  Set ANSI to FALSE only if the program will not compile with it set to TRUE.  This flag mostly effects function prototype styles.

 

ANSI_FUNCT:

Set this flag to TRUE to use the ANSI style for declaring functions over the K&R style.  This flag must be set to TRUE if using THINK C 4.0 on a Macintosh.

 

FILE_SAVE:

If you would like to save the output to a file, then set FILE_SAVE to TRUE.  The output is still printed to the screen as you run the program.  Set it to FALSE if you do not want to save the output to a file.

 

TITLE_PROMPT:

If you would like to be prompted for an optional title at the start of each program, then set TITLE_PROMPT to TRUE.  This is useful when the output is to be handed in as homework, allowing the user's name or the problem number to be entered.  No title is printed to the output file if the [ENTER] key is hit by itself.  Set it to FALSE if you do not want to be bothered with entering a title every time you run an algorithm.

 

EQ_EVAL:

Several of the algorithms require a single function to be evaluated.  Set EQ_EVAL to TRUE if you wish to enter the function during run-time instead of at compile time.  A couple of simple modifications MUST be made to your algorithm BEFORE this option will be effective.  See Chapter 8 - "The Equation Evaluator Routines" for instructions on using this option.

 

NAAUTIL_OBJ:

This option is useful for users who wish to speed up the compilation process.  See Section 6.6 - "Using Naautil.c as Object Code" for more details.

 

These examples assume the following default settings:

 

        FLAG           SETTING

        ANSI           TRUE

        ANSI_FUNCT     FALSE

        FILE_SAVE      TRUE

        TITLE_PROMPT   TRUE

        EQ_EVAL        FALSE   (Is set to TRUE in "041ee.c")

        NAAUTIL_OBJ    FALSE

 

The ANSI, ANSI_FUNCT and OLD_UNIX_OS flags may need to be changed if your compiler varies from the ANSI standard.  See Section 6.5 - "Explanation of the Naautil.c File" for a more thorough explanation of the "naautil.c" flags.

 

 

4.3 Example Using MS-DOS, Microsoft C and the P-Edit Editor

 

This example uses the following software:

 

          Operating System:        MS-DOS on an IBM PC

          Compiler:                       Microsoft C 5.0

          Editor:                            WordPerfect's P-Edit Editor

 

No special "naautil.c" flags need to be set.

 

This example assumes the files were installed onto the "C" drive in the "\NAA42" sub-directory.  The DOS prompt will be represented by "C:\NAA42> ".

 

 

Step #1 - Change to Correct Directory

 

Assuming the "Numerical Analysis Algorithm in C" files are located in the "\NAA42" sub-directory of the "C" drive, go there by typing:

 

          C:\> CD \NAA42                                - changes directories

          C:\NAA42> DIR /P                           - shows directory's contents

 

 

Step #2 - Retrieve Algorithm

 

Invoke your text editor and retrieve the algorithm file:

 

          C:\NAA42> PE 041.C

 

The file "041.c" is now loaded and is ready for editing.  A text editor is preferred over a word processor.  If you plan to use a word processor as your editor, be sure to retrieve and save all files as text-only files.

 

 

Step #3 - Edit Algorithm

 

You must now modify the function f(x).  F(x) is listed twice - once as text and once as the actual function call.  All functions are defined at the top of each program.  To quickly find where modifications are necessary, search for the '$' character.  This character is used exclusively for locating lines of code that need updating in all "Numerical Analysis Algorithms in C" files.

 

Search for the first '$':

 

          [F2] $ [F2]                              - search

 

The first '$' should be found at line 22 of "041.c."

 

Change line 22 from:     char *eq_text_f = "f(x) = sin(x)";

to:                char *eq_text_f = "f(x) = 2*cos(x)";

 

This string of text will be printed as output exactly as it appears inside the quotations when the program is run.

 

Now search for the second '$':

 

          [F2] $ [F2]                              - search

 

The second '$' should find the function itself on line 31 of "041.c."

Change line 31 from:     return (sin(x));

to:                return (2.0 * cos(x));

 

 

Step #4 - Save Modifications

 

Now save the file "041.c" with the above changes and exit the editor:

 

          [F7] Y [ENTER] Y Y             - save and exit

 

 

Step #5 - Compile Algorithm

 

Now compile and link "041.c" into the executable file "041.exe."  At the prompt type:

 

          C:\NAA42> CL 041.C

 

The batch file "cc.bat" can also be used in place of the "CL" command.  See Sub-Section 7.3.1 on using "cc.bat."  If the program requires a larger stack than the default size, using "CL 041.C /link /ST:4096" will increase the stack from 2K bytes to 4K bytes in Microsoft C 5.0.

 

 

Step #6 - Run Program

 

To run "041.exe", at the DOS prompt type:

 

          C:\NAA42> 041

 

The ".exe" extension can be left off.  Answer the prompts with the predetermined inputs.  The screen should look something like this:

 

    64444444444444444444444444444444444444444444444444444444444447

    5 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑ 5

    5          "Numerical Analysis Algorithms in C" v4.2         5

    5 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑ 5

    5                                                            5

    5 Enter an optional title [ie ‑ Set 2.1,  Problem 2 a) ].    5

    5 ‑‑‑‑> User's Manual Example                                5

    5                                                            5

    5 Composite Simpson's Rule ‑ Algorithm 4.1                   5

    5                                                            5

    5 f(x) = 2*cos(x)                                            5

    5                                                            5

    5 Enter endpoint a: 1                                        5

    5 Enter endpoint b: 2                                        5

    5 Enter number of intervals on [a,b], n: 20                  5

    5 Interval number h = 0.05                                   5

    5                                                            5

    5      !2                                                    5

    5 XI = *  f(x) dx = 0.13565288875                            5

    5      "1                                                    5

    5                                                            5

    5 Required 21 functional evaluations.                        5

    5                                                            5

    5 Output saved into file "041.out".                          5

    94444444444444444444444444444444444444444444444444444444444448

 

As indicated by the output, a file named "041.out" is created which contains the output results in a ready-to-print format.

 

 

Step #7 - View Output

 

To view the contents of the output file "041.out", use either the DOS "type" command, the "Numerical Analysis Algorithms in C" utility "list.com", or your text editor.  See Section 7.2 for instructions on the usage of the "list.com" utility.

 

          C:\NAA42> TYPE 041.OUT                                - Using DOS's "type"

or

          C:\NAA42> UTIL\LIST 041.OUT                             - Using "list.com"

 

If the file's contents are accurate, then you are ready to print out a copy to be turned in as homework.

 

 

Step #8 - Print Output

 

To print out the output file from DOS, type:

 

          C:\NAA42> PRINT 041.OUT

 

This step can also be done from within most text editors.  WARNING: Be careful not to print the executable file "041.exe".  It will waste reams of paper.

 

 

4.4 Example Using UNIX, cc and the vi Editor

 

This example uses the following software:

 

          Operating System:        UNIX

          Compiler:                       cc

          Editor:                            vi

 

You may need to set the OLD_UNIX_OS flag to TRUE if your C compiler requires the include file <varargs.h> instead of <stdarg.h> for variable length argument lists.  See your system's "/usr/include" sub-directory to determine which include file will be used.

 

The percent ('%') character will be used to represent the UNIX shell prompt.

 

 

Step #1 - Change to Correct Directory

 

Assuming the "Numerical Analysis Algorithm in C" files are located in the "naa42" sub-directory, go there by typing:

 

          % cd naa42                                          - changes directories

          % pwd                                                       - shows current directory

          % ls -alF                                             - shows directory's contents

 

 

Step #2 - Retrieve Algorithm

 

Invoke the vi editor and retrieve the algorithm file:

 

          % vi 041.c

 

The file "041.c" is now loaded and is ready for editing.

 

 

Step #3 - Edit Algorithm

 

You must now modify the function f(x).  F(x) is listed twice - once as text and once as the actual function call.  All functions are defined at the top of each program.  To quickly find where modifications are necessary, search for the '$' character.  This character is used exclusively for locating lines of code that need updating in all "Numerical Analysis Algorithms in C" files.

 

Search for the first '$':

 

          /$                                           - search

 

The first '$' should be found at line 22 of "041.c."

 

Change line 22 from:     char *eq_text_f = "f(x) = sin(x)";

to:                char *eq_text_f = "f(x) = 2*cos(x)";

 

This string of text will be printed as output exactly as it appears inside the quotations when the program is run.

 

Now search for the second '$':

 

          n                                              - search (next occurrence)

 

The second '$' should find the function itself on line 31 of "041.c."

 

Change line 31 from:     return (sin(x));

to:                return (2.0 * cos(x));

 

Here are a few vi editing commands you should know for future reference:

 

          i                   Enters insert mode  (Exit this mode using [ESC])

          R                 Enters typeover mode  (Exit this mode using [ESC])

          r                  Replace character

          w                 Moves forward one word

          b                 Moves backward one word

          x                  Deletes a character

          dw               Deletes a word

          dd               Deletes a line

          cw               Changes a word  (follow text by an [ESC] key)

          :#                Go to line number #

          :w                Saves (writes) editor contents to a file

          :q                Quits (exits) the editor

          ZZ               Exits the editor saving all changes  (Same as ":wq")

          [ESC]          Exits insert, typeover, and other editing modes

          /string         Searches forward for string

          ?string        Searches backwards for string

          n                 Continue search for string

          Arrow keys, ^g, ^h, ^j, ^k, or [SPACE] move the cursor

 

 

Step #4 - Save Modifications

 

Now save the file "041.c" with the above changes and exit the editor:

 

          :wq                                         - write and quit

or

          ZZ                                           - save and exit (faster to type than ":wq")

 

 

Step #5 - Compile Algorithm

 

Now compile and link "041.c" into the executable file "041".  At the shell prompt type:

 

          % cc -o 041 041.c -lm

 

"Cc" invokes the C compiler, "-o 041" (NOT ‑0) names the executable program, "041.c" is the source code file name, and "-lm" links with the math library.  Without the "-o 041" the program would be given the default name of "a.out".  Without the "-lm" the program would give incorrect floating-point results.

 

The script file "ccc" can also be used in place of the "cc" command.  See Sub-Section 7.3.2 on using "ccc".  It will do the compiling, running, and will list the output for you.

 

 

Step #6 - Run Program

 

To run "041", at the shell prompt type:

 

          % 041

 

Answer the prompts with the predetermined inputs.  The screen should look something like this:

 

    64444444444444444444444444444444444444444444444444444444444447

    5 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑ 5

    5          "Numerical Analysis Algorithms in C" v4.2         5

    5 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑ 5

    5                                                            5

    5 Enter an optional title [ie ‑ Set 2.1,  Problem 2 a) ].    5

    5 ‑‑‑‑> User's Manual Example                                5

    5                                                            5

    5 Composite Simpson's Rule ‑ Algorithm 4.1                   5

    5                                                            5

    5 f(x) = 2*cos(x)                                            5

    5                                                            5

    5 Enter endpoint a: 1                                        5

    5 Enter endpoint b: 2                                        5

    5 Enter number of intervals on [a,b], n: 20                  5

    5 Interval number h = 0.05                                   5

    5                                                            5

    5      [2                                                    5

    5 XI = |  f(x) dx = 0.13565288875                            5

    5      ]1                                                    5

    5                                                            5

    5 Required 21 functional evaluations.                        5

    5                                                            5

    5 Output saved into file "041.out".                          5

    94444444444444444444444444444444444444444444444444444444444448

 

As indicated by the output, a file named "041.out" is created which contains the output results in a ready-to-print format.

 

 

Step #7 - View Output

 

To view the contents of the output file "041.out", use the UNIX "more" command.

 

          % more 041.out

 

If the file's contents are accurate, then you are ready to print out a copy to be turned in as homework.

 

 

Step #8 - Print Output

 

To print out the output file from the UNIX shell prompt, type:

 

          % lp 041.out

 

"Lp" prints the file "041.out" to the line printer.  WARNING: Never try to print the executable file "041*" (denoted with an '*' when listed with "% ls -F").  It will waste reams of paper.

 

 

4.5 Example Using a Macintosh and THINK C

This example uses the following software:

 

          Operating System:        Finder or MultiFinder on a Macintosh

          Compiler:                       THINK C 4.0 by Symantec

          Editor:                            THINK C editor

 

You will need to set the ANSI_FUNCT flag in "naautil.c" to TRUE to compile and use functions using variable length argument lists, such as "printf2(...)" and "eval_eq()".  It simply enforces the newer ANSI style function declarations over the older K&R style (see Section 9.1 for an example).

 

The following example was derived from Chapter 3 - "Tutorial: Hello World" in the THINK C User's Manual.  It replaces the "Hello Folder" with "041 Folder.B", "hello.c" with "041.c", and uses the ANSI library.

 

 

Step #1 - Create a Project

 

The first thing you need to do is create a folder called "041 Folder.B" in the "Development" folder.  Do this before you start THINK C.  The "041 Folder.B" folder should contain your source files ("041.c"), "naautil.c" and other supporting ".c" files such as "eqeval.c".  It is good programming practice, though not necessary, to name your project folders with a ".B" extension.  (To make a B, type Option p.)

 

When you've created "041 Folder.B", open the THINK C Folder (the one that contains the THINK C application) and double click on the THINK C icon.

 

You'll see a dialogue box that asks you to open a project.  Since you are creating a new project, click on the New button.  You'll see another dialogue box, one that lets you create projects.

 

Move back to the "041 Folder.B" folder you just created.  It is very important that you move to this folder.  Name the project "041 project", and click on the Create button.  THINK C creates a new project document on disk and displays a project window.

 

 

Step #2 - Retrieve Algorithm

 

To open the algorithm text file, choose the Open... command in the File menu.  Select the file "041.c" from the menu.

 

 

Step #3 - Edit Algorithm

 

You must now modify the function f(x).  F(x) is listed twice - once as text and once as the actual function call.  All functions are defined at the top of each program.  To quickly find where modifications are necessary, search for the '$' character.  This character is used exclusively for locating lines of code that need updating in all "Numerical Analysis Algorithms in C" files.

 

To search for the first '$' character, choose the Find... command in the Search menu.  Type a '$' character in the Search for: field and click the Find button.  It should be found at line 22 of "041.c."

 

Change line 22 from:     char *eq_text_f = "f(x) = sin(x)";

to:                char *eq_text_f = "f(x) = 2*cos(x)";

 

This string of text will be printed as output exactly as it appears inside the quotations when the program is run.

 

Now search for the second '$' by choosing the Find Again command in the Search menu.  The second '$' should find the function itself on line 31 of "041.c."

 

Change line 31 from:     return (sin(x));

to:                return (2.0 * cos(x));

 

You may want to read Chapter 8 - "The Editor" in your THINK C User's Manual for more information about the THINK C text editor.

 

 

Step #4 - Save Modifications

 

When you have finished modifying the program, select Save As... from the File menu to save it.  You will get a dialogue box in which you should enter the name of the file "041.c", and click on the Save button.  THINK C will only compile files that end with ".c" or ".C".

 

 

Step #5 - Compile Algorithm

 

Now compile "041.c" into the executable named "041".  To do this, select Compile from the Source menu.  THINK C displays a dialogue box that shows how many lines have been compiled.  See your THINK C User's Manual if you can not resolve any compilation errors.

 

Next, you need to add the "ANSI" library to your project.  This library contains all the standard C library routines such as printf().  To add the "ANSI" library, choose Add... from the Source menu.

 

When you get the standard file dialogue box, open the folder called "C Libraries."  This folder contains all the libraries for ANSI compatibility, including the "ANSI" library.  Select "ANSI", and click on the Add button.  WARNING - Do not select "ANSI-small" or "ANSI-A4" since they do not support floating-point operations.  If you have a math coprocessor (MC68881), substitute "ANSI" with "ANSI-881".  This will measurably speed up each algorithm's execution time.

 

THINK C adds the name "ANSI" to the project window and then puts up the standard file dialogue box again.  The second time around just click on the Cancel box.  THINK C will load the library automatically when you run the project.

 

IMPORTANT:  You may need to place "ANSI" into its own segment by dragging "ANSI" below the dotted line and releasing it.  A line indicates that the code is separated into different segments.  This may be necessary due to an object code size limitation of 32K bytes per segment.

 

 

Step #6 - Run Program

 

Everything is all set to run the project.  The source file is in the project window along with the libraries you will be using.  Now select Run from the Project menu.

THINK C notices that the library needs to be loaded, so it puts up a dialogue box asking you if you want to bring the project up to date.  Click on the Yes button.  THINK C goes to disk to load the code for the "ANSI" library.  The executable "041" is now being created.

 

Since all "Numerical Analysis Algorithms in C" programs call the printf() function, all output will go to a window called "console".  The console window emulates a generic terminal screen.

 

The program will now prompt you for inputs.  Answer the prompts with the predetermined inputs.  The console screen should look something like this:

 

    64444444444444444444444444444444444444444444444444444444444447

    5////////////////////////// console ///////////////////////G/5

    :444444444444444444444444444444444444444444444444444444444444<

    5 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑ 5

    5          "Numerical Analysis Algorithms in C" v4.2         5

    5 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑ 5

    5                                                            5

    5 Enter an optional title [ie ‑ Set 2.1,  Problem 2 a) ].    5

    5 ‑‑‑‑> User's Manual Example                                5

    5                                                            5

    5 Composite Simpson's Rule ‑ Algorithm 4.1                   5

    5                                                            5

    5 f(x) = 2*cos(x)                                            5

    5                                                            5

    5 Enter endpoint a: 1                                        5

    5 Enter endpoint b: 2                                        5

    5 Enter number of intervals on [a,b], n: 20                  5

    5 Interval number h = 0.05                                   5

    5                                                            5

    5      [2                                                    5

    5 XI = |  f(x) dx = 0.13565288875                            5

    5      ]1                                                    5

    5                                                            5

    5 Required 21 functional evaluations.                        5

    5                                                            5

    5 Output saved into file "041.out".                          5

    94444444444444444444444444444444444444444444444444444444444448

 

To exit the program, press the Return key or choose Quit from the File menu.

 

As indicated by the output, a text file named "041.out" is created which contains the output results in a ready-to-print format.

 

 

Step #7 - View Output

 

To view the contents of the output file, use the Open... command in the File menu and select "041.out."

 

If the file's contents are accurate, then you are ready to print out a copy to be turned in as homework.

 

Step #8 - Print Output

 

To print out the output file, use the Print... command in the File menu.  Make sure the output file is in the frontmost edit window.  You'll see the standard print dialogue for either the ImageWriter or LaserWriter.

 

To end this example session, select Close All in the Windows menu to close all open files.  If a file has not been saved, the editor will ask you if you want it saved.

 

 

Using SANE

 

As you use these algorithms, you may find it beneficial to use certain utility functions from the Standard Apple Numerics Environment (SANE).  The SANE library uses 80-bit values and is not intended for projects that have the MC68881 Code Generation option checked.

 

The eight functions below are common to both the SANE and ANSI libraries:

 

        atan()         exp()          log()          sqrt()

    cos()       fabs()      sin()       tan()

 

To use SANE versions, #include the file "SANE.h" before the file "math.h" inside "naautil.c."  Similarly, to use the ANSI versions, #include the file "math.h" before the file "SANE.h" in "naautil.c."  For more information on SANE, read "Apple Numerics Manual, Second Edition" (Addison-Wesley).

 

 

4.6 Example Using VAX/VMS, CC and the EDIT/EDT Editor

 

This example uses the following software:

 

          Operating System:        VAX/VMS (really DCL)

          Compiler:                       VAX C v3.2 from DEC (CC)

          Editor:                            EDIT/EDT or EVE

 

The dollar ('$') character will be used to represent the VMS command prompt.

 

 

Step #1 - Change to Correct Directory

 

Assuming the "Numerical Analysis Algorithm in C" files are located in the "NAA42" sub-directory, go there by typing:

 

          $ SET DEFAULT [.NAA42]            - changes directories

          $ SHOW DEFAULT                                - shows current directory

          $ DIR/SIZE/DATE                              - shows directory's contents

 

 

Step #2 - Retrieve Algorithm

 

Invoke the EDIT/EDT editor and retrieve the algorithm file:

 

          $ EDIT/EDT 041.C

 

The file "041.c" is now loaded and is ready for editing.  The first line of the file is printed to the screen.  An asterisk will follow which indicates that you are in EDT line editing mode.  It should look similar this:

 

          $ EDIT/EDT 041.C

              1       /*****************************************************

****************

          *

 

 

Step #3 - Edit Algorithm

 

Now type "C" or "SET MODE CHANGE" followed by [ENTER] to leave line editing mode and enter full screen mode where you can use the EDT function keypad.

 

          * C [ENTER]

 

You must now modify the function f(x).  F(x) is listed twice - once as text and once as the actual function call.  All functions are defined at the top of each program.  To quickly find where modifications are necessary, search for the '$' character.  This character is used exclusively for locating lines of code that need updating in all "Numerical Analysis Algorithms in C" files.

 

Search for the first '$' by entering:

 

          [4] [PF1] [PF3] $

 

The first '$' should be found on line 22 of "041.c."

 

Change line 22 from:     char *eq_text_f = "f(x) = sin(x)";

to:                char *eq_text_f = "f(x) = 2*cos(x)";

 

This string of text will be printed as output exactly as it appears inside the quotations when the program is run.

 

Now search for the second '$' by entering:

 

          [4] [PF1] [PF3] $

 

The second '$' should find the function itself on line 31 of "041.c."

 

Change line 31 from:     return (sin(x));

to:                return (2.0 * cos(x));

 

Here are a few EDIT/EDT editing commands you should know:  (^ = [CONTROL])

 

          [PF2]           Help

          [PF1][0]       Opens blank line after current line

          [,]                Replace character

          [4][1]           Moves forward one word

          [5][1]           Moves backward one word

          [.]                Deletes a character

          [-]                Deletes a word  (Must be followed by the [ESC] key)

          [PF4]           Deletes a line

          [-]                Changes a word  (Must be followed by the [ESC] key)

          [PF1][7]T#  Moves to line number #

          ^Z EXIT       Quits the editor and saves any changes

          ^Z QUIT       Quits the editor without saving changes

          [ESC]                   Terminate input mode

          ^Z                Exits full-screen mode and returns to line mode with *

          [4][PF1][PF3]string                  Searches forward for string

          [5][PF1][PF3]string                  Searches backwards for string

          [PF1][7] EXIT [ENTER]  Exits editor saving any changes

          Arrow keys, ^g, ^h, ^j, ^k, or [SPACE] move the cursor

 

 

Step #4 - Save Modifications

 

Now save the file "041.c" with the above changes and exit the editor:

 

          ^Z                                  - returns to line editing mode and the * prompt

          * EXIT                        - save and exit

 

 

Step #5 - Compile Algorithm

 

The VAX C compiler needs to know which libraries to link to.  Two libraries will be used which will allow floating-point operations.  Define them once as follows:

 

          $ DEFINE LNK$LIBRARY    SYS$LIBRARY:VAXCRTLG

          $ DEFINE LNK$LIBRARY_1  SYS$LIBRARY:VAXCRTL

 

See "HELP CC Link_libraries" to make sure the defines above are correct for your VAX as well (/G_FLOAT without Curses).

 

Now compile and link "041.c" into the executable file "041.exe".  At the VAX prompt type:

 

          $ CC /G_FLOAT 041.C

          $ LINK 041, LNK$LIBRARY/LIB, LNK$LIBRARY_1/LIB

 

"Cc" compiles "041.c" into "041.obj" object code.  "Link" names the executable "041.exe" after linking it to the appropriate libraries.  For machine specific information on the "link" command, use the on-line help by typing "HELP CC LINK" and "HELP LINK."

 

The command file "vaxcc.com" can also be used in place of the "cc" and "link" commands.  See Sub-Section 7.3.3 on using "vaxcc.com".  It will do the compiling and linking in one simple step, assuming the link libraries are correct.  Using it is as easy as typing:

 

          $ @VAXCC.COM 041                  - replaces Step #5 entirely

 

 

Step #6 - Run Program

 

To run "041.exe", at the VAX prompt type:

 

          $ RUN 041

 

Answer the prompts with the predetermined inputs.  The screen should look something like this:

 

    64444444444444444444444444444444444444444444444444444444444447

    5 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑ 5

    5          "Numerical Analysis Algorithms in C" v4.2         5

    5 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑ 5

    5                                                            5

    5 Enter an optional title [ie ‑ Set 2.1,  Problem 2 a) ].    5

    5 ‑‑‑‑> User's Manual Example                                5

    5 Composite Simpson's Rule ‑ Algorithm 4.1                   5

    5                                                            5

    5 f(x) = 2*cos(x)                                            5

    5                                                            5

    5 Enter endpoint a: 1                                        5

    5 Enter endpoint b: 2                                        5

    5 Enter number of intervals on [a,b], n: 20                  5

    5 Interval number h = 5.000000e-02                           5

    5                                                            5

    5      [2                                                    5

    5 XI = |  f(x) dx = 0.13565288875                            5

    5      ]1                                                    5

    5                                                            5

    5 Required 21 functional evaluations.                        5

    5                                                            5

    5 Output saved into file "041.out".                          5

    94444444444444444444444444444444444444444444444444444444444448

 

As indicated by the output, a file named "041.out" is created which contains the output results in a ready-to-print format.

 

 

Step #7 - View Output

 

To view the contents of the output file "041.out", use the "TYPE" command.

 

          $ TYPE/PAGE 041.OUT

 

If the file's contents are accurate, then you are ready to print out a copy to be turned in as homework.

 

 

Step #8 - Print Output

To print out the output file from the VMS prompt, type:

 

          $ PRINT 041.OUT

 

WARNING: Never try printing the executable file "041.exe."  It will waste reams of paper.



 

 

 

5.  For Those New to C

 

 

This chapter will introduce you to the C programming language and some of its basic functions and features.  if you are new to C, it will be to your advantage to take a few minutes to read through this chapter before you move on.  If you are already familiar with C, you may want to glance through this chapter to remind you of the math library functions found in <math.h>.

 

The C language has been around since 1978.  Its popularity continues to grow especially among universities and industry.  C is usually learned as a second language after learning Pascal or FORTRAN.  This chapter is intended to give unexperienced programmers a push in the right direction.

 

The easiest way to learn C is by example.  This chapter also lists the preferred reference books, the mathematical operators and functions, and compares C with other popular programming languages -- along with examples.

 

If you do not own a C compiler and you have access to an IBM PC computer, and you do not want to pay much to get one (student mode), there are some low cost compilers on the market that you may wish to investigate.  One such compiler is "Power C".  This ANSI compatible C compiler lists for only $19.95.  To order, call 1-800-333-0330, or write to: MIX Software, 1132 Commerce Dr., Richardson, TX 75081, (214) 783-6001.  Turbo C and Microsoft C seem to be among the most popular DOS C compilers on the market.

 

The definitive book on the C language is "The C Programming Language", Second Edition, by Brian W. Kernighan and Dennis M. Ritchie (Cost: $28.00).  If you are using an older C compiler (pre-1987), you may find the first edition more useful.  This 272 page book was written by the creators of C at AT&T Bell Laboratories.  All other books on C are derivatives of this book.

 

The syntax of older C compilers follows the first edition of "The C Programming Language."  This pre-standard is often referred to as K&R style, named after its authors, Kernighan and Ritchie.  The second edition was revised to conform to the ANSI standard.

 

 

5.1 Mathematical Operators

 

The following operators are used to write mathematical equations in C.  These operators are built-in to the C language.  For more detailed descriptions, see your C compiler's documentation.

 

Operator              Description

*                          Multiplication.  Not to be confused with pointers.

                             Example:  a = b * c;

 

/                          Division.  Chops to nearest integer if using integer types.  For instance,  11 / 4 = 2 since the remainder of 3 is discarded.  11.0 / 4.0 = 2.75.

                   Example:  a = b / c;

 

%                          Remainder.  Also called the modulus operator.  Use fmod() and/or modf() for floats and doubles.  For instance, 11 % 4 = 3 since the quotient of 2 is discarded.

                   Example:  a = b % c;

 

+                          Addition.

                             Example:  a = b + c;

 

                          Subtraction and arithmetic negation.

                             Example:  a = b ‑ c;  and  a = ‑b;

 

++                        Increment.  For instance, i++; is shorthand for i = i + 1;

                             Example:  i++;  (post‑increment)  and  ++i;  (pre‑increment)

 

‑‑                        Decrement.  For instance, i‑‑; is shorthand for i = i ‑ 1;

                             Example:  i‑‑;  (post‑decrement)  and  ‑‑i;  (pre‑decrement)

 

*=                        Multiplication assignment.  For instance, x *= 3.14 + y; is shorthand for x = x * (3.14 + y);

 

/=                        Division assignment.  For instance, x /= 3.14 + y; is shorthand for x = x / (3.14 + y);

 

%=                        Remainder assignment.  Integers only.  For instance, a %= 314 + b; is shorthand for a = a % (314 + b);

 

+=                        Addition assignment.  For instance, x += 3.14 + y; is shorthand for x = x + (3.14 + y);

 

‑=                        Subtraction assignment.  For instance, x ‑= 3.14 + y; is shorthand for x = x ‑ (3.14 + y);

 

 

5.2 Mathematical Functions

 

The following functions are useful when writing mathematical equations in C.  These functions are not part of the C language proper, but are part of the standard library, an environment that supports standard C.  For more detailed descriptions of these libraries, see your C compiler's documentation.  Another good place to browse is inside the include files <math.h> and <stdlib.h>.  These two include files provide the function declarations for most of the below functions.

 

Listed below are the variable types used in the examples.

 

        Type           Variables

        float          w;

        double         x, y, exp;

        int            *expptr, *intptr, n;

        long int       p, q;

        char           *string;

        div_t          num, denom;

        struct complex z;

 

struct complex { double r,i; } z;  /* Real and imaginary components */

 

#include <math.h>               - must be included to use these functions!

#include <stdlib.h>          - must be included to use these functions!

 

 

Function               Description

abs(n)              Returns the absolute value of its integer argument.

 

acos(x)           Returns the arccosine of x in the range 0 to B.  The value of x must be between ‑1 and 1.

 

asin(x)           Returns the arcsine of x in the range ‑B/2 to B/2.  The value of x must be between ‑1 and 1.

 

atan(x)           Returns the arctangent of x in the range ‑B/2 to B/2.

 

atan2(y,x)    Returns the arctangent of y/x in the range ‑B to B.  Unlike atan(), atan2() uses the signs of both x and y to determine the true quadrant of the return value.

 

atof(string)         Converts a character string into a double‑precision floating‑point value.

 

atoi(string)         Converts a character string into an integer value.

 

cabs(z)           Returns the absolute value of a complex number, which must be a structure of type complex (shown above).   Equivalent to sqrt(z.x*z.x + z.y*z.y).  NOT IN ANSI STANDARD.

 

ceil(x)           Returns a double‑precision floating‑point value representing the smallest integer not less than x.  Also called the postage stamp function.

                             Example: ceil(1.05) = 2.0,  ceil(‑1.05) = ‑1.0

 

cos(x)              Returns the cosine of x, where x is in radians.

 

cosh(x)           Returns the hyperbolic cosine of x.

 

div(num,denom)    Computes the quotient and remainder of num/denom.  The results are stored in the int members quot and rem of a structure of type div_t.

 

exp(x)              Returns the exponential function of its floating‑point argument x.  Also called Euler's or the natural number, e . 2.71828182845.

 

fabs(x)           Returns the absolute value of its floating‑point argument x.

 

floor(x)         Returns a double‑precision floating‑point value representing the largest integer not greater than x.  Also called the greatest integer function, [ ].

                             Example: floor(1.05) = 1.0,  floor(‑1.05) = ‑2.0

 

fmod(x,y)      Returns the floating‑point remainder f of x/y such that x = i*y + f, where i is an integer.  f has the same sign as x, and the absolute value of f is less than the absolute value of y.  If y is zero, the result is implementation defined.

frexp(x,expptr) Breaks down the floating‑point value, x, into a mantissa, p, and an exponent, q, such that the absolute value of p is $ 0.5 and < 1.0, and x = p*2^q.  The integer exponent is stored in the location pointed to by expptr.  If x is zero, both parts of the result are zero.

 

hypot(x,y)    Returns the length of the hypotenuse of a right triangle, given the length of the two sides x and y.  Equivalent to:  sqrt(x*x + y*y).  NOT IN ANSI STANDARD.

 

ldexp(x,exp)         Returns x * 2^exp.

 

log(x)              Returns the natural logarithm of x, x > 0.

 

log10(x)         Returns the base‑10 logarithm of x, x > 0.

 

modf(x,intptr)    Breaks down the floating-point value x into fractional and integer parts.  The signed fractional portion of x is returned.  The integer portion is stored as a floating‑point value at intptr.

 

pow(x,y)         Returns x raised to the yth power (x^y).  A domain error occurs if x = 0 and y # 0, or if x # 0 and y is not an integer.

 

rand()              Returns a pseudo‑random integer in the range 0 to RAND_MAX, which is at least 32,767.

 

sin(x)              Returns the sine of x, where x is in radians.

 

sinh(x)           Returns the hyperbolic sine of x.

 

sqrt(x)           Returns the square root of x, x $ 0.

 

srand(seed) Uses seed as the seed for a new sequence of pseudo‑random numbers.  The initial seed is 1.

 

tan(x)              Returns the tangent of x, where x is in radians.

 

tanh(x)           Returns the hyperbolic tangent of x.

 

 

AVAILABLE AS EXTENSIONS ON SOME C COMPILERS (ie ‑ MIPS for an R3000A/R3010):

 

fsin(w)           Sine for floats.  Sin(x) is for doubles.

 

fcos(w)           Cosine for floats.  Cos(x) is for doubles.

 

ftan(w)           Tangent for floats.  Tan(x) is for doubles.

 

fasin(w)         Arcsine for floats.  Asin(x) is for doubles.

 

facos(w)         Arccosine for floats.  Acos(x) is for doubles.

 

fatan(w)         Arctangent for floats.  Atan(x) is for doubles.

 

fsinh(w)         Hyperbolic sine for floats.  Sinh(x) is for doubles.

 

fcosh(w)         Hyperbolic cosine for floats.  Cosh(x) is for doubles.

 

ftanh(w)         Hyperbolic tangent for floats.  Tanh(x) is for doubles.

 

 

5.3 General Language Hints

 

 

Ternary Statements:

 

C has a couple of constructs that may be foreign to users used to FORTRAN 77 or other high level languages.  One of these is the ternary statement:

 

                   a = b ? c : d;

 

which is equivalent to:

 

                   if (b == TRUE)

                             a = c;

                   else

                             a = d;

 

A couple of examples might include:

 

                   max = (a > b) ? (a) : (b);

or

                   printf("%d iteration%s", iter, (iter > 1) ? "s" : "");

                   /* Prints: "1 iteration" and "2 iterations" */

 

 

Defining TRUE and FALSE:

 

Remember, in C "0" is FALSE while anything other than "0" is defined as TRUE.  For example:

 

                   -2      = TRUE

                   -1      = TRUE

                    0       = FALSE

                    1       = TRUE      (default)

                    2       = TRUE

 

Usually, TRUE and FALSE are defined as "#define FALSE 0" and "#define TRUE !FALSE" or "#define TRUE 1".

 

 

Common Equivalents:

 

        SHORT HAND     LONG HAND

        if (expr) ...  if (expr == TRUE) ...

        if (!expr) ... if (expr == FALSE) ...

        i++            i = i + 1

        i--            i = i - 1

        i += 2         i = i + 2

        i -= 2      i = i - 2

 

 

5.4 Language Transition Kit

 

Many numerical analysis students may already be familiar with another programming language other than C.  This section is intended to help those who have learned other languages other than C to transfer their knowledge easily into C.  To accomplish this goal, two large appendices have been compiled.

 

Appendix C contains a set of charts comparing C statements with those of other popular languages.  The tables provided should help in understanding and modifying the equations and code as needed to perform numerical analysis.  These tables show a simple comparison of programming statements most likely to be used in numerical analysis programs.

 

Appendix D contains a set of working examples in six different languages.  These source code examples show how programs look in each of these languages.  These programs do numerical integration using Algorithm 4.1 - Composite Simpson's Rule.  Each program was compiled and run to ensure they were logically and syntactically correct.  The input, output, and include files are also listed for completeness.  These files are included in the LANGS sub-directory on the distribution diskettes.

 

The list below shows the language, compiler and standard used to create the comparison charts and example programs.

 

          LANGUAGE          COMPILER                                                STANDARD                  

1.       Ada                       Meridian Ada 4.1                     ANSI/MIL‑STD‑1815A

2.       BASIC                  Microsoft GW‑BASIC 3.20

3.       C                          Microsoft C 5.0                                 ANSI C

4.       C++                      Borland Turbo C++ 2.0           AT&T C++ v2.0

5.       FORTRAN 77      Microsoft FORTRAN 77 3.3             ANSI FORTRAN 77

6.       Pascal                  Borland Turbo PASCAL 3.01A

 

This language transition kit, comprised of Appendices C and D, account for one-third of this User's Manual.  They are not really a necessary part of the "Numerical Analysis Algorithms in C' package, but they tremendously aid those who are new or "rusty" on their computer programming skills.

 


 

 

 

6.  Helps and Hints

 

 

This chapter contains many of the fine details that can make your use of this software package a pleasant experience.  Read each section as soon as possible to avoid wasting unnecessary time with tasks or problem solving.  The sections below are designed to save you time, improve your confidence in the algorithms, bring your attention to compiler and text errors, and help you customize the programs to best suit your needs.

 

 

6.1 Generally Nice To Know

 

The following sub-sections will give you a better understanding of how to manipulate and customize these algorithms.  They may even save you the trouble of learning any peculiarities of "Numerical Analysis Algorithms in C" the hard way.

 

 

6.1.1        Professor's Favorites, Must Have, Algorithms

 

Six algorithms have been included as requested by several Brigham Young University mathematics professors.  These programs are not included in the text, but serve to enhance it.  In reality, these are the programs that had to be included in order to persuade Brigham Young University to convert from FORTRAN to C.  Each of these programs are named with an "A.c" suffix.  These algorithms are:

 

          028A.c        - Complex Polynomial Solver (CPOLY)

          101A.c        - Steffenson's Method for Systems

          126A.c        - Parabolic Equations With Newton Iteration in 1-D

          127A.c        - Parabolic Equations With Newton Iteration in 2-D

          128A.c        - Elliptic Equations With Newton Iteration in 2-D

          129A.c        - Biharmonic Equation Using Gauss-Jordan Method

 

 

6.1.2        Homework Helper Algorithms

 

Each algorithm not specifically given in the text has a B, C, or D placed before the ".c" extension in its file name.  Roughly a third of all the programs included are modifications to the given text algorithms.  Many of them are requested as homework exercises.  These modifications range from implementing SIG-digit rounding, or adding Richardson's extrapolation, to solving for AX=B after performing matrix factorization.

 

Each program has a comment block at the top of the file.   This comment block also indicates which page of the text and which problem numbers to expect to use these "Homework Helper" algorithms.  This was included to show where these modifications fit into the text.

 

 

6.1.3        Optional Title

 

Each program begins by prompting for a one‑line title.  This title is printed to the output file for your convenience.  If you do not want a title then just enter a [RETURN] or [ENTER] and no title will be used.  To turn off the prompt for an optional title, simply change the TITLE_PROMPT flag to FALSE in the file "naautil.c."

 

 

6.1.4        Optional File Saving

 

Each program has a default output file name associated with it.  This file has the same name as the program being run, but with a ".out" extension.  The default setting in "naautil.c" is to create an output file as a program is run.  To run a program without saving the output to the default output file, just change the FILE_SAVE flag to FALSE in the file "naautil.c."

 

Errors may result if your disk is too full or the disk is write-protected while the FILE_SAVE flag is set to TRUE.

 

 

6.1.5        Finding Functions

 

Many of the algorithms require a function to be evaluated.  These algorithms can be found in chapters 2, 4, 5, 8, 11, and 12.  The functions are printed out to the screen and to the output file.  Each function needs changing in two places, once in the function itself, and once in the comments to be printed out.  Both of these are shown at the top of each program before main().  To aid you in finding these functions, search for the "$" character.  This is the only use of the "$" symbol throughout all the programs.

 

 

6.1.6        Using Default Inputs

 

Several of the programs ask if another input needs to be evaluated.  Make use of the default inputs as shown by just pressing the [ENTER] key.  This will make repetitious loops easier to use. Example:  "Evaluate another value of X? (Y/N) Y"  means just press [ENTER] for Yes.

 

There is no default for entering tolerances (TOL).  When shown one, it is a suggested tolerance, not a default.  Hitting [ENTER] will cause the program to keep waiting (blank stares) until a valid floating-point number is entered.

 

Entering text where numbers are expected or numbers where text is expected will cause the programs to "crash" and usually enter an infinite input loop.  This is characteristic of the scanf() function.  This unfortunate situation can usually be remedied by typing "[CONTROL] C".  Many of the algorithms perform user-friendly range checking, but not data type checking.

 

 

6.1.7        Changing Arithmetic Precision

 

There may be a "slight" difference to the solutions that these algorithms produce as compared to those shown in the text examples.  This is usually a result of different word sizes used in the computations (ie - float, double, long double).  This is a computer and compiler dependant situation and can be expected -- within reason.  Only deviations in the least significant digits should be noticeable.  An accumulation of this round-off error may result in the variation of even more significant digits.  See the header file <float.h> for the expected number of significant digits when using your C compiler.

 

Most digital computers use floating-point formats which provide a close but by no means exact simulation of real number arithmetic.  Among other things, the associative and distributive laws do not hold completely (i.e. order of operation may be important, repeated addition is not necessarily equivalent to multiplication).  Underflow or cumulative precision loss is often a problem.

 

Do not assume that floating-point results will be exact.  These problems are no worse for C than they are for any other computer language.  Floating-point semantics are usually defined as "however the processor does them;" otherwise a compiler for a machine without the "right" model would have to do prohibitively expensive emulations.  More accurate result can usually be obtained by increasing the precision from type "float" to type "double", or from type "double" to type "long double."

 

When changing a program's precision to or from different floating-point types, remember to change the following:

 

               FLOAT          DOUBLE         LONG DOUBLE

Variables:     float          double         long double

 

printf():      %f             %lf            %Lf

               %g or %G       %lg or %lG     %Lg or %LG

               %e or %E       %le or %lE     %Le or %LE

               % f, etc.      % lf, etc.     % Lf, etc.

               %.9f, etc.     %.16lf, etc.   %.25Lf, etc.

 

naautil.c:     vector();      dvector();

               matrix();      dmatrix();

 

naautil2.c:                                   ldvector();

                       ldmatrix();

 

Some C compilers may add an "f" prefix to their math functions to distinguish them as returning float types instead of the usual double type.  These may be implemented as compiler extensions (such as the MIPS C compiler) but are not part of the ANSI C standard.

 

        Float          Double

        fsin();        sin();

        fcos();        cos();

        ftan();        tan();

        fasin();       asin();

        facos();       acos();

        fatan();       atan();

        fsinh();       sinh();

        fcosh();       cosh();

        ftanh();    tanh();

 

 

6.1.8        Using Floating-Point Numbers in Functions

 

When modifying function equations, be sure to type all constants in floating-point format.  Good C compilers know that if one argument in an expression is a floating-point value then all integer types will be promoted (converted) to floating-point values.  There is no guarantee of getting a correct result especially since many older compilers do not implement strong prototyping.

A common error is to type:

 

          return ((3/2)*sin(x));     /* Bad Example */

 

instead of:

 

          return ((3.0/2.0)*sin(x));     /* Good Example */

 

The first expression returns "1*sin(x)" while the later returns "1.5*sin(x)".  The first is incorrect since with C integer arithmetic, 3/2 equals 1, being truncated to the nearest integer.  A "lazy man's" way is to type:

 

          return ((3./2)*sin(x));        /* Good Example */

 

 

6.1.9        The Pow() Function

 

Remember, pow() requires both arguments to be double-precision floating-point types (double).  For  instance, to raise 5.8 to the 3rd power, type "pow(5.8,3.0)" not "pow(5.8,3)".

 

 

6.1.10      Implementing SIG-Digit Rounding/Truncation

 

To modify a program to work with SIG‑digit rounding arithmetic, do the below steps:

 

NOTE:        To implement SIG‑digit truncation or chopping, replace the word "round" with the word "trunc".

 

Example:

#include "round.c" -‑‑> #include "trunc.c"

round(num,SIG) ----‑-‑> trunc(num,SIG)

 

1.       Add the below #include file:

 

                   #include "round.c" /* Rounds X to SIG significant digits. */

 

This file requires <float.h> and <math.h> which are already included inside of "naautil.c."

 

2.       Add to the global variable list, above main() (or locally inside of main() if round() is ONLY used inside main()), the following:

 

                   int SIG;

 

3.       Prompt for the number of significant digits, SIG, using the code:

 

  do {

    printf("Enter the number of significant digits, SIG (1‑%d): ",

      DBL_DIG);

    scanf("%d", &SIG);

    if (SIG < 1 || SIG > DBL_DIG)     /* Range checking */

      printf("Enter 1 to %d only for number of significant digits.\n",

        DBL_DIG);

  } while (SIG < 1 || SIG > DBL_DIG);

  fprintf(file_id, "Computed with %d‑digit rounding arithmetic.\n\n",

    SIG);

 

          NOTE:        DBL_DIG is defined in <float.h> and is usually has the value of around "10".

 

4.       Now, for EVERY number and after EVERY computation (ie‑ +,‑,*,/, pow(), sqrt(), etc.) add a line similar to the following:

 

              num = round(num, SIG);

 

or just "round(num, SIG)" if in the middle of an equation.

 

5.       (OPTIONAL) Change the output line to show only SIG digits using "*" and "SIG", like:

 

    printf("% *g ", SIG, X[i]);

 

6.       (OPTIONAL) Change all doubles to floats and all "%lg", "%lf", and "%le"'s to "%g", "%f", and "%e" as well as all dmatrix() and dvector() to matrix() and vector() as explained in Sub-Section 6.1.7.

 

7.       If the Tolerance is prompted for, like below:

 

        printf("Enter the tolerance, TOL (1.0e‑4): ");

        scanf("%lf", &TOL);

        fprintf(file_id, "Tolerance = %lg\n\n", TOL);

 

replace it with:

 

        TOL = 0.5*pow(10.0, ‑((double) SIG));

        fprintf(file_id, "Tolerance = %lg\n\n", TOL);

 

 

6.1.11      Floating-Point Output Alignment

 

Many of the programs attempt to print out answers in columns, such as for tables (chapters 2, 3, 5, 7‑12) and matrices (chapters 6, 7, 9).  Assuming the majority of the programs would be used for "normally small" numbers, printf() was used with "%g" and "%f" format arguments.  This can causes the output to appear unaligned if large numbers are printed along side small numbers.  If you would like to have the output align all the time then use "%e".  This forces ALL numbers to be of the form:

 

          ‑3.14159e‑002               [sign] [mantissa] e [[sign] exponent]

 

Alignment is guaranteed, but the numbers often take up more room than is necessary and can be less easy to read.

 

 

6.2 Converting Programs into Functions

 

After becoming familiar with several of these algorithms, many users desire to use them as stand-alone functions to be called from within other C programs.  Several books may be purchased which provide only functions, not stand-alone programs, such as the book "Numerical Recipes."  Extra care has been placed into all of the "Numerical Analysis Algorithms in C" programs to help make converting them into functions easier.

 

Modifying these algorithms to be FORTRAN callable is also possible.  The details for this procedure are too detailed and compiler dependent to be listed in this general-purpose User's Manual.

 

Converting a stand-alone algorithm into a function can be simpler than you might think.  Most of the process involves deleting the unnecessary input and output code.  An example using Algorithm 4.1 listed in Appendix A is given for completeness.

 

To convert a stand-alone program into a function, perform the following steps:

 

1.       Rename "main()" to a proper function name, such as "simpson()."  Be sure to place the appropriate return type (usually double) before the function name.  Example:

 

          From:          main()

          To:              double simpson()

 

2.       Separate the variables that follow "main()" into two groups: those to be passed as parameters and those that are internal to the function.  Refer to the INPUT section in the comments at the top of each algorithm to determine the passed parameters.  Place the passed parameters into the function parentheses, such as:

 

        double simpson (a, b, n)       /* K&R Style */

        double a, b;

        int n;

or

    double simpson (double a, double b, int n)  /* ANSI Style */

 

Ensure that the internal variables are placed after the first "{" character.

 

3.       Delete any unnecessary global variables, such as "char *outfile ..." and "char *eq_text_f ..."

 

4.       Replace all function definitions (not calls), such as f(x), with a proper prototype, such as:

 

    double f();    /* K&R Style */

or

    double f(double x); /* ANSI Style */

 

This instructs your C compiler that the function f receives a variable of type double and returns a result of type double.  Failure to do this may cause the function f to return erroneous integer results.

 

5.       Remove most all of the code under the INPUTS section.  You may want to keep any range checking code, such as:

 

        if (n <= 0) {

          printf("ERROR - n must be greater than zero.\n);

          exit (-1);           /* Exit to system */

    }

 

6.       Keep the code under the ALGORITHM section.  This will form the "brains" of the new function.

 

7.       Replace all of the code under the OUTPUTS section with a single return() statement.  The only exception would be to leave any "free_*()" calls.  The return() call should be the last statement of the new function.  The return value should match that in the top comments of the program.  For "041.C", use:

 

    return (XI);

 

8.       Double-check for and remove any unwanted printf() and scanf() routines.  Most mathematical functions do not use them.  Scanf() data should be passed to the function, while printf() output should be handled by the calling main program.

 

 

6.2.1        An Example Using Simpson's Rule

 

Algorithm 4.1 - Composite Simpson's Rule ("041.c") was converted into a stand-alone function named simpson() as shown below.  This function can also be found in the UTIL sub-directory in a file named "041fun.c."

 

/*********************************************************************

               Composite Simpson's Rule ‑ Algorithm 4.1

                       As A Stand‑Alone Function

**********************************************************************

 

                                !b

To approximate the integral I = *  f(x) dx:

                                "a

 

INPUT endpoints a, b; even positive integer n; the function f().

 

OUTPUT approximation XI to I.

 

NOTE: Listed as Simpson's Composite Rule in 3rd edition of the text.

 

**********************************************************************

*  Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 3Q 1991, v4.2  *

*********************************************************************/

 

#include "naautil.c"   /* Numerical Analysis Algorithms Utilities. */

double f(double x);            /* Function prototype */

 

 

double simpson (a, b, n)

double a, b;

int n;

{

  double h, X, XI, XI0, XI1, XI2, f();

  int i;

 

  if ((n <= 0) || (n % 2 != 0)) {     /* Range checking */

    printf("ERROR ‑ n must be even and greater than zero.\n");

    exit (‑1);                 /* Exit to system */

  }

 

  /*************

   * ALGORITHM *

   *************/

 

  /* STEP #1 */

  h = (b ‑ a)/n;

 

  /* STEP #2 */

  XI0 = f(a) + f(b);

  XI1 = 0.0;                   /* Summation of f(x(2i‑1)). */

  XI2 = 0.0;                   /* Summation of f(x(2i)).   */

 

  /* STEP #3 */

  for (i=1;i<n;i++) {

 

    /* STEP #4 */

    X = a + i*h;

 

    /* STEP #5 */

    if (i % 2 == 0)

      XI2 += f(X);             /* For even i. */

    else

      XI1 += f(X);             /* For odd i.  */

  }

 

  /* STEP #6 */

  XI = h*(XI0 + 2.0*XI2 + 4.0*XI1) / 3.0;

 

  return (XI);

 

}                              /* STOP */

 

/********************************************************************/

/*  Copyright (C) 1988‑1991, Harold A. Toomey, All Rights Reserved. */

/********************************************************************/

 

 

6.3 Using Input Files (*.IN)

 

An input file is provided in the IN sub-directory for each algorithm.  Each file contains the same name as the algorithm, but with a ".in" extension instead of ".c".  The contents of each input file match the examples given in the text following each algorithm.  They were used to create the accompanying output files for each algorithm in the OUT sub-directory.

 

Input files can be used to save time.  They are especially helpful when working with large arrays where only small changes are made from run to run.  Input files consist of simple text just as you would enter it if the program prompted you for it.

 

Please note that the input files provided with "Numerical Analysis Algorithms in C" require that the below "naautil.c" flags be set as follows:

 

        FLAG            SETTING

        TITLE_PROMPT   TRUE

    EQ_EVAL     FALSE

 

Input files can be redirected as input as a program is run.  For example, to "feed" Algorithm 4.1 with data from an input file, type one of the following:

 

MS-DOS:

          C:\NAA42> 041 < IN\041.IN

 

UNIX:

          % 041 < in/041.in

 

VAX/VMS:

$ DEFINE SYS$INPUT 041.IN  - assumes "041.IN" is in the current directory

$ RUN 041

$ DEASSIGN SYS$INPUT

 

MACINTOSH with THINK C 4.0:

 

To use redirection on a Macintosh with the THINK C 4.0 compiler, each algorithm must be modified as follows:

 

1.       Add these two lines of code just before main():

 

               #include <console.h>

        int ccommand (char ***p);

 

2.       Add arguments (parameters) to main() as shown below:

        main(int argc, char **argv)

 

3.       Just after the variable declarations for main() and before calling "NAA_do_first(outfile);", add:

 

        argc = ccommand(&argv);

 

After making these modifications, Algorithm 4.1 should look like this:

 

...

#include <console.h>

int ccommand (char ***p);

 

main(int argc, char **argv)

{

  double a, b, h, X, XI, XI0, XI1, XI2, f();

  int i, n;

 

  argc = ccommand(&argv);

 

  NAA_do_first(outfile);  /* NAA initialization procedure. */

  ...

    }

 

Be sure to link to the "ANSI" library.  It contains the ccommand() console command.

 

Now, when the modified algorithm is run, a command-line window will appear.  Ensure that the input file is in the same folder as "041.c" and enter: "041 < 041.in".

 

 

6.4 Using Output Files (*.OUT)

 

An output file is provided in the OUT sub-directory for each algorithm.  They contain the same name as the algorithms, but with a ".out" file extension instead of ".c".  The default name of an algorithm's output file can be easily changed by modifying "char *outfile = "nnn.out"; " at the top of each individual algorithm.  The contents of each output file match the examples given in the text following each algorithm.  They were created by redirecting the input files found in the IN sub-directory.

 

These output files can be used to verify that each algorithm is performing as expected.  Use them to compare your output results on your computer system.

 

Output files differ somewhat from what you see when a program is run.  Output files format the output into a more condensed and ready-to-print format.  They are created with calls to printf2() and fprintf(file_id,...) ONLY.  The FILE_SAVE flag in "naautil.c" must be set to TRUE to create output files.

 

 

6.5 Explanation of the Naautil.c File

 

The "naautil.c" file is the most important file of all the "Numerical Analysis Algorithm in C" files.  It contains functions and routines that are used in every algorithm.  It also allows these programs to work on many non-standard C compilers.  The "naautil.c" file should be included in all of the programs using #include "naautil.c".

 

If your C compiler is not truly ANSI C compliant, the "naautil.c" file will be the first to correct it or the first to cause error messages.  The complete source code for "naautil.c" is listed in Appendix B.  This file also contains several flags or #define statements which you can set to get the most out of these algorithms.

 

"Naautil.c" also defines the constant B (PI) . 3.14159..., although it can often be found in some system header files.  It is most useful in trigonometric functions.  The constants "TRUE" and "FALSE" are also defined just in case the system header files fail to define them.

 

 

6.5.1        #Define Flags

 

"Naautil.c" has eight flags that can be set.  Most are usually set only once.  An explanation of each flag is given below.

 

ANSI:

If your compiler supports the ANSI C standard, then set ANSI to TRUE.  Set ANSI to FALSE only if the programs will not compile with it set to TRUE.  This flag is used for strong prototyping of functions.  It is used by all of the supporting ".c" files and in the utilities as well.

 

ANSI_FUNCT:

This flag should be set to TRUE to use ANSI style functions.  Setting it to FALSE should work on truly ANSI compliant compilers as well.  See Section 9.1 for an example.  This flag must be set to TRUE for THINK C 4.0 on a Macintosh.

 

FILE_SAVE:

If you would like to save the output of the algorithms to a file, then set FILE_SAVE to TRUE.  The output is still printed to the screen as you run the program.  Set it to FALSE if you do not plan to save the output to a file.  Used only in the functions printf2(), NAA_do_first(), and NAA_do_last().

 

TITLE_PROMPT:

If you would like to be prompted for an optional title at the start of each program, then set TITLE_PROMPT to TRUE.  This is useful when the output is to be handed in as homework, allowing the user's name or the problem number to be entered.  Hitting the [ENTER] key, instead of text for a title, causes no title to be printed to the output file.  Set it to FALSE if you do not want to be bothered with entering a title every time you run an algorithm.  Used only in the function NAA_do_first().

 

EQ_EVAL:

Several of the algorithms require a single function to be evaluated.  Set EQ_EVAL to TRUE if you wish to enter the function during run-time instead of at compile time.  A couple of simple modifications were made to the algorithms to allow this option to work.  See Chapter 8 - "The Equation Evaluator Routines" for instructions on using this option.

 

When this flag is set to TRUE, the 1000+ line file "eqeval.c" is included into "naautil.c" and compiled with the algorithm.  This flag is used in the function NAA_do_first() as well as in "041ee.c" and "ee.c" in the UTIL sub-directory.

 

NAAUTIL_OBJ:

This option is useful for frequent users who wish to speed up the compilation process.  It should be set to TRUE only if "naautil.c" has been pre-compiled into object code.  See Section 6.6 - "Using Naautil.c as Object Code" for more details.

 

OLD_UNIX_OS:

This flag is only necessary for older UNIX computers which use <varargs.h> instead of <stdarg.h> as the header file for variable length argument lists.  Variable length arguments are used only in printf2() and in "eqeval.c" 's eval_eq() routine.

 

NO_LONG_DOUBLES:

Set this flag to TRUE if you are not using the "long double" type routines for higher precision, or if your compiler does not support the "long double" type.  The "long double" type is used in several routines in "naautil2.c", but is not used in any of the algorithms.  It is provided for the user to obtain more accurate numeric results wherever float of double types are being used.  This flag should be set to TRUE for some VAX C compilers.  Setting this flag to FALSE will compile six routines which take about 1K bytes of object code.

 

 

6.5.2        Flag Default Settings

 

        FLAG           SETTING

        ANSI           TRUE

        ANSI_FUNCT     FALSE       (Is set to TRUE on Macintosh disks)        

        TITLE_PROMPT   TRUE

        FILE_SAVE      TRUE

        EQ_EVAL        FALSE       (Set to TRUE when using "041ee.c")

        NAAUTIL_OBJ    FALSE

        OLD_UNIX_OS    FALSE

        NO_LONG_DOUBLES TRUE

 

        EQEVAL_OBJ  FALSE       (In "eqeval.c" only)

 

 

6.5.3        Description of the Routines

 

The "naautil.c" file contains the following procedures and functions:

 

          Return                  Procedure

          Value          Name                             Description

                   void    naaerror         Exits program with an error message

 

                   double** dmatrix         Allocates a 2‑D array of doubles

                   float** matrix           Allocates a 2‑D array of floats

                   double* dvector          Allocates a 1‑D array of doubles

                   float*  vector           Allocates a 1‑D array of floats

                   int*    ivector          Allocates a 1‑D array of integers

                   void    free_dmatrix     Frees the allocated 2‑D array memory

                   void    free_matrix      Frees the allocated 2‑D array memory

                   void    free_dvector     Frees the allocated 1‑D array memory

                   void    free_vector      Frees the allocated 1‑D array memory

                   void    free_ivector     Frees the allocated 1‑D array memory

 

                   int     printf2          Like printf(), but writes to a file as well

                   void    NAA_do_first     NAA initialization procedure

                   void    NAA_do_last      NAA final procedure

 

Some of these functions can be found in the book "Numerical Recipes in C".  They have been tailored for "Numerical Analysis Algorithms in C."

 

 

naaerror():

 

This Numerical Analysis Algorithms Error handler prints error messages then exits the program to the operating system.  It is used by most of the routines found in "naautil.c", "naautil2.c" and "naautil3.c" as well as in several of the algorithms.

 

 

dmatrix():

 

"Naautil.c" defines five routines for allocating 1-D and 2-D arrays.  These are:

 

          ivector()         Allocates a 1‑D array of integers

          vector()           Allocates a 1‑D array of floats

          dvector()         Allocates a 1‑D array of doubles

          matrix()           Allocates a 2‑D array of floats

          dmatrix()         Allocates a 2‑D array of doubles

 

These routines are often used instead of conventional arrays.  For example:

 

          double **A;

          A = dmatrix(0,9,0,11); /* Dynamic method */

 

replaces

 

          double A[10][12];      /* Array method */

 

These simple routines are used for three reasons: speed, flexibility, and efficiency.

 

Speed:

For the 2-D array above, referencing two pointers (2 adds) to obtain a value is usually faster than using an add and a multiply (1 add + 1 multiply) inherent when indexing arrays.  The array "A" is used identically in both situations.  To obtain this speed, a few more bytes of memory are used to store a row of pointers.

 

Flexibility:

With the array method, the number of elements for each dimension are specified.  The above example uses 10 rows and 12 columns.  These must be referenced from 0 to 9 and 0 to 11 respectively.  With the dmatrix() routine, the RANGES of the elements for each dimension are specified.  This makes it easier to work with arrays which are not referenced from 0 to n-1.  Even negative ranges may be specified, such as dvector(-2,3).

 

For example, assume we need to sum five elements from 5 to 10.  The dvector() routine could be used to allocate storage space as follows:

 

          double *B;

          B = dvector(5,10);

 

The sum of i from 5 to 10 could be easily implemented with:

 

          for (i=5;i<=10;i++)

            sum = sum + B[i];

 

Efficiency:

As seen by the above implementation, B stores only 6 elements.  If we used "double B[6];" (the array method) we would be required to adjust the index, i, or to just declare B with 11 elements "double B[11];" for readability.  This would waste 5 elements!  The matrix and vector routines never waste variables since you only declare what you will use.

 

The matrix and vector routines call calloc() to dynamically allocate memory.  This means a program which operates on an array of n x n elements needs to allocate only n x n elements.  With the array method, the largest anticipated array must be declared which is usually wasteful (consider A[100][100] for a simple 4 x 4 matrix operation!).

 

"Naautil2.c" contain more matrix and vector routines for other variable types.  It also defines cube routines (like dcube()) for 3-D matrices.  These are fast but utilize an extra array of pointers as a trade off.  "Naautil3.c" contain vector, matrix and cube routines for complex data types.

 

If your older C compiler does not have calloc() implemented, use "calloc.c" inside the UTIL sub-directory.  Malloc() could also be used only if every vector, matrix and cube element is initialized to zero before using them in each algorithm.

 

 

free_dmatrix():

 

Every vector, matrix, and cube routine has a free_ routine to match it.  The free_ routines, like free_dmatrix(), de-allocate the memory allocated by the vector, matrix, and cube routines.  These are particularly useful if the algorithms are to be converted into stand-alone functions.  Some older compilers require that the free_ routines be called in reverse order from the vector, matrix, and cube routines which allocated the memory blocks.  This reverse ordering style has been used with all of the algorithms.

 

 

printf2():

 

This simple routine works exactly like printf(), but it sends its output to a file as well.  The output file is the one defined at the top of each algorithm (char *outfile), which gets assigned to the file pointer "file_id."  It is used frequently in the algorithms to make the source code shorter and easier to read.  It uses variable length arguments which are often non-portable to non-ANSI compliant compilers.

 

Two separate versions of this routine are provided.  The first uses <varargs.h> as the header file and is included for older UNIX C compilers.  The second uses <stdarg.h> as the header file and is ANSI compliant.  Only one of these routines can be used at a time.  The OLD_UNIX_OS flag determines which routine is selected, assuming the FILE_SAVE flag is set to TRUE.

 

 

NAA_do_first():

 

This routine is used in every algorithm as the first executable statement.  It performs four main functions and is dependant upon several flag settings:

 

1.                Opens the output file for writing (if FILE_SAVE == TRUE)

2.                Prints the "Numerical Analysis Algorithms in C" banner

3.                Prompts for an optional title (if TITLE_PROMPT == TRUE)

4.       Prompts for the use of the Equation Evaluator routines and gets the equation (if EQ_EVAL == TRUE)

 

 

NAA_do_last():

 

This routine is used in every algorithm as the last executable statement.  It simply closes the output file opened by NAA_do_first() and informs the user that a file has been created.  This routine is used only when the FILE_SAVE flag is set to TRUE.

 

 

6.6 Using Naautil.c as Object Code

 

Each of the algorithms use the file "naautil.c."  Both the "naautil.c" and "eqeval.c" files can be easily compiled into object code once and then used thereafter ("naautil.c" includes "eqeval.c" if the EQ_EVAL flag is set to TRUE).  This can save hours of recompilation time, especially when using many algorithms over a period of time, like for a numerical methods course.  The below sub-sections describe this procedure for different computer systems.  The files described in Section 7.3 - "Time-Saving Batch, Script and Command Files" contain commented-out code to do this as well.

 

Note that if any flags are changed in "naautil.c", then it must be recompiled into object code again before the changes can take effect.  This includes changing the TITLE_PROMPT, FILE_SAVE, and EQ_EVAL flags.

 

 

6.6.1        MS-DOS

 

Object code files in MS-DOS have a ".OBJ" extension.  To create object code, do the following:

 

1.       Set the NAAUTIL_OBJ flag to FALSE in "naautil.c"

 

2.       Compile "naautil.c" into object code by typing the following command at the DOS prompt:  (assumes Microsoft C 5.0)

 

    C:\NAA42> CL /c NAAUTIL.C

 

3.       Set the NAAUTIL_OBJ flag back to TRUE in "naautil.c"

4.       From now on, compile the algorithms into object code, then link "naautil.obj" to them.  For example, using "041.c", type:

 

        C:\NAA42> CL /c 041.C

    C:\NAA42> CL 041 NAAUTIL

 

The first command creates "041.obj" while the second command links it to the "naautil.obj" object file to form the executable "041.exe."

 

 

6.6.2        UNIX

 

Object code files for UNIX have a ".o" extension.  To create object code, do the following:

 

1.       Set the NAAUTIL_OBJ flag to FALSE in "naautil.c"

 

2.       Compile "naautil.c" into object code by typing the following at the shell prompt:

 

    % cc ‑c naautil.c

 

3.       Set the NAAUTIL_OBJ flag back to TRUE in "naautil.c"

 

4.       From now on, compile the algorithms along with "naautil.o." For example, using "041.c", type:

 

    % cc 041.c ‑o 041 naautil.o ‑lm

 

 

6.6.3        Macintosh

 

Object code files for THINK C on a Macintosh are indicated in the project window by a non-zero size after the source file's name.  To create the object code, do the following:

 

1.       Set the NAAUTIL_OBJ flag to FALSE in "naautil.c"

 

2.       Compile "naautil.c" into object code.

 

3.       Set the NAAUTIL_OBJ flag back to TRUE in "naautil.c"

 

4.       From now on, compile the algorithm into object code, then link the "naautil.c" object code to it.

 

You may have trouble if the compiler asks to bring the "naautil.c" file up to date after step #3 above.  This may happen since setting the NAAUTIL_OBJ flag back to TRUE in "naautil.c" marks it as no longer current.  Bringing the folder up to date, including "naautil.c", would remove the routines from the object code compiled in step #2.

 

 

6.6.4        VAX/VMS

 

Object code files for VAX/VMS have a ".OBJ" extension.  To create the object code, do the following:

1.       Set the NAAUTIL_OBJ flag to FALSE in "naautil.c"

 

2.       Compile "naautil.c" into object code by typing the following at the VMS prompt:

 

    $ CC /G_FLOAT NAAUTIL.C

 

3.       Set the NAAUTIL_OBJ flag back to TRUE in "naautil.c"

 

4.       From now on, compile the algorithm into object code, then link "naautil.obj" to it.  For example, using "041.c", type:

 

        $ CC /G_FLOAT 041.C

    $ LINK 041, NAAUTIL, LNK$LIBRARY/LIB, LNK$LIBRARY_1/LIB

 

The first command creates "041.obj" while the second command links it to the "naautil.obj" object file to form the executable "041.exe."

 

 

6.7 Supporting C Source Code Usage List

 

The list below outlines the support files used by each chapter:

 

                                COMPLEX.C             ROUND.C

                                   and                  and

Chapter  NAAUTIL.C  NAAUTIL2.C  NAAUTIL3.C  GAUSSJ.C  TRUNC.C EQEVAL.C

  1         X                                                    X

  2         X                       X                            X

  3         X                                          X       X

  4         X                                            X       X

  5         X                                                    X

  6         X                                  X         X

  7         X                                           

  8         X           X           X          X                 X

  9         X                                  X        

  10        X                                  X

  11        X                                  X

  12        X           X                                        X

 

File usage by name:

 

          NAAUTIL.C           - All .C files

          NAAUTIL2.C         - 081.C and 125.C   

          NAAUTIL3.C         - 027.C, 028A.C, and 081.C

          COMPLEX.C        - Used in NAAUTIL3.C only

          GAUSSJ.C           - 060B.C, 080B.C, 093.C, 101.C, 101A.C, 102.C, 116.C, 125.C and 129A.C

          ROUND.C            - 031B.C, 040D2.C, 061B.C, 061C2.C, 061D2.C, 062B.C, 063B.C, 074.C, and 095D.C

          TRUNC.C             - Not used.  May replace ROUND.C in the homework exercises for chopping arithmetic.

          EQEVAL.C           - See Section 8.8 for a list.

 

 

6.8 "Numerical Analysis" Text Errors and Corrections

 

This section lists a few errors encountered in the texts as the algorithms were being programmed into C.  Many of the algorithms will not work correctly without these corrections.  The errors are listed separately for the third and fourth editions of the text.  Perhaps a more complete list of corrections may be obtained from the publisher, PWS-Kent Publishing Company, 20 Park Plaza, Boston, Massachusetts  02116.

 

 

6.8.1        3rd Edition Errors

 

TEXT ERRORS AND CORRECTIONS

for

"Numerical Analysis", third edition,

Richard L. Burden & J. Douglas Faires, 1984

 

 

Page#   Location       Fix

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

345     Algorithm 6.5  In Step 7, only swap a few elements in matrix L.  Use: For k = 1 to i‑1, swap L(p,k) with L(i,k).  This does not apply to matrix A.

 

472     Algorithm 8.9  Comments say: OUTPUT A(n‑1).  (Could over‑write A.)  It should say: ...            (Do not over‑write A.)  Over‑writing A will give different answers.  Use A1 for A(k) and A2 for A(k+1).

 

At Step #10, 5th line, Don't indent "set a(l,l) = a(l,l) ‑ 2*v(l)*z(l);"

 

514     Algorithm 9.3  From ‑‑> Step 5:  g3 = G(x ‑ "3*z).

                       To ‑‑‑‑> Step 5:  g3 = G(x + "3*z).

 

                       From ‑‑> Step 13:  Set x = x + "*z.

                       To ‑‑‑‑> Step 13:  Set x = x ‑ "*z.

 

658     Answers p. 484 The answer to 1 e) should be:

 

                       [ 4      0         0         0    ]

                       [ 0      4     1.414213      0    ]

                       [ 0  1.414213      4     1.414213 ]

            [ 0      0     1.414213      4    ]

 

 

6.8.2        4th Edition Errors

 

TEXT ERRORS AND CORRECTIONS

for

"Numerical Analysis", fourth edition,

Richard L. Burden & J. Douglas Faires, 1988

 

 

 

Page#   Location       Fix

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

79      Algorithm 2.7  From ‑‑> Step 1:  i = 2.

                       To ‑‑‑‑> Step 1:  i = 3.

 

                       From ‑‑> Step 4:  E = b + d;

                                         E = b ‑ d;

                       To ‑‑‑‑> Step 4:  E = b + D;

                                         E = b ‑ D;

                       (Third edition used d where D is now.)

 

273     Algorithm 5.5  Steps 17, 18 and 19 are indented one level too far.  This tends to mislead programming efforts.

 

372     Middle         From ‑‑> Step 10  For ... E l(i,j) * x(j)

                       To ‑‑‑‑> Step 10  For ... E l(j,i) * x(j)

 

        Bottom         From ‑‑> Step 11 For ... E l(i,j) * y(j)

                       To ‑‑‑‑> Step 11 For ... E l(j,i) * x(j)

 

370     Algorithm 6.5  Add a Step 0 to initialize matrix L as an identity matrix.  IE ‑ 0's every where except for 1's on the diagonal elements.

 

                       From ‑‑> Step 2  ... set v(j) = a(i,j) * d(j)

                       To ‑‑‑‑> Step 2  ... set v(j) = l(i,j) * d(j)

 

                       From ‑‑> Step 3  ... E a(i,j) * v(j)

                       To ‑‑‑‑> Step 3  ... E l(i,j) * v(j)

 

                       From ‑‑> Step 4  ... E a(j,k) * v(j) ...

                       To ‑‑‑‑> Step 4  ... E l(j,k) * v(j) ...

 

478     Algorithm 8.1  Step 1  ... zeta = e(B*i/m) is a definition (used in Step 3), not a step to implement as code.

 

                       At Step 8, K1 is never used, just defined.

 

479     Bottom         From ‑‑> + 0.02870726 cos 8z ‑ ...

                       To ‑‑‑‑> + 0.05741474 cos 8z ‑ ...   (double it)

 

494     Algorithm 9.1  Swap Step 6 with Step 7.

 

501     Algorithm 9.3  Swap Step 7 with Step 8.

 

514     Algorithm 9.5  Add a modification to Step 7:

        Modifications  From ‑‑> Set PROD = SUM V(i) * U(i).

                       To ‑‑‑‑> Set PROD = SUM V(i) * (U(i) + Y(i)).

                       See Algorithm 9.5C for the correct implementation.

 

547     Algorithm 10.2 Add to the end of Step 3:  k = k + 1.

 

548     Algorithm 10.2 From ‑‑> Step 8 ... (Note: ... (S_k + A...) )

                       To ‑‑‑‑> Step 8 ... (Note: ... (S_k ‑ A...) )

 

554     Algorithm 10.3 From ‑‑> Step 1  Set k = 0.

                       To ‑‑‑‑> Step 1  Set k = 1.

 

555     Algorithm 10.3 Indent Step 7 and Step 8.

 

                       Step 12 is different from the third edition of text.

 

653     Algorithm 12.5 From ‑‑> Step 12 ... a(l)(l) = alpha(l)(l) + z...

                       To ‑‑‑‑> Step 12 ... alpha(l)(l) = alpha(l)(l) + z...

 

                       Steps 11 and 18 have been indented incorrectly.

                       From ‑‑>  If ...

                                     If ...

                                         else ...

                                     else ...

                                         if ...

                       To ‑‑‑‑>  If ...

                                     If ...

                                     else ...

                                 else ...

                                     if ...

 

709     Answers p. 514 The answer to 3 c) should be:

 

               [      5    ‑4.949747468  ‑1.432078021  1.564976850 ]

               [ 1.414213562     ‑2       2.485551468  1.822644754 ]

               [      0     5.431390246  ‑1.423728814  2.648654214 ]

        [      0           0      ‑1.593986473  5.423728814 ]

 

 

6.9 Watch for These Run-Time Errors

 

On occasion, run-time errors may occur.  Run-time errors are errors which occur as a program is being executed.  Most run-time errors are legitimate and can be easily corrected.  These next few sub-sections outline the most common errors and how to correct them.

 

 

6.9.1        Stack Space

 

Several of the programs require more stack space than the others.  The following programs require a stack larger than 2K bytes:

 

          028A.c  - Complex Polynomial Solver (CPOLY)

          056.c   - Extrapolation

          081.c   - Fast Fourier Transformation

 

In Microsoft C 5.0 with MS-DOS, this problem is solved by specifying a larger stack size to the linker.  For example:

 

          C:\NAA42> CL 028A.C /link /ST:4096 - For a 4K byte stack in decimal

or

          C:\NAA42> CL 028A.C /F 1000        - For a 4K byte stack in hexidecimal

 

 

6.9.2        Division By Zero

 

Division by zero is a common error for fixed-point algorithms and for equations using division.  Algorithms 2.2 and 10.1A are particularly susceptible to fixed-point errors (x = g(x)).  Fixed-point errors can usually be corrected by solving for a different x = g(x) in the equation.

 

Division by zero can occur in algorithms like Algorithm 4.1 - Composite Simpson's Rule.  Trying to integrate the integral below would cause this error to occur due to the lower bound being zero.

    !1

    |  1/x dx

    "0

 

This problem can sometimes be corrected by breaking the integral up into parts, making a "u" substitution, or by making zero a small value (try DBL_EPSILON as defined in <float.h>) and accept the reduced accuracy errors.

 

 

6.9.3        Null Pointer Assignments

 

If arrays created by the "naautil*.c" vector, matrix, and cube routines are referenced outside their legal ranges, the "Null Pointer Assignment" error may occur.  Incorrect use of the free_ routines, such as free_dmatrix(), will also cause this error.

 

For some strange reason, there is an error like this in Algorithm 12.5 with Microsoft C 5.0.  To correct this particular problem, the free_dmatrix() routine was simply commented out without introducing errors to the algorithm.

 

 

6.9.4        No Disk Space

 

The "No Disk Space" error occurs when a disk is full or when the disk is write-protected.  This can be corrected by either removing unnecessary files from the disk (especially executables) or by removing the write-protect sticker or tab from the disk.

 

 

6.9.5        Floating-Point Accuracy

 

Computers inherently round all floating-point numbers.  They are usually only as accurate as the largest word size on the computer or by the size of the internal registers of the math processor chip.  See the system header file <float.h> for your compiler's accuracy limits.

 

Listed are some typical values defined in <float.h>:

 

          FLT_DIG 6       - decimal digits of precision for floats

          DBL_DIG 10      - decimal digits of precision for doubles

          FLT_MAX 1E+37   - maximum floating-point number for floats

          FLT_MIN 1E-37   - minimum floating-point number for floats

          DBL_MAX 1E+308  - maximum floating-point number for doubles

          DBL_MIN 1E-308  - minimum floating-point number for doubles

 

DBL_DIG is used in routines adapted to use "round.c" or "trunc.c", such as Algorithm 6.1C2.  It specifies a range for the number of significant (SIG) digits you can enter.

 

 

6.9.6        Program Stuck in an Infinite Loop

 

The scanf() and getchar() functions are used to get all of the inputs for the "Numerical Analysis Algorithms in C" algorithms.  They may get stuck in an infinite loop if a letter is entered where a number is expected, or vise versa.

To correct this problem, exit the program (usually by hitting "[CONTROL] C") then execute the program again, this time entering the correct responses.  The code needed to check for errors of this nature would have introduced unnecessary overhead and would have made the programs less readable.



 

 

 

7.  Useful Utilities

 

 

The utilities listed below are found in the UTIL sub-directory on the distribution diskettes.  None of these utilities are absolutely necessary, but they may make life easier on your part if you use them.  "Convert.c" will make the algorithms have respectable looking output if uploaded to non-MS-DOS computer systems.  "List.com" is a handy tool for quickly viewing the output files created by these programs.  Several files are also included to make compiling and running these algorithms a little easier.

 

 

7.1 Convert.c - Converting Files from Extended ASCII to Standard ASCII

 

Past versions of "Numerical Analysis Algorithms in C" came in an extended ASCII version (v4.1) and a standard ASCII version (v4.11).  "Convert.c" was written to eliminate the need for having two different versions.  Macintosh disks ship with standard ASCII only.

 

 

7.1.1        Why Convert.c is Needed

 

Many programs use the extended ASCII character set available on MS‑DOS computers.  These extra 128 characters may translate into garbage when uploading files onto UNIX or VAX computers.  Standard ASCII uses 7‑bits per character while extended ASCII uses 8‑bits per character.  When extended ASCII characters are uploaded to standard-ASCII‑only platforms, the 8th bit is masked off (set to zero) converting them into 7‑bit ASCII characters.  To avoid the ill effects of this masking, this program has been provided.  It converts any MS‑DOS text file into standard-ASCII‑only files, making the appropriate character substitutions.

 

Failure to use "convert.c" may produce results like those shown below after the files are uploaded to a non-MS-DOS platform:

 

    normal         w/ convert.c   w/out convert.c      w/out convert.c

                                    7‑bit ASCII          8‑bit ASCII

 

     ! B              [ PI             t c              \364 \343

     * f(x)           | f(x)           3 f(x)           \263 f(x)

     " "              ] alpha          u `              \365 \340

                                                        (in octal)

 

See the Examples Book for the C source code for "convert.c."  This file contains a table called ASCIIlist[] which contains the extended ASCII characters and their suggested standard ASCII substitutions.  This table can be easily modified by the user, but doing so requires "convert.c" to be recompiled.  "Convert.c" has been compiled into "convert.exe" for MS-DOS computers and is shipped with the distribution diskettes.

 

The advantages of running the files through convert is that they can be ported to any machine, especially UNIX systems, with terminals only capable of displaying standard ASCII.  The disadvantages are that you no longer have the proper symbols like those used in chapter 4 of the text for integration, or $, #, x², and numerous Greek symbols often used in mathematics.

 

Examples of the most commonly used extended ASCII characters and their closest substitutions are shown below:

 

        ASCII                          ASCII

        Number  Char    Substitute     Number  Char    Substitute

        129     ü       u              238     ,       E or epsilon

        179     *       |              240     /       =

        224     "       alpha          241     ±       +/-

        225     ß       beta           242     $       >=

        227     B       PI             243     #       <=

        228     E       Summation of   244     !       [

        230     µ       mu             245     "       ]

        232     M      phi            247     .       =

        235     *       d or delta     253     ²       ^2

        236 4   oo or infinity

 

 

7.1.2        How to Use Convert.c

 

Before using the convert program, MAKE A SET OF BACKUP DISKETTES for "Numerical Analysis Algorithms in C"!  Convert over-writes the original files with the newly converted files.  Failure to make a set of backup diskettes will remove the option of ever going back to the extended ASCII version of the files.  In other words, convert is one-way.

 

"Convert.c" will convert a single file or a list of files.  To convert a single file, type:

 

          C:\> CONVERT FILE_NAME

 

where "file_name" is the name of the desired file, such as "041.c."  To convert a list of files, first create a list using a standard text editor ("file_name [ENTER]" format), then type:

 

          C:\> CONVERT ‑L FILE_NAME_LIST

 

where "file_name_list" is the name of the file containing a list of file names you desire to convert.

 

For your convenience, two lists are provided: "LISTALL" and "LISTOUT."  "LISTALL" is a file name list which contains all of the algorithms, support files, and documentation (except "convert.c").  "LISTOUT" is a file name list containing all of the algorithm output file names in the OUT sub-directory.  Together these two file will convert all of the necessary "Numerical Analysis Algorithms in C" files into standard ASCII files.

 

To create a standard ASCII set of files, do the following:

 

1.       Make a set of backup disks.  See your operating system manual for specifics.

 

2.       Change to the directory containing the algorithms (assume C:\NAA42 in this example).  For example:

 

    C:\> CD \NAA42

 

3.       Convert all of the files inside the main directory.  Do this by typing:

 

    C:\NAA42> UTIL\CONVERT -L UTIL\LISTALL

 

Wait a few minutes until the conversion is finished.

 

4.       Now convert all of the files inside the OUT sub-directory.  This step is optional.  Do this by typing:

 

        C:\NAA42\> CD OUT

    C:\NAA42\OUT> ..\UTIL\CONVERT -L ..\UTIL\LISTOUT

 

NOTE:        The above steps can be done on a non-MS-DOS computer if the files are transferred as binary files.  See Section 2.1 - "Uploading to Mainframe Computers" and use the "SET BINARY" option of KERMIT.  "Convert.c" will naturally need to be recompiled on the new host computer.

 

 

7.2 List.com - A Better TYPE Command

 

"List.com" is an MS-DOS program which acts as a better "TYPE" command.  It uses the arrow keys and other editing keys to view text files.  "List.com" does not allow you to edit files, just view them.  It is a public domain program.

 

To use "list.com" to view the output of Algorithm 4.1, type:

 

C:\> LIST 041.OUT

 

To scroll the text left, right, up or down, use the arrow keys.  Typing 'X' exits "list.com."  Typing '?' brings up a help menu.  These commands and more are shown at the bottom of the "list.com" screen.

 

 

7.3 Time-Saving Batch, Script and Command Files

 

The files below can be use to simplify how you compile and run these algorithms.  One is included for Microsoft C 5.0 on an IBM PC, one for UNIX, and one for VMS on a VAX.  The actual commented files are also listed below:

 

 

7.3.1        CC.BAT

 

The batch file "cc.bat" can be used in place of the Microsoft C 5.0 "CL" command under MS-DOS.  It contains the following:

 

          CL /Od /qc %1.c

          IF ERRORLEVEL 1 GOTO END

          %1

          LIST %1.OUT

          :END

To use it, type: "C:\> CC 041" where 041 is an algorithm file name.    Be sure to leave off the ".c" extension.  "Cc.bat" will do the compiling, running, and will list the output file.

 

Commands are also listed to produce and use "naautil.c" as object code.  Read the comments in this batch file for further instructions or see Section 6.6 - "Using Naautil.c as Object Code".

 

Below is a listing of the "cc.bat" batch file:

 

:*********************************************************************

:  Program:  CC.BAT  (MS‑DOS batch file)

:

:  Purpose:

:    Cc.bat is an MS‑DOS batch file used for compiling, running and

:    viewing a Microsoft C 5.0 program.  It can be easily altered to

:    allow for linking to "NAAUTIL.OBJ" (with or without "EQEVAL.C"),

:    speeding up the compile time.  Can also be altered to increase

:    the stack size of a program.

:

:  Written By:  Harold A. Toomey

:  Date:        21 Aug 1991

:

:  Example:  C:\> CC 041   where "041.C" is the file name.

:                          (Leave off the .C extension)

:*********************************************************************

:

:  Do a compile and link (CL), disabling optimization (/Od) and

:  invoke the QuickC compiler option (/qc) to shorten the compile

:  time.

:

CL /Od /qc %1.c

:

:  Replace the main line above with the line below if a larger stack

:  is needed.  This allows for a stack size of 4K bytes (/link

:  /ST:4096).  A MUST when compiling algorithms 2.8A, 5.6 and 8.1. 

:

: CL /Od %1.c /link /ST:4096

:

:  Replace the main line above with the two lines below if

:  "NAAUTIL.C" has been compiled and exists as object code

:  ("NAAUTIL.OBJ").  The first line creates %1.OBJ while the second

:  line links %1.OBJ to "NAAUTIL.OBJ" to form %1.EXE.  (Most

:  flexible)

:

: CL /Od /c %1.c

: CL %1 NAAUTIL

:

:

:  Create "NAAUTIL.OBJ" object code by running the below step once.

:  Remember to re‑compile "NAAUTIL.C" every time one of its flags

:  are changed.

:

: CL /c NAAUTIL.C

:

:

:  If the program compiled correctly, then run it.  If not, exit

:  this batch file.  Replace "%1" with "%1 < IN\%1.IN" if using the

:  input file for initial testing.

IF ERRORLEVEL 1 GOTO END

%1

:

:  View the program's output file using "LIST.COM".  You may

:  substitute DOS's TYPE command for "LIST.COM."

LIST %1.OUT

:END

:*********************************************************************

 

 

7.3.2        CCC

 

The script file "ccc" can be used in place of the "cc" command under UNIX.  It contains the following:

 

          cc $1.c -o $1 -lm

          $1

          more %1.out

 

To use it, type: "% ccc 041" where 041 is an algorithm file name.    Be sure to leave off the ".c" extension.  "Ccc" will do the compiling, running, and will list the output file.  You may want to make "ccc" a UNIX (csh) script file.  To do this, type "% chmod +x ccc" only once.  The alternative is to type "% source ccc 041" every time you use "ccc".

 

Commands are also listed to produce and use "naautil.c" as object code.  Read the comments in this script file for further instructions or see Section 6.6 - "Using Naautil.c as Object Code".

 

Below is a listing of the "ccc" script file:

 

#*********************************************************************

#  Program:  ccc  (UNIX script file)

#

#  Purpose:

#    Ccc is a UNIX script file used for compiling, running, and

#    viewing a mathematical C program.  It can be easily altered to

*    allow for linking to "naautil.o" (with or without "eqeval.c"),

#    speeding up the compile time.

#

#  Written By:  Harold A. Toomey

#  Date:        21 Aug 1991

#

#  Example:  % ccc 041   where "041.c" is the file name.

#                        (Leave off the .c extension)

#*********************************************************************

 

echo Compiling $1.c

 

#  Compile the program and name the executable the same as the

#  original file except with no extension.  Links to the math library

#  (located in /usr/lib/libm.a).

 

cc $1.c ‑o $1 ‑lm

 

#  Replace the above "cc" line with the below "cc" line to link to

#  the pre‑compiled "naautil.c" object code file.

#

# cc $1.c ‑o $1 naautil.o ‑lm

#

#

#  Create "naautil.o" object code by running the below step once.

#  Remember to re‑compile "naautil.c" every time one of its flags

#  are changed.

#

# cc ‑c naautil.c

#

 

#  Run the program

$1

 

#  View the program's output file

more $1.out

#*********************************************************************

 

 

7.3.3        VAXCC.COM

 

The command file "vaxcc.com" can be used in place of the VAX "CC" and "LINK" commands under VAX/VMS.  It contains the following:

 

          $ DEFINE LNK$LIBRARY    SYS$LIBRARY:VAXCRTLG

          $ DEFINE LNK$LIBRARY_1  SYS$LIBRARY:VAXCRTL

          $ CC /G_FLOAT 'P1'.C

          $ LINK 'P1', LNK$LIBRARY/LIB, LNK$LIBRARY_1/LIB

 

To use it, type: "$ @VAXCC 041" where 041 is an algorithm file name.    Be sure to leave off the ".c" extension.  "Vaxcc.com" will do the compiling and linking as a single command.  The '@' character tells VMS that "vaxcc.com" is a command file.

 

Commands are also listed to produce and use "naautil.c" as object code.  Read the comments in this command file for further instructions or see Section 6.6 - "Using Naautil.c as Object Code".

 

Below is a listing of the "vaxcc.com" command file:

 

$! *******************************************************************

$!   Program:  VAXCC.COM  (VAX command file)

$!

$!   Purpose:

$!     VAXCC.COM is a VAX command file used for compiling and linking

$!     a mathematical C program.  It can be easily altered to allow

$!     for linking to "NAAUTIL.OBJ" (with or without "EQEVAL.OBJ"),

$!     speeding up the compile time.

$!

$!   Written By:  Harold A. Toomey

$!   Date:        21 August 1991

$!

$!   Example:  $ @VAXCC 041   where "041.C" is the file name.

$!                            (Leave off the .C extension)

$! *******************************************************************

$!

$!  Define the link libraries to allow the use of the /G_FLOAT

$!  qualifier but not the use of Curses.  These two defines may be

$!  placed into your "LOGIN.COM" file to be performed once at login

$!  time.

$!

$ DEFINE LNK$LIBRARY    SYS$LIBRARY:VAXCRTLG

$ DEFINE LNK$LIBRARY_1  SYS$LIBRARY:VAXCRTL

$!

$!  Compile the program with the floating‑point qualifier to create

$!  an .OBJ object file.  Link the object file to create the

$!  executable.

$!

$ CC /G_FLOAT 'P1'.C

$ LINK 'P1', LNK$LIBRARY/LIB, LNK$LIBRARY_1/LIB

$!

$! *******************************************************************

$!  Replace the above "LINK" line with the below "LINK" line to link

$!  to the pre‑compiled "NAAUTIL.C" object code file.

$!

$! LINK 'P1', NAAUTIL, LNK$LIBRARY/LIB, LNK$LIBRARY_1/LIB

$!

$! *******************************************************************

$!  Create "NAAUTIL.OBJ" object code by running the below step once.

$!  Rember to re‑compile "NAAUTIL.C" every time one of its flags

$!  are changed.

$!

$! CC /G_FLOAT NAAUTIL.C

$!

$! *******************************************************************



 

 

 

8.  The Equation Evaluator Routines

 

 

Over two-thirds of the algorithms in "Numerical Analysis Algorithms in C" need to be compiled only once.  They prompt for all the necessary inputs.  The other one-third of the algorithms contain multiple modifiable functions, such as F(x).  The C language has no pre-defined procedures to allow functions to be entered at run-time.  To add these capabilities, a set of procedures have been written.  These routines are located in the file named "eqeval.c."

 

 

8.1 What the Routines Do

 

Quite simply, the equation evaluator routines allow the user to enter mathematical equations at run-time rather than having to recompile an algorithm for each unique function.  All of the single function programs have the equation evaluator routines already implemented into them.  These routines are activated only if the EQ_EVAL flag is set to TRUE in "naautil.c."  Implementing the equation evaluator routines require only a few simple steps, as shown below.

 

A convenient utility program is also provided called "ee.c."  This program can be used to familiarize yourself with writing equations in the C language.  It can also be used as a command-line calculator similar to the one the BASIC language provides.  Like C, it uses infix notation.  All math functions defined in the standard C library header <math.h> are valid.  Unary operators like "+3" and "-3" are included if the ANSI flag is set to TRUE in "eqeval.c."

 

To evaluate a function like "f(x) = cos(x + 3.14) - 2", just type:

 

          C:\NAA42> ee cos(x + 3.14) - 2

 

Spaces are allowed inside the equations.  Equations can be entered in uppercase or lowercase characters.  The variables x, y and/or t can also be used inside the equations.  The "ee" program will prompt you for the values of needed variables.  It also prompts you to evaluate the entered equation again.

 

Typing "ee" by itself will cause the equation evaluator to prompt for an equation to be entered.

 

All internal computations are done using floating-point numbers.  Equations are limited to 130 characters as defined by MAX_LINE_SIZE in "eqeval.c."  This number may be increased to suit your needs.  The larger it is, the more memory the routines will require.  It was set to 130 since MS-DOS will not accept more than 128 characters at the DOS prompt.  Many computers have similar limitations.

 

 

8.2 How to Insert the Routines into a Program

 

To implement the equation evaluator routines into a Numerical Analysis program, three simple modifications are required.

 

1)      Make sure that the EQ_EVAL flag is set to TRUE in "naautil.c."

 

    #define EQ_EVAL  TRUE

 

2)      Add something similar the following lines into the function to evaluate, usually f(x):

 

        if (eqeval)

           return (eval_eq(x));        /* Use the Equation Evaluator */

        else

       return (sin(x)); /* This is the default function */

 

NOTE:        Valid calls to eval_eq() include eval_eq(any_number), eval_eq(x), eval_eq(x,y), and eval_eq(x,y,t).  Eval_eq() is not valid unless at least one argument (parameter) is passed to it.

 

3)      Just after main(), add something like the following lines to print the correct equation onto the screen and into the output file:

 

        if (eqeval)

           printf2("f(x) = %s", tmpstr);

        else

       printf2("%s", eq_text_f);   /* This is the default text */

 

 

8.3 An Example Using Simpson's Rule

 

See the file "041ee.c" for a descriptive example using Algorithm 4.1 - Simpson's Rule for Integration and the equation evaluator routines.  This file performs the same as "041.c", but is commented differently.

 

 

8.4 Using Eqeval.c As Pre-Compiled Object Code

 

If you find yourself using the equation evaluator routines in "eqeval.c" rather frequently, you may want to compile them only once and then link the object code to the programs.  Doing this will save you time as you compile your modified algorithms.

 

If "naautil.c" had the EQ_EVAL flag set to TRUE and is being used as object code, go no further with this section.  The below steps are unnecessary in this situation, since the "naautil.c" object code will already contain the "eqeval.c" object code.  Otherwise, follow the five steps below:

 

1)      Set the EQEVAL_OBJ flag to FALSE in "eqeval.c":

 

    #define EQEVAL_OBJ FALSE

 

2)      Compile "eqeval.c" into object code.  Do one of the following:

 

          MS-DOS:    C:\NAA42> CL /c EQEVAL.C       - Creates "EQEVAL.OBJ"

          UNIX: % cc -c eqeval.c           - Creates "eqeval.o"

          VAX/VMS:   $ CC /G_FLOAT EQEVAL.C     - Creates "EQEVAL.OBJ"

 

3)      Now set the EQEVAL_OBJ flag to TRUE in "eqeval.c."

 

    #define EQEVAL_OBJ TRUE

 

This keeps the algorithms from re-compiling the equation evaluator routines.  After step 2 above, "eqeval.c" should be available in object code to be linked to later.

 

4)      From now on, compile the algorithms into object code.  Do one of the following, assuming "041.c":

 

          MS-DOS:    C:\NAA42> CL /c 041.C      - Creates "041.OBJ"

          UNIX: % cc -c 041.c          - Creates "041.o"

          VAX/VMS:   $ CC /G_FLOAT 041.C    - Creates "041.OBJ"

 

5)      When compiling the algorithms, be sure to link with the "eqeval" object code.  To do so, type one of the following:

 

          MS-DOS:    C:\NAA42> CL 041 EQEVAL        - Links "041.OBJ"

          UNIX: % cc -o 041 041.o eqeval.o -lm - Links "041.o"

          VAX/VMS:   $ LINK 041 EQEVAL      - Links "041.OBJ"

 

Under UNIX, steps 4 and 5 can be combined into the single command "cc -o 041 041.c eqeval.o -lm".

 

See "cc.bat", "ccc" and "vaxcc.com" in the UTIL sub-directory for ideas on automatically linking object code to programs.  "cc.bat" is for MS-DOS, "ccc" is for UNIX and "vaxcc.com" is for a VAX.

 

 

8.5 Valid Math Operators and Functions

 

This section lists what the equation evaluator routines will accept and what they will reject.

 

Valid mathematical operators are:

 

*   /   %   +   -   +   - (unary)

 

Invalid mathematical operators are:

 

**  ^   mod rem \   div

 

Valid mathematical functions are:

 

abs()          cos()          frexp()        sin()

acos()         cosh()         ldexp()        sinh()

asin()         exp()          log()          sqrt()

atan()         fabs()         log10()        tan()

atan2()        floor()        modf()         tanh()

ceil()         fmod()         pow()

 

Invalid mathematical functions are;

 

atof()         atoi()         div()          hypot()

rand()         fsin()         fcos()         ftan()

fasin()        facos()        fatan()        fsinh()

fcosh()        ftanh()

 

Valid variables are:

 

x   y   t   (uppercase or lowercase)

 

Valid number formats are:

 

3.1415  3.1415e-2   3   .4 

 

For a brief description of the implemented mathematical operators and functions, see Sections 5.1 and 5.2.

 

 

8.6 Sample Equations

 

Use the "ee" program to enhance your skills at coding mathematical equations in C.  Some examples might be:

 

          ee (1+2)*3

ee 1+2*3

ee 1 + sin(x*2)

ee -2+3

ee pow(3.0,x) - y + t

ee +1-x

ee x / y

ee pow(x,pow(2.0,pow(2.0,y)))

 

 

8.7 Possible Error Messages

 

It is easy to accidentally enter an incorrect equation.  If an invalid equation is encountered, one of several possible error messages will be printed to the screen.  The program will also immediately abort.  All possible error messages are listed below:

 

1.       "ERROR: Parentheses are mismatched."

Bad Example: "((3)"

Checks for unmatched parentheses.

 

2.       "ERROR: Misuse of parentheses."

Bad Example: "1+2)*(3"

Another way to catch illegal usage of parentheses.

 

3.       "ERROR: "()" is not a valid equation."

Bad Example: "()"

Handles the special case of nothing enclosed in sets of parentheses.

 

4.       "ERROR: Unrecognized mathematical operator encountered."

Bad Example: "3$4"

Only *, /, %, +, and - operators are allowed.  The '^' symbol, shorthand for pow(), as in "3^x" is not supported and is not part of C (catches former Pascal users).

 

5.       "ERROR: Too many sequential unary operators used."

Bad Examples: "x ‑ ‑ ‑3" and "+ ‑3"

Can usually have up to two unary operators without errors, such as "3 + -4".  No more than one unary operator is allowed to start an equation or to follow a left parenthesis.

 

6.       "ERROR: Incorrect equation entered.  Check for missing operands."

Bad Example: "3 * / 4"

Checks for numbers or functions missing between operators.

 

7.       "ERROR: Incomplete equation entered."

Bad Example: "5+"

Checks for obviously incomplete equations.

 

8.       "ERROR: Invalid number in equation."

Bad Example: "3.1e‑r"

See valid number formats above.  They are the same formats accepted by printf("%f", &x);

 

9.       "ERROR: Invalid function in equation (1)."

Bad Example: "tangent(x)"

Checks for excessively large strings.  Currently, any function longer than 5 characters (MAX_FUN_SZ) is too long.  You should increase the value assigned to MAX_FUN_SZ in "eqeval.c" if you add any new functions longer than 5 characters.

 

10.     "ERROR: Invalid function in equation (2)."

Generated if you add more functions but forget to modify isfunct() and/or you forget to define a new function ID, such as POW_ID.  You should never see this error message if you do not modify the "eqeval.c" source code.

 

11.     "ERROR: In parser."

Generated if you add more functions but forget to modify traverse_tree(), defining how the functions are to behave.  You should never see this error message if you do not modify the "eqeval.c" source code.

 

 

8.8 List of Algorithms Using the Equation Evaluator Routines

 

The 34 algorithms below require only one function to be evaluated.  They each have the equation evaluator routines already implemented into them.  These algorithms need to be compiled only once, assuming the EQ_EVAL flag was set to TRUE in "naautil.c.".

 

        011B.c  031.c   041B.c  051B.c  080B.c

        021.c   031B.c  041C.c  052.c   081.c

        022.c   031C.c  041D.c  054.c   122.c

        024.c   032.c   042.c   054B.c  122B.c

        024B.c  034.c   043.c   054C.c  122C.c

        025.c   035.c   043B.c  055.c   123.c

        027.c   041.c   051.c   056.c

 

The 37 algorithms listed below require the input of more than one function.  Using the equation evaluator on these algorithms is not recommended, since only one of the multiple equations can use the equation evaluator routines at a time.

 

        023.c   044C.c  101.c   113.c   125.c

        024C.c  045.c   101A.c  113B.c  126A.c

        033.c   045B.c  102.c   114.c   127A.c

        040B1.c 045C.c  103.c   114B.c  128A.c

        040B3.c 053.c   103B.c  115.c   129A.c

        040C1.c 057.c   111.c   116.c

        044.c   057B.c  112.c   121.c

        044B.c  058.c   122B.c  124.c

 

The remaining 45 algorithms do not need function equations (or the equation evaluator) and need to be compiled only once.  Most of these perform matrix operations, where the dimension of the matrices are entered at run-time and the memory is dynamically allocated.

 

 

8.9 Limitations

 

The limitations of the equation evaluator routines are as follows:

 

1.       Only one function can use the routines per program.  This means algorithms requiring only a single function, like f(x,y), will benefit while algorithms requiring two or more functions, like f1(x,y) and f2(x,y) in the same algorithm, will not benefit.

 

2.       There is a 130 character limit for the equations.  This can be easily overcome by increasing the value of #define MAX_LINE_SIZE in "eqeval.c."

 

3.       Up to 3 variables can be used in the equations.  These are: constants, x, y, and/or t.  These will cover all algorithms in this package which contain only a single function.  f(x) and f(y,t) are the most common uses of these variables.

 

4.       These routines require the use of variable length arguments.  Variable length argument functions can be very non-portable.  If your compiler does not support variable length argument lists like "eval_eq(x, ...)", you may need to fix the function eval_eq() to require all three arguments (parameters) to be passed, such as eval_eq(x,y,t).  Do this by replacing eval_eq() in "eqeval.c" with:

 

        double eval_eq(x, y, t)

        double x, y, t;

        {

          eq_eval_x = x;

          eq_eval_y = y;

          eq_eval_t = t;

          traverse_tree(eq_node[0]);

          return(eq_node[0]->value);

    }

 

This alteration requires that all calls to eval_eq() pass three values, such as:

 

f(x)   --> eval_eq(x,0,0)

f(y,t) --> eval_eq(0,y,t)

 

 

8.10      Trade-Offs

 

PROS:

1.       Adds long-term flexibility.  Algorithms which use the equation evaluator routines need to be compiled only once.

 

2.       Faster than recompiling different functions, like f(x), several times.

 

CONS:

1.       May evaluate the function slightly slower than hard-coded functions.  This may only become noticeable for very large problem sets.  Uses a binary tree to evaluate the function rather than the faster and more optimized in-line mathematical code generated by the compiler.

 

2.       Will make the executable code larger.  The equation evaluator routines can add up to 7K bytes of code to the executables.



 

 

 

9.  Portability

 

 

It has been said that C is both "a relatively low level system implementation language" and that "C is a portable language."  These two statements seem contradictory.  The portability of C is very dependant upon the operating system, the compiler and even the version of the compiler running the programs.  This chapter attempts to cover some of the necessary issues faced when "porting" these algorithms to other computer platforms and compilers.  For further references about portability, an excellent book detailing these issues is "Portability and the C language", by Rex Jaeschke, 1988.

 

These algorithms are currently being used on a wide variety of computer systems and compilers.  This chapter covers those platforms familiar to the programmer, namely: MS-DOS on IBM PCs, UNIX workstations, Macintoshes, and VAX mainframes.  These programs have been developed with these platforms in mind, especially MS-DOS.  Care has been taken to keep these programs working on older K&R compliant C compilers as well as the newer ANSI C compilers and even C++ compilers.  If your compiler is fully ANSI C compliant, then there should be no problems getting these programs to work on your computer.

 

Whenever a peculiar problem arose on a non-ANSI compiler, the best means of working around the problem was chosen while still maintaining portability.  This usually took on the form of a special flag in "naautil.c."  The sections below cover some of the problems encountered and how they are or were overcome.

 

If you are unable to get these programs to run on your computer system after reading this chapter and trying all means available to you, you are welcome to call the programmer (Care-Free Software) for help or return this package for a full refund.

 

 

Case Sensitivity

 

When uploading these programs to another machine, remember that unlike FORTRAN, C is case sensitive!  These algorithms will not work if they are translated into all uppercase characters.  This situation is most likely to occur when using communications software to transfer the files to a mainframe computer.

 

 

Memory Allocation

 

"Numerical Analysis Algorithms in C" relies heavily upon the functions calloc() and free().  These are found inside most of the routines in "naautil.c", "naautil2.c" and "naautil3.c".  "Naautil.c" is used in every algorithm.  If calloc() doesn't work, neither will the algorithms.  Calloc() usually requires the <stdlib.h> header file.  Non-ANSI C compilers may use <malloc.h> or <alloc.h>.

 

If these do not do the trick, use the file "calloc.c" found in the UTIL sub-directory.  The comments inside this file explain how to use and implement it into these programs.  They provide the functions naacalloc() and naafree() as replacements for calloc() and free().  Few users should ever need these replacement routines.

 

 

9.1 C vs ANSI C

The C language adopted a standard (ANSI C) in December 1989.  Before this standard, the definitive book on C was "The C Programming Language", first edition, by Brian W. Kernighan and Dennis R. Ritchie, the creators of C.  This older style of C is also referred to as K&R style.  For a simple summary of the changes from C to ANSI C, see appendix C of the second edition of "The C Programming Language."

 

ANSI C is guaranteed to accept any strictly conforming program to generate portable code.  To obtain a copy of the ANSI C language specification, contact:

 

          American National Standards Institute

          1430 Broadway

          New York, NY  10018

          (212) 642-4900

 

Ask for ANSI X3.159-1989.  The cost is fixed at $50.00 plus approximately $6.00 for handling.

 

 

Function Prototyping

 

One of the features first used in C++ and quickly adopted into ANSI C is the use of function prototypes.  Function prototypes declare a function, its expected input types and its expected output type.  This is helpful for ensuring that functions are being used correctly.

 

Most older C compilers do not understand the newer type-checking prototype statements like:

 

          double *dvector(int, int);     /* ANSI Style */

or

          double *dvector(int a, int b); /* ANSI Style */

 

These older compilers expect statements like:

 

          double *dvector();         /* K&R Style */

 

The new method of prototyping is preferred but not usually necessary.  Function prototypes are usually placed at the top of a program or inside header files.  To use the older method of prototyping, simply change the ANSI flag to FALSE in "naautil.c."  The default setting is TRUE for ANSI-compliant C compilers.

 

 

Function Declarations

 

Functions can be declare in two different ways in ANSI C.  Examples of these two methods are given below:

 

        OLDER K&R STYLE        NEWER ANSI STYLE

        int max(a,b)           int max(int a, int b)

        int a,b;

        {                      {

          ...                    ...

        }                      }

 

Both styles are allowed in ANSI C, however the ANSI style is preferred.  "Numerical Analysis Algorithms in C" uses the older K&R style to retain compatibility.  You may restructure the functions to conform with the newer ANSI style if necessary.  Setting the ANSI_FUNCT flag to TRUE causes several key functions to use the newer ANSI style function declaration.  This is required when using THINK C 4.0 on a Macintosh.

 

 

9.2 IBM PCs and MS-DOS

 

 

Microsoft C 5.0

 

All of these programs were developed using Microsoft C 5.0 with the small model library.  If you use anything other than the small model, add "#include <malloc.h>" to the top of "naautil.c" and anywhere else where alloc() and calloc() are used.  <malloc.h> is not part of ANSI C.  Use <stdlib.h> to replace it if possible.

 

Also, this compiler allows spaces to precede a "#define" statement.  This is not standard and will not work on several UNIX compilers.  This problem has been corrected.  No leading white spaces are present before "#define" statements in this version, even though using them would have made some of the code easier to read.

 

Compile using the /Za switch to check for ANSI compatibility.

 

 

Turbo C 2.0

 

No reported incompatibility problems.

 

 

9.3 UNIX Workstations

 

These programs should work on all UNIX workstations.  If the version of UNIX is somewhat old, you may need to set the OLD_UNIX_OS flag to TRUE in the "naautil.c" file.  It allows the use of <varargs.h> for variable length argument lists instead of <stdarg.h>.

 

 

Using extended ASCII

 

Many of the algorithms use the extended ASCII character set available on MS-DOS computers.  These get turned into unexpected characters when uploaded to many UNIX machines.  See Section 7.1 - "Convert.c - Converting Files from Extended ASCII to Standard ASCII" if this becomes a problem.

 

 

Variable Length Argument Lists

 

New to version 4.2 is the use of variable length argument lists.  The printf2() command defined in "naautil.c" and the eval_eq() command defined in "eqeval.c" are the only places where variable length argument lists are used.  The "printf2()" function simply prints to two different places; to the screen and to a file.  It requires the ANSI header file <stdarg.h>. 

 

The header <stdarg.h> is an ANSI C invention modeled closely on the UNIX <varargs.h> capability.  Since ANSI C uses a slightly different approach, the new header <stdarg.h> was designed rather than retaining <varargs.h> with a changed meaning.  It is possible that some compilers will provide both of these headers, while others might provide only one or the other.

 

If <stdarg.h> is provided, then use it over <varargs.h>.  If only <varargs.h> is provided, then use the alternate printf2() inside "naautil.c" by setting the OLD_UNIX_OS flag to TRUE.  See the comments inside the printf2() functions in Appendix B on how to use them.

 

 

AT&T UNIX PC

 

Some versions of this C compiler (older K&R style) do not like multiple assignment expressions like "a = b = 4;".  To overcome this problem, just break these statements up like "b = 4; a = b;".  All of these kinds of statements have been found and corrected in version 4.2.  This compiler was used at Brigham Young University's Numerical Analysis Laboratory in 1989.

 

 

HP 9000/300

 

Had an error when not leaving a space between an equal ('=') and a minus sign ('-').  Example:  for (i=-1;i<=N;i++).  Fixed it by adding a space.  Example:  for (i= -1;i<N;i++).  This is probably due to an ambiguity with the obsolete usage of "=-" for "-=", such as with x -= 1; to represent x = x - 1;.  All occurrences of the above problem have been corrected in all of the algorithms.

 

 

Sanyo ICON

 

Version 4.0 was ported successfully onto a 68020 based ICON in use at the Electrical Engineering Department at Brigham Young University.

 

It had an older compiler that did not implement "void."  This can be circumvented by adding "#define void int" or "typedef int void;" to the top of "naautil.c."

 

 

Silicon Graphics 4D Series and the MIPS Compiler

 

Have had no problems running on a Silicon Graphics 4D/85GT using IRIX 3.3.1 and a MIPS C compiler.

 

Compile using the "-ansi" switch to check for ANSI compatibility.  The "­-fullwarn" switch may also be helpful in producing portable code.

 

 

9.4 Macintosh Computers

 

"Numerical Analysis Algorithms in C" versions prior to 4.2 required command line redirection, such as "041 > 041.OUT".  This presented a problem, since Macintoshes do not have a command line!  A quick-and-dirty fix in the past has been to add the "ccommand()" function just after main().  Example:

 

                   (Use the "ANSI" library in THINK C 4.0)

        #include <console.h>           /* Needed header file */

        int ccommand (char ***p);      /* Function prototype */

 

        main(int argc, char **argv)

        {

          ...                          /* Declare variables first */

          argc = ccommand(&argv);      /* Invokes a command line  */

          ...                          /* Continue w/the program  */

        }

 

This was only necessary for creating an output file and has been corrected.  All of the programs have been rewritten to no longer need redirection, or the "ccommand()" function. 

 

 

9.5 VAX Mainframes

 

Many of the algorithms need the C Library function "tolower()".  Be sure it is implemented correctly.  You may need to include the file <ctype.h> along with <stdlib.h>.  "Tolower()" is usually implemented as a function and as a macro.  The function in <stdlib.h> is preferred over the macro in <ctype.h>.

 

Another problem encountered was having the underscores ("_") stripped from file names after being transferred via kermit (with ProComm) to a VAX.  All underscore characters have been removed from the file names eliminating this problem.

 

If your VAX C compilers does not perform floating-point printing correctly in the printf() function, specify the /G_FLOAT qualifier to the "CC" command.

 

Some VAX compilers do not support the "long double" type.  This type is used in "naautil2.c" but is currently not used in any of the algorithms.  Routines using "long double" types in "naautil2.c" where placed there for completeness and for future higher precision needs.  To eliminate any compiler errors or warnings, set the NO_LONG_DOUBLES flag to TRUE in "naautil.c."

 

 

9.6 Tested Compilers

 

The following compilers have successfully run all of the "Numerical Analysis Algorithms in C" v4.2 programs:

 

MS-DOS:

1.  Microsoft C 5.0

2.  Turbo C 2.0

 

UNIX:

1.  MIPS C Compiler for Silicon Graphics 4D Workstations

 

Macintosh:

1.  THINK C 4.0             (Set ANSI_FUNCT == TRUE)

 

VAX/VMS:

1.  VAX C v3.1

2.  VAX C v3.2

 

The following additional compilers have successfully run previous versions of the "Numerical Analysis Algorithms in C" programs:

 

UNIX:

1.  AT&T UNIX PC

2.  HP 9000/300

3.  Sanyo ICON

 

VAX/VMS:

1.  MicroVAX



 

 

 

10.          Sample License Agreements

 

 

"Numerical Analysis Algorithms in C" is available for individuals, universities and corporations.  These sample license agreements are provided as a reminder of your rights when using these programs.  They also allow the legal departments of universities and corporations to determine the scope of a site license before actually purchasing one.  Personalized license agreements are sent with each order.

 

 

10.1            Individual License Sample

 

 

"NUMERICAL ANALYSIS ALGORITHMS IN C"

 

INDIVIDUAL LICENSE (SAMPLE)

 

This Individual License is issued to <INDIVIDUAL'S NAME HERE>, on <DATE>, by CARE-FREE SOFTWARE under permission of Harold A. Toomey, the proprietary owner.

 

Software Version:  4.2

License Number:    <YMMDDX-I>  

 

 

NOTIFICATION OF COPYRIGHT

 

THIS SOFTWARE PROGRAM PACKAGE ("SOFTWARE") IS A PROPRIETARY PRODUCT OF HAROLD A. TOOMEY AND IS BEING DISTRIBUTED BY CARE-FREE SOFTWARE.  AS SUCH, IT IS PROTECTED BY COPYRIGHT LAWS AND INTERNATIONAL TREATY.  YOU ("INDIVIDUAL") MUST TREAT THE SOFTWARE LIKE ANY OTHER COPYRIGHTED MATERIAL, EXCEPT THAT YOU MAY EITHER MAKE ONE COPY OF THE SOFTWARE SOLELY FOR BACKUP OR ARCHIVAL PURPOSES, OR YOU MAY PLACE THE SOFTWARE ON A SINGLE HARD DISK, PROVIDED THAT YOU KEEP THE ORIGINAL SOFTWARE SOLELY FOR BACKUP OR ARCHIVAL PURPOSES.  COPYRIGHT LAWS PROHIBIT MAKING ADDITIONAL COPIES OF THE SOFTWARE FOR ANY OTHER REASON.

 

 

SOFTWARE INDIVIDUAL LICENSE AGREEMENT

 

READ THIS LICENSE AGREEMENT BEFORE OPENING THE SEALED DISK PACKAGE.  THIS AGREEMENT IS A LEGAL CONTRACT BETWEEN YOU, THE END USER, AND CARE-FREE SOFTWARE GOVERNING YOUR USE OF THE SOFTWARE.  OPENING THE SEALED DISK PACKAGE INDICATES YOUR ACCEPTANCE OF THIS AGREEMENT.  THIS AGREEMENT SHALL ALSO BE BINDING ON ANY SUBSEQUENT, AUTHORIZED LICENSEE.  IF YOU DO NOT WISH TO AGREE TO THE TERMS OF THIS AGREEMENT, PROMPTLY RETURN THE COMPLETE SOFTWARE PROGRAM PACKAGE, WITH THE DISK PACKAGE(S) UNOPENED, TO CARE-FREE SOFTWARE WITHIN 90-DAYS TO RECEIVE A FULL REFUND.  IF YOU HAVE ANY QUESTIONS CONCERNING THIS AGREEMENT, CONTACT CARE-FREE SOFTWARE, 464 NORTH 750 EAST, LINDON, UT 84042, OR CALL (801) 785-0464.

 

 

LICENSE

 

1.  CARE-FREE SOFTWARE grants you the right to use one copy of the Software on a single-user computer, or on a single terminal or workstation of a multi-user computer or local area network.  Each workstation or terminal on a multi-user computer or local area network must be separately licensed by CARE-FREE SOFTWARE.  If the software package contains both 3½" and 5¼" diskettes, you are licensed to use only a single set of diskettes for your single user computer, terminal or workstation; you are not licensed to use the other set of diskettes.

 

2.  You may not sublicense, rent or lease the Software, but you may permanently transfer your license to use the Software and accompanying materials by delivering to another party the original diskettes and material comprising the software package, including this numbered individual license, and by simultaneously destroying all copies of the Software and accompanying materials in your possession.  Such transfer terminates your license to use the Software.  The new recipient of the Software and accompanying materials accepts this agreement and is licensed under the terms of this Agreement upon initially using the Software.

 

3.  The Software includes several text files, over a hundred C source code files, and their accompanying input and output files.  It is intended that those using the Software modify the C source code as part of the learning process for numerical methods and analysis.  Copies of this Software or self-modified versions of the source code are not to be distributed for direct commercial advantage without prior written consent from Harold A. Toomey through CARE-FREE SOFTWARE.

 

4.  CARE-FREE SOFTWARE further grants you the right to make a backup/archival copy of the software diskettes as set forth in the Notification of Copyright, above.  You may not copy, transfer, or otherwise use the Software except as stated in this agreement.

 

 

LIMITED 90-DAY WARRANTY/LIMITATION OF REMEDIES

 

CARE-FREE SOFTWARE will replace, at no charge, defective diskettes that are returned within 90 days of the original date of purchase.  CARE-FREE SOFTWARE warrants that the diskettes are free from defects in material and workmanship under normal use and service for a period of ninety (90) days after receipt.  Any implied warranty(ies) on the diskettes is also limited to ninety (90) days.  By opening the sealed disk package, you agree that the only remedy available to you will be a refund of the purchase price of this software program package.  Some states do not allow limitations on duration of an implied warranty, so the above limitation may not apply to you.

 

SUCH WARRANTIES ARE IN LIEU OF OTHER WARRANTIES IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE WITH RESPECT TO THE SOFTWARE AND THE ACCOMPANYING WRITTEN MATERIALS.  IN NO EVENT WILL CARE-FREE SOFTWARE BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOSS OF PROFITS, LOST SAVINGS, OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF YOUR USE OF OR INABILITY TO USE THE PROGRAM, EVEN IF CARE-FREE SOFTWARE OR AN AUTHORIZED CARE-FREE SOFTWARE REPRESENTATIVE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  CARE-FREE SOFTWARE WILL NOT BE LIABLE FOR ANY SUCH CLAIM BY ANY OTHER PARTY.

 

This limited warranty gives you specific legal rights.  Some states provide other rights, and some states do not allow excluding or limiting implied warranties or limiting liability for incidental or consequential damages.  As a result, the above limitations and/or exclusions may not apply to you.  Furthermore, some jurisdictions have statutory consumer provisions which may supersede this section of the Agreement.

 

GENERAL

 

If any provision in this agreement shall be unlawful, void, or for any reason unenforceable, then that provision shall be deemed severable from this agreement and shall not affect the validity and enforceability of the remaining provisions of this Agreement.  This Agreement is governed by the laws of the State of Utah.

 

 

CARE-FREE SOFTWARE'S UNCONDITIONAL GUARANTEE

 

Your satisfaction is unconditionally guaranteed or your money back.  If for any reason whatsoever, you are not satisfied with any product purchased from us, we want you to return it to us within 90 days.  We will be glad to exchange the product or give your money back.

 

NAA42-9/91

 

 

10.2            University/Corporation Site License Sample

 

"NUMERICAL ANALYSIS ALGORITHMS IN C"

 

UNIVERSITY/CORPORATION SITE LICENSE (SAMPLE)

 

This Site License is issued to <UNIVERSITY/CORPORATION NAME HERE>, on <DATE>, by CARE-FREE SOFTWARE under permission of Harold A. Toomey, the proprietary owner.

 

Software Version:  4.2

License Number:   <YMMDDX-S> 

 

 

NOTIFICATION OF COPYRIGHT

 

THIS SOFTWARE PROGRAM PACKAGE ("SOFTWARE") IS A PROPRIETARY PRODUCT OF HAROLD A. TOOMEY AND IS BEING DISTRIBUTED BY CARE-FREE SOFTWARE.  AS SUCH, IT IS PROTECTED BY COPYRIGHT LAWS AND INTERNATIONAL TREATY.  YOU ("UNIVERSITY/CORPORATION") MUST TREAT THE SOFTWARE LIKE ANY OTHER COPYRIGHTED MATERIAL, EXCEPT THAT YOU MAY MAKE AS MANY COPIES OF THE SOFTWARE AS NEEDED FOR YOUR UNIVERSITY'S/CORPORATION'S INTERNAL USE ONLY.  THE SCOPE OF YOUR DISTRIBUTION RIGHTS ARE LISTED BELOW.  COPYRIGHT LAWS PROHIBIT MAKING ADDITIONAL COPIES OF THE SOFTWARE FOR ANY OTHER REASON.

 

 

SOFTWARE SITE LICENSE AGREEMENT

 

READ THIS LICENSE AGREEMENT BEFORE OPENING THE SEALED DISK PACKAGE.  THIS AGREEMENT IS A LEGAL CONTRACT BETWEEN YOU, THE UNIVERSITY/CORPORATION, AND CARE-FREE SOFTWARE GOVERNING YOUR USE OF THE SOFTWARE.  OPENING THE SEALED DISK PACKAGE INDICATES YOUR ACCEPTANCE OF THIS AGREEMENT.  THIS AGREEMENT SHALL ALSO BE BINDING ON ANY SUBSEQUENT, AUTHORIZED LICENSEE.  IF YOU DO NOT WISH TO AGREE TO THE TERMS OF THIS AGREEMENT, PROMPTLY RETURN THE COMPLETE SOFTWARE PROGRAM PACKAGE, WITH THE DISK PACKAGE(S) UNOPENED, TO CARE-FREE SOFTWARE WITHIN 90-DAYS TO RECEIVE A FULL REFUND.  IF YOU HAVE ANY QUESTIONS CONCERNING THIS AGREEMENT, CONTACT CARE-FREE SOFTWARE, 1376 NORTH 1100 EAST, AMERICAN FORK, UT 84003-3245, OR CALL (801) 492-1526.

 

 

LICENSE

 

1.  CARE-FREE SOFTWARE grants you the right to make unlimited copies of the Software on your university/corporation owned single-user computers, terminals and workstations of multi-user computers and on local area networks.  Each workstation or terminal on a multi-user computer or local area network need not be separately licensed by CARE-FREE SOFTWARE, so long as they are owned by you, the university/corporation.  You are licensed to use all sets of diskettes which are shipped with the Software.

 

2.  In addition, CARE-FREE SOFTWARE grants your currently enrolled students, employees, and faculty the right to copy the Software and accompanying manuals for their use, such as for graduate research and for numerical methods courses.  These individual copies remain part of this site license and do not belong to the students, employees, or faculty.  For individuals to retain a legal licensed copy of the Software after they are no longer enrolled or employed or teach at the university/corporation, they must purchase an Individual License.

 

3.  You may not sublicense, rent or lease the Software, but you may permanently transfer your license to use the Software and accompanying materials by delivering to another university/corporation the original diskettes and material comprising the software package, including this numbered site license, and by simultaneously destroying all copies of the Software and accompanying materials in your possession.  Such transfer terminates your license to use the Software.  The new recipient of the Software and accompanying materials accepts this agreement and is licensed under the terms of this Agreement upon initially using the Software.

 

4.  The Software includes several text files, over a hundred C source code files, and their accompanying input and output files.  It is intended that those using the Software modify the C source code as part of the learning process for numerical methods and analysis.  Copies of this Software or self-modified versions of the source code are not to be distributed for direct commercial advantage without prior written consent from Harold A. Toomey through CARE-FREE SOFTWARE.

 

5.  CARE-FREE SOFTWARE further grants you the right to make a backup/archival copy of the software diskettes as set forth in the Notification of Copyright, above.  You may not copy, transfer, or otherwise use the Software except as stated in this agreement.

 

 

LIMITED 90-DAY WARRANTY/LIMITATION OF REMEDIES

 

CARE-FREE SOFTWARE will replace, at no charge, defective diskettes that are returned within 90 days of the original date of purchase.  CARE-FREE SOFTWARE warrants that the diskettes are free from defects in material and workmanship under normal use and service for a period of ninety (90) days after receipt.  Any implied warranty(ies) on the diskettes is also limited to ninety (90) days.  By opening the sealed disk package, you agree that the only remedy available to you will be a refund of the purchase price of this software program package.  Some states do not allow limitations on duration of an implied warranty, so the above limitation may not apply to you.

 

SUCH WARRANTIES ARE IN LIEU OF OTHER WARRANTIES IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE WITH RESPECT TO THE SOFTWARE AND THE ACCOMPANYING WRITTEN MATERIALS.  IN NO EVENT WILL CARE-FREE SOFTWARE BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOSS OF PROFITS, LOST SAVINGS, OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF YOUR USE OF OR INABILITY TO USE THE PROGRAM, EVEN IF CARE-FREE SOFTWARE OR AN AUTHORIZED CARE-FREE SOFTWARE REPRESENTATIVE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  CARE-FREE SOFTWARE WILL NOT BE LIABLE FOR ANY SUCH CLAIM BY ANY OTHER PARTY.

 

This limited warranty gives you specific legal rights.  Some states provide other rights, and some states do not allow excluding or limiting implied warranties or limiting liability for incidental or consequential damages.  As a result, the above limitations and/or exclusions may not apply to you.  Furthermore, some jurisdictions have statutory consumer provisions which may supersede this section of the Agreement.

 

 

GENERAL

 

If any provision in this agreement shall be unlawful, void, or for any reason unenforceable, then that provision shall be deemed severable from this agreement and shall not affect the validity and enforceability of the remaining provisions of this Agreement.  This Agreement is governed by the laws of the State of Utah.

 

 

CARE-FREE SOFTWARE'S UNCONDITIONAL GUARANTEE

 

Your satisfaction is unconditionally guaranteed or your money back.  If for any reason whatsoever, you are not satisfied with any product purchased from us, we want you to return it to us within 90 days.  We will be glad to exchange the product or give your money back.

 

NAA42-9/91



 

 

 

11.          Packaging Information

 

 

To offer the most flexibility to the users, "Numerical Analysis Algorithms in C" v4.2 is shipped on a variety of floppy diskette sizes and capacities.  Too many files are included in this package to fit them on a single diskette.  See the appropriate list below to determine how the files are placed on the different diskettes.

 

Diskettes are currently available only for IBM PCs and Macintosh computers.  Each shipment comes with the following:

 

          - Set of Diskettes with Labels

          - Personalized License Agreement with a unique ID Number

          - Free Technical Support

 

The below items are available for an additional fee:

 

          - User's Manual

          - Examples Book

          - MS-DOS Executables

          - Macintosh Executables

 

The "*.C" source code support files listed below include the following files:

 

        complex.c      naautil.c      round.c

        eqeval.c       naautil2.c     trunc.c

        gaussj.c       naautil3.c

 

These files need to be present on each diskette you intend to run the algorithms from.

 

 

11.1            MS-DOS Diskettes

 

 

11.1.1              5¼" 1.2M High Density Diskettes

 

Disk #1:      "Readme.doc" Essential Information Document

                   "*.C" Source Code Support Files

                   Algorithm Source Code for Ch. 1-12

                   "IN" Sub-Directory Input Data Files

                   "OUT" Sub-Directory Output Data Files

                   "UTIL" Sub-Directory Utility Files

                   "LANGS" Sub-Directory Multiple Language Examples

                   "Revhist.doc" Revision History Document

 

Disk #2:      "Usersman.doc" User's Manual in ASCII Text

 

 

11.1.2              5¼" 360K Low Density Diskettes

 

Disk #1:      "Readme.doc" Essential Information Document

                   "*.C" Source Code Support Files

                   Algorithm Source Code for Ch. 1-4

 

Disk #2:      Algorithm Source Code for Ch. 5-9

 

Disk #3:      Algorithm Source Code for Ch. 10-12

 

Disk #4:      "IN" Sub-Directory Input Data Files

                   "OUT" Sub-Directory Output Data Files

                   "UTIL" Sub-Directory Utility Files

                   "LANGS" Sub-Directory Multiple Language Examples

                   "Revhist.doc" Revision History Document

 

Disk #5:      "Usersman.doc" User's Manual in ASCII Text

 

 

11.1.3              3½" 1.44M High Density Diskettes

 

Disk #1:      "Readme.doc" Essential Information Document

                   "*.C" Source Code Support Files

                   Algorithm Source Code for Ch. 1-12

                   "IN" Sub-Directory Input Data Files

                   "OUT" Sub-Directory Output Data Files

                   "UTIL" Sub-Directory Utility Files

                   "LANGS" Sub-Directory Multiple Language Examples

                   "Revhist.doc" Revision History Document

 

Disk #2:      "Usersman.doc" User's Manual in ASCII Text

 

 

11.1.4              3½" 720K Low Density Diskettes

 

Disk #1:      "Readme.doc" Essential Information Document

                   "*.C" Source Code Support Files

                   Algorithm Source Code for Ch. 1-9

 

Disk #2:      Algorithm Source Code for Ch. 10-12

                   "IN" Sub-Directory Input Data Files

                   "OUT" Sub-Directory Output Data Files

                   "UTIL" Sub-Directory Utility Files

                   "LANGS" Sub-Directory Multiple Language Examples

                   "Revhist.doc" Revision History Document

 

Disk #3:      "Usersman.doc" User's Manual in ASCII Text

 

 

11.2            Macintosh Diskettes

 

 

11.2.1      3½" 800K Macintosh Diskettes

 

Disk #1:      "Readme.doc" Essential Information Document

                   "*.C" Source Code Support Files

                   Algorithm Source Code for Ch. 1-11

 

Disk #2:      Algorithm Source Code for Ch. 11-12

                   "IN" Sub-Directory Input Data Files

                   "OUT" Sub-Directory Output Data Files

                   "UTIL" Sub-Directory Utility Files

                   "LANGS" Sub-Directory Multiple Language Examples

                   "Revhist.doc" Revision History Document

                   "Usersman.doc" User's Manual in ASCII Text



 

 

 

12.          Purchasing Information

 

 

There are two ways to legally purchase and use this software.  The first is by ordering it directly from Care-Free Software.  The second is by copying it from a licensed user and mailing a $20.00 check for an individual license.  Both methods provide you with the same product, assuming you do not copy an old version of the software.

 

"Numerical Analysis Algorithms in C" is written to be used by colleges, universities, and students.  Knowing that the budgets of all three are usually very limited, the prices are kept low enough to have this software accessible by everyone.  It is not unusual for student to want these algorithms for use in their profession after graduation.

 

 

12.1            $20.00 Club

 

The $20.00 Club is really quite simple.  To join, just copy this software from someone else and send Care-Free Software a check for $20.00.  This offer only applies for individual licenses, not for site licenses.  In exchange, Care-Free Software will send you an individual license, some diskette labels, and keep you informed of enhancements and upcoming releases.  The User's Manual and Examples Book are not included, but can be purchased separately.

 

If you are a student attending a school which has not yet purchased a site license, you should pay for these programs.  The $20.00 Club is our way of allowing students to take a class requiring these algorithms and be able to quickly and easily have this software available to them.  The main difference is that you make your own diskettes and save a few dollars doing so.  This method is commonly referred to as Shareware.

 

If you are a student currently enrolled at a college or university which has purchased a university site license, you may copy and use this software from the university computers for free.  If you intend to use the programs on your job after graduating, then you should purchase an individual license.  See the sample university/corporation site license in Chapter 10 - "Sample License Agreements" of this manual.

 

 

12.2            Order Form

 

An order form is provided for your convenience.  Use it to ensure you have the most recent version of this software.

 


ORDER FORM

 

"NUMERICAL ANALYSIS ALGORITHMS IN C"

 

A complete set of 116 stand-alone C programs have been written for the text Numerical Analysis, Burden & Faires, 3rd and 4th edition.  These programs include ALL of the algorithms as well as all modifications required for most of the homework exercises.  The C source code is thoroughly commented and easily modified.  The same source code runs on MS-DOS, UNIX, VMS, the Macintosh, and more!

 

For a FREE demo disk call 1-801-492-1526.

 

 

 

 

 

 

 

 

 

                   TO ORDER CALL OR MAIL THIS FORM TO:

                                       CARE-FREE SOFTWARE

                                       1376 North 1100 East

                                       American Fork, UT  84003-3245

 

Please Indicate Method of Payment:

Check _____  Purchase Order _____ C.O.D. _____

Name          ______________________________________________________________

Address      ______________________________________________________________

          ______________________________________________________________

Phone         ______________________________________________________________

 

Please Send Me:

Individual Licenses:

_____  Version 4.2 on MS-DOS Disks                $30.00

_____  Version 4.2 on Macintosh Disks              $35.00

_____  Demo Disk: MAC _____  DOS _____     FREE

_____  User's Manual (170 pages)                     $20.00

_____  Examples Book (670 pages)                   $65.00

 

Site Licenses:

_____  University/Corporation Packet                 $800.00

(Includes: Set of MS-DOS and Macintosh disks, a User's Manual, an Examples Book, and a site license good for unlimited campus/corporate use.)

 

Diskette Size:

_____ 5¼" (360K)         _____ 3½" (720K)         _____ 3½" (800K Macintosh)

_____ 5¼" (1.2M)          _____ 3½" (1.44M)

 

_______________  MERCHANDISE TOTAL  (prices include S&H)

_______________  C.O.D. Orders add $5.00

_______________  UTAH RESIDENTS add 6¼% Sales Tax

_______________  TOTAL

 

 

UNLIMITED CUSTOMER SUPPORT!  1-801-492-1526.      (7/7/93)



References

 

 

Balfour, Alexander, "Programming in Standard Fortran 77", North Holland, 1979.

 

Borenstein, Philip, "THINK C User's Manual", Symantec Corporation, 1989.

 

Bourne, Philip E., "UNIX for VMS Users", Digital Press, 1990.

 

Burden, Richard L., "Numerical Analysis", third edition, PWS-Kent Publishing Company, 1985.

 

Burden, Richard L., "Numerical Analysis", fourth edition, PWS-Kent Publishing Company, 1989.

 

Jaeschke, Rex, "Portability and the C Language", Hayden Books, 1988.

 

Kernighan, Brian W., "The C Programming Language", first edition, Prentice Hall Software Series, 1984.

 

Kernighan, Brian W., "The C Programming Language", second edition, Prentice Hall Software Series, 1988.

 

Koffman, Eliot B., "Pascal, A Problem Solving Approach", Addison-Wesley Publishing Company, 1982.

 

Mattson, Jeff, "THINK C, The Professional's Choice, Standard Libraries Reference", Symantec Corporation, 1989.

 

"Microsoft C 5.0 Optimizing Compiler, Language Reference, Microsoft CodeView, and Utilities", Microsoft Corporation, 1987.

 

"Microsoft C 5.0 Optimizing Compiler, Run-Time Library Reference", Microsoft Corporation, 1987.

 

"Microsoft C 5.0 Optimizing Compiler, User's Guide and Mixed-Language Programming Guide", Microsoft Corporation, 1987.

 

"Reference Manual for the Ada Programming Language, ANSI/MIL-STD-1815A-1983", Meridian Software Systems, February 17, 1983.

 

Sideris, Daniel A., "VAX/VMS: Mastering DCL Commands and Utilities", QED Information Sciences, Inc., 1990.

 

Tucker, Allen B., "Apple Pascal, A Programming Guide", CBS College Publishing, 1982.

 

"Turbo Pascal, Version 3.0, Reference Manual", Borland International, 1985.


APPENDIX A

 

C Source Code

for 041.C

 


Appendix A:    C Source Code for 041.C

 

 


/******************************************************************************

                                       Composite Simpson's Rule ‑ Algorithm 4.1

*******************************************************************************

 

                                !b

To approximate the integral I = *  f(x) dx:

                                "a

 

INPUT endpoints a, b; even positive integer n; the function f().

 

OUTPUT approximation XI to I.

 

NOTE: Listed as Simpson's Composite Rule in 3rd edition of the text.

 

*******************************************************************************

*                  Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 3Q 1991, v4.2      *

******************************************************************************/

 

/*

**  Set the EQ_EVAL flag to TRUE in "naautil.c" to use the Equation Evaluator.

*/

 

#include "naautil.c"                        /* Numerical Analysis Algorithms Utilities. */

 

char *outfile   = "041.out";              /* Default name of the output file.         */

char *eq_text_f = "f(x) = sin(x)";    /* Needs updating  $        */

 

 

/*****************************************************************************/

/* f(x) ‑ Function to evaluate, f(x).  Needs updating $.                     */

/*****************************************************************************/

double f(x)

double x;

{

  if (eqeval)

    return (eval_eq(x)); /* Use the Equation Evaluator  */

  else

    return (sin(x));                              /* Use the default function.   */

}

/*****************************************************************************/

 

 

main()

{

  double a, b, h, X, XI, XI0, XI1, XI2, f();

  int i, n;

 

  /**********

   * INPUTS *

   **********/

 

  NAA_do_first(outfile);                   /* NAA initialization procedure. */

 

  printf2("Composite Simpson's Rule ‑ Algorithm 4.1\n\n");

 

  if (eqeval)

    printf2("f(x) = %s", tmpstr);        /* Print the Equation Evaluator text */

  else

    printf2("%s", eq_text_f);                                 /* Print the default equation text */

  printf("\n\n");

 

  printf("Enter endpoint a: ");

  scanf("%lf", &a);

  printf("Enter endpoint b: ");

  scanf("%lf", &b);

  fprintf(file_id, " from %lg to %lg.\n\n", a, b);

 

  do {

    printf("Enter even number of intervals on [a,b], n: ");

    scanf("%d", &n);

    if ((n <= 0) || (n % 2 != 0))

      printf("ERROR ‑ n must be even and positive.\n");

  } while ((n <= 0) || (n % 2 != 0));

  fprintf(file_id, "n = %d intervals on [a,b].\n", n);

 

  /*************

   * ALGORITHM *

   *************/

 

  /* STEP #1 */

  h = (b ‑ a)/n;

 

  /* STEP #2 */

  XI0 = f(a) + f(b);

  XI1 = 0.0;                                        /* Summation of f(x(2i‑1)). */

  XI2 = 0.0;                                        /* Summation of f(x(2i)).   */

 

  /* STEP #3 */

  for (i=1;i<n;i++) {

 

    /* STEP #4 */

    X = a + i*h;

 

    /* STEP #5 */

    if (i % 2 == 0)

      XI2 += f(X);                                  /* For even i. */

    else

      XI1 += f(X);                                  /* For odd i.  */

  }

 

  /* STEP #6 */

  XI = h*(XI0 + 2.0*XI2 + 4.0*XI1) / 3.0;

 

  /***********

   * OUTPUTS *

   ***********/

 

  /* STEP #7 */

  printf2("Interval number h = %lg\n\n", h);

  printf2("     !%lg\n", b);

  printf2("XI = *  f(x) dx = %.11lg\n", XI);

  printf2("     "%lg\n\n", a);

  printf2("Required %d functional evaluations.\n", n+1);

 

  NAA_do_last(outfile);                                      /* NAA finish‑up procedure. */

}                                                                             /* STOP */

 

/*****************************************************************************/

/*                 Copyright (C) 1988‑1991, Harold A. Toomey, All Rights Reserved.      */


                    /*****************************************************************************/


APPENDIX B

 

C Source Code

for NAAUTIL.C

 


Appendix B:      C Source Code for NAAUTIL.C

 

 


/******************************** NAAUTIL.C ***********************************

                         "Numerical Analysis Algorithms in C" Utilities I v4.2

******************************************************************************/

 

/*

**  This source file contains many useful procedures, some being used in all

**  of the "Numerical Analysis Algorithms in C" programs.

**

**  At least three of the #defines are needed for all of the supporting ".c"

**  programs.  These #defines are: TRUE, FALSE, and ANSI.  The supporting

**  ".c" files are:

**

**                naautil.c    complex.c round.c

**                naautil2.c  eqeval.c     trunc.c

**                naautil3.c  gaussj.c

**

**  Many of these functions where derived from the book "Numerical Recipes

**  in C".

**

**  "Naautil.c" contains the most often used routines.  Most are dynamic

**  memory allocation routines used to create very flexible vectors and

**  matrices.

**

**  "Naautil2.c" contains less frequently used dynamic memory allocation

**  routines to create very flexible vectors, matrices, and cubes.

**  Currently used only by: "081.c" and "125.c"

**

**  "Naautil3.c" contains routines for complex vectors, matrices, and cubes.

**  Currently used only by: "027.c", "028a.c" and "081.c"

**

**  This file should be included (only once!) whenever the following

**  procedures or functions are used:

**

**    Return    Procedure

**    Type      Name             Description

**    ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

**    void      naaerror        Numerical Analysis Algorithms Error Handler

**    int       printf2         Like printf() but writes to a file too

**    void      NAA_do_first    NAA initialization procedure

**    void      NAA_do_last     NAA final procedure

**

**    int*           ivector    Allocates a 1‑D array of integers

**    float*         vector     Allocates a 1‑D array of floats

**    double*        dvector    Allocates a 1‑D array of doubles

**    long double*   ldvector ‑  Allocates a 1‑D array of long doubles

**    fcomplex*      cvector    Allocates a 1‑D array of fcomplex

**

**    int**          imatrix    Allocates a 2‑D array of integers

**    float**        matrix     Allocates a 2‑D array of floats

**    double**       dmatrix    Allocates a 2‑D array of doubles

**    long double**  ldmatrix ‑  Allocates a 2‑D array of long doubles

**    fcomplex**     cmatrix    Allocates a 2‑D array of fcomplex

**

**    int***         icube      Allocates a 3‑D array of integers

**    float***       cube       Allocates a 3‑D array of floats

**    double***      dcube      Allocates a 3‑D array of doubles

**    long double*** ldcube     Allocates a 3‑D array of long doubles

**    fcomplex***    ccube      Allocates a 3‑D array of fcomplex

**

**    void      free_ivector    Frees the allocated 1‑D array memory

**    void      free_vector     Frees the allocated 1‑D array memory

**    void      free_dvector    Frees the allocated 1‑D array memory

**    void      free_ldvector ‑  Frees the allocated 1‑D array memory

**    void      free_cvector    Frees the allocated 1‑D array memory

**

**    void      free_imatrix    Frees the allocated 2‑D array memory

**    void      free_matrix     Frees the allocated 2‑D array memory

**    void      free_dmatrix    Frees the allocated 2‑D array memory

**    void      free_ldmatrix ‑  Frees the allocated 2‑D array memory

**    void      free_cmatrix    Frees the allocated 2‑D array memory

**

**    void      free_icube      Frees the allocated 3‑D array memory

**    void      free_cube       Frees the allocated 3‑D array memory

**    void      free_dcube      Frees the allocated 3‑D array memory

**    void      free_ldcube     Frees the allocated 3‑D array memory

**    void      free_ccube      Frees the allocated 3‑D array memory

*/

 

/*********************/

/* DEFINES AND FLAGS */

/*********************/

 

/*

**  The FLAGS below allow the users more flexibility when compiling and

**  running these Numerical Analysis Algorithms.  They can also be used to

**  make these programs more portable to different computer systems.

*/

 

#define      PI                3.14159265358979323846264338327950288419716939937510582097

 

#ifndef FALSE

#define FALSE                                0                 /* Define FALSE if not already defined.      */

#endif

 

#ifndef TRUE

#define TRUE                                 !FALSE      /* Define TRUE if not already defined.       */

#endif

 

#define      ANSI                              TRUE         /* Set to TRUE if using an ANSI C standard   */

                                                                               /* compliant compiler (default).             */

                                                                               /* Set to FALSE if using an older C compiler */

                                                                               /* (Kernighan & Ritchie Style C).            */

 

#define      ANSI_FUNCT              FALSE       /* Set to TRUE if using ANSI's style for     */

                                                                               /* declaring functions.  Set to FALSE if     */

                                                                               /* using K&R style functions (default).      */

                                                                               /* (Set to TRUE if using THINK C 4.0 on a    */

                                                                               /* Macintosh.)                               */

 

#define TITLE_PROMPT               TRUE         /* Set to TRUE if you want to be prompted    */

                                                                               /* for an optional title at the start of     */

                                                                               /* each program (default).                   */

                                                                               /* Set to FALSE to disable the title prompt. */

 

#define      FILE_SAVE                   TRUE         /* Set to TRUE to save output to a file      */

                                                                               /* (default).                                */

                                                                               /* Set to FALSE to create no output file.    */

 

#define EQ_EVAL                           FALSE       /* Set to TRUE to be prompted for the use of */

                                                                               /* the Equation Evaluator at run‑time.       */

                                                                               /* Set to FALSE if entering f(x) inside the  */

                                                                               /* C source code and re‑compiling it.        */

                                                                               /* (default)                                 */

 

#define      NAAUTIL_OBJ             FALSE       /* Set to TRUE if using "naautil.c" as a     */

                                                                               /* pre‑compiled object code file to be       */

                                                                               /* linked to at algorithm compile time.      */

                                                                               /* Set to FALSE if using "naautil.c" as an   */

                                                                               /* un‑compiled include file (default).       */

 

/********************** Computer System Specific Flags ***********************/

 

#define      OLD_UNIX_OS           FALSE       /* TRUE if running on older UNIX systems.    */

 

#define NO_LONG_DOUBLES   TRUE         /* TRUE if your C compiler does not have     */

                                                                               /* the "long double" type.                   */

                                                                               /* (Set to TRUE for most VAX C compilers)    */

 

/*****************************************************************************/

 

#define      MAX_LINE_SIZE 130 /* Largest input line size accepted.      */

                                                                              /* Set to 130 for MS‑DOS computers.       */

 

 

/*****************

 * INCLUDE FILES *

 *****************/

 

#include <math.h>                         /* For math function prototypes.             */

#include <stdio.h>                         /* For scanf(), printf() and fprintf().      */

#include <stdlib.h>                        /* Needed for calloc(), free() and rand().   */

 

#if OLD_UNIX_OS == TRUE                            /* For older UNIX C compilers       */

#include <varargs.h>                     /* For vfprintf() used in printf2() */

#else

#include <stdarg.h>                       /* For vfprintf() used in printf2() */

#endif

 

/*

**  NOTE: Including <ctype.h> for tolower() may causes errors in Microsoft C

**  5.0 for IBM PCs where tolower() is defined in the <stdlib.h> header file

**  as well.

*/

 

 

/********************

 * GLOBAL VARIABLES *

 ********************/

 

#if NAAUTIL_OBJ == FALSE        /* If "naautil.c" is not pre‑compiled.    */

  FILE *file_id;                                  /*   Identifies the output file.          */

  char  tmpstr[MAX_LINE_SIZE];  /*   A temporary string.                  */

  int   eqeval = FALSE;                                        /*   Set if using the Equation Evaluator. */

#else                                                                    /* If "naautil.c" is pre‑compiled.        */

  extern FILE *file_id;

  extern char  tmpstr[MAX_LINE_SIZE];

  extern int   eqeval;

#endif

 

 

/***********************

 * FUNCTION PROTOTYPES *

 ***********************/

 

#if ANSI == TRUE       /* ANSI STANDARD PROTOTYPING (Post‑December 14, 1989)*/

  void           naaerror      (char error_text[]);

  int            printf2       (char *format, ...);

  void           NAA_do_first  (char *outfile);

  void           NAA_do_last   (char *outfile);

  double**       dmatrix       (int a, int b, int c, int d);

  float**        matrix        (int a, int b, int c, int d);

  double*        dvector       (int a, int b);

  float*         vector        (int a, int b);

  int*           ivector       (int a, int b);

  void           free_dmatrix  (double **m, int a, int b, int c, int d);

  void           free_matrix   (float **m, int a, int b, int c, int d);

  void           free_dvector  (double *v, int a, int b);

  void           free_vector   (float *v, int a, int b);

  void           free_ivector  (int *v, int a, int b);

  double         eval_eq       (double x, ...);

#else  /* ANSI */           /* OLDER STYLE PROTOTYPING (Pre‑December 14, 1989) */

                                                           /* For compatibility with older C compilers.       */

  void           naaerror();

  int            printf2();

  void           NAA_do_first();

  void           NAA_do_last();

  double**       dmatrix();

  float**        matrix();

  double*        dvector();

  float*         vector();

  int*           ivector();

  void           free_dmatrix();

  void           free_matrix();

  void           free_dvector();

  void           free_vector();

  void           free_ivector();

  double         eval_eq();

#endif        /* ANSI */

 

 

#if NAAUTIL_OBJ == FALSE        /* Include the routines below only if the */

                                                                               /* NAAUTIL_OBJ flag is set to FALSE.      */

 

/****************************

 * EQUATION EVALUATOR LOGIC *

 ****************************/

 

#if EQ_EVAL == TRUE                                      /* Needed for the Equation Evaluator's     */

#include "eqeval.c"                         /* defines, global variables and functions */

#else  /* EQ_EVAL */

 

#if ANSI == TRUE

double eval_eq (double x, ...)       /* May need this "dummy" procedure */

{

  return 0.0;

}

#else

double eval_eq (x, ...)                     /* May need this "dummy" procedure */

double x;

{

  return 0.0;

}

#endif  /* ANSI */

 

#endif  /* EQ_EVAL */

 

 

/***************

 * SUBROUTINES *

 ***************/

 

/*****************************************************************************/

/* naaerror() ‑ Numerical Analysis Algorithms standard error handler.        */

/*****************************************************************************/

void naaerror(error_text)

char error_text[];

{

  /* Print error message to the screen.  (Standard error device) */

  fprintf(stderr, "\n\"Numerical Analysis Algorithms in C\" run‑time");

  fprintf(stderr, " error...\n%s\n", error_text);

  fprintf(stderr, "...now exiting to system...\n");

  exit(‑1);                                            /* Exit the program. */

}

 

 

#if FILE_SAVE == FALSE

 

/*****************************************************************************/

/* Since variable arguments are so terribly non‑portable, the below two      */

/* defines will allow the programs to work properly, but without the use of  */

/* the file_save option (or variable argument lists).  They turn printf2()   */

/* into tried‑and‑true printf() and they hide the usage of the file_id       */

/* variable by turning "fprintf(file_id, ...)" into "sprintf(tmpstr, ...)".  */

/* This causes a write to an ignored string instead of to a file.            */

/*****************************************************************************/

 

#define printf2                                 printf                              /* For printf2() */

#define fprintf                                  sprintf                            /* For fprintf(file_id, ...) */

#define file_id                                 tmpstr

 

#else         /* FILE_SAVE == TRUE */

 

#if OLD_UNIX_OS == TRUE                                               /* For older UNIX C compilers */

 

/*****************************************************************************/

/* printf2() ‑ Like printf() but prints to the outfile (file_id) also, if    */

/*             the FILE_SAVE flag is set to TRUE.                            */

/*             Use this printf2() instead of the below printf2() if your C   */

/*             compiler does not have <stdarg.h>, but does have <varargs.h>. */

/*                                                                           */

/*             NOTE:  This code segment has not been tested.                 */

/*****************************************************************************/

 

/*

**  printf2() ‑ OPTION #1 ‑‑ Uses #include <varargs.h>

*/

 

int printf2(va_alist)

va_list va_alist;

/* or   (w/out a ';')

va_decl

*/

{

  va_list args;

  char *format;

  int length;

 

  /* Note the one less parameter in va_start() than in the below printf2() */

  va_start(args);

  format = va_arg(args, char*);

  length = vprintf(format, args);

  vfprintf(file_id, format, args);

  va_end(args);

  return length;

}

 

#else  /* OLD_UNIX_OS */                               /* For ANSI C compilers */

 

/*****************************************************************************/

/* printf2() ‑ Like printf() but prints to the outfile (file_id) also, if    */

/*             the FILE_SAVE flag is set to TRUE.                            */

/*****************************************************************************/

 

/*

**  printf2() ‑ OPTION #2 ‑‑ Uses #include <stdarg.h>

*/

 

#if ANSI_FUNCT == TRUE

int printf2(char *format, ...)

#else

int printf2(format, ...)

char *format;

#endif

{

  va_list args;

  int length;

 

  va_start(args, format);

  length = vprintf(format, args);     /* Prints to the screen (stdout).  */

  vfprintf(file_id, format, args);       /* Prints to a file (file_id).     */

  va_end(args);

  return length;

}

 

#endif        /* OLD_UNIX_OS */

 

#endif        /* FILE_SAVE */

 

 

/*****************************************************************************/

/* NAA_do_first() ‑ Opens the output file if the FILE_SAVE flag is set to    */

/*                  TRUE, prints the NAA banner to the screen and output     */

/*                  file, then prompts for an optional title and the         */

/*                  optional Equation Evaluator.                             */

/*****************************************************************************/

void NAA_do_first(outfile)

char *outfile;

{

  int i;

 

#if FILE_SAVE == TRUE                                   /* Set to TRUE if saving output to a file. */

  /* Open the default output file initialized in the main program. */

  if ((file_id = fopen(outfile, "w")) == NULL) {

    sprintf(tmpstr, "Can not open the output file named \"%s\".", outfile);

    naaerror(tmpstr);

  }

#endif        /* FILE_SAVE */

 

  /* Print the Numerical Analysis Algorithms banner. */

  for (i=1;i<80;i++)  printf2("‑");

  printf2("\n\t\t   \"Numerical Analysis Algorithms in C\" v4.2\n");

  for (i=1;i<80;i++)  printf2("‑");

  printf2("\n\n");

 

#if TITLE_PROMPT == TRUE

  /* Prompt for an optional title to be placed into the output file. */

  printf("Enter an optional title [ie ‑ Set 2.1,  Problem 2 a) ].\n‑‑‑‑> ");

  fgets(tmpstr, MAX_LINE_SIZE, stdin);

 

  /* Print the optional title to the output file only if one was entered. */

  if (tmpstr[0] != '\n')

    fprintf(file_id, "%s\n", tmpstr);

  printf("\n");

#endif        /* TITLE_PROMPT */

 

#if EQ_EVAL == TRUE

  get_eq();                     /* Get the equation and store it into "tmpstr." */

  if (eqeval == TRUE)  /* eqeval is set by get_eq().  If set, then     */

    parse_eq();                                  /* parse the equation into a usable structure.  */

#endif        /* EQ_EVAL */

 

}

 

/*****************************************************************************/

/* NAA_do_last() ‑ Closes the default output file and informs the user of    */

/*                 its creation or update.                                   */

/*****************************************************************************/

void NAA_do_last(outfile)

char *outfile;

{

 

#if FILE_SAVE == TRUE

  if (fclose(file_id) == EOF) {

    sprintf(tmpstr, "Can not close the output file named \"%s\".", outfile);

    naaerror(tmpstr);

  }

  printf("\nOutput saved into file \"%s\".\n", outfile);

#endif        /* FILE_SAVE */

 

}

 

/*****************************************************************************/

/* dmatrix() ‑ Allocates a double matrix with range [a..b][c..d].            */

/*****************************************************************************/

double **dmatrix(a,b,c,d)

int a,b,c,d;

{

  int i;

  double **m;

 

  /* allocate pointers to rows. */

  m = (double **) calloc((unsigned) (b‑a+1), sizeof(double*));

  if (!m)

    naaerror("allocation failure 1 in dmatrix()");

  m ‑= a;

 

  /* allocate rows and set pointers to them. */

  for (i=a;i<=b;i++) {

    m[i] = (double *) calloc((unsigned) (d‑c+1), sizeof(double));

    if (!m[i])

      naaerror("allocation failure 2 in dmatrix()");

    m[i] ‑= c;

  }

 

  return (m);                                      /* return pointer to array of pointers to rows. */

}

 

/*****************************************************************************/

/* matrix() ‑ Allocates a float matrix with range [a..b][c..d].              */

/*****************************************************************************/

float **matrix(a,b,c,d)

int a,b,c,d;

{

  int i;

  float **m;

 

  /* allocate pointers to rows. */

  m = (float **) calloc((unsigned) (b‑a+1), sizeof(float*));

  if (!m)

    naaerror("allocation failure 1 in matrix()");

  m ‑= a;

 

  /* allocate rows and set pointers to them. */

  for (i=a;i<=b;i++) {

    m[i] = (float *) calloc((unsigned) (d‑c+1), sizeof(float));

    if (!m[i])

      naaerror("allocation failure 2 in matrix()");

    m[i] ‑= c;

  }

 

  return (m);                                      /* return pointer to array of pointers to rows. */

}

 

/*****************************************************************************/

/* dvector() ‑ Allocates a double vector with range [a..b].                  */

/*****************************************************************************/

double *dvector(a,b)

int a,b;

{

  double *v;

 

  v = (double *) calloc((unsigned) (b‑a+1), sizeof(double));

  if (!v)

    naaerror("allocation failure in dvector()");

  return (v‑a);

}

 

/*****************************************************************************/

/* vector() ‑ Allocates a float vector with range [a..b].                    */

/*****************************************************************************/

float *vector(a,b)

int a,b;

{

  float *v;

 

  v = (float *) calloc((unsigned) (b‑a+1), sizeof(float));

  if (!v)

    naaerror("allocation failure in vector()");

  return (v‑a);

}

 

/*****************************************************************************/

/* ivector() ‑ Allocates an integer vector with range [a..b].                */

/*****************************************************************************/

int *ivector(a,b)

int a,b;

{

  int *v;

 

  v = (int *) calloc((unsigned) (b‑a+1), sizeof(int));

  if (!v)

    naaerror("allocation failure in ivector()");

  return (v‑a);

}

 

/*****************************************************************************/

/* free_dmatrix() ‑ Frees a matrix allocated with dmatrix().                 */

/*****************************************************************************/

void free_dmatrix(m,a,b,c,d)

double **m;

int a,b,c,d;                                         /* (variable d is never used.) */

{

  int i;

 

  for(i=b;i>=a;i‑‑)

    free((char *) (m[i]+c));

  free((char *) (m+a));

}

 

/*****************************************************************************/

/* free_matrix() ‑ Frees a matrix allocated with matrix().                   */

/*****************************************************************************/

void free_matrix(m,a,b,c,d)

float **m;

int a,b,c,d;                                         /* (variable d is never used.) */

{

  int i;

 

  for(i=b;i>=a;i‑‑)

    free((char *) (m[i]+c));

  free((char *) (m+a));

}

 

/*****************************************************************************/

/* free_dvector() ‑ Frees a double vector allocated by dvector().            */

/*****************************************************************************/

void free_dvector(v,a,b)

double *v;

int a,b;                                               /* (variable b is never used.) */

{

  free((char *) (v+a));

}

 

/*****************************************************************************/

/* free_vector() ‑ Frees a float vector allocated by vector().               */

/*****************************************************************************/

void free_vector(v,a,b)

float *v;

int a,b;                                               /* (variable b is never used.) */

{

  free((char *) (v+a));

}

 

/*****************************************************************************/

/* free_ivector() ‑ Frees an integer vector allocated by ivector().          */

/*****************************************************************************/

void free_ivector(v,a,b)

int *v,a,b;                                           /* (variable b is never used.) */

{

  free((char *) (v+a));

}

 

 

/*****************************************************************************/

 

#endif        /* NAAUTIL_OBJ */

 

/******************************************************************************

*                  Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 3Q 1991, v4.2      *

*                  Copyright (C) 1988‑1991, Harold A. Toomey, All Rights Reserved.       *


******************************************************************************/


APPENDIX C

 

Language Comparison Charts

 


Appendix C:      Language Comparison Charts

 

This section is intended to help those who have learned other languages other than C to transfer their knowledge easily into C.  The tables provided should help in understanding and modifying the equations and code as needed to perform numerical analysis.  These tables provide a simple comparison of items most likely to be used in numerical analysis programs.

 

Complete working example programs are also provided to give clear examples of how programs look in each of the below languages.

 

The languages compared to C include:

 

LANGUAGE          COMPILER                                        STANDARD

1. Ada                   Meridian Ada 4.1                  ANSI/MIL‑STD‑1815A

2. BASIC               Microsoft GW‑BASIC 3.20

3. C                       Microsoft C 5.0                                   ANSI C

4. C++                  Borland Turbo C++ 2.0                      AT&T C++ v2.0

5. FORTRAN 77   Microsoft FORTRAN 77 3.3               ANSI FORTRAN 77

6. Pascal              Borland Turbo PASCAL 3.01A

 

(NOTE: '...' means one or more statements).


C.1   C vs Ada

 

Description:                                      C                                                       ADA

======================================================================

 

ARITHMETIC OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Addition                          +                                                       +

Subtraction                                                                           

Multiplication                                     *                                                        *

Division                          /                                                         /

Modulus (real)                                   fmod(), modf()                                  N/A

Modulus (integer)           %                                                      MOD, REM

Exponentiation                                  pow()                                                 **

 

 

RELATIONAL OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Greater Than                                    >                                                        >

Greater Then or Equal   >=                                                     >=

Less Than                     <                                                       <

Less Than or Equal       <=                                                     <=

Equal                                                ==                                                     =

Not Equal                       !=                                                      /=

 

 

LOGICAL OPERATORS:                                                       (With Bit_Ops; Use Bit_Ops;)

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

And                                                   &&                                                     AND

Or                                                     ||                                                        OR

Not                                                    !                                                         NOT

Xor                                                    N/A                                                    XOR

 

 

ASSIGNMENT OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Assignment                                      =                                                        :=

Assignment w/Add        i += 2;                                               I := I + (2);

Assignment w/Sub        i ‑= 4;                                                I := I ‑ (4);

Assignment w/Mult        x *= ‑2.1;                        X := X * (‑2.1);

Assignment w/Div         x /= 8.9;                         X := X / (8.9);

Assignment w/Mod        x %= 7.3;                       X := X REM (7.3);

 

 

INCREMENT AND DECREMENT STATEMENTS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Post‑Increment                                 i++;                                                    I := I + 1;

Post‑Decrement                               i‑‑;                                                      I := I ‑ 1;

Pre‑Increment                                  ++i;                                                    I := I + 1;

Pre‑Decrement                                ‑‑i;                                                      I := I ‑ 1;

 

 

DATA TYPES:                                                                         (With Standard; Use Standard;)

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      char                                                  CHARACTER

String                                                char str[n];                     str : STRING(1..20)

                                                                                                                   ‑or‑  STRING

Integer                                               int                                                      INTEGER

Integer with limits           (use int)                         POSITIVE

                                                          (use int)                         NATURAL

Long Integer                                      long                                                  

Floating Point                                    float                                                   FLOAT ‑or‑ REAL

Double‑Precision Float  double                           

Double Double‑Precision                 long double                   

Complex                                           fcomplex (naautil.c)       (See the record below)

Arrays                                               float A[3][2];                                       A : ARRAY (1..3,1..2)

                                                                                                                     of FLOAT;

Enumeration                                     enum gender {M,F};       type GENDER is (M,F);

Boolean                                                                                                      BOOLEAN

Pointers                         int *ptr;                           PTR = ^INTEGER;  ???

Structures                      struct complex {            type COMPLEX_TYPE is

                                                            float r, i;                          RECORD                   

                                                          };                                                            R, I : REAL;

                                                                                                                     END RECORD;

File Pointers                                     FILE *fptr;                     

 

                   Examples of ADA type declarations:

                                       type STRING  is array  (POSITIVE range <>) of

                                         CHARACTERS;

                                       type INTEGER is range  1..2_000;

                                       type FLOAT   is digits 16;

                                       type REAL    is digits 16;

                                       type REAL    is digits 16  range 0.0..1.0E35;

                                       type FIXED   is delta  0.1 range 0.0..255.0;

 

 

DATA TYPE INITIALIZATION:                              (With Standard; Use Standard;)

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      char ch = 'c';                                     CH := 'c';

String                                                char *str = "A string";     STR := "A string";

Integer                                               int i = 5;                          I := 5;

Long Integer                                      int i = 5L;                       

Floating Point                                    float x = 123.4F;             X := 123.4;

Floating Point                                    float x = 1.0e‑2F;           X := 1.0E‑2;

Double‑Precision Float  double x = 123.4;                             

Double‑Precision Float  double x = 1e‑2;                               

Double Double‑Precision                 long double x = 123.4L;

Double Double‑Precision                 long double x = 1e‑2L;  

Complex                                           fcomplex c = {6.2,7.1};

Arrays                                               float A[3][2] = {{4,2},{1,‑2},{0,5}};     

                                                                                                                   A(2,2) := ‑2;

Enumeration                                     boolean ANS = NO;      

Boolean                                            N/A                                                    BOOLEAN FOUND;

                                                                                                                   FOUND := FALSE;

Pointers                         char *                                                ^

Structures                      struct complex {            RECORD1 := RECORD2;

                                                            float r = 12.0;                                    

                                                            float i = 7.0;                                      

                                                          };                                                         

File Pointers                                     FILE *fptr;                     

Constants                      #define PI 3.1415            CONST PI = 3.1415;

                                                          const char DOLLAR = '$';  CONST DOLLAR = '$';

 

 

                                                                                                (With Unchecked_Conversion;)

DATA TYPE CONVERSION:                                                  (Use  Unchecked_Conversion;)

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      (char) i                           CHARACTER(i);

String                                                (char *) x                        STRING(x);

Integer                                               (int) ch                           INTEGER(ch);

Long Integer                                      (long) x                          

Floating Point                                    (float) x                           REAL(x);

Double‑Precision Float  (double) x                     

Double Double‑Precision                 (long double) x

Complex                                           (complex) x                                       COMPLEX(x);

Other Types                                     typedef ... new_type;     type NEW_TYPE is ...;

                                                          (new_type) x                                     NEW_TYPE(x);

 

 

STANDARD FUNCTIONS:                                                     (With Math_Lib; Use Math_Lib;)

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Truncation                     trunc() (in trunc.c)        

Round                                               round() (in round.c)      

Nearest Integer                                 ceil()                                                 

Nearest Whole Number                   floor()                                               

Absolute Value                                  abs(), fabs()                                      ABS()

Odd (INTEGER)                               #define ODD(a) (a%2)?(1):(0)

 

Square Root                                     sqrt()                                                 SQRT()

Square                                              x*x                                                     X*X

Exponential                    exp()                                                 EXP()

Natural Log                    log()                                                  LOG(X)

Common Log                                   log10()                                               LOG(X,10)

Power                                               pow(x,y)                         "**"(X,Y)

 

Sine                                                  sin()                                                   SIN()

Cosine                                              cos()                                                 COS()

Tangent                                            tan()                                                  TAN()

Cotangent                      1.0/tan()                         COT()

Arcsine                                             asin()                                                 ARCSIN()

Arccosine                      acos()                                               ARCCOS()

Arctangent                     atan()                                                ATAN(X)

Atan of Quotient             atan2()                                              ATAN(X,Y)

 

Hyperbolic Sine                                sinh()                                                 SINH()

Hyperbolic Cosine         cosh()                                               COSH()

Hyperbolic Tangent       tanh()                                                TANH()

Hyperbolic Cotangent    1.0/tanh()                       COTH()

Hyperbolic Arcsine                                                                  ARCSINH()

Hyperbolic Arccosine                                                              ARCCOSH()

Hyperbolic Arctangent                                                             ARCTANH()

Hyperbolic Arccotangent                                                                            ARCCOTH()

 

Random Number                              rand(), srand()                                 

 

 

SYNTAX:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Case Sensitive?                               YES                                                   NO

Name a program                              main()                                               Procedure Prog_Name is

                                                          {                                                         begin

                                                            ...                                                       ...

                                                          }                                                         end Prog_Name;

Define a Package          use #include "package_name.h"

                                                                                                                   Package Prog_Name is

                                                                                                                     ...

                                                                                                                   end;

                                                                                                                   Package body Prog_Name

                                                                                                                   is

                                                                                                                     ...

                                                                                                                   end Prog_Name;

Comment Begin                               /*                                                       ‑‑

Comment End                                  */                                                       <CARRIAGE RETURN>

Begin Symbol                                   {                                                         BEGIN

End Symbol                                      }                                                         END;  ‑or‑  END function_name;

Statement Terminator   ;                                                         ;

Include Files                                     #include <filename.h>   With Package_name;

                                                          #include "filename.h"

Variable Names                                a‑zA‑Z0‑9_                     A‑Z0‑9_

                                                          (31 chars max.)                                (? chars max.)

 

Functions                       float func_name (int x, y)

                                                          {

                                                            ...

                                                            return some_float;

                                                          }

                                                               FUNCTION FNAME (X,Y: REAL) RETURN REAL is

                                                                 ...

                                                                 RETURN SOMEREAL;

                                                               end FNAME;

 

Procedures                                       proc_name (int x, y)

                                                                                    PROCEDURE PROC_NAME(X,Y: REAL);

 

Get Input                        scanf("%f", &sum);       READLN (SUM);

 

                                                          scanf("%s", &string);     GET (STRING_VAR);

 

                                                          scanf("%s", &string);     GET_LINE (STRING_VAR);

                                                          printf("\n");

 

                                                          scanf("%c", &ch);          GET (CH);

 

                                                                                                (With Text_IO; Use Text_IO;)

Print Output                                      printf("A = %f\n", A);

                                                                                                   Float_IO.PUTLN ('A = ', A);

                                                                                                                  

                                                          printf("A = %f", A);

                                                                                                   Float_IO.PUT ('A = ', A);

 

                                                          printf("S = %s", S);        PUT('S = ', S);  ‑or‑

 

                                                          printf("S = %s\n", S);     PUT_LINE('S = ', S);

 

                                                          printf("\n");                      NEW_LINE;

 

                                                          printf("\n\n\n");                NEW_LINE (ITEM => 3);

 

                                                                 May Need:

                                                                 Package FIO is new float_io(float);

                                                                 Package IIO is new integer_io(integer);

                                                                 Package Ada_IO is new ...;

 

File Output                     FILE *file_id;

                                                          file_id = fopen("filename", "w");

                                                          ...

                                                          fprintf(file_id, "Any string here");

                                                          ...

                                                          fclose(file_id);

 

                                                                                               

                                                                                                ...

                                                                                               

                                                                                                ...

                                                                                               

 

 

Exit                                                    exit(1);                            Exit (Package_Name);

                                                          (Exits main())                                    (Exits Package_Name)

 

CONTROL STRUCTURES:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

If‑Then‑Else                                      if (x>y) {                         IF X > Y THEN

                                                            ...                                                       ...

                                                                                                                   (No BEGIN/END needed)

                                                          }                                                         ELSIF X = Y THEN

                                                          else if (x==y) {                 ...

                                                            ...                                                     ELSE

                                                          } else {                             ...

                                                            ...                                                     END IF;

                                                          }                                                        

 

Case                                                 switch (my_var) {          CASE MY_VAR IS

                                                            case 'D' :                       WHEN 'D' =>

                                                              ...                                                       ...

                                                              break;                           WHEN 'Y' | 'y' =>

                                                            case 'Y':                           ...

                                                            case 'y':                         WHEN OTHERS => NULL;

                                                              ...                                                   END CASE;

                                                              break;

                                                            default : break;

                                                          }                                                        

 

Loops                                                while (1) {                       LOOP

                                                            ...                                                       ...

                                                            if (x==y)                         EXIT WHEN X = Y;

                                                              break;                           ...

                                                            ...                                                     END LOOP;

                                                          }

 

                                                          ‑‑ or ‑‑

 

                                                          for (;;) {

                                                            ...

                                                           if (x==y)

                                                              goto exit_label;

                                                            ...

                                                          }

                                                          exit_label:

 

While Loops                                     while (count != 5) {        WHILE count /= 5 LOOP

                                                            ...                                                       ...

                                                          }                                                         END LOOP;

 

For Loops                      for (i=1;i<=10;i++) {       FOR I IN 1..10 LOOP

                                                            ...                                                       ...

                                                          }                                                         END LOOP;

 

                                                          for (i=10;i>=1;i‑‑) {         FOR I IN REVERSE 1..10 LOOP

                                                            ...                                                       ...

                                                          }                                                         END LOOP;

 

Named Loops                                   N/A                                                    SUMMATION:

                                                                                                                   WHILE COUNT /= 5 LOOP

                                                                                                                     ...

                                                                                                                   END LOOP SUMMATION;

 

Block Statements          if (1) {                             SWAP:

                                                            int temp;                       DECLARE

                                                            temp = v;                       TEMP : INTEGER;

                                                            v = u;                            BEGIN

                                                            u = temp;                       TEMP := V;

                                                          }                                                           V := U;

                                                                                                                     U := TEMP;

                                                                                                                   END SWAP;                                                                                  

 

Goto                                                  goto label_text;              GOTO LABEL_TEXT;

                                                          ...                                                       ...

                                                          label_text :                     <<LABEL_TEXT>>

                                            ...                                         ...


C.2   C vs BASIC

 

Description:                                      C                                                       BASIC

======================================================================

 

ARITHMETIC OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Addition                          +                                                       +

Subtraction                                                                           

Multiplication                                     *                                                        *

Division (float)                /                                                         /

Division (integer)           /                                                         \

Modulus (integer)           %                                                      MOD

Exponentiation                                  pow()                                                 ^

 

 

RELATIONAL OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Greater Than                                    >                                                        >

Greater Then or Equal   >=                                                     >=

Less Than                     <                                                       <

Less Than or Equal       <=                                                     <=

Equal                                                ==                                                     =

Not Equal                       !=                                                      <>

 

 

LOGICAL OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

And                                                   &&                                                     AND

Or                                                     ||                                                        OR

Not                                                    !                                                         NOT

Exclusive Or                                     N/A                                                    XOR

Implication                     N/A                                                    IMP

Equivalence                                      ==                                                     EQV

 

 

ASSIGNMENT OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Assignment                                      =                                                        =

Assignment w/Add        i += 2;                                               I = I + (2)

Assignment w/Sub        i ‑= 4;                                                I = I ‑ (4)

Assignment w/Mult        x *= ‑2.1;                        X = X * (‑2.1)

Assignment w/Div (float) x /= 8.9;                       X = X / (8.9)

Assignment w/Div (Int)  N/A                                                    X = X \ (8.9)

Assignment w/Mod        x %= 7.3;                       X = X MOD (7.3)

 

 

INCREMENT AND DECREMENT STATEMENTS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Post‑Increment                                 i++;                                                    I = I + 1

Post‑Decrement                               i‑‑;                                                      I = I ‑ 1

Pre‑Increment                                  ++i;                                                    I = I + 1

Pre‑Decrement                                ‑‑i;                                                      I = I ‑ 1

 

 

DATA TYPES:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      char ch;                         DEFSTR C

                                                                                                                   (First letter only)

                                                                                                                   ‑or‑  C$

String                                                char str[n];                     DEFSTR S

                                                                                                                   (First letter only)

                                                                                                                   ‑or‑  S$

Integer                                               int i,j;                              DEFINT I,J

                                                                                                                   (First letter only)

                                                                                                                   ‑or‑  I, J

Long Integer                                      long i;                                               

Floating Point                                    float x;                            DEFSNG X

                                                                                                                   (First letter only)

                                                                                                                   ‑or‑  X!

Double‑Precision Float  double x;                        DEFDBL X

                                                                                                                   (First letter only)

                                                                                                                   ‑or‑  X#

Double Double‑Precision                 long double x;                                   

Complex                                           fcomplex (naautil.c)      

Arrays                                               int A[3];                           DIM A (3)

Enumeration                                     enum boolean {NO,YES};                

Logical                                              N/A                                                   

Functions                       N/A                                                    DEF FNname(X)

                                                                                                                   (Prefix with FN)

 

 

DATA TYPE INITIALIZATION:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      char ch='c';                                       CH$ = "c"

String                                                char *str="string";          STR$ = "string"

Integer                                               int i=5;                            I = 5%  ‑or‑  I = 5

Long Integer                                      int i=5L;                         

Floating Point                                    float x=123.4F;                                  X = 123.4!, X = 123.4

                                                                                                                   -or- X!=123.4

Floating Point                                    float x=1.0e‑2F;             X = 1.0E‑2

Double‑Precision Float  double x=123.4;                                X = 123.4#

Double‑Precision Float  double x=1e‑2;                                  X = 1.0D‑2

Double Double‑Precision                 long double x=123.4L;  

Double Double‑Precision                 long double x=1e‑2L;    

Complex                                           fcomplex c={6.2,7.1};   

Arrays                                               int A[3]={4,2,7};             

Enumeration                                     boolean T=NO;

Constants                      const double x=123.4;   PI# = 3.14

                                                          #define PI 3.14                                    (Usage: X = 2 * PI#)

Logical                                              N/A                                                   

 

 

DATA TYPE CONVERSION:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      (char) x                                            

String                                                (char *) x                        "Type Mismatch" ERROR

Integer                                               (int) x                                                 CINT(X)

Long Integer                                      (long) x                                             

Floating Point                                    (float) x                           CSNG(X)

Double‑Precision Float  (double) x                      CDBL(X)

Double Double‑Precision                 (long double) x                                 

Complex                                           (complex) x                                      

 

 

STANDARD FUNCTIONS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Truncation                     trunc() (in trunc.c)         FIX()

Round                                               round() (in round.c)       CINT()

Nearest Integer                                 ceil()                                                 

Nearest Whole Number                   floor()                                                INT()

Absolute Value                                  abs(), fabs()                                      ABS()

Choose Largest                                #define MAX(a,b) (a)>(b)?(a):(b)

Choose Smallest                              #define MIN(a,b) (a)<(b)?(a):(b)

 

Square Root                                     sqrt()                                                 SQR()

Exponential                    exp()                                                 EXP()

Natural Log                    log()                                                  LOG()

Common Log                                   log10()                                               LOG(X) / LOG(10)

 

Sine                                                  sin()                                                   SIN()

Cosine                                              cos()                                                 COS()

                                                                                                                   (Load interpreter with

                                                                                                                   /D option for doubles)

Tangent                                            tan()                                                  TAN()

Arcsine                                             asin()                                                 ATN(X/SQR(‑X*X+1))

Arccosine                      acos()                                               ‑ATN(X/SQR(‑X*X+1))

                                                                                                                     + 1.5708

Arctangent                     atan()                                                ATN()

Atan of Quotient             atan2()                                             

 

Hyperbolic Sine                                sinh()                                                 (EXP(X) ‑ EXP(‑X))/2

Hyperbolic Cosine         cosh()                                               (EXP(X) + EXP(‑X))/2

Hyperbolic Tangent       tanh()                                                (EXP(X) ‑ EXP(‑X)) /

                                                                                                                     (EXP(X) + EXP(‑X))

Random Number                              rand(), srand()                                  RND()  (Returns 0..1)

 

 

SYNTAX:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Case Sensitive?                               YES                                                   NO

Name a program                              main()                                              

Comment Begin                               /*                                                       '  ‑or‑  REM

Comment End                                  */                                                       <CARRIAGE RETURN>

Begin Symbol                                   {                                                        

End Symbol                                      }                                                         END

Statement Terminator   ;                                                         <CARRIAGE RETURN>

                                                                                                                   ‑or‑  ':' followed by

                                                                                                                   another command

Statement Separator     ;                                                         :

Include Files                                     #include <filename.h>   (Currently not

                                                                                                                     supported?)

                                                          #include "filename.h"

Variable Names                                a‑zA‑Z0‑9_                     A‑Z0‑9.

                                                          (31 chars max.)                                (40 chars max.)

 

Functions                       float func_name (int x, y)

                                                          {                                     DEF FNfunc_name (X,Y) = SIN(X)

                                                            ...                                                     (256 chars max.)

                                                            return sin(x);                ‑or‑

                                                          }

 

                                                                             (Load interpreter with /N switch)

                                                                                                DEF FNfunc_name (X,Y)

                                                                                                  ...

                                                                                                  FNfunc_name = some_float

                                                                                                END DEF

 

                                                                                                                   (Using the /N switch)

Procedures                                       proc_name (int x, y)      GOSUB proc_name

                                                                                                                   -or- GOSUB line #

(Subroutines)                                    {                                                         ...

                                                            ...                                                     proc_name:

                                                          }                                                           ...

                                                                                                                   RETURN

 

                                                                                                                   ‑or‑

 

                                                                             (Load interpreter with /N switch)

                                                                                                                   SUB sub_name(x#)

                                                                                                                     ...

                                                                                                                   END SUB

                                                                                                (Usage: CALL sub_name(x#) )

 

Get Input                        scanf("%f%f", &s1, &s2); INPUT S1, S2

 

                                                          printf("Enter sum");        (DEFSNG S)

                                                          scanf("%f", &sum);        INPUT "Enter sum"; SUM

 

                                                          N/A                                                    READ STR$, NUM1, NUM2

                                                                                                                   DATA "Happy",7.29,2.0

 

Print Output                                      printf("Sum = %f.\n", sum);

                                                                                                PRINT "Sum = "; SUM ;"."

 

                                                          printf("Sum = \t%f\t.\n", sum);

                                                                                                PRINT "Sum = ", SUM ,"."

                                                                                                                  

                                                          printf("\n");                      PRINT

 

File Output                     FILE *file_id;

                                                          file_id = fopen("filename", "w");

                                                          ...

                                                          fprintf(file_id, "Any string");

                                                          ...

                                                          fclose(file_id);

 

                                                                                                100  OPEN "O", #1, "filename"

                                                                                                ...

                                                                                                200  PRINT#1, "Any string."

                                                                                                ...

                                                                                                300  CLOSE #1

 

Exit                                                    exit(1); (Exits main())

                                                                                                RETURN  ‑or‑  STOP

 

 

CONTROL STRUCTURES:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

If‑Then                                              if (x>y) { ... }                   IF (X > Y) THEN ...

 

If‑Then‑Else                                      if (x>y) { ... }                   IF (X > Y) THEN ... ELSE ...

                                                          else { ... }                                          

 

                                                                             (Load interpreter with /N switch)

While Loops                                     while (count != 5) {        WHILE (logical)

                                                            ...                                                       ...

                                                          }                                                         WEND

 

For Loops                      for (i=1;i<=11;i+=2) {     FOR I = 1 TO 11 STEP 2

                                                            ...                                                       ...

                                                          }                                                         NEXT I

 

                                                          for (i=1;i<10;i++) {         FOR I = 1 TO 10‑1

                                                            ...                                                       ...

                                                          }                                                         NEXT I

 

                                                          for (i=10;i>=1;i‑‑) {  FOR I = 10 TO 1 STEP ‑1

                                                            ...                                                       ...

                                                          }                                                         NEXT I

 

 

Case                                                 switch (my_var) {

                                                                                                (Use If‑Then‑Else or IF..GOTO)

                                                            case 'D' :  IF MY_VAR$ = "D" THEN 100

                                                              ...                                IF MY_VAR$ = "Y" THEN 200

                                                              break;     IF MY_VAR$ = "y" THEN 200

                                                            case         'Y':               ...

                                                            case 'y':    100 ...

                                                              ...                                GOTO 400

                                                              break;     200 ...

                                                          }                                     GOTO 400

                                                                                                400 ...

Goto (Logical)                                   goto label_text;              GOTO 200

                                                            ...                                                     ...

                                                          label_text :                     200 ...

                                                            ...

                                                                                                (Load interpreter with /N

                                                                                                                    switch)

                                                                                                                   GOTO my_mark

                                                                                                                     ...

                                                                                                                   my_mark:

                                                                                                                     ...

 

Goto (Computed)                             N/A                                                    ON I GOTO 100,200,300

                                                                                                                   100 ...

                                                                                                                   200 ...

                                                                                                                   300 ...

 

                                                                                                                   ‑same as‑

 

                                                          if i==1 goto label1          IF I = 1 THEN 100

                                                          if i==2 goto label2          IF I = 2 THEN 200

                                            if i==3 goto label3 IF I = 3 THEN 300


C.3   C vs C++

 

Description:                                      C                                                       C++

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

NOTE: Only additional operators are listed, since "C" is a subset of "C++".

 

SYNTAX:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Comment Begin                               /*                                                       //

Comment End                                  */                                                       <NEWLINE>

 

                                                          (Needs #include <stream.h> or <iostream.h>)

Get Input                        scanf("%f", &sum);       cin >> sum;

 

                                                          scanf("%s", &string);     cin >> string;

 

                                                          scanf("%c", &ch);          cin >> ch;

 

                                                          (Needs #include <stream.h> or <iostream.h>)

Print Output                                      printf("A = %f\n", A);       cout << A << "\n";

                                                                                                                  

                                                          printf("A = %f", A);          cout << A;

 

                                                          printf("S = %s", S);        cout << S;

 

                                                          printf("S = %s\n", S);     cout << S << "\n";

 

                                                          printf("X = %d", i+1);      cout << "X = " << i+1;

 

                                                          printf("\n");                      cout << "\n";

 

Use of Objects                                 C = My_Matrix_Multiply(A,B);

                                                                                                                   C = A * B;

 

                                                          X = My_Complex_Multiply(C1,C2);

                                                                                         X = C1 * C2;


C.4   C vs FORTRAN 77

 

Description:                                      C                                                       FORTRAN 77

======================================================================

 

ARITHMETIC OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Addition                          +                                                       +

Subtraction                                                                           

Multiplication                                     *                                                        *

Division                          /                                                         /

Modulus (integer)           %                                                      MOD(x,y)

Exponentiation                                  pow()                                                 **

 

 

RELATIONAL OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Greater Than                                    >                                                        .GT.                              

Greater Then or Equal   >=                                                     .GE.

Less Than                     <                                                       .LT.

Less Than or Equal       <=                                                     .LE.

Equal                                                ==                                                     .EQ.

Not Equal                       !=                                                      .NE.

 

 

LOGICAL OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

And                                                   &&                                                     .AND.

Or                                                     ||                                                        .OR.

Not                                                    !                                                         .NOT.

Equivalent                      N/A                                                    .EQV.

Not Equivalent                                  N/A                                                    .NEQV.

 

 

ASSIGNMENT OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Assignment                                      =                                                        =

Assignment w/Add        i += 2;                                               I = I + (2)

Assignment w/Sub        i ‑= 4;                                                I = I ‑ (4)

Assignment w/Mult        x *= ‑2.1;                        X = X * (‑2.1)

Assignment w/Div         x /= 8.9;                         X = X / (8.9)

Assignment w/Mod        x %= 7.3;                       X = MOD(X, 7.3)

 

 

INCREMENT AND DECREMENT STATEMENTS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Post‑Increment                                 i++;                                                    I = I + 1

Post‑Decrement                               i‑‑;                                                      I = I ‑ 1

Pre‑Increment                                  ++i;                                                    I = I + 1

Pre‑Decrement                                ‑‑i;                                                      I = I ‑ 1

 

 

DATA TYPES:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      char ch;                         CHARACTER*1 CH

                                                                                                                   CHARACTER CH

String                                                char str[n];                     CHARACTER*n STR

                                                                                                                   CHARACTER STR*n

Integer                                               int i,j;                              INTEGER I,J

                                                                                                                   INTEGER*4 I,J

                                                                                                                   INTEGER*1 I,J

                                                                                                                   (Machine dependant)

                                                                                                                   INTEGER*2 I,J

                                                                                                                   (Machine dependant)

Long Integer                                      long i;                                                INTEGER*2 I

                                                                                                                   (Machine dependant)

Floating Point                                    float x;                            REAL X

                                                                                                                   REAL*4 X

Double‑Precision Float  double x;                        DOUBLE PRECISION X

                                                                                                                   REAL*8 X

Double Double‑Precision                 long double x;                                   

Complex                                           fcomplex (naautil.c)       COMPLEX C

Arrays                                               int A[3][2];                       INTEGER A(3,2)  ‑or‑

                                                                                                                   INTEGER A

                                                                                                                   DIMENSION A(3,2)

Enumeration                                     enum boolean {NO,YES};                

Logical                                              N/A                                                    LOGICAL A,B

 

 

DATA TYPE INITIALIZATION:     (Use variables as declared above first)

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      char ch='c';                                       DATA CH/'c'/

String                                                char *str="string";          DATA STR/'string'/

Integer                                               int i=5;                            DATA I/5/

Long Integer                                      int i=5L;                          DATA I/5/

Floating Point                                    float x=123.4F;                                  DATA X/123.4/

Floating Point                                    float x=1.0e‑2F;             DATA X/1.E‑2/

Double‑Precision Float  double x=123.4;                                DATA X/123.4D0/

Double‑Precision Float  double x=1e‑2;                                  DATA X/1.D‑2/

Double Double‑Precision                 long double x=123.4L;  

Double Double‑Precision                 long double x=1e‑2L;    

Complex                                           fcomplex c={6.2,7.1};    DATA C/(6.2,7.1)/

Arrays                                               int A[3][2]={{1,2},{3,4},{5,6}};

                                                                                                                   DATA A/1,3,5,2,4,6/

Enumeration                                     boolean T=NO;

Constants                      const double x=123.4;   REAL*8 X,PI

                                                          #define PI 3.14                                  PARAMETER(X=123.4D0)

                                                                                                                   PARAMETER(PI=3.14)

Logical                                              N/A                                 DATA A,B/.FALSE.,.TRUE.)/

 

 

DATA TYPE CONVERSION:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      (char) x                          CHAR(X)

String                                                (char *) x                       

Integer                                               (int) x                                                 INT(X)

                                                                                                                   FORTRAN 66:

                                                                                                                     IFIX(X), IDINT(X)

Long Integer                                      (long) x

Floating Point                                    (float) x                           REAL(X)

                                                                                                                   FORTRAN 66:

                                                                                                                     SNGL(X), FLOAT(X)

Double‑Precision Float  (double) x                      DBLE(X)

Double Double‑Precision                 (long double) x

Complex                                           (complex) x                                       CMPLX(X)

 

 

STANDARD FUNCTIONS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Truncation                     trunc() (in trunc.c)         AINT(), DINT()

Round                                               round() (in round.c)       ANINT()

Nearest Integer                                 ceil()                                                  NINT(), IDNINT()

Nearest Whole Number                   floor()                                                ANINT(), DNINT()

Absolute Value                                  abs(), fabs()                                      ABS(), IABS(),

                                                                                                                   DABS(), CABS()

Choose Largest                                #define MAX(a,b) (a)>(b)?(a):(b)

                                                                                                                   MAX(), MAX0(),

                                                                                                                   MAX1(), DMAX1()

                                                                                                                   FORTRAN 66:

                                                                                                                     AMAX0(), AMAX1()

Choose Smallest                              #define MIN(a,b) (a)<(b)?(a):(b)

                                                                                                                   MIN(), MIN0(),

                                                                                                                   MIN1(), DMIN1()

                                                                                                                   FORTRAN 66:

                                                                                                                     AMIN0(), AMIN1()

Square Root                                     sqrt()                                                 SQRT(), DSQRT(),

                                                                                                                   CSQRT()

Exponential                    exp()                                                 EXP(), DEXP(), CEXP()

Natural Log                    log()                                                  LOG(), ALOG(),

                                                                                                                   DLOG(), CLOG()

Common Log                                   log10()                                               LOG10(), ALOG10(),

                                                                                                                   DLOG10()

 

Sine                                                  sin()                                                   SIN(), DSIN(), CSIN()

Cosine                                              cos()                                                 COS(), DCOS(), CCOS()

Tangent                                            tan()                                                  TAN(), DTAN()

Arcsine                                             asin()                                                 ASIN(), DASIN()

Arccosine                      acos()                                               ACOS(), DACOS()

Arctangent                     atan()                                                ATAN(), DATAN()

Atan of Quotient             atan2()                                              ATAN2(,), DATAN2(,)

 

Hyperbolic Sine                                sinh()                                                 SINH(), DSINH()

Hyperbolic Cosine         cosh()                                               COSH(), DCOSH()

Hyperbolic Tangent       tanh()                                                TANH(), DTANH()

Random Number                              rand(), srand()                                 

 

 

SYNTAX:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Case Sensitive?                               YES                                                   NO

Name a program                              main()                                               PROGRAM prog_name

Comment Begin                               /*                                                       'C'  ‑or‑  '*' in

                                                                                                                   column 1

Comment End                                  */                                                       <CARRIAGE RETURN>

Begin Symbol                                   {                                                        

End Symbol                                      }                                                         END  w/any character

                                                                                                                   except '0' or <SPACE>

                                                                                                                   in column 6                   

Statement Terminator   ;                                                         <CARRIAGE RETURN>

Include Files                                     #include <filename.h>

                                                                                                $INCLUDE : 'FILENAME.INC'

                                                          #include "filename.h"

Variable Names                                a‑zA‑Z0‑9_                     A‑Z0‑9

                                                          (31 chars max.)                                (6 chars max.)

 

Functions                       float func_name (int x, y)

                                                          {

                                                            ...

                                                            return some_float;

                                                          }

                                                                                                REAL FUNCTION FNAME (X,Y)

                                                                                                  ...

                                                                                                FNAME = SOMEREAL

                                                                                                RETURN

                                                                                                END

 

                                                                                                ‑or‑

 

                                                                                                FUNCTION FNAME (X,Y)

                                                                                                REAL FNAME

                                                                                                  ...

                                                                                                FNAME = SOMEREAL

                                                                                                RETURN

                                                                                                END

 

Procedures                                       proc_name (int x, y) SUBROUTINE SUB_NAME (X,Y)

(Subroutines)                                    {                                                           ...

                                                            ...                                       RETURN

                                                          }                                          END

 

Get Input                        scanf("%f", &sum);       READ *,SUM

 

                                                          scanf("%c", &ch);             READ (4,7) CH

                                                                                                                   7  FORMAT (A1)

 

Print Output                                      printf("A = %f\n", A);       PRINT *, 'A = ', A/

 

                                                          printf("A = %f", A);          PRINT *, 'A = ', A

 

                                                                                                                   ‑or‑

                                                                                                                   WRITE (*,8) A

                                                                                                                   8  FORMAT('1',F8.8)

 

                                                          printf("\n");                      PRINT*

 

                                                                                                                   ‑or‑

 

                                                                                                                   WRITE(*,'(/)')

 

                                                                                                                   ‑or‑

 

                                                                                                                      WRITE (*,9)

                                                                                                                   9  FORMAT(/)

 

File Output                     FILE *file_id;

                                                          file_id = fopen("filename", "w");

                                                          ...

                                                          fprintf(file_id, "Any string\n");

                                                          ...

                                                          fclose(file_id);

 

                                                                             OPEN (UNIT=4, FILE='FILE_NAME')

                                                                             ...

                                                                             WRITE (4,8)

                                                                             FORMAT ('1',2X,'Any string',/)

                                                                             ...

                                                                             CLOSE (4)

 

Exit                                                    exit(1); (Exits main())

                                                                                                RETURN  ‑or‑  STOP

 

 

CONTROL STRUCTURES:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

If‑Then                                              if (x>y) {                         IF (X.GT.Y) THEN

                                                            ...                                                       ...

                                                          }                                                         ENDIF

 

If‑Then‑Else                                      if (x>y) {                         IF (X.GT.Y) THEN

                                                            ...                                                       ...

                                                          }                                                           ...

                                                          else if (x==y) {               ELSE IF (X.EQ.Y) THEN

                                                            ...                                                       ...

                                                          } else {                           ELSE

                                                            ...                                                       ...

                                                          }                                                         ENDIF

 

Arithmetic If                                       if (x>y) ...    (For FORTRAN 66 compatibility)

                                                                                                                   IF (X.GT.Y) ...

                                                                                                                   (limited)

 

                                                                                                (Not in ANSI FORTRAN 77)

While Loops                                     while (count != 5) {        DO WHILE (logical)

                                                            ...                                                       ...

                                                          }                                                         END DO

 

For Loops                      for (i=1;i<=11;i+=2) {     DO 30 I=1,11,2

                                                            ...                                                       ...

                                                          }                                                         30 CONTINUE

 

                                                          for (i=10;i>=1;i‑‑) {         DO 30 I=10,1,‑1

                                                            ...                                                       ...

                                                          }                                                         30 CONTINUE

 

Case                                                 switch (my_var) {          (Use If‑Then‑Else)

                                                            case 'D' :

                                                              ...

                                                              break;                        

                                                            case 'Y':

                                                            case 'y':

                                                              ...                                                  

                                                             break;

                                                          }                                    

 

Goto (Logical)                                   goto label_text;              GOTO S1

                                                                                                                   (S1 is in [1..99999])

                                                            ...                                                       ...

                                                          label_text :                     S1 ...

                                                                                                                   (S1 is in col 1‑5)

                                                            ...

 

Goto (Computed IF)      N/A                                 (For FORTRAN 66 compatibility)

                                                                                                                   GOTO (S1, S2,...Sn) I

                                                                                                                   S1 ...

                                                                                                                   S2 ...

                                                                                                                   Sn ...

 

                                                                                                                   ‑or‑

 

                                                                                                (For FORTRAN 66 compatibility)

                                                                                                                   GOTO I, (S1, S2,...Sn)

                                                                                                                   S1 ...

                                                                                                                   S2 ...

                                                                                                                   Sn ...

 

                                                                                                                   ‑same as‑

 

                                                          if i==1 goto label1          IF (I.EQ.1) GOTO S1

                                                          if i==2 goto label2          IF (I.EQ.2) GOTO S2

                                                          if i==n goto labeln          IF (I.EQ.n) GOTO Sn

 

Goto (Arithmetic IF)       N/A                                                    (Use is discouraged)

                                                                                                IF (arith_exp < 0) S1, S2, S3

 

                                                                                                ‑same as‑

 

                                                                                                IF (arith_exp < 0) GOTO S1

                                                                                                IF (arith_exp = 0) GOTO S2

                                                                          IF (arith_exp > 0) GOTO S3


C.5   C vs Pascal

 

Description:                                      C                                                       Pascal

======================================================================

 

ARITHMETIC OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Addition                          +                                                       +

Subtraction                                                                           

Multiplication                                     *                                                        *

Division (real)                                   /                                                         /

Division (integer)           /                                                         DIV

Modulus (real)                                   fmod(), modf()                                  N/A

Modulus (integer)           %                                                      MOD

Exponentiation                                  pow()                                                 ‑‑‑ NOT STANDARD ‑‑‑

 

 

RELATIONAL OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Greater Than                                    >                                                        >

Greater Then or Equal   >=                                                     >=

Less Than                     <                                                       <

Less Than or Equal       <=                                                     <=

Equal                                                ==                                                     =

Not Equal                       !=                                                      <>

 

 

LOGICAL OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

And                                                   &&                                                     AND

Or                                                     ||                                                        OR

Not                                                    !                                                         NOT

 

 

ASSIGNMENT OPERATORS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Assignment                                      =                                                        :=

Assignment w/Add        i += 2;                                               I := I + (2);

Assignment w/Sub        i ‑= 4;                                                I := I ‑ (4);

Assignment w/Mult        x *= ‑2.1;                        X := X * (‑2.1);

Assignment w/Div         x /= 8.9;                         X := X / (8.9);

Assignment w/Mod        x %= 7.3;                       X := X MOD (7.3);

 

 

INCREMENT AND DECREMENT STATEMENTS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Post‑Increment                                 i++;                                                    I := I + 1;

Post‑Decrement                               i‑‑;                                                      I := I ‑ 1;

Pre‑Increment                                  ++i;                                                    I := I + 1;

Pre‑Decrement                                ‑‑i;                                                      I := I ‑ 1;

 

 

DATA TYPES:                                                                                            (Precede with VAR)

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      char                                                  CHAR

String                                                char str[n];                     STRING[n]

                                                          char * (pointer only)       STRING

                                                                                                                   (default size of 80)

Integer                                               int                                                      INTEGER

Long Integer                                      long                                                  

Floating Point                                    float                                                   REAL

Double‑Precision Float  double                           

Double Double‑Precision                 long double                   

Complex                                           fcomplex (naautil.c)       (Create a record)

Arrays                                               float A[3][2];                                       A : ARRAY [1..3,1..2]

                                                                                                                   OF REAL

Enumeration                                     enum boolean {NO,YES};                 TYPE ANS = (NO, YES);

Boolean                                                                                                      BOOLEAN

Pointers                         int *ptr;                           PTR = ^INTEGER;

Structures                      struct complex {            TYPE COMPLEX_TYPE =

                                                                                                                        RECORD

                                                            float r, i;                               R, I : REAL

                                                          };                                                             END;

File Pointers                                     FILE *fptr;                      TEXT

Ranges                                                                                                       I : 1..80;

 

 

DATA TYPE INITIALIZATION:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      char ch = 'c';                                     CH := 'c';

String                                                char *str = "A string";     STR := 'A string';

Integer                                               int i = 5;                          I := 5;

Long Integer                                      int i = 5L;                       

Floating Point                                    float x = 123.4F;             X := 123.4;

Floating Point                                    float x = 1.0e‑2F;           X := 1.0E‑2;

Double‑Precision Float  double x = 123.4;                             

Double‑Precision Float  double x = 1e‑2;                               

Double Double‑Precision                 long double x = 123.4L;

Double Double‑Precision                 long double x = 1e‑2L;  

Complex                                           fcomplex c = {6.2,7.1};  (Create a record)

Arrays                                               float A[3][2] = {{4,2},{1,‑2},{0,5}};     

                                                                                                                   A(2,2) := ‑2;

Enumeration                                     boolean ANS = NO;       TYPE ANS = (NO, YES);

Boolean                                                                                                      VAR BOOLEAN FOUND;

                                                                                                                   FOUND := FALSE;

Pointers                         char *, ... *                     ^

Structures                      struct complex {            RECORD1 := RECORD2;

                                                            float r = 12.0;                                    

                                                            float i = 7.0;                                      

                                                          };                                                         

File Pointers                                     FILE *fptr;                      OUTFILE : TEXT;

Ranges                                                                                                       I := 39;

                                                                                                                   (1..80 is valid above)

Constants                      #define PI 3.1415          CONST PI = 3.1415;

                                                          const char DOLLAR = '$'; CONST DOLLAR = '$';

 

DATA TYPE CONVERSION:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Character                      (char) i                           CHR(ORD(0) + i);

                                                                                                                   (where i = 0..9)

String                                                (char *) x                       

Integer                                               (int) ch                           ORD(ch) ‑ ORD('0');

                                                                                                                   (where ch = '0'..'9')

Long Integer                                      (long) x

Floating Point                                    (float) x                           (INTEGERs migrate up

                                                                                                                   to REALs)

Double‑Precision Float  (double) x                     

Double Double‑Precision                 (long double) x

Complex                                           (complex) x                                      

 

 

STANDARD FUNCTIONS:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Truncation                     trunc() (in trunc.c)         TRUNC()

Round                                               round() (in round.c)       ROUND()

Nearest Integer                                 ceil()                                                 

Nearest Whole Number                   floor()                                               

Absolute Value                                  abs(), fabs()                                      ABS()

Odd (INTEGER)                               #define ODD(a) (a%2)?(1):(0)         ODD()

 

Square Root                                     sqrt()                                                 SQRT()

Square                                                                                                        SQR()

Exponential                    exp()                                                 EXP()

Natural Log                    log()                                                  LN()

Common Log                                   log10()                                               (LN() / LN(10.0))

Power of Ten (INTEGER)                pow(10.0,x)                                       PWROFTEN(X)

 

Sine                                                  sin()                                                   SIN()

Cosine                                              cos()                                                 COS()

Tangent                                            tan()                                                  (SIN() / COS())

Arcsine                                             asin()                                                 ATAN(X/SQR(‑X*X+1))

Arccosine                      acos()                                               ‑ATAN(X/SQR(‑X*X+1))

                                                                                                                    + 1.5708

Arctangent                     atan()                                                ATAN()

Atan of Quotient             atan2()                                             

Hyperbolic Sine                                sinh()                                                 ((EXP(X) + EXP(‑X))

                                                                                                                      / 2.0)

Hyperbolic Cosine         cosh()                                               ((EXP(X) ‑ EXP(‑X))

                                                                                                                      / 2.0)

Hyperbolic Tangent       tanh()                                                (EXP(X) ‑ EXP(‑X)) /

                                                                                                                     (EXP(X) + EXP(‑X))

Random Number                              rand(), srand()                                 

 

 

SYNTAX:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

Case Sensitive?                               YES                                                   NO

Name a program                              main()                                               PROGRAM prog_name;

Comment Begin                               /*                                                       (*  ‑or‑  {

Comment End                                  */                                                       *)  ‑or‑  }

Begin Symbol                                   {                                                         BEGIN

End Symbol                                      }                                                         END  ‑or‑  END.

                                                                                                                   (last one only)

Statement Terminator   ;                                                         ;  ‑or‑  Nothing if

                                                                                                                   preceding an END or

                                                                                                                   ELSE statement

Include Files                                     #include <filename.h>   {$I FILENAME.INC}

                                                          #include "filename.h"

Variable Names                                a‑zA‑Z0‑9_                     A‑Z0‑9

                                                         (31 chars max.)                                (? chars max.)

 

Functions                       float func_name (int x, y)

                                                          {

                                                            ...

                                                            return some_float;

                                                          }

                                                                             FUNCTION FNAME (X,Y: REAL) : REAL;

                                                                               ...

                                                                             FNAME := SOMEREAL;

 

Procedures                                       proc_name (int x, y)

                                                                             PROCEDURE PROC_NAME (X,Y: REAL);

 

Get Input                        scanf("%f", &sum);       READLN (SUM);

 

                                                          scanf("%c", &ch);          READ (CH);

 

Print Output                                      printf("A = %f\n", A);       WRITELN ('A = ', A);

 

                                                          printf("A = %f", A);          WRITE ('A = ', A);

 

                                                          printf("\n");                      WRITELN;

 

File Output                     #include <stdio.h>

                                                          FILE *file_id;

                                                          file_id = fopen("filename", "w");

                                                          ...

                                                          fprintf(file_id, "Any string here\n");

                                                          ...

                                                          fclose(file_id);

 

                                                                             VAR file_id : TEXT;

                                                                             ASSIGN (file_id, outfile);

                                                                             REWRITE (file_id);

                                                                             ...

                                                                             WRITELN (file_id, 'Any string.');

                                                                             ...

                                                                             CLOSE (file_id);

 

Exit                                                    exit(1); (Exits main())

                                                                                                                   Exit (block name)

 

CONTROL STRUCTURES:

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

If‑Then‑Else                                      if (x>y)                            IF X > Y THEN

                                                          {                                                           BEGIN

                                                            ...                                                         ...

                                                          }                                                           END

                                                          else if (x==y) {               ELSE IF X = Y THEN

                                                            ...                                                       ...

                                                          } else {                           ELSE

                                                            ...                                                       ...

                                                          }

 

While Loops                                     while (count != 5)          WHILE count <> 5 DO

                                                          {                                                         BEGIN

                                                            ...                                                     ...

                                                          }                                                         END

 

For Loops                      for (i=1;i<=10;i++)         FOR I := 1 TO 10 DO

                                                          {                                                         BEGIN

                                                            ...                                                     ...

                                                          }                                                         END

 

                                                          for (i=10;i>=1;i‑‑)           FOR I := 10 DOWNTO 1

                                                          {                                                         DO BEGIN

                                                            ...                                                     ...

                                                          }                                                         END

 

Case                                                 switch (my_var) {          CASE MY_VAR OF

                                                            case 'D' :                       'D' : BEGIN

                                                              ...                                                                        ...

                                                              break;                                            END;

                                                            case 'Y': case 'y':    'Y', 'y' : ...

                                                              ...                                                   ("break" not needed)    

                                                              break;                        

                                                          }                                                         END

 

Repeat                                              do {                                                    REPEAT

                                                            ...                                                       ...

                                                                                                                   (No BEGIN/END needed)

                                                          } while (i < 7);                 UNTIL (I < 7);

 

With                                                  No equivalent                                    (From RECORD variable

                                                                                                                   ME.SSAN)

                                                                                                                   WITH record_var DO

                                                                                                                      SSAN := 1234567890;

 

Goto                                                  goto label_text;              LABEL 20, 30;

                                                          ... label_text : ...             GOTO label_number

                                                                                                                   (1..9999)


                                                                                         ... label_number : ...


APPENDIX D

 

Sample Programs in

Other Languages



Appendix D:    Sample Programs in Other Languages

 

 

This appendix is long, but important.  It lists the example programs of Simpson's Composite Rule for Integration - Algorithm 4.1, in six different languages!  Each of these programs can be found in the LANGS sub-directory of the distribution diskettes.  These files are organized as follows:

 

                            LANGS

                              *

   +)))))))))))0)))))))))))0))2))))))))0)))))))))))0))))))))))),  

   R           R           R           R           R           R

  ADA        BASIC         C          C++       FORTRAN      PASCAL 

   R           R           R           R           R           R

SIMPSON.ADA SIMPSON.BAS SIMPSON.C  SIMPSON.CPP SIMPSON.FOR SIMPSON.PAS

NAAUTIL.ADA SIMPSON.IN  SIMPSON.H  SIMPSON.HPP SIMPSON.IN  NAAUTIL.INC

SIMPSON.IN  SIMPSON.OUT SIMPSON.IN SIMPSON.IN  SIMPSON.OUT NAAMATH.INC

SIMPSON.OUT            SIMPSON.OUT SIMPSON.OUT             SIMPSON.IN

                                                           SIMPSON.OUT


D.1   Ada

 

 

D.1.1  SIMPSON.ADA

 


‑‑ FILE NAME: SIMPSON.ADA

‑‑ LANGUAGE:  ADA

‑‑ COMPILER:  Meridian Ada 4.1

‑‑ STATUS:    Not tested yet

 

‑‑ ****************************************************************************

‑‑                                     Composite Simpson's Rule ‑ Algorithm 4.1

‑‑ ****************************************************************************

‑‑

‑‑                                 !b

‑‑ To approximate the integral I = *  f(x) dx:

‑‑                                 "a

‑‑

‑‑ INPUT endpoints a, b; positive integer n; the function f():

‑‑

‑‑ OUTPUT approximation XI to I.

‑‑

‑‑ ****************************************************************************

‑‑ *              Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.0     *

‑‑ ****************************************************************************

 

with naa_util; use naa_util;          ‑‑ Numerical Analysis Algorithms utilities

with math_lib; use math_lib;        ‑‑ Contains several useful math functions

with text_io;  use text_io;               ‑‑ For file I/O

with ada_io;   use ada_io;            ‑‑ For easier text, integer and float I/O

                                                                               ‑‑ NOTE: ada_io is supplied with the Meridian

                                                                               ‑‑ Ada Compiler

 

procedure simpson is

 

  ‑‑ *************

  ‑‑ * constants *

  ‑‑ *************

 

  ‑‑ NOTE: PI is defined in the package math_lib to 40 decimal places.

  outfile   : constant := "simpson.out";    ‑‑ Default name of the output file

  eq_text_f : constant := "f(x) = sin(x)";  ‑‑ Needs updating  $

 

  ‑‑ *********

  ‑‑ * types *

  ‑‑ *********

  type file_type is limited private;

 

  ‑‑ *************

  ‑‑ * variables *

  ‑‑ *************

 

  a, b, h, x, xi, xi0, xi1, xi2 : float;

  n       : positive;

  title   : string(1..80);

  file_id : file_type;

 

  ‑‑ **********************************

  ‑‑ * LOCAL PROCEDURES AND FUNCTIONS *

  ‑‑ **********************************

 

  ‑‑ **************************************************************************

  ‑‑ * f(x) ‑ Function to evaluate, f(x).  Needs updating $.                           *

  ‑‑ **************************************************************************

  function f(x : in float) return float is

  begin  ‑‑ f

    return (sin(x));

  end f;

 

  ‑‑ **************************************************************************

 

 

‑‑ ********

‑‑ * MAIN *

‑‑ ********

 

begin

 

  ‑‑ **********

  ‑‑ * INPUTS *

  ‑‑ **********

 

  title := get_title;                              ‑‑ Prompts for optional comments

 

  put_line ("Composite Simpson's Rule ‑ Algorithm 4.1");

  new_line;

  put ("Enter endpoint a: ");

  get_line (a);

  put ("Enter endpoint b: ");

  get_line (b);

 

  loop

    put ("Enter number of intervals on [a,b], n: ");

    get_line (n);

 

‑‑  Place an exception handler here for better use of ADA.

    if n <= 0 then                                ‑‑ ERROR ‑ n can not be negative.

      put_line ("ERROR ‑ n must be greater than zero.");

    end if;

 

    exit when n > 0;

  end loop;

 

  ‑‑ *************

  ‑‑ * ALGORITHM *

  ‑‑ *************

 

  ‑‑ STEP #1

  h := (b ‑ a)/n;

 

  ‑‑ STEP #2

  xi0 := f(a) + f(b);

  xi1 := 0.0;                                        ‑‑ Summation of f(x(2i‑1))

  xi2 := 0.0;                                        ‑‑ Summation of f(x(2i))

 

  ‑‑ STEP #3

  for i in 1..n‑1 loop

 

      ‑‑ STEP #4

      x := a + i*h;

 

      ‑‑ STEP #5

      if i mod 2 = 0 then

        xi2 := xi2 + f(x);     ‑‑ For even i

      else

        xi1 := xi1 + f(x);     ‑‑ For odd i

      end if;

 

  end loop;

 

  ‑‑ STEP #6

  xi := h*(xi0 + 2.0*xi2 + 4.0*xi1) / 3.0;

 

  ‑‑ ***********

  ‑‑ * OUTPUTS *

  ‑‑ ***********

 

  ‑‑ STEP #7

  ‑‑ Write output to the screen.

  print_title (title);

 

  put_line ("Composite Simpson`s Rule ‑ Algorithm 4.1");

  new_line;

  put_line (eq_text_f, " from ", a, " to ", b, ".");

  new_line;

  put_line ("n = ", n, " intervals on [a,b].");

  put_line ("Interval number h = ", h);

  new_line;

  put_line ("     !", b);

  put_line ("XI = *  f(x) dx = ", xi);

  put_line ("     "", a);

  new_line;

  put_line ("Required ", n+1, " functional evaluations.");

 

  ‑‑ Write output to a file.

  ‑‑ Open outfile for output.

  create (file => file_id, mode => out_file, name => outfile);              ‑‑ See 14.3.10

 

  print_title_to_outfile (file_id, title);

 

  new_line (file_id);

  put_line (file_id, "Composite Simpson`s Rule ‑ Algorithm 4.1");

  new_line (file_id);

  put_line (file_id, eq_text_f, " from ", a, " to ", b, ".");

  new_line (file_id);

  put_line (file_id, "n = ", n, " intervals on [a,b].");

  put_line (file_id, "Interval number h = ", h);

  new_line (file_id);

  put_line (file_id, "     !", b);

  put_line (file_id, "XI = *  f(x) dx = ", xi);

  put_line (file_id, "     "", a);

  new_line (file_id);

  put_line (file_id, "Required ", n+1, " functional evaluations.");

  close (file => file_id);                                       ‑‑ Closes output file.

 

  new_line;

  put_line ("Output saved into file '", outfile, "'.");

 

end simpson;                                                                         ‑‑ STOP

‑‑ ****************************************************************************

‑‑ *                  Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.            *


‑‑ ****************************************************************************

 

 

D.1.2  NAAUTIL.ADA

 


‑‑ ****************************************************************************

‑‑ * PACKAGE:  NAA_UTIL.ADA                                                                     *

‑‑ * VERSION:  4.0                                                            *

‑‑ *                                                                          *

‑‑ * WRITTEN BY:  Harold A. Toomey, CARE‑FREE SOFTWARE                        *

‑‑ * DATE:        22 May 1991  (2Q 1991)                                      *

‑‑ *                                                                          *

‑‑ * DESCRIPTION:                                                             *

‑‑ *   Contains useful utilities (functions and procedures) to be used with   *

‑‑ *   "Numerical Analysis Algorithms in Ada" v4.0.                           *

‑‑ *                                                                          *

‑‑ * VARIABLES:                                                               *

‑‑ *   numchars : integer;                                                    *

‑‑ *                                                                          *

‑‑ * FUNCTIONS:                                                               *

‑‑ *   get_title()                                                            *

‑‑ *                                                                          *

‑‑ * PROCEDURES:                                                              *

‑‑ *   print_title()                                                          *

‑‑ *   print_title_to_file()                                                  *

‑‑ *                                                                          *

‑‑ ****************************************************************************

 

with ada_io;  use ada_io;

 

‑‑ ****************************************************************************

‑‑  Package specification

‑‑ ****************************************************************************

package NAA_UTIL is

 

  numchars : integer;                      ‑‑ Stores title length in characters.

 

  function get_title return string;

 

  procedure print_title(

      file_id : in file_type;

      title   : in string

  );

 

  procedure print_title_to_outfile(

      file_id : in file_type;

      title   : in string

  );

 

end NAA_UTIL;

 

 

‑‑ ****************************************************************************

‑‑  Package body

‑‑ ****************************************************************************

 

package body NAA_UTIL is

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

‑‑ get_title() ‑ Prompts for an optional title.

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

function get_title return string is

  title : string(1..80);

begin  ‑‑ get_title

  for i in 1..79 loop                           ‑‑ Print the NAA banner

    put ("‑");

  end loop;

  new_line;

  put_line(ht, ht, "'Numerical Analysis Algorithms in Ada' v4.0");

  for i in 1..79 loop

    put ("‑");

  end loop;

  new_line;                                                           ‑‑ Get the title

  put_line ("Enter a title [ie ‑ Set 2.1,  Problem 2 a) ].");

  put ("‑‑‑‑> ");

  get_line (title);

  numchars := title'length;              ‑‑ Numchars stores the length of the title.

  return (title);

end get_title;

 

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

‑‑ print_title() ‑ Prints NAA banner and title to the screen.

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

procedure print_title (file_id : in file_type, title : in string) is

begin  ‑‑ print_title

  for i in 1..79 loop                           ‑‑ Print the NAA banner

    put ("‑");

  end loop;

  new_line;

  put_line(ht, ht, "'Numerical Analysis Algorithms in Ada' v4.0");

  for i in 1..79 loop

    put ("‑");

  end loop;

  new_line;

  if numchars > 0 then

    put_line (title);                             ‑‑ Print the title

    new_line;

  end if;

end print_title;

 

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

‑‑ print_title_to_outfile() ‑ Prints NAA banner and title to the output file.

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

procedure print_title_to_outfile (file_id : in file_type, title : in string) is

begin  ‑‑ print_title_to_outfile

  for i in 1..79 loop                           ‑‑ Print the NAA banner

    put (file_id, "‑");

  end loop;

  new_line (file_id);

  put_line(file_id, ht, ht, "'Numerical Analysis Algorithms in Ada' v4.0");

  for i in 1..79 loop

    put (file_id, "‑");

  end loop;

  new_line (file_id);

  if numchars > 0 then

    put_line (file_id, title);                ‑‑ Print the title

    new_line (file_id);

  end if;

end print_title_to_outfile;

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

 

end NAA_UTIL;            ‑‑ end package body NAA_UTIL

 

‑‑ ****************************************************************************

‑‑ *                 Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.             *


‑‑ ****************************************************************************

 

 

D.1.3  SIMPSON.IN

 

NAA v4.0 Sample Output

0.0

3.14159265358979324

20

 

 

D.1.4  SIMPSON.OUT

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

                                       'Numerical Analysis Algorithms in Ada' v4.0

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

NAA v4.0 Sample Output

 

Composite Simpson's Rule ‑ Algorithm 4.1

 

f(x) = sin(x) from 0 to 3.14159.

 

n = 20 intervals on [a,b].

Interval number h = 0.15708

 

     !3.14159

XI = *  f(x) dx = 2.0000067844

     "0

 

Required 21 functional evaluations.

 


D.2   BASIC

 

 

D.2.1  SIMPSON.BAS

 

10  'FILE NAME: SIMPSON.BAS

20  'LANGUAGE:  BASIC

30  'COMPILER:  Microsoft GW‑BASIC Version 3.20

40  'STATUS:    Compiles and runs correctly

50  '

60  '**************************************************************************

70  '                                Composite Simpson's Rule ‑ Algorithm 4.1

80  '**************************************************************************

90  '

100 '                                  !b

110 '  To approximate the integral I = *  f(x) dx:

120 '                                  "a

130 '

140 '  INPUT endpoints a, b; positive integer n; the function fnf().

150 '

160 '  OUTPUT approximation XI to I.

170 '

180 '**************************************************************************

190 '  Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.0

200 '**************************************************************************

210 '

220  PI# = 3.141592653589793#                   'The constant PI (Usage: X = 2 * PI# )

230  OUTFILE$ = "SIMPSON.OUT"                'Output file name

240  EQTEXTF$ = "f(x) = sin(x)"   'Needs updating  $

250 '

260  DEFDBL A, B, H, X                                    'For XI, XI0, XI1, and XI2 also

270  DEFINT I, N

280  DEFSTR T                                                  'For title

290 '    

300 '**************************************************************************

310 '* FNF(X) ‑ Function to evaluate, f(x).  Needs updating $.

320 '**************************************************************************

330  DEF FNF(X) = SIN(X)

340 '**************************************************************************

350 '

360 '**********

370 '* INPUTS *

380 '**********

390 '

400 'Get the optional title

410  PRINT "‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑"

420  PRINT "           'Numerical Analysis Algorithms in BASIC' v4.0          "

430  PRINT "‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑"

440  PRINT

450  PRINT "Enter a title [ie ‑ Set 2.1,  Problem 2 a) ]."

460  INPUT "‑‑‑‑‑>"; TITLE$

470 '

480  PRINT

490  PRINT "Composite Simpson's Rule ‑ Algorithm 4.1"

500  PRINT

510  INPUT "Enter endpoint a = "; A

520  INPUT "Enter endpoint b = "; B

530  INPUT "Enter number of intervals on [a,b], n = "; N

540 '

550 'ERROR ‑ N must be positive

560  IF (N <= 0) THEN PRINT "ERROR ‑ n must be greater than zero.": GOTO 530

570 '

580 '*************

590 '* ALGORITHM *

600 '*************

610 '

620 'STEP #1

630  H = (B ‑ A) / N

640 '

650 'STEP #2

660  XI0 = FNF(A) + FNF(B)

670  XI1 = 0!                                                        'Summation of f(x(2i‑1))

680  XI2 = 0!                                                        'Summation of f(x(2i))

690 '

700 'STEP #3

710  FOR  I = 1 TO N ‑ 1

720 '

730 '  STEP #4

740    X = A + I*H

750 '

760 '  STEP #5                (For even i)             (For odd i)

770    IF (I MOD 2 = 0)  THEN XI2 = XI2 + FNF(X)  ELSE XI1 = XI1 + FNF(X)

780 '

790  NEXT I

800 '

810 'STEP #6

820  XI = H * (XI0 + 2*XI2 + 4*XI1) / 3

830 '

840 '***********

850 '* OUTPUTS *

860 '***********

870 '

880 'STEP #7

890 'Write output to the SCREEN

900  PRINT "‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑"

910  PRINT "           'Numerical Analysis Algorithms in BASIC' v4.0          "

920  PRINT "‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑"

930  PRINT

940  PRINT TITLE$                        'Print optional title

950  PRINT

960  PRINT "Composite Simpson's Rule ‑ Algorithm 4.1"

970  PRINT

980  PRINT EQTEXTF$, " from"; A ;"to"; B ;"."

990  PRINT

1000  PRINT "n ="; N ;"intervals on [a,b]."

1010  PRINT "Interval number h ="; H

1020  PRINT

1030  PRINT "     !"; B

1040  PRINT "XI = *  f(x) dx = "; XI

1050  PRINT "     ""; A

1060  PRINT

1070  PRINT "Required"; N+1 ;"functional evaluations."

1080 '

1090 'Write output to a FILE

1100  OPEN "O", #1, OUTFILE$  'Create or open the file "041.OUT"

1110  PRINT#1, "‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑"

1120  PRINT#1, "        'Numerical Analysis Algorithms in BASIC' v4.0         "

1130  PRINT#1, "‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑"

1140  PRINT#1,

1150  PRINT#1, TITLE$                                    'Print optional title

1160  PRINT#1,

1170  PRINT#1, "Composite Simpson's Rule ‑ Algorithm 4.1"

1180  PRINT#1,

1190  PRINT#1, EQTEXTF$, " from"; A ;"to"; B ;"."

1200  PRINT#1,

1210  PRINT#1, "n ="; N ;"intervals on [a,b]."

1220  PRINT#1, "Interval number h ="; H

1230  PRINT#1,

1240  PRINT#1, "     !"; B

1250  PRINT#1, "XI = *  f(x) dx = "; XI

1260  PRINT#1, "     ""; A

1270  PRINT#1,

1280  PRINT#1, "Required"; N + 1 ;"functional evaluations."

1290  CLOSE #1

1300 '

1310  PRINT

1320  PRINT "Output saved into file '"; OUTFILE$; "'."

1330  END                                                           'STOP

1340 '

1350 '************************************************************************

1360 '  Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.

1370 '*************************************************************************

 

 

D.2.2  SIMPSON.IN

 

NAA v4.0 Sample Output

0.0

3.14159265358979324

20

 

 

D.2.3  SIMPSON.OUT

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

        'Numerical Analysis Algorithms in BASIC' v4.0        

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

NAA 4.0 Sample Output

 

Composite Simpson's Rule ‑ Algorithm 4.1

 

f(x) = sin(x)  from 0 to 3.14159265358979 .

 

n = 20 intervals on [a,b].

Interval number h = .1570796326794895

 

     ! 3.14159265358979

XI = *  f(x) dx =  2.000006886810941

     " 0

 

Required 21 functional evaluations.

 


D.3   C

 

 

D.3.1  SIMPSON.C

 


/*

**  FILE NAME: SIMPSON.C

**  LANGUAGE:  C

**  COMPILERS: Any ANSI C Compiler  (Microsoft C 5.0, Turbo C 2.0, etc.)

**  STATUS:    Compiles and runs correctly

*/

 

/******************************************************************************

                                       Composite Simpson's Rule ‑ Algorithm 4.1

*******************************************************************************

 

                                !b

To approximate the integral I = *  f(x) dx:

                                "a

 

INPUT endpoints a, b; positive integer n; the function f().

 

OUTPUT approximation XI to I.

 

*******************************************************************************

*                  Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.0      *

******************************************************************************/

 

#include "naautil.h"                        /* Numerical Analysis Algorithms Utilities. */

#define      PI                3.141592653589793238462643383279502884197

 

char *outfile   = "simpson.out";    /* Default name of the output file. */

char *eq_text_f = "f(x) = sin(x)";    /* Needs updating  $.               */

 

 

/*****************************************************************************/

/* f(x) ‑ Function to evaluate, f(x).  Needs updating $.                     */

/*****************************************************************************/

double f(x)

double x;

{

  return (sin(x));

}

/*****************************************************************************/

 

 

main()

{

  double a, b, h, X, XI, XI0, XI1, XI2, f();

  int i, n;

 

  /**********

   * INPUTS *

   **********/

 

  get_title();                                                           /* Prompts for optional comments. */

 

  printf("Composite Simpson's Rule ‑ Algorithm 4.1\n\n");

  printf("%s\n\n", eq_text_f);

  printf("Enter endpoint a: ");

  scanf("%lf", &a);

  printf("Enter endpoint b: ");

  scanf("%lf", &b);

 

  do {

    printf("Enter number of intervals on [a,b], n: ");

    scanf("%d", &n);

    if (n <= 0)

      printf("ERROR ‑ n must be greater than zero.\n");

  } while (n <= 0);

 

  /*************

   * ALGORITHM *

   *************/

 

  /* STEP #1 */

  h = (b ‑ a)/n;

 

  /* STEP #2 */

  XI0 = f(a) + f(b);

  XI1 = 0.0;                                        /* Summation of f(x(2i‑1)). */

  XI2 = 0.0;                                        /* Summation of f(x(2i)).   */

 

  /* STEP #3 */

  for (i=1;i<n;i++) {

 

    /* STEP #4 */

    X = a + i*h;

 

    /* STEP #5 */

    if (i % 2 == 0)

      XI2 += f(X);                                  /* For even i. */

    else

      XI1 += f(X);                                  /* For odd i.  */

  }

 

  /* STEP #6 */

  XI = h*(XI0 + 2.0*XI2 + 4.0*XI1) / 3.0;

 

  /***********

   * OUTPUTS *

   ***********/

 

  /* STEP #7 */

  /* Write output to the screen. */

  printf("Interval number h = %lg\n\n", h);

  printf("     !%lg\n", b);

  printf("XI = *  f(x) dx = %.11lg\n", XI);

  printf("     "%lg\n\n", a);

  printf("Required %d functional evaluations.\n", n + 1);

 

  /* Write output to a file. */

  open_outfile(outfile);

  fprintf(file_id, "Composite Simpson's Rule ‑ Algorithm 4.1\n\n");

  fprintf(file_id, "%s from %lg to %lg.\n\n", eq_text_f, a, b);

  fprintf(file_id, "n = %d intervals on [a,b].\n", n);

  fprintf(file_id, "Interval number h = %lg\n\n", h);

  fprintf(file_id, "     !%lg\n", b);

  fprintf(file_id, "XI = *  f(x) dx = %.11lg\n", XI);

  fprintf(file_id, "     "%lg\n\n", a);

  fprintf(file_id, "Required %d functional evaluations.\n", n + 1);

  close_outfile(outfile);

 

  printf("\nOutput saved into file \"%s\".\n", outfile);

 

}                                                                             /* STOP */

 

/*****************************************************************************/

/*                    Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.        */


/*****************************************************************************/

 

 

D.3.2  NAAUTIL.H

 


/******************************* NAAUTIL.H ************************************

                          "Numerical Analysis Algorithms in C" Utilities I v4.0

******************************************************************************/

 

/*

**      Return   Procedure

**      Value    Name            Description

**      ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

**                void     naaerror        Exits a program with an error message

**                void     get_title       Prompts for an optional title

**                void     open_outfile    Opens the default output file

**                void     close_outfile ‑  Closes the default output file

*/

 

/***********/

/* DEFINES */

/***********/

 

/*

**  The ANSI FLAG below allows the user more flexibility when compiling and

**  running these Numerical Analysis Algorithms.  Set to TRUE first.  Older

**  C compilers may require it to be set to FALSE.  No adverse effects should

**  occur.

*/

 

#ifndef TRUE

#define TRUE              1                                     /* Define TRUE if not already defined.       */

#endif

 

#ifndef FALSE

#define FALSE            0                                     /* Define FALSE if not already defined.      */

#endif

 

#define      ANSI                              TRUE         /* Set to TRUE if using an ANSI C standard   */

                                                                               /* compliant compiler (default).             */

                                                                               /* Set to FALSE if using an older C compiler.*/

                                                                               /* ANSI = American National Standards        */

                                                                               /*        Institute                          */

 

/*****************

 * INCLUDE FILES *

 *****************/

 

#include <math.h>                         /* For math function prototypes.             */

#include <stdio.h>                         /* For scanf(), printf() and fprintf().      */

 

#if ANSI == TRUE

#include <stdlib.h>                        /* Needed for calloc() by some compilers and */

#endif                                                                   /* for tolower().                            */

 

 

/********************

 * GLOBAL VARIABLES *

 ********************/

 

char title[133];                                  /* Used in get_title() and print_title().    */

FILE *file_id;                                                        /* Stream used to save output into a file.   */

 

 

/***********************

 * FUNCTION PROTOTYPES *

 ***********************/

 

#if ANSI == TRUE

  /* ANSI STANDARD PROTOTYPING (Post‑December 14, 1989)    */

  void     naaerror      (char []);

  void     get_title     (void);

  void     open_outfile  (char *);

  void     close_outfile (char *);

#else

  /* OLDER STYLE PROTOTYPING (Pre‑December 14, 1989)       */

  /* Placed here for compatibility with older C compilers. */

  void     naaerror();

  void     get_title();

  void     open_outfile();

  void     close_outfile();

#endif

 

 

/***************

 * SUBROUTINES *

 ***************/

 

/*****************************************************************************/

/* naaerror() ‑ Numerical Analysis Algorithms standard error handler.        */

/*****************************************************************************/

void naaerror(error_text)

char error_text[];

{

  fprintf(stderr,"\nNumerical Analysis Algorithms run‑time error...\n");

  fprintf(stderr,"%s", error_text);

  fprintf(stderr,"\n...now exiting to system...\n");

  exit (1);

}

 

/*****************************************************************************/

/* get_title() ‑ Prints the NAA banner and prompts for an optional title.    */

/*****************************************************************************/

void get_title()

{

  int i;

 

  /* Print the Numerical Analysis Algorithms banner. */

  for (i=1;i<80;i++)  printf("‑");

  printf("\n\t\t\"Numerical Analysis Algorithms in C\" v4.0\n");

  for (i=1;i<80;i++)  printf("‑");

  printf("\n");

 

  printf("Enter a title [ie ‑ Set 2.1,  Problem 2 a) ].\n‑‑‑‑> ");

  fgets(title, 133, stdin);

  printf("\n");

}

 

/*****************************************************************************/

/* open_outfile() ‑ Opens the default output file and prints the NAA banner  */

/*                  and optional title.                                      */

/*****************************************************************************/

void open_outfile(outfile)

char *outfile;

{

  char msg[80];                                                    /* Holds an error message string */

  int i;

 

  /* Open the default output file. */

  if ((file_id = fopen(outfile, "w")) == NULL) {

    sprintf(msg, "Can not open the output file named \"%s\".", outfile);

    naaerror(msg);

  }

 

  /* Print the Numerical Analysis Algorithms banner. */

  for (i=1;i<80;i++)  fprintf(file_id, "‑");

  fprintf(file_id, "\n\t\t\"Numerical Analysis Algorithms in C\" v4.0\n");

  for (i=1;i<80;i++)  fprintf(file_id, "‑");

  fprintf(file_id, "\n\n");

 

  /* Print the optional title. */

  if (title[0] != '\n')

    fprintf(file_id, "%s\n", title);

}

 

/*****************************************************************************/

/* close_outfile() ‑ Closes the default output file.                         */

/*****************************************************************************/

void close_outfile(outfile)

char *outfile;

{

  char msg[80];                                                    /* Holds an error message string */

 

  if (fclose(file_id) == EOF) {

    sprintf(msg, "Can not close the output file named \"%s\".", outfile);

    naaerror(msg);

  }

}

 

/*****************************************************************************/

/*                 Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.0     */

/*                 Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.           */


/*****************************************************************************/

 

 

D.3.3  SIMPSON.IN

NAA v4.0 Sample Output

0.0

3.14159265358979324

20

 

 

D.3.4  SIMPSON.OUT

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

                                       "Numerical Analysis Algorithms in C" v4.0

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

NAA v4.0 Sample Output

 

Composite Simpson's Rule ‑ Algorithm 4.1

 

f(x) = sin(x) from 0 to 3.14159.

 

n = 20 intervals on [a,b].

Interval number h = 0.15708

 

     !3.14159

XI = *  f(x) dx = 2.0000067844

     "0

 

Required 21 functional evaluations.

 


D.4   C++

 

 

D.4.1  SIMPSON.CPP

 


//

//  FILE NAME: SIMPSON.CPP

//  LANGUAGE:  C++

//  COMPILERS: Borland C++ or Turbo C++ 2.0

//  STATUS:    Not tested yet

//

 

/******************************************************************************

                                       Composite Simpson's Rule ‑ Algorithm 4.1

*******************************************************************************

 

                                !b

To approximate the integral I = *  f(x) dx:

                                "a

 

INPUT endpoints a, b; positive integer n; the function f().

 

OUTPUT approximation XI to I.

 

*******************************************************************************

*                  Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.2      *

******************************************************************************/

 

#include "simpson.hpp"                                   // Numerical Analysis Algorithms Utilities.

                                                                               // Also contains #include <iostream.h>.

#define      PI                3.141592653589793238462643383279502884197

 

char *outfile   = "simpson.out";    // Default name of the output file.

char *eq_text_f = "f(x) = sin(x)";    // Needs updating  $.

 

/***********************/

/* FUNCTION PROTOTYPES */

/***********************/

 

double f(double x);

 

 

/*****************************************************************************/

/* f(x) ‑ Function to evaluate, f(x).  Needs updating $.                              */

/*****************************************************************************/

double f(double x)

{

  return (sin(x));

}

/*****************************************************************************/

 

 

void main(void)

{

  double a, b, h, X, XI, XI0, XI1, XI2, f();

  int i, n;

 

  /**********

   * INPUTS *

   **********/

 

  get_title();                                                           // Prompts for optional comments.

 

  cout << "Composite Simpson's Rule ‑ Algorithm 4.1\n\n";

  cout << eq_text_f << "\n\n";

 

  cout << "Enter endpoint a: ";

  cin >> a;

  cout << "Enter endpoint b: ";

  cin >> b;

 

  do {

    cout << "Enter number of intervals on [a,b], n: ";

    cin >> n;

    if (n <= 0)

      cerr << "ERROR ‑ n must be greater than zero.\n";

  } while (n <= 0);

 

  /*************

   * ALGORITHM *

   *************/

 

  /* STEP #1 */

  h = (b ‑ a)/n;

 

  /* STEP #2 */

  XI0 = f(a) + f(b);

  XI1 = 0.0;                                        // Summation of f(x(2i‑1)).

  XI2 = 0.0;                                        // Summation of f(x(2i)).

 

  /* STEP #3 */

  for (i=1;i<n;i++) {

 

    /* STEP #4 */

    X = a + i*h;

 

    /* STEP #5 */

    if (i % 2 == 0)

      XI2 += f(X);                                  // For even i.

    else

      XI1 += f(X);                                  // For odd i.

  }

 

  /* STEP #6 */

  XI = h*(XI0 + 2.0*XI2 + 4.0*XI1) / 3.0;

 

  /***********

   * OUTPUTS *

   ***********/

 

  /* STEP #7 */

  // Write output to the screen.

  cout << "Interval number h = " << h << "\n\n";

  cout << "     !" << b << "\n";

  cout << "XI = *  f(x) dx = " << XI << "\n";

  cout << "     "" << a << "\n\n";

  cout << "Required " << n + 1 << " functional evaluations.\n";

 

  // Write output to a file.

  open_outfile(outfile);

  fprintf(file_id, "Composite Simpson's Rule ‑ Algorithm 4.1\n\n");

  fprintf(file_id, "%s from %lg to %lg.\n\n", eq_text_f, a, b);

  fprintf(file_id, "n = %d intervals on [a,b].\n", n);

  fprintf(file_id, "Interval number h = %lg\n\n", h);

  fprintf(file_id, "     !%lg\n", b);

  fprintf(file_id, "XI = *  f(x) dx = %.11lg\n", XI);

  fprintf(file_id, "     "%lg\n\n", a);

  fprintf(file_id, "Required %d functional evaluations.\n", n + 1);

  close_outfile(outfile);

 

  cout << "\nOutput saved into file \"" << outfile << "\".\n";

 

}                                                                             // STOP

 

/*****************************************************************************/

/*                 Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.           */


/*****************************************************************************/

 

 

D.4.2  NAAUTIL.HPP

 


/****************************** NAAUTIL.HPP ***********************************

                        "Numerical Analysis Algorithms in C++" Utilities I v4.0

******************************************************************************/

 

//

//      Return   Procedure

//      Value    Name            Description

//      ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

//                  void     naaerror        Exits a program with an error message

//                  void     get_title       Prompts for an optional title

//                  void     open_outfile    Opens the default output file

//                  void     close_outfile ‑  Closes the default output file

//

 

 

/*****************

 * INCLUDE FILES *

 *****************/

 

#include <stdio.h>                         // For fprintf().

#include <iostream.h>                                      // For cin, cout and cerr.

#include <stdlib.h>                        // Needed for calloc() by some compilers and

                                                                               // for tolower().

#include <math.h>                         // For math function prototypes.

 

 

/********************

 * GLOBAL VARIABLES *

 ********************/

 

char title[133];                                  // Used in get_title() and print_title().

FILE *file_id;                                                        // Stream used to save output into a file.

 

 

/***********************

 * FUNCTION PROTOTYPES *

 ***********************/

 

void naaerror      (char []);

void get_title     (void);

void open_outfile  (char *);

void close_outfile (char *);

 

 

/***************

 * SUBROUTINES *

 ***************/

 

/*****************************************************************************/

/* naaerror() ‑ Numerical Analysis Algorithms standard error handler.        */

/*****************************************************************************/

void naaerror(char error_text[])

{

  cerr << "\nNumerical Analysis Algorithms run‑time error...\n";

  cerr << error_text;

  cerr << "\n...now exiting to system...\n";

  exit (1);

}

 

/*****************************************************************************/

/* get_title() ‑ Prints the NAA banner and prompts for an optional title.    */

/*****************************************************************************/

void get_title(void)

{

  int i;

 

  // Print the Numerical Analysis Algorithms banner.

  for (i=1;i<80;i++)  cout << "‑";

  cout << "\n\t\t\"Numerical Analysis Algorithms in C++\" v4.0\n";

  for (i=1;i<80;i++)  cout << "‑";

  cout << "\n";

 

  cout << "Enter an optional title [ie ‑ Set 2.1,  Problem 2 a) ].\n‑‑‑‑> ";

  fgets(title, 133, stdin);

  cout << "\n";

}

 

/*****************************************************************************/

/* open_outfile() ‑ Opens the default output file and prints the NAA banner  */

/*                  and optional title.                                      */

/*****************************************************************************/

void open_outfile(char *outfile)

{

  char msg[80];                                                    // Holds an error message string.

  int i;

 

  // Open the default output file.

  if ((file_id = fopen(outfile, "w")) == NULL) {

    sprintf(msg, "Can not open the output file named \"%s\".", outfile);

    naaerror(msg);

  }

 

  // Print the Numerical Analysis Algorithms banner.

  for (i=1;i<80;i++)  fprintf(file_id, "‑");

  fprintf(file_id, "\n\t\t\"Numerical Analysis Algorithms in C++\" v4.0\n");

  for (i=1;i<80;i++)  fprintf(file_id, "‑");

  fprintf(file_id, "\n\n");

 

  // Print the optional title.

  if (title[0] != '\n')

    fprintf(file_id, "%s\n", title);

}

 

/*****************************************************************************/

/* close_outfile() ‑ Closes the default output file.                         */

/*****************************************************************************/

void close_outfile(char *outfile)

{

  char msg[80];                                                    // Holds an error message string.

 

  if (fclose(file_id) == EOF) {

    sprintf(msg, "Can not close the output file named \"%s\".", outfile);

    naaerror(msg);

  }

}

 

/*****************************************************************************/

/*                 Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.0     */

/*                 Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.           */


/*****************************************************************************/

 

 

D.4.3  SIMPSON.IN

 

NAA v4.2 Sample Output

0.0

3.14159265358979324

20

 

 

D.4.4  SIMPSON.OUT

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

                                       "Numerical Analysis Algorithms in C++" v4.0

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

NAA v4.0 Sample Output

 

Composite Simpson's Rule ‑ Algorithm 4.1

 

f(x) = sin(x) from 0 to 3.14159.

 

n = 2m = 20 subintervals of [a,b].

Interval number h = 0.15708

 

     !3.14159

XI = *  f(x) dx = 2.0000067844

     "0

 

Required 21 functional evaluations.

 


D.5   FORTRAN 77

 

 

D.5.1  SIMPSON.FOR

 


C  FILE NAME: SIMPSON.FOR

C  LANGUAGE:  FORTRAN 77

C  COMPILER:  Microsoft FORTRAN 77 Version 3.3

C  STATUS:    Compiles and runs correctly

C

C *****************************************************************************

C                                        Composite Simpson's Rule ‑ Algorithm 4.1

C *****************************************************************************

C

C                                 !b

C To approximate the integral I = *  f(x) dx:

C                                 "a

C

C INPUT endpoints a, b; positive integer n; the function f().

C

C OUTPUT approximation XI to I.

C

C *****************************************************************************

C                 Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.0

C *****************************************************************************

C

C

      PROGRAM SIMPSON

C

      DOUBLE PRECISION A, B, H, X

      INTEGER OUT, I, N

      CHARACTER*80 TITLE

      CHARACTER*12 OUTFILE

C

C     ‑‑ OUT will be assigned to OUTFILE for printing to an output file

      PARAMETER (OUT=4)

C

C     ‑‑ Default name of the outfile

      DATA OUTFILE/'SIMPSON.OUT'/

C

C *****************************************************************************

C * F(X) ‑ Function to evaluate, f(x).  Needs updating $.

C *****************************************************************************

C

      F(X) = DSIN(X)

C

C *****************************************************************************

C

C     **********

C     * INPUTS *

C     **********

C

C     ‑‑ Prompts for optional title

      WRITE (*,1)

      WRITE (*,2)

      WRITE (*,3)

      WRITE (*,*) ' Enter a title [ie ‑ Set 2.1,  Problem 2 a) ].'

      WRITE (*,*) ' ‑‑‑‑> '

      READ (*, 100) TITLE

100   FORMAT(A80)

      WRITE (*,4)

      WRITE (*,*) 'Enter endpoint a:'

      READ (*, 101) A

101   FORMAT(D8.0)

      WRITE (*,*) 'Enter endpoint b:'

      READ (*, 102) B

102   FORMAT(D8.0)

200   WRITE (*,*) 'Enter number of intervals on [a,b], n:'

      READ (*, 103) N

103   FORMAT(I8)

C

C     ‑‑ ERROR ‑ n must be positive

      IF (N .LE. 0) THEN

        WRITE (*,*) 'ERROR ‑ n must be greater than zero.'

        GOTO 200

      ENDIF

C

C     *************

C     * ALGORITHM *

C     *************

C

C     STEP #1

      H = (B ‑ A) / N

C

C     STEP #2

      XI0 = F(A) + F(B)

C     ‑‑ Summation of f(x(2i‑1))

      XI1 = 0.0

C     ‑‑ Summation of f(x(2i))

      XI2 = 0.0

C

C     STEP #3

      DO 50 I=1,N‑1

C

C       STEP #4

        X = A + I*H

C

C       STEP #5

        IF (MOD(I,2) .EQ. 0) THEN

C         ‑‑ For I even

          XI2 = XI2 + F(X)

        ELSE

C         ‑‑ For I odd

          XI1 = XI1 + F(X)

        ENDIF

50    CONTINUE

C

C     STEP #6

      XI = H * (XI0 + 2*XI2 + 4*XI1) / 3.0

C

C     ***********

C     * OUTPUTS *

C     ***********

C

C     STEP #7

C     ‑‑ Write output to the screen (*) and to a file (OUT=4).

C     ‑‑ Open outfile for output

C     OPEN (OUT,FILE=OUTFILE,STATUS='UNKNOWN')

      OPEN (OUT,FILE=OUTFILE)

C

      WRITE (*,1)

      WRITE (OUT,1)

      WRITE (*,2)

      WRITE (OUT,2)

      WRITE (*,3)

      WRITE (OUT,3)

1     FORMAT(' ',78('‑'))

2     FORMAT(' ',16X,'"Numerical Analysis Algorithms in FORTRAN" v4.0')

3     FORMAT(' ',78('‑'),/)

      WRITE (*,*) TITLE

      WRITE (OUT,*) TITLE

      WRITE (*,4)

      WRITE (OUT,4)

4     FORMAT(' Composite Simpson`s Rule ‑ Algorithm 4.1',/)

      WRITE (*,5) A, B

      WRITE (OUT,5) A, B

5     FORMAT(' f(x) = sin(x) from ',D12.7,' to ',D12.7,'.',/) A, B

      WRITE (*,6) N

      WRITE (OUT,6) N

6     FORMAT(' n = ',I4,' intervals on [a,b].')

      WRITE (*,7) H

      WRITE (OUT,7) H

7     FORMAT(' Interval number h = ',D13.7/)

      WRITE (*,8) B

      WRITE (OUT,8) B

8     FORMAT('     !',D13.7)

      WRITE (*,9) XI

      WRITE (OUT,9) XI

9     FORMAT(' I = *  f(x) dx = ',D13.7)

      WRITE (*,10) A

      WRITE (OUT,10) A

10    FORMAT('     "',D13.7/)

      WRITE (*,11) N + 1

      WRITE (OUT,11) N + 1

11    FORMAT(' Required ',I4,' functional evaluations.',/)

C

C     ‑‑ Closes outfile previously opened for output

      ENDFILE (OUT)

      CLOSE (OUT)

      WRITE (*,12) OUTFILE

12    FORMAT(' Output saved into file "', A, '".',/)

C

      END

C

C *****************************************************************************

C                    Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.


C *****************************************************************************

 

 

D.5.2  SIMPSON.IN

 

NAA v4.0 Sample Output

0.0

3.14159265358979324

20

 

 

D.5.3  SIMPSON.OUT

 

 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

                 "Numerical Analysis Algorithms in FORTRAN" v4.0

 ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

 

 NAA 4.2 Sample Output                                                         

 

 Composite Simpson`s Rule ‑ Algorithm 4.1

 

 f(x) = sin(x) from .0000000D+00 to .3141592D+01.

 

 n =   20 intervals on [a,b].

 Interval number h =  .1570796D+00

 

     ! .3141592D+01

 I = *  f(x) dx =  .2000007D+01

     " .0000000D+00

 

 Required   21 functional evaluations.

 


D.6   Pascal

 

 

D.6.1  SIMPSON.PAS

 


{

FILE NAME: SIMPSON.PAS

LANGUAGE:  PASCAL

COMPILER:  Turbo PASCAL Version 3.02A

STATUS:    Compiles and runs correctly

           Note: NAAMATH.INC has not been fully tested yet

}

 

{******************************************************************************

                                       Composite Simpson's Rule ‑ Algorithm 4.1

*******************************************************************************

 

                                !b

To approximate the integral I = *  f(x) dx:

                                "a

 

INPUT endpoints a, b; positive integer n; the function f().

 

OUTPUT approximation XI to I.

 

*******************************************************************************

*                  Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.0      *

******************************************************************************}

 

PROGRAM simpson;

 

{ USES TRANSCEND }                                     { Un‑comment if using UCSD Pascal. }

 

  TYPE

    STRING_TYPE = STRING[80];

 

  CONST

    PI = 3.1415926535897932384626433832795028841972;

    outfile = 'simpson.out';              { Default name of the output file. }

    eq_text_f = 'f(x) = sin(x)';{ Needs Updating $                 }

 

  VAR

    a, b, h, X, XI, XI0, XI1, XI2 : REAL;

    i, n    : INTEGER;

    title   : STRING_TYPE;

    file_id : TEXT;

 

  {****************************

   * PROCEDURES AND FUNCTIONS *

   ****************************}

 

  {$I NAAUTIL.INC}                          { Numerical Analysis Algorithms Utilities. }

  {$I NAAMATH.INC}                        { Complete set of math functions.          }

 

 

{*****************************************************************************

 * f(x) ‑ Function to evaluate, f(x).  Needs updating $.                              *

 *****************************************************************************}

  FUNCTION f(x : REAL) : REAL;

  BEGIN

    f := SIN(x)

  END;

 

 

{*****************************************************************************

 *               THIS IS WHERE THE PROGRAM STARTS EXECUTING                  *

 *****************************************************************************}

 

BEGIN

 

  {**********

   * INPUTS *

   **********}

 

  title := get_title;                              { Prompts for optional comments. }

 

  WRITELN ('Composite Simpson`s Rule ‑ Algorithm 4.1');

  WRITELN;

  WRITELN (eq_text_f);

  WRITELN;

  WRITE ('Enter endpoint a: ');

  READLN (a);

  WRITE ('Enter endpoint b: ');

  READLN (b);

 

  REPEAT

    WRITE ('Enter number of intervals on [a,b], n: ');

    READLN (n);

    IF n <= 0 THEN

      WRITELN ('ERROR ‑ n must be greater than zero.');

  UNTIL (n > 0);

 

  {*************

   * ALGORITHM *

   *************}

 

  { STEP #1 }

  h := (b ‑ a)/n;

 

  { STEP #2 }

  XI0 := f(a) + f(b);

  XI1 := 0.0;                                                           { Summation of f(x(2i‑1)). }

  XI2 := 0.0;                                                           { Summation of f(x(2i)).   }

 

  { STEP #3 }

  FOR i := 1 TO n ‑ 1 DO

    BEGIN

 

      { STEP #4 }

      X := a + i*h;

 

      { STEP #5 }

      IF NOT ODD(i) THEN

        XI2 := XI2 + f(X)    { For even i. }

      ELSE

        XI1 := XI1 + f(X)    { For odd i.  }

    END;

 

  { STEP #6 }

  XI := h*(XI0 + 2.0*XI2 + 4.0*XI1) / 3.0;

 

  {***********

   * OUTPUTS *

   ***********}

 

  { STEP #7 }

  { Write output to the screen. }

  print_title (title);

 

  WRITELN ('Composite Simpson`s Rule ‑ Algorithm 4.1');

  WRITELN;

  WRITELN (eq_text_f, ' from ', a :8:8, ' to ', b :8:8, '.');

  WRITELN;

  WRITELN ('n = ', n, ' intervals on [a,b].');

  WRITELN ('Interval number h = ', h :8:8);

  WRITELN;

  WRITELN ('    !', b :8:8);

  WRITELN ('I = *  f(x) dx = ', XI :8:8);

  WRITELN ('    "', a :8:8);

  WRITELN;

  WRITELN ('Required ', n + 1, ' functional evaluations.');

 

  { Write output to a file. }

  ASSIGN (file_id, outfile);              { Opens outfile for output. }

  REWRITE (file_id);

 

  print_title_to_outfile (title);

 

  WRITELN (file_id);

  WRITELN (file_id, 'Composite Simpson`s Rule ‑ Algorithm 4.1');

  WRITELN (file_id);

  WRITELN (file_id, eq_text_f, ' from ', a :8:8, ' to ', b :8:8, '.');

  WRITELN (file_id);

  WRITELN (file_id, 'n = ', n, ' intervals on [a,b].');

  WRITELN (file_id, 'Interval number h = ', h :8:8);

  WRITELN (file_id);

  WRITELN (file_id, '    !', b :8:8);

  WRITELN (file_id, 'I = *  f(x) dx = ', XI :8:8);

  WRITELN (file_id, '    "', a :8:8);

  WRITELN (file_id);

  WRITELN (file_id, 'Required ', n + 1, ' functional evaluations.');

  CLOSE (file_id);                            { Closes output file. }

 

  WRITELN;

  WRITELN ('Output saved into file "', outfile, '".');

 

END.                                                                     { STOP }

 

{******************************************************************************

*                  Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.                *


******************************************************************************}

 

 

D.6.2  NAAUTIL.INC

 


(****************************** NAAUTIL.INC ***********************************

                    "Numerical Analysis Algorithms in Pascal" Utilities I v4.0

******************************************************************************)

(*

This include file contains many useful procedures used by most all of the

Numerical Analysis Algorithms programs.  It should be included in all of the

programs using the line {$I NAAUTIL.INC}.  It contains the following

procedures and functions:

 

                    PROCEDURE naaerror               (str     : STRING_TYPE);

                    FUNCTION  get_title                       : STRING_TYPE;

                    PROCEDURE print_title            (str     : STRING_TYPE);

                    PROCEDURE print_title_to_outfile (str     : STRING_TYPE);

 

*)

 

(*****************************************************************************

 * naaerror() ‑ Numerical Analysis Algorithms standard error handler.        *

 *****************************************************************************)

PROCEDURE naaerror(str : STRING_TYPE);

BEGIN

  WRITELN;

  WRITELN('Numerical Analysis Algorithms run‑time error...');

  WRITELN(str);

  WRITELN('...now exiting to system...');

  HALT

END;

 

(*****************************************************************************

 * get_title() ‑ Prints the NAA banner and prompts for an optional title.    *

 *****************************************************************************)

FUNCTION get_title : STRING_TYPE;

VAR

  str : STRING_TYPE;

BEGIN

  FOR i := 1 TO 79 DO

    WRITE('‑');

  WRITELN;

  WRITE('                 ');

  WRITELN('"Numerical Analysis Algorithms in Pascal" v4.0');

  FOR i := 1 TO 79 DO

    WRITE('‑');

  WRITELN;

  WRITELN;

  WRITELN('Enter a title [ie ‑ Set 2.1,  Problem 2 a) ].');

  WRITE('‑‑‑‑> ');

  READLN(str);

  WRITELN;

  get_title := str

END;

 

(*****************************************************************************

 * print_title() ‑ Prints the optional title to the screen.                  *

 *****************************************************************************)

PROCEDURE print_title(str : STRING_TYPE);

VAR

  i : INTEGER;

BEGIN

  FOR i := 1 TO 79 DO

    WRITE('‑');

  WRITELN;

  WRITE('                 ');

  WRITELN('"Numerical Analysis Algorithms in Pascal" v4.0');

  FOR i := 1 TO 79 DO

    WRITE('‑');

  WRITELN;

  WRITELN;

 

  IF LENGTH(str) > 1 THEN

    WRITELN(str);

  WRITELN

END;

 

(*****************************************************************************

 * print_title_to_outfile() ‑ Prints the optional title to a file.           *

 *****************************************************************************)

PROCEDURE print_title_to_outfile(str : STRING_TYPE);

VAR

  i : INTEGER;

BEGIN

  FOR i := 1 TO 79 DO

    WRITE (file_id, '‑');

  WRITELN (file_id);

  WRITE   (file_id, '                 ');

  WRITELN (file_id, '"Numerical Analysis Algorithms in Pascal" v4.0');

  FOR i := 1 TO 79 DO

    WRITE (file_id, '‑');

  WRITELN (file_id);

  WRITELN (file_id);

 

  IF LENGTH(str) > 1 THEN

    WRITELN (file_id, str);

END;

 

(******************************************************************************

*                  Written by:  Harold A. Toomey, CARE‑FREE SOFTWARE, 2Q 1991, v4.0      *

*                  Copyright (C) 1991, Harold A. Toomey, All Rights Reserved.                *


******************************************************************************)

 

 

D.6.3  NAAMATH.INC

 

Too long to list here.  "Naamath.inc" contains a complete set of mathematical functions left out of the Pascal language.

 

 

D.6.4  SIMPSON.IN

 

NAA v4.0 Sample Output

0.0

3.14159265358979

20

 

 

D.6.5  SIMPSON.OUT

 

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

                 "Numerical Analysis Algorithms in Pascal" v4.0

‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑

NAA 4.0 Sample Output

 

Composite Simpson`s Rule ‑ Algorithm 4.1

 

f(x) = sin(x) from 0.00000000 to 3.14159200.

 

n = 20 subintervals of [a,b].

Interval number h = 0.15707960

 

    !3.14159200

I = *  f(x) dx = 2.00000678

    "0.00000000

 

Required 21 functional evaluations.