Fortran 95权威指南：兼容与扩展，HPF与字符字符串模块详解

3星 · 超过75%的资源需积分: 10 117 浏览量更新于2024-08-02 3 收藏 1.9MB PDF 举报

"《Fortran 95：高级编程语言指南》是一本由Martin Counihan编著的修订版书籍，它是在Fortran 90最初作为国际标准编程语言推出后五年发布的。这本书是对Fortran 90的扩展和更新，旨在符合新的Fortran 95标准。然而，书中对新特性进行了明确标注，使得那些仍在使用Fortran 90的用户也能无障碍地阅读。本书不仅适用于编程初学者作为教材，也作为资深计算机用户的全面更新参考书。在内容上，本书涵盖了Fortran 95的核心特性，包括对Fortran 90的详细介绍，以及对High Performance Fortran（HPF）的深入探讨。此外，还特别关注了Fortran模块中的变量长度字符字符串处理。作者Martin Counihan以University of Southampton的身份编写，确保了专业性和实用性。版权方面，该书受到伯尔尼公约保护，未经许可禁止复制。版权信息包括首次出版于1996年，由UCL Press发行，并在后续版本中与Taylor & Francis-Library合作，于2005年重新出版。读者可以通过www.eBookstore.tandf.co.uk购买自己的电子版或纸质版。书中还包含了版权信息，如英国图书馆的出版记录和美国国会图书馆的公共目录数据，以及本书的ISBN号。最后，这本著作是对Elizabeth的一份献礼，体现了作者对读者的感激之情。通过阅读《Fortran 95》，学习者可以了解到这个编程语言的发展历程，掌握其高效性能优化技术，以及如何利用模块化设计处理复杂的字符数据类型。无论你是初次接触编程的新手还是寻求提升的资深程序员，这本书都是不可或缺的参考资料。"

does not involve the programmer in the “low-level” technical details of exactly how a particular computer

system is designed and how it stores and manipulates information internally. This philosophy is an aspect of

what is sometimes called “data abstraction”—allowing the programmer to think of data in terms of idealized

concepts (such as that of a real number) while not having to think about how that data is represented

physically within a particular computer’s hardware. If Fortran is not easy to learn, it is because, in response

to demand by its users, it has become a sophisticated and powerful modern programming language and is

very extensive. However, most programming tasks can be achieved with recourse to only a fraction of

Fortran’s features, and most program-writers do not attempt to memorize the whole language. The skill lies

not in knowing all of Fortran, but in knowing what it can express and being able to refer to what you want

when you want it.

A program written in Fortran will be translated (or “compiled”, to use the technical term) into the

appropriate low-level machine code by the computer system itself. This leaves the programmer free to

concentrate on solving the real problem in hand, whether it be in aeronautics, economic forecasting

or whatever. Programmers can cultivate their expertise in their specialist subjects and their involvement

with computer science need not extend much beyond the strictly defined boundaries of the programming

language. The purpose of a programming language, like that of any language, is that the user should not

have to cross its boundaries. The compilation of a program from Fortran into machine code is carried out by

a part of the system known as a “compiler”. A compiler is itself a piece of software, i.e. a computer program,

but one that would not normally be written in Fortran. For all its merits, Fortran is not usually the ideal

language for writing system software or compilers. Other languages, such as C, come into their own for

such purposes. Compiling a program is not the same as running it: compilation puts instructions into a form

understandable to the computer, but only when the compiled program is “run” will the instructions be

carried out.

Portability between computers has already been mentioned above, but portability in time is just as

important as portability in space. There is now an enormous investment in existing programs written by the

scientific community in the past using earlier versions of Fortran. To preserve that investment, Fortran 90 was

designed for backwards-compatibility with the previous standard version, FORTRAN 77; and apart from

the deletion of a few of the obsolete features Fortran 95 is compatible with Fortran 90. Consequently,

Fortran 95 includes a number of archaic features that would not have been included in the language if it

were being designed from scratch without the burden of history. The archaic features should be avoided by

