Fortran 95编程指南：涵盖HPF与变量长度字符串模块

5星 · 超过95%的资源需积分: 34 95 浏览量更新于2024-07-24 1 收藏 1.9MB PDF 举报

"这是一本由Martin Counihan编写的Fortran 95英文原版电子书，涵盖了Fortran 90、High Performance Fortran (HPF)的详细内容，以及针对可变长度字符字符串的Fortran模块。这本书由UCL Press于1996年首次出版，并在2005年由Taylor & Francis Library再版。" Fortran 95是FORTRAN编程语言的一个重要版本，它在Fortran 77的基础上进行了大量改进，旨在提高代码的可读性、可维护性和现代性。Fortran 95引入了模块（Modules）的概念，这是一种组织代码的方式，允许将数据和程序组件封装在一起，提高了代码重用和模块化设计的能力。模块可以包含公共变量、子程序、类型定义等，有助于减少命名冲突和提高代码组织。在描述中提到的High Performance Fortran (HPF)是针对并行计算设计的一种扩展，旨在利用多处理器系统和分布式内存架构。HPF引入了并行处理的语法和概念，如并行数组和分布内存模型，使得编写高效能的并行程序成为可能。然而，HPF并未广泛采用，因为它增加了编程复杂性，且与标准Fortran 90/95不完全兼容。书中还特别提到了Fortran对可变长度字符字符串的支持，这是对早期版本中固定长度字符串的改进。在Fortran 95中，可以声明具有动态大小的字符串，这在处理各种长度的文本数据时非常有用，也使得Fortran在处理字符串操作时更加灵活。此外，这本书的作者Martin Counihan来自英国南安普敦大学，暗示本书可能包含了教育和实践背景的视角，适合学生和研究人员学习。书中的内容可能包括基础语法、高级特性、HPF的详细解释以及如何在实际项目中应用Fortran 95。该书版权受保护，未经许可不得复制，同时提供了电子版和印刷版的购买信息。书的目录通常会包含引言、基本概念介绍、语言特性讲解、HPF的深入探讨、示例程序和可能的练习题等内容，帮助读者逐步掌握Fortran 95编程。这本《Fortran 95》电子书不仅涵盖语言基础，还深入探讨了并行计算和高级特性，对于想要学习或提升Fortran编程技能的人来说是一份宝贵的资源。

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页未读，继续阅读

refwef43535

粉丝: 0
资源: 4

Fortran 95编程指南：涵盖HPF与变量长度字符串模块

Fortran电子书

Fortran95程序设计【彭国伦】.pdf

FORTRAN95课本

Fortran_英文电子书_HXM

Fortran 95_2003程序设计 第3版_12278508_fortran95fortran_Fortran_

Fortran 95

fortran 95

电子书 Introduction to Programming using Fortran 95/2003/2008

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

Fortran_fortran95_

最新资源

Fortran 95_2003程序设计第3版_12278508_fortran95fortran_Fortran_