Fact-checked by Grok 2 weeks ago

LINPACK

LINPACK is a collection of Fortran subroutines designed for analyzing and solving systems of linear equations and linear least-squares problems, supporting a variety of matrix types including general, banded, tridiagonal, symmetric indefinite, and Cholesky factored forms, as well as computing QR decompositions and singular value decompositions.^[1] Developed in the 1970s by Jack J. Dongarra, Jim Bunch, Cleve Moler, and G. W. Stewart at Argonne National Laboratory and the University of New Mexico, it was specifically tailored for the supercomputers of that era, employing column-oriented algorithms to optimize performance on vector processors.^[2] Released in 1979, LINPACK provided efficient numerical tools for high-performance computing, relying on the Basic Linear Algebra Subprograms (BLAS) for core operations like matrix multiplication.^[3] A key legacy of LINPACK is its associated benchmark, introduced in the 1979 user's guide, which measures a system's floating-point performance (FLOPS) by solving a dense linear system of order up to 1000; this benchmark evolved into the High-Performance LINPACK (HPL) test and has ranked the world's 500 fastest supercomputers biannually since the inaugural TOP500 list in 1993.^[4]^[5] Though largely superseded in the 1990s by the more modern LAPACK library—which extends LINPACK's algorithms for shared-memory architectures and better cache utilization—LINPACK remains influential in numerical software history and continues to serve as a foundational reference for linear algebra implementations.^[1]^[3]

History and Development

Origins at Argonne National Laboratory

The development of LINPACK was initiated in January 1976 under the auspices of Argonne National Laboratory's Applied Mathematics Division, as a collaborative project to create a comprehensive package of Fortran subroutines for solving systems of linear equations and related matrix computations on digital computers.^[6] This effort was spurred by the need to consolidate and standardize numerical linear algebra software, which had previously suffered from inconsistencies in implementation across various computing platforms, thereby hindering portability and reliability in scientific applications.^[6] The project aimed to deliver efficient, well-documented routines that could be widely adopted by researchers, emphasizing dense matrix problems to support advanced scientific computing tasks.^[7] The initial team comprised key researchers including Cleve Moler of the University of New Mexico, whose prior work on the EISPACK library for eigenvalue computations served as a foundational inspiration; Jim Bunch from the University of California, San Diego; Jack Dongarra, based at Argonne; and G. W. Stewart from the University of Maryland.^[6]^[7] Funding was provided through a three-year grant from the National Science Foundation starting in 1976, supplemented by support from the U.S. Department of Energy at Argonne, which facilitated coordination and resource allocation for the distributed team.^[6] Informal meetings had begun in June 1974, leading to annual month-long workshops held at Argonne beginning in the summer of 1976, where the group refined designs and prototyped code collaboratively.^[6] By 1977, early prototype routines had been tested, validating their performance and portability for dense linear algebra operations ahead of broader distribution.^[8] These milestones marked significant progress toward a unified software framework, building briefly on the precedent set by EISPACK as a precursor focused on eigenvalue routines.^[7]

Release and Initial Adoption

LINPACK was officially released in 1979 as a comprehensive Fortran library comprising over 40 subroutines designed for solving systems of linear equations and performing related matrix computations.^[9] The package, developed under a National Science Foundation grant at Argonne National Laboratory, was documented in the LINPACK Users' Guide, published by the Society for Industrial and Applied Mathematics (SIAM), which provided detailed instructions for implementation and usage. Distribution initially occurred through magnetic tapes supplied by Argonne's National Energy Software Center, allowing researchers to obtain the Fortran source code, including necessary Basic Linear Algebra Subprograms (BLAS), for a nominal fee.^[9] This method enabled access at hundreds of installations worldwide, with the library later becoming freely available via the Netlib repository established in 1985, which revolutionized software sharing in scientific computing by allowing electronic requests and automated delivery.^[10] Early adoption was swift and broad, with LINPACK integrated into simulations across national laboratories, universities, and industries for applications in physics, engineering, and chemistry, where reliable linear algebra tools were essential.^[10] It quickly influenced numerical methods research and practice. The initial release faced some challenges, including bugs reported by users through mail and telephone feedback, which the development team addressed in subsequent updates to enhance reliability.^[10] These interactions also informed iterative improvements to the documentation in the 1979 Users' Guide, making it more robust for diverse user needs and compiler environments.^[6]

