C++ implements a device-independent approach to reading and writing data such that nearly the same interface (the public class members) is employed to send data to or receive data from different devices such as disk files, memory buffers and the keyboard and terminal. This is achieved by collecting functions and variables common to all input and output operations into an ios base class. Operations involving the standard input device (keyboard) cin are appended in a derived istream class, while functionality that enables data to be read from files and memory buffers is incorporated in the ifstream and istrstream subclasses of istream, respectively. Output operations are implemented in the same manner by the corresponding output classes, ostream, ofstream and ostrstream. The iostream class multiply inherits the internal functions and variables of both the istream and ostream classes. Finally, the fstream and strstream classes further specialize the iostream class by appending the properties required to both read and write to files and memory buffers (alternatively e.g. fstream can multiply inherit from ofstream and ifstream). Following the structure of the inheritance diagram, we first discuss the iostream class. Subsequently we discuss the interfaces to files and memory buffers associated with fstream and strstream.

The iostream class and stream manipulators

In C++, variables read into or written from a program initially reside in abstract objects termed streams, examples of which are cin and cout. These streams may be thought of as smart memory buffers enhanced through the inclusion of public, user-accessible functions that can act on the data stored in the stream buffer before its contents are processed by the program or sent to a device. The components that interface the memory buffer with the actual system devices are implemented as private functions and variables of the stream classes and are invisible to the user.

The following three chapters introduce basic C++ program structure and syntax inthe context first of procedural programming and subsequently, in the two laterchapters, of object-oriented programming. The material in these chaptersaddresses the significant challenges encountered by beginning programmers.

Scientific software development

Procedural programing follows a clearly defined set of steps, which are discussedindividually in this section.

Problem definition. First, a problem description that capturesthe main scenarios (possible outcomes), including possible abnormal situations,such as, for example, those generated by erroneous input data, should beformulated.

Detailed specification. A program specification comprises adetailed solution strategy such as the form and content of the input and outputdata, the equations to be programmed, the numerical methods to be employed, thehardware and software to be used and the manner in which the code will handlethe various scenarios. This can be facilitated by first generating the input andoutput screens that the user will encounter.

Iterative coding and modular testing. Subsequently, the programtasks should be compartmentalized into functions. Each of these should beverified independently with a set of test data that is subsequently saved incomment lines for possible future use. Comments should be supplied for eachadditional function or block of code and the verified code modules packaged forreuse in other projects. As a rule, only a single change or function isadded to the program at a time before retesting. In addition, beforeimplementing any non-trivial change, the previous version of the code (withan appropriate version number) should be saved in case an inadvertent erroris introduced. An editor that can identify the differences betweentwo text files can then find subtle errors such as adding an additional(sometimes invisible) character during editing.

Scientific programming comprises four basic elements: analyzing a physicalproblem, developing a numerical algorithm for solving the problem, designing aprogram that implements this solution within a clear and understandableframework and, finally, determining the accuracy and the limits of validity ofthe numerical solution. Before discussing these, however, we surveycomputational methods and software and hardware architecture.

Computational methods

While most textbook problems possess a high degree of symmetry and/or alimited number of variables and can therefore be solved analytically, real-worldapplications typically require numerical analysis. Further, even analyticsolutions can be unstable, as in water flowing through a cylindrical tube athigh velocity, for which the motion depends critically on the initialconditions. Numerical calculations are then performed for numerous initialconditions and statistical properties derived from the results.

Often a numerical model of a continuous system recasts the solution to the full,global problem as a set of simplified, coupled local problems, each of whichdescribes the system over a restricted spatial or temporal domain. Continuousoperators such as derivatives and integrals are then approximated by employingtheir definition as the limit of discrete differences and sums but withoutpassing to the infinitesimal limit. As an example, the response of a building toan applied force from the ground can be obtained by noting that the forces oneach brick vary only slightly over the surface of the brick. The response ofeach discrete, rigid, brick to these local applied forces can therefore easilybe evaluated. Coupling the forces and displacements on each brick to those onneighboring bricks and to those applied at the boundary between the house andthe ground generates a large system of linear equations that is solvednumerically.

While scientific programs are less frequently written in Java than in C++, in certain contexts, such as internet applications, the enhanced Java feature set significantly shortens development time. Since many high-level constructs in Java reflect an involved and largely hidden underlying structure that often precludes a description in terms of a compact set of underlying principles, the subsequent discussion focuses on compact code samples that illustrate the most significant aspects of the language. Once a basic understanding of Java has been acquired, specialized programming tasks can often be addressed by extending these samples while consulting a full list of the specialized functions available in the language.

While numerous free integrated Java development environments exist, flags can be set inadvertently, leading to anomalous behavior that often proves difficult to correct. Additionally, the details of the Java file structure which constitutes an important feature of the language are often obscured. This text therefore employs a command-line compiler, the Java DISLIN graphics package and a text editor. Downloading, installing and testing these components is described below.

In this and the following chapter, arrays, references and pointers are examined. These will prove essential to a more detailed discussion of objects and classes.

Data structures and arrays

An array constitutes a built-in (e.g. native to the compiler) data structure, which denotes a collection of related quantities with common ordering properties. Each object in an array must be of the same type and is accessible through an integer index. Other commonly occurring data structures include the following.

1. A bag – an unordered collection of objects.

2. A set – a bag in which no object can appear more than once.

3. A list – an object sequence that enables navigation between an object and its successor.

4. An ordered list – a list with the property that an object can be accessed through its position as well as by way of the neighboring object.

5. A sorted list – a list with elements stored according to a given ordering operation.

6. A key set– an object collection that employs a key such as a word or number to locate elements.

7. A stack – a container for which elements can be added or removed only at the first (top) position; that is, only the last element to be added is accessible at any given time.

8. A queue – a container constructed such that only the oldest (first) element in the container can be removed at any given time.

Soon after the publication of my C++ textbook, A First Course in Computational Science and Object-Oriented Programming with C++, in 2005, I conceived of including a yet more compact introduction to C++ in a survey of the entire field of scientific programming. Drawing on 20 years of experience of teaching programming at all levels in both physics and electrical engineering departments, I resolved to both summarize my previous treatment of C++ and incorporate a discussion of the Octave and Java programming languages, focusing on their conceptual foundations. Finally, I would insert many additional scientific programming examples, emphasizing short programs that illustrate key algorithms. By employing only free software, this would create a uniquely comprehensive treatment of the full set of steps from compiler installation to sophisticated scientific programming.

Objective

This textbook overviews modern scientific programming, including numerical analysis, object-oriented programming, scientific graphics, software engineering, numerical analysis and physical system modeling. Consequently, knowledge of the material will provide sufficient background to enable the reader to analyze and solve nearly all normally encountered scientific programming tasks.