- Modern Fortran
- Copyright
- contents
- front matter
- Part 1. Getting started with Modern Fortran
- 1 Introducing Fortran
- 2 Getting started: Minimal working app
- 2.1 Compiling and running your first program
- 2.2 Simulating the motion of an object
- 2.3 Implementing the minimal working app
- 2.3.1 Implementation strategy
- 2.3.2 Defining the main program
- 2.3.3 Declaring and initializing variables
- 2.3.4 Numeric data types
- 2.3.5 Declaring the data to use in our app
- 2.3.6 Branching with an if block
- 2.3.7 Using a do loop to iterate
- 2.3.8 Setting the initial water height values
- 2.3.9 Predicting the movement of the object
- 2.3.10 Printing results to the screen
- 2.3.11 Putting it all together
- 2.4 Going forward with the tsunami simulator
- 2.5 Answer key
- 2.6 New Fortran elements, at a glance
- 2.7 Further reading
- Summary
- Part 2. Core elements of Fortran
- 3 Writing reusable code with functions and subroutines
- 3.1 Toward higher app complexity
- 3.2 Don’t repeat yourself, use procedures
- 3.3 Modifying program state with subroutines
- 3.4 Writing pure procedures to avoid side effects
- 3.5 Writing procedures that operate on both scalars and arrays
- 3.6 Procedures with optional arguments
- 3.7 Tsunami simulator: Putting it all together
- 3.8 Answer key
- 3.9 New Fortran elements, at a glance
- 3.10 Further reading
- Summary
- 4 Organizing your Fortran code using modules
- 5 Analyzing time series data with arrays
- 5.1 Analyzing stock prices with Fortran arrays
- 5.2 Finding the best and worst performing stocks
- 5.2.1 Declaring arrays
- 5.2.2 Array constructors
- 5.2.3 Reading stock data from files
- 5.2.4 Allocating arrays of a certain size or range
- 5.2.5 Allocating an array from another array
- 5.2.6 Automatic allocation on assignment
- 5.2.7 Cleaning up after use
- 5.2.8 Checking for allocation status
- 5.2.9 Catching allocation and deallocation errors
- 5.2.10 Implementing the CSV reader subroutine
- 5.2.11 Indexing and slicing arrays
- 5.3 Identifying risky stocks
- 5.4 Finding good times to buy and sell
- 5.5 Answer key
- 5.6 New Fortran elements, at a glance
- 5.7 Further reading
- Summary
- 6 Reading, writing, and formatting your data
- Part 3. Advanced Fortran use
- 7 Going parallel with Fortran coarrays
- 8 Working with abstract data using derived types
- 8.1 Recasting the tsunami simulator with derived types
- 8.2 Defining, declaring, and initializing derived types
- 8.2.1 Defining a derived type
- 8.2.2 Instantiating a derived type
- 8.2.3 Accessing derived type components
- 8.2.4 Positional vs. keyword arguments in derived type constructors
- 8.2.5 Providing default values for derived type components
- 8.2.6 Writing a custom type constructor
- 8.2.7 Custom type constructor for the Field type
- 8.3 Binding procedures to a derived type
- 8.4 Extending tsunami to two dimensions
- 8.5 Answer key
- 8.6 New Fortran elements, at a glance
- 8.7 Further reading
- Summary
- 9 Generic procedures and operators for any data type
- 10 User-defined operators for derived types
- 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 server
- 11.2 TCP server program: Receiving network connections
- 11.2.1 IP address data structures
- 11.2.2 Initializing the IP address structure
- 11.2.3 Checking IP address values
- 11.2.4 Intermezzo: Matching compatible C and Fortran data types
- 11.2.5 Creating a socket and listening for connections
- 11.2.6 Accepting incoming connections to a socket
- 11.2.7 Sending a TCP message to the client
- 11.2.8 Closing a connection
- 11.3 TCP client program: Connecting to a remote server
- 11.4 Some interesting mixed Fortran-C projects
- 11.5 Answer key
- 11.6 New Fortran elements, at a glance
- 11.7 Further reading
- Summary
- 12 Advanced parallelism with teams, events, and collectives
- appendix A. Setting up the Fortran development environment
- appendix B. From calculus to code
- appendix C. Concluding remarks
- index
In this part, you’ll get a taste of Fortran and a gentle introduction into the language.
In chapter 1, we’ll discuss the design and features of Fortran, and the kinds of problems for which Fortran is suitable. You’ll learn why parallel programming is important and when you should use it.
In chapter 2, we’ll build a minimal working example of the tsunami simulator that we’ll be working on throughout the book. This example will give you a taste of the Fortran essentials: variable declaration, data types, arrays, loops, and branches.
If you’re new to Fortran, this is the place to start. At the end of this part of the book, you’ll be able to write simple yet useful Fortran programs. More importantly, you’ll be ready to learn about Fortran essentials in more depth.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.