Core Functionality

Solving Systems of Linear Equations

LINPACK's primary function is to solve systems of linear equations of the form Ax = b, where A is an n \times n dense square matrix, and x and b are vectors of length n.^[1] The package addresses this core problem through Gaussian elimination with partial pivoting, which computes an LU factorization of a permuted version of A, ensuring numerical stability for a wide range of matrix conditions.^[8] The key algorithm involves first performing LU factorization to decompose the matrix as PA = LU, where P is a permutation matrix, L is a lower triangular matrix with unit diagonal entries, and U is an upper triangular matrix.^[11] This decomposition is achieved using routines such as SGEFA for single-precision real arithmetic and DGEFA for double-precision, which apply Gaussian elimination with partial pivoting. Partial pivoting selects the entry with the largest absolute value in the current column (below the pivot position) as the pivot element, swapping rows as needed to place it on the diagonal; this strategy minimizes the growth factor during elimination, bounding it by $2^{n-1} in the worst case and promoting stability by reducing error amplification.^[11] Once the factorization is obtained, the system is solved via forward substitution to compute Ly = Pb (accounting for the permutation) followed by back substitution to obtain Ux = y, implemented in routines SGESL and DGESL, which also support solving transposed systems.^[12]^[13] For numerical stability, LINPACK incorporates error handling features, including condition number estimation and overflow detection. The routines SGECO and DGECO perform the factorization while estimating the reciprocal condition number rcond \approx 1 / \kappa(A), where \kappa(A) = \|A\| \cdot \|A^{-1}\|, by solving for an approximate null vector and rescaling to avoid overflow or underflow; if rcond is near zero, the matrix is deemed ill-conditioned or singular.^[14] Additionally, the factorization routines set an info flag to indicate potential singularity (if a pivot is zero) or to detect overflow risks during elimination, allowing users to assess solution reliability without explicit error bounds.^[11] The computational complexity of solving an n \times n system in LINPACK is O(n^3) operations for the LU factorization step, dominated by the elimination process, with subsequent solves requiring only O(n^2) operations per right-hand side.^[8] These routines were optimized for vector processors prevalent in the 1970s, such as the CDC 7600 and Cray-1, by leveraging level-1 BLAS operations (e.g., SAXPY, IDAMAX) to exploit inner loops for vectorization, achieving near-peak performance on such hardware without sacrificing portability across Fortran compilers.^[11]^[8]

Additional Matrix Computations

LINPACK provides a suite of routines for auxiliary linear algebra operations on dense matrices, extending beyond the core task of solving linear systems. These include computing matrix inverses, determinants, solutions to linear least squares problems, and singular value decompositions. All operations rely on underlying factorizations such as LU or QR, and the package employs level 1 BLAS routines for efficient vector operations where applicable.^[1]^[15] Matrix inversion in LINPACK is achieved by first performing an LU factorization using the routine SGEFA (for single precision real general matrices), which decomposes the matrix A into a lower triangular matrix L, an upper triangular matrix U, and a permutation matrix P such that PA = LU. The routine SGEDI then utilizes this factorization to compute the inverse A⁻¹ by solving n systems of the form Ax = e_i for i = 1 to n, where e_i are the standard basis vectors; the resulting inverse overwrites the original factored matrix. This approach is recommended only when direct inversion is unavoidable, as solving systems is generally more stable and efficient for most applications. Similar routines exist for double precision (DGEDI), complex (CGEDI), and double complex (ZGEDI) cases.^[15]^[16] The determinant of a matrix is computed as a byproduct of the LU factorization from SGEFA or the related SGECO routine, which also estimates the condition number. Specifically, the determinant is the product of the diagonal elements of the upper triangular factor U, multiplied by (-1) raised to the number of row interchanges performed during pivoting to account for sign changes. For band matrices, the routine SGBDI computes only the determinant, as the inverse is generally not banded. These capabilities are available across precision variants, such as DGEDI for double precision.^[15]^[17] For linear least squares problems of the form minimize ||Ax - b||₂ where A is m × n with m ≥ n and full column rank, LINPACK employs QR decomposition via Householder transformations. The routine SQRDC computes the QR factorization of A, producing an orthogonal matrix Q and upper triangular R such that A = QR, while SQRSL applies this decomposition to solve for the least squares solution x, compute residuals, and perform related projections or covariance estimates. These routines support overdetermined systems and are implemented for single, double, complex, and double complex precisions, with SQRDC handling the orthogonalization and SQRSL managing the solution phase.^[1]^[15] Singular value decomposition in LINPACK is provided by routines such as SSVDC for single precision and DSVDC for double precision. These compute the decomposition of an n × p matrix X as X = U S V^T, where U and V are orthogonal matrices and S is a diagonal matrix containing the singular values in descending order. The algorithm first reduces X to upper bidiagonal form using Householder transformations, then applies iterative QR transformations (up to 30 iterations) to compute the singular values, with optional computation of singular vectors based on input flags. The input matrix is overwritten, and analogous routines exist for complex cases.^[18]^[1] LINPACK is designed exclusively for dense matrices, offering no native support for sparse structures, which limits its applicability to problems where matrices have few zero entries.^[4]