a newcomer; they are no longer functionally necessary, and in this book they are covered only for the sake

of completeness.

What we mean by a “program” generally takes the form of a length of text divided into lines. There

might be a couple of dozen lines in a very simple program, or a few hundred in a medium-sized one, or

many tens of thousands of lines in sophisticated programs written and maintained by teams of

programmers.

Any program will have a starting point and an end point, and instructions between the start and the end

will be “executed” in turn when the program runs. Many of the instructions will manipulate data in some

way—multiplying numbers together, for example, or concatenating strings of text. However, some

instructions can permit a program to branch out into alternative paths, and so in practice most programs are

not executed in a fixed linear sequence of instructions. There can be branches, loops, conditionally executed

blocks of instructions, and other structures, and a program may have several different possible points of

termination.

PROGRAMS AND PROGRAMMING 3

1.3

Program structure

In general a Fortran program consists of a number of separate “program units”, namely

• A “main program” When the program as a whole is run, it always starts at the first statement of the main

program.

• An arbitrary number of other program units These can be called into play when needed by special

statements within the main program or within other program units.

A short program could consist only of a main program, but in practice there are usually several program

units. Apart from the main program, the other program units fall into two classes:

• “external subprograms”, or “external procedures” (introduced in Chapter 7).

• “modules” (dealt with in Chapter 10) that can, for example, be used to contain data that will be made

available to different subprograms.

There is a third class of program unit, now outmoded and unnecessary, known as BLOCK DATA.

Throughout the chapters of this book, small type like this is used when referring to old Fortran features

whose use is no longer recommended.

The difference between a module and an external subprogram is that a module contains information made

permanently accessible to the program unit that invokes it: invocation is by a once-and-for-all declaration at

the start of that program unit. A subprogram, on the other hand, is invoked dynamically (and perhaps

repetitively) by action statements during program execution.

Subprograms can be invoked from the main program or from other subprograms. There is even the

possibility of “recursive” subprograms that invoke themselves. Subprograms fall into two classes, namely

“subroutines” and “functions”, differing according to exactly how they are invoked. Normally subroutines

are used to switch the flow of execution of the program, while functions are used for repeated calculations.

It should be noted that the terms “procedure” and “subprogram” are synonyms in the Fortran context.

They are used interchangeably in this book.

There is another kind of subprogram not so far mentioned, namely a “module subprogram”. A module

subprogram is a procedure encapsulated within a module. Module subprograms, like external subprograms,

are classified as either subroutines or functions, but putting a group of them together in a module can be a

useful way of setting out a group of subprograms that have a special relationship with one another and need

access to a shared pool of data. Technically, module subprograms are not classified as program units in

their own right: it is the module that contains them that is classed as a “program unit”.

1.4

Intrinsic procedures

“Intrinsic procedures” are a kind of toolkit provided for the programmer in Fortran. They are a general-

purpose set of subprograms that can be invoked from any Fortran program. For example, to calculate the

square root of a number a program only needs to use the expression SQRT(…), inserting the number in

question between the brackets. SQRT is a Fortran “keyword” that simply causes the square root to be

calculated. Procedures like SQRT are just there, waiting in the background in case they are needed. They

4 WHAT IS FORTRAN 95?

are an intrinsic part of the Fortran language. There are well over 100 intrinsic procedures in Fortran 95, and

almost all of them (including SQRT) take the form of a “function”, like a mathematical function, and are called

“intrinsic functions”. A function is a procedure that can be referred to simply by mentioning its name, even

in the middle of a complicated expression; for example SQRT(21–SQRT(25)) is an acceptable Fortran

expression that calls the SQRT function twice and is equal to 4.0.

Fortran’s intrinsic procedures include several standard mathematical functions such as the common

trigonometrical and hyperbolic functions. They also include some very useful procedures for frequently

needed numeric manipulations, such as finding the absolute magnitude of a number or picking out the

largest from a given set of numbers. There are other intrinsic procedures that operate not on numbers but on

