Misplaced Pages

#266733

71-646: GNU Fortran ( GFortran ) is an implementation of the Fortran programming language in the GNU Compiler Collection (GCC), an open-source and free software project maintained in the open-source programmer community under the umbrella of the GNU Project . It is the successor to previous compiler versions in the suite, such as g77 . As of July 2020, GFortran had almost fully implemented Fortran 2008 , and about 20% of Fortran 2018 . It supports

142-488: A complex number data type in the language made Fortran especially suited to technical applications such as electrical engineering. By 1960, versions of FORTRAN were available for the IBM 709 , 650 , 1620 , and 7090 computers. Significantly, the increasing popularity of FORTRAN spurred competing computer manufacturers to provide FORTRAN compilers for their machines, so that by 1963 over 40 FORTRAN compilers existed. FORTRAN

213-522: A uvular trill in IPA, and ɢ a voiced uvular plosive . They should not normally be used in other contexts; rather, the basic character set should be used with suitable formatting controls as described in the preceding sections. * Superscript versions of small caps ᴀ , ᴅ , ᴇ and ᴘ have been provisionally assigned for inclusion in a future version of the Unicode Standard. Additionally,

284-574: A 1979 interview with Think , the IBM employee magazine, "Much of my work has come from being lazy. I didn't like writing programs, and so, when I was working on the IBM 701 , writing programs for computing missile trajectories, I started work on a programming system to make it easier to write programs." The language was widely adopted by scientists for writing numerically intensive programs, which encouraged compiler writers to produce compilers that could generate faster and more efficient code. The inclusion of

355-696: A colon, feature tag, an equals sign and feature value, for example, EB Garamond 12:smcp=1 , and version 6.2 added a dialog to switch. Although small caps are allographs of their full size equivalents (and so not usually "semantically important"), the Unicode standard does define a number of "small capital" characters in the IPA extensions , Phonetic Extensions and Latin Extended-D ranges (0250–02AF, 1D00–1D7F, A720–A7FF). These characters are meant for use in phonetic representations. For example, ʀ represents

426-452: A de facto standard), and Basic FORTRAN (based on FORTRAN II, but stripped of its machine-dependent features). The FORTRAN defined by the first standard, officially denoted X3.9-1966, became known as FORTRAN 66 (although many continued to term it FORTRAN IV, the language on which the standard was largely based). FORTRAN 66 effectively became the first industry-standard version of FORTRAN. FORTRAN 66 included: The above Fortran II version of

497-548: A few less-common Latin characters, several Greek characters, and a single Cyrillic character used in Latin-script notation (small capital Л : ᴫ), also have small capitals encoded: The Unicode Consortium has a typographical convention of using small caps for its formal names for symbols, in running text. For example, the name of U+0416 Ж CYRILLIC CAPITAL LETTER ZHE is conventionally shown as CYRILLIC CAPITAL LETTER ZHE . Small caps can be specified in

568-446: A more practical alternative to assembly language for programming their IBM 704 mainframe computer . Backus' historic FORTRAN team consisted of programmers Richard Goldberg, Sheldon F. Best, Harlan Herrick, Peter Sheridan, Roy Nutt , Robert Nelson, Irving Ziller, Harold Stern, Lois Haibt , and David Sayre . Its concepts included easier entry of equations into a computer, an idea developed by J. Halcombe Laning and demonstrated in

639-413: A number of significant features to address many of the shortcomings of FORTRAN 66: In this revision of the standard, a number of features were removed or altered in a manner that might invalidate formerly standard-conforming programs. (Removal was the only allowable alternative to X3J3 at that time, since the concept of " deprecation " was not yet available for ANSI standards.) While most of the 24 items in

710-499: A sequence number or text, which could be used to re-order cards if a stack of cards was dropped; though in practice this was reserved for stable, production programs. An IBM 519 could be used to copy a program deck and add sequence numbers. Some early compilers, e.g., the IBM 650's, had additional restrictions due to limitations on their card readers. Keypunches could be programmed to tab to column 7 and skip out after column 72. Later compilers relaxed most fixed-format restrictions, and