Implementation Details

Fortran Structure and Routines

LINPACK is implemented entirely in Fortran 77, ensuring compatibility with compilers prevalent in the 1970s, such as those adhering to Fortran 66 standards.^[1] This choice facilitated widespread adoption on early supercomputers and vector processors of the time.^[19] The codebase employs a modular architecture, consisting of subroutines organized by arithmetic precision—single and double for real numbers, and single and double for complex numbers—and by matrix storage types, including general, banded, symmetric indefinite, symmetric positive definite, triangular, and tridiagonal forms.^[1] This organization results in over 100 subroutines in total, with core functionality distributed across driver routines for primary computations, building block routines for decompositions, and utility functions for supporting operations.^[1] Examples of driver routines include SGECO, which factors a general real matrix and estimates its condition number for subsequent solves, and SGEFA, which performs LU factorization with partial pivoting for numerical stability.^[20] Auxiliary routines, such as those for error analysis and inverse computation (e.g., SGEDI), provide additional diagnostics like determinant evaluation and solution error bounds.^[1] The library heavily relies on Level 1 Basic Linear Algebra Subprograms (BLAS) for vector operations, such as dot products (SDOT) and scaling (SSCAL), which are included in the distribution to promote portability and efficiency.^[6] Code features emphasize maintainability and user accessibility, with inline comments in each subroutine detailing parameters, usage, and dependencies on BLAS or intrinsic Fortran functions.^[6] The accompanying user's guide includes complete example programs demonstrating invocation of routines for common tasks, such as solving dense linear systems. Machine-dependent parameters, defined in a separate constants file, allow tuning for specific hardware, including constants for safe minimum values and overflow thresholds to prevent numerical issues across platforms.^[1] The initial design prioritized code readability and clarity over aggressive optimization, reflecting its role as a foundational library for scientific computing.^[21]

Optimization and Portability

LINPACK was engineered for portability across diverse hardware architectures prevalent in the late 1970s and 1980s, primarily through its reliance on the Level 1 Basic Linear Algebra Subprograms (BLAS), which provided a standardized interface for vector and scalar operations without incorporating vendor-specific intrinsics or assembly code. This design allowed the library to be compiled and executed on a wide range of systems, from scalar processors to early vector machines, by leveraging compiler optimizations rather than hardware-dependent implementations. Tunable parameters, such as machine epsilon for floating-point precision handling and constants for safe minimum values and overflow thresholds, further enhanced adaptability; machine epsilon, computed dynamically in the benchmark code, ensured numerical stability across varying arithmetic precisions.^[22]^[23] Optimizations in LINPACK focused on efficiency through the integration of BLAS routines, which handled the computationally intensive inner loops—over 90% of execution time for a 100×100 matrix solve was spent in the DAXPY routine—allowing outer loops to remain portable while benefiting from machine-tuned BLAS implementations. For vector processors like the Cray-1, performance was achieved via Fortran code amenable to automatic vectorization by compilers, including loop unrolling and chaining to exploit pipeline parallelism, rather than hand-coded assembly. Early versions, however, encountered challenges on pipelined architectures due to predominantly scalar code structures that limited vector utilization, resulting in suboptimal throughput until compiler advancements in the 1980s provided vectorization hints and improved code generation.^[22]^[24] In 1979, the accompanying benchmark was run on 23 different machines, demonstrating its broad applicability and revealing performance disparities across systems; on supercomputers of the era, such as the Cray-1, it achieved 12 MFLOPS in unoptimized scalar form, improving to up to 27 MFLOPS with optimized compilation and compiler advancements in the early 1980s. Maintenance of the library occurred through the Netlib repository, where community contributions facilitated bug fixes and minor enhancements, including compatibility updates for evolving Fortran standards, extending its usability into the 1990s.^[22]^[24]

