Category:Fortran

This programming language may be used to instruct a computer to perform a task.
| Garbage collected: | No |
|---|---|
| Type safety: | Safe |
| Type strength: | Strong |
| Type compatibility: | Nominative |
| Type checking: | Static |
| Lang tag(s): | fortran |
| See Also: |
Fortran is the oldest programming language still in widespread use. The language has evolved considerably since it was first released in 1957. Fortran was original developed for scientific and engineering applications, and remains especially suited to numeric computation and scientific computing. By convention, versions before Fortran 90 are spelled with all uppercase letters (e.g. FORTRAN IV, FORTRAN 66, FORTRAN 77), while starting with Fortran 90, the mixed case spelling is used (i.e. Fortran 90, Fortran 95, Fortran 2003 and Fortran 2008). The most recent standard is Fortran 2018 (ISO/IEC 1539-1:2018).
FORTRAN 77, being quite old, lacks almost everything one expects from a modern programming language. It uses a fixed-length line and column oriented line format which was motivated by punch cards. Due to its age, and since FORTRAN compilers generally gave very good performance for numerical code, a lot of code, especially scientific code, was written in FORTRAN. Also, for quite a while there was no free Fortran 90 compiler, which also caused a lot of FORTRAN 77 code to be written even quite some time after Fortran 90 was standardized. Because of the large body of code written in FORTRAN 77 it remains relevant today. Indeed, every modern Fortran compiler still accepts FORTRAN 77 code.
Fortran 90 was a major revision of the language. It introduced a new free-form source code format, modern programming language features like modules, pointers and user-defined types, an improved type system for built-in types and superiour built-in array handling. Newer Fortran standards (Fortran 2003 and Fortran 2008) added further modern features, like support for object oriented programming, inheritance, polymorphism, parallel processing, and interoperability with the C programming language.
Subcategories
This category has the following 3 subcategories, out of 3 total.
@
- Fortran Implementations (3 P)
- Fortran User (104 P)
Pages in category "Fortran"
The following 200 pages are in this category, out of 891 total.
(previous page) (next page)A
- A+B
- Abbreviations, automatic
- Abbreviations, easy
- Abbreviations, simple
- ABC correlation
- ABC problem
- ABC words
- Abelian sandpile model
- Abelian sandpile model/Identity
- Abstract type
- Abundant odd numbers
- Abundant, deficient and perfect number classifications
- Accumulator factory
- Ackermann function
- Additive primes
- Address of a variable
- ADFGVX cipher
- Air mass
- AKS test for primes
- Align columns
- Aliquot sequence classifications
- Almost prime
- Amicable pairs
- Anadromes
- Anagram generator
- Anagrams
- Angle difference between two bearings
- Animate a pendulum
- Anonymous recursion
- Anti-primes
- Append a record to the end of a text file
- Apply a callback to an array
- Apply a digital filter (direct form II transposed)
- Approximate equality
- Arbitrary-precision integers (included)
- Arena storage pool
- Arithmetic derivative
- Arithmetic numbers
- Arithmetic-geometric mean
- Arithmetic-geometric mean/Calculate Pi
- Arithmetic/Complex
- Arithmetic/Integer
- Arithmetic/Rational
- Array concatenation
- Array length
- Arrays
- Ascending primes
- Assertions in design by contract
- Associative array/Merging
- Attractive numbers
- Autogram checker
- Averages/Arithmetic mean
- Averages/Mean angle
- Averages/Mean time of day
- Averages/Median
- Averages/Mode
- Averages/Pythagorean means
- Averages/Root mean square
- Averages/Simple moving average
- AVL tree
B
- Babbage problem
- Balanced brackets
- Barnsley fern
- Base64 encode data
- Benford's law
- Bernoulli's triangle
- Best shuffle
- Bifid cipher
- Bin given limits
- Binary digits
- Binary search
- Binary strings
- Bioinformatics/Base count
- Bioinformatics/Sequence mutation
- Biorhythms
- Bitmap
- Bitmap/Bresenham's line algorithm
- Bitmap/Bézier curves/Cubic
- Bitmap/Bézier curves/Quadratic
- Bitmap/Flood fill
- Bitmap/Histogram
- Bitmap/Midpoint circle algorithm
- Bitmap/Read a PPM file
- Bitmap/Write a PPM file
- Bitwise operations
- Blossom algorithm
- Blum integer
- Boolean values
- Borůvka algorithm
- Box the compass
- Boyer-Moore string search
- Brazilian numbers
- Brilliant numbers
- Bron–Kerbosch algorithm
- Brownian tree
- Bulls and cows
- Bulls and cows/Player
- Burrows–Wheeler transform
- Bézier curves/Intersections
C
- Caesar cipher
- Calculating the value of e
- Calendar
- Calendar - for "REAL" programmers
- Calkin-Wilf sequence
- Call a foreign-language function
- Call a function
- Call a function in a shared library
- Call an object method
- Camel case and snake case
- Carmichael 3 strong pseudoprimes
- Cartesian product of two or more lists
- Case-sensitivity of identifiers
- Casting out nines
- Catalan numbers
- Catalan numbers/Pascal's triangle
- Catamorphism
- Centre and radius of a circle passing through 3 points in a plane
- Change e letters to i in words
- Chaocipher
- Chaos game
- Character codes
- Check if a polygon overlaps with a rectangle
- Check if two polygons overlap
- Check input device is a terminal
- Check output device is a terminal
- Check that file exists
- Chemical calculator
- Cheryl's birthday
- Chinese remainder theorem
- Chinese zodiac
- Cholesky decomposition
- Chowla numbers
- Christofides algorithm
- Circles of given radius through two points
- Classes
- Closest-pair problem
- Cocke–Younger–Kasami (CYK) Algorithm
- Code Golf
- Collections
- Color Difference CIE ΔE2000
- Combinations
- Combinations with repetitions
- Comma quibbling
- Command-line arguments
- Commatizing numbers
- Comments
- Compare a list of strings
- Compare length of two strings
- Compile-time calculation
- Compiler/AST interpreter
- Compiler/code generator
- Compiler/lexical analyzer
- Compiler/syntax analyzer
- Compiler/virtual machine interpreter
- Compound data type
- Concurrent computing
- Conditional structures
- Conjugate transpose
- Consecutive primes with ascending or descending differences
- Constrained genericity
- Constrained random points on a circle
- Continued fraction
- Continued fraction/Arithmetic/Construct from rational number
- Continued fraction/Arithmetic/G(matrix ng, continued fraction n)
- Continued fraction/Arithmetic/G(matrix ng, continued fraction n1, continued fraction n2)
- Convert decimal number to rational
- Convert seconds to compound duration
- Convex hull
- Conway's Game of Life
- Copy a string
- Copy stdin to stdout
- CORDIC
- Count in factors
- Count in octal
- Count occurrences of a substring
- Count the coins
- Cramer's rule
- CRC-32
- Create a file
- Create a file on magnetic tape
- Create a two-dimensional array at runtime
- Create an HTML table
- CSV data manipulation
- CSV to HTML translation
- Cuban primes
- Cullen and Woodall numbers
- Cumulative standard deviation
- Currency
- Curzon numbers
- CUSIP