strings of characters. Yet others are useful for checking up on the characteristics of the computer being used:

for example the intrinsic inquiry function PRECISION will tell your program what is the limit of your

computer’s decimal precision. Inquiry functions like this would be unnecessary if all computers were

identical, but are very valuable for writing programs to be portable between computers with different

characteristics.

There are still other intrinsic procedures that are used for handling vectors and matrices, and for

manipulating binary “bits”, and for tasks such as the generating of random numbers. They are introduced

gradually through this book, but are all listed in Appendix F.

1.5

Statements

A Fortran program or subprogram consists of an ordered sequence of “statements”, and the statements can

carry out different sorts of tasks. Some statements (“assignment” statements) give a value to a variable

quantity: for example

n = 256

is an assignment statement that sets a variable called n equal (for the time being!) to 256. Assignment

statements always have an = sign in them. Other kinds of statement are indicated by special keywords, for

example a statement that writes out data will begin with the keyword WRITE. Fortran statement types are

listed in Appendix E; it is a long list, and rather bewildering at first sight, but in practice most programs,

like most people’s conversation, is built up predominantly out of statements of relatively few kinds.

Statements can be divided into two important classes: “declarative” statements and “executable” statements.

The declarative statements can be imagined to take effect once and for all when the program is compiled:

they establish what kinds of data are to be manipulated by the program (or subprogram), allow memory

space to be allotted to data, and may set up certain relationships between items of data.

The executable statements take full effect only when the program is run: they are action statements that

cause items of data to be altered or moved in some way, or that make decisions. Executable statements are

sometimes called “procedural” statements and, when the program runs, the computer proceeds through them

in turn.

Within a program or subprogram, the declarative statements must be grouped together at the beginning

and they are followed by the executable statements in sequence. The difference between a declarative

statement and an executable statement is quite fundamental. It is a little like the difference between an adjective

and a verb in English. Consider the following program:

PROGRAMS AND PROGRAMMING 5

Cinderella is beautiful

Sisters are ugly, and coarse, and there are two of them

The Prince is rich

Dress Cinderella

Nullify the Sisters

Take Cinderella to the dance

Marry the Prince

The first three of these statements do not actually do anything but they set the scene. They could have been

stated in any order. They are declarative. The last four statements are executable, in the sense that changes are

made to some of the entities referred to in the first three statements. For the executable statements, the order

is important.

All Fortran program units have the same basic structure as the Cinderella example above. However, one

should be aware that there are different styles and fashions in programming and some programmers prefer

to emphasize declarative aspects of programming while others prefer the procedural approach. Fortran is

historically a procedural language and earlier versions of it were much more limited in their repertoire of

declarative statements than Fortran 95 is.

There are several kinds of declarative statement in Fortran, but by far the most important is known as the

“type declaration statement” or TDS. It is so important that most of Chapter 8 is devoted to describing all its

possible variations. The TDS can be regarded as Fortran’s archetypal declarative statement, the archetypal

executable statements being the assignment statement and the IF statement that enables the flow of program

execution to be controlled according to the values that variables are found to have at the time.

1.6

Data

Items of data may be “constants”, unchanging throughout the execution of a program, or they may be

“variables” able to be changed. Every variable is identified by a “name”. In the example of an executable

statement given earlier,

n = 256

the letter n is the name of a variable and the number 256 is a constant. In fact, a set of similar data items

may be grouped together in an “array” under a common name: this makes it possible to manipulate large

sets of data with very simple statements. Mathematically, these sets of data may be sequences of numbers, or

vectors, or matrices, or tensors, or whatever you like, and they may be organized in many different

dimensions; they can still be named and handled as single entities. “Array” is the general term used for a set

of data going under a single name. Fortran works very flexibly with arrays of almost arbitrary size and can

be used to exploit vector-processing facilities on computers of advanced architecture. In fact, the statement

above could actually cause a large number of data items each to be set equal to 256 if it had been arranged