Benchmark Applications

High-Performance LINPACK (HPL)

High-Performance LINPACK (HPL) represents an adaptation of the original LINPACK library for parallel computing environments, specifically designed to evaluate the floating-point performance of distributed-memory supercomputers. Developed in 1992 by Jack Dongarra at the University of Tennessee, HPL extends the serial LU factorization algorithms to leverage message-passing interfaces for scalability across multiple processors.^[22] It builds upon the foundational routines of LINPACK by incorporating parallel data distribution and communication patterns, enabling efficient computation on clusters and massively parallel systems using the Message Passing Interface (MPI).^[25] The core algorithm in HPL employs a block-based LU factorization with partial row pivoting, utilizing a right-looking variant to facilitate parallelism. This approach divides the matrix into blocks and processes panel factorizations sequentially while performing recursive updates on trailing submatrices in a distributed manner. The two-dimensional block-cyclic data distribution ensures load balancing across processors, with communications optimized through techniques like look-ahead depth and various broadcast topologies to minimize latency.^[25]^[19] Key features of HPL include tunable parameters that allow users to optimize performance for specific hardware configurations. The process grid, defined as a P × Q topology, maps the computational workload across processors, ideally balanced to approximate a square shape for better scalability. The block size NB, typically set between 100 and 200 for optimal cache utilization and communication overhead, controls the granularity of operations; values in this range often yield peak efficiency on modern architectures. HPL supports execution on systems with thousands of processors, making it suitable for large-scale clusters.^[26]^[27] Performance is measured in gigaflops (GFLOPS), derived from the time taken to solve a dense n × n linear system, where n is chosen to utilize approximately 80% of the available system memory. The maximum achieved performance, R_max, is calculated as:

R_{\max} = \frac{2 n^3 / 3}{t}

where t is the execution time in seconds, reflecting the dominant (2/3)n³ floating-point operations in the LU factorization. This metric provides a standardized assessment of sustained computational capability under realistic parallel conditions.^[19] HPL has been open-source since 1995, distributed freely through Netlib to encourage widespread adoption and tuning experiments. The latest version, HPL 2.3 released in 2018, includes enhancements for ease of installation on diverse clusters, such as automated configuration scripts and comprehensive documentation for portability across vendors.^[25]

Integration with TOP500 List

