book

Modern Fortran

Name: Modern Fortran
Author: Milan Curcic
ISBN: 9781617295287

by Milan Curcic

November 2020

Intermediate to advanced

416 pages

12h 18m

English

Manning Publications

Read now

Unlock full access

Modern Fortran
Copyright
contents
front matter
forewordprefaceacknowledgmentsabout this bookWho should read this bookA bit of Fortran historyHow this book is organized: a roadmapAbout the codeRequirementsGet involvedliveBook discussion forumabout the authorabout the cover illustration
Part 1. Getting started with Modern Fortran
1 Introducing Fortran
1.1 What is Fortran?1.2 Fortran features1.3 Why learn Fortran?1.4 Advantages and disadvantages1.4.1 Side-by-side comparison with Python1.5 Parallel Fortran, illustrated1.6 What will you learn in this book?1.7 Think parallel!1.7.1 Copying an array from one processor to another1.8 Running example: A parallel tsunami simulator1.8.1 Why tsunami simulator?1.8.2 Shallow water equations1.8.3 What we want our app to do1.9 Further readingSummary
2 Getting started: Minimal working app
2.1 Compiling and running your first program2.2 Simulating the motion of an object2.2.1 What should our app do?2.2.2 What is advection?2.3 Implementing the minimal working app2.3.1 Implementation strategy2.3.2 Defining the main program2.3.3 Declaring and initializing variables2.3.4 Numeric data types2.3.5 Declaring the data to use in our app2.3.6 Branching with an if block2.3.7 Using a do loop to iterate2.3.8 Setting the initial water height values2.3.9 Predicting the movement of the object2.3.10 Printing results to the screen2.3.11 Putting it all together2.4 Going forward with the tsunami simulator2.5 Answer key2.5.1 Exercise: Cold front propagation2.6 New Fortran elements, at a glance2.7 Further readingSummary
Part 2. Core elements of Fortran
3 Writing reusable code with functions and subroutines
3.1 Toward higher app complexity3.1.1 Refactoring the tsunami simulator3.1.2 Revisiting the cold front problem3.1.3 An overview of Fortran program units3.2 Don’t repeat yourself, use procedures3.2.1 Your first function3.2.2 Expressing finite difference as a function in the tsunami simulator3.3 Modifying program state with subroutines3.3.1 Defining and calling a subroutine3.3.2 When do you use a subroutine over a function?3.3.3 Initializing water height in the tsunami simulator3.4 Writing pure procedures to avoid side effects3.4.1 What is a pure procedure?3.4.2 Some restrictions on pure procedures3.4.3 Why are pure functions important?3.5 Writing procedures that operate on both scalars and arrays3.6 Procedures with optional arguments3.7 Tsunami simulator: Putting it all together3.8 Answer key3.8.1 Exercise 1: Modifying state with a subroutine3.8.2 Exercise 2: Writing an elemental function that operates on both scalars and arrays3.9 New Fortran elements, at a glance3.10 Further readingSummary
4 Organizing your Fortran code using modules
4.1 Accessing a module4.1.1 Getting compiler version and options4.1.2 Using portable data types4.2 Creating your first module4.2.1 The structure of a custom module4.2.2 Defining a module4.2.3 Compiling Fortran modules4.2.4 Controlling access to variables and procedures4.2.5 Putting it all together in the tsunami simulator4.3 Toward realistic wave simulations4.3.1 A brief look at the physics4.3.2 Updating the finite difference calculation4.3.3 Renaming imported entities to avoid name conflict4.3.4 The complete code4.4 Answer key4.4.1 Exercise 1: Using portable type kinds in the tsunami simulator4.4.2 Exercise 2: Defining the set_gaussian subroutine in a module4.5 New Fortran elements, at a glance4.6 Further readingSummary