6 WHAT IS FORTRAN 95?

for the name n to represent an array of numbers. The arrangement would be made by stating n to be an array

in a declarative statement (a TDS) at the start of the program. Thus, the meaning and effect of an executable

statement may depend profoundly on the attributes that items of data have been declared to have.

Likewise, most of Fortran’s intrinsic mathematical functions will work for arrays: an expression like

SQRT(x), if x is the name of an array, will calculate the square roots of all the numbers in the array x.

Data items may be of a number of different “types”. For example, integer numbers and complex numbers

are different types. The word “type” is not used loosely: it is a technical term that refers to the nature, and

not the particular value, of a single data item. Most programming languages allow for a few different types

of data, but Fortran 90 allows, in principle, for an arbitrary variety of types. This is because of a feature

known as “user-defined types” or “derived types”, by which the programmer may construct a definition of a

fresh type of data relevant to the problem in hand. It is easy to draw examples from advanced mathematics:

for example, a programmer interested in four-dimensional geometry could define four-component vectors

and 4×4 transformation matrices, and could also define what would be meant by the sums and products of

such entities. As a more down-to-earth example, the latitude and longitude of a geographical point together

comprise a special sort of data item and could be set up as a user-defined type obeying its own rules

according to the programmer’s wishes. User-defined types can be more flexible than arrays: an array is a set

of items all of which must be of the same type, but a user-defined type can be a complicated structure

incorporating data of quite different basic types, e.g. mixing numbers and words. So, a single Fortran

“name”, like x, could in this way refer to a mixed package of data such as a person’s name, address,

telephone number and age.

Another interesting feature in Fortran is that of “pointer” data. The concept of a pointer is not easy to

appreciate at first, but one way to illustrate the idea is to take the example at the end of the previous

paragraph, of a set of data consisting of a person’s name, address, telephone number and age. Imagine that

we have a large list of information of this sort. Suppose that we want the set of data for each person to

include also a cross-reference to the corresponding information for the person’s spouse. There are various

ways in which this might be achieved. One way might be to give an index number to each person listed, and

to include the spouse’s index number in the data set for each person who is married. However, the simplest

method in Fortran is to include a “pointer” to a spouse’s details. The pointer would have the appearance of

an additional data item encapsulating all the spouse’s personal details; but in reality it would simply “point”

to the other area of memory where the spouse’s details are already listed in his/her own right. Using

pointers, there is no need to take up unnecessary memory space by repeating chunks of data, nor to set up

special codes for cross-referencing between data.

Modules are another very valuable feature of Fortran, and were mentioned above in Section 1.3. Like

pointers, modules are difficult to appreciate in the abstract. You have to use them, in real programs, to see

how effective they can be. Modules are useful in the architecture of large programs or systems of programs,

where they can be used to organize plug-in sets of procedures for particular purposes. In smaller programs,

modules are most useful for memory access, i.e. for containing data that is to be used by more than one

procedure.

1.7

Writing Fortran

In practice, any Fortran program takes the form of text divided into lines. Each line may be up to 132

characters in length. Usually there is one Fortran “statement” per line. Within the line, the statement does

not have to start at the first character or end at the end of the line: there may be blank spaces leading or

PROGRAMS AND PROGRAMMING 7

剩余434页未读，继续阅读

yangjj2005

粉丝: 14
资源: 2

Fortran 95权威指南：兼容与扩展，HPF与字符字符串模块详解

FORTRAN 95 科学计算入门指南

Fortran95：科学与工程领域的高效数值计算工具

Fortran95学习笔记：彭国伦《Fortran95程序设计》要点解析

fortran 95

Fortran 95_2003程序设计 第3版_12278508_fortran95fortran_Fortran_

使用Fortran 95进行编程简介Introduction to Programming using Fortran 95

Fortran_fortran95_

fortran95课件

FORTRAN95课本

fortran 95标准

最新资源

Fortran 95_2003程序设计第3版_12278508_fortran95fortran_Fortran_