The TOP500 project was launched in June 1993 by Hans W. Meuer of the University of Mannheim, Erich Strohmaier of Lawrence Berkeley National Laboratory, Jack Dongarra of the University of Tennessee, and Horst D. Simon of Lawrence Berkeley National Laboratory, establishing a biannual ranking of the world's 500 most powerful supercomputers based on performance measured by the High-Performance LINPACK (HPL) benchmark.^[28] This initiative provided a standardized metric to track trends in high-performance computing, with the first list compiled from submissions at the International Supercomputing Conference (ISC) in Hamburg, Germany. Since its inception, the project has published lists every June and November, fostering global competition and highlighting advancements in supercomputing hardware and software.^[29] The methodology for TOP500 rankings centers on the sustainable performance, or Rmax, achieved in HPL runs, where participating systems solve a dense system of linear equations using double-precision arithmetic across distributed-memory architectures.^[5] Submissions must adhere to strict guidelines, including selecting a problem size N that utilizes at least 80% of the system's available memory to ensure realistic scaling, prohibiting overclocking or non-standard configurations to maintain fairness, and providing verifiable run logs reviewed by the TOP500 team for accuracy.^[27]^[30] Rmax values, expressed in teraflops or higher units, determine the ordering, while theoretical peak performance (Rpeak) offers additional context but does not influence the ranking.^[29] Over the decades, the TOP500 lists have grown in scope and scale, consistently featuring 500 entries drawn from hundreds of submissions worldwide, with top systems demonstrating exponential performance gains driven by advances in processors, interconnects, and accelerators. By mid-2025, the list included systems exceeding 1 exaFLOPS, exemplified by the Frontier supercomputer at Oak Ridge National Laboratory, which achieved 1.102 exaFLOPS Rmax in 2022. More recently, El Capitan at Lawrence Livermore National Laboratory topped the June 2025 list with 1.742 exaFLOPS Rmax. In the November 2025 list, published on November 18, 2025, El Capitan retained the top spot, followed by Frontier and Aurora, with JUPITER entering as the fourth exascale system and Europe's first, underscoring the benchmark's role in quantifying exascale computing milestones.^[31] Despite its enduring use, the HPL-based ranking has faced criticisms for emphasizing dense linear algebra operations, which typically achieve only about two-thirds of a system's theoretical peak FLOPS and do not represent the memory-bound or sparse workloads common in scientific applications.^[32] Alternatives like the High-Performance Conjugate Gradient (HPCG) benchmark, introduced in 2014 to better reflect irregular access patterns and multi-physics simulations, have been proposed and even integrated into TOP500 lists as a secondary metric but have not replaced HPL as the primary standard.^[33]^[34] The core LINPACK-derived algorithm in HPL has remained fundamentally unchanged since 1993, enabling consistent historical comparisons across more than 65 published lists by late 2025.^[5]^[35]

Successors and Legacy

Transition to LAPACK

The LAPACK project began in 1987 as a collaborative effort funded by the U.S. Department of Energy and the National Science Foundation, involving researchers from Argonne National Laboratory, the Courant Institute of Mathematical Sciences at New York University, and the Numerical Algorithms Group (NAG) Ltd. in the United Kingdom.^[36] This initiative aimed to modernize numerical linear algebra software for emerging high-performance computing architectures, particularly shared-memory vector processors. The first release of LAPACK occurred in 1992, integrating the linear equation solvers from LINPACK with the eigenvalue routines from EISPACK to provide a unified, efficient library for dense linear algebra operations.^[36]^[37] A primary focus of LAPACK's design was to introduce blocked algorithms that leverage Level 3 Basic Linear Algebra Subprograms (BLAS) for improved cache efficiency and reduced memory access overhead on hierarchical memory systems. Unlike the column-oriented operations in LINPACK, which often led to suboptimal performance on vector machines, LAPACK's blocked approach partitions matrices into subblocks and performs matrix-matrix multiplications, minimizing data movement between fast and slow memory. For instance, the right-looking variant of the LU factorization in LAPACK uses a block size chosen to optimize for hardware characteristics, often on the order of tens to hundreds of elements, to balance computation and factorization steps, enabling asymptotic performance closer to the theoretical peak while maintaining numerical stability.^[38] These enhancements allow LAPACK routines to achieve higher flop rates on shared-memory systems compared to their LINPACK predecessors, though both retain the standard O(n^3) complexity for core operations like Gaussian elimination, with LAPACK offering improved practical constants through better data locality.^[39] To facilitate adoption, LAPACK was engineered for backward compatibility, allowing existing LINPACK and EISPACK code to invoke LAPACK routines via simple wrapper interfaces that preserve the original calling conventions and argument lists.^[39] This design choice ensured a smooth transition for legacy scientific software without requiring extensive rewrites. The library was initially implemented in Fortran 77 for broad portability across compilers and machines, with subsequent versions supporting interfaces to C and Fortran 90/95 for easier integration into mixed-language environments. As of version 3.12.1 released in January 2025, LAPACK includes extensions for heterogeneous computing, such as GPU acceleration through auxiliary libraries like MAGMA, while maintaining core portability. As of the 3.12.1 release in January 2025, LAPACK continues to evolve with support for modern architectures.^[37] By the mid-1990s, LAPACK had largely superseded LINPACK in new developments for high-performance numerical computing, becoming the de facto standard for dense linear algebra in scientific and engineering applications. Major software ecosystems, including MATLAB from MathWorks and NumPy in the Python scientific computing stack, adopted LAPACK as their underlying engine for matrix operations, leveraging its optimized routines for reliability and speed across diverse hardware.^[40] This widespread integration underscored LAPACK's role in bridging classical algorithms to modern computational paradigms.