781-409: A simple means for FORTRAN 77 programmers to issue POSIX system calls. Over 100 calls were defined in the document – allowing access to POSIX-compatible process control, signal handling, file system control, device control, procedure pointing, and stream I/O in a portable manner. The much-delayed successor to FORTRAN 77, informally known as Fortran 90 (and prior to that, Fortran 8X ),

SECTION 10

#1732786996267

852-518: A specific machine register ( IBM 360 et seq ), which only allows recursion if a stack is maintained by software and the return address is stored on the stack before the call is made and restored after the call returns. Although not specified in FORTRAN 77, many F77 compilers supported recursion as an option, and the Burroughs mainframes , designed with recursion built-in, did so by default. It became

923-455: A standard in Fortran 90 via the new keyword RECURSIVE. This program, for Heron's formula , reads data on a tape reel containing three 5-digit integers A, B, and C as input. There are no "type" declarations available: variables whose name starts with I, J, K, L, M, or N are "fixed-point" (i.e. integers), otherwise floating-point. Since integers are to be processed in this example, the names of

994-637: Is again because small caps were normally only used in body text and cutting bold and italic small caps was thought unnecessary. An isolated early appearance was in the Enschedé type foundry specimen of 1768, which featured a set cut by Joan Michaël Fleischman , and in 1837 Thomas Adams commented that in the United States "small capitals are in general only cast to roman fonts" but that "some founders in England cast italic small capitals to most, if not

1065-467: Is documented in Backus et al.'s paper on this original implementation, The FORTRAN Automatic Coding System : The fundamental unit of program is the basic block ; a basic block is a stretch of program which has one entry point and one exit point. The purpose of section 4 is to prepare for section 5 a table of predecessors (PRED table) which enumerates the basic blocks and lists for every basic block each of

1136-449: Is implemented depends on the typesetting system; some can use true small caps glyphs that are included in modern professional typefaces ; but less complex computer fonts do not have small-caps glyphs, so the typesetting system simply reduces the uppercase letters by a fraction (often 1.5 to 2 points less than the base scale). However, this will make the characters look somewhat out of proportion. A work-around to simulate real small capitals

1207-534: Is sometimes called petite caps , preserving the name "small caps" for the larger variant. OpenType fonts can define both forms via the "small caps" and the "petite caps" features. When the support for the petite caps feature is absent from a desktop publishing program, x-height small caps are often substituted. Many word processors and text formatting systems include an option to format text in caps and small caps, which leaves uppercase letters as they are, but converts lowercase letters to small caps. How this

1278-471: Is therefore easier to work with fonts that have true small caps as a completely separate style, similar to bold or italic. Few free and open-source fonts have this feature; an exception is Georg Duffner's EB Garamond , in open beta. LibreOffice Writer started allowing true small caps for OpenType fonts since version 5.3, they can be enabled via a syntax used in the Font Name input box, including font name,

1349-407: Is to use a bolder version of the small caps generated by such systems, to match well with the normal weights of capitals and lowercase, especially when such small caps are extended about 5% or letter-spaced a half point or a point. Small caps are often used in sections of text that are unremarkable and thus a run of uppercase capital letters might imply an emphasis that is not intended. For example,

1420-761: Is used for programs that benchmark and rank the world's fastest supercomputers . Fortran has evolved through numerous versions and dialects. In 1966, the American National Standards Institute (ANSI) developed a standard for Fortran to limit proliferation of compilers using slightly different syntax. Successive versions have added support for a character data type (Fortran 77), structured programming , array programming , modular programming , generic programming (Fortran 90), parallel computing ( Fortran 95 ), object-oriented programming (Fortran 2003), and concurrent programming (Fortran 2008). Since April 2024, Fortran has ranked among

