Fortran

Fortran (anteriormente FORTRAN) é uma linguagem de programação imperativa compilada de propósito geral que é especialmente adequada para computação numérica e computação científica.

Fortran foi originalmente desenvolvido pela IBM na década de 1950 para aplicações científicas e de engenharia e, subsequentemente, passou a dominar a computação científica. Está em uso há mais de seis décadas em áreas computacionalmente intensivas, como previsão numérica do tempo, análise de elementos finitos, dinâmica de fluidos computacional, geofísica, física computacional, cristalografia e química computacional. É uma linguagem popular para computação de alto desempenho e é usada para programas que comparam e classificam os supercomputadores mais rápidos do mundo.

A instalação do supercomputador IBM Blue Gene/P em 2007 no Argonne Leadership Angela Yang Computing Facility localizado no Argonne National Laboratory, em Lemont, Illinois, EUA

O design do Fortran foi a base para muitas outras linguagens de programação, especialmente BASIC e ALGOL. Mas o próprio Fortran evoluiu através de inúmeras versões e dialetos, adicionando extensões enquanto mantém a compatibilidade com as versões anteriores. Versões sucessivas adicionaram suporte para programação estruturada e processamento de dados baseados em caracteres (FORTRAN 77), programação de matrizes, programação modular e programação genérica (Fortran 90), Fortran de alto desempenho (Fortran 95), programação orientada a objetos (Fortran 2003), programação simultânea (Fortran 2008) e capacidades nativas de computação paralela (Coarray Fortran 2008/2018).

Árvore de genealogia FORTRAN e COBOL

Desde agosto de 2021, o Fortran está classificado entre as quinze principais linguagens no índice TIOBE, uma medida da popularidade das linguagens de programação.

Nomeando

O primeiro manual para FORTRAN o descreve como um Sistema de Tradução de Fórmulas, e imprimiu o nome com letras minúsculas, FORTRAN. Outras fontes sugerem que o nome significa Formula Translator, ou Formula Translation. Os primeiros computadores IBM não suportavam letras minúsculas e os nomes das versões do idioma através do FORTRAN 77 eram geralmente escritos em letras maiúsculas (FORTRAN 77 foi a última versão em que o conjunto de caracteres Fortran incluía apenas letras maiúsculas). Os padrões oficiais de linguagem para Fortran referem-se à linguagem como "Fortran" com limites iniciais desde Fortran 90.

Origens

John Backus (1924-2007) propôs o projeto FORTRAN em dezembro de 1953 e recebeu o A.M. Turing Award em 1977.

No final de 1953, John W. Backus apresentou uma proposta a seus superiores na IBM para desenvolver uma alternativa mais prática à linguagem assembly para programar seu computador mainframe IBM 704. Costas' A equipe histórica do FORTRAN consistia nos programadores Richard Goldberg, Sheldon F. Best, Harlan Herrick, Peter Sheridan, Roy Nutt, Robert Nelson, Irving Ziller, Harold Stern, Lois Haibt e David Sayre. Seus conceitos incluíam entrada mais fácil de equações em um computador, uma ideia desenvolvida por J. Halcombe Laning e demonstrada no sistema Laning e Zierler de 1952.

O sistema de codificação automático Fortran para IBM 704 (15 de outubro de 1956), o primeiro manual de referência do programador para Fortran

Um rascunho de especificação para O IBM Mathematical Formula Translating System foi concluído em novembro de 1954. O primeiro manual para FORTRAN apareceu em outubro de 1956, com o primeiro compilador FORTRAN entregue em abril de 1957. Este foi o primeiro compilador otimizado, porque os clientes relutavam em usar uma linguagem de programação de alto nível, a menos que seu compilador pudesse gerar código com desempenho próximo ao da linguagem assembly codificada manualmente.

Embora a comunidade estivesse cética de que esse novo método pudesse superar a codificação manual, ele reduziu o número de instruções de programação necessárias para operar uma máquina por um fator de 20 e rapidamente ganhou aceitação. John Backus disse durante uma entrevista em 1979 para Think, a revista para funcionários da IBM: “Muito do meu trabalho veio de ser preguiçoso. Eu não gostava de escrever programas, então, quando estava trabalhando no IBM 701, escrevendo programas para computar trajetórias de mísseis, comecei a trabalhar em um sistema de programação para facilitar a escrita de programas."

A linguagem foi amplamente adotada por cientistas para escrever programas numericamente intensivos, o que incentivou os criadores de compiladores a produzir compiladores que pudessem gerar códigos mais rápidos e eficientes. A inclusão de um tipo de dado de número complexo na linguagem tornou o Fortran especialmente adequado para aplicações técnicas, como engenharia elétrica.

Em 1960, versões do FORTRAN estavam disponíveis para os computadores IBM 709, 650, 1620 e 7090. Significativamente, a crescente popularidade do FORTRAN estimulou fabricantes de computadores concorrentes a fornecer compiladores FORTRAN para suas máquinas, de modo que em 1963 existiam mais de 40 compiladores FORTRAN. Por essas razões, o FORTRAN é considerado a primeira linguagem de programação multiplataforma amplamente utilizada.

O desenvolvimento do Fortran acompanhou a evolução inicial da tecnologia de compiladores, e muitos avanços na teoria e no design de compiladores foram especificamente motivados pela necessidade de gerar código eficiente para programas Fortran.

FORTRAN

A versão inicial do FORTRAN para o IBM 704 continha 32 instruções, incluindo:

• DIMENSION e EQUIVALENCE declarações
• Declarações de atribuição
• Declaração IF aritmética de três vias, que passou o controle para um dos três locais no programa dependendo se o resultado da declaração aritmética foi negativo, zero ou positivo
• IF declarações para verificar exceções (ACCUMULATOR OVERFLOW, QUOTIENT OVERFLOWe DIVIDE CHECK); e IF declarações para manipular interruptores de sentido e luzes de sentido
• GO TO, computado GO TO, ASSIGN, e atribuído GO TO
• DO loops
• Formatado I/O: FORMAT, READ, READ INPUT TAPE, WRITE, WRITE OUTPUT TAPE, PRINTe PUNCH
• I/O não formatado: READ TAPE, READ DRUM, WRITE TAPEe WRITE DRUM
• Outros I/O: END FILE, REWINDe BACKSPACE
• PAUSE, STOPe CONTINUE
• FREQUENCY declaração (para fornecer dicas de otimização para o compilador).

A aritmética se A instrução foi remanescente de (mas não é prontamente implementável por) uma instrução de comparação de três vias (CAS-Acumulador de Compare com armazenamento) disponível no 704. A instrução forneceu a única maneira de comparar números-testando sua diferença, com um risco de transbordamento. Essa deficiência foi posteriormente superada por "lógico " Instalações introduzidas em Fortran IV.