Enduring Influence

LINPACK's enduring influence in numerical computing is evident in its foundational role within educational curricula. It remains a staple in numerical analysis courses, where it exemplifies core algorithms for solving systems of linear equations and least-squares problems, providing students with practical insights into Fortran-based scientific computing.^[41] The original user's guide, published in 1979, continues to serve as an authoritative reference for these fundamental techniques, emphasizing efficient implementation and error analysis in linear algebra.^[1] The package significantly shaped subsequent standards in high-performance computing. LINPACK's reliance on the Basic Linear Algebra Subprograms (BLAS) directly inspired the formal standardization of BLAS in the 1980s and 1990s, enabling portable and optimized linear algebra operations across diverse hardware.^[42] This influence extended to parallel computing, where it motivated the development of ScaLAPACK, a distributed-memory extension for scalable linear algebra on clusters and supercomputers.^[43] Modern adaptations demonstrate LINPACK's versatility beyond its original Fortran implementation. Ports to C++ appear in libraries like Eigen, which incorporates LINPACK-inspired routines for dense matrix factorizations in high-performance applications. Similarly, Julia's standard LinearAlgebra module includes implementations drawing from LINPACK's algorithms, facilitating efficient numerical computations in a dynamic language environment. Adaptations for embedded systems, such as optimized versions for ARM processors, extend its utility to resource-constrained devices, while legacy Fortran codebases in climate models—such as those in the Community Earth System Model—continue to rely on LAPACK (which incorporates LINPACK algorithms) for core simulations.^[44] Culturally, LINPACK has become synonymous with supercomputing prowess through its central role in the TOP500 list, which ranks the world's fastest systems based on its benchmark since 1993, fostering global competition and hardware innovation.^[45] Critiques of its focus on dense linear algebra and peak performance, however, spurred the creation of alternative benchmarks like Graph500 in 2010, which emphasizes irregular memory access and graph processing to better reflect diverse scientific workloads. As of 2025, the LINPACK codebase resides in the Netlib repository, where it has amassed millions of downloads since its inception, underscoring its archival value despite active development ceasing in the post-1990s era following the rise of LAPACK.^[46]

References