1491-634: The fleece and trap vowels in English. The Bluebook prescribes small caps for some titles and names in United States legal citations. The practice precedes World War I , with Harvard Law Review using it while referring to itself. By 1915, small caps were used for all titles of journals and books. In many books, mention of another part of the same book or mentions the work as a whole will be set in small caps. For example, articles in The World Book Encyclopedia refer to

SECTION 20

#1732786996267

1562-499: The IBM 7030 ("Stretch") computer, followed by versions for the IBM 7090 , IBM 7094 , and later for the IBM 1401 in 1966. By 1965, FORTRAN IV was supposed to be compliant with the standard being developed by the American Standards Association X3.4.3 FORTRAN Working Group. Between 1966 and 1968, IBM offered several FORTRAN IV compilers for its System/360 , each named by letters that indicated

1633-592: The Laning and Zierler system of 1952. A draft specification for The IBM Mathematical Formula Translating System was completed by November 1954. The first manual for FORTRAN appeared in October 1956, with the first FORTRAN compiler delivered in April 1957. Fortran produced efficient enough code for assembly language programmers to accept a high-level programming language replacement. John Backus said during

1704-474: The OpenMP multi-platform shared memory multiprocessing , up to its latest version (4.5). GFortran is also compatible with most language extensions and compilation options supported by g77, and many other popular extensions of the Fortran language. Since GCC version 4.0.0, released in April 2005, GFortran has replaced the older g77 compiler. The new Fortran front-end for GCC was rewritten from scratch, after

1775-516: The Heron program needs several modifications to compile as a Fortran 66 program. Modifications include using the more machine independent versions of the READ and WRITE statements, and removal of the unneeded FLOATF type conversion functions. Though not required, the arithmetic IF statements can be re-written to use logical IF statements and expressions in a more structured fashion. After

1846-575: The Hollerith edit descriptors in the FORMAT statements with quoted strings. It also uses structured IF and END IF statements, rather than GOTO / CONTINUE . The development of a revised standard to succeed FORTRAN 77 would be repeatedly delayed as the standardization process struggled to keep up with rapid changes in computing and programming practice. In the meantime, as the "Standard FORTRAN" for nearly fifteen years, FORTRAN 77 would become

1917-528: The IBM 704 contained 32 statements , including: The arithmetic IF statement was reminiscent of (but not readily implementable by) a three-way comparison instruction (CAS—Compare Accumulator with Storage) available on the 704. The statement provided the only way to compare numbers—by testing their difference, with an attendant risk of overflow. This deficiency was later overcome by "logical" facilities introduced in FORTRAN IV. The FREQUENCY statement

1988-475: The University of Waterloo's WATFOR and WATFIV were created to simplify the complex compile and link processes of earlier compilers. In the FORTRAN IV programming environment of the era, except for that used on Control Data Corporation (CDC) systems, only one instruction was placed per line. The CDC version allowed for multiple instructions per line if separated by a $ (dollar) character. The FORTRAN sheet

2059-564: The basic blocks which can be its immediate predecessor in flow, together with the absolute frequency of each such basic block link. This table is obtained by running the program once in Monte-Carlo fashion, in which the outcome of conditional transfers arising out of IF-type statements and computed GO TO's is determined by a random number generator suitably weighted according to whatever FREQUENCY statements have been provided. The first FORTRAN compiler reported diagnostic information by halting

2130-399: The character string. Miscounts were a problem. IBM's FORTRAN II appeared in 1958. The main enhancement was to support procedural programming by allowing user-written subroutines and functions which returned values with parameters passed by reference . The COMMON statement provided a way for subroutines to access common (or global ) variables. Six new statements were introduced: Over