5 Analyzing time series data with arrays
5.1 Analyzing stock prices with Fortran arrays5.1.1 Objectives for this exercise5.1.2 About the data5.1.3 Getting the data and code5.2 Finding the best and worst performing stocks5.2.1 Declaring arrays5.2.2 Array constructors5.2.3 Reading stock data from files5.2.4 Allocating arrays of a certain size or range5.2.5 Allocating an array from another array5.2.6 Automatic allocation on assignment5.2.7 Cleaning up after use5.2.8 Checking for allocation status5.2.9 Catching allocation and deallocation errors5.2.10 Implementing the CSV reader subroutine5.2.11 Indexing and slicing arrays5.3 Identifying risky stocks5.4 Finding good times to buy and sell5.5 Answer key5.5.1 Exercise 1: Convenience (de)allocator subroutines5.5.2 Exercise 2: Reversing an array5.5.3 Exercise 3: Calculating moving average and standard deviation5.6 New Fortran elements, at a glance5.7 Further readingSummary
6 Reading, writing, and formatting your data
6.1 Your first I/O: Input from the keyboard and output to the screen6.1.1 The simplest I/O6.1.2 Reading and writing multiple variables at once6.1.3 Standard input, output, and error6.2 Formatting numbers and text6.2.1 Designing the aircraft dashboard6.2.2 Formatting strings, broken down6.2.3 Format statements in legacy Fortran code6.3 Writing to files on disk: A minimal note-taking app6.3.1 Opening a file and writing to it6.3.2 Opening a file6.3.3 Writing to a file6.3.4 Appending to a file6.3.5 Opening files in read-only or write-only mode6.3.6 Checking whether a file exists6.3.7 Error handling and closing the file6.4 Answer key6.4.1 Exercise: Redirect stdout and stderr to files6.5 New Fortran elements, at a glanceSummary
Part 3. Advanced Fortran use
7 Going parallel with Fortran coarrays
7.1 Why write parallel programs?7.2 Processing real-world weather buoy data7.2.1 About the data7.2.2 Getting the data and code7.2.3 Objectives7.2.4 Serial implementation of the program7.3 Parallel processing with images and coarrays7.3.1 Fortran images7.3.2 Getting information about the images7.3.3 Telling images what to do7.3.4 Gathering all data to a single image7.4 Coarrays and synchronization, explained7.4.1 Declaring coarrays7.4.2 Allocating dynamic coarrays7.4.3 Sending and receiving data7.4.4 Controlling the order of image execution7.5 Toward the parallel tsunami simulator7.5.1 Implementation strategy7.5.2 Finding the indices of neighbor images7.5.3 Allocating the coarrays7.5.4 The main time loop7.6 Answer key7.6.1 Exercise 1: Finding the array subranges on each image7.6.2 Exercise 2: Writing a function that returns the indices of neighbor images7.7 New Fortran elements, at a glance7.8 Further readingSummary
8 Working with abstract data using derived types
8.1 Recasting the tsunami simulator with derived types8.2 Defining, declaring, and initializing derived types8.2.1 Defining a derived type8.2.2 Instantiating a derived type8.2.3 Accessing derived type components8.2.4 Positional vs. keyword arguments in derived type constructors8.2.5 Providing default values for derived type components8.2.6 Writing a custom type constructor8.2.7 Custom type constructor for the Field type8.3 Binding procedures to a derived type8.3.1 Your first type-bound method8.3.2 Type-bound methods for the Field type8.3.3 Controlling access to type components and methods8.3.4 Bringing it all together8.4 Extending tsunami to two dimensions8.4.1 Going from 1-D to 2-D arrays8.4.2 Updating the equation set8.4.3 Finite differences in x and y8.4.4 Passing a class instance to diffx and diffy functions8.4.5 Derived type implementation of the tsunami solver8.5 Answer key8.5.1 Exercise 1: Working with private components8.5.2 Exercise 2: Invoking a type-bound method from an array of instances8.5.3 Exercise 3: Computing finite difference in y direction.8.6 New Fortran elements, at a glance8.7 Further readingSummary
9 Generic procedures and operators for any data type
9.1 Analyzing weather data of different types9.1.1 About the data9.1.2 Objectives9.1.3 Strategy for this exercise9.2 Type systems and generic procedures9.2.1 Static versus strong typing9.3 Writing your first generic procedure9.3.1 The problem with strong typing9.3.2 Writing the specific functions9.3.3 Writing the generic interface9.3.4 Results and complete program9.4 Built-in and custom operators9.4.1 What’s an operator?9.4.2 Things to do with operators9.4.3 Fortran’s built-in operators9.4.4 Operator precedence9.4.5 Writing custom operators9.4.6 Redefining built-in operators9.5 Generic procedures and operators in the tsunami simulator9.5.1 Writing user-defined operators for the Field type9.6 Answer key9.6.1 Exercise 1: Specific average function for a derived type9.6.2 Exercise 2: Defining a new string concatenation operator9.7 New Fortran elements, at a glanceSummary
10 User-defined operators for derived types
10.1 Happy Birthday! A countdown app10.1.1 Some basic specification10.1.2 Implementation strategy10.2 Getting user input and current time10.2.1 Your first datetime class10.2.2 Reading user input10.2.3 Getting current date and time10.3 Calculating the difference between two times10.3.1 Modeling a time interval10.3.2 Implementing a custom subtraction operator10.3.3 Time difference algorithm10.3.4 The complete program10.4 Overriding operators in the tsunami simulator10.4.1 A refresher on the Field class10.4.2 Implementing the arithmetic for the Field class10.4.3 Synchronizing parallel images on assignment10.5 Answer key10.5.1 Exercise 1: Validating user input10.5.2 Exercise 2: Leap year in the Gregorian calendar10.5.3 Exercise 3: Implementing the addition for the Field type10.6 New Fortran elements, at a glanceSummary
Part 4. The final stretch
11 Interoperability with C: Exposing your app to the web
11.1 Interfacing C: Writing a minimal TCP client and server11.1.1 Introducing networking to Fortran11.1.2 Installing libdill11.2 TCP server program: Receiving network connections11.2.1 IP address data structures11.2.2 Initializing the IP address structure11.2.3 Checking IP address values11.2.4 Intermezzo: Matching compatible C and Fortran data types11.2.5 Creating a socket and listening for connections11.2.6 Accepting incoming connections to a socket11.2.7 Sending a TCP message to the client11.2.8 Closing a connection11.3 TCP client program: Connecting to a remote server11.3.1 Connecting to a remote socket11.3.2 Receiving a message11.3.3 The complete client program11.4 Some interesting mixed Fortran-C projects11.5 Answer key11.5.1 Exercise 1: The Fortran interface to ipaddr_port11.5.2 Exercise 2: Fortran interfaces to suffix_detach and tcp_close11.6 New Fortran elements, at a glance11.7 Further readingSummary
12 Advanced parallelism with teams, events, and collectives
12.1 From coarrays to teams, events, and collectives12.2 Grouping images into teams with common tasks12.2.1 Teams in the tsunami simulator12.2.2 Forming new teams12.2.3 Changing execution between teams12.2.4 Synchronizing teams and exchanging data12.3 Posting and waiting for events12.3.1 A push notification example12.3.2 Posting an event12.3.3 Waiting for an event12.3.4 Counting event posts12.4 Distributed computing using collectives12.4.1 Computing the minimum and maximum of distributed arrays12.4.2 Collective subroutines syntax12.4.3 Broadcasting values to other images12.5 Answer key12.5.1 Exercise 1: Hunters and gatherers12.5.2 Exercise 2: Tsunami time step logging using events12.5.3 Exercise 3: Calculating the global mean of water height12.6 New Fortran elements, at a glance12.7 Further readingSummary
appendix A. Setting up the Fortran development environment
A.1 Editing Fortran source filesA.2 Setting up the Fortran compilerLinuxmacOSWindowsA.3 Setting up the MPI library (Message Passing Interface)A.4 Setting up OpenCoarraysLinuxmacOSUsing OpenCoarraysA.5 Building a Docker image
appendix B. From calculus to code
B.1 The advection equation explainedB.1.1 Discretizing the derivativesB.1.2 Casting the derivatives into code
appendix C. Concluding remarks
C.1 Tsunami simulator: The complete codeC.1.1 Main program: tsunami.f90C.1.2 The Field module: mod_field.f90C.1.3 The I/O module: mod_io.f90C.1.4 The parallel module: mod_parallel.f90C.2 Going forward with the tsunami simulatorC.3 Neural networks and deep learningC.4 Online resourcesC.5 CompilersC.6 Books
index