A instrução MW-Highlight-Lang-text MW-Highlight-Lang-Text MW-Highlight-Lang-Text MW-Content-LTR "ID =" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "style =" "" Dir = "Ltr"> Frequency foi usado originalmente (e opcionalmente) para fornecer probabilidades de ramificação para os três casos de ramificação da declaração da aritmética. O primeiro compilador Fortran usou essa ponderação para executar no momento da compilação uma simulação de Monte Carlo do código gerado, cujos resultados foram usados para otimizar a colocação de blocos básicos na memória - uma otimização muito sofisticada para seu tempo. A técnica de Monte Carlo está documentada em Backus et al.

A unidade fundamental do programa é o bloco básico; um bloco básico é um trecho do programa que tem um ponto de entrada e um ponto de saída. O objetivo da seção 4 é preparar para a seção 5 uma tabela de antecessores (Tabela PRED) que enumera os blocos básicos e listas para cada bloco básico cada um dos blocos básicos que podem ser seu antecessor imediato no fluxo, juntamente com a frequência absoluta de cada link de bloco básico. Esta tabela é obtida executando o programa uma vez na moda de Monte-Carlo, em que o resultado de transferências condicionais decorrentes de declarações do tipo IF e computados GO TO é determinado por um gerador de números aleatórios adequadamente ponderado de acordo com quaisquer declarações FREQUENCY foram fornecidas.

O primeiro compilador FORTRAN relatou informações de diagnóstico interrompendo o programa quando um erro foi encontrado e exibindo um código de erro em seu console. Esse código pode ser consultado pelo programador em uma tabela de mensagens de erro no manual do operador, fornecendo uma breve descrição do problema. Posteriormente, foi incorporada uma sub-rotina de tratamento de erros para lidar com erros do usuário, como divisão por zero, desenvolvida pela NASA, informando aos usuários qual linha de código continha o erro.

Layout fixo e cartões perfurados

Código FORTRAN em um cartão perfurado, mostrando os usos especializados das colunas 1–5, 6 e 73–80

Uma reprodução de um formulário de codificação FORTRAN, impresso em papel e destinado a ser usado por programadores para preparar programas para perfurar cartões por operadores keypunch. Agora obsoleto.

Antes do desenvolvimento de arquivos de disco, editores de texto e terminais, os programas eram mais frequentemente inseridos em um teclado do teclado em cartões perfurados de 80 colunas, uma linha em um cartão. O baralho resultante de cartas seria alimentado em um leitor de cartas para ser compilado. Os códigos de cartão perfurados não incluíam cartas de baixo caso ou muitos caracteres especiais, e versões especiais do IBM 026 Keypunch foram oferecidas que imprimiriam corretamente os caracteres especiais reimpados usados no Fortran.

Refletindo a prática de entrada do cartão perfurado, os programas fortran foram originalmente escritos em um formato de coluna fixa, com as primeiras 72 colunas lidas em doze palavras de 36 bits.

uma carta " c " Na coluna 1, o cartão inteiro era tratado como um comentário e ignorado pelo compilador. Caso contrário, as colunas do cartão foram divididas em quatro campos:

• 1 a 5 foram o campo da etiqueta: uma sequência de dígitos aqui foi tomada como um rótulo para uso em DO ou demonstrações de controle, como GO TO e IF, ou para identificar uma declaração FORMAT referida em uma declaração WRITE ou LER. Os zeros principais são ignorados e 0 não é um número de etiqueta válido.
• 6 era um campo de continuação: um personagem diferente de um branco ou um zero aqui fez com que o cartão fosse tomado como uma continuação da declaração no cartão anterior. Os cartões de continuação foram geralmente numerados 1, 2, etc. e o cartão inicial pode, portanto, ter zero em sua coluna de continuação - que não é uma continuação de seu cartão precedente.
• 7 a 72 serviu como campo de declaração.
• 73 a 80 foram ignorados (o leitor de cartões do IBM 704 só usou 72 colunas).

As colunas 73 a 80 podem, portanto, ser usadas para informações de identificação, como perfurar um número de sequência ou texto, que pode ser usado para reordenar os cartões se uma pilha de cartões for descartada; embora na prática isso fosse reservado para programas de produção estáveis. Um IBM 519 pode ser usado para copiar um deck de programa e adicionar números de sequência. Alguns compiladores anteriores, por exemplo, o IBM 650's, tinham restrições adicionais devido a limitações em seus leitores de cartão. Os keypunches podiam ser programados para tabular na coluna 7 e pular após a coluna 72. Compiladores posteriores relaxaram a maioria das restrições de formato fixo e o requisito foi eliminado no padrão Fortran 90.

Dentro do campo de instrução, os caracteres de espaço em branco (em branco) foram ignorados fora de um literal de texto. Isso permitia omitir espaços entre os tokens para concisão ou incluir espaços nos identificadores para maior clareza. Por exemplo, AVG OF X era um identificador válido, equivalente a AVGOFX e 101010DO101I=1,101 era uma declaração válida, equivalente a 10101 DO 101 I = 1, 101 porque o zero na coluna 6 é tratado como se fosse um espaço (!), enquanto 101010DO101I= 1.101 era 10101 DO101I = 1.101 , a atribuição de 1.101 a uma variável chamada DO101I. Observe a ligeira diferença visual entre uma vírgula e um ponto.

As strings Hollerith, originalmente permitidas apenas em declarações FORMAT e DATA, eram precedidas por uma contagem de caracteres e a letra H (por exemplo, 26HTHIS IS ALPHANUMERIC DATA.), permitindo que os espaços em branco sejam retidos na cadeia de caracteres. Erros de contagem eram um problema.

Evolução

FORTRAN II

O FORTRAN II da IBM apareceu em 1958. O principal aprimoramento foi oferecer suporte à programação procedural, permitindo sub-rotinas e funções escritas pelo usuário que retornavam valores com parâmetros passados por referência. A instrução COMMON fornecia uma maneira de as sub-rotinas acessarem variáveis comuns (ou globais). Seis novas declarações foram introduzidas:

• SUBROUTINE, FUNCTIONe END
• CALL e RETURN
• COMMON

Nos próximos anos, o Fortran II adicionou suporte para o Precisão dupla e Tipos de dados complexos .

Compiladores Fortran antecipados não suportaram recursão nas sub -rotinas. As arquiteturas iniciais de computadores não apoiaram nenhum conceito de pilha e, quando eles apoiaram diretamente as chamadas da sub -rotina, o local de retorno era frequentemente armazenado em um local fixo adjacente ao código da sub -rotina (por exemplo, o IBM 1130) ou um registro de máquina específico (IBM 360 e segs), que apenas permite a recursão se uma pilha for mantida pelo software e o endereço de retorno for armazenado na pilha antes que a chamada seja feita e restaurada após a chamada de retorno. Embora não estejam especificados no Fortran 77, muitos compiladores F77 suportaram a recursão como uma opção, e os mainframes de Burroughs, projetados com a recursão embutida, o fizeram por padrão. Tornou -se um padrão no Fortran 90 através da nova palavra -chave recursiva.