2201-692: The computed AREA of the triangle as a floating-point number occupying ten spaces along the line of output and showing 2 digits after the decimal point, the .2 in F10.2 of the FORMAT statement with label 601. IBM also developed a FORTRAN III in 1958 that allowed for inline assembly code among other features; however, this version was never released as a product. Like the 704 FORTRAN and FORTRAN II, FORTRAN III included machine-dependent features that made code written in it unportable from machine to machine. Early versions of FORTRAN provided by other vendors suffered from

GNU Fortran - Misplaced Pages Continue

2272-487: The conflict list (see Appendix A2 of X3.9-1978) addressed loopholes or pathological cases permitted by the prior standard but rarely used, a small number of specific capabilities were deliberately removed, such as: A Fortran 77 version of the Heron program requires no modifications to the Fortran 66 version. However this example demonstrates additional cleanup of the I/O statements, including using list-directed I/O, and replacing

2343-591: The digital period, such as in Hoefler Text and FF Scala . The OpenType font standard provides support for transformations from normal letters to small caps by two feature tags, smcp and c2sc . A font may use the tag smcp to indicate how to transform lower-case letters to small caps, and the tag c2sc to indicate how to transform upper-case letters to small caps. OpenType provides support for transformations from normal letters to petite caps by two feature tags, pcap and c2pc . A font may use