Overview

Using Fortran, early and accurate forecasts for hurricanes and other major storms have saved thousands of lives. Better designs for ships, planes, and automobiles have made travel safer, more efficient, and less expensive than ever before. Using Fortran, low-level machine learning and deep learning libraries provide incredibly easy, fast, and insightful analysis of massive data. Fortran is an amazingly powerful and flexible programming language that forms the foundation of high performance computing for research, science, and industry. And it's come a long, long way since starting life on IBM mainframes in 1956. Modern Fortran is natively parallel, so it's uniquely suited for efficiently handling problems like complex simulations, long-range predictions, and ultra-precise designs. If you're working on tasks where speed, accuracy, and efficiency matter, it's time to discover—or re-discover—Fortran..

About the Technology
For over 60 years Fortran has been powering mission-critical scientific applications, and it isn't slowing down yet! Rock-solid reliability and new support for parallel programming make Fortran an essential language for next-generation high-performance computing. Simply put, the future is in parallel, and Fortran is already there.

About the Book
Modern Fortran teaches you to develop fast, efficient parallel applications using twenty-first-century Fortran. In this guide, you'll dive into Fortran by creating fun apps, including a tsunami simulator and a stock price analyzer. Filled with real-world use cases, insightful illustrations, and hands-on exercises, Modern Fortran helps you see this classic language in a whole new light.

What's Inside

Fortran's place in the modern world
Working with variables, arrays, and functions
Module development
Parallelism with coarrays, teams, and events
Interoperating Fortran with C

About the Reader
For developers and computational scientists. No experience with Fortran required.

About the Author
Milan Curcic is a meteorologist, oceanographer, and author of several general-purpose Fortran libraries and applications.

Quotes
For the reader seeking proof of life for modern Fortran, Milan’s work provides ample evidence of the language’s ongoing role in technological modernity.
- From the Foreword by Damian Rouson, Sourcery Institute

An excellent introduction to the joys of modern Fortran; from polymorphism to parallelism. A must-read.
- Matthew Emmett, Computer Modelling Group

A unique book that builds on many real-life examples to show that Fortran is still alive and can be used productively even in the era of the web.
- Maurizio Tomasi, Università degli Studi di Milano

Compared to other programming books I have seen, this one is exceptionally pleasant to work through.
- Konrad Hinsen, Centre National de la Recherche Scientifique

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617295287Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills