Numerical Methods in Scientific Computing with Fortran

Sources and Grounding Material

• mission: Fortran and scientific computing: language references, numerical methods, and high-performance computing resources.
• editorial_style: reference
• primary_topics: Fortran language reference; numerical methods; high-performance computing; scientific software ecosystem
• excluded_topics: law or legal services; politics; medical advice beyond general wellness; any Axis client or legal domain references
• Numerical Methods | GFortran Reference By the GFortran Reference Editorial Team First published August 20, 2026 · Last updated August 20, 2026 Numerical methods turn mathematical problems into computations a computer can carry out. This section covers three pillars in reference style: finding roots of equations, solving linear systems, and stepping through differential equations. Root Finding Methods — bisection and Newton-Raphson: how they work, how fast they converge, and how to choose. Solving Linear Systems — Gaussian elimination, pivoting, and why triangular systems are easy. Ordinary Differential Equations — initial value problems, the Euler method, and the Runge-Kutta family. Each article states the method precisely and points out where its behavior is reliable and where care is needed. For a bird's-eye view first, see Numerical Methods: An Overview . Root Finding Methods Bisection, Newton-Raphson, and how to choose. Read more Solving Linear Systems Gaussian elimination, pivoting, and triangular systems. Read more Ordinary Differential Equations Initial value problems, Euler, and Runge-Kutta. Read more Keep reading Numerical Methods: An Overview Scientific Computing Fundamentals About the author GFortran Reference Editorial Team GFortran Reference is written and reviewed by its editorial team. We publish independent educational publication on the Fortran language and scientific computing - not part of the GNU project, and we review and update articles on a regular cycle. Read our editorial standards and corrections policy .
• Numerical Methods: An Overview Guide | GFortran Reference Published 2026-08-21 · by the editorial team By the GFortran Reference Editorial Team First published August 21, 2026 · Last updated August 21, 2026 Root finding Many problems come down to solving f(x) = 0 for x. Root-finding methods produce successively better approximations of a root. The bisection method brackets a root between two points where the function changes sign and halves the interval each step — slow but dependable. The Newton-Raphson method uses the derivative to move quickly toward a root when the starting guess is good, but it can fail when the guess is poor or the derivative is awkward to evaluate. A fuller treatment is in Root Finding Methods . Linear systems Linear systems of the form Ax = b appear everywhere in science and engineering, and a large share of scientific computing time is spent solving them. Direct methods such as Gaussian elimination transform the system into a triangular form and then solve it by substitution; iterative methods repeatedly improve a starting guess. The choice depends on the size and structure of the matrix. See Solving Linear Systems . Interpolation and approximation When data is known only at points, interpolation fits a function through those points so values can be estimated in between. Polynomial interpolation in its Lagrange and Newton divided-difference forms is the classical approach; piecewise methods such as splines fit separate low-degree polynomials on each interval and are often more stable for many data points. Approximation problems — finding a simple function close to a complicated one — are handled by related least-squares techniques. Differential equations Differential equations describe how systems change over time. Methods for initial value problems step forward from a starting condition: the Euler method uses the slope at the current point, while Runge-Kutta methods evaluate the slope at several points within each step and combine them for higher accuracy. Stiff problems need specially designed methods. See Ordinary Differential Equations . Every method family has strengths and weaknesses; the right choice depends on the problem, the accuracy required, and the available computing resources. Keep reading Root Finding Methods Solving Linear Systems All guides About the author GFortran Reference Editorial Team GFortran Reference is written and reviewed by its editorial team. We publish independent educational publication on the Fortran language and scientific computing - not part of the GNU project, and we review and update articles on a regular cycle. Read our editorial standards and corrections policy .
• Numerical computing fundamentals — GFortran Numerical Computing Fundamentals with GFortran Numerical computing involves solving mathematical problems through computational methods, often using programming languages designed for numerical analysis and scientific computation. Among the tools available for this purpose is GFortran, which is part of the GNU Compiler Collection (GCC) and supports the Fortran programming language. #### What is GFortran? GFortran is a free and open-source compiler that translates source code written in Fortran into machine-executable format. Fortran, originally developed in the 1950s for scientific computing and engineering applications, remains popular due to its efficient handling of array operations and other numerical tasks. #### Installing GFortran To use GFortran on your system, you first need to install it. On Debian-based systems like Ubuntu, you can install GFortran using the package manager: ```bash sudo apt-get update sudo apt-get install gfortran ``` On Red Hat–based distributions such as Fedora or CentOS, the installation command would be: ```bash sudo yum install gcc-gfortran ``` For macOS users, Homebrew is a common way to install GFortran: ```bash brew install gfortran ``` #### Basic Fortran Syntax Understanding basic Fortran syntax is crucial for writing efficient numerical code. A simple program illustrating the basics looks like this: ```fortran program hello_world implicit none print *, "Hello, World!" end program hello_world ``` Here, `print *` outputs a string to standard output (usually the console). #### Array Operations One of Fortran's strengths is its ability to handle large arrays efficiently. Here’s an example showing array initialization and multiplication: ```fortran program matrix_multiplication implicit none integer :: i, j, k real, dimension(2, 2) :: a = reshape((/1., 2., 3., 4./), (/2, 2/)) real, dimension(2, 2) :: b = reshape((/5., 6., 7., 8./), (/2, 2/)) real, dimension(2, 2) :: c do i = 1, 2 do j = 1, 2 c(i,j) = 0. do k = 1, 2 c(i,j) = c(i,j) + a(i,k) * b(k,j) enddo enddo enddo print *, "Matrix A:" call matprint(a) print *, "Matrix B:" call matprint(b) print *, "Result Matrix C:" call matprint(c) contains subroutine matprint(x) real, dimension(:, :), intent(in) :: x integer :: i, j do i = 1, size(x, 1) write(*,'(2(f5.2,x))') (x(i,j), j=1, size(x, 2)) enddo end subroutine matprint end program matrix_multiplication ``` This code initializes two matrices `A` and `B`, performs their multiplication to produce a result in matrix `C`, and prints all three using the helper subroutine `matprint`. #### Compiling and Running Programs Once you have written your Fortran program, compile it with GFortran: ```bash gfortran -o myprogram myprogram.f90 ``` The `-o` flag specifies the output file name. Then run the compiled executable: ```bash ./myprogram ``` #### Conclusion GFortran provides a robust environment for numerical computing and scientific programming, leveraging Fortran's strengths in handling arrays and mathematical
• GFortran Reference — Independent Fortran and Scientific Computing Education Independent educational publication · Fortran · Scientific computing A clear reference for Fortran and scientific computing Precise, neutral reference material on the Fortran language, numerical methods, performance, and parallel programming — written for students, scientists, and engineers who want to understand the fundamentals. Explore the guides Our mission Fortran Language Reference A language built for computation, Fortran was developed in the 1950s to let scientists and engineers write numerical programs with ease. It remains one of the oldest programming languages still in wide use today. The GNU Fortran compiler, part of the GCC project, seeks to bring free number crunching to a broad spectrum of platforms and users. This mission is crucial for advancing scientific computing across various fields. Fortran's enduring popularity can be attributed to its rich set of intrinsic functions that simplify common mathematical operations such as finding absolute values (`abs(x)`), calculating square roots (`sqrt(x)`), determining remainders (`mod(a, b)`), and identifying maximum or minimum values among a group of numbers. These features are essential for efficient scientific analysis. Numerical Methods Fortran's capabilities extend beyond basic arithmetic operations to encompass sophisticated numerical methods that are crucial in scientific research. These methods include algorithms for solving differential equations, matrix algebra, and optimization problems. The language's strength lies in its ability to handle large datasets efficiently, making it an ideal choice for high-performance computing environments. The NIST Digital Library of Mathematical Functions is a valuable resource for scientists and engineers who need detailed information about mathematical functions used in numerical analysis. According to the library, this comprehensive revision of Abramowitz and Stegun’s Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables provides an updated reference for standards that are fundamental in scientific computing. High-Performance Computing Fortran's utility extends to high-performance computing (HPC) environments where speed is crucial. Performance work in science can be critical when programs run for hours or days, as it determines the practicality of research endeavors. The Fortran Performance: The Basics Guide highlights why performance matters in scientific applications. The NASA High-End Computing Capability Project provides a unique, integrated environment to support the scientific modeling and simulation needs of NASA missions across the Agency. This capability allows for addressing complex science and engineering questions with power and efficiency. By leveraging HPC resources, researchers can push the boundaries of computational analysis and simulate phenomena that would otherwise be infeasible. Types of Fortran Intrinsics The Fortran language includes numerous intrinsic functions categorized into types based on their purpose. Some common categories include arithmetic operations, relational operators, inquiry functions, and conversion routines. These intrinsics form the backbone of numerical methods in scientific applications, enabling researchers to perform complex calculations efficiently. Trends Sources GNU Fortran — GCC Project (gcc.gnu.org) — We seek to bring free number crunching to a broad spectrum of platforms and users NIST Digital Library of Mathematical Functions — dlmf.nist.gov — …Mathematical Functions with Formulas, Graphs, and Mathematical Tables , published in 1964 by the National Bureau of Standards NASA High-End Computing Capability — nas.nasa.gov — …The High-End Computing Capability (HECC) Project provides a unique, integrated environment to support the scientific modeling and simulation needs of NASA missions across the Agency Featured sections Getting Started First programs, arrays, intrinsic functions, and file I/O.
• Parallel Programming | GFortran Reference By the GFortran Reference Editorial Team First published August 20, 2026 · Last updated August 20, 2026 This section covers the two main approaches to parallel programming in the Fortran world. Coarray Fortran — parallelism built into the language since the Fortran 2008 standard: images, coarray syntax, and synchronization statements. Message Passing Concepts — distributed memory, ranks and communicators, point-to-point messages, and collective operations. New to the subject? Parallel Programming Concepts starts from zero with shared and distributed memory. The Performance section covers single-core speed, which remains the foundation everything parallel builds on. Coarray Fortran Images, coarray syntax, and synchronization in the standard. Read more Message Passing Concepts Ranks, point-to-point messages, and collectives. Read more Keep reading Parallel Programming Concepts Performance section About the author GFortran Reference Editorial Team GFortran Reference is written and reviewed by its editorial team. We publish independent educational publication on the Fortran language and scientific computing - not part of the GNU project, and we review and update articles on a regular cycle. Read our editorial standards and corrections policy .