2414-640: The early history of FORTRAN was the decision by the American Standards Association (now American National Standards Institute (ANSI)) to form a committee sponsored by the Business Equipment Manufacturers Association (BEMA) to develop an American Standard Fortran . The resulting two standards, approved in March 1966, defined two languages, FORTRAN (based on FORTRAN IV, which had served as

2485-524: The encyclopedia as a whole and to the encyclopedia's other articles in small caps, as in the "Insurance" article's direction, at one point, to "See No-Fault Insurance ", "No-Fault Insurance" being another of the encyclopedia's articles. Among Romance languages , as an orthographic tradition, only the French and Spanish languages render Roman numerals in small caps to denote centuries, e.g. xviii siècle and siglo xviii for "18th century";

2556-429: The error. Before the development of disk files, text editors and terminals, programs were most often entered on a keypunch keyboard onto 80-column punched cards , one line to a card. The resulting deck of cards would be fed into a card reader to be compiled. Punched card codes included no lower-case letters or many special characters, and special versions of the IBM 026 keypunch were offered that would correctly print

2627-573: The first sans serif to feature small caps and optional oldstyle numerals across all weights." (Some caps-only typefaces intended for printing stationery, for instance Copperplate Gothic and Bank Gothic , were intended to be used with smaller sizes serving as small capitals, and had no lower case as a result. ) Italic small capitals were historically rarer than roman small caps. Some digital font families, sometimes digitisations of older metal type designs, still only have small caps in roman style and do not have small caps in bold or italic styles. This

2698-467: The formal names of algorithmic problem, e.g. MᴀxSAT, are sometimes set in small caps. Linguists use small caps to analyze the morphology and tag ( gloss ) the parts of speech in a sentence; e.g., She 3SG . F . NOM love-s love- 3SG . PRS . IND you. 2 She love-s you. 3SG.F.NOM love-3SG.PRS.IND 2 Linguists also use small caps to refer to the keywords in lexical sets for particular languages or dialects; e.g.

2769-401: The height of a small capital glyph will be one ex , the same height as most lowercase characters in the font. In fonts with relatively low x-height, however, small caps may be somewhat larger than this. For example, in some Tiro Typeworks fonts, small caps glyphs are 30% larger than x-height, and 70% the height of full capitals. To differentiate between these two alternatives, the x-height form

2840-527: The historically most important dialect. An important practical extension to FORTRAN 77 was the release of MIL-STD-1753 in 1978. This specification, developed by the U.S. Department of Defense , standardized a number of features implemented by most FORTRAN 77 compilers but not included in the ANSI FORTRAN 77 standard. These features would eventually be incorporated into the Fortran 90 standard. The IEEE 1003.9 POSIX Standard, released in 1991, provided

2911-403: The language through FORTRAN 77 were usually spelled in all- uppercase . FORTRAN 77 was the last version in which the Fortran character set included only uppercase letters. The official language standards for Fortran have referred to the language as "Fortran" with initial caps since Fortran 90. In late 1953, John W. Backus submitted a proposal to his superiors at IBM to develop

GNU Fortran - Misplaced Pages Continue

2982-666: The minimum amount of memory the compiler needed to run. The letters (F, G, H) matched the codes used with System/360 model numbers to indicate memory size, each letter increment being a factor of two larger: Digital Equipment Corporation maintained DECSYSTEM-10 Fortran IV (F40) for PDP-10 from 1967 to 1975. Compilers were also available for the UNIVAC 1100 series and the Control Data 6000 series and 7000 series systems. At about this time FORTRAN IV had started to become an important educational tool and implementations such as

3053-512: The names of characters before their lines. Some publications use small caps to indicate surnames. An elementary example is Don Quixote de La Mancha . In the 21st century, the practice is gaining traction in scientific publications. In many versions of the Old Testament of the Bible , the word " Lord " is set in small caps. Typically, an ordinary "Lord" corresponds to the use of

3124-463: The next few years, FORTRAN II added support for the DOUBLE PRECISION and COMPLEX data types. Early FORTRAN compilers supported no recursion in subroutines. Early computer architectures supported no concept of a stack, and when they did directly support subroutine calls, the return location was often stored in one fixed location adjacent to the subroutine code (e.g. the IBM 1130 ) or

3195-475: The numerals are cardinally postpositive in Spanish alone. Research by Margaret M. Smith concluded that the use of small caps was probably popularised by Johann Froben in the early 16th century, who used them extensively from 1516. Froben may have been influenced by Aldus Manutius , who used very small capitals with printing Greek and at the start of lines of italic, copying a style common in manuscripts at

3266-521: The principal author and maintainer of g77, Craig Burley, decided in 2001 to stop working on the g77 front end. GFortran forked off from g95 in January 2003, which itself started in early 2000. The two codebases have "significantly diverged" according to GCC developers, and g95 has not been maintained since 2013. Since 2010 the front-end, like the rest of the GCC project, has been migrated to C++ , where it

3337-409: The program when an error was found and outputting an error code on its console. That code could be looked up by the programmer in an error messages table in the operator's manual, providing them with a brief description of the problem. Later, an error-handling subroutine to handle user errors such as division by zero, developed by NASA, was incorporated, informing users of which line of code contained

3408-481: The re-purposed special characters used in FORTRAN. Reflecting punched card input practice, Fortran programs were originally written in a fixed-column format, with the first 72 columns read into twelve 36-bit words. A letter "C" in column 1 caused the entire card to be treated as a comment and ignored by the compiler. Otherwise, the columns of the card were divided into four fields: Columns 73 to 80 could therefore be used for identification information, such as punching

3479-621: The release of the FORTRAN 66 standard, compiler vendors introduced several extensions to Standard Fortran , prompting ANSI committee X3J3 in 1969 to begin work on revising the 1966 standard, under sponsorship of CBEMA , the Computer Business Equipment Manufacturers Association (formerly BEMA). Final drafts of this revised standard circulated in 1977, leading to formal approval of the new FORTRAN standard in April 1978. The new standard, called FORTRAN 77 and officially denoted X3.9-1978, added

3550-464: The requirement was eliminated in the Fortran 90 standard. Within the statement field, whitespace characters (blanks) were ignored outside a text literal. This allowed omitting spaces between tokens for brevity or including spaces within identifiers for clarity. For example, AVG OF X was a valid identifier, equivalent to AVGOFX , and 101010 DO101I = 1 , 101 was a valid statement, equivalent to 10101 DO 101 I = 1 , 101 because

3621-428: The same disadvantage. IBM began development of FORTRAN IV in 1961 as a result of customer demands. FORTRAN IV removed the machine-dependent features of FORTRAN II (such as READ INPUT TAPE ), while adding new features such as a LOGICAL data type , logical Boolean expressions , and the logical IF statement as an alternative to the arithmetic IF statement. FORTRAN IV was eventually released in 1962, first for

SECTION 50

#1732786996267

3692-399: The style of some publications, like The New Yorker and The Economist , is to use small caps for acronyms and initialisms longer than three letters —thus "U.S." and "W.H.O." in normal caps but " nato " in small caps. The initialisms ad , ce , am , and pm are sometimes typeset in small caps. In printed plays small caps are used for stage directions and

3763-738: The tag pcap to indicate how to transform lower-case letters to petite caps, and the tag c2pc to indicate how to transform upper-case letters to petite caps. Desktop publishing applications, as well as web browsers, can use these features to display petite caps. However, only a few currently do so. LibreOffice can use the fontname:pcap=1 method. Professional desktop publishing applications supporting genuine small caps include Quark XPress, and Adobe Creative Suite applications. Most word processing applications, including Microsoft Word and Pages , do not automatically substitute true small caps when working with OpenType fonts that include them, instead generating scaled ones. For these applications it

3834-461: The time, and sometimes used these capitals to set headings in his printing; as a result these headings were in all caps, but in capitals from a smaller font than the body text type. The idea caught on in France, where small capitals were used by Simon de Colines , Robert Estienne and Claude Garamond . Johannes Philippus de Lignamine used small caps in the 1470s, but apparently was not copied at

3905-449: The time. Small capitals are not found in all font designs, as traditionally in printing they were primarily used within the body text of books and so are often not found in fonts that are not intended for this purpose, such as sans-serif types which historically were not preferred for book printing. Fonts in Use reports that Gert Wunderlich 's Maxima (1970), for Typoart , was "maybe

3976-464: The top ten languages in the TIOBE index , a measure of the popularity of programming languages. The first manual for FORTRAN describes it as a Formula Translating System , and printed the name with small caps , Fortran . Other sources suggest the name stands for Formula Translator , or Formula Translation . Early IBM computers did not support lowercase letters, and the names of versions of

4047-484: The variables start with the letter "I". The name of a variable must start with a letter and can continue with both letters and digits, up to a limit of six characters in FORTRAN II. If A, B, and C cannot represent the sides of a triangle in plane geometry, then the program's execution will end with an error code of "STOP 1". Otherwise, an output line will be printed showing the input values for A, B, and C, followed by

4118-535: The web page presentation language CSS using font-variant : small-caps . For example, the HTML renders as Since CSS styles the text, and no actual case transformation is applied, readers are still able to copy the normally-capitalized plain text from the web page as rendered by a browser. CSS3 can specify OpenType small caps (given the smcp feature in the font replaces glyphs with proper small caps glyphs) by using font-variant-caps : small-caps , which

4189-524: The whole of their fonts." (Bold type did not appear until the nineteenth century.) In 1956, Hugh Williamson 's textbook Methods of Book Design noted that "one of the most conspicuous defects" of contemporary book faces was that they did not generally feature italic small capitals: "these would certainly be widely used if they were generally available". Exceptions available at the time were Linotype's Pilgrim , Janson and their release of Monotype Garamond , and from Monotype Romulus . More have appeared in

4260-462: The word Adonai in the original Hebrew, but the small caps " Lord " corresponds to the use of Yahweh in the original; in some versions the compound "Lord God " represents the Hebrew compound Adonai Yahweh . In zoological and botanical nomenclature, the small caps are occasionally used for genera and families. In computational complexity theory , a sub-field of computer science ,

4331-470: The zero in column 6 is treated as if it were a space (!), while 101010 DO101I = 1.101 was instead 10101 DO101I = 1.101 , the assignment of 1.101 to a variable called DO101I . Note the slight visual difference between a comma and a period. Hollerith strings , originally allowed only in FORMAT and DATA statements, were prefixed by a character count and the letter H (e.g., 26HTHIS IS ALPHANUMERIC DATA. ), allowing blanks to be retained within

SECTION 60

#1732786996267

4402-520: Was a minor revision, mostly to resolve some outstanding issues from the Fortran 90 standard. Nevertheless, Fortran 95 also added a number of extensions, notably from the High Performance Fortran specification: Small caps Well-designed small capitals are not simply scaled-down versions of normal capitals; they normally retain the same stroke weight as other letters and have a wider aspect ratio for readability. Typically,

4473-480: Was also standard-conforming under Fortran 90, and either standard should have been usable to define its behavior. A small set of features were identified as "obsolescent" and were expected to be removed in a future standard. All of the functionalities of these early-version features can be performed by newer Fortran features. Some are kept to simplify porting of old programs but many were deleted in Fortran 95. Fortran 95 , published officially as ISO/IEC 1539-1:1997,

4544-443: Was available (at least for the early IBM 1620 computer). Modern Fortran, and almost all later versions, are fully compiled, as done for other high-performance languages. The development of Fortran paralleled the early evolution of compiler technology , and many advances in the theory and design of compilers were specifically motivated by the need to generate efficient code for Fortran programs. The initial release of FORTRAN for

4615-430: Was divided into four fields, as described above. Two compilers of the time, IBM "G" and UNIVAC, allowed comments to be written on the same line as instructions, separated by a special character: "master space": V (perforations 7 and 8) for UNIVAC and perforations 12/11/0/7/8/9 (hexadecimal FF) for IBM. These comments were not to be inserted in the middle of continuation cards. Perhaps the most significant development in

4686-410: Was finally released as ISO/IEC standard 1539:1991 in 1991 and an ANSI Standard in 1992. In addition to changing the official spelling from FORTRAN to Fortran, this major revision added many new features to reflect the significant changes in programming practice that had evolved since the 1978 standard: Unlike the prior revision, Fortran 90 removed no features. Any standard-conforming FORTRAN 77 program

4757-439: Was originally developed by IBM . It first compiled correctly in 1958. Fortran computer programs have been written to support scientific and engineering applications, such as numerical weather prediction , finite element analysis , computational fluid dynamics , plasma physics , geophysics , computational physics , crystallography and computational chemistry . It is a popular language for high-performance computing and

4828-438: Was previously written in C . Development of the compiler by volunteer users continues and each new version of GCC incorporates better support for the latest language standards and bug fixes. Fortran Fortran ( / ˈ f ɔːr t r æ n / ; formerly FORTRAN ) is a third generation , compiled , imperative programming language that is especially suited to numeric computation and scientific computing . Fortran

4899-408: Was provided for the IBM 1401 computer by an innovative 63-phase compiler that ran entirely in its core memory of only 8000 (six-bit) characters. The compiler could be run from tape, or from a 2200-card deck; it used no further tape or disk storage. It kept the program in memory and loaded overlays that gradually transformed it, in place, into executable form, as described by Haines. This article

4970-482: Was reprinted, edited, in both editions of Anatomy of a Compiler and in the IBM manual "Fortran Specifications and Operating Procedures, IBM 1401". The executable form was not entirely machine language ; rather, floating-point arithmetic, sub-scripting, input/output, and function references were interpreted, preceding UCSD Pascal P-code by two decades. GOTRAN , a simplified, interpreted version of FORTRAN I (with only 12 statements not 32) for "load and go" operation

5041-489: Was used originally (and optionally) to give branch probabilities for the three branch cases of the arithmetic IF statement. It could also be used to suggest how many iterations a DO loop might run. The first FORTRAN compiler used this weighting to perform at compile time a Monte Carlo simulation of the generated code, the results of which were used to optimize the placement of basic blocks in memory—a very sophisticated optimization for its time. The Monte Carlo technique

#266733