[1]
LINPACK - NetLib.org
LINPACK is a collection of Fortran subroutines that analyze and solve linear equations and linear least-squares problems. The package solves linear systems ...
[2]
Linear Algebra Libraries
LINPACK, originally written for Fortran, is a library of linear algebra functions and subroutines. It was created in the 1970s by Jim Bunch, Jack Dongarra, Clee ...
[3]
Linear algebra libraries for high-performance computers - IEEE Xplore
Linpack software, which was released in 1979, for solving linear algebra problems on high-performance computers is reviewed. The Linpack benchmark and ...
[4]
Frequent Asked Questions on the LINPACK Benchmark - The Netlib
May 8, 2007 · The first ``Linpack Benchmark'' report appeared as an appendix in the Linpack Users' Guide in 1979.<|control11|><|separator|>
[5]
The Linpack Benchmark - TOP500
LINPACK was chosen because it is widely used and performance numbers are available for almost all relevant systems. The LINPACK Benchmark was introduced by Jack ...Missing: history - | Show results with:history -
[6]
LINPACK Users' Guide - SIAM Publications Library
January 1976;.the Department of Energy also provided support at Argonne. The LINPACK project had a number of objectives. In the first place, it represented.
[7]
Jack J. Dongarra - History of Numerical Analysis
... Cleve Moler, and worked as a visiting scientist at Los Alamos. From 1976 to 1979 he worked with Moler, Pete Stewart and Jim Bunch to produce LINPACK, a ...
[8]
[PDF] linpack - The Netlib
The documentation for the codes is contained in the following book: J.J. Dongarra, J.R. Bunch, C.B. Moler, G.W. Stewart,. LINPACK Users' Guide. Society for ...Missing: Cleve Jack Pete
[9]
[PDF] ANL-80-105
LINPACK is distributed in the form of a magnetic tape which contains the Fortran source for LINPACK, the Basic Linear Algebra. Subprograms (BLAS) needed by ...Missing: motivations inconsistencies
[10]
[PDF] Jack J. Dongarra SIAM oral history; 2004-04-26
Apr 26, 2004 · received funding were Jim Bunch at California, Cleve Moler at New Mexico, Pete. Stewart at Maryland, and I received funding at Argonne.
[11]
The View From The TOP500 - Asian Scientist Magazine
Jan 25, 2018 · In 1979, the group finally released LINPACK to the world, along with a manual to show people how to use the software. Tucked into the back of ...
[12]
dgefa.f - The Netlib
subroutine dgefa(a,lda,n,ipvt,info) integer lda,n,ipvt(1),info double precision a(lda,1) c c dgefa factors a double precision matrix by gaussian elimination ...
[13]
None
### Summary of SGESL Routine from sgesl.f
[14]
https://www.netlib.org/linpack/dgeco.f
[15]
None
### Summary of DGECO Routine from dgeco.f
[16]
LINPACK_S - Linear Algebra Library - Single Precision Real
Jun 24, 2009 · SGEDI computes the determinant and inverse of a matrix factored by SGECO or SGEFA. SGEFA factors a real general matrix. SGESL solves a real ...
[17]
[PDF] LINPACK, a package for solving linear systems - SciSpace
UNPACK is a collection of Fortran subroutines that analyze and solve linear equations and linear least squares problems. The.
[18]
[PDF] LINPACK WORKING NOTE #15. Y E . - CERN Document Server
collecting and editing the programs as well as distributing them to test sites. In the summer of 1976 the members of the project visited. Argonne for a month.
[19]
EISPACK - The Netlib
EISPACK is a collection of Fortran subroutines that compute the eigenvalues and eigenvectors of nine classes of matrices.Missing: LINPACK | Show results with:LINPACK
[20]
[PDF] EISPACK - A Package for Solving Matrix Eigenvalue Problems
Sub- routines TRED2 and TQL2 accumulate eigenvectors S as a by-product of the ori- ginal reduction and eigenvalue iteration. Since S is a full matrix, most ...
[21]
[PDF] The LINPACK Benchmark: Past, Present, and Future
In the LINPACK Benchmark, a matrix of size 100 was originally used because of memory limitations with the computers that were in use in 1979. Such a matrix has ...
[22]
linpack/sgeco.html - Math
Previous: sgbsl Up: ../linpack.html Next: sgedi. SGECO. SUBROUTINE SGECO(A,LDA ... MATRIX BY GAUSSIAN ELIMINATION C AND ESTIMATES THE CONDITION OF THE ...Missing: routine | Show results with:routine
[23]
LINPACK, Linear Equation Package
Jan 23, 2018 · LINPACK and EISPACK are Fortran subroutine packages for matrix computation developed in the 1970's. They are a follow-up to the Algol 60 procedures.
[24]
[PDF] Past, Present, and Future* 1 LINPACK Benchmark History - The Netlib
In the LINPACK Benchmark, a matrix of size 100 was originally used because of memory limitations with the computer that were in use in 1979; the matrix has O( ...
[25]
linpack_bench.c
Reference: Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, LINPACK User's Guide, SIAM, 1979. Charles Lawson, Richard Hanson, David Kincaid, Fred ...Missing: origins Argonne National Laboratory 1976<|control11|><|separator|>
[26]
[PDF] Linear Algebra Libraries for High-Performance Computers - NetLib.org
We began the. Linpack project in the mid-1970s with the goal of producing a package of mathematical software for solving systems of linear equations.' We took a ...
[27]
HPL - A Portable Implementation of the High-Performance Linpack ...
The HPL package provides a testing and timing program to quantify the accuracy of the obtained solution as well as the time it took to compute it. The best ...HPL Software · HPL Algorithm · HPL Tuning · FAQsMissing: maintenance | Show results with:maintenance
[28]
HPL Tuning - The Netlib
... line reads: HPL Linpack benchmark input file. Line ... means that one wants xhpl to run 3 (specified in line 5) problem sizes, namely 3000, 6000 and 10000.
[29]
HPL Frequently Asked Questions - The Netlib
From a data distribution point of view, the smallest NB, the better the load balance. You definitely want to stay away from very large values of NB.Missing: 100 200
[30]
[PDF] The TOP500 List and Progress in High- Performance Computing
Nov 2, 2015 · Hans W. Meuer started the TOP500 list together with Erich Strohmaier, Jack Dongarra, and Horst. D. Simon in 1993. The project grew directly out ...
[31]
TOP500 Description
In the TOP500 List table, the computers are ordered first by their Rmax value. In the case of equal performances (Rmax value) for different computers, we have ...Missing: methodology HPL rules overclocking
[32]
Frequently Asked Questions - TOP500
For HPL what block size NB should I use ? HPL uses the block size NB for the data distribution as well as for the computational granularity. From a data ...
[33]
[PDF] Supercomputer Benchmarks ! A comparison of HPL, HPCG ... - HLRS
Dec 6, 2016 · TOP500 Main Criticism. ❖ HPL is too floating point-intensive. ▫ It performs O(n3) floating point operations and moves O(n2) data. (locally ...
[34]
[PDF] HPCG: ONE YEAR LATER - The Netlib
• TOP500 (HPL) is 21.5 years old. • Floating point-intensive performs O ... HPCG will serve as an alternate ranking of the Top500. • Or maybe top 50 for ...
[35]
HPCG Gains Steam as Alternative Benchmark for Supercomputers
Mar 14, 2018 · Based on a dense system for linear equations, HPL is used to rank supercomputer performance on the 25-year-old TOP500 list and is often used as ...
[36]
TOP500
The 65th TOP500 List was published June 14, 2025 in Hamburg. November 2024. The 64th TOP500 List was published Nov. 19, 2024 in Atlanta, GA. June 2024.November 2024 · June 2025 · November 2023 · November 2010Missing: entries peak
[37]
[PDF] rospectus for the Development of a Linear Algebra Library - The Netlib
rs at several institutions: Argonne National Laboratory, Courant Institute, and Numerical Algorithms. N. Group Ltd. The first two groups have received funding ...
[38]
LAPACK RELEASE NOTES - The Netlib
Jan 12, 2025 · History of LAPACK releases. Version 1.0 : February 29, 1992. Revised, Version 1.0a: June 30, 1992. Revised, Version 1.0b: October 31, 1992.Missing: development Argonne Courant NAG
[39]
[PDF] LAPACK Working Note 58 The Design of Linear Algebra Libraries ...
This paper discusses designing linear algebra libraries for high-performance computers, focusing on scalable algorithms for MIMD distributed memory computers. ...
[40]
LAPACK Compared with LINPACK and EISPACK - The Netlib
LAPACK has been designed to supersede LINPACK [38] and EISPACK [92,54], principally by restructuring the software to achieve much greater efficiency.
[41]
MATLAB Incorporates LAPACK - MathWorks
LAPACK is the modern replacement for LINPACK and EISPACK. It is a large, multi-author, Fortran library for numerical linear algebra.
[42]
The LINPACK Benchmark: past, present and future | Request PDF
Aug 6, 2025 · This paper describes the LINPACK Benchmark (41) and some of its variations commonly used to assess perfor- mance of computer systems.
[43]
The Evolution of Mathematical Software - Communications of the ACM
Dec 1, 2022 · Turing lecture The Evolution of Mathematical Software Tracing how software and algorithms follow the hardware.
[44]
ScaLAPACK — Scalable Linear Algebra PACKage - The Netlib
ScaLAPACK is a high-performance linear algebra library for parallel machines, solving dense and banded linear systems, and is an acronym for Scalable Linear ...Missing: LINPACK lasting impact education
[45]
https://www.top500.org/project/linpack/
[46]
[PDF] The evolution of mathematical software - The Netlib
Nov 24, 2022 · Advancing to the next stage of growth for computational simulation and modeling will require us to solve basic research problems in computer sci ...