Programa simples para fortran II

Este programa, para a fórmula de Heron, lê dados em um carretel de fita contendo três números inteiros de 5 dígitos A, B e C como entrada. Não há " tipo " Declarações disponíveis: variáveis cujo nome começa com i, j, k, l, m ou n são " ponto fixo " (ou seja, números inteiros), caso contrário, ponto flutuante. Como os números inteiros devem ser processados neste exemplo, os nomes das variáveis começam com a letra " i 34; O nome de uma variável deve começar com uma letra e pode continuar com letras e dígitos, até um limite de seis caracteres no Fortran II. Se A, B e C não puderem representar os lados de um triângulo na geometria plana, a execução do programa terminará com um código de erro de Stop 1 -. Caso contrário, uma linha de saída será impressa mostrando os valores de entrada para A, B e C, seguidos pela área computada do triângulo como um número de ponto flutuante que ocupava dez espaços ao longo da linha de saída e mostrando 2 dígitos após o ponto decimal, o.2 em F10.2 da instrução Formato com o rótulo 601.

C ESPAÇO DE UM TRIANGEIRO COM UMA FUNÇÃO DE ROOT DE SQUARE STANDARDC INPUT - READER UNIT 5, INTEGER INPUTC OUTPUT - PRINTER UNIT 6, REAL OUTPUTC INPUT ERROR DISPLAY ERROR OUTPUT CODE 1 EM CONTROLO JOB  LER INP TA 5, 501, IA, IB, IC 501 FORMATIVA (3I5)C IA, IB, e posso não ser NEGATIVA ou ZEROC FURTHERMORE, O SUM de TWO lados de um TRIANGLEDeve ser melhor do que o outro lado, por isso, também sabemos.  IF (IA) 777, 777, 701 701 IF (IB) 777, 777, 702 702 IF (IC) 777, 777, 703 703 IF (IA+IB- Não.IC) 777, 777, 704 704 IF (IA+IC- Não.IB) 777, 777, 705 705 IF (IB+IC- Não.IA) 777, 777, 799 777 POLÍTICA 1FORMULA DE HERON CALCULARESPAÇO DA TRIANGLE 799 S = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = FLOAT (IA + IB + IC) / 2.0  ESPAÇO = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = SQRTF( S * (S - Não. FLOAT(IA) * (S - Não. FLOAT(IB) * + (S - Não. FLOAT(IC)  WRITE OUTROS TA 6, 601, IA, IB, IC, ESPAÇO 601 FORMATIVA (4H. H. H. A= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ,I5,5H. H. H. B= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ,I5,5H. H. H. C= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ,I5,8H. H. H. ESPAÇO= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ,F10.2, + 13H. H. H. SQUARE UNIDOS)  POLÍTICA  FIM

FORTRAN III para FORTRAN IV

A IBM também desenvolveu um FORTRAN III em 1958 que permitia o código de montagem inline entre outros recursos; no entanto, esta versão nunca foi lançada como um produto. Como o FORTRAN 704 e o FORTRAN II, o FORTRAN III incluía recursos dependentes da máquina que tornavam o código escrito nele inportável de máquina para máquina. As primeiras versões do FORTRAN fornecidas por outros fornecedores sofriam da mesma desvantagem.

FORTRAN foi fornecido para o computador IBM 1401 por um compilador inovador de 63 fases que rodava inteiramente em sua memória central de apenas 8.000 (seis bits) caracteres. O compilador pode ser executado a partir de uma fita ou de um baralho de 2200 cartas; não usava mais armazenamento em fita ou disco. Ele mantinha o programa na memória e carregava sobreposições que gradualmente o transformavam, no local, em forma executável, conforme descrito por Haines. Este artigo foi reimpresso, editado, em ambas as edições de Anatomy of a Compiler e no manual IBM "Fortran Specifications and Operating Procedures, IBM 1401". A forma executável não era inteiramente linguagem de máquina; em vez disso, aritmética de ponto flutuante, subscript, entrada/saída e referências de funções foram interpretadas, precedendo o código UCSD Pascal P por duas décadas.

A IBM posteriormente forneceu um compilador FORTRAN IV para a série 1400 de computadores.

A IBM iniciou o desenvolvimento do FORTRAN IV a partir de 1961, como resultado das demandas dos clientes. O FORTRAN IV removeu os recursos dependentes da máquina do FORTRAN II (como READ INPUT TAPE), adicionando novos recursos, como um tipo de dados LÓGICO, expressões booleanas lógicas e a instrução IF lógica como uma alternativa à aritmética Instrução IF. FORTRAN IV foi finalmente lançado em 1962, primeiro para o computador IBM 7030 ("Stretch"), seguido por versões para o IBM 7090, IBM 7094 e, posteriormente, para o IBM 1401 em 1966.

Em 1965, FORTRAN IV deveria estar em conformidade com o padrão desenvolvido pelo Grupo de Trabalho FORTRAN da American Standards Association X3.4.3.

Entre 1966 e 1968, a IBM ofereceu vários compiladores FORTRAN IV para seu System/360, cada um nomeado por letras que indicavam a quantidade mínima de memória que o compilador precisava para executar. As letras (F, G, H) correspondem aos códigos usados com os números de modelo do System/360 para indicar o tamanho da memória, cada incremento de letra sendo um fator de dois maior:

• 1966: FORTRAN IV F para DOS/360 (64K bytes)
• 1966: FORTRAN IV G para OS/360 (128K bytes)
• 1968: FORTRAN IV H para OS/360 (256K bytes)

A Digital Equipment Corporation manteve o DECSYSTEM-10 Fortran IV (F40) para PDP-10 de 1967 a 1975

Por volta dessa época, FORTRAN IV começou a se tornar uma importante ferramenta educacional e implementações como WATFOR e WATFIV da Universidade de Waterloo foram criadas para simplificar os complexos processos de compilação e vinculação de compiladores anteriores.

FORTRAN 66

Talvez o desenvolvimento mais significativo no início da história do FORTRAN tenha sido a decisão da American Standards Association (agora American National Standards Institute (ANSI)) de formar um comitê patrocinado pela Business Equipment Manufacturers Association (BEMA) para desenvolver um American Standard Fortran. Os dois padrões resultantes, aprovados em março de 1966, definiram duas linguagens, FORTRAN (baseado em FORTRAN IV, que serviu como padrão de fato) e FORTRAN básico (baseado em em FORTRAN II, mas despojado de seus recursos dependentes da máquina). O FORTRAN definido pelo primeiro padrão, oficialmente denominado X3.9-1966, tornou-se conhecido como FORTRAN 66 (embora muitos continuassem a denominá-lo FORTRAN IV, a linguagem na qual o padrão foi amplamente baseado). FORTRAN 66 tornou-se efetivamente a primeira versão padrão da indústria do FORTRAN. FORTRAN 66 incluiu:

• Programa principal, SUBROUTINE, FUNCTIONe BLOCK DATA unidades de programa
• INTEGER, REAL, DOUBLE PRECISION, COMPLEXe LOGICAL tipos de dados
• COMMON, DIMENSIONe EQUIVALENCE declarações
• DATA declaração para especificar valores iniciais
• Intrínseca e EXTERNAL (por exemplo, biblioteca) funções
• Declaração de atribuição
• GO TO, computado GO TO, designado GO TOe ASSIGN declarações
• Lógica IF e aritmética (três vias) IF declarações
• DO declaração de loop
• READ, WRITE, BACKSPACE, REWINDe ENDFILE declarações para I/O sequencial
• FORMAT declaração e formato atribuído
• CALL, RETURN, PAUSEe STOP declarações
• Constantes de Hollerith em DATA e FORMAT declarações, e como argumentos para procedimentos
• Identificadores de até seis caracteres de comprimento
• Linhas de comentário
• END linha de linha

FORTRAN 77

Programa FORTRAN-77 com saída de compilador, escrito em um CDC 175 na RWTH Aachen University, Alemanha, em 1987

4.3 BSD para a Digital Equipment Corporation (DEC) VAX, exibindo o manual para compilador FORTRAN 77 (f77)

Após o lançamento do padrão FORTRAN 66, os fornecedores de compiladores introduziram várias extensões para o Padrão Fortran, levando o comitê ANSI X3J3 em 1969 a começar a trabalhar na revisão do padrão de 1966, sob o patrocínio do CBEMA, the Computer Associação de Fabricantes de Equipamentos Comerciais (anteriormente BEMA). Os rascunhos finais desse padrão revisado circularam em 1977, levando à aprovação formal do novo padrão FORTRAN em abril de 1978. O novo padrão, chamado FORTRAN 77 e oficialmente denotado como X3.9-1978, adicionou uma série de recursos significativos para resolver muitas das deficiências do FORTRAN 66:

• bloco IF e END IF declarações, com opcional ELSE e ELSE IF Cláusulas, para fornecer melhor suporte de linguagem para programação estruturada
• DO extensões de loop, incluindo expressões de parâmetros, incrementos negativos e contagem de viagens zero
• OPEN, CLOSEe INQUIRE declarações para melhor capacidade de I/O
• Arquivo de acesso direto I/O
• IMPLICIT declaração, para substituir as convenções implícitas que as variáveis não declaradas são INTEGER se seu nome começa com I, J, K, L, M ou N (e REAL de outra forma)
• CHARACTER tipo de dados, substituindo cadeias de caracteres Hollerith por instalações vastamente expandidas para entrada de caracteres e saída e processamento de dados baseados em caracteres
• PARAMETER declaração para especificar constantes
• SAVE declaração para variáveis locais persistentes
• Nomes genéricos para funções intrínsecas (p. ex. SQRT também aceita argumentos de outros tipos, como COMPLEX ou REAL*16).
• Um conjunto de intrínsecos (LGE, LGT, LLE, LLT) para lexical comparação de cordas, com base na sequência de colagem ASCII. (Estas funções do ASCII foram exigidas pelo Departamento de Defesa dos EUA, em seu voto de aprovação condicional.)

Nesta revisão do padrão, vários recursos foram removidos ou alterados de uma maneira que pudesse invalidar programas de conformidade anterior. (a remoção era a única alternativa permitida ao x3J3 naquele momento, uma vez que o conceito de depreciação "ainda não estava disponível para os padrões da ANSI.) Enquanto a maioria dos 24 itens da lista de conflitos (consulte o Apêndice A2 de X3.9-1978) abordou brechas ou casos patológicos permitidos pelo padrão anterior, mas raramente usado, um pequeno número de recursos específicos foi deliberadamente removido, como:

• Constantes Hollerith e dados Hollerith, como GREET = 12HHELLO THERE!
• Lendo em um descritor de edição H (campo Holerith) em uma especificação FORMAT
• Overindexing de limites de array por subscripts

    DIMENSÃO A(10.,5)  Y= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = A(11,1)

• Transferência de controle fora e de volta para a gama de um loop DO (também conhecido como "Extended Range")

Transição para ANSI Standard Fortran

O desenvolvimento de um padrão revisado para suceder o FORTRAN 77 seria repetidamente adiado, pois o processo de padronização lutava para acompanhar as rápidas mudanças na prática de computação e programação. Enquanto isso, como o "Fortran padrão" por quase quinze anos, o FORTRAN 77 se tornaria o dialeto historicamente mais importante.

Uma extensão prática importante para FORTRAN 77 foi o lançamento de MIL-STD-1753 em 1978. Esta especificação, desenvolvida pelo Departamento de Defesa dos Estados Unidos, padronizou vários recursos implementados pela maioria dos compiladores FORTRAN 77, mas não incluídos no ANSI padrão FORTRAN 77. Esses recursos acabariam sendo incorporados ao padrão Fortran 90.

• DO WHILE, EXIT, CYCLEe END DO declarações
• INCLUDE declaração
• IMPLICIT NONE variante do IMPLICIT declaração
• Funções intrínsecas de manipulação de bits, baseadas em funções semelhantes incluídas no Industrial Real-Time Fortran (ANSI/ISA S61.1 (1976)

O padrão IEEE 1003.9 POSIX, lançado em 1991, forneceu um meio simples para programadores FORTRAN 77 emitirem chamadas de sistema POSIX. Mais de 100 chamadas foram definidas no documento - permitindo acesso a controle de processo compatível com POSIX, manipulação de sinal, controle de sistema de arquivos, controle de dispositivo, apontamento de procedimento e E/S de fluxo de maneira portátil.

Fortran 90

O muito atrasado sucessor do FORTRAN 77, informalmente conhecido como Fortran 90 (e antes disso, Fortran 8X), foi finalmente lançado como padrão ISO/IEC 1539:1991 em 1991 e um padrão ANSI em 1992. Além de alterar a ortografia oficial de FORTRAN para Fortran, esta grande revisão adicionou muitos novos recursos para refletir as mudanças significativas na prática de programação que evoluíram desde o padrão de 1978:

• Entrada de fonte de forma livre removeu a necessidade de pular as primeiras seis posições de caracteres antes de entrar em declarações.
• Palavras-chave da Lowercase Fortran
• Identificadores de até 31 caracteres de comprimento (No padrão anterior, foram apenas seis caracteres).
• Comentários inline
• Capacidade de operar em arrays (ou seções de array) como um todo, assim simplificando significativamente as computaçãos de matemática e engenharia.
  • instruções de atribuição de matrizes inteiras, parciais e mascaradas e expressões de array, tais como X(1:N)=R(1:N)*COS(A(1:N))
  • WHERE declaração para atribuição de array seletivo
  • constantes e expressões,
  • funções com valor de array definido pelo usuário e construtores de array.
• RECURSOS
• Módulos, para agrupar procedimentos e dados relacionados, e torná-los disponíveis para outras unidades do programa, incluindo a capacidade de limitar a acessibilidade a apenas partes específicas do módulo.
• Um mecanismo de transição de argumentos muito melhorado, permitindo que as interfaces sejam verificadas no tempo de compilação
• Interfaces escritas pelo usuário para procedimentos genéricos
• Sobrecarga do operador
• Tipos de dados derivados (estruturados)
• Nova sintaxe de declaração de tipo de dados, para especificar o tipo de dados e outros atributos de variáveis
• Alocação dinâmica da memória por meio da ALLOCATABLE atributo e o ALLOCATE e DEALLOCATE declarações
• Atributo POINTER, atribuição de ponteiro e NULLIFY declaração para facilitar a criação e manipulação de estruturas dinâmicas de dados
• Construções de loop estruturado, com um END DO declaração para terminação de loop, e EXIT e CYCLE declarações para terminar normal DO iterações de loop em uma maneira ordenada
• SELECT... CASE construção para seleção multi-way
• Especificação portátil de precisão numérica sob o controle do usuário
• Procedimentos intrínsecos novos e aprimorados.

Obsolescência e exclusões

Ao contrário da revisão anterior, o Fortran 90 não removeu nenhum recurso. Qualquer programa em FORTRAN 77 em conformidade com o padrão também estava em conformidade com o padrão em Fortran 90, e qualquer um dos padrões deveria ser usado para definir seu comportamento.

Um pequeno conjunto de recursos foi identificado como "obsolescente" e esperava-se que fossem removidos em um padrão futuro. Todas as funcionalidades desses recursos de versão inicial podem ser executadas por recursos Fortran mais recentes. Alguns são mantidos para simplificar a portabilidade de programas antigos, mas muitos foram excluídos no Fortran 95.

" Olá, mundo! " Exemplo

programa Olá. impressão *, "Olá, Mundo!"programa final Olá.

fortran 95

Fortran 95 , publicado oficialmente como ISO/IEC 1539-1: 1997, foi uma revisão menor, principalmente para resolver alguns problemas pendentes do padrão Fortran 90. No entanto, o Fortran 95 também adicionou uma série de extensões, principalmente a partir da especificação Fortran de alto desempenho:

• FORALL e aninhado WHERE construções para ajudar a vetorização
• Definido pelo usuário PURE e ELEMENTAL procedimentos
• Inicialização padrão de componentes de tipo derivado, incluindo inicialização de ponteiro
• Expandiu a capacidade de usar expressões de inicialização para objetos de dados
• Inicialização dos ponteiros NULL()
• Claramente definido que ALLOCATABLE arrays são automaticamente negociados quando eles saem do escopo.

Várias funções intrínsecas foram estendidas (por exemplo, um dim O argumento foi adicionado ao intrínseco maxloc).

Vários recursos considerados no Fortran 90 como "obsolecentes" foram removidos do Fortran 95:

• DO instruções usando REAL e DOUBLE PRECISION variáveis índice
• Ramo para um END IF declaração de fora de seu bloco
• PAUSE declaração
• ASSIGN e atribuído GO TO declaração e especificadores de formato atribuídos
• H Hollerith edit descriptor.

Um suplemento importante para o Fortran 95 foi o relatório técnico ISO TR-15581: Enhanced Data Type Facilities, informalmente conhecido como Allocatable TR. Esta especificação definiu o uso aprimorado de Arrays ALOCÁVEIS, antes da disponibilidade do Fortran 2003 completo compiladores Fortran compatíveis. Tais usos incluem matrizes ALLOCATABLE como componentes de tipo derivado, em listas de argumentos fictícios de procedimento e como valores de retorno de função. (ALLOCATABLE arrays são preferíveis a POINTER arrays baseados em ALLOCATABLE arrays são garantidos pelo Fortran 95 para serem desalocados automaticamente quando saem do escopo, eliminando a possibilidade de vazamento de memória. Além disso, os elementos de arrays alocáveis são contíguos e o aliasing não é um problema para otimização de referências de array, permitindo que os compiladores gerem código mais rápido do que no caso de ponteiros.)

Outro suplemento importante para o Fortran 95 foi o relatório técnico ISO TR-15580: Tratamento de exceção de ponto flutuante, informalmente conhecido como IEEE TR. Esta especificação definiu o suporte para Aritmética de ponto flutuante IEEE e manipulação de exceção de ponto flutuante.

Compilação condicional e strings de comprimento variável

Além do obrigatório "Idioma base" (definido na ISO/IEC 1539-1: 1997), a linguagem Fortran 95 também inclui dois módulos opcionais:

• Cordas de caracteres de comprimento variável (ISO/IEC 1539-2: 2000)
• Colecção condicional (ISO/IEC 1539-3: 1998)

que, juntos, compõem a Norma Internacional de várias partes (ISO/IEC 1539).

De acordo com os desenvolvedores de padrões, "as partes opcionais descrevem recursos independentes que foram solicitados por um corpo substancial de usuários e/ou implementadores, mas que não são considerados de generalidade suficiente para que sejam obrigatório em todos os compiladores Fortran em conformidade com o padrão." No entanto, se um Fortran em conformidade com o padrão fornecer tais opções, então elas "devem ser fornecidas de acordo com a descrição desses recursos na Parte apropriada do Padrão".

Fortran moderno

A linguagem definida pelos padrões do século XXI, em particular por causa de sua incorporação de suporte de programação orientada a objetos e, posteriormente, Coarray Fortran, é frequentemente chamada de 'Modern Fortran', e o termo é cada vez mais utilizado na literatura.

Fortran 2003

Fortran 2003, publicado oficialmente como ISO/IEC 1539-1:2004, é uma grande revisão que apresenta muitos novos recursos. Um resumo abrangente dos novos recursos do Fortran 2003 está disponível no site oficial do Fortran Working Group (ISO/IEC JTC1/SC22/WG5).

A partir desse artigo, as principais melhorias para esta revisão incluem:

• Melhorias de tipo derivados: tipos derivados parametrizados, controle melhorado de acessibilidade, construtores de estrutura melhorados e finalizadores
• Suporte de programação orientado a objetos: extensão e herança de tipo, polimorfismo, alocação de tipo dinâmico e procedimentos de digitação, fornecendo suporte completo para tipos de dados abstratos
• Melhorias de manipulação de dados: componentes alocatáveis (incorporando TR 15581), parâmetros de tipo diferido, atributo VOLATILE, especificação de tipo explícito em construtores de matrizes e alocar declarações, aprimoramentos de ponteiros, expressões de inicialização estendidas e procedimentos intrínsecos aprimorados
• Melhorias de entrada/saída: transferência assíncrona, acesso a fluxo, operações de transferência especificadas pelo usuário para tipos derivados, controle especificado pelo usuário de arredondamento durante conversões de formato, constantes nomeadas para unidades pré-conectadas, o FLUSH declaração, regularização de palavras-chave e acesso a mensagens de erro
• Pontos de procedimento
• Suporte para IEEE manuseio de exceção aritmética e ponto flutuante (incorporando TR 15580)
• Interoperabilidade com a linguagem de programação C
• Suporte para uso internacional: acesso a caracteres ISO 10646 4-byte e escolha de decimal ou vírgula em entrada/saída numérica formatada
• Integração aprimorada com o sistema operacional host: acesso a argumentos de linha de comando, variáveis de ambiente e mensagens de erro do processador

Um suplemento importante para o Fortran 2003 foi o relatório técnico ISO TR-19767: Enhanced module features in Fortran. Este relatório forneceu submódulos, que tornam os módulos Fortran mais semelhante aos módulos Modula-2. Eles são semelhantes às subunidades infantis privadas de Ada. Isso permite que a especificação e a implementação de um módulo sejam expressas em unidades de programa separadas, o que melhora o empacotamento de grandes bibliotecas, permite a preservação de segredos comerciais ao publicar interfaces definitivas e evita cascatas de compilação.

Fortran 2008

ISO/IEC 1539-1:2010, informalmente conhecido como Fortran 2008, foi aprovado em setembro de 2010. Assim como o Fortran 95, esta é uma pequena atualização, incorporando esclarecimentos e correções ao Fortran 2003, bem como introduzindo alguns novos recursos. Os novos recursos incluem:

• Sub-módulos – instalações de estruturação adicionais para módulos; substitui ISO/IEC TR 19767:2005
• Coarray Fortran – um modelo de execução paralelo
• A construção DO CONCURRENT – para iterações de loop sem interdependências
• O atributo CONTIGUOUS – para especificar restrições de layout de armazenamento
• A construção BLOCK – pode conter declarações de objetos com escopo de construção
• Componentes alocatáveis recursivos – como uma alternativa aos ponteiros recursivos em tipos derivados

A versão final do padrão internacional (FDIS) está disponível como documento N1830.

Um suplemento ao Fortran 2008 é a Especificação Técnica (TS) 29113 da Organização Internacional para Padronização (ISO) sobre Interoperabilidade adicional do Fortran com C, que foi submetida à ISO em maio de 2012 para aprovação. A especificação adiciona suporte para acessar o descritor de matriz de C e permite ignorar o tipo e a classificação dos argumentos.

Fortran 2018

A revisão mais recente da linguagem (Fortran 2018) foi anteriormente referida como Fortran 2015. É uma revisão significativa e foi lançada em 28 de novembro de 2018.

Fortran 2018 incorpora duas Especificações Técnicas publicadas anteriormente:

• ISO/IEC TS 29113:2012 Interoperabilidade adicional com C
• ISO/IEC TS 18508:2015 Características paralelas adicionais em Fortran

Mudanças adicionais e novos recursos incluem suporte para ISO/IEC/IEEE 60559:2011 (a versão do padrão de ponto flutuante IEEE antes da última revisão secundária IEEE 754–2019), entrada/saída hexadecimal, aprimoramentos IMPLICIT NONE e outros mudanças.

Fortran 2023

A publicação da nova norma está prevista para julho de 2023.

Recursos de linguagem

Uma descrição completa dos recursos da linguagem Fortran trazidos pelo Fortran 95 é abordada no artigo relacionado, Recursos da linguagem Fortran 95. As versões de linguagem definidas por padrões posteriores são muitas vezes referidas coletivamente como 'Modern Fortran' e são descritos na literatura.

Ciência e engenharia

General relativistic magnetohidrodinâmica Simulação de Fortran de acreção de buraco negro usando o código BHAC com malha adaptativa cartesiana

Fluxo em torno de um cilindro computado em Fortran com OpenCL (Universidade de Bristol, Reino Unido)

Temperatura da superfície da velocidade e do mar nos oceanos, computada com o código NMO Fortran (Nucleus for European Modeling of the Ocean, https://www.nemo-ocean.eu) no Centro de Supercomputação de Barcelona (2020).

Embora um artigo de jornal de 1968 dos autores do BASIC já descreva o FORTRAN como "antiquado", a partir de 2022 os programas foram escritos em Fortran por mais de seis décadas e há um vasto corpo de software Fortran no uso diário em todas as comunidades científicas e de engenharia. Jay Pasachoff escreveu em 1984 que “estudantes de física e astronomia simplesmente precisam aprender FORTRAN”. Tanto existe em FORTRAN que parece improvável que os cientistas mudem para Pascal, Modula-2 ou qualquer outra coisa." Em 1993, Cecil E. Leith chamou o FORTRAN de "língua materna da computação científica", acrescentando que sua substituição por qualquer outra linguagem possível "pode permanecer uma esperança perdida".

É a linguagem principal para algumas das tarefas de supercomputação mais intensivas, como astronomia, modelagem climática, química computacional, economia computacional, dinâmica de fluidos computacional, física computacional, análise de dados, modelagem hidrológica, álgebra linear numérica e bibliotecas numéricas (LAPACK, IMSL e NAG), otimização, simulação de satélite, engenharia estrutural e previsão do tempo. Muitos dos benchmarks de ponto flutuante para avaliar o desempenho de novos processadores de computador, como os componentes de ponto flutuante dos benchmarks SPEC (por exemplo, CFP2006, CFP2017) são escritos em Fortran. Algoritmos matemáticos estão bem documentados em Receitas Numéricas.

Além disso, códigos mais modernos em ciência computacional geralmente usam grandes bibliotecas de programas, como METIS para particionamento de gráficos, PETSc ou Trilinos para recursos de álgebra linear, deal.II ou FEniCS para suporte a malhas e elementos finitos e outras bibliotecas genéricas. Desde o início dos anos 2000, muitas das bibliotecas de suporte amplamente usadas também foram implementadas em C e, mais recentemente, em C++. Por outro lado, linguagens de alto nível como Wolfram Language, MATLAB, Python e R tornaram-se populares em áreas específicas da ciência computacional. Consequentemente, uma fração crescente de programas científicos também é escrita nessas linguagens de script de alto nível. Por esse motivo, facilidades para interoperação com C foram adicionadas ao Fortran 2003 e aprimoradas pela especificação técnica ISO/IEC 29113, que foi incorporada ao Fortran 2018 para permitir uma interoperação mais flexível com outras linguagens de programação.

O software para as sondas Voyager 1 e Voyager 2 da NASA foi originalmente escrito em FORTRAN 5 e posteriormente portado para FORTRAN 77. Em 25 de setembro de 2013, parte do software ainda é escrita em Fortran e parte foi portada para C.

Portabilidade

A portabilidade era um problema no início porque não havia um padrão acordado - nem mesmo o manual de referência da IBM - e as empresas de computadores competiam para diferenciar suas ofertas de outras fornecendo recursos incompatíveis. Os padrões melhoraram a portabilidade. O padrão de 1966 forneceu uma sintaxe e semântica de referência, mas os fornecedores continuaram a fornecer extensões incompatíveis. Embora programadores cuidadosos estivessem percebendo que o uso de extensões incompatíveis causava problemas caros de portabilidade e, portanto, estavam usando programas como o The PFORT Verifier, não foi até depois do padrão de 1977, quando o National Bureau of Standards (agora NIST) publicou FIPS PUB 69, que os processadores adquiridos pelo governo dos EUA eram obrigados a diagnosticar extensões do padrão. Em vez de oferecer dois processadores, essencialmente todo compilador eventualmente tinha pelo menos uma opção para diagnosticar extensões.

As extensões incompatíveis não eram o único problema de portabilidade. Para cálculos numéricos, é importante levar em conta as características da aritmética. Isso foi abordado por Fox et al. no contexto do padrão de 1966 pela biblioteca PORT. As ideias nele contidas tornaram-se amplamente utilizadas e foram eventualmente incorporadas ao padrão de 1990 por meio de funções intrínsecas de investigação. A adoção generalizada (agora quase universal) do padrão IEEE 754 para aritmética binária de ponto flutuante essencialmente removeu esse problema.

O acesso ao ambiente de computação (por exemplo, linha de comando do programa, variáveis de ambiente, explicação textual das condições de erro) permaneceu um problema até ser resolvido pelo padrão de 2003.

Grandes coleções de software de biblioteca que poderiam ser descritas como sendo vagamente relacionadas a cálculos científicos e de engenharia, como bibliotecas gráficas, foram escritas em C e, portanto, o acesso a elas apresentava um problema de portabilidade. Isso foi resolvido pela incorporação da interoperabilidade C no padrão de 2003.

Agora é possível (e relativamente fácil) escrever um programa totalmente portátil em Fortran, mesmo sem recorrer a um pré-processador.

Variantes obsoletas

Até o padrão Fortran 66 ser desenvolvido, cada compilador suportava sua própria variante do Fortran. Alguns eram mais divergentes do mainstream do que outros.

O primeiro compilador Fortran definiu um alto padrão de eficiência para o código compilado. Esse objetivo dificultou a criação de um compilador, por isso geralmente era feito pelos fabricantes de computadores para dar suporte às vendas de hardware. Isso deixou um nicho importante: compiladores que eram rápidos e forneciam bons diagnósticos para o programador (muitas vezes um estudante). Os exemplos incluem Watfor, Watfiv, PUFFT e, em menor escala, FORGO, Wits Fortran e Kingston Fortran 2.

Fortran 5 foi comercializado pela Data General Corp no final dos anos 1970 e início dos anos 1980, para a linha de computadores Nova, Eclipse e MV. Ele tinha um compilador otimizador bastante bom para os minicomputadores de sua época. A linguagem mais se assemelha ao FORTRAN 66.

FORTRAN V foi distribuído pela Control Data Corporation em 1968 para a série CDC 6600. A linguagem foi baseada em FORTRAN IV.

A Univac também ofereceu um compilador para a série 1100 conhecido como FORTRAN V. Um derivado do Univac Fortran V foi o Athena FORTRAN.

Variantes específicas produzidas pelos fornecedores de computadores científicos de alto desempenho (por exemplo, Burroughs, Control Data Corporation (CDC), Cray, Honeywell, IBM, Texas Instruments e UNIVAC) adicionaram extensões ao Fortran para aproveitar recursos especiais de hardware, como cache de instruções, pipelines de CPU e matrizes de vetores. Por exemplo, um dos compiladores FORTRAN da IBM (H Extended IUP) tinha um nível de otimização que reordenou as instruções do código de máquina para manter várias unidades aritméticas internas ocupadas simultaneamente. Outro exemplo é o CFD, uma variante especial do FORTRAN projetada especificamente para o supercomputador ILLIAC IV, executado no Ames Research Center da NASA. O IBM Research Labs também desenvolveu uma linguagem estendida baseada em FORTRAN chamada VECTRAN para processar vetores e matrizes.

Fortran orientado a objetos era uma extensão orientada a objetos do Fortran, na qual os itens de dados podem ser agrupados em objetos, que podem ser instanciados e executados em paralelo. Estava disponível para Sun, Iris, iPSC e nCUBE, mas não é mais compatível.

Essas extensões específicas da máquina desapareceram com o tempo ou tiveram elementos incorporados aos principais padrões. A principal extensão remanescente é o OpenMP, que é uma extensão de plataforma cruzada para programação de memória compartilhada. Uma nova extensão, Coarray Fortran, destina-se a oferecer suporte à programação paralela.

FOR TRANSIT era o nome de uma versão reduzida da linguagem IBM 704 FORTRAN, que foi implementado para o IBM 650, usando um programa tradutor desenvolvido na Carnegie no final dos anos 1950. O seguinte comentário aparece no IBM Reference Manual (FOR TRANSIT Automatic Coding System C28-4038, Copyright 1957, 1959 da IBM):

O sistema FORTRAN foi projetado para uma máquina mais complexa do que a 650, e consequentemente algumas das 32 declarações encontradas no Manual de Referência do Programador FORTRAN não são aceitáveis ao sistema FORTRAN. Além disso, foram adicionadas algumas restrições à linguagem FORTRAN. No entanto, nenhuma dessas restrições faz um programa fonte escrito para FOR TRANSIT incompatível com o sistema FORTRAN para o 704.

As declarações permitidas eram:

• Declarações de atribuição aritmética, por exemplo, a = b
• GO to n
• GO TO (n1, n2,..., nm), i
• IF (a) n1, n2, n3
• PAUSE
• STOP
• DO n i = m1, m2
• CONTINUE
• END
• READ n, list
• PUNCH n, list
• DIMENSION V, V, V,...
• EQUIVALENCE (a,b,c), (d,c),...

Até dez sub-rotinas podem ser usadas em um programa.

As instruções FOR TRANSIT foram limitadas apenas às colunas 7 a 56. Cartões perfurados foram usados para entrada e saída no IBM 650. Três passes foram necessários para traduzir o código-fonte para o "IT" linguagem, em seguida, para compilar as instruções de TI em linguagem de montagem SOAP e, finalmente, para produzir o programa objeto, que pode ser carregado na máquina para executar o programa (usando cartões perfurados para entrada de dados e saída de resultados em cartões perfurados).

Existiam duas versões para os 650s com um tambor de memória de 2000 palavras: FOR TRANSIT I (S) e FOR TRANSIT II, esta última para máquinas equipadas com registradores de indexação e aritmética decimal automática de ponto flutuante (biquinaria). O Apêndice A do manual inclui diagramas de fiação para o painel de controle do leitor de cartão/perfurador IBM 533.

Linguagens baseadas em Fortran

Antes do FORTRAN 77, vários pré-processadores eram comumente usados para fornecer uma linguagem mais amigável, com a vantagem de que o código pré-processado poderia ser compilado em qualquer máquina com um compilador FORTRAN padrão. Esses pré-processadores normalmente suportam programação estruturada, nomes de variáveis com mais de seis caracteres, tipos de dados adicionais, compilação condicional e até recursos de macro. Os pré-processadores populares incluíam EFL, FLECS, iftran, MORTRAN, SFtran, S-Fortran, Ratfor e Ratfiv. Ratfor e Ratfiv, por exemplo, implementaram uma linguagem semelhante a C, gerando código pré-processado no padrão FORTRAN 66. Apesar dos avanços na linguagem Fortran, os pré-processadores continuam a ser usados para compilação condicional e substituição de macro.

Uma das primeiras versões do FORTRAN, introduzida nos anos 60, era popularmente usada em faculdades e universidades. Desenvolvido, apoiado e distribuído pela Universidade de Waterloo, o WATFOR foi amplamente baseado no FORTRAN IV. Um aluno usando o WATFOR poderia enviar seu trabalho FORTRAN em lote e, se não houvesse erros de sintaxe, o programa iria direto para a execução. Essa simplificação permitiu que os alunos se concentrassem na sintaxe e na semântica de seus programas ou no fluxo lógico de execução, em vez de lidar com a linguagem de controle de tarefas de envio (JCL), o(s) processo(s) sucessivo(s) de compilação/edição de link/execução ou outros complexidades do ambiente mainframe/minicomputador. Uma desvantagem desse ambiente simplificado era que WATFOR não era uma boa escolha para programadores que precisavam das habilidades expandidas de seus processadores host, por exemplo, WATFOR normalmente tinha acesso muito limitado a dispositivos de E/S. WATFOR foi sucedido por WATFIV e suas versões posteriores.

programa; S= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =0 Eu...= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =1,n; S= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =S+1; Pare! Eu...; S= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =' ' Pára!

(programação de linha)

LRLTRAN foi desenvolvido no Lawrence Radiation Laboratory para fornecer suporte para aritmética vetorial e armazenamento dinâmico, entre outras extensões para apoiar a programação de sistemas. A distribuição incluiu o sistema operacional LTSS.

O padrão Fortran-95 inclui uma Parte 3 opcional que define uma capacidade opcional de compilação condicional. Esse recurso geralmente é chamado de "CoCo".

Muitos compiladores Fortran integraram subconjuntos do pré-processador C em seus sistemas.

SIMSCRIPT é um pré-processador Fortran específico para modelagem e simulação de grandes sistemas discretos.

A linguagem de programação F foi projetada para ser um subconjunto limpo do Fortran 95 que tentou remover os recursos redundantes, não estruturados e obsoletos do Fortran, como o EQUIVALÊNCIA declaração. F retém os recursos de array adicionados no Fortran 90 e remove as instruções de controle que se tornaram obsoletas por construções de programação estruturadas adicionadas ao FORTRAN 77 e ao Fortran 90. F é descrito por seus criadores como "uma linguagem de programação de array compilada e estruturada especialmente adequado para educação e computação científica". Essencial Lahey Fortran 90 (ELF90) foi um subconjunto semelhante.

Lahey e Fujitsu se uniram para criar o Fortran para o Microsoft.NET Framework. Silverfrost FTN95 também é capaz de criar código.NET.

Exemplos de código

O programa a seguir ilustra a alocação dinâmica de memória e operações baseadas em array, dois recursos introduzidos com Fortran 90. Particularmente notável é a ausência de DO e SE/ENTÃO na manipulação do array; operações matemáticas são aplicadas ao array como um todo. Também é aparente o uso de nomes de variáveis descritivos e formatação de código geral que se conforma com o estilo de programação contemporâneo. Este exemplo calcula uma média sobre os dados inseridos interativamente.

programa média ! Leia em alguns números e tome a média ! Como escrito, se não houver pontos de dados, uma média de zero é retornada ! Enquanto isso pode não ser comportamento desejado, ele mantém este exemplo simples implícito nenhum real, dimensão(:) alocatório : pontos Intérprete : número_de_pontos real : média_pontos, positivo_média, negativo_average média_pontos = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 0,0 positivo_média = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 0,0 negativo_average = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 0,0 escrever (*,*) "Input number of points to average:" ler (*,*) número_de_pontos alocar (pontos(número_de_pontos) escrever (*,*) "Entre os pontos em média:" ler (*,*) pontos ! Pegue a média somando pontos e dividindo por number_of_points se (número_de_pontos > 0) média_pontos = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = soma(pontos) / número_de_pontos ! Agora formar média sobre pontos positivos e negativos apenas se (contagem(pontos > 0.) > 0) positivo_média = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = soma(pontos, pontos > 0.) / contagem(pontos > 0.) se (contagem(pontos < 0.) > 0) negativo_average = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = soma(pontos, pontos < 0.) / contagem(pontos < 0.) ! Resultado da impressão para a unidade terminal de stdout 6 escrever (*,(a,g12.4) ') A média, média_pontos escrever (*,(a,g12.4) ') • Média dos pontos positivos =, positivo_média escrever (*,(a,g12.4) ') Média de pontos negativos =, negativo_average Lugar de origem: China (pontos) ! memória livreprograma final média

Humor

Durante a mesma reunião do comitê de padrões FORTRAN em que o nome "FORTRAN 77" foi escolhido, uma proposta técnica satírica foi incorporada à distribuição oficial com o título "Carta O Considerada Prejudicial". Esta proposta pretendia resolver a confusão que às vezes surge entre a letra "O" e o numeral zero, eliminando a letra dos nomes de variáveis permitidos. No entanto, o método proposto era eliminar totalmente a letra do conjunto de caracteres (retendo assim 48 como o número de caracteres lexicais, que os dois pontos haviam aumentado para 49). Isso foi considerado benéfico na medida em que promoveria a programação estruturada, impossibilitando o uso do notório GO TO como antes. (Declarações FORMAT problemáticas também seriam eliminadas.) observou-se que isso "pode invalidar alguns programas existentes" mas que a maioria deles "provavelmente não estava em conformidade, de qualquer maneira".

Quando X3J3 debateu se a contagem mínima de viagem para um loop DO deveria ser zero ou um em Fortran 77, Loren Meissner sugeriu uma contagem mínima de viagem de dois - raciocinando (irônico) que se fosse menor que dois, não haveria razão para um loop!

Quando as matrizes de comprimento presumido estavam sendo adicionadas, havia uma disputa quanto ao caractere apropriado para separar os limites superior e inferior. Em um comentário examinando esses argumentos, o Dr. Walt Brainerd escreveu um artigo intitulado "Astronomy vs. Gastroenterology" porque alguns proponentes sugeriram usar a estrela ou asterisco ("*"), enquanto outros favoreciam os dois pontos (":").

Os nomes de variáveis que começam com as letras I–N têm um tipo padrão de número inteiro, enquanto as variáveis que começam com quaisquer outras letras são padronizadas como real, embora os programadores possam substituir os padrões com uma declaração explícita. Isso levou à piada: "Em FORTRAN, GOD é REAL (a menos que seja declarado INTEGER)."